SUSYMatching.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef SUSYMATCHING_H
#define SUSYMATCHING_H
 
#include <gslpp.h>
#include <complex>
#include <Polylogarithms.h>
#include <PVfunctions.h>
#include "StandardModelMatching.h"
 
#define LEPS 1.e-5     // tolerance in the limit of S(x,y) to S(x) 
#define SUSYLEPS 5.e-3 // tolerance in the limits of D0[x,y,z,t] and D2[x,y,z,t]
#define SUSYLEPS2 1.e-10 // tolerance in the limits of B0[x,y]
#define SUSYLEPS3 5.e-3 // tolerance in the limits of D0N
 
class SUSY;
 
class SUSYMatching : public StandardModelMatching {
public:
    SUSYMatching(const SUSY & SUSY_i);
    
    virtual std::vector<WilsonCoefficient>& CMdbd2();
    
    virtual std::vector<WilsonCoefficient>& CMdbs2();
    
//    /**
//     * 
//     * @brief \f$ \Delta C = 2 \f$,
//     * @return return the vector of SUSY Wilson coefficients
//     */
    virtual std::vector<WilsonCoefficient>& CMdd2();
    
    virtual std::vector<WilsonCoefficient>& CMdk2();
    
//    /** 
//     * 
//     * @brief operator basis: 
//     * @brief current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic  
//     * @param a, a=0 deltaS=0 deltaC=0;  a=1 deltaS=1 deltaC=0;
//     * @return Wilson coefficients Buras base for non-leptonic B decays 
//     */
//    virtual std::vector<WilsonCoefficient>& CMbnlep(const int& a);
//    
//    /**
//     * 
//     * @brief operator basis: - current current opertors  
//     * @param a, a=0 deltaS=0 deltaC=0;  a=1 1,0 ;  a=2 0,1 ; a=3 1,1 
//     * @return Wilson coefficients, Buras basis, for non-leptonic B decays 
//     */
//    virtual const std::vector<WilsonCoefficient>& CMbnlepCC(const int& a);
    
    virtual std::vector<WilsonCoefficient>& CMbsg();
    
    virtual std::vector<WilsonCoefficient>& CMBMll(QCD::lepton lepton);
 
    virtual std::vector<WilsonCoefficient>& CMDLij(int li_lj);
 
    virtual std::vector<WilsonCoefficient>& CMDLi3j(int li_lj);
 
    virtual std::vector<WilsonCoefficient>& CMmueconv();
 
    virtual std::vector<WilsonCoefficient>& CMgminus2mu();
 
//   /** Calculates gamma penguin amplitudes for m->(3)e (1), t->(3)m (2) and t->(3)e (3)**/
    virtual gslpp::vector<gslpp::complex> AFunctions(int n);
    
    //   /** Calculates Z penguin amplitudes for m->3e (1), t->3m (2) and t->3e (3)**/
    virtual gslpp::vector<gslpp::complex> FFunctions(int n);
 
 
//   /** Calculates box amplitudes for m->3e (1), t->3m (2) and t->3e (3) **/
    virtual gslpp::vector<gslpp::complex> BFunctions(int n);
 
//   /** Calculates Higgs penguin amplitudes for m->3e (1), t->3m (2) and t->3e (3)**/
    virtual gslpp::vector<gslpp::complex> BHFunctions(int n);
 
//   /** Calculates box amplitudes for m->e conversion**/
    virtual gslpp::vector<gslpp::complex> DFunctions();
 
//   /** Calculates the muon g-2**/
    virtual gslpp::vector<gslpp::complex> gminus2mu();
 
//   /** Calculates the muon g-2**/
    virtual double gminus2muNLO();
 
    virtual gslpp::vector<gslpp::complex> C7_Lepton(int n);
 
    virtual gslpp::vector<gslpp::complex> C9_Lepton(int n);
 
    virtual gslpp::vector<gslpp::complex> C10_Lepton(int n);
 
    virtual gslpp::vector<gslpp::complex> CS_Lepton(int n);
 
    virtual gslpp::vector<gslpp::complex> CP_Lepton(int n);
 
