AMEGIC%2B%2B/Amplitude/Single_Amplitude_Base.H

0001 #ifndef AMEGIC_Amplitude_Single_Amplitude_Base_H
0002 #define AMEGIC_Amplitude_Single_Amplitude_Base_H
0003
0004 #include "AMEGIC++/Amplitude/Amplitude_Base.H"
0005 #include "ATOOLS/Math/Kabbala.H"
0006
0007 namespace AMEGIC {
0008
0009   class Argument;
0010
0011   class Single_Amplitude_Base: public virtual Amplitude_Base {
0012   protected:
0013     int amplnumber;
0014
0015     Zfunc_List *zlist;
0016     Pfunc_List plist;
0017     int * b;
0018     int   N;
0019
0020     String_Handler     * shand;
0021     Basic_Sfuncs       * BS;
0022     ATOOLS::Flavour * fl;
0023
0024     virtual ATOOLS::Kabbala SingleZvalue(Zfunc*,std::vector<int>*,std::vector<int>*,int last=0);
0025     ATOOLS::Kabbala SingleZGroupvalue(Zfunc* z, std::vector<int>* iz, std::vector<int>* iargs,int last=0);
0026     ATOOLS::Kabbala SingleZvalueTensor(Zfunc* z,std::vector<int>* iz, std::vector<int>* iargs,int);
0027     int     FillArgs(Zfunc* z,int* args,std::vector<int>*,std::vector<int>*);
0028     void    SetLoopVar(std::vector<int>&,std::vector<std::vector<int> >&);
0029
0030     ATOOLS::Kabbala SingleMassTerms(int iz,int iarg);
0031     ATOOLS::Flavour* GetPflav(int pn);
0032     ATOOLS::Kabbala GetProp(Zfunc* z);
0033     void    GroupZfuncs();
0034   public:
0035     int sign;
0036     std::vector<int> m_order;
0037     Single_Amplitude_Base(int*,int,Basic_Sfuncs*,ATOOLS::Flavour* ,String_Handler*);
0038     Single_Amplitude_Base(String_Handler*,int);
0039     virtual ~Single_Amplitude_Base();
0040
0041     Complex Zvalue(int);
0042     Complex Zvalue(int,int*);
0043     Complex Zvalue(String_Handler * sh,int ihel);
0044
0045     Zfunc_List* GetZlist();
0046     Pfunc_List* GetPlist();
0047     int GetSign();
0048     void SetSign(int);
0049
0050     void ClearCalcList();
0051     void KillZList();
0052     void PrintGraph();
0053     void SetNumber(int& i);
0054     Amplitude_Base* GetAmplitude(const int n);
0055     int GetNumber() { return amplnumber; }
0056
0057     void DefineOrder(const std::vector<int> &o);
0058     const std::vector<int> &GetOrder();
0059
0060   };
0061
0062   /*!
0063     \class Single_Amplitude_Base
0064     \brief Numerical calculation and string generation for one amplitude.
0065
0066     The numerical calculation and string generation for a Single_Amplitude as well as
0067     for a Super_Amplitude is performed in this class.
0068
0069
0070   */
0071   /*!
0072     \var Zfunc_List Single_Amplitude_Base::zlist
0073     A list of Z functions in the amplitude; Calling
0074     Single_Amplitude_Base::GroupZfuncs transforms it into a Zfunc_Group,
0075     that recursivley contains all original Z functions.
0076   */
0077   /*!
0078     \var Pfunc_List Single_Amplitude_Base::plist
0079     A list of all propagators in the amplitude.
0080   */
0081   /*!
0082     \fn ATOOLS::Kabbala Single_Amplitude_Base::SingleZvalue(Zfunc* z,std::vector<int>* iz,std::vector<int>* iargs,int last=0)
0083     Calculates the Z function z.
0084
0085     The vector iz contains a list of labels for propagators or external particles,
0086     while iargs is a list of corresponding helicity/polarization states.
0087
0088     When SingleZvalue is first called from Single_Amplitude_Base::Zvalue, iz is
0089     just a list 0,1,2,...,n with n the number of external particles.
0090
0091     This method may be also called recursively from Single_Amplitude_Base::SingleZGroupvalue
0092     or Single_Amplitude_Base::SingleZvalueTensor.
0093
0094     - Single_Amplitude_Base::FillArgs generates the argument array for the
0095     calculator of the Zfunc (Zfunc_Calc).
0096     - In the case, the calculated process has external spin-2 particles,
0097     Single_Amplitude_Base::FillArgs returns their position in iz. The corresponding
0098     dummy polarization modes (see class mt) in iargs will be replaced
0099     in Single_Amplitude_Base::SingleZvalueTensor by sums of outer products
0100     of two polarization vectors.
0101     - The Zfunc::m_calclist is checked, if the Z function was already calculated
0102     for the current set of arguments. If yes, the result will be returned directly.
0103     - Calculation:
0104       - If the Zfunc is not elementary, but a Zfunc_Group, it is calculated
0105       in Single_Amplitude_Base::SingleZGroupvalue.
0106       - For an elementary Zfunc its calculator (Zfunc_Calc* Zfunc::p_calculator)
0107       is started.
0108     - The result is saved in Zfunc::m_calclist and returned.
0109   */
0110   /*!
0111     \fn ATOOLS::Kabbala Single_Amplitude_Base::SingleZGroupvalue(Zfunc* z, std::vector<int>* iz, std::vector<int>* iargs,int last=0)
0112     Calculates a Zfunc_Group.
0113
0114     - For a group with the operator '+' it's simply the sum of all sub Z functions,
0115     calculated by Single_Amplitude_Base::SingleZvalue with the same set of arguments.
0116
0117     - For a group with the operator '*' the product of the two Z functions is calculated.
0118     Depending on the propagator connecting these functions also a sum over the
0119     helicity/polarization modes has to be performed in order to reproduce the
0120     propagator's Dirac/Lorentz structure. The list of corresponding arguments is determined
0121     in Single_Amplitude_Base::SetLoopVar.
0122   */
0123   /*!
0124     \fn ATOOLS::Kabbala Single_Amplitude_Base::SingleZvalueTensor(Zfunc* z,std::vector<int>* iz, std::vector<int>* iargs,int)
0125   */
0126   /*!
0127     \fn int Single_Amplitude_Base::FillArgs(Zfunc* z,int* args,std::vector<int>*,std::vector<int>*)
0128     Generates the argument array args for the calculator of the Zfunc (Zfunc_Calc).
0129
0130     For every element of Zfunc::p_arguments args contains a pair of elements:
0131     - external particles: number of the particle; helicity or polarization
0132     - boson propagators: propagator label; polarization (0 for scalars)
0133     - fermion propagators:
0134       - outer particle version: number of an external particle; helicity
0135       - inner particle version: propagator label; helicity
0136       - the spinor type is encoded in an extra \f$-\f$ sign in the arguments
0137   */
0138   /*!
0139     \fn void Single_Amplitude_Base::SetLoopVar(std::vector<int>& iz ,std::vector<std::vector<int> >& iarg)
0140     Determines a list of arguments for the decomposition of a propagator.
0141   */
0142   /*!
0143     \fn ATOOLS::Kabbala Single_Amplitude_Base::SingleMassTerms(int iz,int iarg)
0144     Calculates the mass term for the decomposition of fermionic propagators.
0145   */
0146   /*!
0147     \fn ATOOLS::Flavour* Single_Amplitude_Base::GetPflav(int pn)
0148     Returns the flavour of the propagator with label pn.
0149   */
0150   /*!
0151     \fn ATOOLS::Kabbala Single_Amplitude_Base::GetProp(Zfunc*)
0152     Returns the product of the propagators in the Zfunc.
0153     If the Zfunc is elementary only propagators with the flag Pfunc::on are
0154     returned. This avoids double countings.
0155    */
0156   /*!
0157    \fn void Single_Amplitude_Base::GroupZfuncs();
0158    Rearranges the the Z funtions of the amplitude from a linear list to
0159    a recursive structure of Zfunc_Group.
0160
0161    Within the helicity method an amplitude
0162    (helicities/polarizations of external particles are fixed) is a product of
0163    Z functions, with a sum over spinor/helicity or polarization modes of the
0164    propagator.
0165
0166    The procedure in this method corresponds to a factoring out in order
0167    to reduce the number of complex multiplications.
0168   */
0169   /*!
0170    \var int Single_Amplitude_Base::sign
0171    An overall sign for the amplitude.
0172   */
0173   /*!
0174     \fn Complex Single_Amplitude_Base::Zvalue(int,int*)
0175     Performs the calculation of an amplitude.
0176
0177     - If Single_Amplitude_Base::zlist contains more than one Zfunc,
0178     Single_Amplitude_Base::GroupZfuncs is called.
0179     - The remaining Zfunc in the list has only arguments of external particles
0180     and is calculated using Single_Amplitude_Base::SingleZvalue.
0181     - The result is multiplied with all propagator factors,
0182     that were factored out.
0183   */
0184   /*!
0185     \fn void Single_Amplitude_Base::ClearCalcList()
0186     Executes Zfunc::ClearCalcList() for all Z functions in the amplitude.
0187   */
0188  }
0189 #endif
0190
0191
0192
0193
0194
0195
0196
0197
0198
0199
0200
0201