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, 
        B_D, 
        B_P, 
        B_S, 
        B_C, 
        PHI, 
        K_star, 
        K_star_P, 
        D_star_P, 
        RHO, 
        RHO_P, 
        OMEGA, 
        MESON_END 
    };
    
    static const int NQCDvars = 11; 
 
    static std::string QCDvars[NQCDvars];
 
    QCD();
    
    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;
    
    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
 
    double getNc() const
    {
        return Nc;
    }
 
    void setNc(double Nc)
    {
        this->Nc = Nc;
    }
 
    Meson getMesons(const QCD::meson m) const
    {
        return mesonsMap.at(m);
    }
 
    Particle getQuarks(const QCD::quark q) const
    {
        return quarks[q];
    }
 
    double getAlsM() const
    {
        return AlsM;
    }
 
    double getMAls() const
    {
        return MAls;
    }
 
    double getMut() const
    {
        return mut;
    }
 
    double getMub() const
    {
        return mub;
    }
 
    double getMuc() const
    {
        return muc;
    }
 
    double getMtpole() const
    {
        return mtpole;
    }
 
    double getCF() const
    {
        return CF;
    }
 
    BParameter getBBd() const
    {
        return BParameterMap.at("BBd");
    }
 
    BParameter getBBs() const
    {
        return BParameterMap.at("BBs");
    }
 
    BParameter getBD() const
    {
        return BParameterMap.at("BD");
    }
 
    BParameter getBK() const
    {
        return BParameterMap.at("BK");
    }
 
    BParameter getBKd1() const
    {
        return BParameterMap.at("BKd1");
    }
 
    BParameter getBKd3() const
    {
        return BParameterMap.at("BKd3");
    }
 
    
 
    double Thresholds(const int i) const;
    
    double AboveTh(const double mu) const;
 
    double BelowTh(const double mu) const;
 
    double Nf(const double mu) const;
 
    double NfThresholdCorrections(double mu, double M, double als, int nf, orders order) const;
    
    orders FullOrder(orders order) const;
    
 
    double Beta0(const double nf) const;
 
    double Beta1(const double nf) const;
 
    double Beta2(const double nf) const;
 
    double Beta3(const double nf) const;
 
    double AlsWithInit(const double mu, const double alsi, const double mu_i,
            const orders order) const;
 
    double AlsWithLambda(const double mu, const orders order) const;
 
    double AlsOLD(const double mu, const orders order = FULLNLO) const;
    virtual double Als(const double mu, const orders order = FULLNLO, bool Nf_thr = true) const;
    virtual double AlsByOrder(const double mu, const orders order = FULLNLO, bool Nf_thr = true) const;
 
    double logLambda(const double nf, orders order) const;
 
    double Als4(const double mu) const;
 
    double Mrun4(const double mu_f, const double mu_i, const double m) const;
 
 
    double Gamma0(const double nf) const;
 
    double Gamma1(const double nf) const;
 
    double Gamma2(const double nf) const;
 
    double Mrun(const double mu, const double m, const orders order = FULLNNLO) const;
 
    double Mrun(const double mu_f, const double mu_i, const double m,
            const orders order = FULLNNLO) const;
 
 
    double Mbar2Mp(const double mbar, const orders order = FULLNNLO) const;
 
    double Mp2Mbar(const double mp, const orders order = FULLNNLO) const;
 
    double MS2DRqmass(const double MSscale, const double MSbar) const;
 
    double MS2DRqmass(const double MSbar) const;
 
 
    void CacheShift(double cache[][5], int n) const;
    void CacheShift(int cache[][5], int n) const;
 
 
protected:
 
    virtual void setParameter(const std::string name, const double& value);
 
    double MassOfNf(int nf) const;
 
    bool computemt; 
    bool requireYu; 
    bool requireYd; 
 
    // 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[10][CacheSize]; 
    mutable double mp2mbar_cache[5][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;
 
    double AlsWithLambda(const double mu, const double logLambda, const orders order) const;
 
    double ZeroNf6NLO(double *logLambda6, double *logLambda5_in) const;
 
    double ZeroNf5(double *logLambda5, double *order) const;
 
    double ZeroNf4NLO(double *logLambda4, double *logLambda5_in) const;
 
    double ZeroNf3NLO(double *logLambda3, double *logLambda4_in) const;
 
    double logLambda5(orders order) const;
 
    double logLambdaNLO(const double nfNEW, const double nfORG, const double logLambdaORG) const;
 
    double logLambda(const double muMatching, const double mf,
            const double nfNEW, const double nfORG,
            const double logLambdaORG, orders order) const;
 
    double threCorrForMass(const double nf_f, const double nf_i) const;
 
    double MrunTMP(const double mu_f, const double mu_i, const double m, const orders order) const;
 
    double Mp2MbarTMP(double *mu, double *params) const;
};
 
#endif  /* QCD_H */