    virtual gslpp::vector<gslpp::complex> CT_Lepton(int n);
    
 
//    /**
//     * 
//     * @brief current-current oerators, Misiak basis
//     * @return Wilson coefficients for \f$ D^{0} \rightarrow \pi \pi , K K \f$
//     */
//    virtual std::vector<WilsonCoefficient>& CMd1();
//    
//    /**
//     * 
//     * @brief current-current oerators, Buras basis
//     * @return Wilson coefficients for \f$ D^{0} \rightarrow \pi \pi , K K \f$
//     */
//    virtual std::vector<WilsonCoefficient>& CMd1Buras();
    
    void updateSUSYParameters();
 
   
    void Comp_DeltaMd();
    void Comp_mySUSY_CKM();
    
    void Comp_mySUSYMQ();
    
    void Comp_VUDHH();
    
    void Comp_VdDNL(int flag);
    void Comp_VdDNR(int flag);
    
    void Comp_VdUCL();
    void Comp_VdUCR(int flag);     
    
    
    void Comp_VuUN();
    
    void Comp_VuDCL();
    void Comp_VuDCR();
    
    
    void Comp_Eps_J();
    void Comp_Lambda0EpsY();
    
    void Comp_PHLR();
    void Comp_PHRL();
    
    void Comp_DeltaDL();
 
    
    
private:
    const SUSY & mySUSY;
    const Polylogarithms Polylogs;
    const PVfunctions PV;
 
    WilsonCoefficient mcdbd2, mcdbd2Hp, mcdbd2gg, mcdbd2ChiChi, mcdbd2Chi0Chi0, mcdbd2Chi0g,
                      mcdbd2HpT, mcdbd2ggT, mcdbd2ChiChiT, mcdbd2Chi0Chi0T, mcdbd2Chi0gT;
    WilsonCoefficient mcdbs2, mcdbs2Hp, mcdbs2gg, mcdbs2ChiChi, mcdbs2Chi0Chi0, mcdbs2Chi0g,
                      mcdbs2HpT, mcdbs2ggT, mcdbs2ChiChiT, mcdbs2Chi0Chi0T, mcdbs2Chi0gT;
    WilsonCoefficient mcdk2, mcdk2Hp, mcdk2gg, mcdk2ChiChi, mcdk2Chi0Chi0, mcdk2Chi0g,
                      mcdk2HpT, mcdk2ggT, mcdk2ChiChiT, mcdk2Chi0Chi0T, mcdk2Chi0gT;
    WilsonCoefficient mcdd2, mcdd2Hp, mcdd2gg, mcdd2ChiChi, mcdd2Chi0Chi0, mcdd2Chi0g,
                      mcdd2HpT, mcdd2ggT, mcdd2ChiChiT, mcdd2Chi0Chi0T, mcdd2Chi0gT;
    WilsonCoefficient mcDLij,mcDLi3j,mcmueconv,mcgminus2mu;
 
    WilsonCoefficient mcbsg, mcBMll, mcbnlep, mcbnlepCC, mcd1, mcd1Buras;
    
    std::vector<WilsonCoefficient> vmdbd2;                           
    std::vector<WilsonCoefficient> vmdbs2;
    std::vector<WilsonCoefficient> vmdk2;
    std::vector<WilsonCoefficient> vmdd2;
    std::vector<WilsonCoefficient> vmcbsg;
//    std::vector<WilsonCoefficient> vmDLij;
//    std::vector<WilsonCoefficient> vmDLi3j;
    
    gslpp::matrix<gslpp::complex> myCKM;
//    gslpp::matrix<gslpp::complex> myRu;
//    gslpp::matrix<gslpp::complex> myRd;
//    gslpp::matrix<gslpp::complex> myRl;
//    gslpp::matrix<gslpp::complex> myRn;
//    gslpp::vector<double> mym_sn_sq;
//    gslpp::vector<double> mym_se_sq;
//    gslpp::vector<double> mym_su_sq;
//    gslpp::vector<double> mym_sd_sq;
 
    gslpp::vector<double> mym_su_sq,mym_sd_sq,mym_se_sq,mym_sn_sq;
    
    gslpp::matrix<gslpp::complex> myRu,myRd,myRl,myRn;
    
