include/apfel/splittingfunctionsunp_sl.h

0001 //
0002 // APFEL++ 2017
0003 //
0004 // Author: Valerio Bertone: valerio.bertone@cern.ch
0005 //
0006
0007 #pragma once
0008
0009 #include "apfel/expression.h"
0010
0011 #include <vector>
0012
0013 namespace apfel
0014 {
0015   /**
0016    * @defgroup SLSplittings Space-like splitting functions
0017    * Collection of the MSbar space-like splitting functions up to the
0018    * highest order currently known for unpolarised, polarised, and
0019    * transversity evolution.
0020    * @note While for the O(&alpha;<SUB>s</SUB>) and
0021    * O(&alpha;<SUB>s</SUB><SUP>2</SUP>) splitting functions exact
0022    * expressions are used, a fast parameterisation for the
0023    * O(&alpha;<SUB>s</SUB><SUP>3</SUP>) (and
0024    * O(&alpha;<SUB>s</SUB><SUP>4</SUP>) when available) ones is
0025    * used. See https://www.liverpool.ac.uk/~avogt/split.html for more
0026    * details.
0027    */
0028   ///@{
0029   ///@}
0030   /**
0031    * @defgroup UnpSF Unpolarised splitting functions
0032    * @ingroup SLSplittings
0033    */
0034   ///@{
0035   ///@}
0036   /**
0037    * @defgroup LOunpsf LO splitting functions
0038    * @ingroup UnpSF
0039    */
0040   ///@{
0041   /**
0042    * @brief Space-like O(&alpha;<SUB>s</SUB>) non-singlet unpolarised splitting
0043    * function.
0044    */
0045   class P0ns: public Expression
0046   {
0047   public:
0048     P0ns();
0049     double Regular(double const& x)  const;
0050     double Singular(double const& x) const;
0051     double Local(double const& x)    const;
0052   };
0053
0054   /**
0055    * @brief Space-like O(&alpha;<SUB>s</SUB>) quark-gluon unpolarised splitting
0056    * function.
0057    */
0058   class P0qg: public Expression
0059   {
0060   public:
0061     P0qg(int const& nf);
0062     double Regular(double const& x) const;
0063   private:
0064     int const _nf;
0065   };
0066
0067   /**
0068    * @brief Space-like O(&alpha;<SUB>s</SUB>) gluon-quark unpolarised splitting
0069    * function.
0070    */
0071   class P0gq: public Expression
0072   {
0073   public:
0074     P0gq();
0075     double Regular(double const& x) const;
0076   };
0077
0078   /**
0079    * @brief Space-like O(&alpha;<SUB>s</SUB>) gluon-gluon unpolarised splitting
0080    * function.
0081    */
0082   class P0gg: public Expression
0083   {
0084   public:
0085     P0gg(int const& nf);
0086     double Regular(double const& x)  const;
0087     double Singular(double const& x) const;
0088     double Local(double const& x)    const;
0089   private:
0090     int const _nf;
0091   };
0092   ///@}
0093
0094   /**
0095    * @defgroup NLOunpsf NLO splitting functions
0096    * @ingroup UnpSF
0097    */
0098   ///@{
0099   /**
0100    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>2</SUP>) non-singlet-plus
0101    * unpolarised splitting function.
0102    */
0103   class P1nsp: public Expression
0104   {
0105   public:
0106     P1nsp(int const& nf);
0107     double Regular(double const& x)  const;
0108     double Singular(double const& x) const;
0109     double Local(double const& x)    const;
0110   protected:
0111     int const _nf;
0112     double    _a2;
0113   };
0114
0115   /**
0116    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>2</SUP>) non-singlet-minus
0117    * unpolarised splitting function.
0118    */
0119   class P1nsm: public P1nsp
0120   {
0121   public:
0122     P1nsm(int const& nf);
0123     double Regular(double const& x) const;
0124   };
0125
0126   /**
0127    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>2</SUP>) pure-singlet
0128    * unpolarised splitting function.
0129    */
0130   class P1ps: public Expression
0131   {
0132   public:
0133     P1ps(int const& nf);
0134     double Regular(double const& x) const;
0135   private:
0136     int const _nf;
0137   };
0138
0139   /**
0140    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>2</SUP>) quark-gluon unpolarised
0141    * splitting function.
0142    */
0143   class P1qg: public Expression
0144   {
0145   public:
0146     P1qg(int const& nf);
0147     double Regular(double const& x) const;
0148   private:
0149     int const _nf;
0150   };
0151
0152   /**
0153    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>2</SUP>) gluon-quark unpolarised
0154    * splitting function.
0155    */
0156   class P1gq: public Expression
0157   {
0158   public:
0159     P1gq(int const& nf);
0160     double Regular(double const& x) const;
0161   private:
0162     int const _nf;
0163   };
0164
0165   /**
0166    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>2</SUP>) gluon-gluon unpolarised
0167    * splitting function.
0168    */
0169   class P1gg: public Expression
0170   {
0171   public:
0172     P1gg(int const& nf);
0173     double Regular(double const& x)  const;
0174     double Singular(double const& x) const;
0175     double Local(double const& x)    const;
0176   private:
0177     int const _nf;
0178     double    _a2g;
0179   };
0180   ///@}
0181
0182   /**
0183    * @defgroup NNLOunpsf NNLO splitting functions
0184    * @ingroup UnpSF
0185    */
0186   ///@{
0187   /**
0188    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>3</SUP>) non-singlet-plus
0189    * unpolarised splitting function.
0190    */
0191   class P2nsp: public Expression
0192   {
0193   public:
0194     P2nsp(int const& nf);
0195     double Regular(double const& x)  const;
0196     double Singular(double const& x) const;
0197     double Local(double const& x)    const;
0198   private:
0199     int const _nf;
0200   };
0201
0202   /**
0203    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>3</SUP>) non-singlet-minus
0204    * unpolarised splitting function.
0205    */
0206   class P2nsm: public Expression
0207   {
0208   public:
0209     P2nsm(int const& nf);
0210     double Regular(double const& x)  const;
0211     double Singular(double const& x) const;
0212     double Local(double const& x)    const;
0213   private:
0214     int const _nf;
0215   };
0216
0217   /**
0218    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>3</SUP>) non-singlet-valence
0219    * unpolarised splitting function minus non-singlet-minus
0220    * unpolarised splitting function.
0221    */
0222   class P2nss: public Expression
0223   {
0224   public:
0225     P2nss(int const& nf);
0226     double Regular(double const& x) const;
0227   private:
0228     int const _nf;
0229   };
0230
0231   /**
0232    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>3</SUP>) pure-singlet
0233    * unpolarised splitting function.
0234    */
0235   class P2ps: public Expression
0236   {
0237   public:
0238     P2ps(int const& nf);
0239     double Regular(double const& x) const;
0240   private:
0241     int const _nf;
0242   };
0243
0244   /**
0245    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>3</SUP>) quark-gluon unpolarised
0246    * splitting function.
0247    */
0248   class P2qg: public Expression
0249   {
0250   public:
0251     P2qg(int const& nf);
0252     double Regular(double const& x) const;
0253   private:
0254     int const _nf;
0255   };
0256
0257   /**
0258    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>3</SUP>) gluon-quark unpolarised
0259    * splitting function.
0260    */
0261   class P2gq: public Expression
0262   {
0263   public:
0264     P2gq(int const& nf);
0265     double Regular(double const& x) const;
0266   private:
0267     int const _nf;
0268   };
0269
0270   /**
0271    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>3</SUP>) gluon-gluon unpolarised
0272    * splitting function.
0273    */
0274   class P2gg: public Expression
0275   {
0276   public:
0277     P2gg(int const& nf);
0278     double Regular(double const& x)  const;
0279     double Singular(double const& x) const;
0280     double Local(double const& x)    const;
0281   private:
0282     int const _nf;
0283   };
0284   ///@}
0285
0286   /**
0287    * @defgroup NNNLOunpsf NNNLO splitting functions
0288    * @ingroup UnpSF
0289    * @note For now only leading-color plus, minus, and valence
0290    * contributions have been computed and parameterised. The singlet
0291    * ones are also parameterised and using the first Mellin moments
0292    * and the small- and large-x asymptotic behaviours.
0293    */
0294   ///@{
0295   /* /\** */
0296   /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) non-singlet-plus */
0297   /*  * unpolarised splitting function. */
0298   /*  *\/ */
0299   /* class P3nsp: public Expression */
0300   /* { */
0301   /* public: */
0302   /*   P3nsp(int const& nf, int const& imod = 0, double const& rho = 0.007); */
0303   /*   double Regular(double const& x)  const; */
0304   /*   double Singular(double const& x) const; */
0305   /*   double Local(double const& x)    const; */
0306   /* private: */
0307   /*   int           const _nf; */
0308   /*   int           const _imod; */
0309   /*   double        const _rho; */
0310   /*   std::vector<double> _C; */
0311   /* }; */
0312
0313   /**
0314    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>)
0315    * non-singlet-plus unpolarised splitting function. Parameterisation
0316    * determined in https://arxiv.org/pdf/1707.08315.pdf
0317    */
0318   class P3nsp: public Expression
0319   {
0320   public:
0321     P3nsp(int const& nf, int const& imod = 0);
0322     double Regular(double const& x)  const;
0323     double Singular(double const& x) const;
0324     double Local(double const& x)    const;
0325   private:
0326     int const _nf;
0327     int const _imod;
0328   };
0329
0330   /**
0331    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>)
0332    * non-singlet-minus unpolarised splitting
0333    * function. Parameterisation determined in
0334    * https://arxiv.org/pdf/1707.08315.pdf
0335    */
0336   class P3nsm: public Expression
0337   {
0338   public:
0339     P3nsm(int const& nf, int const& imod = 0);
0340     double Regular(double const& x)  const;
0341     double Singular(double const& x) const;
0342     double Local(double const& x)    const;
0343   private:
0344     int const _nf;
0345     int const _imod;
0346   };
0347
0348   /**
0349    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>)
0350    * non-singlet-valence unpolarised splitting
0351    * function. Parameterisation determined in
0352    * https://arxiv.org/pdf/1707.08315.pdf
0353    */
0354   class P3nss: public Expression
0355   {
0356   public:
0357     P3nss(int const& nf, int const& imod = 0);
0358     double Regular(double const& x) const;
0359   private:
0360     int const _nf;
0361     int const _imod;
0362   };
0363
0364   /* /\** */
0365   /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) pure-singlet */
0366   /*  * unpolarised splitting function. */
0367   /*  *\/ */
0368   /* class P3ps: public Expression */
0369   /* { */
0370   /* public: */
0371   /*   P3ps(int const& nf, int const& imod = 0); */
0372   /*   double Regular(double const& x) const; */
0373   /* private: */
0374   /*   int const _nf; */
0375   /*   int const _imod; */
0376   /* }; */
0377
0378   /**
0379    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) pure-singlet
0380    * unpolarised splitting function. Parameterisation determined in
0381    * https://arxiv.org/pdf/2512.10783.pdf
0382    */
0383   class P3ps: public Expression
0384   {
0385   public:
0386     P3ps(int const& nf, int const& imod = 0);
0387     double Regular(double const& x) const;
0388   private:
0389     int const _nf;
0390     int const _imod;
0391   };
0392
0393   /* /\** */
0394   /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) quark-gluon unpolarised */
0395   /*  * splitting function. */
0396   /*  *\/ */
0397   /* class P3qg: public Expression */
0398   /* { */
0399   /* public: */
0400   /*   P3qg(int const& nf, double const& rho = -1.754); */
0401   /*   double Regular(double const& x) const; */
0402   /* private: */
0403   /*   int           const _nf; */
0404   /*   double        const _rho; */
0405   /*   std::vector<double> _C; */
0406   /* }; */
0407
0408   /**
0409    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) quark-gluon
0410    * unpolarised splitting function. Parameterisation determined in
0411    * https://arxiv.org/pdf/2512.10783.pdf
0412    */
0413   class P3qg: public Expression
0414   {
0415   public:
0416     P3qg(int const& nf, int const& imod = 0);
0417     double Regular(double const& x) const;
0418   private:
0419     int const _nf;
0420     int const _imod;
0421   };
0422
0423   /* /\** */
0424   /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) gluon-quark unpolarised */
0425   /*  * splitting function. */
0426   /*  *\/ */
0427   /* class P3gq: public Expression */
0428   /* { */
0429   /* public: */
0430   /*   P3gq(double const& rho = -1.784); */
0431   /*   double Regular(double const& x) const; */
0432   /* private: */
0433   /*   double        const _rho; */
0434   /*   std::vector<double> _C; */
0435   /* }; */
0436
0437   /**
0438    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) gluon-quark
0439    * unpolarised splitting function. Parameterisation determined in
0440    * https://arxiv.org/pdf/2512.10783.pdf
0441    */
0442   class P3gq: public Expression
0443   {
0444   public:
0445     P3gq(int const& nf, int const& imod = 0);
0446     double Regular(double const& x) const;
0447   private:
0448     int const _nf;
0449     int const _imod;
0450   };
0451
0452   /* /\** */
0453   /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) gluon-gluon unpolarised */
0454   /*  * splitting function. */
0455   /*  *\/ */
0456   /* class P3gg: public Expression */
0457   /* { */
0458   /* public: */
0459   /*   P3gg(double const& rho = 19.245); */
0460   /*   double Regular(double const& x)  const; */
0461   /* private: */
0462   /*   double        const _rho; */
0463   /*   std::vector<double> _C; */
0464   /* }; */
0465
0466   /* /\** */
0467   /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) gluon-gluon */
0468   /*  * unpolarised splitting function. Parameterisation determined in */
0469   /*  * https://arxiv.org/pdf/2310.05744.pdf. */
0470   /*  *\/ */
0471   /* class P3gg: public Expression */
0472   /* { */
0473   /* public: */
0474   /*   P3gg(int const& nf, int const& imod = 0); */
0475   /*   double Regular(double const& x)  const; */
0476   /*   double Singular(double const& x) const; */
0477   /*   double Local(double const& x)    const; */
0478   /* private: */
0479   /*   int const _nf; */
0480   /*   int const _imod; */
0481   /*   double _A4gluon; */
0482   /* }; */
0483
0484   /**
0485    * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) gluon-gluon
0486    * unpolarised splitting function. Parameterisation determined in
0487    * https://arxiv.org/pdf/2512.10783.pdf
0488    */
0489   class P3gg: public Expression
0490   {
0491   public:
0492     P3gg(int const& nf, int const& imod = 0);
0493     double Regular(double const& x)  const;
0494     double Singular(double const& x) const;
0495     double Local(double const& x)    const;
0496   private:
0497     int const _nf;
0498     int const _imod;
0499     double _A4gluon;
0500   };
0501   ///@}
0502 }