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