include/apfel/matchedevolution.h

0001 //
0002 // APFEL++ 2017
0003 //
0004 // Author: Valerio Bertone: valerio.bertone@cern.ch
0005 //
0006
0007 #pragma once
0008
0009 #include <cmath>
0010 #include <vector>
0011
0012 namespace apfel
0013 {
0014   /**
0015    * @brief The MatchedEvolution class is a template mother class for
0016    * the computation of the running of a generic quantity in a
0017    * VFNS. It provides the basic ingredients for the computation and
0018    * the heavy-quark threshold matching of the running of a given
0019    * object.
0020    */
0021   template<class T>
0022   class MatchedEvolution
0023   {
0024   public:
0025     MatchedEvolution() = delete;
0026
0027     virtual ~MatchedEvolution() = default;
0028
0029     /**
0030      * @brief The MatchedEvolution constructor.
0031      * @param ObjRef: the reference object
0032      * @param MuRef: the reference scale
0033      * @param Thresholds: vector with the heavy quark threholds
0034      * @param nsteps: number of steps of the ODE solver (default: 10)
0035      */
0036     MatchedEvolution(T                   const& ObjRef,
0037                      double              const& MuRef,
0038                      std::vector<double> const& Thresholds,
0039                      int                 const& nsteps = 10);
0040
0041     /**
0042      * @brief Virtual function for the computation of the evolution.
0043      * @param nf: the number of active flavours
0044      * @param t0: the initial value of the scale
0045      * @param t1: the final value of the scale
0046      * @param Obj0: the starting object
0047      * @return the object evolved at the scale mu2
0048      */
0049     virtual T EvolveObject(int const& nf, double const& t0, double const& t1, T const& Obj0) const;
0050
0051     /**
0052      * @brief Pure virtual function for the computation of the matching.
0053      * @param Up: the direction of the matching: "true" = upward, "false" = downward
0054      * @param nf: the number of active flavours
0055      * @param Obj: the object to be matched
0056      * @return the matched object on the other side of the threshold
0057      */
0058     virtual T MatchObject(bool const& Up, int const& nf, T const& Obj) const = 0;
0059
0060     /**
0061      * @brief Pure virtual function for the computation of the r.h.s. of a ODE (the derivative).
0062      * @param nf: the number of active flavours
0063      * @param Mu: the scale at which the derivative is computed
0064      * @param Obj: the object used to compute the derivative
0065      * @return the r.h.s. of the ODE
0066      */
0067     virtual T Derivative(int const& nf, double const& Mu, T const& Obj) const = 0;
0068
0069     /**
0070      * @brief Function that returns the evolved object.
0071      * @param mu: the final scale
0072      * @return the evolved object.
0073      */
0074     T Evaluate(double const& mu) const;
0075
0076     /**
0077      * @name Getters
0078      */
0079     ///@{
0080     /**
0081      * @brief Function that returns the reference value of the object
0082      */
0083     T GetObjectRef() const { return _ObjRef; }
0084
0085     /**
0086      * @brief Function that returns the reference scale
0087      */
0088     double GetMuRef() const { return _MuRef; }
0089
0090     /**
0091      * @brief Function that returns the values of the thresholds.
0092      */
0093     std::vector<double> GetThresholds() const { return _Thresholds; }
0094
0095     /**
0096      * @brief Function that returns the number of steps.
0097      */
0098     int GetNumberOfSteps() const { return _nsteps; }
0099     ///@}
0100
0101     /**
0102      * @name Setters
0103      */
0104     ///@{
0105     /**
0106      * @brief Function that sets the reference value of the object
0107      * @param ObjRef: the reference object
0108      */
0109     void SetObjectRef(T ObjRef) { _ObjRef = std::move(ObjRef); }
0110
0111     /**
0112      * @brief Function that sets the reference scale
0113      * @param MuRef: the reference scale
0114      */
0115     void SetMuRef(double const& MuRef) { _MuRef2 = MuRef * MuRef; _LogMuRef2 = log(_MuRef2); }
0116
0117     /**
0118      * @brief Function that sets the number of steps of the RK algorithm.
0119      * @param nsteps: the number of steps
0120      */
0121     void SetNumberOfSteps(int const& nsteps) { _nsteps = nsteps; }
0122     ///@}
0123   protected:
0124     T                   _ObjRef;         //<! Reference value of the object
0125     double              _MuRef;          //<! Reference scale of the object
0126     double              _MuRef2;         //<! Squared reference scale of the object
0127     double              _LogMuRef2;      //<! Log of the squared reference scale of the object
0128     std::vector<double> _Thresholds;     //<! Values of the thresholds
0129     int                 _nsteps;         //<! Number of steps of the RK algorithm
0130     std::vector<double> _Thresholds2;    //<! Squared quark threholds
0131     std::vector<double> _LogThresholds2; //<! Log of the squared quark threholds
0132   };
0133 }