Vertex.h

Go to the documentation of this file.

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


#define DECLARE_VERTEX(NAME)                                                                                                                                   \
  struct NAME : public Base {                                                                                                                                  \
    NAME() { DEBUG("Constructing vertex"); }                                                                                                                   \
    virtual Tensor operator()(const Tensor &P, const Tensor &Q, const Tensor &V1, const Tensor &V2, DebugSymbols *db = 0) override;                            \
    static std::string _id;                                                                                                                                    \
  }
 
#define DEFINE_VERTEX(VERTEX)                                                                                                                                  \
  REGISTER_WITH_KEY(Vertex::Base, Vertex::VERTEX, #VERTEX, std::string);                                                                                       \
  Tensor Vertex::VERTEX::operator()(const Tensor &P, const Tensor &Q, const Tensor &V1, const Tensor &V2, DebugSymbols *db)
 
namespace AmpGen {
  namespace Vertex {
    struct Base {
      virtual AmpGen::Tensor
      operator()(const AmpGen::Tensor &P, const AmpGen::Tensor &Q, const AmpGen::Tensor &V1, const AmpGen::Tensor &V2, AmpGen::DebugSymbols *db = nullptr)
        = 0;
 
      virtual ~Base() = default;
      Base *create() { return this; }
    };

    DECLARE_VERTEX(S_SS_S);

    DECLARE_VERTEX(S_VV_S);

    DECLARE_VERTEX(S_VV_S1);

    DECLARE_VERTEX(S_VV_P);

    DECLARE_VERTEX(S_VV_D);

    DECLARE_VERTEX(S_VS_P);

    DECLARE_VERTEX(S_TV_P);

    DECLARE_VERTEX(S_TV_D);

    DECLARE_VERTEX(S_TS_D);

    DECLARE_VERTEX(S_TT_S);

    DECLARE_VERTEX(V_SS_P);
 
    DECLARE_VERTEX(V_VS_P);

    DECLARE_VERTEX(V_VS_S);
    DECLARE_VERTEX(V_VS_D);
    DECLARE_VERTEX(V_TS_P);
    DECLARE_VERTEX(V_TS_D);
 
    DECLARE_VERTEX(V_VV_P);
    DECLARE_VERTEX(V_VV_P1);
    DECLARE_VERTEX(V_VV_P2);
    DECLARE_VERTEX(V_VV_S);
 
    DECLARE_VERTEX(T_VS_D);
    DECLARE_VERTEX(T_VS_P);
    DECLARE_VERTEX(T_SS_D);
    DECLARE_VERTEX(T_TS_D);
    DECLARE_VERTEX(T_TS_S);
 
    DECLARE_VERTEX(f_fS_S);
    DECLARE_VERTEX(f_fS_S1);
    DECLARE_VERTEX(f_fS_P);
    DECLARE_VERTEX(f_fS_P1);
 
    DECLARE_VERTEX(f_Vf_S);
    DECLARE_VERTEX(f_Vf_S1);
    DECLARE_VERTEX(f_Vf_P);
    DECLARE_VERTEX(f_Vf_P1);
    DECLARE_VERTEX(f_Vf_P2);
    DECLARE_VERTEX(f_Vf_P3);
 
    DECLARE_VERTEX(f_fS_SL);
    DECLARE_VERTEX(f_fS_SR);
 
    DECLARE_VERTEX(f_Vf_SL);
    DECLARE_VERTEX(f_Vf_SR);
 
    DECLARE_VERTEX(f_Vf_D);
    DECLARE_VERTEX(f_Vf_D1);
 
    DECLARE_VERTEX(f_Tf_P);
 
    DECLARE_VERTEX(r_fS_P);
    DECLARE_VERTEX(r_fS_D);
    DECLARE_VERTEX(f_rS_P);
    DECLARE_VERTEX(f_rS_D);
    DECLARE_VERTEX(f_rS_P1);
 
    DECLARE_VERTEX(F_FS_S);
    DECLARE_VERTEX(F_FS_S1);
    DECLARE_VERTEX(F_FS_P);
    DECLARE_VERTEX(F_FS_P1);
 
    DECLARE_VERTEX(F_VF_S);
    DECLARE_VERTEX(F_VF_S1);
    DECLARE_VERTEX(F_VF_P);
    DECLARE_VERTEX(F_VF_P1);
    DECLARE_VERTEX(F_VF_P2);
    DECLARE_VERTEX(F_VF_P3);
 
    DECLARE_VERTEX(F_FS_SL);
    DECLARE_VERTEX(F_FS_SR);
 
    DECLARE_VERTEX(F_VF_SL);
    DECLARE_VERTEX(F_VF_SR);
 
    DECLARE_VERTEX(F_VF_D);
    DECLARE_VERTEX(F_VF_D1);
 
    DECLARE_VERTEX(F_TF_P);
 
    DECLARE_VERTEX(R_FS_P);
    DECLARE_VERTEX(R_FS_D);
    DECLARE_VERTEX(F_RS_P);
    DECLARE_VERTEX(F_RS_D);
    DECLARE_VERTEX(F_RS_P1);
 
    DECLARE_VERTEX(S_fF_S);
    DECLARE_VERTEX(S_fF_S1);
    DECLARE_VERTEX(V_fF_S);
    DECLARE_VERTEX(V_fF_S1);
    DECLARE_VERTEX(V_fF_PL);
    DECLARE_VERTEX(V_fF_PR);
 
    DECLARE_VERTEX(S_VV_rp);
    DECLARE_VERTEX(S_VV_rm);
    DECLARE_VERTEX(S_TV_rp);
    DECLARE_VERTEX(S_TV_rm);
 
    class Factory : public AmpGen::Factory<Vertex::Base> {
    public:
      static Tensor getSpinFactor(const Tensor &P, const Tensor &Q, const Tensor &V1, const Tensor &V2, const std::string &name, DebugSymbols *db = nullptr);
      static Tensor getSpinFactorNBody(const std::vector<std::pair<Tensor, Tensor>> &tensors, const unsigned int &mL, DebugSymbols *db = nullptr);
      static bool isVertex(const std::string &hash);
    };
  } // namespace Vertex

  Tensor Orbital_PWave(const Tensor &p, const Tensor &q);

  Tensor Orbital_DWave(const Tensor &p, const Tensor &q);

  Tensor Spin1Projector(const Tensor &p);

  Tensor Spin2Projector(const Tensor &p);

  Tensor Spin1hProjector(const Tensor &B);
  Tensor Spin3hProjector(const Tensor &A);
  Tensor Spin1hbProjector(const Tensor &B);
  Tensor Spin3hbProjector(const Tensor &A);
 
  Tensor gamma_twiddle(const Tensor &P);
  Tensor Gamma4Vec();
  Tensor Bar(const Tensor &P);
  Tensor slash(const Tensor &P);
} // namespace AmpGen
#endif