ThePEG/MatrixElement/Amplitude.h

0001 // -*- C++ -*-
0002 //
0003 // Amplitude.h is a part of ThePEG - Toolkit for HEP Event Generation
0004 // Copyright (C) 1999-2019 Leif Lonnblad
0005 //
0006 // ThePEG is licenced under version 3 of the GPL, see COPYING for details.
0007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
0008 //
0009 #ifndef ThePEG_Amplitude_H
0010 #define ThePEG_Amplitude_H
0011 // This is the declaration of the Amplitude class.
0012
0013
0014 #include "ThePEG/Handlers/HandlerBase.h"
0015 #include "ThePEG/PDT/ParticleData.h"
0016 #include "ThePEG/EventRecord/Particle.h"
0017
0018 namespace ThePEG {
0019
0020 /**
0021  * The Amplitude class is the abstract base class for all the classes
0022  * representing complex amplitudes associated with either a hard
0023  * 2\f$\rightarrow\f$ N subprocess or a decay 1\f$\rightarrow\f$ N
0024  * process.  The returned value should be dimensionless suitable
0025  * scaled by the total invariant mass squared (shat), which is always
0026  * computable from the specified momenta of the particles in the
0027  * vertex.  Notice that the amplitude for splitting
0028  * 1\f$\rightarrow\f$ N processes is instead represented in other
0029  * classes (derived from the SplitFun class).
0030  *
0031  * @see \ref AmplitudeInterfaces "The interfaces"
0032  * defined for Amplitude.
0033  */
0034 class Amplitude: public HandlerBase {
0035
0036   /** @name Main virtual functions to be overridden by sub-classes. */
0037   //@{
0038   /**
0039    * Return the amplitude. Given the ParticleData objects in \a
0040    * particles, their \a momenta and \a helicities of all the
0041    * particles in the vertex, return the complex amplitude.  The
0042    * convention is the order of the vectors is that first there is the
0043    * incoming particle(s) and then the outgoing ones.  For the
0044    * helicities, the convention is to number them starting from 0 (no
0045    * negative values, because they are used as vector indeces), for
0046    * example, for a massive particle of spin S, 0 <= helicity <= 2*S.
0047    * The returned value should be dimensionless suitable scaled by the
0048    * total invariant mass squared (\f$\hat{s}\f$), which is always
0049    * computable from the specified \a momenta of the particles in the
0050    * vertex.
0051    */
0052   virtual Complex value(const tcPDVector & particles,
0053             const vector<Lorentz5Momentum> & momenta,
0054             const vector<int> & helicities) = 0;
0055
0056   /**
0057    * Return an overestimated amplitude. Same as value(const tcPDVector
0058    * &, const vector<Lorentz5Momentum> &, const vector<int> &), but it
0059    * provides an overestimate of the complex amplitude, that is:
0060    * <code>abs( overestimaValue() ) >= abs(value()) </code> The
0061    * default definition just returns value(), but it can be overriden
0062    * by derived classes.
0063    */
0064   virtual Complex overestimateValue(const tcPDVector & particles,
0065                     const vector<Lorentz5Momentum> & momenta,
0066                     const vector<int> & helicities);
0067   //@}
0068
0069   /** @name Alternative interface to main virtual functions. */
0070   //@{
0071   /**
0072    * Return the amplitude. Calls value(const tcPDVector &, const
0073    * vector<Lorentz5Momentum> &, const vector<int> &) and should not
0074    * be overridden.
0075    */
0076
0077   Complex value(const PVector & particles, const vector<int> & helicities);
0078
0079   /**
0080    * Return an overestimated amplitude. Calls overestimateValue(const
0081    * tcPDVector &, const vector<Lorentz5Momentum> &, const vector<int>
0082    * &)
0083    */
0084   Complex overestimateValue(const PVector & particles,
0085                 const vector<int> & helicities);
0086   //@}
0087
0088 public:
0089
0090   /**
0091    * Standard Init function used to initialize the interfaces.
0092    */
0093   static void Init();
0094
0095   /**
0096    * Describe an abstract base class with persistent data.
0097    */
0098   static AbstractNoPIOClassDescription<Amplitude> initAmplitude;
0099
0100   /**
0101    *  Private and non-existent assignment operator.
0102    */
0103   Amplitude & operator=(const Amplitude &) = delete;
0104
0105 };
0106
0107 }
0108
0109
0110 namespace ThePEG {
0111
0112 /** @cond TRAITSPECIALIZATIONS */
0113
0114 /**
0115  * This template specialization informs ThePEG about the
0116  * base class of Amplitude.
0117  */
0118 template <>
0119 struct BaseClassTrait<Amplitude,1>: public ClassTraitsType {
0120   /** Typedef of the base class of Amplitude. */
0121   typedef HandlerBase NthBase;
0122 };
0123
0124 /**
0125  * This template specialization informs ThePEG about the name of the
0126  * Amplitude class.
0127  */
0128 template <>
0129 struct ClassTraits<Amplitude>: public ClassTraitsBase<Amplitude> {
0130   /** Return the class name. */
0131   static string className() { return "ThePEG::Amplitude"; }
0132 };
0133
0134 /** @endcond */
0135
0136 }
0137
0138 #endif /* ThePEG_Amplitude_H */