MVgamma.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2014 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef MVGAMMA_H
#define MVGAMMA_H
 
class StandardModel;
class F_1;
class F_2;
class AmpDB2;
#include "ThObservable.h"
#include <gsl/gsl_integration.h>
#include <memory>
 
#define NFPOLARBASIS_MVGAMMA true
#define UNIFIEDBTOS true
#define FULLNLOQCDF_MVGAMMA false
 
class MVgamma {
public:
    MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
    
    virtual ~MVgamma();
    
    void updateParameters();
    
    std::vector<std::string> initializeMVgammaParameters();
    
    std::vector<std::string> parametersForMVgamma;
    
    double GF;            
    double ale;           
    double MM;            
    double MM2;           
    double MV;            
    double Mb;            
    double mb_pole;       
    double mc_pole;       
    double mu_b;          
    double mu_h;          
    double width;         
    double fperp;         
    double fpara;         
    double fB;            
    double Ms;            
    double MW;            
    gslpp::complex lambda_t;     
    gslpp::complex lambda_u;     
    gslpp::complex h[2];         
    double r1_1;
    double r1_2;
    double r2_1;
    double r2_2;
    double deltaC9_1;
    double deltaC9_2;
    gslpp::complex exp_Phase_1;
    gslpp::complex exp_Phase_2;
    gslpp::complex SU3_breaking;
    double lambda;        
    double spectator_charge; 
    double alpha_s_mub; 
    gslpp::complex DC7_QCDF;
    gslpp::complex DC7_QCDF_bar;
    
    double a_0T1;
    double a_0A1;
    double a_0V;
    gslpp::vector<gslpp::complex> ** allcoeff;
    gslpp::vector<gslpp::complex> ** allcoeffprime;
    gslpp::vector<gslpp::complex> ** allcoeff_noSM;
    gslpp::complex C_1;
    gslpp::complex C_2;
    gslpp::complex C_3;
    gslpp::complex C_4;
    gslpp::complex C_5;
    gslpp::complex C_6;
    gslpp::complex C_7;
    gslpp::complex C_7p;
    gslpp::complex C_8;
    double T_1();
    
    gslpp::complex h_lambda(int hel);
 
    gslpp::complex H_V_p();
    
    gslpp::complex H_V_m();
    
    gslpp::complex H_V_p_bar();
    
    gslpp::complex H_V_m_bar();
    
    gslpp::complex deltaC7_QCDF(bool conjugate);
    
    gslpp::complex Cq34(bool conjugate);
    
    gslpp::complex T_perp_WA_1();
    
    gslpp::complex T_perp_WA_2(bool conjugate);
    
    gslpp::complex L1(gslpp::complex x);
    
    double phi_V(double u);
    
    gslpp::complex t_perp(double u, double m);
    
    gslpp::complex T_perp_plus_QSS(double u, bool conjugate);
    
    gslpp::complex T_perp_plus_O8(double u);
    
    gslpp::complex T_perp(double u, bool conjugate);
 
    double getT_perp_integrand_real(double u) {
        return T_perp(u, false).real();
    };
 
    double getT_perp_integrand_imag(double u) {
        return T_perp(u, false).imag();
    };
 
    double getT_perp_bar_integrand_real(double u) {
        return T_perp(u, true).real();
    };
 
    double getT_perp_bar_integrand_imag(double u) {
        return T_perp(u, true).imag();
    };
    
    gslpp::complex T_QCDF_minus(bool conjugate);
    
private:
    QCD::meson meson;
    QCD::meson vectorM;
    bool dispersion;
    bool FixedWCbtos;
    double mJ2;
    
    const StandardModel& SM;
    std::unique_ptr<F_1> myF_1;
    std::unique_ptr<F_2> myF_2;
    double T_perp_real;
    double T_perp_imag;
    double T_perp_bar_real;
    double T_perp_bar_imag;
    
    double average;
    double error;
    gsl_function f_GSL;
    gsl_integration_cquad_workspace * w_GSL;
    std::vector<std::string> mVgammaParameters;
};
 
 
 
class BR_MVgamma : public ThObservable {
public:
    
    BR_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
    
    double computeBR_MVgamma(QCD::meson meson, QCD::meson vector);
    
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
    AmpDB2& myAmpDB2;
    double arg;
    double ADG; 
    double ys; 
    double t_int; 
};
 
 
 
class R_MVgamma : public BR_MVgamma {
public:
    
    R_MVgamma(const StandardModel& SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2);
    
    double computeThValue();
 
private:
    QCD::meson meson1; 
    QCD::meson meson2; 
    QCD::meson vector1; 
    QCD::meson vector2; 
};
 
 
 
class D0p_MVgamma : public BR_MVgamma {
public:
    
    D0p_MVgamma(const StandardModel& SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2);
    
    double computeThValue();
 
private:
    QCD::meson meson1; 
    QCD::meson meson2; 
    QCD::meson vector1; 
    QCD::meson vector2; 
};
 
 
 
class ACP_MVgamma : public ThObservable {
public:
    
    ACP_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
    
    double computeACP_MVgamma(QCD::meson meson, QCD::meson vector);
    
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
 
 
class DACP_MVgamma : public ACP_MVgamma {
public:
    
    DACP_MVgamma(const StandardModel& SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2);
    
    double computeThValue();
 
private:
    QCD::meson meson1; 
    QCD::meson meson2; 
    QCD::meson vector1; 
    QCD::meson vector2; 
};
 
 
 
class C_MVgamma : public ThObservable {
public:
    
    C_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
    
    double computeThValue ();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class S_MVgamma : public ThObservable {
public:
    
    S_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
    
    double computeThValue ();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
    AmpDB2& myAmpDB2;
    double arg;
};
 
class ADG_MVgamma : public ThObservable {
public:
    
    ADG_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
    
    double computeThValue ();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
    AmpDB2& myAmpDB2;
    double arg;
};
 
 
class DC7_1 : public ThObservable {
public:
    
    DC7_1(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
 
 
class DC7_2 : public ThObservable {
public:
    
    DC7_2(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class hp0_hm0 : public ThObservable {
public:
    
    hp0_hm0(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class AbsDC7_L : public ThObservable {
public:
    
    AbsDC7_L(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
 
 
class AbsDC7_R : public ThObservable {
public:
    
    AbsDC7_R(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class ReDC7_L : public ThObservable {
public:
    
    ReDC7_L(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
 
 
class ReDC7_R : public ThObservable {
public:
    
    ReDC7_R(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class ImDC7_L : public ThObservable {
public:
    
    ImDC7_L(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
 
 
class ImDC7_R : public ThObservable {
public:
    
    ImDC7_R(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class AbsDC7_QCDF : public ThObservable {
public:
    
    AbsDC7_QCDF(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class AbsDC7_QCDF_bar : public ThObservable {
public:
    
    AbsDC7_QCDF_bar(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class ReDC7_QCDF : public ThObservable {
public:
    
    ReDC7_QCDF(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class ReDC7_QCDF_bar : public ThObservable {
public:
    
    ReDC7_QCDF_bar(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class ImDC7_QCDF : public ThObservable {
public:
    
    ImDC7_QCDF(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
 
class ImDC7_QCDF_bar : public ThObservable {
public:
    
    ImDC7_QCDF_bar(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i);
 
    double computeThValue();
 
private:
    QCD::meson meson; 
    QCD::meson vectorM; 
};
#endif  /* MVLL_H */