MODEL/Main/Running_AlphaS.H

0001 #ifndef MODEL_Main_Running_AlphaS_H
0002 #define MODEL_Main_Running_AlphaS_H
0003
0004 #include "ATOOLS/Phys/Flavour.H"
0005 #include "ATOOLS/Math/Function_Base.H"
0006 #include "PDF/Main/ISR_Handler.H"
0007
0008 #include <vector>
0009 #include <algorithm>
0010
0011 namespace PDF { class PDF_Base; }
0012
0013 namespace MODEL {
0014
0015   //! Contains data for alpha_S running up to 3rd order
0016   struct AsDataSet {
0017     double low_scale, high_scale;
0018     double as_low, as_high;
0019     int nf;
0020     double lambda2;
0021     double b[4];
0022     double beta0;
0023   };
0024   //! coefficients of the Beta functions for QCD
0025   // cf. T. van Ritbergen, J. Vermaseren, S. Larin PLB 400 (1997) 379
0026   // up to factor 4^(i+1)
0027
0028   class One_Running_AlphaS {
0029   protected:
0030
0031     int         m_order,m_pdf;
0032     int         m_nthresholds,m_mzset;
0033     double      m_CF,m_CA,m_TR;
0034     double      m_as_MZ,m_m2_MZ;
0035     double      m_cutq2,m_cutas;
0036
0037     AsDataSet     * p_thresh;
0038     PDF::PDF_Base * p_pdf;
0039
0040     double Beta0(const int);
0041     double Beta1(const int);
0042     double Beta2(const int);
0043     double Beta3(const int);
0044     double Lambda2(const int);
0045     double ZetaOS2(const double,const double,const double,const int);
0046     double InvZetaOS2(const double,const double,const double,const int);
0047     double AlphaSLam(const double,const int);
0048     void   ContinueAlphaS(int &);
0049     void   PrintSummary();
0050
0051   public:
0052
0053     One_Running_AlphaS(PDF::PDF_Base *const pdf,
0054                        const double as_MZ = 0.0,const double m2_MZ = 0.0,
0055                        const int order = 0, const int thmode = 1);
0056
0057     ~One_Running_AlphaS();
0058
0059     inline int    Order()                { return m_order;       }
0060     inline double Beta0(const double q2) { return Beta0(Nf(q2)); }
0061     inline double Beta1(const double q2) { return Beta1(Nf(q2)); }
0062     inline double Beta2(const double q2) { return Beta2(Nf(q2)); }
0063     inline double Beta3(const double q2) { return Beta3(Nf(q2)); }
0064     inline double AsMZ()                 { return m_as_MZ;       }
0065     inline PDF::PDF_Base * PDF()         { return p_pdf;         }
0066
0067     inline double CA() const { return m_CA; }
0068     inline double CF() const { return m_CF; }
0069     inline double TR() const { return m_TR; }
0070
0071     int    Nf(const double q2);
0072     std::vector<double> Thresholds(double q12,double q22);
0073
0074     inline double CutQ2()                { return m_cutq2;       }
0075
0076     inline double BoundedAlphaS(const double &q2)
0077     { return (*this)(std::max(q2, CutQ2())); }
0078
0079     double operator()(double q2);
0080     double AlphaS(const double q2);
0081   };
0082
0083
0084   class Running_AlphaS : public ATOOLS::Function_Base {
0085
0086   protected:
0087
0088     typedef std::map<PDF::isr::id, One_Running_AlphaS*> AlphasMap;
0089     AlphasMap m_alphas;
0090     One_Running_AlphaS * p_active;
0091     PDF::PDF_Base * p_overridingpdf;
0092
0093     void RegisterDefaults() const;
0094
0095     // construct PDFs that are only used for their AlphaS info and values
0096     void InitOverridingPDF(const std::string name, const int member);
0097
0098   public:
0099
0100     //! construct a wrapper over One_Running_AlphaS instances, one for each ISR handlers
0101     Running_AlphaS(const double as_MZ,const double m2_MZ,
0102                    const int order, const int thmode,
0103                    const PDF::ISR_Handler_Map& isr);
0104
0105     /*!
0106      * Construct a wrapper for a single One_Running_AlphaS instance, corresponding to the PDF.
0107      *
0108      * This is used for reweighting purposes.
0109      */
0110     Running_AlphaS(const std::string pdfname, const int member = 0,
0111                    const double as_MZ = 0.0,const double m2_MZ = 0.0,
0112                    const int order = 0, const int thmode = 1);
0113     Running_AlphaS(PDF::PDF_Base *const pdf,
0114                    const double as_MZ = 0.0,const double m2_MZ = 0.0,
0115                    const int order = 0, const int thmode = 1);
0116     Running_AlphaS(const double as_MZ = 0.0,const double m2_MZ = 0.0,
0117                    const int order = 0, const int thmode = 1);
0118
0119     ~Running_AlphaS();
0120
0121     // member functions
0122     void SetActiveAs(PDF::isr::id id);
0123     One_Running_AlphaS * GetAs() { return p_active; }
0124     One_Running_AlphaS * GetAs(PDF::isr::id id);
0125
0126     // proxy member functions
0127     inline double operator()(double q2)   { return p_active->operator()(q2); }
0128     inline double AlphaS(const double q2) { return p_active->AlphaS(q2); }
0129     inline int    Order()                 { return p_active->Order(); }
0130     inline double Beta0(const double q2)  { return p_active->Beta0(q2); }
0131     inline double Beta1(const double q2)  { return p_active->Beta1(q2); }
0132     inline double Beta2(const double q2)  { return p_active->Beta2(q2); }
0133     inline double Beta3(const double q2)  { return p_active->Beta3(q2); }
0134     inline double AsMZ()                  { return p_active->AsMZ(); }
0135     inline double CA() const              { return p_active->CA(); }
0136     inline double CF() const              { return p_active->CF(); }
0137     inline double TR() const              { return p_active->TR(); }
0138     inline int    Nf(const double q2)     { return p_active->Nf(q2); }
0139     inline std::vector<double> Thresholds(double q12,double q22)
0140                                           { return p_active->Thresholds(q12,q22); }
0141     inline double CutQ2()                 { return p_active->CutQ2(); }
0142     inline double BoundedAlphaS(const double &q2)
0143                                           { return p_active->BoundedAlphaS(q2); }
0144   };
0145
0146   extern Running_AlphaS * as;
0147
0148   //! QCD SM Running of AlphaS
0149   /*!
0150     \class Running_AlphaS
0151     \brief The class for the (running) strong coupling constant.
0152
0153     This is an implementation of the
0154     <A HREF="http://131.169.91.193/cgi-bin/spiface/find/hep/www?rawcmd=f+eprint+hep-ph%2F9706430">
0155     strong coupling constant by K.~G.~Chetyrkin, B.~A.~Kniehl and M.~Steinhauser</A>
0156
0157     The following points should be noted:
0158     - At the moment the running at up to three loops is tested, the four loop
0159       running remains to be checked.
0160     - Thresholds are fixed to the onshell masses of the correspondig quark.
0161     - In order to avoid the Landau Pole, the running is bounded by one or another specified value.
0162   */
0163   /*!
0164     \var One_Running_AlphaS::m_order
0165     The order at which running \f$alpha_s\f$ is evaluated, e.g. m_order = 0 refers to one-loop,
0166     m_order = 3 then signifies four-loop running.
0167   */
0168   /*!
0169     \var One_Running_AlphaS::m_nthresholds
0170     The number of thresholds, i.e. of quarks. Later on, other particles should be implmented as well,
0171     at least at one-loop order. The only exception is the Z boson which is inserted as well -
0172     this is due to the fact that in SHERPA \f$\alpha_s\f$ at the Z-pole is used as defining
0173     parameter.
0174   */
0175   /*!
0176     \var One_Running_AlphaS::m_mzset
0177     The place of the Z-pole in the list of thresholds.
0178   */
0179   /*!
0180     \var One_Running_AlphaS::m_m2_MZ
0181     The mass squared of the Z-boson.
0182   */
0183   /*!
0184     \var One_Running_AlphaS::m_as_MZ
0185     \f$\alpha_s\f$ at the Z-pole.
0186   */
0187   /*!
0188     \var One_Running_AlphaS::m_CF
0189     The Casimir operator of QCD in the fundamental representation, \f$C_F=4/3\f$.
0190   */
0191   /*!
0192     \var One_Running_AlphaS::m_CA
0193     The Casimir operator of QCD in the adjoint representation, \f$C_A=3\f$.
0194   */
0195   /*!
0196     \var One_Running_AlphaS::p_thresh
0197     Values of \f$\alpha_{s}\f$ and the \f[\beta_i\f] at the various thresholds.
0198   */
0199   /*!
0200     \fn double Running_AlphaS::Beta0(const double)
0201     Returns \f[\beta_0\f] at a given scale.
0202   */
0203   /*!
0204     \fn double Running_AlphaS::Beta0(const int)
0205     Returns \f[\beta_0 = (33 - 2n_f)/12\f] for a given number of active flavours.
0206   */
0207   /*!
0208     \fn double Running_AlphaS::Beta1(const int)
0209     Returns \f[\beta_1 = (306 - 38n_f)/48\f] for a given number of active flavours.
0210   */
0211   /*!
0212     \fn double Running_AlphaS::Beta2(const int)
0213     Returns \f[\beta_2 = (2857/2 - 5033/18n_f + 325/54n_f^2)/64\f] for a given number of active flavours.
0214   */
0215   /*!
0216     \fn double Running_AlphaS::Beta3(const int)
0217     Returns \f[\beta_3 = \left[ (149753/6 + 3564\zeta(3)) -
0218                         (1078361/162 + 6508/27\zeta(3))n_f +
0219                         (50065/162 + 6472/81\zeta(3))n_f^2 +
0220                         (1093/729)n_f^3\right]/256\f] for a given number of active flavours.
0221   */
0222   /*!
0223     \fn One_Running_AlphaS::Lambda2(const int)
0224     Fills in the b-coefficients, \f[b_{1,2,3} = \beta_{1,2,3}/\beta_0\,,\f]
0225     and caluclates a suitable \f$\Lambda_{\rm QCD}^2\f$ which is then returned.
0226   */
0227   /*!
0228     \fn One_Running_AlphaS::ZetaOS2(const double,const double,const double,const int)
0229     \todo Documentation for this method.
0230   */
0231   /*!
0232     \fn One_Running_AlphaS::InvZetaOS2(const double,const double,const double,const int)
0233     \todo Documentation for this method.
0234   */
0235   /*!
0236     \fn One_Running_AlphaS::AlphaSLam(const double,const int)
0237     \todo Documentation for this method.
0238   */
0239   /*!
0240     \fn One_Running_AlphaS::ContinueAlphaS(int &)
0241     \todo Documentation for this method.
0242   */
0243   /*!
0244     \fn One_Running_AlphaS::One_Running_AlphaS(double,double)
0245     The constructor of Running_AlphaS fills in and sorts the thresholds according to their mass.
0246     \todo Documentation for this method.
0247   */
0248   /*!
0249     \fn Running_AlphaS::~Running_AlphaS()
0250     \todo Documentation for this method.
0251   */
0252   /*!
0253     \fn double Running_AlphaS::operator()(double)
0254     Returns the runnnig \f$alpha_s\f$ at a given scale.
0255   */
0256   /*!
0257     \fn double Running_AlphaS::AlphaS(const double)
0258     Returns the value of the Running_AlphaS::operator()(double).
0259   */
0260   /*!
0261     \fn int Running_AlphaS::Nf(const double)
0262     Returns the number of active flavours at a given scale.
0263   */
0264 }
0265
0266
0267
0268 #endif