convol_coeff_function/TCS/TCSCFFStandard.h

0001 #ifndef TCS_CFF_STANDARD_H
0002 #define TCS_CFF_STANDARD_H
0003
0004 /**
0005  * @file TCSCFFStandard.h
0006  * @author Bryan BERTHOU (SPhN / CEA Saclay)
0007  * @author Hervé MOUTARDE (SPhN / CEA Saclay)
0008  * @author Hervé MOUTARDE (SPhN / CEA Saclay)
0009  * @date September 08, 2014
0010  * @version 1.0
0011  */
0012
0013 #include <stddef.h>
0014 #include <complex>
0015 #include <map>
0016 #include <string>
0017 #include <vector>
0018
0019 #include "../../../beans/automation/BaseObjectData.h"
0020 #include "TCSConvolCoeffFunctionModule.h"
0021
0022 namespace NumA {
0023 class FunctionType1D;
0024 } /* namespace NumA */
0025 namespace PARTONS {
0026 class PartonDistribution;
0027 } /* namespace PARTONS */
0028
0029 namespace PARTONS {
0030
0031 /**
0032  * @class TCSCFFStandard
0033  *
0034  * TODO: Add description.
0035  *
0036  * Available CFF types: H, E, Ht, Et.
0037  */
0038 class TCSCFFStandard: public TCSConvolCoeffFunctionModule {
0039 public:
0040
0041     static const unsigned int classId; ///< Unique ID to automatically register the class in the registry.
0042
0043     /**
0044      * Constructor.
0045      * See BaseObject::BaseObject and ModuleObject::ModuleObject for more details.
0046      * @param className Name of last child class.
0047      */
0048     TCSCFFStandard(const std::string &className);
0049
0050     virtual TCSCFFStandard* clone() const;
0051
0052     /**
0053      * Default destructor.
0054      */
0055     virtual ~TCSCFFStandard();
0056
0057     virtual void resolveObjectDependencies();
0058
0059     void prepareSubModules(
0060             const std::map<std::string, BaseObjectData>& subModulesData);
0061
0062     // ##### GETTERS & SETTERS #####
0063
0064     /**
0065      * Get alphaS module.
0066      */
0067     RunningAlphaStrongModule* getRunningAlphaStrongModule() const;
0068
0069     /**
0070      * Set alphaS module.
0071      */
0072     void setRunningAlphaStrongModule(
0073             RunningAlphaStrongModule* pRunningAlphaStrongModule);
0074
0075 protected:
0076     /**
0077      * Copy constructor.
0078      * @param other
0079      */
0080     TCSCFFStandard(const TCSCFFStandard &other);
0081
0082     double m_logQ2PrimOverMu2;
0083
0084     virtual void initModule();
0085     virtual void isModuleWellConfigured();
0086
0087     virtual std::complex<double> KernelGluonNLOA(double x); ///< T^{g, NLO, A}, appendix A, eq. (A2)
0088     virtual std::complex<double> KernelGluonNLOV(double x); ///< T^{g, NLO, V}, appendix A, eq. (A2)
0089
0090     virtual std::complex<double> KernelQuarkNLOV(double x); ///< T^{q, NLO, V}, appendix A, eq. (A2)
0091     virtual std::complex<double> KernelQuarkNLOA(double x); ///< T^{q, NLO, A}, appendix A, eq. (A2)
0092
0093     virtual void computeSubtractionFunctionsV();
0094     virtual void computeSubtractionFunctionsA();
0095
0096     double m_realPartSubtractQuark;
0097     double m_imaginaryPartSubtractQuark;
0098     double m_realPartSubtractGluon;
0099     double m_imaginaryPartSubtractGluon;
0100     double m_CF;                     ///< ( Nc^2 - 1 ) / ( 2 Nc ) (colour)
0101
0102     double m_Zeta;
0103     double m_QPrim;
0104     double m_alphaSOver2Pi;
0105
0106     virtual std::complex<double> computeUnpolarized();
0107     virtual std::complex<double> computePolarized();
0108
0109 private:
0110
0111     double m_quarkDiagonal;
0112     double m_gluonDiagonal;
0113
0114     size_t m_nf; ///< Number of active flavors.
0115     RunningAlphaStrongModule *m_pRunningAlphaStrongModule; ///< Related alphaS module.
0116
0117     virtual void computeDiagonalGPD();
0118
0119     virtual std::complex<double> KernelQuarkV(double x); ///< T^{q, V/A}, appendix A, eq. (A1)
0120     virtual std::complex<double> KernelGluonV(double x); ///< T^{g, V/A}, appendix A, eq. (A1)
0121
0122     virtual double ConvolReKernelQuark1V(double x, std::vector<double> params); ///< eq. (8), real part of amplitude, \int_0^zeta
0123     virtual double ConvolReKernelQuark2V(double x, std::vector<double> params); ///< eq. (8), real part of amplitude, \int_zeta^1
0124     virtual double ConvolImKernelQuark1V(double x, std::vector<double> params); ///< eq. (8), imaginary part of amplitude, \int_0^zeta
0125     virtual double ConvolImKernelQuark2V(double x, std::vector<double> params); ///< eq. (8), imaginary part of amplitude, \int_zeta^1
0126     virtual double ConvolReKernelGluon1V(double x, std::vector<double> params); ///< eq. (9), real part of amplitude, \int_0^zeta
0127     virtual double ConvolReKernelGluon2V(double x, std::vector<double> params); ///< eq. (9), real part of amplitude, \int_zeta^1
0128     virtual double ConvolImKernelGluon1V(double x, std::vector<double> params); ///< eq. (9), imaginary part of amplitude, \int_0^zeta
0129     virtual double ConvolImKernelGluon2V(double x, std::vector<double> params); ///< eq. (9), imaginary part of amplitude, \int_zeta^1
0130
0131     virtual std::complex<double> KernelQuarkA(double x); ///< T^{q, V/A}, appendix A, eq. (A1)
0132     virtual std::complex<double> KernelGluonA(double x); ///< T^{g, V/A}, appendix A, eq. (A1)
0133
0134     virtual double ConvolReKernelQuark1A(double x, std::vector<double> params); ///< eq. (8), real part of amplitude, \int_0^zeta
0135     virtual double ConvolReKernelQuark2A(double x, std::vector<double> params); ///< eq. (8), real part of amplitude, \int_zeta^1
0136     virtual double ConvolImKernelQuark1A(double x, std::vector<double> params); ///< eq. (8), imaginary part of amplitude, \int_0^zeta
0137     virtual double ConvolImKernelQuark2A(double x, std::vector<double> params); ///< eq. (8), imaginary part of amplitude, \int_zeta^1
0138     virtual double ConvolReKernelGluon1A(double x, std::vector<double> params); ///< eq. (9), real part of amplitude, \int_0^zeta
0139     virtual double ConvolReKernelGluon2A(double x, std::vector<double> params); ///< eq. (9), real part of amplitude, \int_zeta^1
0140     virtual double ConvolImKernelGluon1A(double x, std::vector<double> params); ///< eq. (9), imaginary part of amplitude, \int_0^zeta
0141     virtual double ConvolImKernelGluon2A(double x, std::vector<double> params); ///< eq. (9), imaginary part of amplitude, \int_zeta^1
0142
0143     std::complex<double> computeIntegralsV();
0144     std::complex<double> computeIntegralsA();
0145
0146     double computeSquareChargeAveragedGPD(
0147             const PartonDistribution &partonDistribution);
0148
0149     NumA::FunctionType1D* m_pConvolReKernelQuark1V;
0150     NumA::FunctionType1D* m_pConvolReKernelQuark2V;
0151     NumA::FunctionType1D* m_pConvolImKernelQuark1V;
0152     NumA::FunctionType1D* m_pConvolImKernelQuark2V;
0153     NumA::FunctionType1D* m_pConvolReKernelGluon1V;
0154     NumA::FunctionType1D* m_pConvolReKernelGluon2V;
0155     NumA::FunctionType1D* m_pConvolImKernelGluon1V;
0156     NumA::FunctionType1D* m_pConvolImKernelGluon2V;
0157     NumA::FunctionType1D* m_pConvolReKernelQuark1A;
0158     NumA::FunctionType1D* m_pConvolReKernelQuark2A;
0159     NumA::FunctionType1D* m_pConvolImKernelQuark1A;
0160     NumA::FunctionType1D* m_pConvolImKernelQuark2A;
0161     NumA::FunctionType1D* m_pConvolReKernelGluon1A;
0162     NumA::FunctionType1D* m_pConvolReKernelGluon2A;
0163     NumA::FunctionType1D* m_pConvolImKernelGluon1A;
0164     NumA::FunctionType1D* m_pConvolImKernelGluon2A;
0165
0166     void initFunctorsForIntegrations(); ///< Initialize functors.
0167 };
0168
0169 } /* namespace PARTONS */
0170
0171 #endif /* TCS_CFF_STANDARD_H */