    gslpp::vector<double> MChi;
    gslpp::matrix<gslpp::complex> myV;
    gslpp::matrix<gslpp::complex> myU;
 
    gslpp::vector<double> MChi0,MNeig;
    gslpp::matrix<gslpp::complex> myN,ON;
 
//    gslpp::vector<double> MNeig;
//    gslpp::matrix<double> ON;
    
    gslpp::matrix<double> Lepty,Leptz,Leptfa1,Leptfa2,Leptf1,Leptf2,Leptf3,Leptf4;
    std::complex<double> Leptfzn[6][4][4],Leptgzn[6][4][4],Leptfzc[3][2][2],Leptgzc[3][2][2];
 
//    gslpp::matrix<double> Leptz;
//    gslpp::matrix<double> Leptfa1;
//    gslpp::matrix<double> Leptfa2;
//    gslpp::matrix<double> Leptf1;
//    gslpp::matrix<double> Leptf2;
//    gslpp::matrix<double> Leptf3;
//    gslpp::matrix<double> Leptf4;
 
//    std::complex<double> Leptgzn[6][4][4];
//    std::complex<double> Leptfzc[3][2][2];
//    std::complex<double> Leptgzc[3][2][2];
 
    gslpp::matrix<gslpp::complex> CRlE,CRlMU,CRlTAU,CRqUP,CRqDOWN,CLlE,CLlMU,CLlTAU,CLqUP,CLqDOWN,NRlE,NRlMU,NRlTAU,NRqUP,NRqDOWN,NLlE,NLlMU,NLlTAU,NLqUP,NLqDOWN;
    
//    gslpp::matrix<gslpp::complex> CRlMU;
//    gslpp::matrix<gslpp::complex> CRlTAU;
//    gslpp::matrix<gslpp::complex> CRqUP;
//    gslpp::matrix<gslpp::complex> CRqDOWN;
//    gslpp::matrix<gslpp::complex> CLlE;
//    gslpp::matrix<gslpp::complex> CLlMU;
//    gslpp::matrix<gslpp::complex> CLlTAU;
//    gslpp::matrix<gslpp::complex> CLqUP;
//    gslpp::matrix<gslpp::complex> CLqDOWN;
//    gslpp::matrix<gslpp::complex> NRlE;
//    gslpp::matrix<gslpp::complex> NRlMU;
//    gslpp::matrix<gslpp::complex> NRlTAU;
//    gslpp::matrix<gslpp::complex> NRqUP;
//    gslpp::matrix<gslpp::complex> NRqDOWN;
//    gslpp::matrix<gslpp::complex> NLlE;
//    gslpp::matrix<gslpp::complex> NLlMU;
//    gslpp::matrix<gslpp::complex> NLlTAU;
//    gslpp::matrix<gslpp::complex> NLqUP;
//    gslpp::matrix<gslpp::complex> NLqDOWN;
    
    gslpp::matrix<gslpp::complex> AmpA1LN,AmpA1RN,AmpA1LC,AmpA1RC,AmpTauA1LN,AmpTauA1RN,AmpTauA1LC,AmpTauA1RC,AmpTEA1LN,AmpTEA1RN,AmpTEA1LC,AmpTEA1RC,AmpALN,AmpARN,AmpALC,AmpARC,AmpTauALN,AmpTauARN,AmpTauALC,AmpTauARC,AmpTEALN,AmpTEARN,AmpTEALC,AmpTEARC;
 
//    gslpp::matrix<gslpp::complex> AmpA1RN;
//    gslpp::matrix<gslpp::complex> AmpA1LC;
//    gslpp::matrix<gslpp::complex> AmpA1RC;
//    gslpp::matrix<gslpp::complex> AmpTauA1LN;
//    gslpp::matrix<gslpp::complex> AmpTauA1RN;
//    gslpp::matrix<gslpp::complex> AmpTauA1LC;
//    gslpp::matrix<gslpp::complex> AmpTauA1RC;
//    gslpp::matrix<gslpp::complex> AmpTEA1LN;
//    gslpp::matrix<gslpp::complex> AmpTEA1RN;
//    gslpp::matrix<gslpp::complex> AmpTEA1LC;
//    gslpp::matrix<gslpp::complex> AmpTEA1RC;
//    gslpp::matrix<gslpp::complex> AmpALN;
//    gslpp::matrix<gslpp::complex> AmpARN;
//    gslpp::matrix<gslpp::complex> AmpALC;
//    gslpp::matrix<gslpp::complex> AmpARC;
//    gslpp::matrix<gslpp::complex> AmpTauALN;
//    gslpp::matrix<gslpp::complex> AmpTauARN;
//    gslpp::matrix<gslpp::complex> AmpTauALC;
//    gslpp::matrix<gslpp::complex> AmpTauARC;
//    gslpp::matrix<gslpp::complex> AmpTEALN;
//    gslpp::matrix<gslpp::complex> AmpTEARN;
//    gslpp::matrix<gslpp::complex> AmpTEALC;
//    gslpp::matrix<gslpp::complex> AmpTEARC;
 
