Back to home page

EIC code displayed by LXR

 
 

    


File indexing completed on 2026-06-02 08:17:15

0001 //
0002 // APFEL++ 2017
0003 //
0004 // Author: Valerio Bertone: valerio.bertone@cern.ch
0005 //
0006 
0007 #pragma once
0008 
0009 #include "apfel/grid.h"
0010 #include "apfel/dglap.h"
0011 #include "apfel/observable.h"
0012 #include "apfel/disbasis.h"
0013 #include "apfel/dglapbuilder.h"
0014 
0015 namespace apfel
0016 {
0017   /**
0018    * @brief Structure that contains all the precomputed quantities
0019    * needed to compute the DIS structure functions, i.e. the
0020    * perturbative coefficients of the coefficient functions for
0021    * F<SUB>2</SUB>, F<SUB>L</SUB>, and xF<SUB>3</SUB>.
0022    */
0023   struct StructureFunctionObjects
0024   {
0025     int                           nf;
0026     DglapObjects                  P;
0027     std::vector<int>              skip;
0028     std::map<int, ConvolutionMap> ConvBasis;
0029     std::map<int, Set<Operator>>  C0;
0030     std::map<int, Set<Operator>>  C1;
0031     std::map<int, Set<Operator>>  C2;
0032     std::map<int, Set<Operator>>  C3;
0033   };
0034 
0035   /**
0036    * @name DIS structure function object initializers
0037    * Collection of functions that initialise StructureFunctionObjects
0038    * structure for the different kinds of structure functions
0039    * available.
0040    */
0041   ///@{
0042   /**
0043    * @brief The InitializeF2NCObjectsZM precomputes the perturbative
0044    * coefficients of coefficient functions for NC F2 in the ZM scheme
0045    * and store them in the 'StructureFunctionObjects' structure.
0046    * @param g: the x-space grid
0047    * @param Thresholds: the heavy quark thresholds
0048    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0049    * @return A StructureFunctionObjects-valued function
0050    */
0051   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF2NCObjectsZM(Grid                const& g,
0052                                                                                                              std::vector<double> const& Thresholds,
0053                                                                                                              double              const& IntEps = 1e-5);
0054 
0055   /**
0056    * @brief The InitializeFLNCObjectsZM precomputes the perturbative
0057    * coefficients of coefficient functions for NC FL in the ZM scheme
0058    * and store them in the 'StructureFunctionObjects' structure.
0059    * @param g: the x-space grid
0060    * @param Thresholds: the heavy quark thresholds
0061    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0062    * @return A StructureFunctionObjects-valued function
0063    */
0064   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeFLNCObjectsZM(Grid                const& g,
0065                                                                                                              std::vector<double> const& Thresholds,
0066                                                                                                              double              const& IntEps = 1e-5);
0067 
0068   /**
0069    * @brief The InitializeF3NCObjectsZM precomputes the perturbative
0070    * coefficients of coefficient functions for NC xF3 in the ZM scheme
0071    * and store them in the 'StructureFunctionObjects' structure.
0072    * @param g: the x-space grid
0073    * @param Thresholds: the heavy quark thresholds
0074    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0075    * @return A StructureFunctionObjects-valued function
0076    */
0077   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF3NCObjectsZM(Grid                const& g,
0078                                                                                                              std::vector<double> const& Thresholds,
0079                                                                                                              double              const& IntEps = 1e-5);
0080 
0081   /**
0082    * @brief The Initializeg4NCObjectsZM precomputes the perturbative
0083    * coefficients of coefficient functions for NC g4 in the ZM scheme
0084    * and store them in the 'StructureFunctionObjects' structure.
0085    * @param g: the x-space grid
0086    * @param Thresholds: the heavy quark thresholds
0087    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0088    * @return A StructureFunctionObjects-valued function
0089    */
0090   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> Initializeg4NCObjectsZM(Grid                const& g,
0091                                                                                                              std::vector<double> const& Thresholds,
0092                                                                                                              double              const& IntEps = 1e-5);
0093 
0094   /**
0095    * @brief The InitializegLNCObjectsZM precomputes the perturbative
0096    * coefficients of coefficient functions for NC gL in the ZM scheme
0097    * and store them in the 'StructureFunctionObjects' structure.
0098    * @param g: the x-space grid
0099    * @param Thresholds: the heavy quark thresholds
0100    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0101    * @return A StructureFunctionObjects-valued function
0102    */
0103   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializegLNCObjectsZM(Grid                const& g,
0104                                                                                                              std::vector<double> const& Thresholds,
0105                                                                                                              double              const& IntEps = 1e-5);
0106 
0107   /**
0108    * @brief The Initializeg1NCObjectsZM precomputes the perturbative
0109    * coefficients of coefficient functions for NC xg1 in the ZM scheme
0110    * and store them in the 'StructureFunctionObjects' structure.
0111    * @param g: the x-space grid
0112    * @param Thresholds: the heavy quark thresholds
0113    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0114    * @return A StructureFunctionObjects-valued function
0115    */
0116   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> Initializeg1NCObjectsZM(Grid                const& g,
0117                                                                                                              std::vector<double> const& Thresholds,
0118                                                                                                              double              const& IntEps = 1e-5);
0119 
0120   /**
0121    * @brief The InitializeF2CCPlusObjectsZM precomputes the perturbative
0122    * coefficients of coefficient functions for combination ( F2(nu) +
0123    * F2(nubar) ) / 2 in the ZM scheme and store them in the
0124    * 'StructureFunctionObjects' structure.
0125    * @param g: the x-space grid
0126    * @param Thresholds: the heavy quark thresholds
0127    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0128    * @return A StructureFunctionObjects-valued function
0129    */
0130   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF2CCPlusObjectsZM(Grid                const& g,
0131                                                                                                                  std::vector<double> const& Thresholds,
0132                                                                                                                  double              const& IntEps = 1e-5);
0133 
0134   /**
0135    * @brief The InitializeF2CCMinusObjectsZM precomputes the perturbative
0136    * coefficients of coefficient functions for combination ( F2(nu) -
0137    * F2(nubar) ) / 2 in the ZM scheme and store them in the
0138    * 'StructureFunctionObjects' structure.
0139    * @param g: the x-space grid
0140    * @param Thresholds: the heavy quark thresholds
0141    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0142    * @return A StructureFunctionObjects-valued function
0143    */
0144   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF2CCMinusObjectsZM(Grid                const& g,
0145                                                                                                                   std::vector<double> const& Thresholds,
0146                                                                                                                   double              const& IntEps = 1e-5);
0147 
0148   /**
0149    * @brief The InitializeFLCCPlusObjectsZM precomputes the perturbative
0150    * coefficients of coefficient functions for combination ( FL(nu) +
0151    * FL(nubar) ) / 2 in the ZM scheme and store them in the
0152    * 'StructureFunctionObjects' structure.
0153    * @param g: the x-space grid
0154    * @param Thresholds: the heavy quark thresholds
0155    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0156    * @return A StructureFunctionObjects-valued function
0157    */
0158   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeFLCCPlusObjectsZM(Grid                const& g,
0159                                                                                                                  std::vector<double> const& Thresholds,
0160                                                                                                                  double              const& IntEps = 1e-5);
0161 
0162   /**
0163    * @brief The InitializeFLCCMinusObjectsZM precomputes the perturbative
0164    * coefficients of coefficient functions for combination ( FL(nu) -
0165    * FL(nubar) ) / 2 in the ZM scheme and store them in the
0166    * 'StructureFunctionObjects' structure.
0167    * @param g: the x-space grid
0168    * @param Thresholds: the heavy quark thresholds
0169    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0170    * @return A StructureFunctionObjects-valued function
0171    */
0172   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeFLCCMinusObjectsZM(Grid                const& g,
0173                                                                                                                   std::vector<double> const& Thresholds,
0174                                                                                                                   double              const& IntEps = 1e-5);
0175 
0176   /**
0177    * @brief The InitializeF3CCPlusObjectsZM precomputes the perturbative
0178    * coefficients of coefficient functions for combination ( F3(nu) +
0179    * F3(nubar) ) / 2 in the ZM scheme and store them in the
0180    * 'StructureFunctionObjects' structure.
0181    * @param g: the x-space grid
0182    * @param Thresholds: the heavy quark thresholds
0183    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0184    * @return A StructureFunctionObjects-valued function
0185    */
0186   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF3CCPlusObjectsZM(Grid                const& g,
0187                                                                                                                  std::vector<double> const& Thresholds,
0188                                                                                                                  double              const& IntEps = 1e-5);
0189 
0190   /**
0191    * @brief The InitializeF3CCMinusObjectsZM precomputes the perturbative
0192    * coefficients of coefficient functions for combination ( F3(nu) -
0193    * F3(nubar) ) / 2 in the ZM scheme and store them in the
0194    * 'StructureFunctionObjects' structure.
0195    * @param g: the x-space grid
0196    * @param Thresholds: the heavy quark thresholds
0197    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0198    * @return A StructureFunctionObjects-valued function
0199    */
0200   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF3CCMinusObjectsZM(Grid                const& g,
0201                                                                                                                   std::vector<double> const& Thresholds,
0202                                                                                                                   double              const& IntEps = 1e-5);
0203 
0204   /**
0205    * @brief The InitializeF2NCObjectsMassive precomputes the
0206    * perturbative coefficients of coefficient functions for NC F2 in
0207    * the massive scheme and store them in the
0208    * 'StructureFunctionObjects' structure.
0209    * @param g: the x-space grid
0210    * @param Masses: the heavy quark masses
0211    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0212    * @param nxi: the number of nodes of the grid in &xi; = Q<SUP>2</SUP>/M<SUP>2</SUP> (default: 150)
0213    * @param ximin: the lower bound of the grid in &xi; (default: 0.05)
0214    * @param ximax: the upper bound of the grid in &xi; (default: 10000)
0215    * @param intdeg: the interpolation degree on the grid in &xi; (default: 3)
0216    * @param lambda: the value of the parameter in the function ln(ln(&xi;/&Lambda;<SUP>2</SUP>)) used for the tabulation (default: 0.0005)
0217    * @param IModThr: parameter of the threshold part of the approximated N3LO coefficient functions (default: zero)
0218    * @param IModAsy: parameter of the asymptotic part of the approximated N3LO coefficient functions (default: zero)
0219    * @param DampPow: power of the damping factor of the approximated N3LO coefficient functions (default: one)
0220    * @return A StructureFunctionObjects-valued function
0221    */
0222   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF2NCObjectsMassive(Grid                const& g,
0223                                                                                                                   std::vector<double> const& Masses,
0224                                                                                                                   double              const& IntEps = 1e-5,
0225                                                                                                                   int                 const& nxi    = 150,
0226                                                                                                                   double              const& ximin  = 0.05,
0227                                                                                                                   double              const& ximax  = 10000,
0228                                                                                                                   int                 const& intdeg = 3,
0229                                                                                                                   double              const& lambda = 0.0005,
0230                                                                                                                   double              const& IModThr = 0,
0231                                                                                                                   double              const& IModAsy = 0,
0232                                                                                                                   double              const& DampPow = 1);
0233 
0234   /**
0235    * @brief The InitializeFLNCObjectsMassive precomputes the
0236    * perturbative coefficients of coefficient functions for NC FL in
0237    * the massive scheme and store them in the
0238    * 'StructureFunctionObjects' structure.
0239    * @param g: the x-space grid
0240    * @param Masses: the heavy quark masses
0241    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0242    * @param nxi: the number of nodes of the grid in &xi; = Q<SUP>2</SUP>/M<SUP>2</SUP> (default: 150)
0243    * @param ximin: the lower bound of the grid in &xi; (default: 0.05)
0244    * @param ximax: the upper bound of the grid in &xi; (default: 10000)
0245    * @param intdeg: the interpolation degree on the grid in &xi; (default: 3)
0246    * @param lambda: the value of the parameter in the function ln(ln(&xi;/&Lambda;<SUP>2</SUP>)) used for the tabulation (default: 0.0005)
0247    * @param IModThr: parameter of the threshold part of the approximated N3LO coefficient functions (default: zero)
0248    * @param IModAsy: parameter of the asymptotic part of the approximated N3LO coefficient functions (default: zero)
0249    * @param DampPow: power of the damping factor of the approximated N3LO coefficient functions (default: one)
0250    * @return A StructureFunctionObjects-valued function
0251    */
0252   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeFLNCObjectsMassive(Grid                const& g,
0253                                                                                                                   std::vector<double> const& Masses,
0254                                                                                                                   double              const& IntEps  = 1e-5,
0255                                                                                                                   int                 const& nxi     = 150,
0256                                                                                                                   double              const& ximin   = 0.05,
0257                                                                                                                   double              const& ximax   = 10000,
0258                                                                                                                   int                 const& intdeg  = 3,
0259                                                                                                                   double              const& lambda  = 0.0005,
0260                                                                                                                   double              const& IModThr = 0,
0261                                                                                                                   double              const& IModAsy = 0,
0262                                                                                                                   double              const& DampPow = 1);
0263 
0264   /**
0265    * @brief The InitializeF2NCObjectsMassiveZero precomputes the
0266    * perturbative coefficients of coefficient functions for NC F2 in
0267    * the massless limit of the massive scheme and store them in the
0268    * 'StructureFunctionObjects' structure.
0269    * @param g: the x-space grid
0270    * @param Masses: the heavy quark masses
0271    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0272    * @param nxi: the number of nodes of the grid in &xi; = Q<SUP>2</SUP>/M<SUP>2</SUP> (default: 150)
0273    * @param ximin: the lower bound of the grid in &xi; (default: 0.05)
0274    * @param ximax: the upper bound of the grid in &xi; (default: 10000)
0275    * @param intdeg: the interpolation degree on the grid in &xi; (default: 3)
0276    * @param lambda: the value of the parameter in the function ln(ln(&xi;/&Lambda;<SUP>2</SUP>)) used for the tabulation (default: 0.0005)
0277    * @return A StructureFunctionObjects-valued function
0278    */
0279   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF2NCObjectsMassiveZero(Grid                const& g,
0280                                                                                                                       std::vector<double> const& Masses,
0281                                                                                                                       double              const& IntEps = 1e-5,
0282                                                                                                                       int                 const& nxi    = 150,
0283                                                                                                                       double              const& ximin  = 0.05,
0284                                                                                                                       double              const& ximax  = 10000,
0285                                                                                                                       int                 const& intdeg = 3,
0286                                                                                                                       double              const& lambda = 0.0005);
0287 
0288   /**
0289    * @brief The InitializeFLNCObjectsMassiveZero precomputes the
0290    * perturbative coefficients of coefficient functions for NC FL in
0291    * the massless limit of the massive scheme and store them in the
0292    * 'StructureFunctionObjects' structure.
0293    * @param g: the x-space grid
0294    * @param Masses: the heavy quark masses
0295    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0296    * @param nxi: the number of nodes of the grid in &xi; = Q<SUP>2</SUP>/M<SUP>2</SUP> (default: 150)
0297    * @param ximin: the lower bound of the grid in &xi; (default: 0.05)
0298    * @param ximax: the upper bound of the grid in &xi; (default: 10000)
0299    * @param intdeg: the interpolation degree on the grid in &xi; (default: 3)
0300    * @param lambda: the value of the parameter in the function ln(ln(&xi;/&Lambda;<SUP>2</SUP>)) used for the tabulation (default: 0.0005)
0301    * @return A StructureFunctionObjects-valued function
0302    */
0303   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeFLNCObjectsMassiveZero(Grid                const& g,
0304                                                                                                                       std::vector<double> const& Masses,
0305                                                                                                                       double              const& IntEps = 1e-5,
0306                                                                                                                       int                 const& nxi    = 150,
0307                                                                                                                       double              const& ximin  = 0.05,
0308                                                                                                                       double              const& ximax  = 10000,
0309                                                                                                                       int                 const& intdeg = 3,
0310                                                                                                                       double              const& lambda = 0.0005);
0311   ///@}
0312 
0313   /**
0314    * @name SIA structure function object initializers
0315    * Collection of functions that initialise StructureFunctionObjects
0316    * structure for the different kinds of structure functions
0317    * available.
0318    * @note For now only Zero-Mass structure functions up to
0319    * O(&alpha;<SUB>s</SUB>) are implemented.
0320    */
0321   ///@{
0322   /**
0323    * @brief The InitializeF2NCObjectsZMT precomputes the perturbative
0324    * coefficients of coefficient functions for NC F2 for SIA in the ZM
0325    * scheme and store them in the 'StructureFunctionObjects'
0326    * structure.
0327    * @param g: the x-space grid
0328    * @param Thresholds: the heavy quark thresholds
0329    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0330    * @return A StructureFunctionObjects-valued function
0331    */
0332   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF2NCObjectsZMT(Grid                const& g,
0333                                                                                                               std::vector<double> const& Thresholds,
0334                                                                                                               double              const& IntEps = 1e-5);
0335 
0336   /**
0337    * @brief The InitializeFLNCObjectsZMT precomputes the perturbative
0338    * coefficients of coefficient functions for NC FL for SIA in the ZM
0339    * scheme and store them in the 'StructureFunctionObjects'
0340    * structure.
0341    * @param g: the x-space grid
0342    * @param Thresholds: the heavy quark thresholds
0343    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0344    * @return A StructureFunctionObjects-valued function
0345    */
0346   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeFLNCObjectsZMT(Grid                const& g,
0347                                                                                                               std::vector<double> const& Thresholds,
0348                                                                                                               double              const& IntEps = 1e-5);
0349 
0350   /**
0351    * @brief The InitializeF3NCObjectsZMT precomputes the perturbative
0352    * coefficients of coefficient functions for NC xF3 for SIA in the
0353    * ZM scheme and store them in the 'StructureFunctionObjects'
0354    * structure.
0355    * @param g: the x-space grid
0356    * @param Thresholds: the heavy quark thresholds
0357    * @param IntEps: the integration accuracy (default: 10<SUP>-5</SUP>})
0358    * @return A StructureFunctionObjects-valued function
0359    */
0360   std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> InitializeF3NCObjectsZMT(Grid                const& g,
0361                                                                                                               std::vector<double> const& Thresholds,
0362                                                                                                               double              const& IntEps = 1e-5);
0363   ///@}
0364 
0365   /**
0366    * @name Structure function builders
0367    * Collection of functions that build a map of Observable objects
0368    * corresponding to the different component of the structure
0369    * functions.
0370    */
0371   ///@{
0372   /**
0373    * @brief The BuildStructureFunctions function constructs a map of
0374    * "Observable" objects.
0375    * @param FObj: the StructureFunctionObjects-valued for the structure function objects
0376    * @param InDistFunc: the distribution to be convoluted with as a map<int,double>-valued function of x and Q
0377    * @param PerturbativeOrder: the perturbative order
0378    * @param Alphas: the strong coupling function
0379    * @param Couplings: the vector-valued function of (non-QCD) couplings
0380    * @param xiR: the renormalisation scale-variation factor (default: 1)
0381    * @param xiF: the factorisation scale-variation factor (default: 1)
0382    * @return A map of "Observable" objects, one for number of active flavours
0383    */
0384   std::map<int, Observable<>> BuildStructureFunctions(std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> const& FObj,
0385                                                       std::function<std::map<int, double>(double const&, double const&)>                 const& InDistFunc,
0386                                                       int                                                                                const& PerturbativeOrder,
0387                                                       std::function<double(double const&)>                                               const& Alphas,
0388                                                       std::function<std::vector<double>(double const&)>                                  const& Couplings,
0389                                                       double                                                                             const& xiR = 1,
0390                                                       double                                                                             const& xiF = 1);
0391 
0392   /**
0393    * @brief The BuildStructureFunctions function constructs a map of
0394    * "Observable" objects.
0395    * @param FObj: the StructureFunctionObjects-valued for the structure function objects
0396    * @param InDistFunc: the distribution to be convoluted with as a double-valued function of i, x, and Q
0397    * @param PerturbativeOrder: the perturbative order
0398    * @param Alphas: the strong coupling function
0399    * @param Couplings: the vector-valued function of (non-QCD) couplings
0400    * @param xiR: the renormalisation scale-variation factor (default: 1)
0401    * @param xiF: the factorisation scale-variation factor (default: 1)
0402    * @return A map of "Observable" objects, one for number of active flavours
0403    */
0404   std::map<int, Observable<>> BuildStructureFunctions(std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> const& FObj,
0405                                                       std::function<double(int const&, double const&, double const&)>                    const& InDistFunc,
0406                                                       int                                                                                const& PerturbativeOrder,
0407                                                       std::function<double(double const&)>                                               const& Alphas,
0408                                                       std::function<std::vector<double>(double const&)>                                  const& Couplings,
0409                                                       double                                                                             const& xiR = 1,
0410                                                       double                                                                             const& xiF = 1);
0411 
0412   /**
0413    * @brief The BuildStructureFunctions function constructs a map of
0414    * "Observable" objects.
0415    * @param FObj: the StructureFunctionObjects-valued for the
0416    * structure function objects. In this function, the
0417    * StructureFunctionObjects do not longer admit a truncated
0418    * perturbative expasion (as for example in resummation). The
0419    * relevant objects are to be stored in the C0 element of the
0420    * structure.
0421    * @param InDistFunc: the distribution to be convoluted with as a map<int,double>-valued function of x and Q
0422    * @param Couplings: the vector-valued function of (non-QCD) couplings
0423    * @return A map of "Observable" objects, one for number of active flavours
0424    */
0425   std::map<int, Observable<>> BuildStructureFunctions(std::function<StructureFunctionObjects(double const&, std::vector<double> const&)> const& FObj,
0426                                                       std::function<std::map<int, double>(double const&, double const&)>                 const& InDistFunc,
0427                                                       std::function<std::vector<double>(double const&)>                                  const& Couplings);
0428 
0429   /**
0430    * @brief The BuildStructureFunctions function constructs an
0431    * "Observable" object.
0432    * @param FObjQ: the StructureFunctionObjects at the scale Q
0433    * @param InDistFuncQ: the distribution to be convoluted with at the scale Q as a map<int,Distribution>
0434    * @param PerturbativeOrder: the perturbative order
0435    * @param AlphasQ: the strong coupling at the scale Q
0436    * @param k: the observable index
0437    * @param xiR: the renormalisation scale-variation factor (default: 1)
0438    * @param xiF: the factorisation scale-variation factor (default: 1)
0439    * @return A "Distribution" object
0440    */
0441   Distribution BuildStructureFunctions(StructureFunctionObjects    const& FObjQ,
0442                                        std::map<int, Distribution> const& InDistFuncQ,
0443                                        int                         const& PerturbativeOrder,
0444                                        double                      const& AlphasQ,
0445                                        int                         const& k,
0446                                        double                      const& xiR = 1,
0447                                        double                      const& xiF = 1);
0448 
0449   /**
0450    * @brief The BuildStructureFunctions function constructs a map of
0451    * "Observable" objects.
0452    * @param FObjQ: the StructureFunctionObjects at the scale Q
0453    * @param InDistFuncQ: the distribution to be convoluted with at the scale Q as a map<int, Distribution>
0454    * @param PerturbativeOrder: the perturbative order
0455    * @param AlphasQ: the strong coupling at the scale Q
0456    * @param xiR: the renormalisation scale-variation factor (default: 1)
0457    * @param xiF: the factorisation scale-variation factor (default: 1)
0458    * @return A map of "Distribution" objects, one for each number of active flavours
0459    */
0460   std::map<int, Distribution> BuildStructureFunctions(StructureFunctionObjects    const& FObjQ,
0461                                                       std::map<int, Distribution> const& InDistFuncQ,
0462                                                       int                         const& PerturbativeOrder,
0463                                                       double                      const& AlphasQ,
0464                                                       double                      const& xiR = 1,
0465                                                       double                      const& xiF = 1);
0466   ///@}
0467 }