QCD.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef QCD_H
#define QCD_H
 
#include "Model.h"
#include "Meson.h"
#include "BParameter.h"
#include "OrderScheme.h"
#define MEPS 1.e-10 // mass precision
 
class QCD : public Model {
public:
 
    enum lepton {
        NEUTRINO_1, 
        ELECTRON, 
        NEUTRINO_2, 
        MU, 
        NEUTRINO_3, 
        TAU, 
        NOLEPTON  
    };
 
    enum quark {
        UP, 
        DOWN, 
        CHARM, 
        STRANGE, 
        TOP, 
        BOTTOM 
    };
 
 
    enum meson {
        P_0, 
        P_P, 
        K_0, 
        K_P, 
        D_0, 
        D_P, 
        D_S, 
        B_D, 
        B_P, 
        B_S, 
        B_C, 
        PHI, 
        K_star, 
        K_star_P, 
        K_S, 
        D_star_P, 
        RHO, 
        RHO_P, 
        OMEGA, 
        MESON_END 
    };
 
    static const int NQCDvars = 11; 
 
    static std::string QCDvars[NQCDvars];
 
    QCD();
 
    const std::string orderToString(const orders order) const;
 
    // Parameters
 
    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);
 
    void addParameters(std::vector<std::string> params_i);
 
    void initializeBParameter(std::string name_i) const;
 
    void initializeMeson(QCD::meson meson_i) const;
 
    const double getOptionalParameter(std::string name) const
    {
        return optionalParameters.at(name);
    }
 
    void setOptionalParameter(std::string name, double value)
    {
        optionalParameters[name] = value;
    }
 
    std::vector<std::string> getUnknownParameters()
    {
        return unknownParameters;
    }
 
    // Flags
 
    virtual bool setFlag(const std::string name, const bool value);
 
    virtual bool setFlagStr(const std::string name, const std::string value);
 
    virtual bool CheckFlags() const;
 
 
    // get and set methods for class members
 
    const double getNc() const
    {
        return Nc;
    }
 
    void setNc(double Nc)
    {
        this->Nc = Nc;
    }
 
    const Meson& getMesons(const QCD::meson m) const
    {
        return mesonsMap.at(m);
    }
 
    const Particle& getQuarks(const QCD::quark q) const
    {
        return quarks[q];
    }
 
    void setQuarkMass(const quark q, const double mass)
    {
        quarks[q].setMass(mass);
    }
 
    const double getAlsM() const
    {
        return AlsM;
    }
 
    const double getMAls() const
    {
        return MAls;
    }
 
    const double getMut() const
    {
        return mut;
    }
 
    const double getMub() const
    {
        return mub;
    }
 
    const double getMuc() const
    {
        return muc;
    }
 
    const double getMtpole() const
    {
        return mtpole;
    }
 
    void setMtpole(double mtpole_in)
    {
        mtpole = mtpole_in;
    }
 
    const double getCF() const
    {
        return CF;
    }
 
    const BParameter& getBBd() const
    {
        return BParameterMap.at("BBd");
    }
 
    const BParameter& getBBs() const
    {
        return BParameterMap.at("BBs");
    }
    
    const BParameter& getBBd_subleading() const
    {
        return BParameterMap.at("BBd_subleading");
    }  
    
    const BParameter& getBBs_subleading() const
    {
        return BParameterMap.at("BBs_subleading");
    }    
 
    const BParameter& getBD() const
    {
        return BParameterMap.at("BD");
    }
 
    const BParameter& getBK() const
    {
        return BParameterMap.at("BK");
    }
 
    const BParameter& getBKd1() const
    {
        return BParameterMap.at("BKd1");
    }
 
    const BParameter& getBKd3() const
    {
        return BParameterMap.at("BKd3");
    }
 
 
 
    const double Thresholds(const int i) const;
 
    const double AboveTh(const double mu) const;
 
    const double BelowTh(const double mu) const;
 
    const double Nf(const double mu) const;
 
    const double NfThresholdCorrections(double mu, double M, double als, int nf, orders order) const;
 
    const orders FullOrder(orders order) const;
 
 
    const double Beta0(const double nf) const;
 
    const double Beta1(const double nf) const;
 
    const double Beta2(const double nf) const;
 
    const double Beta3(const double nf) const;
 
    const double AlsWithInit(const double mu, const double alsi, const double mu_i, const int nf,
            const orders order) const;
 
    const double AlsWithLambda(const double mu, const orders order) const;
 
    const double AlsOLD(const double mu, const orders order = FULLNLO) const;
    const double Als(const double mu, const orders order = FULLNLO, const bool Nf_thr = true) const;
 
    const double Als(const double mu, const int Nf_in, const orders order = FULLNLO) const;
 
    const double AlsByOrder(const double mu, const orders order = FULLNLO, bool Nf_thr = true) const;
    const double AlsByOrder(const double mu, const int Nf_in, const orders order = FULLNLO) const;
 
    const double logLambda(const double nf, orders order) const;
 
    const double Als4(const double mu) const;
 
    const double Mrun4(const double mu_f, const double mu_i, const double m) const;
 
 
    const double Gamma0(const double nf) const;
 
    const double Gamma1(const double nf) const;
 
    const double Gamma2(const double nf) const;
 
    const double Mrun(const double mu, const double m, const quark q, const orders order = FULLNNLO) const;
 
    const double Mrun(const double mu_f, const double mu_i, const double m, const quark q,
            const orders order = FULLNNLO) const;
 
 
    const double Mbar2Mp(const double mbar, const quark q, const orders order = FULLNNLO) const;
 
    const double Mp2Mbar(const double mp, const quark q, orders order = FULLNNLO) const;
 
    const double Mofmu2Mbar(const double m, const double mu, const quark q) const;
 
    const double MS2DRqmass(const double MSscale, const double MSbar) const;
 
    const double MS2DRqmass(const double MSbar) const;
 
 
    void CacheShift(double cache[][5], int n) const;
    void CacheShift(int cache[][5], int n) const;
 
    bool isQCDsuccess() const
    {
        return QCDsuccess;
    }
 
    void setComputemt(bool computemt)
    {
        this->computemt = computemt;
    }
 
