splittingfunctionsunp_sl.h

Go to the documentation of this file.

//
// APFEL++ 2017
//
// Author: Valerio Bertone: valerio.bertone@cern.ch
//
 
#pragma once
 
#include "apfel/expression.h"
 
#include <vector>
 
namespace apfel
{
 
 
 
  class P0ns: public Expression
  {
  public:
    P0ns();
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  };
 
  class P0qg: public Expression
  {
  public:
    P0qg(int const& nf);
    double Regular(double const& x) const;
  private:
    int const _nf;
  };
 
  class P0gq: public Expression
  {
  public:
    P0gq();
    double Regular(double const& x) const;
  };
 
  class P0gg: public Expression
  {
  public:
    P0gg(int const& nf);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  private:
    int const _nf;
  };
 
 
  class P1nsp: public Expression
  {
  public:
    P1nsp(int const& nf);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  protected:
    int const _nf;
    double    _a2;
  };
 
  class P1nsm: public P1nsp
  {
  public:
    P1nsm(int const& nf);
    double Regular(double const& x) const;
  };
 
  class P1ps: public Expression
  {
  public:
    P1ps(int const& nf);
    double Regular(double const& x) const;
  private:
    int const _nf;
  };
 
  class P1qg: public Expression
  {
  public:
    P1qg(int const& nf);
    double Regular(double const& x) const;
  private:
    int const _nf;
  };
 
  class P1gq: public Expression
  {
  public:
    P1gq(int const& nf);
    double Regular(double const& x) const;
  private:
    int const _nf;
  };
 
  class P1gg: public Expression
  {
  public:
    P1gg(int const& nf);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  private:
    int const _nf;
    double    _a2g;
  };
 
 
  class P2nsp: public Expression
  {
  public:
    P2nsp(int const& nf);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  private:
    int const _nf;
  };
 
  class P2nsm: public Expression
  {
  public:
    P2nsm(int const& nf);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  private:
    int const _nf;
  };
 
  class P2nss: public Expression
  {
  public:
    P2nss(int const& nf);
    double Regular(double const& x) const;
  private:
    int const _nf;
  };
 
  class P2ps: public Expression
  {
  public:
    P2ps(int const& nf);
    double Regular(double const& x) const;
  private:
    int const _nf;
  };
 
  class P2qg: public Expression
  {
  public:
    P2qg(int const& nf);
    double Regular(double const& x) const;
  private:
    int const _nf;
  };
 
  class P2gq: public Expression
  {
  public:
    P2gq(int const& nf);
    double Regular(double const& x) const;
  private:
    int const _nf;
  };
 
  class P2gg: public Expression
  {
  public:
    P2gg(int const& nf);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  private:
    int const _nf;
  };
 
  /* /\** */
  /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) non-singlet-plus */
  /*  * unpolarised splitting function. */
  /*  *\/ */
  /* class P3nsp: public Expression */
  /* { */
  /* public: */
  /*   P3nsp(int const& nf, int const& imod = 0, double const& rho = 0.007); */
  /*   double Regular(double const& x)  const; */
  /*   double Singular(double const& x) const; */
  /*   double Local(double const& x)    const; */
  /* private: */
  /*   int           const _nf; */
  /*   int           const _imod; */
  /*   double        const _rho; */
  /*   std::vector<double> _C; */
  /* }; */
 
  class P3nsp: public Expression
  {
  public:
    P3nsp(int const& nf, int const& imod = 0);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  private:
    int const _nf;
    int const _imod;
  };
 
  class P3nsm: public Expression
  {
  public:
    P3nsm(int const& nf, int const& imod = 0);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  private:
    int const _nf;
    int const _imod;
  };
 
  class P3nss: public Expression
  {
  public:
    P3nss(int const& nf, int const& imod = 0);
    double Regular(double const& x) const;
  private:
    int const _nf;
    int const _imod;
  };
 
  /* /\** */
  /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) pure-singlet */
  /*  * unpolarised splitting function. */
  /*  *\/ */
  /* class P3ps: public Expression */
  /* { */
  /* public: */
  /*   P3ps(int const& nf, int const& imod = 0); */
  /*   double Regular(double const& x) const; */
  /* private: */
  /*   int const _nf; */
  /*   int const _imod; */
  /* }; */
 
  class P3ps: public Expression
  {
  public:
    P3ps(int const& nf, int const& imod = 0);
    double Regular(double const& x) const;
  private:
    int const _nf;
    int const _imod;
  };
 
  /* /\** */
  /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) quark-gluon unpolarised */
  /*  * splitting function. */
  /*  *\/ */
  /* class P3qg: public Expression */
  /* { */
  /* public: */
  /*   P3qg(int const& nf, double const& rho = -1.754); */
  /*   double Regular(double const& x) const; */
  /* private: */
  /*   int           const _nf; */
  /*   double        const _rho; */
  /*   std::vector<double> _C; */
  /* }; */
 
  class P3qg: public Expression
  {
  public:
    P3qg(int const& nf, int const& imod = 0);
    double Regular(double const& x) const;
  private:
    int const _nf;
    int const _imod;
  };
 
  /* /\** */
  /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) gluon-quark unpolarised */
  /*  * splitting function. */
  /*  *\/ */
  /* class P3gq: public Expression */
  /* { */
  /* public: */
  /*   P3gq(double const& rho = -1.784); */
  /*   double Regular(double const& x) const; */
  /* private: */
  /*   double        const _rho; */
  /*   std::vector<double> _C; */
  /* }; */
 
  class P3gq: public Expression
  {
  public:
    P3gq(int const& nf, int const& imod = 0);
    double Regular(double const& x) const;
  private:
    int const _nf;
    int const _imod;
  };
 
  /* /\** */
  /*  * @brief Space-like O(&alpha;<SUB>s</SUB><SUP>4</SUP>) gluon-gluon unpolarised */
  /*  * splitting function. */
  /*  *\/ */
  /* class P3gg: public Expression */
  /* { */
  /* public: */
  /*   P3gg(double const& rho = 19.245); */
  /*   double Regular(double const& x)  const; */
  /* private: */
  /*   double        const _rho; */
  /*   std::vector<double> _C; */
  /* }; */
 
  class P3gg: public Expression
  {
  public:
    P3gg(int const& nf, int const& imod = 0);
    double Regular(double const& x)  const;
    double Singular(double const& x) const;
    double Local(double const& x)    const;
  private:
    int const _nf;
    int const _imod;
    double _A4gluon;
  };
}