    gslpp::matrix<gslpp::complex> TUhat;
 
    gslpp::matrix<gslpp::complex> TDhat;
 
    gslpp::matrix<gslpp::complex> TEhat;
 
    double Q_S;
    double mu2R;
    double Als;
    double Mg;
    double MHpm;
    double tanb;
    double sinb;
    double cosb;
    double v;
    double v1;
    double v2;
    double gW,mW,sinthetaW;
    
    
    double Dk(double x, double y, double z, double t, int k);
 
    double D0N(double x, double y, double z, double t);
    double D2LL0(double a, double b);
    double DL0(double a, double b, double c, int k);
    double DL(double a, double b, double c, int k);
    double DLL(double a, double b, int k);
    double DLLp(double a, double b, int k);
    double DLLL(double a, int k);
    
    
    /* Loop functions for bsll */    
    
    double bsll_f1(double x);
    double bsll_f2(double x);
    double bsll_f3(double x);
    double bsll_f4(double x);
    double bsll_f5(double x);
    double bsll_f6(double x);
    double bsll_f7(double x);
    double bsll_f8(double x);
    double bsll_C0(double m1, double m2, double m3);
    double bsll_C2(double m1, double m2, double m3, double mu2);
    double bsll_D0reg(double m1, double m2, double m3, double m4);
    double bsll_D2reg(double m1, double m2, double m3, double m4);
    gslpp::complex bsll_DeltaC7_SUSY();
    gslpp::complex bsll_Y_SUSY(int lep_pair); // lep_pair = 0 --> b to s e+e-, lep_pair = 1 --> b to s mu+mu-, lep_pair = 2 --> b to s tau+tau-
    gslpp::complex bsll_Z_SUSY(int lep_pair); // lep_pair = 0 --> b to s e+e-, lep_pair = 1 --> b to s mu+mu-, lep_pair = 2 --> b to s tau+tau-
    gslpp::complex bsll_DeltaC9_SUSY(int lep_pair);
    gslpp::complex bsll_DeltaC10_SUSY(int lep_pair);
 
    gslpp::matrix<gslpp::complex> gamULCKM,gamURCKM,gamULCKMMD,gamURCKMMU,gamDLMD,gamDRMD;
    gslpp::matrix<gslpp::complex> gamULgamULdag,gamDRgamDRdag;
    gslpp::matrix<gslpp::complex> upQmassM,downQmassM;
    
    gslpp::complex XUL[6][3][2],XUR[6][3][2],ZDL[6][3][4],ZDR[6][3][4];
    
    gslpp::vector<gslpp::complex> CdF2dHp(int b, int q, int Dmixingflag);
    
    gslpp::vector<gslpp::complex> CdF2dgg(int b, int q, int Dmixingflag);
    
    gslpp::vector<gslpp::complex> CdF2dChi0g(int b, int q, int Dmixingflag);
    
    gslpp::vector<gslpp::complex> CdF2dChiChi(int b, int q, int Dmixingflag);
    
    gslpp::vector<gslpp::complex> CdF2dChi0Chi0(int b, int q, int Dmixingflag);
 
    void NeutralinoRemixing();
 
    int delta_ab(int a, int b);
 
