GeneralTHDM.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2016 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef GENERALTHDM_H
#define GENERALTHDM_H
 
#include "StandardModel.h"
#include "GeneralTHDMMatching.h"
#include "NPbase.h"
 
 
 
class GeneralTHDMcache; //forward reference to GeneralTHDMcache class
 
class GeneralTHDM: public NPbase {
public:
 
    static const int NGeneralTHDMvars = 68;
    static std::string GeneralTHDMvars[NGeneralTHDMvars];
 
    GeneralTHDM();
 
    ~GeneralTHDM();
    
    virtual bool InitializeModel();
    
    virtual bool Init(const std::map<std::string, double>& DPars);
    
    virtual bool PreUpdate();
    
    virtual bool Update(const std::map<std::string, double>& DPars);
    
    virtual bool PostUpdate();
    
    virtual bool CheckParameters(const std::map<std::string, double>& DPars);
    
    double getMuw() const
    {
        return muw;
    }
 
 
    virtual GeneralTHDMMatching& getMatching() const
    {
        return GTHDMM.getObj();
    }
 
 
    // Flags
 
    virtual bool setFlagStr(const std::string name, const std::string value);
    
    virtual bool setFlag(const std::string, const bool);
 
    GeneralTHDMcache* getMyGTHDMCache() const
    {
        return myGTHDMcache;
    }
 
 
    double getlogtb() const {
        return logtb;
    }
 
    double gettanb() const {
        return tanb;
    }
 
    double getsinb() const {
        return sinb;
    }
 
    double getcosb() const {
        return cosb;
    }
 
    double getmHp2() const {
        if(flag_use_sq_masses) {
            return mHp2;
        }
        else
        {
            return mHp1*mHp1;
        }
    }
 
    double getmHp() const {
        if(flag_use_sq_masses) {
            if(mHp2 < 0.) {
                throw std::runtime_error("error in GeneralTHDM: mHp2 < 0!");
            }
            else
            {
                return sqrt(mHp2);
            }
        }
        else
        {
                return mHp1;
        }
    }
 
 
    double getmH2sq() const {
        if(flag_use_sq_masses) {
             if(mH2sq < 0.) {
                throw std::runtime_error("error in GeneralTHDM: mH2sq < 0!");
            }
                return mH2sq;
            }
         else
        {
            return mH21*mH21;
        }
    }
 
      double getmH3sq() const {
        if(flag_use_sq_masses) {
             if(mH3sq < 0.) {
                throw std::runtime_error("error in GeneralTHDM: mH3sq < 0!");
            }
                return mH3sq;
            }
         else
        {
            return mH31*mH31;
        }
    }
 
    double getalpha1() const {
        return alpha1;
    }
 
    double getcosalpha1() const {
        return cosalpha1;
    }
 
    double getsinalpha1() const {
        return sinalpha1;
    }
 
    double getalpha2() const {
        if(flag_CPconservation==true) {
            return 0.0;
        }
        else {
            return alpha2;
        }
    }
 
    double getcosalpha2() const {
        if(flag_CPconservation==true) {
            return 1.0;
        }
        else {
            return cosalpha2;
        }
    }
 
    double getsinalpha2() const {
        if(flag_CPconservation==true) {
            return 0.0;
        }
        else {
            return sinalpha2;
        }
    }
 
    double getalpha3() const {
        if(flag_CPconservation==true) {
            return 0.0;
        }
        else {
            return alpha3;
        }
    }
 
    double getcosalpha3() const {
        if(flag_CPconservation==true) {
            return 1.0;
        }
        else {
            return cosalpha3;
        }
    }
 
    double getsinalpha3() const {
        if(flag_CPconservation==true) {
            return 0.0;
        }
        else {
            return sinalpha3;
        }
    }
 
    double getRelambda5() const {
        return Relambda5;
    }
    
    double getImlambda5() const {
        if(flag_CPconservation==true) {
            return 0.0;
        }
        else {
            return Imlambda5;
        }
    }
    
    double getRelambda6() const {
        return Relambda6;
    }
 
    double getRelambda7() const {
        return Relambda7;
    }
 
    gslpp::complex getNu_11() const {
        gslpp::complex i = gslpp::complex::i();
         if(flag_sigma) {
        return (Nu_11r + i*Nu_11i);
        }
         else
         {
             if(alpha1==0)
               return 0 +i*0;
             else
                return (yu1R_GTHDM - cosalpha1)/(sinalpha1);
         }
    }
       
