THDM.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef THDM_H
#define THDM_H
 
#include "StandardModel.h"
#include "THDMMatching.h"
 
class THDMcache; //forward reference to THDMcache class
 
class THDM: public StandardModel {
public:
 
    static const int NTHDMvars = 16;
    static std::string THDMvars[NTHDMvars];
    
    THDM();
    
    ~THDM();
    
    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);
 
    virtual THDMMatching& getMatching() const
    {
        return THDMM.getObj();
    }
 
    // Flags
 
    virtual bool setFlagStr(const std::string name, const std::string value);
    
    virtual bool setFlag(const std::string name, const bool value);
 
    THDMcache* getMyTHDMCache() const
    {
        return myTHDMcache;
    }
 
    
    double getv1() const {
        return v() * cosb;
    }
 
    double getv2() const {
        return v() * sinb;
    }
    
 
    std::string getModelTypeflag() const {
        return flag_model;
    }
 
    std::string getRGEorderflag() const {
        return flag_RGEorder;
    }
 
    bool getsqmassesflag() const {
        return flag_use_sq_masses;
    }
 
    bool getWFRflag() const {
        return flag_wfr;
    }
 
    double getlogtb() const {
        return logtb;
    }
 
    double gettanb() const {
        return tanb;
    }
 
    double getsinb() const {
        return sinb;
    }
 
    double getcosb() const {
        return cosb;
    }
 
    double getbma() const {
        return bma;
    }
 
    double getsin_ba() const {
        return sin_ba;
    }
 
    double getcosa() const{
        return cos(atan(pow(10.,logtb))-bma);
    }
 
    double getsina() const{
        return sin(atan(pow(10.,logtb))-bma);
    }
 
    double getmHl2() const {
        if(flag_use_sq_masses) {
            if(mHh2 < mHl2) {
                return mHh2;
            }
            else
            {
                return mHl2;
            }
        }
        else
        {
            if(mHh1*mHh1 < mHl2) {
                return mHh1*mHh1;
            }
            else
            {
                return mHl2;
            }
        }
    }
 
    double getmHh2() const {
        if(flag_use_sq_masses) {
            if(mHh2 < 0.) {
                return 0.;
            }
            else if(mHh2 < mHl2) {
                return mHl2;
            }
            else
            {
                return mHh2;
            }
        }
        else
        {
            if(mHh1*mHh1 < mHl2) {
                return mHl2;
            }
            else
            {
                return mHh1*mHh1;
            }
        }
    }
 
    double getmHh() const {
        if(flag_use_sq_masses) {
            if(mHh2 < 0.) {
                return 0.;
            }
            else if(mHh2 < mHl2) {
                return sqrt(mHl2);
            }
            else
            {
                return sqrt(mHh2);
            }
        }
        else
        {
            if(mHh1*mHh1 < mHl2) {
                return sqrt(mHl2);
            }
            else
            {
                return mHh1;
            }
        }
    }
 
    double getmA2() const {
        if(flag_use_sq_masses) {
            return mA2;
        }
        else
        {
            return mA1*mA1;
        }
    }
 
    double getmA() const {
        if(flag_use_sq_masses) {
            if(mA2 < 0.) {
                return 0.;
            }
            else
            {
                return sqrt(mA2);
            }
        }
        else
        {
                return mA1;
        }
    }
 
    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.) {
                return 0.;
            }
            else
            {
                return sqrt(mHp2);
            }
        }
        else
        {
                return mHp1;
        }
    }
 
    double getm12_2() const {
        return m12_2;
    }
 
    double getBDtaunu_SM() const {
        return BDtaunu_SM;
    }
 
    double getBDtaunu_A() const {
        return BDtaunu_A;
    }
 
    double getBDtaunu_B() const {
        return BDtaunu_B;
    }
 
    double getBDstartaunu_SM() const {
        return BDstartaunu_SM;
    }
 
    double getBDstartaunu_A() const {
        return BDstartaunu_A;
    }
 
    double getBDstartaunu_B() const {
        return BDstartaunu_B;
    }
 
    double getbsgamma_theoryerror() const {
        return bsgamma_theoryerror;
    }
 
    double getQ_THDM() const {
        return Q_THDM;
    }
 
    double getRpeps() const {
        return Rpeps;
    }
 
    double getNLOuniscale() const {
        return NLOuniscale;
    }
 
protected: 
 
    virtual void setParameter(const std::string name, const double& value);
//    THDMcache * mycache;
 
    bool checkmodelType(const std::string modeltype) const
    {
        if (modeltype.compare("type1") == 0
                || modeltype.compare("type2") == 0
                || modeltype.compare("typeX") == 0
                || modeltype.compare("typeY") == 0)
            return true;
        else
            return false;
    }
 
    bool checkRGEorder(const std::string RGEorder) const
    {
        if (RGEorder.compare("LO") == 0
                || RGEorder.compare("approxNLO") == 0
                || RGEorder.compare("NLO") == 0)
            return true;
        else
            return false;
    }
 
    mutable Matching<THDMMatching,THDM> THDMM; 
 
private:
 
    THDMcache* myTHDMcache;
 
    double logtb, tanb, sinb, cosb, bma, sin_ba, mHh1, mA1, mHp1, mHh2, mA2, mHp2, m12_2, bsgamma_theoryerror, Q_THDM, Rpeps, NLOuniscale;
    double mHl2;
    double BDtaunu_SM, BDtaunu_A, BDtaunu_B, BDstartaunu_SM, BDstartaunu_A, BDstartaunu_B;
    std::string flag_model, flag_RGEorder;
    bool flag_use_sq_masses, flag_wfr;
};
 
#endif  /* THDM_H */