protected:
 
    mutable bool QCDsuccess=true; // A flag to check if the current calculation is successful
 
    virtual void setParameter(const std::string name, const double& value);
 
    const double MassOfNf(int nf) const;
    
    bool computemt; 
    bool requireYu; 
    bool requireYd; 
    bool FlagMtPole; 
    bool FlagMpole2MbarNumeric; 
 
    // model parameters
    double AlsM; 
    double MAls; 
    double mtpole; 
    double mut; 
    double mub; 
    double muc; 
 
    double Nc; 
    double TF,CA,CF,dFdF_NA,dAdA_NA,dFdA_NA,NA; //SU(N)-related quantities
    Particle quarks[6]; 
 
private:
    mutable std::map<std::string, BParameter> BParameterMap;
 
    double zeta2; 
    double zeta3; 
    mutable bool computeFBd; 
    mutable bool computeFBp; 
    mutable bool computeBd; 
    mutable bool computeBs; 
    static const int CacheSize = 5; 
    mutable double als_cache[9][CacheSize]; 
    mutable double logLambda5_cache[4][CacheSize];
    mutable double logLambdaNLO_cache[9][CacheSize];
    mutable double mrun_cache[11][CacheSize]; 
    mutable double mp2mbar_cache[6][CacheSize]; 
    bool unknownParameterWarning; 
    std::map<std::string, double> optionalParameters; 
    std::vector<std::string> unknownParameters; 
    mutable std::map<const QCD::meson, Meson> mesonsMap;
    bool FlagCsi; 
    mutable orders realorder;
 
    const double Mp2Mbar_pole(const double mp, const orders order = FULLNNLO) const;
 
    const double Mp2Mbar_bar(const double mp, const quark q, const orders order = FULLNNLO) const;
 
    double DeltaMass(double x) const;
 
    const double AlsWithLambda(const double mu, const double logLambda, const orders order) const;
 
    const double ZeroNf6NLO(double *logLambda6, double *logLambda5_in) const;
 
    const double ZeroNf5(double *logLambda5, double *order) const;
 
    const double ZeroNf4NLO(double *logLambda4, double *logLambda5_in) const;
 
    const double ZeroNf3NLO(double *logLambda3, double *logLambda4_in) const;
 
    const double logLambda5(orders order) const;
 
    const double logLambdaNLO(const double nfNEW, const double nfORG, const double logLambdaORG) const;
 
    const double logLambda(const double muMatching, const double mf,
            const double nfNEW, const double nfORG,
            const double logLambdaORG, orders order) const;
 
    const double threCorrForMass(const double nf_f, const double nf_i) const;
 
    const double MrunTMP(const double mu_f, const double mu_i, const double m, const int nf, const orders order) const;
 
    const double Mp2MbarTMP(double *mu, double *params) const;
    
    const double Mofmu2MbarTMP(double *mu, double *params) const;
};
 
#endif  /* QCD_H */