        // loopfunctions for Barr-Zee corrections:
        double fPS(double x);
        double fS(double x);
        double fft(double x);
        // loopfunction for tanb-enhanced correction
        double It(double a, double b, double c);
        // loopfunctions for the photonic 2loop corrections:
        double F3C(double x);
        double F4C(double x);
        double F3N(double x);
        double F4N(double x);
        double Li2(double x);
        // loopfunctions for the following correction:
        //   Deviation of the smuon-muon-chargino/neutralino couplings
        //   from gauge/Yukawa couplings due to the breaking of SUSY relations
        //   ref. arXiv:1311.1775
        double Fa(double x, double y);
        double Fb(double x, double y);    
 
    gslpp::complex VdUCL_cache[3][6][2];
    gslpp::complex VdUCR_cache[3][6][2][2];
 
    gslpp::complex VdUCL(int b, int k, int j);
    gslpp::complex VdUCR(int b, int k, int j, int flag);
    
    gslpp::complex VdDNL_cache[3][6][4][2];
    gslpp::complex VdDNR_cache[3][6][4][2];
    
    gslpp::complex VdDNL(int b, int k, int j, int flag);
    gslpp::complex VdDNR(int b, int k, int j, int flag);
    
    gslpp::complex VuDCL_cache[3][6][2];
    gslpp::complex VuDCR_cache[3][6][2];
    
    gslpp::complex VuDCL(int b, int k, int j);
    gslpp::complex VuDCR(int b, int k, int j);
    
    gslpp::complex VuUNL_cache[3][6][4];
    gslpp::complex VuUNR_cache[3][6][4];
    
    gslpp::complex VuUN(int b, int k, int j, const std::string);
  
  
    gslpp::complex VdUCL(int b, int k, int j, int Dmixingflag);
    gslpp::complex VdUCR(int b, int k, int j, int flag, int Dmixingflag);
        
    gslpp::complex VdDNL(int b, int k, int j, int flag, int Dmixingflag);
    gslpp::complex VdDNR(int b, int k, int j, int flag, int Dmixingflag);
    
    
    
    
 
    double CL(double a, double b, int k);
    double CLL(double a, int k);
    double Ck(double x, double y, double z,int k);
    double BL(double a, int k);
    double Bk(double x, double y, int k);
    
    gslpp::complex DeltaMd(int J, int I);
    
    gslpp::vector<gslpp::complex> Eps_JCache;
    gslpp::complex Eps_J(int J);
    
    gslpp::matrix<gslpp::complex> Lambda0EpsYCache;
    
    gslpp::complex Lambda0EpsY(int J, int I);
    
    gslpp::matrix<gslpp::complex> DeltaDL_Cache;
    
    
    gslpp::complex DeltaDL(int J, int I);
    gslpp::complex DeltaDR(int J, int I);
    
    
    gslpp::complex xdS(int S);
    gslpp::complex xuS(int S);
    gslpp::complex XRLS(int J, int I, int S);
    gslpp::complex XLRS(int J, int I, int S);
    
    
   
    gslpp::matrix<gslpp::complex> PHLRCache;
    
    
    gslpp::complex PHLR(int j, int i);
    gslpp::complex DeltaFHL(int j, int i);
    
    gslpp::matrix<gslpp::complex> PHRLCache;
    
    gslpp::complex PHRL(int j, int i);
    
    
    gslpp::complex VUDHH(int i, int j);
    gslpp::complex PGLR(int j, int i);
    gslpp::complex PGRL(int j, int i);
    gslpp::complex PLRk(int j, int i, int k);
    gslpp::complex PRLk(int j, int i, int k);
    
    gslpp::complex PRLk(int j, int i, int k, int Dmixingflag);
    gslpp::complex PLRk(int j, int i, int k, int Dmixingflag);
    
    gslpp::matrix<gslpp::complex> mySUSY_CKM();
    
    gslpp::complex EpsPrime(int J, int I);
    gslpp::vector<gslpp::complex> CalcC7(int b, int q);
    double F7k(double x, int k);
   
    
    gslpp::matrix<gslpp::complex> myCKM_cache;
    gslpp::matrix<gslpp::complex> VUDHH_cache;
    gslpp::matrix<gslpp::complex> DeltaMd_cache;
    gslpp::vector<double> mySUSYMQ;
    
};
 
#endif  /* SUSYMATCHING_H */