    gslpp::complex getNu_12() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nu_12r + i*Nu_12i);
    }
    
    gslpp::complex getNu_13() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nu_13r + i*Nu_13i);
    }
    
    gslpp::complex getNu_21() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nu_21r + i*Nu_21i);
    }
    
    gslpp::complex getNu_22() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nu_22r + i*Nu_22i);
    }
      
    gslpp::complex getNu_23() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nu_23r + i*Nu_23i);
    }
    
    gslpp::complex getNu_31() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nu_31r + i*Nu_31i);
    }
    
    gslpp::complex getNu_32() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nu_32r + i*Nu_32i);
    }
    
    gslpp::complex getNu_33() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nu_33r + i*Nu_33i);
    }
    
    gslpp::complex getNd_11() const {
        gslpp::complex i = gslpp::complex::i();
        if(flag_sigma) {
        return (Nd_11r + i*Nd_11i);
        }
     else
         {
            if(alpha1==0)
                return 0 +i*0;
            else
             return (yd1R_GTHDM - cosalpha1)/(sinalpha1);
         }
    }
    
 
    gslpp::complex getNd_12() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nd_12r + i*Nd_12i);
    }
    
    gslpp::complex getNd_13() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nd_13r + i*Nd_13i);
    }
    
    gslpp::complex getNd_21() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nd_21r + i*Nd_21i);
    }
    
    gslpp::complex getNd_22() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nd_22r + i*Nd_22i);
    }
    
    gslpp::complex getNd_23() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nd_23r + i*Nd_23i);
    }
    
    gslpp::complex getNd_31() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nd_31r + i*Nd_31i);
    }
    
    gslpp::complex getNd_32() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nd_32r + i*Nd_32i);
    }
    
    gslpp::complex getNd_33() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nd_33r + i*Nd_33i);
    }
    
    gslpp::complex getNl_11() const {
        gslpp::complex i = gslpp::complex::i();
        if(flag_sigma) {
        return (Nl_11r + i*Nl_11i);
        }
        else
         {
            if(alpha1==0)
                return 0 +i*0;
            else
             return (yl1R_GTHDM  -cosalpha1)/(sinalpha1);
         }
    }
    
    gslpp::complex getNl_12() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nl_12r + i*Nl_12i);
    }
    
    gslpp::complex getNl_13() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nl_13r + i*Nl_13i);
    }
    
    gslpp::complex getNl_21() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nl_21r + i*Nl_21i);
    }
    
    gslpp::complex getNl_22() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nl_22r + i*Nl_22i);
    }
    
    gslpp::complex getNl_23() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nl_23r + i*Nl_23i);
    }
    
    gslpp::complex getNl_31() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nl_31r + i*Nl_31i);
    }
    
    gslpp::complex getNl_32() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nl_32r + i*Nl_32i);
    }
    
    gslpp::complex getNl_33() const {
        gslpp::complex i = gslpp::complex::i();
        return (Nl_33r + i*Nl_33i);
    }
    
    
    
    gslpp::complex getyu1() const {
        if(!flag_sigma) {
        return (yu1R_GTHDM);
        }
         else
         {
            gslpp::complex i = gslpp::complex::i();
            double R11 = cosalpha1*cosalpha2;
            double R12 = sinalpha1*cosalpha2;
            double R13 = -sinalpha2;
            return (R11 + (R12 - i*R13)*(Nu_11r + i*Nu_11i).conjugate());
         }
    }
        
     
    double getyu1R() const {
        if(!flag_sigma) {
        return (yu1R_GTHDM);
        }
         else
         {
            double R11 = cosalpha1*cosalpha2;
            double R12 = sinalpha1*cosalpha2;
            return (R11 + R12*Nu_11r);
         }
    }    
        
        
    gslpp::complex getyd1() const {
        if(!flag_sigma) {
        return (yd1R_GTHDM);
        }
         else
         {
            gslpp::complex i = gslpp::complex::i();
            double R11 = cosalpha1*cosalpha2;
            double R12 = sinalpha1*cosalpha2;
            double R13 = -sinalpha2;
            return (R11 + (R12 - i*R13)*(Nd_11r + i*Nd_11i));
         }
    }
    
    
    double getyd1R() const {
        if(!flag_sigma) {
        return (yd1R_GTHDM);
        }
         else
         {
            double R11 = cosalpha1*cosalpha2;
            double R12 = sinalpha1*cosalpha2;
            return (R11 + R12*Nd_11r);
         }
    }
    
        gslpp::complex getyl1() const {
         if(!flag_sigma) {
        return (yl1R_GTHDM);
        }
         else
         {
            gslpp::complex i = gslpp::complex::i();
            double R11 = cosalpha1*cosalpha2;
            double R12 = sinalpha1*cosalpha2;
            double R13 = -sinalpha2;
            return (R11 + (R12 - i*R13)*(Nl_11r + i*Nl_11i));
         }
    }
    
    
    double getyl1R() const {
         if(!flag_sigma) {
        return (yl1R_GTHDM);
        }
         else
         {
            double R11 = cosalpha1*cosalpha2;
            double R12 = sinalpha1*cosalpha2;
            return (R11 + R12*Nl_11r);
         }
    }
    
    double getQ_GTHDM() const {
        return Q_GTHDM;
    }
 
    double getRpepsGTHDM() const {
        return RpepsGTHDM;
    }
 
    double getNLOuniscaleGTHDM() const {
        return NLOuniscaleGTHDM;
    }
 
    bool getATHDMflag() const {
        return flag_ATHDM;
    }
 
    bool getCPconservationflag() const {
        return flag_CPconservation;
    }
 
    std::string getRGEorderflag() const {
        return flag_RGEorder;
    }
    
    bool getsqmassesflag() const {
        return flag_use_sq_masses;
    }
 
 
    virtual double muggH(const double sqrt_s) const;
    virtual double muVBF(const double sqrt_s) const;
    virtual double mueeWBF(const double sqrt_s) const;
    virtual double muWH(const double sqrt_s) const;
    virtual double muZH(const double sqrt_s) const;
    virtual double mueeZH(const double sqrt_s) const;
    virtual double muVH(const double sqrt_s) const;
    virtual double muVBFpVH(const double sqrt_s) const;
    virtual double muttH(const double sqrt_s) const;
    virtual double GammaTotal() const;
    virtual double BrHggRatio() const;
    virtual double BrHWWRatio() const;
    virtual double BrHZZRatio() const;
    virtual double BrHZgaRatio() const;
    virtual double BrHgagaRatio() const;
    virtual double BrHmumuRatio() const;
    virtual double BrHtautauRatio() const;
    virtual double BrHccRatio() const;
    virtual double BrHbbRatio() const;
    virtual double muggHgaga(const double sqrt_s) const;
    virtual double muVBFHgaga(const double sqrt_s) const;
    virtual double muVHgaga(const double sqrt_s) const;
    virtual double muttHgaga(const double sqrt_s) const;
    virtual double muggHZZ(const double sqrt_s) const;
    virtual double muVBFHZZ(const double sqrt_s) const;
    virtual double muVHZZ(const double sqrt_s) const;
    virtual double muttHZZ(const double sqrt_s) const;
    virtual double muggHWW(const double sqrt_s) const;
    virtual double muVBFHWW(const double sqrt_s) const;
    virtual double muVHWW(const double sqrt_s) const;
    virtual double muttHWW(const double sqrt_s) const;
    virtual double muggHtautau(const double sqrt_s) const;
    virtual double muVBFHtautau(const double sqrt_s) const;
    virtual double muVHtautau(const double sqrt_s) const;
    virtual double muttHtautau(const double sqrt_s) const;
    virtual double muggHbb(const double sqrt_s) const;
    virtual double muVBFHbb(const double sqrt_s) const;
    virtual double muVHbb(const double sqrt_s) const;
    virtual double muttHbb(const double sqrt_s) const;
    virtual double muppHmumu(const double sqrt_s) const;
    virtual double muppHZga(const double sqrt_s) const;
    virtual double computeGammaTotalRatio() const;
 
    /*
     * @brief Method overriding the NPbase Mw with the tree-level W mass
     */
    virtual double Mw() const;
 
