include/apfel/dglapnonlinear.h

0001 //
0002 // APFEL++ 2017
0003 //
0004 // Author: Valerio Bertone: valerio.bertone@cern.ch
0005 //
0006
0007 #pragma once
0008
0009 #include "apfel/matchedevolution.h"
0010 #include "apfel/set.h"
0011 #include "apfel/operator.h"
0012
0013 namespace apfel
0014 {
0015   /**
0016    * @brief The DglapNonLinear class is specialization class of the
0017    * MatchedEvolution class for the computation of the non-linear
0018    * DGLAP evolution. Note that this class only works for Distribution
0019    * objects and not for Operator objects.
0020    */
0021   class DglapNonLinear: public MatchedEvolution<Set<Distribution>>
0022   {
0023   public:
0024     DglapNonLinear() = delete;
0025
0026     /**
0027      * @brief DglapNonLinear constructor.
0028      * @param SplittingFunctions: set of splitting functions
0029      * @param MatchingConditions: set of matching conditions
0030      * @param TranformationFuncs: set of functions that trasform distributions in the l.h.s. of DGLAP
0031      * @param ObjRef: reference object to be evolved
0032      * @param MuRef: reference scale from which the evolution starts
0033      * @param Thresholds: vector of the heavy-quark thresholds
0034      * @param nsteps: number of steps of the ODE solver (default: 10)
0035      */
0036     DglapNonLinear(std::function<Set<Operator>(int const&, double const&)>                                          const& SplittingFunctions,
0037                    std::function<Set<Operator>(bool const&, int const&)>                                            const& MatchingConditions,
0038                    std::function<std::map<int, std::function<double(std::map<int, double> const&)>>(double const&)> const& TranformationFuncs,
0039                    Set<Distribution>                                                                                const& ObjRef,
0040                    double                                                                                           const& MuRef,
0041                    std::vector<double>                                                                              const& Thresholds,
0042                    int                                                                                              const& nsteps = 10);
0043
0044     /**
0045      * @brief Function that matches the evolved object at the thresholds.
0046      * @param Up: whether the matching has to be done upward or backward
0047      * @param nf: number of active flavours on this side of the threshold
0048      * @param sd: object on this side of the threshold
0049      * @return The matched object on the other side of the threshold.
0050      */
0051     Set<Distribution> MatchObject(bool const& Up, int const& nf, Set<Distribution> const& sd) const;
0052
0053     /**
0054      * @brief This function returns the r.h.s. of the DGLAP equation,
0055      * i.e. the convolution between splitting functions and
0056      * distributions.
0057      * @param nf: number of active flavours
0058      * @param t: value of the log of the factorisation scale squared
0059      * @param f: set of distributions at the scale mu
0060      * @return The r.h.s. of the DGLAP equation.
0061      */
0062     Set<Distribution> Derivative(int const& nf, double const& t, Set<Distribution> const& f) const;
0063
0064     /**
0065      * @name Setters
0066      */
0067     ///@{
0068     /**
0069      * @brief Function that sets the reference object at the reference
0070      * scale using a function of the index and x.
0071      * @param InDistFunc: the function that returns the distributions.
0072      */
0073     void SetInitialDistributions(std::function<double(int const&, double const&)> const& InDistFunc);
0074
0075     /**
0076      * @brief Function that sets the reference distribution at the
0077      * reference scale using a map of the distribution as function of
0078      * x.
0079      * @param InDistFunc: the function that returns the distributions.
0080      */
0081     void SetInitialDistributions(std::function<std::map<int, double>(double const&)> const& InDistFunc);
0082
0083     /**
0084      * @brief Function that sets the reference distribution at the
0085      * reference scale using a map of the distribution as function of
0086      * x and Q.
0087      * @param InDistFunc: the function that returns the distributions.
0088      * @param mu: the scale at which distributions have to be computed
0089      */
0090     void SetInitialDistributions(std::function<std::map<int, double>(double const&, double const&)> const& InDistFunc, double const& mu);
0091     ///@}
0092   private:
0093     std::function<Set<Operator>(int const&, double const&)>                                          const _SplittingFunctions;
0094     std::function<Set<Operator>(bool const&, int const&)>                                            const _MatchingConditions;
0095     std::function<std::map<int, std::function<double(std::map<int, double> const&)>>(double const&)> const _TranformationFuncs;
0096   };
0097 }