GeorgiMachacek.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2015 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef GEORGIMACHACEK_H
#define GEORGIMACHACEK_H
 
//#include "StandardModel.h"
#include "GMMatching.h"
#include "NPbase.h"
 
class GMcache; //forward reference to GMcache class
 
 
 
class GeorgiMachacek: public NPbase {
public:
 
    static const int NGMvars = 8;
    //The parameters of the Higgs potential for Georgi Machacek model according to 1511.00865v1
    //We choose the physical basis: vDelta, alpha, mHh=mH1, mA=mH3, mH5, Mu1, Mu2
    static std::string GMvars[NGMvars];
    
    GeorgiMachacek();
    
    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 GMMatching& getMatching() const
    {
        return GMM.getObj();
    }
 
    GMcache* getMyGMCache() const
    {
        return myGMcache;
    }
 
    // Flags
 
//    virtual bool setFlagStr(const std::string name, const std::string value);
    virtual bool setFlag(const std::string, const bool);
 
 
 
    double getvDelta() const {
        return vDelta;
    }
 
    double getalpha() const {
        return alpha;
    }
 
    double getcosa() const{
        return cos(alpha);
    }
 
    double getsina() const{
        return sin(alpha);
    }
 
    double getmHl2() const {
        if(flag_use_sq_masses) {
            if(mHhsq < mHl2) {
                return mHhsq;
            }
            else
            {
                return mHl2;
            }
        }
        else
        {
            if(mHh*mHh < mHl2) {
                return mHh*mHh;
            }
            else
            {
                return mHl2;
            }
        }
    }
 
    double getmHh2() const {
        if(flag_use_sq_masses) {
            if(mHhsq < 0.) {
                return 0.;
            }
            else if(mHhsq < mHl2) {
                return mHl2;
            }
            else
            {
                return mHhsq;
            }
        }
        else
        {
            if(mHh*mHh < mHl2) {
                return mHl2;
            }
            else
            {
                return mHh*mHh;
            }
        }
    }
 
    double getmHh() const {
        if(flag_use_sq_masses) {
            if(mHhsq < 0.) {
                return 0.;
            }
            else if(mHhsq < mHl2) {
                return sqrt(mHl2);
            }
            else
            {
                return sqrt(mHhsq);
            }
        }
        else
        {
            if(mHh*mHh < mHl2) {
                return sqrt(mHl2);
            }
            else
            {
                return mHh;
            }
        }
    }
 
    double getinputmHh2() const {
        if(flag_use_sq_masses) {
            if(mHhsq < 0.) {
                return 0.;
            }
                return mHhsq;
        }
        else
        {
                return mHh*mHh;
        }
    }
 
    double getmAsq() const {
        if(flag_use_sq_masses) {
            return mAsq;
        }
        else
        {
            return mA*mA;
        }
    }
 
    double getmA() const {
        if(flag_use_sq_masses) {
            if(mA < 0.) {
                return 0.;
            }
            else
            {
                return sqrt(mAsq);
            }
        }
        else
        {
                return mA;
        }
    }
 
    double getmH5sq() const {
        if(flag_use_sq_masses) {
            return mH5sq;
        }
        else
        {
            return mH5*mH5;
        }
    }
 
    double getmH5() const {
        if(flag_use_sq_masses) {
            if(mH5 < 0.) {
                return 0.;
            }
            else
            {
                return sqrt(mH5sq);
            }
        }
        else
        {
                return mH5;
        }
    }
 
    double getMu1() const {
        return Mu1;
    }
 
    double getMu2() const {
        return Mu2;
    }
 
    double getQ_GM() const {
        return Q_GM;
    }
 
    virtual const double Mw() const;
 
    virtual const double muggH(const double sqrt_s) const;
    virtual const double muVBF(const double sqrt_s) const;
    virtual const double mueeWBF(const double sqrt_s, const double Pol_em, const double Pol_ep) const;
    virtual const double muWH(const double sqrt_s) const;
    virtual const double muZH(const double sqrt_s) const;
    virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const;
    virtual const double muVH(const double sqrt_s) const;
    virtual const double muVBFpVH(const double sqrt_s) const;
    virtual const double muttH(const double sqrt_s) const;
    virtual const double GammaTotal() const;
    virtual const double BrHggRatio() const;
    virtual const double BrHWWRatio() const;
    virtual const double BrHZZRatio() const;
    virtual const double BrHZgaRatio() const;
    virtual const double BrHgagaRatio() const;
    virtual const double BrHmumuRatio() const;
    virtual const double BrHtautauRatio() const;
    virtual const double BrHccRatio() const;
    virtual const double BrHbbRatio() const;
    virtual const double muggHgaga(const double sqrt_s) const;
    virtual const double muVBFHgaga(const double sqrt_s) const;
    virtual const double muVHgaga(const double sqrt_s) const;
    virtual const double muttHgaga(const double sqrt_s) const;
    virtual const double muggHZZ(const double sqrt_s) const;
    virtual const double muVBFHZZ(const double sqrt_s) const;
    virtual const double muVHZZ(const double sqrt_s) const;
    virtual const double muttHZZ(const double sqrt_s) const;
    virtual const double muggHWW(const double sqrt_s) const;
    virtual const double muVBFHWW(const double sqrt_s) const;
    virtual const double muVHWW(const double sqrt_s) const;
    virtual const double muttHWW(const double sqrt_s) const;
    virtual const double muggHtautau(const double sqrt_s) const;
    virtual const double muVBFHtautau(const double sqrt_s) const;
    virtual const double muVHtautau(const double sqrt_s) const;
    virtual const double muttHtautau(const double sqrt_s) const;
    virtual const double muggHbb(const double sqrt_s) const;
    virtual const double muVBFHbb(const double sqrt_s) const;
    virtual const double muVHbb(const double sqrt_s) const;
    virtual const double muttHbb(const double sqrt_s) const;
    virtual const double muppHmumu(const double sqrt_s) const;
    virtual const double muppHZga(const double sqrt_s) const;
    virtual const double computeGammaTotalRatio() const;
 
 
protected: 
    virtual void setParameter(const std::string, const double&);
 
    mutable Matching<GMMatching,GeorgiMachacek> GMM; 
 
private:
 
    GMcache* myGMcache;
 
    double vDelta, alpha, mHh, mA, mH5, mHhsq, mAsq, mH5sq, Mu1, Mu2, Q_GM;
    double mHl2;
    bool flag_use_sq_masses;
//    double sign(const double x) const;
 
};
 
#endif  /* GEORGIMACHACEK_H */