QTilde/Couplings/ShowerAlphaQCD.h

0001 // -*- C++ -*-
0002 //
0003 // ShowerAlphaQCD.h is a part of Herwig - A multi-purpose Monte Carlo event generator
0004 // Copyright (C) 2002-2019 The Herwig Collaboration
0005 //
0006 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
0007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
0008 //
0009 #ifndef HERWIG_ShowerAlphaQCD_H
0010 #define HERWIG_ShowerAlphaQCD_H
0011 //
0012 // This is the declaration of the ShowerAlphaQCD class.
0013 //
0014
0015 #include "Herwig/Shower/ShowerAlpha.h"
0016
0017 namespace Herwig {
0018
0019 using namespace ThePEG;
0020
0021 /** \ingroup Shower
0022  *
0023  *  This concrete class provides the definition of the
0024  *  pure virtual function value() and overestimateValue() for the
0025  *  strong coupling.
0026  *
0027  *  A  number of different options for the running of the coupling
0028  *  and its initial definition are supported.
0029  *
0030  * @see \ref ShowerAlphaQCDInterfaces "The interfaces"
0031  * defined for ShowerAlphaQCD.
0032  */
0033 class ShowerAlphaQCD: public ShowerAlpha {
0034
0035 public:
0036
0037   /**
0038    * The default constructor.
0039    */
0040   ShowerAlphaQCD() : ShowerAlpha(),
0041              _qmin(0.630882*GeV), _asType(1), _asMaxNP(1.0),
0042              _thresholds(4), _lambda(4),
0043              _nloop(3),_thresopt(false),
0044              _alphain(0.118),_tolerance(1e-10),
0045              _maxtry(100),_alphamin(0.),_val0(1.), _optInputScale(91.1876_GeV) {}
0046
0047 public:
0048
0049   /**
0050    *  Methods to return the coupling
0051    */
0052   //@{
0053   /**
0054    * It returns the running coupling value evaluated at the input scale
0055    * multiplied by the scale factor scaleFactor().
0056    * @param scale The scale
0057    * @return The coupling
0058    */
0059   virtual double value(const Energy2 scale) const;
0060
0061   /**
0062    * It returns the running coupling value evaluated at the input scale
0063    * multiplied by the scale factor scaleFactor().
0064    */
0065   virtual double overestimateValue() const;
0066
0067   /**
0068    *  Return the ratio of the coupling at the scale to the overestimated value
0069    */
0070   virtual double ratio(const Energy2 scale,double factor =1.) const;
0071
0072   /**
0073    * Initialize this coupling.
0074    */
0075   virtual void initialize() { doinit(); }
0076
0077   /**
0078    * A command to initialize the coupling and write
0079    * its value at the scale given by the argument (in GeV)
0080    */
0081   string value(string);
0082
0083   /**
0084    * Match thresholds and write alpha_s
0085    * specified file; arguments are
0086    * Q_low/GeV Q_high/GeV n_steps filename
0087   */
0088   string check(string args);
0089
0090   //@}
0091
0092   /**
0093    *  Get the value of \f$\Lambda_{\rm QCd}\f$
0094    *  @param nf number of flavours
0095    */
0096   Energy lambdaQCD(unsigned int nf) {
0097     if      (nf <= 3)        return _lambda[0];
0098     else if (nf==4 || nf==5) return _lambda[nf-3];
0099     else                     return _lambda[3];
0100   }
0101
0102   /**
0103    * Return the quark masses to be used; if not empty these masses
0104    * should be considered instead of the ones set in the particle data
0105    * objects.
0106    */
0107   const vector<Energy>& quarkMasses() const { return _quarkMasses; }
0108
0109 public:
0110
0111   /** @name Functions used by the persistent I/O system. */
0112   //@{
0113   /**
0114    * Function used to write out object persistently.
0115    * @param os the persistent output stream written to.
0116    */
0117   void persistentOutput(PersistentOStream & os) const;
0118
0119   /**
0120    * Function used to read in object persistently.
0121    * @param is the persistent input stream read from.
0122    * @param version the version number of the object when written.
0123    */
0124   void persistentInput(PersistentIStream & is, int version);
0125   //@}
0126
0127   /**
0128    * The standard Init function used to initialize the interfaces.
0129    * Called exactly once for each class by the class description system
0130    * before the main function starts or
0131    * when this class is dynamically loaded.
0132    */
0133   static void Init();
0134
0135 protected:
0136
0137   /** @name Clone Methods. */
0138   //@{
0139   /**
0140    * Make a simple clone of this object.
0141    * @return a pointer to the new object.
0142    */
0143   virtual IBPtr clone() const;
0144
0145   /** Make a clone of this object, possibly modifying the cloned object
0146    * to make it sane.
0147    * @return a pointer to the new object.
0148    */
0149   virtual IBPtr fullclone() const;
0150   //@}
0151
0152
0153 protected:
0154
0155   /** @name Standard Interfaced functions. */
0156   //@{
0157   /**
0158    * Initialize this object after the setup phase before saving an
0159    * EventGenerator to disk.
0160    * @throws InitException if object could not be initialized properly.
0161    */
0162   virtual void doinit();
0163   //@}
0164
0165 private:
0166
0167   /**
0168    *  Member functions which calculate the coupling
0169    */
0170   //@{
0171   /**
0172    * Compute the value of \f$Lambda\f$ needed to get the input value of
0173    * the strong coupling at the scale given for the given number of flavours
0174    * using the Newton-Raphson method
0175    * @param match The scale for the coupling
0176    * @param alpha The input coupling
0177    * @param nflav The number of flavours
0178    */
0179   Energy computeLambda(Energy match, double alpha, unsigned int nflav) const;
0180
0181   /**
0182    * Return the value of \f$\Lambda\f$ and the number of flavours at the scale.
0183    * @param q The scale
0184    * @return The number of flavours at the scale and \f$\Lambda\f$.
0185    */
0186   pair<short, Energy> getLamNfTwoLoop(Energy q) const;
0187   //@}
0188
0189 private:
0190
0191   /**
0192    * The assignment operator is private and must never be called.
0193    * In fact, it should not even be implemented.
0194    */
0195   ShowerAlphaQCD & operator=(const ShowerAlphaQCD &) = delete;
0196
0197 private:
0198
0199   /**
0200    *  Minimum value of the scale
0201    */
0202   Energy _qmin;
0203
0204   /**
0205    *  Parameter controlling the behaviour of \f$\alpha_S\f$ in the
0206    *  non-perturbative region.
0207    */
0208   int _asType;
0209
0210   /**
0211    *  Another parameter, a possible (maximum) value of alpha in the
0212    *  non-perturbative region.
0213    */
0214   double _asMaxNP;
0215
0216   /**
0217    *  Thresholds for the different number of flavours
0218    */
0219   vector<Energy> _thresholds;
0220
0221   /**
0222    *  \f$\Lambda\f$ for the different number of flavours
0223    */
0224   vector<Energy> _lambda;
0225
0226   /**
0227    *  Option for the number of loops
0228    */
0229   unsigned int _nloop;
0230
0231   /**
0232    *  Option for the threshold masses
0233    */
0234   bool _thresopt;
0235
0236   /**
0237    *  Input value of \f$alpha_S(M_Z)\f$
0238    */
0239   double _alphain;
0240
0241   /**
0242    *  Tolerance for discontinuities at the thresholds
0243    */
0244   double _tolerance;
0245
0246   /**
0247    *  Maximum number of iterations for the Newton-Raphson method to converge
0248    */
0249   unsigned int _maxtry;
0250
0251   /**
0252    *  The minimum value of the coupling
0253    */
0254   double _alphamin;
0255
0256   /**
0257    *  Value of \f$\alpha_S\f$ at the minimum scale
0258    */
0259   double _val0;
0260
0261   /**
0262    * An optional input scale to be used for the input alphas; if zero MZ will
0263    * be used out of the particle data object.
0264    */
0265   Energy _optInputScale;
0266
0267   /**
0268    * The quark masses to be used; if not empty these masses should be
0269    * considered instead of the ones set in the particle data objects.
0270    */
0271   vector<Energy> _quarkMasses;
0272 };
0273
0274 }
0275
0276 #endif /* HERWIG_ShowerAlphaQCD_H */