Lineshapes.h

Go to the documentation of this file.

#ifndef AMPGEN_LINESHAPES_H
#define AMPGEN_LINESHAPES_H
 
#include <map>
#include <string>
#include <utility>
#include <vector>
 
#include "AmpGen/Expression.h"
#include "AmpGen/Factory.h"
#include "AmpGen/MsgService.h"
#include "AmpGen/Tensor.h"
#include "AmpGen/Particle.h"

 
#define DECLARE_LINESHAPE( X )                                                                                  \
  class X : public AmpGen::Lineshape::Base {                                                                    \
    static std::string _id;                                                                                     \
    public:                                                                                                     \
    X(){ DEBUG("Constructing lineshape") ;}                                                                     \
    AmpGen::Expression get(const AmpGen::Expression& s, const AmpGen::Expression& s1,                           \
                                   const AmpGen::Expression& s2, const std::string& particleName,               \
                                   const unsigned int& L, const std::string& lineshapeModifier,                 \
                                   AmpGen::DebugSymbols* dbexpressions = 0) const override;                     \
    AmpGen::Expression get(const AmpGen::Particle& p,                                                           \
                           const std::string& lineshapeModifier,                                                \
                           AmpGen::DebugSymbols* dbexpressions = nullptr ) const override;                      \
  }
 
#define DEFINE_LINESHAPE( X )                                                                                   \
  REGISTER_WITH_KEY( Lineshape::Base, Lineshape::X, #X, std::string );                                          \
  AmpGen::Expression Lineshape::X::get( const AmpGen::Particle& p,                                              \
                                        const std::string& lineshapeModifier,                                   \
                                        AmpGen::DebugSymbols* dbexpressions ) const { return                    \
                                           get(p.massSq(), p.daughter(0)->massSq(), p.daughter(1)->massSq(),    \
                                           p.name(), p.L(), lineshapeModifier, dbexpressions) ;}                \
  AmpGen::Expression Lineshape::X::get( const AmpGen::Expression& s, const AmpGen::Expression& s1,              \
                                        const AmpGen::Expression& s2, const std::string& particleName,          \
                                        const unsigned int& L, const std::string& lineshapeModifier,            \
                                        AmpGen::DebugSymbols* dbexpressions ) const
 
#define DEFINE_GENERIC_SHAPE( X )                                                                               \
  REGISTER_WITH_KEY( Lineshape::Base, Lineshape::X, #X, std::string );                                          \
  AmpGen::Expression Lineshape::X::get( const AmpGen::Expression& s, const AmpGen::Expression& s1,              \
                                        const AmpGen::Expression& s2, const std::string& particleName,          \
                                        const unsigned int& L, const std::string& lineshapeModifier,            \
                                        AmpGen::DebugSymbols* dbexpressions ) const { return 0;}                \
  AmpGen::Expression Lineshape::X::get( const AmpGen::Particle& p,                                              \
                                        const std::string& lineshapeModifier,                                   \
                                        AmpGen::DebugSymbols* dbexpressions ) const 
 
namespace AmpGen
{
  class Particle; // forward definitions

 
  namespace Lineshape
  {
    class  Base {
      public:
      virtual ~Base() = default;
      virtual Expression get( const Expression& s, const Expression& s1, const Expression& s2,
                              const std::string& particleName, const unsigned& L,
                              const std::string& lineshapeModifier, DebugSymbols* dbexpressions = nullptr ) const = 0;
      virtual Expression get( const AmpGen::Particle& p, 
                              const std::string& lineshapeModifier,
                              AmpGen::DebugSymbols* dbexpressions = nullptr ) const = 0; 
      Base* create() { return this; }
    };
 
    class Factory : public AmpGen::Factory<Lineshape::Base>
    {
    public:
      static Expression get(const std::string& lineshape, const Expression& s, const Expression& s1,
                            const Expression& s2, const std::string& particleName, const unsigned& L,
                            std::vector<std::pair<std::string, Expression>>* dbexpressions = nullptr );
      static Expression get(const std::string& lineshape,
                            const Particle& p,
                            AmpGen::DebugSymbols* dbexpressions );
      static bool isLineshape( const std::string& lineshape );
    };
    
    DECLARE_LINESHAPE( None );
    
    DECLARE_LINESHAPE( BW );
 
    DECLARE_LINESHAPE( SBW );
      
    DECLARE_LINESHAPE( NonRelBW );

    DECLARE_LINESHAPE( GounarisSakurai );
  
    DECLARE_LINESHAPE( LASS );  
    DECLARE_LINESHAPE(GLASS);

    DECLARE_LINESHAPE( Flatte );
    DECLARE_LINESHAPE( Bugg );
    DECLARE_LINESHAPE( Isotensor );

    DECLARE_LINESHAPE( ExpFF );
 
    DECLARE_LINESHAPE( FormFactor );

    DECLARE_LINESHAPE( Gaussian );

    DECLARE_LINESHAPE( PolyNR );
    
    DECLARE_LINESHAPE( Poly );

     DECLARE_LINESHAPE( FOCUS );

    DECLARE_LINESHAPE( PALANO );

    DECLARE_LINESHAPE( kMatrixSimple );
    
    DECLARE_LINESHAPE( MIPWA );

    DECLARE_LINESHAPE( GSpline );
    DECLARE_LINESHAPE( FormFactorSpline );
    DECLARE_LINESHAPE( DecaySpline );
    DECLARE_LINESHAPE( InelasticSpline );

    DECLARE_LINESHAPE(GenericKmatrix);
   
    DECLARE_LINESHAPE( EtaDalitz );

    DECLARE_LINESHAPE( TD );
 
    DECLARE_LINESHAPE( Photon );
  } // namespace Lineshape
  
  Expression Q2( const Expression& Msq, const Expression& M1sq, const Expression& M2sq );
 
  Expression kFactor( const Expression& mass, const Expression& width,
                      std::vector<std::pair<std::string, Expression>>* dbexpressions = nullptr );
  Expression BlattWeisskopf_Norm( const Expression& z, const Expression& z0, unsigned int L );
 
  Expression BL( const Expression& s, const Expression& s0, const Expression& s1, const Expression& s2,
                 const Expression& radius, const unsigned int& L );
 
  Expression BlattWeisskopf( const Expression& z, unsigned int L );
 
  Expression pol( const AmpGen::Expression& X, const std::vector<Expression>& p );
 
  std::vector<Expression> parameterVector(const std::string& name, const size_t& nParam);
 
  Expression width( const Expression& s, const Expression& s1, const Expression& s2, const Expression& mass,
                    const Expression& width, const Expression& radius, unsigned int L,
                    DebugSymbols* dbexpressions = nullptr );
} // namespace AmpGen
#endif