Line data    Source code

       1             : /*******************************************************************************
       2             :  * Project: BaBar detector at the SLAC PEP-II B-factory
       3             :  * Package: EvtGenBase
       4             :  *    File: $Id: EvtAmplitudeSum.hh,v 1.2 2009-03-16 16:42:46 robbep Exp $
       5             :  *  Author: Alexei Dvoretskii, dvoretsk@slac.stanford.edu, 2001-2002
       6             :  *
       7             :  * Copyright (C) 2002 Caltech
       8             :  *******************************************************************************/
       9             : 
      10             : #ifndef EVT_AMPLITUDE_SUM_HH
      11             : #define EVT_AMPLITUDE_SUM_HH
      12             : 
      13             : #include <stdio.h>
      14             : #include <assert.h>
      15             : #include <vector>
      16             : #include "EvtGenBase/EvtAmplitude.hh"
      17             : 
      18             : template <class T>
      19             : class EvtAmplitudeSum : public EvtAmplitude<T> {
      20             :   
      21             : public:
      22             :   
      23           0 :   EvtAmplitudeSum() {}
      24           0 :   EvtAmplitudeSum(const EvtAmplitudeSum<T>& other)
      25           0 :     : EvtAmplitude<T>(other)
      26           0 :   {
      27             :     int i;
      28           0 :     for(i=0;i<other.nTerms();i++) {
      29             :       
      30           0 :       EvtComplex c = other.c(i);      
      31           0 :       _c.push_back(c);
      32           0 :       EvtAmplitude<T>* amp = other.getTerm(i);
      33           0 :       assert(amp);
      34           0 :       EvtAmplitude<T>* amp1 = amp->clone();
      35           0 :       assert(amp1);
      36           0 :       _term.push_back(amp1);
      37           0 :     }
      38           0 :   }
      39             :   
      40             :   virtual ~EvtAmplitudeSum()
      41           0 :   {
      42           0 :     for(size_t i=0;i<_term.size();i++) {
      43             :       
      44           0 :       delete _term[i];
      45             :     }
      46           0 :   }  
      47             :   
      48             :   virtual EvtAmplitude<T>* clone() const
      49             :   {
      50           0 :     return new EvtAmplitudeSum<T>(*this);
      51           0 :   }
      52             :   
      53             :   
      54             :   void addTerm(EvtComplex c,const EvtAmplitude<T>& amp)
      55             :   {
      56             :     _c.push_back(c);
      57             :     _term.push_back(amp.clone());
      58             :   }
      59             :   
      60             :   void addOwnedTerm(EvtComplex c, EvtAmplitude<T>* amp)
      61             :   {
      62           0 :     assert(amp);
      63           0 :     _c.push_back(c);
      64           0 :     _term.push_back(amp);
      65           0 :   }
      66             :   
      67           0 :   int nTerms() const { return _term.size(); }  // number of terms
      68             : 
      69             :   void print() const {
      70             : 
      71             :     int N = nTerms();
      72             :     printf("Amplitude has %d terms\n",N);
      73             :     int i;
      74             :     for(i=0;i<N;i++) {
      75             :       printf("c%d = (%f,%f)\n",i,real(_c[i]),imag(_c[i]));
      76             :       assert(_term[i]);
      77             :     }
      78             :   }
      79             : 
      80             : 
      81           0 :   inline EvtComplex   c(int i) const { return _c[i]; }
      82           0 :   inline EvtAmplitude<T>*  getTerm(int i) const { return _term[i]; }
      83             : 
      84             : protected:
      85             : 
      86             :   virtual EvtComplex amplitude(const T& p) const
      87             :   {
      88           0 :     if(_term.size() == 0) 
      89           0 :       printf("Warning: amplitude sum has zero terms\n");
      90             :     
      91           0 :     EvtComplex value = 0.;
      92             : 
      93           0 :     for(size_t i=0;i<_term.size();i++) {    
      94           0 :       value+=_c[i]*_term[i]->evaluate(p);    
      95             :     }    
      96           0 :     return value;
      97             :   }
      98             : 
      99             : private:
     100             :   
     101             :   std::vector<EvtComplex> _c;              // coefficients
     102             :   std::vector<EvtAmplitude<T>*> _term;  // pointers to amplitudes
     103             : }; 
     104             : 
     105             : 
     106             : #endif
     107             : 
     108             :