protected:
 
    virtual void setParameter(const std::string, const double&);
 
    bool checkRGEorder(const std::string RGEorder) const
    {
        if (RGEorder.compare("LO") == 0)
//                || RGEorder.compare("approxNLO") == 0)
            return true;
        else
            return false;
    }
 
    mutable Matching<GeneralTHDMMatching,GeneralTHDM> GTHDMM; 
 
private:
 
    GeneralTHDMcache* myGTHDMcache;
 
    double logtb, tanb, sinb, cosb, mHp2, mH2sq, mH3sq, mHp1, mH21, mH31, alpha1, cosalpha1, sinalpha1, alpha2, cosalpha2, sinalpha2,
            alpha3, cosalpha3, sinalpha3, Relambda5, Imlambda5, Relambda6, Relambda7,
            yu1R_GTHDM, yd1R_GTHDM, yl1R_GTHDM, 
            Nu_11r, Nu_11i, Nu_12r, Nu_12i, Nu_13r, Nu_13i, 
            Nu_21r, Nu_21i, Nu_22r, Nu_22i, Nu_23r, Nu_23i, 
            Nu_31r, Nu_31i, Nu_32r, Nu_32i, Nu_33r, Nu_33i, 
            Nd_11r, Nd_11i, Nd_12r, Nd_12i, Nd_13r, Nd_13i, 
            Nd_21r, Nd_21i, Nd_22r, Nd_22i, Nd_23r, Nd_23i, 
            Nd_31r, Nd_31i, Nd_32r, Nd_32i, Nd_33r, Nd_33i, 
            Nl_11r, Nl_11i, Nl_12r, Nl_12i, Nl_13r, Nl_13i, 
            Nl_21r, Nl_21i, Nl_22r, Nl_22i, Nl_23r, Nl_23i, 
            Nl_31r, Nl_31i, Nl_32r, Nl_32i, Nl_33r, Nl_33i, 
            Q_GTHDM, RpepsGTHDM, NLOuniscaleGTHDM;
    bool flag_ATHDM, flag_CPconservation, flag_use_sq_masses, flag_sigma;
    std::string flag_RGEorder;
};
 
#endif  /* GENERALTHDM_H */