HiggsKigen.h

Go to the documentation of this file.

/*
 * Copyright (C) 2014 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef HIGGSKIGEN_H
#define HIGGSKIGEN_H
#include "NPbase.h"
 
class HiggsKigen : public NPbase {
public:
 
    static const int NHKvKfgenvars = 92; 
 
    static const std::string HKvKfgenvars[NHKvKfgenvars];
 
    HiggsKigen();
 
    virtual ~HiggsKigen()
    {
    };
    
    virtual bool PostUpdate();
    
    virtual bool setFlag(const std::string name, const bool value);
 
    double getKw() const
    {
        return Kw;
    }
 
    void setKw(double Kw)
    {
        this->Kw = Kw;
    }
       
    double getKz() const
    {
        return Kz;
    }
 
    void setKz(double Kz)
    {
        this->Kz = Kz;
    }
      
    double getKg() const
    {
        return Kg;
    }
 
    void setKg(double Kg)
    {
        this->Kg = Kg;
    }
      
    double getKga() const
    {
        return Kga;
    }
 
    void setKga(double Kga)
    {
        this->Kga = Kga;
    }
 
    double getKzga() const
    {
        return Kzga;
    }
 
    void setKzga(double Kzga)
    {
        this->Kzga = Kzga;
    }
 
    double getKd() const
    {
        return Kd;
    }
 
    void setKd(double Kd)
    {
        this->Kd = Kd;
    }
        
    double getKs() const
    {
        return Ks;
    }
 
    void setKs(double Ks)
    {
        this->Ks = Ks;
    }    
    
    double getKb() const
    {
        return Kb;
    }
 
    void setKb(double Kb)
    {
        this->Kb = Kb;
    }
 
    double getKe() const
    {
        return Ke;
    }
 
    void setKe(double Ke)
    {
        this->Ke = Ke;
    }
    
    double getKmu() const
    {
        return Kmu;
    }
 
    void setKmu(double Kmu)
    {
        this->Kmu = Kmu;
    }
    
    double getKtau() const
    {
        return Ktau;
    }
 
    void setKtau(double Ktau)
    {
        this->Ktau = Ktau;
    }
 
    double getKu() const
    {
        return Ku;
    }
 
    void setKu(double Ku)
    {
        this->Ku = Ku;
    }
    
    double getKc() const
    {
        return Kc;
    }
 
    void setKc(double Kc)
    {
        this->Kc = Kc;
    }    
    
    double getKt() const
    {
        return Kt;
    }
 
    void setKt(double Kt)
    {
        this->Kt = Kt;
    }   
    
    double getKH() const
    {
        return KH;
    }
 
    void setKH(double KH)
    {
        this->KH = KH;
    }
    
    
    double getBrHinv() const
    {
        return BrHinv;
    }
 
    void setBrHinv(double BrHinv)
    {
        this->BrHinv = BrHinv;
    } 
    
    double getBrHexo() const
    {
        return BrHexo;
    }
    
    void setBrHexo(double BrHexo)
    {
        this->BrHexo = BrHexo;
    }
 
    virtual bool CheckParameters(const std::map<std::string, double>& DPars);
 
 
    virtual double obliqueS() const;
 
    virtual double obliqueT() const;
 
    virtual double obliqueU() const;
 
    virtual double muggH(const double sqrt_s) const;
    virtual double muVBF(const double sqrt_s) const;
    virtual double muVBFgamma(const double sqrt_s) const;
    virtual double mueeWBF(const double sqrt_s) const;
    virtual double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const;
    virtual double mueeHvv(const double sqrt_s) const;
    virtual double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const;
    virtual double mueeZBF(const double sqrt_s) const;
    virtual double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const;
    virtual double muepWBF(const double sqrt_s) const;
    virtual double muepZBF(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 mueeZllH(const double sqrt_s) const;
    virtual double mueeZqqH(const double sqrt_s) const;
    virtual double mueeZHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const;  
    virtual double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const;    
    virtual double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) 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 mutHq(const double sqrt_s) const;
    virtual double mummH(const double sqrt_s) const;
    virtual double muggHpttH(const double sqrt_s) const;
    virtual double mueettH(const double sqrt_s) const;
    virtual double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const;
    virtual double BrHggRatio() const;
    virtual double BrHWWRatio() const;
    virtual double BrHWW2l2vRatio() const;
    virtual double BrHZZRatio() const;
    virtual double BrHZZ4lRatio() const;
    virtual double BrHZZ4eRatio() const;
    virtual double BrHZZ2e2muRatio() const;
    virtual double BrHZZ4muRatio() const;
    virtual double BrHZgaRatio() const;
    virtual double BrHZgallRatio() const;
    virtual double BrHZgaeeRatio() const;
    virtual double BrHZgamumuRatio() const;
    virtual double BrHgagaRatio() const;
    virtual double BrHmumuRatio() const;
    virtual double BrHtautauRatio() const;
    virtual double BrHccRatio() const;
    virtual double BrHbbRatio() const;
    virtual double muttHZbbboost(const double sqrt_s) const;
 
    virtual double muggHgaga(const double sqrt_s) const;    
    virtual double muggHgagaInt(const double sqrt_s) const;
    virtual double muVBFHgaga(const double sqrt_s) const;
    virtual double muZHgaga(const double sqrt_s) const;
    virtual double muWHgaga(const double sqrt_s) const;
    virtual double muVHgaga(const double sqrt_s) const;
    virtual double muttHgaga(const double sqrt_s) const;
    virtual double muggHZga(const double sqrt_s) const;
    virtual double muVBFHZga(const double sqrt_s) const;    
    virtual double muZHZga(const double sqrt_s) const;
    virtual double muWHZga(const double sqrt_s) const;    
    virtual double muVHZga(const double sqrt_s) const;
    virtual double muttHZga(const double sqrt_s) const; 
    virtual double muggHZZ(const double sqrt_s) const;
    virtual double muVBFHZZ(const double sqrt_s) const;
    virtual double muZHZZ(const double sqrt_s) const;
    virtual double muWHZZ(const double sqrt_s) const;
    virtual double muVHZZ(const double sqrt_s) const;
    virtual double muttHZZ(const double sqrt_s) const;
    
    
    
    virtual double muggHZZ4l(const double sqrt_s) const;
    virtual double muVBFHZZ4l(const double sqrt_s) const;    
    virtual double muZHZZ4l(const double sqrt_s) const;
    virtual double muWHZZ4l(const double sqrt_s) const;    
    virtual double muVHZZ4l(const double sqrt_s) const;
    virtual double muttHZZ4l(const double sqrt_s) const;
    
    
    
    
    virtual double muggHWW(const double sqrt_s) const;
    virtual double muVBFHWW(const double sqrt_s) const;
    virtual double muZHWW(const double sqrt_s) const;
    virtual double muWHWW(const double sqrt_s) const; 
    virtual double muVHWW(const double sqrt_s) const;
    virtual double muttHWW(const double sqrt_s) const;
    virtual double muggHWW2l2v(const double sqrt_s) const;
    virtual double muVBFHWW2l2v(const double sqrt_s) const;   
    virtual double muZHWW2l2v(const double sqrt_s) const;
    virtual double muWHWW2l2v(const double sqrt_s) const;    
    virtual double muVHWW2l2v(const double sqrt_s) const;
    virtual double muttHWW2l2v(const double sqrt_s) const;
    virtual double muggHmumu(const double sqrt_s) const;
    virtual double muVBFHmumu(const double sqrt_s) const;    
    virtual double muZHmumu(const double sqrt_s) const;
    virtual double muWHmumu(const double sqrt_s) const;    
    virtual double muVHmumu(const double sqrt_s) const;
    virtual double muttHmumu(const double sqrt_s) const;
    virtual double muggHtautau(const double sqrt_s) const;
    virtual double muVBFHtautau(const double sqrt_s) const;
    virtual double muZHtautau(const double sqrt_s) const;
    virtual double muWHtautau(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 muZHbb(const double sqrt_s) const;
    virtual double muWHbb(const double sqrt_s) const;
    virtual double muVHbb(const double sqrt_s) const;
    virtual double muttHbb(const double sqrt_s) const;
 
    virtual double computeGammaTotalRatio() const;
    
    virtual double computeGammaTotalnoErrorRatio() const;
    
    virtual double computeGammaTotalSMRatio() const;
    
    virtual double computeGammaTotalSMnoErrorRatio() const;
    
    virtual double Br_H_exo() const;
    
    virtual double Br_H_inv() const;
    
    virtual double Br_H_inv_NP() const;
    
    virtual double BrHvisRatio() const;
    
    virtual double BrHtoinvRatio() const;
    
    
//-----------------------------------------------------------------------------------------
//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
//-----------------------------------------------------------------------------------------
    
    virtual double muTHUggHgaga(const double sqrt_s) const;    
    virtual double muTHUVBFHgaga(const double sqrt_s) const;
    virtual double muTHUZHgaga(const double sqrt_s) const;
    virtual double muTHUWHgaga(const double sqrt_s) const;
    virtual double muTHUVHgaga(const double sqrt_s) const;
    virtual double muTHUttHgaga(const double sqrt_s) const;
    virtual double muTHUggHZga(const double sqrt_s) const;
    virtual double muTHUVBFHZga(const double sqrt_s) const;    
    virtual double muTHUZHZga(const double sqrt_s) const;
    virtual double muTHUWHZga(const double sqrt_s) const;    
    virtual double muTHUVHZga(const double sqrt_s) const;
    virtual double muTHUttHZga(const double sqrt_s) const; 
    virtual double muTHUggHZZ(const double sqrt_s) const;
    virtual double muTHUVBFHZZ(const double sqrt_s) const;
    virtual double muTHUZHZZ(const double sqrt_s) const;
    virtual double muTHUWHZZ(const double sqrt_s) const;
    virtual double muTHUVHZZ(const double sqrt_s) const;
    virtual double muTHUttHZZ(const double sqrt_s) const;
    
    virtual double muTHUggHZZ4l(const double sqrt_s) const;
    virtual double muTHUVBFHZZ4l(const double sqrt_s) const;    
    virtual double muTHUZHZZ4l(const double sqrt_s) const;
    virtual double muTHUWHZZ4l(const double sqrt_s) const;    
    virtual double muTHUVHZZ4l(const double sqrt_s) const;
    virtual double muTHUttHZZ4l(const double sqrt_s) const;
    
    virtual double muTHUggHWW(const double sqrt_s) const;
    virtual double muTHUVBFHWW(const double sqrt_s) const;
    virtual double muTHUZHWW(const double sqrt_s) const;
    virtual double muTHUWHWW(const double sqrt_s) const; 
    virtual double muTHUVHWW(const double sqrt_s) const;
    virtual double muTHUttHWW(const double sqrt_s) const;
    virtual double muTHUggHWW2l2v(const double sqrt_s) const;
    virtual double muTHUVBFHWW2l2v(const double sqrt_s) const;   
    virtual double muTHUZHWW2l2v(const double sqrt_s) const;
    virtual double muTHUWHWW2l2v(const double sqrt_s) const;    
    virtual double muTHUVHWW2l2v(const double sqrt_s) const;
    virtual double muTHUttHWW2l2v(const double sqrt_s) const;
    virtual double muTHUggHmumu(const double sqrt_s) const;
    virtual double muTHUVBFHmumu(const double sqrt_s) const;    
    virtual double muTHUZHmumu(const double sqrt_s) const;
    virtual double muTHUWHmumu(const double sqrt_s) const;    
    virtual double muTHUVHmumu(const double sqrt_s) const;
    virtual double muTHUttHmumu(const double sqrt_s) const;
    virtual double muTHUggHtautau(const double sqrt_s) const;
    virtual double muTHUVBFHtautau(const double sqrt_s) const;
    virtual double muTHUZHtautau(const double sqrt_s) const;
    virtual double muTHUWHtautau(const double sqrt_s) const;
    virtual double muTHUVHtautau(const double sqrt_s) const;
    virtual double muTHUttHtautau(const double sqrt_s) const;
    virtual double muTHUggHbb(const double sqrt_s) const;
    virtual double muTHUVBFHbb(const double sqrt_s) const;
    virtual double muTHUZHbb(const double sqrt_s) const;
    virtual double muTHUWHbb(const double sqrt_s) const;
    virtual double muTHUVHbb(const double sqrt_s) const;
    virtual double muTHUttHbb(const double sqrt_s) const;
    
    virtual double muTHUVBFBRinv(const double sqrt_s) const;
    virtual double muTHUVBFHinv(const double sqrt_s) const;
    virtual double muTHUVHBRinv(const double sqrt_s) const;
    virtual double muTHUVHinv(const double sqrt_s) const;
    
    virtual double muTHUggHZZ4mu(const double sqrt_s) const;    
    virtual double muTHUggHZgamumu(const double sqrt_s) const;    
 
 
    virtual double deltaG_hgg() const;
    virtual double deltaG_hggRatio() const;
    virtual double deltaG1_hWW() const;
    virtual double deltaG2_hWW() const;
    virtual double deltaG3_hWW() const;
    virtual double deltaG1_hZZ() const;
    virtual double deltaG2_hZZ() const;
    virtual double deltaG3_hZZ() const;
    virtual double deltaG1_hZA() const;
    virtual double deltaG1_hZARatio() const;
    virtual double deltaG2_hZA() const;
    virtual double deltaG_hAA() const;
    virtual double deltaG_hAARatio() const;
    // no generation mixing
    virtual gslpp::complex deltaG_hff(const Particle p) const;   
   
    
    virtual double kappamueff() const;
    
    virtual double kappataueff() const;
    
    virtual double kappaceff() const;
    
    virtual double kappabeff() const;
    
    virtual double kappaGeff() const;
    
    virtual double kappaZeff() const;
    
    virtual double kappaWeff() const;
    
    virtual double kappaAeff() const;
    
    virtual double kappaZAeff() const;
 
protected:
 
    virtual void setParameter(const std::string name, const double& value);
 
    virtual double computeKg() const;
 
    virtual double computeKW() const;
 
    virtual double computeKZ() const;
 
    virtual double computeKZga() const;
 
    virtual double computeKgaga() const;
    
    virtual double computeKe() const;
    
    virtual double computeKmu() const;
 
    virtual double computeKtau() const;
    
    virtual double computeKu() const;
 
    virtual double computeKc() const;
 
    virtual double computeKt() const;
    
    virtual double computeKd() const;
    
    virtual double computeKs() const;
 
    virtual double computeKb() const;
    
    virtual double computeKgLoop() const;
    
    virtual double computeKZgaLoop() const;
 
    virtual double computeKgagaLoop() const;
 
private:
    gslpp::complex f_func(const double x) const;
    gslpp::complex g_func(const double x) const;
    gslpp::complex Int1(const double tau, const double lambda) const;
    gslpp::complex Int2(const double tau, const double lambda) const;
 
    // Model parameters    
    double Kw; 
    double Kz; 
    double Kg; 
    double Kga; 
    double Kzga; 
    double Ku; 
    double Kc; 
    double Kt; 
    double Kd; 
    double Ks; 
    double Kb; 
    double Ke; 
    double Kmu; 
    double Ktau; 
    double KH; 
    double BrHinv; 
    double BrHexo; 
// The intrinsic and parametric theory relative errors in the Higgs observables.
    double eggFint; 
    double eggFpar; 
    double ettHint; 
    double ettHpar; 
    double eVBFint; 
    double eVBFpar; 
    double eWHint; 
    double eWHpar; 
    double eZHint; 
    double eZHpar; 
    double eeeWBFint; 
    double eeeWBFpar; 
    double eeeZHint; 
    double eeeZHpar; 
    double eeettHint; 
    double eeettHpar; 
    double eepWBFint; 
    double eepWBFpar; 
    double eepZBFint; 
    double eepZBFpar; 
    double eHggint; 
    double eHggpar; 
    double eHWWint; 
    double eHWWpar; 
    double eHZZint; 
    double eHZZpar; 
    double eHZgaint; 
    double eHZgapar; 
    double eHgagaint; 
    double eHgagapar; 
    double eHmumuint; 
    double eHmumupar; 
    double eHtautauint; 
    double eHtautaupar; 
    double eHccint; 
    double eHccpar; 
    double eHbbint; 
    double eHbbpar; 
    
    double eggFHgaga,eggFHZga,eggFHZZ,eggFHWW,eggFHtautau,eggFHbb,eggFHmumu; 
    double eVBFHgaga,eVBFHZga,eVBFHZZ,eVBFHWW,eVBFHtautau,eVBFHbb,eVBFHmumu; 
    double eWHgaga,eWHZga,eWHZZ,eWHWW,eWHtautau,eWHbb,eWHmumu; 
    double eZHgaga,eZHZga,eZHZZ,eZHWW,eZHtautau,eZHbb,eZHmumu; 
    double ettHgaga,ettHZga,ettHZZ,ettHWW,ettHtautau,ettHbb,ettHmumu; 
    double eVBFHinv,eVHinv; 
    
    double eHwidth; 
    
    // Cache variables
    double GammaHTotR;
    double GammaHTotSMR;
    
    double GammaHTotnoER;
    double GammaHTotSMnoER;
    
    // Flags    
    bool FlagKiLoop; 
    bool FlagCustodial; 
    bool FlagUniversalKf; 
    bool FlagUniversalK; 
    bool FlagUseKH; 
    
};
 
#endif  /* HIGGSKIGEN_H */