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