apfel Namespace Reference

Namespace for all APFEL++ functions and classes. More...

Classes
class	AlphaQCD
	The AlphaQCD is a specialization class of the MatchedEvolution class for the computation of the QCD coupling running. More...
class	AlphaQCDg
	The AlphaQCDg is a specialization class of the MatchedEvolution class for the computation of the QCD coupling running using the analytic g functions. More...
class	AlphaQCDQED
	The AlphaQCDQED is a specialization class of the MatchedEvolution class for the computation of the mixed evolution of QCD and QED. More...
class	AlphaQCDxi
	The AlphaQCDxi is a specialization class of the MatchedEvolution class for the computation of the QCD coupling running with the possibility to vary the resummation scale through the parameter xi. More...
class	AlphaQED
	The AlphaQED is a specialization class of the MatchedEvolution class for the computation of the QED coupling running. More...
class	ANS2qqH_0
	O(αs2) constant term of eq (B.4) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	ANS2qqH_L
	O(αs2) term propotional to ln(μ2/m2) of eq (B.4) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	ANS2qqH_L2
	O(αs2) term propotional to ln2(μ2/m2) of eq (B.4) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	ANS3qqH_0
	O(αs3) constant term. More...
class	APS2Hq_0
	O(αs2) constant term of eq (B.1) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	APS2Hq_L
	O(αs2) term propotional to ln(μ2/m2) of eq (B.1) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	APS2Hq_L2
	O(αs2) term propotional to ln2(μ2/m2) of eq (B.1) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	APS3Hq_0
	O(αs3) constant term. More...
class	AS1ggH_L
	O(αs) term propotional to ln(μ2/m2) of eq (B.6) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS1gH_0
	O(αs) constant term for the gH matching. This is the QCD adaptation of Eq. (4.189) of https://arxiv.org/pdf/1909.03886.pdf. More...
class	AS1gH_L
	O(αs) term propotional to ln(μ2/m2) for the gH matching. This is the QCD adaptation of Eq. (4.189) of https://arxiv.org/pdf/1909.03886.pdf. More...
class	AS1Hg_L
	O(αs) term propotional to ln(μ2/m2) of eq. (B.2) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS1HH_0
	O(αs) constant term for the HH matching. This is the QCD adaptation of Eq. (4.121) of https://arxiv.org/pdf/1909.03886.pdf. More...
class	AS1HH_L
	O(αs) term propotional to ln(μ2/m2) for the HH matching. This is the QCD adaptation of Eq. (4.121) of https://arxiv.org/pdf/1909.03886.pdf. More...
class	AS1polggH_L
	O(αs) term propotional to ln(μ2/m2). More...
class	AS1polgH_0
	O(αs) constant term for the gH matching. More...
class	AS1polgH_L
	O(αs) term propotional to ln(μ2/m2) for the gH matching. More...
class	AS1polHg_L
	O(αs) term propotional to ln(μ2/m2). More...
class	AS1polHH_0
	O(αs) constant term for the HH matching. More...
class	AS1polHH_L
	O(αs) term propotional to ln(μ2/m2) for the HH matching. More...
class	AS2ggH_0
	O(αs2) constant term of eq (B.7) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS2ggH_L
	O(αs2) term propotional to ln(μ2/m2) of eq (B.7) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS2ggH_L2
	O(αs2) term propotional to ln2(μ2/m2) of eq (B.7) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS2gqH_0
	O(αs2) constant term of eq (B.5) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS2gqH_L
	O(αs2) term propotional to ln(μ2/m2) of eq (B.5) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS2gqH_L2
	O(αs2) term propotional to ln2(μ2/m2) of eq (B.5) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS2Hg_0
	O(αs2) constant term of eq (B.3) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS2Hg_L
	O(αs2) term propotional to ln(μ2/m2) of eq (B.3) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS2Hg_L2
	O(αs2) term propotional to ln2(μ2/m2) of eq (B.3) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	AS3ggH_0
	O(αs3) constant term. More...
class	AS3gqH_0
	O(αs3) constant term. More...
class	AS3Hg_0
	O(αs3) constant term. More...
class	ATS1ggH_L
	O(αs) term propotional to ln(μ2/m2) of eq. (22) of https://arxiv.org/pdf/hep-ph/0504192.pdf. More...
class	ATS1gH_L
	O(αs) term propotional to ln(μ2/m2) of eq. (B.2) of https://arxiv.org/pdf/hep-ph/9612398.pdf. More...
class	ATS1Hg_0
	O(αs) constant term of eq. (15) of https://arxiv.org/pdf/hep-ph/0504192.pdf. More...
class	ATS1Hg_L
	O(αs) term propotional to ln(μ2/m2) of eq. (15) of https://arxiv.org/pdf/hep-ph/0504192.pdf. More...
class	ATS1HH_0
	O(αs) constant term for the HH matching. This is the QCD adaptation of Eq. (4.121) of https://arxiv.org/pdf/1909.03886.pdf. More...
class	ATS1HH_L
	O(αs) term propotional to ln(μ2/m2) for the HH matching. This is the QCD adaptation of Eq. (4.121) of https://arxiv.org/pdf/1909.03886.pdf. More...
class	C1ggff
	The O(αs) gluon-gluon matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C1ggpdf
	The O(αs) gluon-gluon matching function for PDFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C1ggpdfBM
	The O(αs) gluon-gluon matching function for linearly polarised gluon PDF (reference: https://arxiv.org/pdf/1907.03780.pdf). More...
class	C1ggpdfg1
	The O(αs) gluon-gluon matching function for g1 PDFs (reference: https://arxiv.org/pdf/1702.06558.pdf). More...
class	C1gqff
	The O(αs) gluon-quark matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C1gqpdf
	The O(αs) gluon-quark matching function for PDFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C1gqpdfBM
	The O(αs) gluon-quark matching function for linearly polarised gluon PDF (reference: https://arxiv.org/pdf/1907.03780.pdf). More...
class	C1gqpdfg1
	The O(αs) gluon-quark matching function for g1 PDFs (reference: https://arxiv.org/pdf/1702.06558.pdf). More...
class	C1nsff
	The O(αs) non-singlet matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C1nspdf
	The O(αs) non-singlet matching function for PDFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C1nspdfg1
	The O(αs) non-singlet matching function for g1 PDFs (reference: https://arxiv.org/pdf/1702.06558.pdf). More...
class	C1nspdfSivers
	The O(αs) non-singlet matching function for Sivers PDFs (see Eq. (A.9) of https://arxiv.org/pdf/2009.10710.pdf). More...
class	C1qgff
	The O(αs) quark-gluon matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C1qgpdf
	The O(αs) quark-gluon matching function for PDFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C1qgpdfg1
	The O(αs) quark-gluon matching function for g1 PDFs (reference: https://arxiv.org/pdf/1702.06558.pdf). More...
class	C21g
	O(αs) gluon coefficient function for F2. More...
class	C21ns
	O(αs) non-singlet coefficient function for F2. More...
class	C21Tg
	O(αs) gluon coefficient function for F2 in SIA. More...
class	C21Tns
	O(αs) non-singlet coefficient function for F2 in SIA. More...
class	C22g
	O(αs2) gluon coefficient function for F2. More...
class	C22nsm
	O(αs2) non-singlet-minus coefficient function for F2. More...
class	C22nsp
	O(αs2) non-singlet-plus coefficient function for F2. More...
class	C22ps
	O(αs2) pure-singlet coefficient function for F2. More...
class	C22Tg
	O(αs2) gluon coefficient function for F2 in SIA. More...
class	C22Tnsp
	O(αs2) non-singlet-plus coefficient function for F2 in SIA. More...
class	C22Tps
	O(αs2) pure-singlet coefficient function for F2 in SIA. More...
class	C23g
	O(αs3) gluon coefficient function for F2. More...
class	C23nsm
	O(αs3) non-singlet-minus coefficient function for F2. More...
class	C23nsp
	O(αs3) non-singlet-plus coefficient function for F2. More...
class	C23ps
	O(αs3) pure-singlet coefficient function for F2. More...
class	C2ggff
	The O(αs2) gluon-gluon matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C2ggpdf
	The O(αs2) gluon-gluon matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C2ggpdfBM
	The O(αs2) gluon-gluon matching function for linearly polarised gluon PDFs (reference: https://arxiv.org/pdf/1907.03780.pdf). More...
class	C2gqff
	The O(αs2) gluon-quark matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C2gqpdf
	The O(αs2) gluon-quark matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C2gqpdfBM
	The O(αs2) gluon-quark matching function for linearly polarised gluon PDF (reference: https://arxiv.org/pdf/1907.03780.pdf). More...
class	C2nsmff
	The O(αs2) quark-antiquark matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C2nsmpdf
	The O(αs2) valence minus matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C2nspff
	The O(αs2) quark-quark matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C2nsppdf
	The O(αs2) valence plus matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C2psff
	The O(αs2) pure-singlet matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C2pspdf
	The O(αs2) pure-singlet matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C2qgff
	The O(αs2) quark-gluon matching function for FFs (references: https://arxiv.org/pdf/1604.07869.pdf and https://arxiv.org/pdf/1706.01473.pdf). More...
class	C2qgpdf
	The O(αs2) quark-gluon matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C31ns
	O(αs) non-singlet coefficient function for F3. More...
class	C31Tns
	O(αs) non-singlet coefficient function for F3 in SIA. More...
class	C32nsm
	O(αs2) non-singlet-minus coefficient function for F3. More...
class	C32nsp
	O(αs2) non-singlet-plus coefficient function for F3. More...
class	C32Tnsp
	O(αs2) non-singlet-plus coefficient function for F3 in SIA. More...
class	C33nsm
	O(αs3) non-singlet-minus coefficient function for F3. More...
class	C33nsp
	O(αs3) non-singlet-plus coefficient function for F3. More...
class	C33nsv
	O(αs3) total-valence coefficient function for F3. More...
class	C3ggff
	The O(αs3) gluon-gluon matching function for FFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3ggpdf
	The O(αs3) gluon-gluon matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3gqff
	The O(αs3) gluon-quark matching function for FFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3gqpdf
	The O(αs3) gluon-quark matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3nsmff
	The O(αs3) valence minus matching function for FFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3nsmpdf
	The O(αs3) valence minus matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3nspff
	The O(αs3) valence plus matching function for FFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3nsppdf
	The O(αs3) valence plus matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3psff
	The O(αs3) pure-singlet matching function for FFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3pspdf
	The O(αs3) pure-singlet matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3pvff
	The O(αs3) pure-valence matching function for FFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3pvpdf
	The O(αs3) pure-valence matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3qgff
	The O(αs3) quark-gluon matching function for FFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	C3qgpdf
	The O(αs3) quark-gluon matching function for PDFs (reference: https://arxiv.org/pdf/2012.03256.pdf). More...
class	Cgtmd1gg
	The O(αs) gluon-gluon unpolarised matching function for GTMDs. More...
class	Cgtmd1gq
	The O(αs) gluon-quark unpolarised matching function for GTMDs. More...
class	Cgtmd1ns
	The O(αs) non-singlet unpolarised matching function for GTMDs. More...
class	Cgtmd1qg
	The O(αs) quark-gluon unpolarised matching function for GTMDs. More...
class	Cgtmd1qq
	The O(αs) quark-quark unpolarised matching function for GTMDs. More...
class	CL1g
	O(αs) gluon coefficient function for FL. More...
class	CL1ns
	O(αs) non-singlet coefficient function for FL. More...
class	CL1Tg
	O(αs) gluon coefficient function for FL in SIA. More...
class	CL1Tns
	O(αs) non-singlet coefficient function for FL in SIA. More...
class	CL2g
	O(αs2) gluon coefficient function for FL. More...
class	CL2nsm
	O(αs2) non-singlet-minus coefficient function for FL. More...
class	CL2nsp
	O(αs2) non-singlet-plus coefficient function for FL. More...
class	CL2ps
	O(αs2) pure-singlet coefficient function for FL. More...
class	CL2Tg
	O(αs2) gluon coefficient function for FL in SIA. More...
class	CL2Tnsp
	O(αs2) non-singlet-plus coefficient function for FL in SIA. More...
class	CL2Tps
	O(αs2) pure-singlet coefficient function for FL in SIA. More...
class	CL3g
	O(αs3) gluon coefficient function for FL. More...
class	CL3nsm
	O(αs3) non-singlet-minus coefficient function for FL. More...
class	CL3nsp
	O(αs3) non-singlet-plus coefficient function for FL. More...
class	CL3ps
	O(αs3) pure-singlet coefficient function for FL. More...
class	Cm021gNC_c
	O(αs) gluon coefficient function for F2. Constant term. More...
class	Cm021gNC_l
	O(αs) gluon coefficient function for F2. Single-log term. More...
class	Cm022gNC_c
	O(αs2) gluon coefficient function for F2. Constant term. More...
class	Cm022gNC_f
	O(αs2) gluon coefficient function for F2. Single-log(μF) term. More...
class	Cm022gNC_l
	O(αs2) gluon coefficient function for F2. Single-log term. More...
class	Cm022gNC_l2
	O(αs2) gluon coefficient function for F2. Double-log term. More...
class	Cm022gNC_lf
	O(αs2) gluon coefficient function for F2. Mixed-double-log term. More...
class	Cm022nsNC_c
	O(αs2) non-singlet coefficient function for F2. Constant term. More...
class	Cm022nsNC_l
	O(αs2) non-singlet coefficient function for F2. Single-log term. More...
class	Cm022nsNC_l2
	O(αs2) non-singlet coefficient function for F2. Double-log term. More...
class	Cm022psNC_c
	O(αs2) pure-singlet coefficient function for F2. Constant term. More...
class	Cm022psNC_f
	O(αs2) pure-singlet coefficient function for F2. Single-log(μF) term. More...
class	Cm022psNC_l
	O(αs2) pure-singlet coefficient function for F2. Single-log term. More...
class	Cm022psNC_l2
	O(αs2) pure-singlet coefficient function for F2. Double-log term. More...
class	Cm022psNC_lf
	O(αs2) pure-singlet coefficient function for F2. Mixed-double-log term. More...
class	Cm0L1gNC_c
	O(αs) gluon coefficient function for FL. Constant term. More...
class	Cm0L2gNC_c
	O(αs2) gluon coefficient function for FL. Constant term. More...
class	Cm0L2gNC_f
	O(αs2) gluon coefficient function for FL. Single-log(μF) term. More...
class	Cm0L2gNC_l
	O(αs2) gluon coefficient function for FL. Single-log term. More...
class	Cm0L2nsNC_c
	O(αs2) non-singlet coefficient function for FL. Constant term. More...
class	Cm0L2nsNC_l
	O(αs2) non-singlet coefficient function for FL. Single-log term. More...
class	Cm0L2psNC_c
	O(αs2) pure-singlet coefficient function for FL. Constant term. More...
class	Cm0L2psNC_f
	O(αs2) pure-singlet coefficient function for FL. Single-log(μF) term. More...
class	Cm0L2psNC_l
	O(αs2) pure-singlet coefficient function for FL. Single-log term. More...
class	Cm11ns
	O(αs) non-singlet coefficient function for 2xF1. The relevant function is in Eq. (C4) of https://arxiv.org/pdf/hep-ph/9805233.pdf. More...
class	Cm21gCC
	O(αs) gluon coefficient function for F2. More...
class	Cm21gNC
	O(αs) gluon coefficient function for F2. See eq. (53) of https://arxiv.org/pdf/1001.2312.pdf. Or it uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	Cm21ns
	O(αs) non-singlet coefficient function for F2. The relevant function is in Eq. (C4) of https://arxiv.org/pdf/hep-ph/9805233.pdf. More...
class	Cm21qCC
	O(αs) quark coefficient function for F2. More...
class	Cm22bargNC
	O(αs2) gluon coefficient function proportional to ln(Q2/M2) for F2. Uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	Cm22barpsNC
	O(αs2) pure-singlet coefficient function proportional to ln(Q2/M2) for F2. Uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	Cm22gNC
	O(αs2) gluon coefficient function for F2. Uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	Cm22nsNC
	O(αs2) non-singlet coefficient function for F2. See Appendix A of https://arxiv.org/pdf/hep-ph/9601302.pdf. Or it uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	Cm22psNC
	O(αs2) pure-singlet coefficient function for F2. Uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	Cm31gCC
	O(αs) gluon coefficient function for xF3. More...
class	Cm31ns
	O(αs) non-singlet coefficient function for F3. The relevant function is in Eq. (C4) of https://arxiv.org/pdf/hep-ph/9805233.pdf. More...
class	Cm31qCC
	O(αs) quark coefficient function for xF3. More...
class	CmL1gCC
	O(αs) gluon coefficient function for FL. More...
class	CmL1gNC
	O(αs) gluon coefficient function for FL. More...
class	CmL1ns
	O(αs) non-singlet coefficient function for FL = F2 - 2xF1. The relevant function is in Eq. (C4) of https://arxiv.org/pdf/hep-ph/9805233.pdf. More...
class	CmL1qCC
	O(αs) quark coefficient function for FL. More...
class	CmL2bargNC
	O(αs2) gluon coefficient function proportional to ln(Q2/M2) for FL. Uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	CmL2barpsNC
	O(αs2) pure-singlet coefficient function proportional to ln(Q2/M2) for FL. Uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	CmL2gNC
	O(αs2) gluon coefficient function for FL. Uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	CmL2nsNC
	O(αs2) non-singlet coefficient function for FL. See Appendix A of https://arxiv.org/pdf/hep-ph/9601302.pdf. Or it uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	CmL2psNC
	O(αs2) pure-singlet coefficient function for FL. Uses the fortran routines in 'src/dis/hqcoef.f'. More...
class	ConvolutionMap
	The ConvolutionMap class encapsulates the set of rules to multiply a sets of operators with a set of distributions. More...
class	Dglap
	The Dglap class is specialization class of the MatchedEvolution class for the computation of the DGLAP evolution. More...
struct	DglapObjects
	Structure that contains all the precomputed quantities needed to perform the DGLAP evolution, i.e. perturbative coefficients of splitting functions and matching conditions, and the heavy quark thresholds. More...
class	DiagonalBasis
	The DiagonalBasis class is the simplest derivation of ConvolutionMap meant to essentially perform a scalar product of two sets of objects. More...
class	DISCCBasis
	The DISCCBasis class is a derived of ConvolutionMap specialised for the computation of the CC DIS structure functions. More...
class	DISNCBasis
	The DISNCBasis class is a derived of ConvolutionMap specialised for the computation of the NC DIS structure functions. More...
class	Distribution
	The Distribution class defines one of the basic objects of APFEL++. This is essentially the discretisation of a function that can be conveniently used for convolutions. More...
class	DoubleExponentialQuadrature
	DE-Quadrature Numerical automatic integrator for improper integral using double dxponential (DE) quadrature. The code is a manipulation of the code linked here: More...
class	DoubleObject
	The DoubleObject class is a collection of pairs of single objects (Distributions or Operators) accompained by a multiplicative constant. This mother class provides the basic ingredients for the computation double convolutions required in SIDIS and DY. More...
class	EvolBasisPlusMinus
	The EvolBasisPlusMinus class is derives from ConvolutionMap and implements a basis in which plus (q+qbar) and minus (q-qbar) combinations are fully coupled. More...
class	EvolutionBasisQCD
	The EvolutionBasisQCD class is a derived of ConvolutionMap specialised for the DGLAP evolution of distributions using the QCD evolution basis. More...
class	EvolutionOperatorBasisQCD
	The EvolutionOperatorBasisQCD class is a derived of ConvolutionMap specialised for the DGLAP evolution of operators using the QCD evolution basis. More...
struct	EvolutionSetup
	The EvolutionSetup structure is a collection of all possible evolution parameters. More...
class	EvolveDistributionsBasisQCD
	The EvolveDistributionsBasisQCD class is a derived of ConvolutionMap specialised to match a set of evolution operators to a set a initial-scale distributions. More...
class	Expression
	The Expression class encapsulates in a proper form a given analytic expression in such a way that it can be transformed into an operator. More...
class	ExtendedVector
	Class that extends vectors to negative indices. More...
class	G11g
	O(αs) gluon coefficient function for for g1. More...
class	G11ns
	O(αs) non-singlet coefficient function for g1. More...
class	G12g
	O(αs2) gluon coefficient function for F2. More...
class	G12nsp
	O(αs2) non-singlet-plus coefficient function for F2. More...
class	G12ps
	O(αs2) pure-singlet coefficient function for F2. More...
class	G41ns
	O(αs) non-singlet coefficient function for g4. More...
class	GL1ns
	O(αs) non-singlet coefficient function for gL. More...
class	Grid
	The Grid class defines ab object that is essentially a collection of "SubGrid" objects plus other global parameters. This class also includes all the relevant methods for the manipulation of the SubGrids. More...
struct	GtmdObjects
class	Identity
	Derived class from Expression to implement the Identity operator (delta function). More...
class	InitialiseEvolution
	The InitialiseEvolution performs all the operations to initialise a DGLAP evolution using an EvolutionSetup object to retrieve the relevant information. This class also provides the necessary functions to access the evolved distributions, coupling(s), and masses. More...
class	Integrator
	The Integrator class performs unidimensional numerical integrations using the Guassian quadrature. More...
class	Integrator2D
	The Integrator2D class performs two-dimensional numerical integrations using the Guassian quadrature. More...
class	Interpolator
	The Interpolator class is a mother class for the x-space interpolationand requires the implementation of a specialized interpolation algorithm. The current version uses the joint grid object stored allocated by the Grid class. More...
class	LagrangeInterpolator
	The LagrangeInterpolator class is a specialization of the Interpolator class using the lagrange interpolation procedure. More...
struct	LHKnotArray
	The LHKnotArray structure emulates the KnotArray1F class of LHAPDF and contains the grids in x, Q2 (only a given subgrid), and one single distribution tabulated on the (x,Q) bidimensional grid. More...
class	MatchedEvolution
	The MatchedEvolution class is a template mother class for the computation of the running of a generic quantity in a VFNS. It provides the basic ingredients for the computation and the heavy-quark threshold matching of the running of a given object. More...
class	MatchingBasisQCD
	The MatchingBasisQCD class is a derived of ConvolutionMap specialised for the matching of distributions using the QCD evolution basis and without assuming that intrinsic heavy quark contributions vanish. More...
class	MatchingOperatorBasisQCD
	The MatchingOperatorBasisQCD class is a derived of ConvolutionMap specialised for the matching of the evolution of operators at the heavy-quark thresholds using the QCD evolution basis. More...
class	matrix
	The matrix class is a simple implementation of 2d arrays based on a continous memory allocation. Elements are accessible throught the (i,j) operator. More...
class	Null
	Derived class from Expression to implement the Null operator (zero). More...
class	Observable
	The Observable class encapsulates sets of operators and sets of T-type objects for an easy computation of observables deriving from the convolution of the two. This class can contain an arbitrary number of such pairs that are separatately convoluted and joint when the obeservable is computed by means of the "Evaluate" function. More...
class	OgataQuadrature
	The OgataQuadrature class implements the Hankel-transform of the input function using the Ogata quadrature method described here: http://www.kurims.kyoto-u.ac.jp/~okamoto/paper/Publ_RIMS_DE/41-4-40.pdf. More...
class	Operator
	The Operator class defines the basic object "Operator" which is essentially the convolution on the grid bewteen an Expression object (e.g. a splitting function) and the interpolant functions. More...
class	P0gg
	Space-like O(αs) gluon-gluon unpolarised splitting function. More...
class	P0gq
	Space-like O(αs) gluon-quark unpolarised splitting function. More...
class	P0ns
	Space-like O(αs) non-singlet unpolarised splitting function. More...
class	P0polgg
	Space-like O(αs) gluon-gluon longitudinally polarised splitting function. More...
class	P0polgq
	Space-like O(αs) gluon-quark longitudinally polarised splitting function. More...
class	P0polns
	Space-like O(αs) non-singlet longitudinally polarised splitting function. This is equal to the non-singlet unpolarised splitting function. More...
class	P0polqg
	Space-like O(αs) quark-gluon longitudinally polarised splitting function. More...
class	P0qg
	Space-like O(αs) quark-gluon unpolarised splitting function. More...
class	P0Tgg
	Time-like O(αs) gluon-gluon unpolarised splitting function. More...
class	P0Tgq
	Time-like O(αs) gluon-quark unpolarised splitting function. More...
class	P0Tns
	Time-like O(αs) non-singlet unpolarised splitting function. More...
class	P0Tqg
	Time-like O(αs) quark-gluon unpolarised splitting function. More...
class	P0transgg
	Space-like O(αs) gluon-gluon linearly polarised splitting function. More...
class	P0transns
	Space-like O(αs) non-singlet transversely polarised splitting function. More...
class	P0Ttransns
	Time-like O(αs) non-singlet transversely polarised splitting function. More...
class	P1gg
	Space-like O(αs2) gluon-gluon unpolarised splitting function. More...
class	P1gq
	Space-like O(αs2) gluon-quark unpolarised splitting function. More...
class	P1nsm
	Space-like O(αs2) non-singlet-minus unpolarised splitting function. More...
class	P1nsp
	Space-like O(αs2) non-singlet-plus unpolarised splitting function. More...
class	P1polgg
	Space-like O(αs2) gluon-gluon longitudinally polarised splitting function. More...
class	P1polgq
	Space-like O(αs2) gluon-quark longitudinally polarised splitting function. More...
class	P1polnsm
	Space-like O(αs2) non-singlet-minus longitudinally polarised splitting function. This is equal to the non-singlet-plus unpolarised splitting function. More...
class	P1polnsp
	Space-like O(αs2) non-singlet-plus longitudinally polarised splitting function. This is equal to the non-singlet-minus unpolarised splitting function. More...
class	P1polps
	Space-like O(αs2) pure-singlet longitudinally polarised splitting function. More...
class	P1polqg
	Space-like O(αs2) quark-gluon longitudinally polarised splitting function. More...
class	P1ps
	Space-like O(αs2) pure-singlet unpolarised splitting function. More...
class	P1qg
	Space-like O(αs2) quark-gluon unpolarised splitting function. More...
class	P1Tgg
	Time-like O(αs2) gluon-gluon unpolarised splitting function. More...
class	P1Tgq
	Time-like O(αs2) gluon-quark unpolarised splitting function. More...
class	P1Tnsm
	Time-like O(αs2) non-singlet-minus unpolarised splitting function. More...
class	P1Tnsp
	Time-like O(αs2) non-singlet-plus unpolarised splitting function. More...
class	P1Tps
	Time-like O(αs2) pure-singlet unpolarised splitting function. More...
class	P1Tqg
	Time-like O(αs2) quark-gluon unpolarised splitting function. More...
class	P1transgg
	Space-like O(αs2) gluon-gluon linearly polarised splitting function. More...
class	P1transnsm
	Space-like O(αs2) non-singlet-minus transversely polarised splitting function. More...
class	P1transnsp
	Space-like O(αs2) non-singlet-plus transversely polarised splitting function. More...
class	P1Ttransnsm
	Time-like O(αs2) non-singlet-minus transversely polarised splitting function. More...
class	P1Ttransnsp
	Time-like O(αs2) non-singlet-plus transversely polarised splitting function. More...
class	P2gg
	Space-like O(αs3) gluon-gluon unpolarised splitting function. More...
class	P2gq
	Space-like O(αs3) gluon-quark unpolarised splitting function. More...
class	P2nsm
	Space-like O(αs3) non-singlet-minus unpolarised splitting function. More...
class	P2nsp
	Space-like O(αs3) non-singlet-plus unpolarised splitting function. More...
class	P2nss
	Space-like O(αs3) non-singlet-valence unpolarised splitting function minus non-singlet-minus unpolarised splitting function. More...
class	P2polgg
	Space-like O(αs3) gluon-gluon longitudinally polarised splitting function. More...
class	P2polgq
	Space-like O(αs3) gluon-quark longitudinally polarised splitting function. More...
class	P2polnsm
	Space-like O(αs3) non-singlet-minus longitudinally polarised splitting function. This is equal to the non-singlet-plus unpolarised splitting function. More...
class	P2polnsp
	Space-like O(αs3) non-singlet-plus longitudinally polarised splitting function. This is equal to the non-singlet-minus unpolarised splitting function. More...
class	P2polnss
	Space-like O(αs3) non-singlet-valence longitudinally polarised splitting function minus non-singlet-minus longitudinally polarised splitting function. More...
class	P2polps
	Space-like O(αs3) pure-singlet longitudinally polarised splitting function. More...
class	P2polqg
	Space-like O(αs3) quark-gluon longitudinally polarised splitting function. More...
class	P2ps
	Space-like O(αs3) pure-singlet unpolarised splitting function. More...
class	P2qg
	Space-like O(αs3) quark-gluon unpolarised splitting function. More...
class	P2Tgg
	Time-like O(αs3) gluon-gluon unpolarised splitting function. More...
class	P2Tgq
	Time-like O(αs3) gluon-quark unpolarised splitting function. More...
class	P2Tnsm
	Time-like O(αs3) non-singlet-minus unpolarised splitting function. More...
class	P2Tnsp
	Time-like O(αs3) non-singlet-plus unpolarised splitting function. More...
class	P2Tnss
	Time-like O(αs3) non-singlet-valence unpolarised splitting function minus non-singlet-minus unpolarised splitting function. More...
class	P2Tps
	Time-like O(αs3) pure-singlet unpolarised splitting function. More...
class	P2Tqg
	Time-like O(αs3) quark-gluon unpolarised splitting function. More...
class	P3gg
	Space-like O(αs4) gluon-gluon unpolarised splitting function. More...
class	P3gq
	Space-like O(αs4) gluon-quark unpolarised splitting function. More...
class	P3nsm
	Space-like O(αs4) non-singlet-minus unpolarised splitting function. More...
class	P3nsp
	Space-like O(αs4) non-singlet-plus unpolarised splitting function. More...
class	P3nss
	Space-like O(αs4) non-singlet-valence unpolarised splitting function minus non-singlet-minus unpolarised splitting function. More...
class	P3ps
	Space-like O(αs4) pure-singlet unpolarised splitting function. More...
class	P3qg
	Space-like O(αs4) quark-gluon unpolarised splitting function. More...
class	Pgpd0gg
	O(αs) gluon-gluon unpolarised splitting function. More...
class	Pgpd0gq
	O(αs) gluon-quark unpolarised splitting function. More...
class	Pgpd0ns
	O(αs) non-singlet unpolarised evolution kernel. More...
class	Pgpd0polgg
	O(αs) gluon-gluon polarised splitting function. More...
class	Pgpd0polgq
	O(αs) gluon-quark polarised splitting function. More...
class	Pgpd0polns
	O(αs) non-singlet polarised evolution kernel. More...
class	Pgpd0polqg
	O(αs) quark-gluon polarised splitting function. More...
class	Pgpd0polqq
	O(αs) quark-quark polarised splitting function. More...
class	Pgpd0qg
	O(αs) quark-gluon unpolarised splitting function. More...
class	Pgpd0qq
	O(αs) quark-quark unpolarised splitting function. More...
class	Pgpd0transgg
	O(αs) gluon-gluon linearly polarised splitting function. More...
class	Pgpd0transns
	O(αs) non-singlet polarised evolution kernel. More...
class	Pgpd0transqq
	O(αs) quark-quark transversely polarised splitting function. More...
class	QGrid
	The template class QGrids is a mother class for the interpolation in Q. This class also implements methods for the subgrid interpolation relevant for example in a VFNS evolution. More...
class	Set
	The Set template class allocates a collection of objects of type T along the ConvolutionMap and provides the methods to perform operations between different types of objects T. More...
struct	StructureFunctionObjects
	Structure that contains all the precomputed quantities needed to compute the DIS structure functions, i.e. the perturbative coefficients of the coefficient functions for F2, FL, and xF3. More...
class	SubGrid
	Class for the x-space interpolation SubGrids. More...
class	TabulateObject
	The template TabulateObject class is a derived of the QGrid class that tabulates on object of type T (it can be a double, a Distribution, an Operator, Set<Distribution>, a Set<Operator>) over a grid in Q, taking into account the possible presence of thresholds, and provides the method to evaluate the tabulated object at any generic value of Q. More...
struct	term
	The term structure that contains all the objects of a single term of a double object. More...
class	Timer
	The Timer class computes the time elapsed between start and stop. More...
struct	TmdObjects
	Structure that contains all precomputed quantities needed to perform the TMD evolution, matching to the collinear PDFs, and computation of cross sections, i.e. the perturbative coefficients of matching functions, all anomalous dimensions, and hard functions. More...
class	TwoBodyPhaseSpace
	Class for the calculation of the phase-space reduction factor due to cuts on the single outgoing lepton in Drell-Yan production. The relevant process is: γ(q) → l+(k1) + l-(k2) with: kT,1(2) > pT,min,1(2) < ηmin η1(2) < ηmax More...

Enumerations
enum	FixedOrderAccuracy : int {   LO = 0 , NLO = 1 , NNLO = 2 , NNNLO = 3 ,   N4LO = 4 }
enum	LogAccuracy : int {   NNNLLp = -3 , NNLLp = -2 , NLLp = -1 , LL = 0 ,   NLL = 1 , NNLL = 2 , NNNLL = 3 , N4LL = 4 }
enum	PartonSpecies : int {   GLUON = 0 , QUARK = 1 , PHOTON = 2 , CHARGEDLEPTON = 3 ,   NEUTRINO = 4 }
enum	JetAlgorithm : int { CONE = 0 , KT = 1 }
	Enumerator for the jet algoritms for the jet TMDs. More...

Functions
std::ostream &	operator<< (std::ostream &os, ConvolutionMap const &cm)
	Method which prints ConvolutionMap with cout <<.
template<class T , class U >
std::ostream &	operator<< (std::ostream &os, DoubleObject< T, U > const &dob)
	Method which prints the double object with cout <<.
std::ostream &	operator<< (std::ostream &os, Grid const &gr)
	Overload the << operator to print the parameters of the grid.
std::ostream &	operator<< (std::ostream &os, Interpolator const &in)
	Method which prints Interpolator with cout <<. This only prints the first subgrid and is supposed to be used for debugging purposes.
std::ostream &	operator<< (std::ostream &os, Operator const &op)
	Method which prints Operator with cout <<. This only prints the Operator on the first subgrid and is supposed to be used for debugging purposes.
template<class T >
std::ostream &	operator<< (std::ostream &os, QGrid< T > const &Qg)
	Method that prints QGrid with cout <<.
std::ostream &	operator<< (std::ostream &os, SubGrid const &sg)
	Method which prints SubGrid with cout <<.
QCD beta function
Coefficients of the QCD function. Reference: https://arxiv.org/pdf/1701.01404.pdf
double	beta0qcd (int const &nf)
	LO coefficient of the QCD function.
double	beta1qcd (int const &nf)
	NLO coefficient of the QCD function.
double	beta2qcd (int const &nf)
	NNLO coefficient of the QCD function.
double	beta3qcd (int const &nf)
	NNNLO coefficient of the QCD function.
double	beta4qcd (int const &nf)
	N4LO coefficient of the QCD function.
QCDxQED mixed beta function
Coefficients of the QCDxQED mixed function. Reference: https://arxiv.org/pdf/hep-ph/9803211.pdf
double	beta1qcdqed (int const &nf)
	coefficient of the QCD function.
double	beta1qedqcd (int const &nf)
	coefficient of the QCD function.
QED beta function
Coefficients of the QED function.
double	beta0qed (int const &nf, int const &nl)
	LO coefficient of the QED function.
double	beta1qed (int const &nf, int const &nl)
	NLO coefficient of the QED function.
DGLAP object initializers
Collection of functions that initialise DglapObjects structure for the different kinds of evolution currently available.
std::map< int, DglapObjects >	InitializeDglapObjectsQCD (Grid const &g, std::vector< double > const &Masses, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCD function precomputes the perturbative coefficients of space-like unpolarised splitting functions and matching conditions and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCD (Grid const &g, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCD function precomputes the perturbative coefficients of space-like unpolarised splitting functions and matching conditions and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCDpol (Grid const &g, std::vector< double > const &Masses, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCDpol function precomputes the perturbative coefficients of space-like longitudinally polarised splitting functions and matching conditions (assumed to be equal to the unpolarised ones) and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCDpol (Grid const &g, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCDpol function precomputes the perturbative coefficients of space-like longitudinally polarised splitting functions and matching conditions (assumed to be equal to the unpolarised ones) and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCDT (Grid const &g, std::vector< double > const &Masses, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCDT function precomputes the perturbative coefficients of time-like unpolarised splitting functions and matching conditions and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCDT (Grid const &g, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCDT function precomputes the perturbative coefficients of time-like unpolarised splitting functions and matching conditions and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCDtrans (Grid const &g, std::vector< double > const &Masses, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCDtrans function precomputes the perturbative coefficients of space-like transverity splitting functions and matching conditions and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCDtrans (Grid const &g, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCDtrans function precomputes the perturbative coefficients of space-like transverity splitting functions and matching conditions and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCDTtrans (Grid const &g, std::vector< double > const &Masses, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCDtrans function precomputes the perturbative coefficients of timelike-like transverity splitting functions and matching conditions and store them into a 'DglapObjects' structure.
std::map< int, DglapObjects >	InitializeDglapObjectsQCDTtrans (Grid const &g, std::vector< double > const &Thresholds, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeDglapObjectsQCDtrans function precomputes the perturbative coefficients of time-like transverity splitting functions and matching conditions and store them into a 'DglapObjects' structure.
DGLAP builders
Collection of functions that build a Dglap object used to perform the DGLAP evolution of distributions or operators.
std::unique_ptr< Dglap< Distribution > >	BuildDglap (std::map< int, DglapObjects > const &DglapObj, std::function< std::map< int, double >(double const &, double const &)> const &InDistFunc, double const &MuRef, int const &PerturbativeOrder, std::function< double(double const &)> const &Alphas, double const &xi=1, int const &nsteps=10)
	The BuildDglap function builds the actual dglap object that performs the DGLAP evolution for distributions.
std::unique_ptr< Dglap< Operator > >	BuildDglap (std::map< int, DglapObjects > const &DglapObj, double const &MuRef, int const &PerturbativeOrder, std::function< double(double const &)> const &Alphas, double const &xi=1, int const &nsteps=10)
	The BuildDglap function builds the actual dglap object that performs the DGLAP evolution for operators.
std::unique_ptr< Dglap< Distribution > >	BuildDglap (std::function< DglapObjects(double const &)> const &DglapObj, std::vector< double > const &Thresholds, std::function< std::map< int, double >(double const &, double const &)> const &InDistFunc, double const &MuRef, int const &PerturbativeOrder, std::function< double(double const &)> const &Alphas, int const &nsteps=10)
	The BuildDglap function builds the actual dglap object that performs the DGLAP evolution for distributions.
Ternary operators
Distribution	operator* (double const &s, Distribution rhs)
	Scalar*Distribution.
Distribution	operator* (Distribution lhs, double const &s)
	Distribution*Scalar.
Distribution	operator* (std::function< double(double const &)> const &f, Distribution rhs)
	Function*Distribution.
Distribution	operator* (Distribution lhs, std::function< double(double const &)> const &f)
	Distribution*Function.
Distribution	operator/ (Distribution lhs, double const &s)
	Distribution/Scalar.
Distribution	operator+ (Distribution lhs, Distribution const &rhs)
	Distribution+Distribution.
Distribution	operator- (Distribution lhs, Distribution const &rhs)
	Distribution-Distribution.
Distribution	operator* (Distribution lhs, Distribution const &rhs)
	Distribution*Distribution.
template<class A , class B >
DoubleObject< B >	operator* (DoubleObject< A > lhs, DoubleObject< B > const &rhs)
template<class T , class U >
DoubleObject< T, U >	operator* (double const &s, DoubleObject< T, U > rhs)
template<class T , class U >
DoubleObject< T, U >	operator* (DoubleObject< T, U > lhs, double const &s)
template<class T , class U >
DoubleObject< T, U >	operator/ (DoubleObject< T, U > lhs, double const &s)
template<class T , class U >
DoubleObject< T, U >	operator* (DoubleObject< T, U > lhs, DoubleObject< T, U > const &rhs)
template<class T , class U >
DoubleObject< T, U >	operator+ (DoubleObject< T, U > lhs, DoubleObject< T, U > const &rhs)
template<class T , class U >
DoubleObject< T, U >	operator- (DoubleObject< T, U > lhs, DoubleObject< T, U > const &rhs)
template<class T >
matrix< T >	operator+ (matrix< T > lhs, matrix< T > const &rhs)
	matrix+matrix
template<class T >
matrix< T >	operator- (matrix< T > lhs, matrix< T > const &rhs)
	matrix-matrix
template<class T >
matrix< T >	operator* (double const &s, matrix< T > rhs)
	Scalar*matrix.
template<class T >
matrix< T >	operator* (matrix< T > lhs, double const &s)
	matrix*Scalar
template<class T >
matrix< T >	operator/ (matrix< T > lhs, double const &s)
	matrix/Scalar
template<class T >
matrix< T >	operator* (matrix< T > lhs, matrix< T > const &rhs)
	matrix*matrix
Distribution	operator* (Operator lhs, Distribution const &rhs)
	Operator*Distribution.
Operator	operator* (Operator lhs, Operator const &rhs)
	Operator*Operator.
Operator	operator* (double const &s, Operator rhs)
	Scalar*Operator.
Operator	operator* (Operator lhs, double const &s)
	Operator*Scalar.
Operator	operator* (std::function< double(double const &)> f, Operator rhs)
	function*Operator
Operator	operator* (Operator lhs, std::function< double(double const &)> f)
	Operator*function.
Operator	operator/ (Operator lhs, double const &s)
	Operator/Scalar.
Operator	operator+ (Operator lhs, Operator const &rhs)
	Operator+Operator.
Operator	operator- (Operator lhs, Operator const &rhs)
	Operator-Operator.
template<class A , class B >
Set< B >	operator* (Set< A > lhs, Set< B > const &rhs)
template<class T >
Set< T >	operator* (double const &s, Set< T > rhs)
template<class T >
Set< T >	operator* (Set< T > lhs, double const &s)
template<class T >
Set< T >	operator* (std::function< double(double const &)> f, Set< T > rhs)
template<class T >
Set< T >	operator* (Set< T > lhs, std::function< double(double const &)> f)
template<class T >
Set< T >	operator* (std::vector< double > const &v, Set< T > rhs)
template<class T >
Set< T >	operator* (Set< T > lhs, std::vector< double > const &v)
template<class T >
Set< T >	operator* (std::map< int, double > const &v, Set< T > rhs)
template<class T >
Set< T >	operator* (Set< T > lhs, std::map< int, double > const &v)
template<class T >
Set< T >	operator/ (Set< T > lhs, double const &s)
template<class T >
Set< T >	operator* (Set< T > lhs, Set< T > const &rhs)
template<class T >
Set< T >	operator+ (Set< T > lhs, Set< T > const &rhs)
template<class T >
Set< T >	operator- (Set< T > lhs, Set< T > const &rhs)
Map of Distribution functions
Function that return maps pf distributions.
std::map< int, Distribution >	DistributionMap (Grid const &g, std::function< std::map< int, double >(double const &, double const &)> const &InDistFunc, double const &Q, std::vector< int > const &skip={})
	Function that fills in a map of distributions from a map-valued function.
std::map< int, Distribution >	DistributionMap (Grid const &g, std::function< std::map< int, double >(double const &)> const &InDistFunc, std::vector< int > const &skip={})
	Function that fills in a map of distributions from a map-valued function.
std::map< int, Distribution >	DistributionMap (Grid const &g, std::function< std::vector< double >(double const &)> const &InDistFunc, int const &NOutputs=0)
	Function that fills in a map of distributions from a vector-valued function.
double	Sum (Distribution const &InDist)
	Function that sums the element of a distribution. Specifically, it sums the elements of the joint grid. Combined with the Distribution*Distribution operator, this function is useful to compute scalar products.
double	InnerProduct (Distribution const &d1, Distribution const &d2, double const &offset=0)
	Function that computes the scala product bewteen two distributions. The product is computed using the joint grids.
Jet coefficients.
Perturbative coefficients for the definction of the low-scale jet TMD depending on the jet algorithm.
double	dJetqCone1 ()
double	dJetqkT1 ()
	αs correction to the kT-algorithm jet definition
GammaV anomalous dimension.
Coefficients of the γF anomalous dimension. The expressions are taken from eq. (58) https://arxiv.org/pdf/1705.07167.pdf.
double	gammaFq0 ()
double	gammaFq1 (int const &nf)
	Quark αs2 term.
double	gammaFq2 (int const &nf)
	Quark αs3 term.
double	gammaFg0 (int const &nf)
	Gluon αs term.
double	gammaFg1 (int const &nf)
	Gluon αs2 term.
double	gammaFg2 (int const &nf)
	Gluon αs3 term.
Cusp anomalous dimension.
Coefficients of the γK anomalous dimension. The expressions up to O(αs3) are taken from eq. (59) https://arxiv.org/pdf/1705.07167.pdf. While the expressions at O(αs4) are taken from eqs. (6.3) of https://arxiv.org/pdf/1911.10174.pdf or Eq. (6) of https://arxiv.org/pdf/2002.04617v2.pdf Note All the expressions do not include an overall factor CF or CA.
double	gammaK0 ()
double	gammaK1 (int const &nf)
	αs2 term
double	gammaK2 (int const &nf)
	αs3 term
double	gammaK3 (int const &nf)
	αs4 term
double	gammaK3gmq (int const &nf)
g-functions beta.
g-functions used for the analytic evolution of the strong coupling.
double	g1beta (double const &lambda)
	g-function for the LO analytic running of the strong coupling.
double	g2beta (int const &nf, double const &kappa, double const &lambda)
	g-function for the NLO analytic running of the strong coupling.
double	g3beta (int const &nf, double const &kappa, double const &lambda)
	g-function for the NNLO analytic running of the strong coupling.
double	g4beta (int const &nf, double const &kappa, double const &lambda)
	g-function for the NNNLO analytic running of the strong coupling.
GPD object initializers
Collection of functions that initialise DglapObjects structure for the different kinds of GPD evolution currently available.
std::map< int, DglapObjects >	InitializeGpdObjects (Grid const &g, std::vector< double > const &Thresholds, double const &xi, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeGPDObjects function precomputes the perturbative coefficients of unpolarised GPD evolution kernels and store them into a 'DglapObjects' structure. GPDs are assumed to be continuous over heavy-quark thresholds.
std::map< int, DglapObjects >	InitializeGpdObjectsPol (Grid const &g, std::vector< double > const &Thresholds, double const &xi, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeGPDObjectsPol function precomputes the perturbative coefficients of polarised GPD evolution kernels and store them into a 'DglapObjects' structure. GPDs are assumed to be continuous over heavy-quark thresholds.
std::map< int, DglapObjects >	InitializeGpdObjectsTrans (Grid const &g, std::vector< double > const &Thresholds, double const &xi, bool const &OpEvol=false, double const &IntEps=1e-5)
	The InitializeGPDObjectsTrans function precomputes the perturbative coefficients of transversely polarised GPD evolution kernels and store them into a 'DglapObjects' structure. GPDs are assumed to be continuous over heavy-quark thresholds.
GTMD object initializers
Collection of functions that initialise GtmdObjects structure for the perturbartive evolution and matching currently available.
std::map< int, GtmdObjects >	InitializeGtmdObjects (Grid const &g, std::vector< double > const &Thresholds, double const &xi, double const &IntEps=1e-5)
	The InitializeGtmdObjects function precomputes the perturbative coefficients required for the evolution and matching of GTMD and store them into a 'GtmdObjects' structure.
Hard factors
Coefficients of the hard function H for the available processes.
double	H1DY ()
double	H2DY (int const &nf)
	αs2 correction to the Drell-Yan hard factor
double	H3DY (int const &nf)
	αs3 correction to the Drell-Yan hard factor
double	H1SIDIS ()
	αs correction to the SIDIS hard factor
double	H2SIDIS (int const &nf)
	αs2 correction to the SIDIS hard factor
double	H3SIDIS (int const &nf)
	αs3 correction to the SIDIS hard factor
double	H3Ch ()
double	H1ggH ()
	αs correction to the H in gg fusion hard factor
double	H2ggH (int const &nf)
	αs2 correction to the H in gg fusion hard factor
Collins-Soper anomalous dimension.
Coefficients of the Collins-Soper anomalous dimension. The expressions are taken from eq. (69) https://arxiv.org/pdf/1705.07167.pdf and from eq (D.9) of https://arxiv.org/pdf/1604.07869.pdf. Note All the expressions do not include an overall factor CF or CA.
double	KCS00 ()
double	KCS01 ()
	αsL term
double	KCS10 (int const &nf)
	αs2 term
double	KCS11 (int const &nf)
	αs2L term
double	KCS12 (int const &nf)
	αs2L2 term
double	KCS20 (int const &nf)
	αs3 term
double	KCS21 (int const &nf)
	αs3L term
double	KCS22 (int const &nf)
	αs3L2 term
double	KCS23 (int const &nf)
	αs3L3 term
Message functions
Collection of functions related to the verbosity of the code.
void	SetVerbosityLevel (int const &vl)
	Set Verbosity level.
int	GetVerbosityLevel ()
	Get Verbosity level.
void	report (std::string const &what)
	Function that prints information on screen. Effective according to the verbosity level.
void	info (std::string const &tag, std::string const &what)
	Function that prints information on screen. Effective according to the verbosity level.
void	warning (std::string const &tag, std::string const &what)
	Function that prints warnings on screen. Effective according to the verbosity level.
std::string	error (std::string const &tag, std::string const &what)
	Function that prints information on screen. Always effective.
void	Banner ()
	Function that prints the APFEL++ banner on screen. Effective according to the verbosity level.
Fortran harmonic polylogarithms
Harmonic polylogarithms up to weight five Parameters x real input argument nw maximum number of weights requested Hr1 weight 1 harmonic polylogs (1D array) Hr2 weight 2 harmonic polylogs (2D array) Hr3 weight 3 harmonic polylogs (3D array) Hr4 weight 4 harmonic polylogs (4D array) Hr5 weight 5 harmonic polylogs (5D array) n1 lower bound of the weight index requested n2 upper bound of the weight index requested Note This is just a suitably formatted wrapper of the original fortran function (see src/kernel/hplog.f) to facilitate the call of the harmonic logarithms from a C++ code.
double	apf_hplog_ (double *wx, int *wnw, double *Hr1, double *Hr2, double *Hr3, double *Hr4, double *Hr5, int *wn1, int *wn2)
Special functions
Collection of special functions needed in the evaluation of some expressions.
double	dilog (double const &x)
	Real dilogarithm .
double	wgplg (int const &n, int const &p, double const &x)
	Function for the computation of the Nielsen's generalized dilogs.
double	hpoly (std::vector< int > const &w, double const &x)
	Function for the computation of the Harmonic polylogs up to weight 5.
double	digamma (double const &x)
	Digamma function.
int	HPLogMap (std::vector< int > const &w)
	Function that returns the index to be used with unidimensional arrays returned by hplog_.
std::vector< int >	UnpackWeights (std::vector< int > const &w)
	Function that returns the unpacked weights of the HPL given the input vector.
Structure function builders
Collection of functions that build a map of Observable objects corresponding to the different component of the structure functions.
std::map< int, Observable<> >	BuildStructureFunctions (std::function< StructureFunctionObjects(double const &, std::vector< double > const &)> const &FObj, std::function< std::map< int, double >(double const &, double const &)> const &InDistFunc, int const &PerturbativeOrder, std::function< double(double const &)> const &Alphas, std::function< std::vector< double >(double const &)> const &Couplings, double const &xiR=1, double const &xiF=1)
	The BuildStructureFunctions function constructs a map of "Observable" objects.
std::map< int, Observable<> >	BuildStructureFunctions (std::function< StructureFunctionObjects(double const &, std::vector< double > const &)> const &FObj, std::function< double(int const &, double const &, double const &)> const &InDistFunc, int const &PerturbativeOrder, std::function< double(double const &)> const &Alphas, std::function< std::vector< double >(double const &)> const &Couplings, double const &xiR=1, double const &xiF=1)
	The BuildStructureFunctions function constructs a map of "Observable" objects.
Distribution	BuildStructureFunctions (StructureFunctionObjects const &FObjQ, std::map< int, Distribution > const &InDistFuncQ, int const &PerturbativeOrder, double const &AlphasQ, int const &k, double const &xiR=1, double const &xiF=1)
	The BuildStructureFunctions function constructs an "Observable" object.
std::map< int, Distribution >	BuildStructureFunctions (StructureFunctionObjects const &FObjQ, std::map< int, Distribution > const &InDistFuncQ, int const &PerturbativeOrder, double const &AlphasQ, double const &xiR=1, double const &xiF=1)
	The BuildStructureFunctions function constructs a map of "Observable" objects.
TMD object initializers
Collection of functions that initialise a TmdObjects structure for the perturbartive evolution and the matching.
std::map< int, TmdObjects >	InitializeTmdObjects (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeTmdObjects function precomputes the perturbative coefficients required for the evolution and matching of TMD PDFs and FFs and store them into a 'TmdObjects' structure.
std::map< int, TmdObjects >	InitializeTmdObjectsDYResScheme (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeTmdObjectsDYResScheme function precomputes the perturbative coefficients required for the evolution and matching of TMD PDFs and FFs and store them into a 'TmdObjects' structure. This function applies a resummation-scheme transformation to produce the scheme often used in qT resummation that has H = 1.
std::map< int, TmdObjects >	InitializeTmdObjectsBM (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeTmdObjectsBM function precomputes the perturbative coefficients required for the evolution and matching of the (gluon) Boer-Mulders TMD PDF and store them into a 'TmdObjects' structure. For now, quark and FF TMDs are not filled in.
std::map< int, TmdObjects >	InitializeTmdObjectsSivers (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeTmdObjectsSivers function precomputes the perturbative coefficients required for the evolution and matching of the quark Sivers TMD PDF and store them into a 'TmdObjects' structure. For now, gluon and FF TMDs (i.e. the Collins TMDs) are not filled in. In addition, the matching is only present up to one loop.
std::map< int, TmdObjects >	InitializeTmdObjectsg1 (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeTmdObjects function precomputes the perturbative coefficients required for the evolution and matching of TMD g1 PDFs and store them into a 'TmdObjects' structure.

Variables
const std::map< std::pair< int, int >, int >	Gkj
	The map between pair of indices corresponding to the position of the operator in the evolution matrix and its linear index.
Small numbers
Small numbers used for cutoffs, integration accuracies, etc.
const double	eps2 = 1e-2
const double	eps3 = 1e-3
const double	eps4 = 1e-4
const double	eps5 = 1e-5
const double	eps6 = 1e-6
const double	eps7 = 1e-7
const double	eps8 = 1e-8
const double	eps9 = 1e-9
const double	eps10 = 1e-10
const double	eps11 = 1e-11
const double	eps12 = 1e-12
const double	eps13 = 1e-13
const double	eps14 = 1e-14
const double	eps15 = 1e-15
const double	eps25 = 1e-25
Gauss-Legendre quadrature
Coordinates and weights of the Gauss-Legendre quadrature with 8 and 16-point integration.
const std::array< std::vector< double >, 2 >	gl_x
const std::array< std::vector< double >, 2 >	gl_w
Gauss-Kronrod quadrature
Coordinates and weights of the Gauss-Kronrod quadrature with 7 and 15-point integration.
const std::array< std::vector< double >, 2 >	gk_x
const std::array< std::vector< double >, 2 >	gk_w
Numerical constants
Definitions for recurrent constants.
const double	Pi2 = M_PI * M_PI
const double	FourPi = 4 * M_PI
const double	emc = 0.5772156649015329
const double	zeta2 = 1.6449340668482264
const double	zeta3 = 1.2020569031595943
const double	zeta4 = 1.0823232337111382
const double	zeta5 = 1.0369277551433699
const double	zeta6 = 1.0173430619844491
QCD colour factors
The SU(3) Casimir's.
const double	TR = 0.5
const double	CF = 4. / 3.
const double	CA = 3.
const double	NC = 3.
Quark charges
Quark electric charges and their square (it also includes sums of charges).
const double	ed = - 1. / 3.
const double	eu = 2. / 3.
const double	ed2 = 1. / 9.
const double	eu2 = 4. / 9.
const std::vector< double >	QCh = {ed, eu, ed, eu, ed, eu}
const std::vector< double >	QCh2 = {ed2, eu2, ed2, eu2, ed2, eu2}
const std::vector< double >	SumCh2 = {0., 1./9., 5./9., 2./3., 10./9., 11./9., 5./3.}
const std::vector< double >	SumCh4 = {0., 1./81., 17./81., 18./81., 34./81., 35./81., 51./81.}
Flavour factors required by the N<SUP>3</SUP>LO DIS coefficient functions
Their definition can be found in Tab. 2 (page 8) of https://arxiv.org/pdf/hep-ph/0504242v1.pdf.
const std::vector< double >	fl11ns = {-1, 0.5, 0, 0.5, 0.2, 0.5}
const std::vector< double >	fl11sg = {1, 0.1, 0, 0.1, 0.018181818, 0.1}
Conversion factor
Conversion factor from * GeV-2 to pb taken from: https://pdg.lbl.gov/2022/reviews/rpp2022-rev-phys-constants.pdf.
const double	ConvFact = 0.3893793721e9
Z-boson mass and width
Value of the mass of the Z boson and its width in GeV taken from: https://pdg.lbl.gov/2023/listings/rpp2023-list-z-boson.pdf.
const double	ZMass = 91.1876
const double	GammaZ = 2.4955
W-boson mass and width
Value of the mass of the W bosons and their width in GeV taken from: https://pdg.lbl.gov/2023/listings/rpp2023-list-w-boson.pdf.
const double	WMass = 80.377
const double	GammaW = 2.085
Proton mass
Value of the mass of the proton in GeV taken from: https://pdg.lbl.gov/2022/reviews/rpp2022-rev-phys-constants.pdf.
const double	ProtonMass = 0.93827208816
Weinberg angle
Value of sin2θW in the MSbar scheme taken from: https://pdg.lbl.gov/2022/reviews/rpp2022-rev-phys-constants.pdf.
const double	Sin2ThetaW = 0.23121
Fermi constant
Value of GF in GeV-2 taken from: https://pdg.lbl.gov/2022/reviews/rpp2022-rev-phys-constants.pdf.
const double	GFermi = 1.1663788e-5
const double	alphaem = 7.2973525693e-3
CKM matrix elements
Absolute value of the CMK matrix elements and their square taken from: http://pdg.lbl.gov/2018/reviews/rpp2018-rev-ckm-matrix.pdf.
const double	Vud = 0.97446
const double	Vus = 0.22452
const double	Vub = 0.00365
const double	Vcd = 0.22438
const double	Vcs = 0.97359
const double	Vcb = 0.04214
const double	Vtd = 0.00896
const double	Vts = 0.04133
const double	Vtb = 0.999105
const double	Vud2 = Vud * Vud
const double	Vus2 = Vus * Vus
const double	Vub2 = Vub * Vub
const double	Vcd2 = Vcd * Vcd
const double	Vcs2 = Vcs * Vcs
const double	Vcb2 = Vcb * Vcb
const double	Vtd2 = Vtd * Vtd
const double	Vts2 = Vts * Vts
const double	Vtb2 = Vtb * Vtb
const std::vector< double >	CKM = {Vud, Vus, Vub, Vcd, Vcs, Vcb, Vtd, Vts, Vtb}
const std::vector< double >	CKM2 = {Vud2, Vus2, Vub2, Vcd2, Vcs2, Vcb2, Vtd2, Vts2, Vtb2}
GTMD builders
Collection of functions that build a GTMD distributions as Set<Distribution>-valued functions. These functions perform evolution and matching either separately or alltogether.
std::function< Set< Distribution >(double const &, double const &, double const &)	BuildGtmds )(std::map< int, GtmdObjects > const &GtmdObj, std::function< Set< Distribution >(double const &)> const &CollGPDs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the matched and evolved GTMDs in b-space as functions of the final scale and rapidity.
std::function< Set< Distribution >(double const &)	MatchGtmds )(std::map< int, GtmdObjects > const &GtmdObj, std::function< Set< Distribution >(double const &)> const &CollGPDs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)
	Function that returns the matched TMD GPDs in b-space.
std::function< Set< Operator >(double const &)	MatchingFunctions )(std::map< int, GtmdObjects > const &GtmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)
	Function that returns the mathing functions for the GTMDs.
Runge-Kutta (RK) ODE solvers.
These functions solve the ordinary differential equation (ODE): dy / dt = f(t,y) where: dy = rk4(f(t,y)) so differentiation between lower and upper: y += dy(t,y,dt) U is the type of the 'y' object.
template<class U >
std::function< U(double const &, U const &, double const &)	rk4 )(std::function< U(double const &t, U const &Obj)> const &f)
	Template function that implements the fourth order RK algorithm.
template<class U >
std::function< U(double const &, U const &, double const &)	rk1 )(std::function< U(double const &t, U const &Obj)> const &f)
	Template function that implements the first order RK algorithm.
DIS structure function object initializers
Collection of functions that initialise StructureFunctionObjects structure for the different kinds of structure functions available.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF2NCObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeF2NCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC F2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeFLNCObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeFLNCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC FL in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF3NCObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeF3NCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC xF3 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	Initializeg4NCObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The Initializeg4NCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC g4 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializegLNCObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializegLNCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC gL in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	Initializeg1NCObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The Initializeg1NCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC xg1 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF2CCPlusObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeF2CCPlusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( F2(nu) + F2(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF2CCMinusObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeF2CCMinusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( F2(nu) - F2(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeFLCCPlusObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeFLCCPlusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( FL(nu) + FL(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeFLCCMinusObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeFLCCMinusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( FL(nu) - FL(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF3CCPlusObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeF3CCPlusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( F3(nu) + F3(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF3CCMinusObjectsZM )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeF3CCMinusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( F3(nu) - F3(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF2NCObjectsMassive )(Grid const &g, std::vector< double > const &Masses, double const &IntEps=1e-5, int const &nxi=150, double const &ximin=0.01, double const &ximax=10000, int const &intdeg=3, double const &lambda=0.0005)
	The InitializeF2NCObjectsMassive precomputes the perturbative coefficients of coefficient functions for NC F2 in the massive scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeFLNCObjectsMassive )(Grid const &g, std::vector< double > const &Masses, double const &IntEps=1e-5, int const &nxi=150, double const &ximin=0.01, double const &ximax=10000, int const &intdeg=3, double const &lambda=0.0005)
	The InitializeFLNCObjectsMassive precomputes the perturbative coefficients of coefficient functions for NC FL in the massive scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF2NCObjectsMassiveZero )(Grid const &g, std::vector< double > const &Masses, double const &IntEps=1e-5, int const &nxi=150, double const &ximin=0.01, double const &ximax=10000, int const &intdeg=3, double const &lambda=0.0005)
	The InitializeF2NCObjectsMassiveZero precomputes the perturbative coefficients of coefficient functions for NC F2 in the massless limit of the massive scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeFLNCObjectsMassiveZero )(Grid const &g, std::vector< double > const &Masses, double const &IntEps=1e-5, int const &nxi=150, double const &ximin=0.01, double const &ximax=10000, int const &intdeg=3, double const &lambda=0.0005)
	The InitializeFLNCObjectsMassiveZero precomputes the perturbative coefficients of coefficient functions for NC FL in the massless limit of the massive scheme and store them in the 'StructureFunctionObjects' structure.
SIA structure function object initializers
Collection of functions that initialise StructureFunctionObjects structure for the different kinds of structure functions available. Note For now only Zero-Mass structure functions up to O(αs) are implemented.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF2NCObjectsZMT )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeF2NCObjectsZMT precomputes the perturbative coefficients of coefficient functions for NC F2 for SIA in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeFLNCObjectsZMT )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeFLNCObjectsZMT precomputes the perturbative coefficients of coefficient functions for NC FL for SIA in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
std::function< StructureFunctionObjects(double const &, std::vector< double > const &)	InitializeF3NCObjectsZMT )(Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)
	The InitializeF3NCObjectsZMT precomputes the perturbative coefficients of coefficient functions for NC xF3 for SIA in the ZM scheme and store them in the 'StructureFunctionObjects' structure.
TMD builders
Collection of functions that build a TMD distributions (both PDFs and FFs) as Set<Distribution>-valued functions. These functions perform evolution and matching either separately or alltogether. Also a function for the computation of the hard factors is provided.
std::function< Set< Distribution >(double const &, double const &, double const &)	BuildTmdPDFs )(std::map< int, TmdObjects > const &TmdObj, std::function< Set< Distribution >(double const &)> const &CollPDFs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the matched and evolved TMD PDFs in b-space as functions of the final scale and rapidity.
std::function< Set< Distribution >(double const &, double const &, double const &)	BuildTmdFFs )(std::map< int, TmdObjects > const &TmdObj, std::function< Set< Distribution >(double const &)> const &CollFFs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the matched and evolved TMD FFs in b-space as functions of the final scale and rapidity.
std::function< double(double const &, double const &, double const &)	BuildTmdJet )(std::map< int, TmdObjects > const &TmdObj, JetAlgorithm const &JetAlgo, double const &JetR, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &CJ=1, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the TMD of a jet in b-space as functions of the final scale and rapidity.
std::function< Set< Distribution >(double const &)	MatchTmdPDFs )(std::map< int, TmdObjects > const &TmdObj, std::function< Set< Distribution >(double const &)> const &CollPDFs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)
	Function that returns the matched TMD PDFs in b-space.
std::function< Set< Distribution >(double const &)	MatchTmdFFs )(std::map< int, TmdObjects > const &TmdObj, std::function< Set< Distribution >(double const &)> const &CollFFs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)
	Function that returns the matched TMD FFs in b-space.
std::function< double(double const &, double const &)	MatchTmdJet )(std::map< int, TmdObjects > const &TmdObj, JetAlgorithm const &JetAlgo, double const &tR, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &CJ=1, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the jet TMD in b-space at the initial scale.
std::function< Set< Operator >(double const &)	MatchingFunctionsPDFs )(std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)
	Function that returns the mathing functions for the TMD PDFs.
std::function< Set< Operator >(double const &)	MatchingFunctionsFFs )(std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)
	Function that returns the mathing functions for the TMD FFs.
std::function< std::vector< double >(double const &, double const &, double const &)	EvolutionFactors )(std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the evolution factors for gluon and quarks.
std::function< std::vector< double >(double const &, double const &, double const &)	EvolutionFactorsK )(std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the evolution factors for gluon and quarks. As compared to "EvolutionFactors", this function isolates the double logs into gammaK. This is reminiscent of the qT-resummation typical way of computing the Sudakov form factor.
std::function< double(double const &, double const &, double const &)	QuarkEvolutionFactor )(std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the evolution factor for quarks.
std::function< double(double const &, double const &, double const &)	QuarkEvolutionFactorxi )(std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &xi=1, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the evolution factor for quarks with explicit dependence on the resummation-scale parameter.
std::function< double(double const &, double const &, double const &)	GluonEvolutionFactor )(std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the evolution factor for the gluon.
std::function< double(double const &)	QuarkAnalyticEvolutionFactor )(TmdObjects const &TmdObj, double const &mu0, double const &Alphas0, double const &kappa, double const &kappa0, int const &PerturbativeOrder)
	Analytic evolution factor for the quark TMD.
std::function< double(double const &)	GluonAnalyticEvolutionFactor )(TmdObjects const &TmdObj, double const &mu0, double const &Alphas0, double const &kappa, double const &kappa0, int const &PerturbativeOrder)
	Analytic evolution factor for the gluon TMD.
std::function< double(double const &, double const &)	CollinsSoperKernel )(std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)
	Function that returns the perturbative part of the Collins-Soper kernel for quarks.
std::function< double(double const &)	HardFactor )(std::string const &Process, std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Cf=1)
	Function that returns the hard factor.

Tools
Collection of useful tools.
enum	QuarkFlavour : int {   TOTAL , DOWN , UP , STRANGE ,   CHARM , BOTTOM , TOP }
int	NF (double const &Q, std::vector< double > const &Thresholds)
	Return the number of active flavours at the scale Q given the (ordered) vector of thresholds.
double	DeltaFun (double const &a, double const &b, double const &c)
	Utility function used by the heavy-quark initiated massive coefficient functions.
std::vector< double >	ElectroWeakCharges (double const &Q, bool const &virt, int const &Comp=TOTAL)
	Utility function for the computation of the electroweak charges, for both time-like and space-like virtualities (Reference: https://arxiv.org/pdf/hep-ph/9711387.pdf).
std::vector< double >	ParityViolatingElectroWeakCharges (double const &Q, bool const &virt, int const &Comp=TOTAL)
	Utility function for the computation of the parity-violating electroweak charges, for both time-like and space-like virtualities.
std::vector< double >	ElectroWeakChargesNWA ()
	Utility function for the computation of the electroweak charges for Drell-Yan in narrow-width appriximation.
std::vector< double >	ConcatenateAndSortVectors (std::vector< double > const &v1, std::vector< double > const &v2)
	Utility function that concatenates and sort the input vectors.
template<typename T >
double	dabs (T const &d)
	Absolute value of the object T. In the case of a Distribution, this is computed like the squared mean average of the entries of the joint grid. In the case of a set of distributions, the minimum dabs over the distributions is returned.
std::vector< double >	ProductExpansion (std::vector< double > const &r)
	Function that computes the coefficients of the expansion of a product of n binomials with zero's in r.
int	factorial (int const &n)
	Factorial of an integer.
double	GetSIATotalCrossSection (int const &PerturbativeOrder, double const &Q, double const &AlphaQCD, double const &AlphaQED, std::vector< double > const &Thresholds, QuarkFlavour const &Comp=TOTAL, bool const &NoCharges=false)
	Function that computes the total cross section in a electron-positron annihilation process.

Basis rotations
Collection of functions to rotate distributions from the QCD evolution basis to the phsycal basis and back. Specifically, the QCD evolution basis is: {g, Σ, V, T3, V3, T8, V8, T15, V15, T24, V24, T35, T34} while the physical basis is: { t, b, c, s, u, d, g, d, u, s, c, b, t}
const double	RotQCDEvToPhys [6][6]
	Rotation matrix from the QCD evolution to the physical basis. Inverse of RotPhysToQCDEv.
const double	RotQCDEvToPhysFull [13][13]
	Rotation matrix from the QCD evolution to the physical basis for the full bases. Inverse of RotPhysToQCDEvFull.
const double	RotPhysToQCDEv [6][6]
	Rotation matrix from the physical to the QCD evolution basis. Inverse of RotQCDEvToPhys.
const double	RotPhysToQCDEvFull [13][13]
	Rotation matrix from the physical to the QCD evolution basis for the full bases. Inverse of RotQCDEvToPhysFull.
const double	RotPhysToPlusMinus [13][13]
	Rotation matrix from the physical basis to the basis of q_{+/-} = q +/- qbar.
const double	RotPlusMinusToPhys [13][13]
	Rotation matrix from the basis of q_{+/-} = q +/- qbar to the physical basis. Inverse of RotPhysToPlusMinus.
std::map< int, double >	PhysToQCDEv (std::map< int, double > const &InPhysMap)
	Rotation from the physical to the QCD evolution basis.
Set< Distribution >	PhysToQCDEv (std::map< int, Distribution > const &InPhysMap, int const &nf)
	Rotation from the physical to the QCD evolution basis of a map of distributions.
Set< Operator >	PhysToQCDEv (std::map< int, Operator > const &InPhysMap, int const &nf)
	Rotation from the physical to the QCD evolution basis of a map of operators.
std::map< int, double >	QCDEvToPhys (std::map< int, double > const &QCDEvMap)
	Rotation from the QCD evolution to the physical basis.
std::map< int, Distribution >	QCDEvToPhys (std::map< int, Distribution > const &QCDEvMap)
	Rotation from the QCD evolution to the physical basis of a map of distributions.
std::map< int, Operator >	QCDEvToPhys (std::map< int, Operator > const &QCDEvMap)
	Rotation from the QCD evolution to the physical basis of a map of operators.
std::map< int, double >	PhysToPlusMinus (std::map< int, double > const &InPhysMap)
	Rotation from the physical to the PlusMinus basis.
std::map< int, double >	PlusMinusToPhys (std::map< int, double > const &PlusMinusMap)
	Rotation from to the PlusMinus basis to the physical basis.
std::map< int, Distribution >	PlusMinusToPhys (std::map< int, Distribution > const &PlusMinusMap)
	Rotation from to the PlusMinus basis to the physical basis of a map of distributions.

Detailed Description

Namespace for all APFEL++ functions and classes.

Enumeration Type Documentation

JetAlgorithm

enum apfel::JetAlgorithm : int

Enumerator for the jet algoritms for the jet TMDs.

Enumerator
CONE
KT

QuarkFlavour

enum apfel::QuarkFlavour : int

Quark enumerator

Enumerator
TOTAL
DOWN
UP
STRANGE
CHARM
BOTTOM
TOP

Function Documentation

apf_hplog_()

double apfel::apf_hplog_	(	double *	wx,
		int *	wnw,
		double *	Hr1,
		double *	Hr2,
		double *	Hr3,
		double *	Hr4,
		double *	Hr5,
		int *	wn1,
		int *	wn2 )

Examples

polylog_test.cc.

Banner()

void apfel::Banner

(

)

Function that prints the APFEL++ banner on screen. Effective according to the verbosity level.

Examples

dglap_test_streamlined.cc, structurefunction_cc_test.cc, structurefunction_massive_test.cc, structurefunction_nc_pol_test.cc, and structurefunction_nc_test.cc.

beta0qcd()

double apfel::beta0qcd

(

int const &

nf

)

LO coefficient of the QCD function.

Parameters

nf	the number of active flavours

Returns

Examples

massiveCF_test.cc.

beta0qed()

double apfel::beta0qed	(	int const &	nf,
		int const &	nl )

LO coefficient of the QED function.

Parameters

nf	the number of active quark flavours
nl	the number of active charged leptons

Returns

beta1qcd()

double apfel::beta1qcd

(

int const &

nf

)

NLO coefficient of the QCD function.

Parameters

nf	the number of active flavours

Returns

beta1qcdqed()

double apfel::beta1qcdqed

(

int const &

nf

)

coefficient of the QCD function.

Parameters

nf	the number of active flavours

Returns

beta1qed()

double apfel::beta1qed	(	int const &	nf,
		int const &	nl )

NLO coefficient of the QED function.

Parameters

nf	the number of active flavours
nl	the number of active charged leptons

Returns

beta1qedqcd()

double apfel::beta1qedqcd

(

int const &

nf

)

coefficient of the QCD function.

Parameters

nf	the number of active flavours

Returns

beta2qcd()

double apfel::beta2qcd

(

int const &

nf

)

NNLO coefficient of the QCD function.

Parameters

nf	the number of active flavours

Returns

beta3qcd()

double apfel::beta3qcd

(

int const &

nf

)

NNNLO coefficient of the QCD function.

Parameters

nf	the number of active flavours

Returns

beta4qcd()

double apfel::beta4qcd

(

int const &

nf

)

N4LO coefficient of the QCD function.

Parameters

nf	the number of active flavours

Returns

BuildDglap() [1/3]

std::unique_ptr< Dglap< Distribution > > apfel::BuildDglap	(	std::function< DglapObjects(double const &)> const &	DglapObj,
		std::vector< double > const &	Thresholds,
		std::function< std::map< int, double >(double const &, double const &)> const &	InDistFunc,
		double const &	MuRef,
		int const &	PerturbativeOrder,
		std::function< double(double const &)> const &	Alphas,
		int const &	nsteps = 10 )

The BuildDglap function builds the actual dglap object that performs the DGLAP evolution for distributions.

Parameters

DglapObj	DglapObjects-valued function that returns the structure with the coefficients of the perturbative objects as functions of the scale
Thresholds	the heavy-quark thresholds
InDistFunc	the distributions at the reference scale
MuRef	the reference scale
PerturbativeOrder	the perturbative order of the evolution
Alphas	the function returning the strong coupling
nsteps	the number of steps of the ODE solver (default: 10).

Returns

A unique pointer to a Dglap object

BuildDglap() [2/3]

std::unique_ptr< Dglap< Operator > > apfel::BuildDglap	(	std::map< int, DglapObjects > const &	DglapObj,
		double const &	MuRef,
		int const &	PerturbativeOrder,
		std::function< double(double const &)> const &	Alphas,
		double const &	xi = 1,
		int const &	nsteps = 10 )

The BuildDglap function builds the actual dglap object that performs the DGLAP evolution for operators.

Parameters

DglapObj	structure with the coefficients of the perturbative objects
MuRef	the reference scale
PerturbativeOrder	the perturbative order of the evolution
Alphas	the function returning the strong coupling
xi	the scale-variation parameter (default: 1)
nsteps	the number of steps of the ODE solver (default: 10).

Returns

A unique pointer to a Dglap object

BuildDglap() [3/3]

std::unique_ptr< Dglap< Distribution > > apfel::BuildDglap	(	std::map< int, DglapObjects > const &	DglapObj,
		std::function< std::map< int, double >(double const &, double const &)> const &	InDistFunc,
		double const &	MuRef,
		int const &	PerturbativeOrder,
		std::function< double(double const &)> const &	Alphas,
		double const &	xi = 1,
		int const &	nsteps = 10 )

The BuildDglap function builds the actual dglap object that performs the DGLAP evolution for distributions.

Parameters

DglapObj	structure with the coefficients of the perturbative objects
InDistFunc	the distributions at the reference scale
MuRef	the reference scale
PerturbativeOrder	the perturbative order of the evolution
Alphas	the function returning the strong coupling
xi	the scale-variation parameter (default: 1)
nsteps	the number of steps of the ODE solver (default: 10).

Returns

A unique pointer to a Dglap object

BuildStructureFunctions() [1/4]

std::map< int, Observable<> > apfel::BuildStructureFunctions	(	std::function< StructureFunctionObjects(double const &, std::vector< double > const &)> const &	FObj,
		std::function< double(int const &, double const &, double const &)> const &	InDistFunc,
		int const &	PerturbativeOrder,
		std::function< double(double const &)> const &	Alphas,
		std::function< std::vector< double >(double const &)> const &	Couplings,
		double const &	xiR = 1,
		double const &	xiF = 1 )

The BuildStructureFunctions function constructs a map of "Observable" objects.

Parameters

FObj	the StructureFunctionObjects-valued for the structure function objects
InDistFunc	the distribution to be convoluted with as a double-valued function of i, x, and Q
PerturbativeOrder	the perturbative order
Alphas	the strong coupling function
Couplings	the vector-valued function of (non-QCD) couplings
xiR	the renormalisation scale-variation factor (default: 1)
xiF	the factorisation scale-variation factor (default: 1)

Returns

A map of "Observable" objects, one for number of active flavours

BuildStructureFunctions() [2/4]

std::map< int, Observable<> > apfel::BuildStructureFunctions	(	std::function< StructureFunctionObjects(double const &, std::vector< double > const &)> const &	FObj,
		std::function< std::map< int, double >(double const &, double const &)> const &	InDistFunc,
		int const &	PerturbativeOrder,
		std::function< double(double const &)> const &	Alphas,
		std::function< std::vector< double >(double const &)> const &	Couplings,
		double const &	xiR = 1,
		double const &	xiF = 1 )

The BuildStructureFunctions function constructs a map of "Observable" objects.

Parameters

FObj	the StructureFunctionObjects-valued for the structure function objects
InDistFunc	the distribution to be convoluted with as a map<int,double>-valued function of x and Q
PerturbativeOrder	the perturbative order
Alphas	the strong coupling function
Couplings	the vector-valued function of (non-QCD) couplings
xiR	the renormalisation scale-variation factor (default: 1)
xiF	the factorisation scale-variation factor (default: 1)

Returns

A map of "Observable" objects, one for number of active flavours

BuildStructureFunctions() [3/4]

std::map< int, Distribution > apfel::BuildStructureFunctions	(	StructureFunctionObjects const &	FObjQ,
		std::map< int, Distribution > const &	InDistFuncQ,
		int const &	PerturbativeOrder,
		double const &	AlphasQ,
		double const &	xiR = 1,
		double const &	xiF = 1 )

The BuildStructureFunctions function constructs a map of "Observable" objects.

Parameters

FObjQ	the StructureFunctionObjects at the scale Q
InDistFuncQ	the distribution to be convoluted with at the scale Q as a map<int, Distribution>
PerturbativeOrder	the perturbative order
AlphasQ	the strong coupling at the scale Q
xiR	the renormalisation scale-variation factor (default: 1)
xiF	the factorisation scale-variation factor (default: 1)

Returns

A map of "Distribution" objects, one for each number of active flavours

BuildStructureFunctions() [4/4]

Distribution apfel::BuildStructureFunctions	(	StructureFunctionObjects const &	FObjQ,
		std::map< int, Distribution > const &	InDistFuncQ,
		int const &	PerturbativeOrder,
		double const &	AlphasQ,
		int const &	k,
		double const &	xiR = 1,
		double const &	xiF = 1 )

The BuildStructureFunctions function constructs an "Observable" object.

Parameters

FObjQ	the StructureFunctionObjects at the scale Q
InDistFuncQ	the distribution to be convoluted with at the scale Q as a map<int,Distribution>
PerturbativeOrder	the perturbative order
AlphasQ	the strong coupling at the scale Q
k	the observable index
xiR	the renormalisation scale-variation factor (default: 1)
xiF	the factorisation scale-variation factor (default: 1)

Returns

A "Distribution" object

ConcatenateAndSortVectors()

std::vector< double > apfel::ConcatenateAndSortVectors	(	std::vector< double > const &	v1,
		std::vector< double > const &	v2 )

Utility function that concatenates and sort the input vectors.

Parameters

v1	first vector
v2	second vector

Returns

a std::vector containing the sorted entries of 'v1' and 'v2'

dabs()

template<typename T >

double apfel::dabs

(

T const &

d

)

Absolute value of the object T. In the case of a Distribution, this is computed like the squared mean average of the entries of the joint grid. In the case of a set of distributions, the minimum dabs over the distributions is returned.

Parameters

d	input object

Returns

the absolute value

DeltaFun()

double apfel::DeltaFun	(	double const &	a,
		double const &	b,
		double const &	c )

Utility function used by the heavy-quark initiated massive coefficient functions.

Parameters

a	first parameter
b	second parameter
c	third parameter

Returns

Triangular function

digamma()

double apfel::digamma

(

double const &

x

)

Digamma function.

Parameters

x	real argument

Returns

The digamma funciton computed at x.

Note

C++ (real) adaptation of the FORTRAN (complex) implementation present in the PEGASUS code (hep-ph/0408244).

dilog()

double apfel::dilog

(

double const &

x

)

Real dilogarithm .

Parameters

x	the real argument

Returns

Note

Implementation translated by R.Brun from CERNLIB DILOG function C332.

Examples

polylog_test.cc.

DistributionMap() [1/3]

std::map< int, Distribution > apfel::DistributionMap	(	Grid const &	g,
		std::function< std::map< int, double >(double const &)> const &	InDistFunc,
		std::vector< int > const &	skip = {} )

Function that fills in a map of distributions from a map-valued function.

Parameters

g	Grid object
InDistFunc	map-valued function dependent on x
skip	vector of indices to be skipped in the tabulation.

DistributionMap() [2/3]

std::map< int, Distribution > apfel::DistributionMap	(	Grid const &	g,
		std::function< std::map< int, double >(double const &, double const &)> const &	InDistFunc,
		double const &	Q,
		std::vector< int > const &	skip = {} )

Function that fills in a map of distributions from a map-valued function.

Parameters

g	Grid object
InDistFunc	map-valued function dependent on x and a scale Q.
Q	the value of Q in which InDistFunc has to be tabulated
skip	vector of indices to be skipped in the tabulation.

DistributionMap() [3/3]

std::map< int, Distribution > apfel::DistributionMap	(	Grid const &	g,
		std::function< std::vector< double >(double const &)> const &	InDistFunc,
		int const &	NOutputs = 0 )

Function that fills in a map of distributions from a vector-valued function.

Parameters

g	Grid object
InDistFunc	vector-valued function dependent on x
NOutputs	number of outputs of the input function (default: 0, that is unknown)

dJetqCone1()

double apfel::dJetqCone1

(

)

α_s correction to the cone-algorithm jet definition

dJetqkT1()

double apfel::dJetqkT1

(

)

α_s correction to the kT-algorithm jet definition

ElectroWeakCharges()

std::vector< double > apfel::ElectroWeakCharges	(	double const &	Q,
		bool const &	virt,
		int const &	Comp = TOTAL )

Utility function for the computation of the electroweak charges, for both time-like and space-like virtualities (Reference: https://arxiv.org/pdf/hep-ph/9711387.pdf).

Parameters

Q	absolute value the virtuality of the vector boson
virt	virtuality (true: time-like, false: space-like)
Comp	the flavour selector (default: TOTAL, i.e. all flavours are computed)

Returns

the std::vector of the electroweak charges

Examples

structurefunction_massive_test.cc, structurefunction_nc_pol_test.cc, structurefunction_nc_test.cc, and tmd_test.cc.

ElectroWeakChargesNWA()

std::vector< double > apfel::ElectroWeakChargesNWA

(

)

Utility function for the computation of the electroweak charges for Drell-Yan in narrow-width appriximation.

Returns

the std::vector of the electroweak charges

error()

std::string apfel::error	(	std::string const &	tag,
		std::string const &	what )

Function that prints information on screen. Always effective.

Parameters

tag	the function that generates the error
what	the error to report

Returns

the error message

factorial()

int apfel::factorial

(

int const &

n

)

Factorial of an integer.

Parameters

n	input integer

g1beta()

double apfel::g1beta

(

double const &

lambda

)

g-function for the LO analytic running of the strong coupling.

Parameters

lambda

evolution parameter

Returns

the g1 function

g2beta()

double apfel::g2beta	(	int const &	nf,
		double const &	kappa,
		double const &	lambda )

g-function for the NLO analytic running of the strong coupling.

Parameters

nf	the number of active flavours
kappa	the resummation-scale parameter
lambda	evolution parameter

Returns

the g2 function

g3beta()

double apfel::g3beta	(	int const &	nf,
		double const &	kappa,
		double const &	lambda )

g-function for the NNLO analytic running of the strong coupling.

Parameters

nf	the number of active flavours
kappa	the resummation-scale parameter
lambda	evolution parameter

Returns

the g3 function

g4beta()

double apfel::g4beta	(	int const &	nf,
		double const &	kappa,
		double const &	lambda )

g-function for the NNNLO analytic running of the strong coupling.

Parameters

nf	the number of active flavours
kappa	the resummation-scale parameter
lambda	evolution parameter

Returns

the g3 function

gammaFg0()

double apfel::gammaFg0

(

int const &

nf

)

Gluon α_s term.

gammaFg1()

double apfel::gammaFg1

(

int const &

nf

)

Gluon α_s² term.

gammaFg2()

double apfel::gammaFg2

(

int const &

nf

)

Gluon α_s³ term.

gammaFq0()

double apfel::gammaFq0

(

)

Quark α_s term

gammaFq1()

double apfel::gammaFq1

(

int const &

nf

)

Quark α_s² term.

gammaFq2()

double apfel::gammaFq2

(

int const &

nf

)

Quark α_s³ term.

gammaK0()

double apfel::gammaK0

(

)

α_s term

gammaK1()

double apfel::gammaK1

(

int const &

nf

)

α_s² term

gammaK2()

double apfel::gammaK2

(

int const &

nf

)

α_s³ term

gammaK3()

double apfel::gammaK3

(

int const &

nf

)

α_s⁴ term

gammaK3gmq()

double apfel::gammaK3gmq

(

int const &

nf

)

α_s⁴ correction to the quark anonalous dimension needed to obtain the gluon anomalous dimension (neglected for now).

GetSIATotalCrossSection()

double apfel::GetSIATotalCrossSection	(	int const &	PerturbativeOrder,
		double const &	Q,
		double const &	AlphaQCD,
		double const &	AlphaQED,
		std::vector< double > const &	Thresholds,
		QuarkFlavour const &	Comp = TOTAL,
		bool const &	NoCharges = false )

Function that computes the total cross section in a electron-positron annihilation process.

Parameters

PerturbativeOrder	perturbative order of the computation
Q	vector-boson invariant mass
AlphaQCD	value of the strong coupling at Q
AlphaQED	value of the electromagnetic coupling at Q
Thresholds	heavy-quark thresholds
Comp	component of the cross section, e.g. charm, bottom, etc. (default = TOTAL)
NoCharges	whether to exclude the sum over the charge of the active flavours (default = false)

Returns

the total cross section (in nbarn)

Note

The QCD corrections to the total cross section in a electron-positron annihilation process are taken from Phys.Lett. B259 (1991) 144–150.

Examples

siaxsec_test.cc.

GetVerbosityLevel()

int apfel::GetVerbosityLevel

(

)

Get Verbosity level.

Returns

the current verbosity level

H1DY()

double apfel::H1DY

(

)

α_s correction to the Drell-Yan hard factor

H1ggH()

double apfel::H1ggH

(

)

α_s correction to the H in gg fusion hard factor

H1SIDIS()

double apfel::H1SIDIS

(

)

α_s correction to the SIDIS hard factor

H2DY()

double apfel::H2DY

(

int const &

nf

)

α_s² correction to the Drell-Yan hard factor

H2ggH()

double apfel::H2ggH

(

int const &

nf

)

α_s² correction to the H in gg fusion hard factor

H2SIDIS()

double apfel::H2SIDIS

(

int const &

nf

)

α_s² correction to the SIDIS hard factor

H3Ch()

double apfel::H3Ch

(

)

α_s³ charge-dependent correction to DY and SIDIS hard factor

H3DY()

double apfel::H3DY

(

int const &

nf

)

α_s³ correction to the Drell-Yan hard factor

H3SIDIS()

double apfel::H3SIDIS

(

int const &

nf

)

α_s³ correction to the SIDIS hard factor

HPLogMap()

int apfel::HPLogMap

(

std::vector< int > const &

w

)

Function that returns the index to be used with unidimensional arrays returned by hplog_.

Parameters

w	the packed vector of weights

Examples

polylog_test.cc.

hpoly()

double apfel::hpoly	(	std::vector< int > const &	w,
		double const &	x )

Function for the computation of the Harmonic polylogs up to weight 5.

Parameters

w	vector of weights
x	real argument

Returns

Note

C++ adaptation of the FORTRAN implementation discussed in https://arxiv.org/pdf/1809.07084.pdf. The argument x is limited to the interval [0, sqrt(2)-1].

Examples

polylog_test.cc.

info()

void apfel::info	(	std::string const &	tag,
		std::string const &	what )

Function that prints information on screen. Effective according to the verbosity level.

Parameters

tag	the emitter of the message
what	the message to report

InitializeDglapObjectsQCD() [1/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCD	(	Grid const &	g,
		std::vector< double > const &	Masses,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCD function precomputes the perturbative coefficients of space-like unpolarised splitting functions and matching conditions and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy-quark masses
Thresholds	the heavy quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

InitializeDglapObjectsQCD() [2/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCD	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCD function precomputes the perturbative coefficients of space-like unpolarised splitting functions and matching conditions and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy-quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

Note

This function assumes that masses and thresholds coincide.

InitializeDglapObjectsQCDpol() [1/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCDpol	(	Grid const &	g,
		std::vector< double > const &	Masses,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCDpol function precomputes the perturbative coefficients of space-like longitudinally polarised splitting functions and matching conditions (assumed to be equal to the unpolarised ones) and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy-quark masses
Thresholds	the heavy quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

InitializeDglapObjectsQCDpol() [2/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCDpol	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCDpol function precomputes the perturbative coefficients of space-like longitudinally polarised splitting functions and matching conditions (assumed to be equal to the unpolarised ones) and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy-quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

Note

This function assumes that masses and thresholds coincide.

InitializeDglapObjectsQCDT() [1/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCDT	(	Grid const &	g,
		std::vector< double > const &	Masses,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCDT function precomputes the perturbative coefficients of time-like unpolarised splitting functions and matching conditions and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy-quark masses
Thresholds	the heavy quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

InitializeDglapObjectsQCDT() [2/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCDT	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCDT function precomputes the perturbative coefficients of time-like unpolarised splitting functions and matching conditions and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy-quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

Note

This function assumes that masses and thresholds coincide.

InitializeDglapObjectsQCDtrans() [1/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCDtrans	(	Grid const &	g,
		std::vector< double > const &	Masses,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCDtrans function precomputes the perturbative coefficients of space-like transverity splitting functions and matching conditions and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy-quark masses
Thresholds	the heavy quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

InitializeDglapObjectsQCDtrans() [2/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCDtrans	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCDtrans function precomputes the perturbative coefficients of space-like transverity splitting functions and matching conditions and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy-quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

Note

This function assumes that masses and thresholds coincide.

InitializeDglapObjectsQCDTtrans() [1/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCDTtrans	(	Grid const &	g,
		std::vector< double > const &	Masses,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCDtrans function precomputes the perturbative coefficients of timelike-like transverity splitting functions and matching conditions and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy-quark masses
Thresholds	the heavy quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

InitializeDglapObjectsQCDTtrans() [2/2]

std::map< int, DglapObjects > apfel::InitializeDglapObjectsQCDTtrans	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeDglapObjectsQCDtrans function precomputes the perturbative coefficients of time-like transverity splitting functions and matching conditions and store them into a 'DglapObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy-quark thresholds
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

Note

This function assumes that masses and thresholds coincide.

InitializeGpdObjects()

std::map< int, DglapObjects > apfel::InitializeGpdObjects	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	xi,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeGPDObjects function precomputes the perturbative coefficients of unpolarised GPD evolution kernels and store them into a 'DglapObjects' structure. GPDs are assumed to be continuous over heavy-quark thresholds.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
xi	value of the skewness
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

InitializeGpdObjectsPol()

std::map< int, DglapObjects > apfel::InitializeGpdObjectsPol	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	xi,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeGPDObjectsPol function precomputes the perturbative coefficients of polarised GPD evolution kernels and store them into a 'DglapObjects' structure. GPDs are assumed to be continuous over heavy-quark thresholds.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
xi	value of the skewness
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

InitializeGpdObjectsTrans()

std::map< int, DglapObjects > apfel::InitializeGpdObjectsTrans	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	xi,
		bool const &	OpEvol = false,
		double const &	IntEps = 1e-5 )

The InitializeGPDObjectsTrans function precomputes the perturbative coefficients of transversely polarised GPD evolution kernels and store them into a 'DglapObjects' structure. GPDs are assumed to be continuous over heavy-quark thresholds.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
xi	value of the skewness
OpEvol	the switch for the computation of the evolution operator (default: false)
IntEps	the integration accuracy (default: 10-5)

Returns

A map of DglapObject objects, one for each possible nf

InitializeGtmdObjects()

std::map< int, GtmdObjects > apfel::InitializeGtmdObjects	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	xi,
		double const &	IntEps = 1e-5 )

The InitializeGtmdObjects function precomputes the perturbative coefficients required for the evolution and matching of GTMD and store them into a 'GtmdObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
xi	value of the skewness
IntEps	the integration accuracy (default: 10-5)

Returns

A map of GtmdObjects, one for each possible nf

InitializeTmdObjects()

std::map< int, TmdObjects > apfel::InitializeTmdObjects	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeTmdObjects function precomputes the perturbative coefficients required for the evolution and matching of TMD PDFs and FFs and store them into a 'TmdObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5)

Returns

A map of TmdObject objects, one for each possible nf

Examples

tmd_test.cc.

InitializeTmdObjectsBM()

std::map< int, TmdObjects > apfel::InitializeTmdObjectsBM	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeTmdObjectsBM function precomputes the perturbative coefficients required for the evolution and matching of the (gluon) Boer-Mulders TMD PDF and store them into a 'TmdObjects' structure. For now, quark and FF TMDs are not filled in.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-7)

Returns

A map of TmdObject objects, one for each possible nf

InitializeTmdObjectsDYResScheme()

std::map< int, TmdObjects > apfel::InitializeTmdObjectsDYResScheme	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeTmdObjectsDYResScheme function precomputes the perturbative coefficients required for the evolution and matching of TMD PDFs and FFs and store them into a 'TmdObjects' structure. This function applies a resummation-scheme transformation to produce the scheme often used in qT resummation that has H = 1.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5)

Returns

A map of TmdObject objects, one for each possible nf

InitializeTmdObjectsg1()

std::map< int, TmdObjects > apfel::InitializeTmdObjectsg1	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeTmdObjects function precomputes the perturbative coefficients required for the evolution and matching of TMD g1 PDFs and store them into a 'TmdObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5)

Returns

A map of TmdObject objects, one for each possible nf

InitializeTmdObjectsSivers()

std::map< int, TmdObjects > apfel::InitializeTmdObjectsSivers	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeTmdObjectsSivers function precomputes the perturbative coefficients required for the evolution and matching of the quark Sivers TMD PDF and store them into a 'TmdObjects' structure. For now, gluon and FF TMDs (i.e. the Collins TMDs) are not filled in. In addition, the matching is only present up to one loop.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-7)

Returns

A map of TmdObject objects, one for each possible nf

InnerProduct()

double apfel::InnerProduct	(	Distribution const &	d1,
		Distribution const &	d2,
		double const &	offset = 0 )

Function that computes the scala product bewteen two distributions. The product is computed using the joint grids.

Parameters

d1	first input distribution
d2	second input distribution
offset	offset applied to the inner product (default: 0)

KCS00()

double apfel::KCS00

(

)

α_s term

KCS01()

double apfel::KCS01

(

)

α_sL term

KCS10()

double apfel::KCS10

(

int const &

nf

)

α_s² term

KCS11()

double apfel::KCS11

(

int const &

nf

)

α_s²L term

KCS12()

double apfel::KCS12

(

int const &

nf

)

α_s²L² term

KCS20()

double apfel::KCS20

(

int const &

nf

)

α_s³ term

KCS21()

double apfel::KCS21

(

int const &

nf

)

α_s³L term

KCS22()

double apfel::KCS22

(

int const &

nf

)

α_s³L² term

KCS23()

double apfel::KCS23

(

int const &

nf

)

α_s³L³ term

NF()

int apfel::NF	(	double const &	Q,
		std::vector< double > const &	Thresholds )

Return the number of active flavours at the scale Q given the (ordered) vector of thresholds.

Parameters

Q	the scale
Thresholds	the vector of thresholds

Returns

number of active flavours at Q

Examples

tmd_test.cc.

operator*() [1/28]

Distribution apfel::operator*	(	Distribution	lhs,
		Distribution const &	rhs )

Distribution*Distribution.

operator*() [2/28]

Distribution apfel::operator*	(	Distribution	lhs,
		double const &	s )

Distribution*Scalar.

operator*() [3/28]

Distribution apfel::operator*	(	Distribution	lhs,
		std::function< double(double const &)> const &	f )

Distribution*Function.

operator*() [4/28]

Distribution apfel::operator*	(	double const &	s,
		Distribution	rhs )

Scalar*Distribution.

operator*() [5/28]

template<class T , class U >

DoubleObject< T, U > apfel::operator*	(	double const &	s,
		DoubleObject< T, U >	rhs )

operator*() [6/28]

template<class T >

matrix< T > apfel::operator*	(	double const &	s,
		matrix< T >	rhs )

Scalar*matrix.

operator*() [7/28]

Operator apfel::operator*	(	double const &	s,
		Operator	rhs )

Scalar*Operator.

operator*() [8/28]

template<class T >

Set< T > apfel::operator*	(	double const &	s,
		Set< T >	rhs )

operator*() [9/28]

template<class A , class B >

DoubleObject< B > apfel::operator*	(	DoubleObject< A >	lhs,
		DoubleObject< B > const &	rhs )

operator*() [10/28]

template<class T , class U >

DoubleObject< T, U > apfel::operator*	(	DoubleObject< T, U >	lhs,
		double const &	s )

operator*() [11/28]

template<class T , class U >

DoubleObject< T, U > apfel::operator*	(	DoubleObject< T, U >	lhs,
		DoubleObject< T, U > const &	rhs )

operator*() [12/28]

template<class T >

matrix< T > apfel::operator*	(	matrix< T >	lhs,
		double const &	s )

matrix*Scalar

operator*() [13/28]

template<class T >

matrix< T > apfel::operator*	(	matrix< T >	lhs,
		matrix< T > const &	rhs )

matrix*matrix

operator*() [14/28]

Distribution apfel::operator*	(	Operator	lhs,
		Distribution const &	rhs )

Operator*Distribution.

operator*() [15/28]

Operator apfel::operator*	(	Operator	lhs,
		double const &	s )

Operator*Scalar.

operator*() [16/28]

Operator apfel::operator*	(	Operator	lhs,
		Operator const &	rhs )

Operator*Operator.

operator*() [17/28]

Operator apfel::operator*	(	Operator	lhs,
		std::function< double(double const &)>	f )

Operator*function.

operator*() [18/28]

template<class A , class B >

Set< B > apfel::operator*	(	Set< A >	lhs,
		Set< B > const &	rhs )

operator*() [19/28]

template<class T >

Set< T > apfel::operator*	(	Set< T >	lhs,
		double const &	s )

operator*() [20/28]

template<class T >

Set< T > apfel::operator*	(	Set< T >	lhs,
		Set< T > const &	rhs )

operator*() [21/28]

template<class T >

Set< T > apfel::operator*	(	Set< T >	lhs,
		std::function< double(double const &)>	f )

operator*() [22/28]

template<class T >

Set< T > apfel::operator*	(	Set< T >	lhs,
		std::map< int, double > const &	v )

operator*() [23/28]

template<class T >

Set< T > apfel::operator*	(	Set< T >	lhs,
		std::vector< double > const &	v )

operator*() [24/28]

Distribution apfel::operator*	(	std::function< double(double const &)> const &	f,
		Distribution	rhs )

Function*Distribution.

operator*() [25/28]

Operator apfel::operator*	(	std::function< double(double const &)>	f,
		Operator	rhs )

function*Operator

operator*() [26/28]

template<class T >

Set< T > apfel::operator*	(	std::function< double(double const &)>	f,
		Set< T >	rhs )

operator*() [27/28]

template<class T >

Set< T > apfel::operator*	(	std::map< int, double > const &	v,
		Set< T >	rhs )

operator*() [28/28]

template<class T >

Set< T > apfel::operator*	(	std::vector< double > const &	v,
		Set< T >	rhs )

operator+() [1/5]

Distribution apfel::operator+	(	Distribution	lhs,
		Distribution const &	rhs )

Distribution+Distribution.

operator+() [2/5]

template<class T , class U >

DoubleObject< T, U > apfel::operator+	(	DoubleObject< T, U >	lhs,
		DoubleObject< T, U > const &	rhs )

operator+() [3/5]

template<class T >

matrix< T > apfel::operator+	(	matrix< T >	lhs,
		matrix< T > const &	rhs )

matrix+matrix

operator+() [4/5]

Operator apfel::operator+	(	Operator	lhs,
		Operator const &	rhs )

Operator+Operator.

operator+() [5/5]

template<class T >

Set< T > apfel::operator+	(	Set< T >	lhs,
		Set< T > const &	rhs )

operator-() [1/5]

Distribution apfel::operator-	(	Distribution	lhs,
		Distribution const &	rhs )

Distribution-Distribution.

operator-() [2/5]

template<class T , class U >

DoubleObject< T, U > apfel::operator-	(	DoubleObject< T, U >	lhs,
		DoubleObject< T, U > const &	rhs )

operator-() [3/5]

template<class T >

matrix< T > apfel::operator-	(	matrix< T >	lhs,
		matrix< T > const &	rhs )

matrix-matrix

operator-() [4/5]

Operator apfel::operator-	(	Operator	lhs,
		Operator const &	rhs )

Operator-Operator.

operator-() [5/5]

template<class T >

Set< T > apfel::operator-	(	Set< T >	lhs,
		Set< T > const &	rhs )

operator/() [1/5]

Distribution apfel::operator/	(	Distribution	lhs,
		double const &	s )

Distribution/Scalar.

operator/() [2/5]

template<class T , class U >

DoubleObject< T, U > apfel::operator/	(	DoubleObject< T, U >	lhs,
		double const &	s )

operator/() [3/5]

template<class T >

matrix< T > apfel::operator/	(	matrix< T >	lhs,
		double const &	s )

matrix/Scalar

operator/() [4/5]

Operator apfel::operator/	(	Operator	lhs,
		double const &	s )

Operator/Scalar.

operator/() [5/5]

template<class T >

Set< T > apfel::operator/	(	Set< T >	lhs,
		double const &	s )

operator<<() [1/7]

std::ostream & apfel::operator<<	(	std::ostream &	os,
		ConvolutionMap const &	cm )

Method which prints ConvolutionMap with cout <<.

operator<<() [2/7]

template<class T , class U >

std::ostream & apfel::operator<<	(	std::ostream &	os,
		DoubleObject< T, U > const &	dob )

Method which prints the double object with cout <<.

operator<<() [3/7]

std::ostream & apfel::operator<<	(	std::ostream &	os,
		Grid const &	gr )

Overload the << operator to print the parameters of the grid.

operator<<() [4/7]

std::ostream & apfel::operator<<	(	std::ostream &	os,
		Interpolator const &	in )

Method which prints Interpolator with cout <<. This only prints the first subgrid and is supposed to be used for debugging purposes.

operator<<() [5/7]

std::ostream & apfel::operator<<	(	std::ostream &	os,
		Operator const &	op )

Method which prints Operator with cout <<. This only prints the Operator on the first subgrid and is supposed to be used for debugging purposes.

operator<<() [6/7]

template<class T >

std::ostream & apfel::operator<< ( std::ostream & os, QGrid< T > const & Qg )

inline

Method that prints QGrid with cout <<.

operator<<() [7/7]

std::ostream & apfel::operator<<	(	std::ostream &	os,
		SubGrid const &	sg )

Method which prints SubGrid with cout <<.

ParityViolatingElectroWeakCharges()

std::vector< double > apfel::ParityViolatingElectroWeakCharges	(	double const &	Q,
		bool const &	virt,
		int const &	Comp = TOTAL )

Utility function for the computation of the parity-violating electroweak charges, for both time-like and space-like virtualities.

Parameters

Q	absolute value the virtuality of the vector boson
virt	virtuality (true: time-like, false: space-like)
Comp	the flavour selector (default: TOTAL, i.e. all flavours are computed)

Returns

the std::vector of the electroweak charges

Examples

structurefunction_nc_pol_test.cc, and structurefunction_nc_test.cc.

PhysToPlusMinus()

std::map< int, double > apfel::PhysToPlusMinus

(

std::map< int, double > const &

InPhysMap

)

Rotation from the physical to the PlusMinus basis.

Parameters

InPhysMap

the map in the physical basis

Returns

The map in the PlusMinus basis

PhysToQCDEv() [1/3]

Set< Distribution > apfel::PhysToQCDEv	(	std::map< int, Distribution > const &	InPhysMap,
		int const &	nf )

Rotation from the physical to the QCD evolution basis of a map of distributions.

Parameters

InPhysMap	the map in the physical basis
nf	the the number of active flavours

Returns

The set of distributions in the QCD evolution basis

PhysToQCDEv() [2/3]

std::map< int, double > apfel::PhysToQCDEv

(

std::map< int, double > const &

InPhysMap

)

Rotation from the physical to the QCD evolution basis.

Parameters

InPhysMap

the map in the physical basis

Returns

The map in the QCD evolution basis

PhysToQCDEv() [3/3]

Set< Operator > apfel::PhysToQCDEv	(	std::map< int, Operator > const &	InPhysMap,
		int const &	nf )

Rotation from the physical to the QCD evolution basis of a map of operators.

Parameters

InPhysMap	the map in the physical basis
nf	the the number of active flavours

Returns

The set of operators in the QCD evolution basis

PlusMinusToPhys() [1/2]

std::map< int, Distribution > apfel::PlusMinusToPhys

(

std::map< int, Distribution > const &

PlusMinusMap

)

Rotation from to the PlusMinus basis to the physical basis of a map of distributions.

Parameters

PlusMinusMap

the map in the PlusMinus basis

Returns

The map of distributions in the physical basis

PlusMinusToPhys() [2/2]

std::map< int, double > apfel::PlusMinusToPhys

(

std::map< int, double > const &

PlusMinusMap

)

Rotation from to the PlusMinus basis to the physical basis.

Parameters

PlusMinusMap

the map in the PlusMinus basis

Returns

The map in the physical basis

ProductExpansion()

std::vector< double > apfel::ProductExpansion

(

std::vector< double > const &

r

)

Function that computes the coefficients of the expansion of a product of n binomials with zero's in r.

Parameters

r	input vector of zero's

Examples

expansion_test.cc.

QCDEvToPhys() [1/3]

std::map< int, Distribution > apfel::QCDEvToPhys

(

std::map< int, Distribution > const &

QCDEvMap

)

Rotation from the QCD evolution to the physical basis of a map of distributions.

Parameters

QCDEvMap

The map of distributions in the QCD evolution basis

Returns

the map of distributions in the physical basis

QCDEvToPhys() [2/3]

std::map< int, double > apfel::QCDEvToPhys

(

std::map< int, double > const &

QCDEvMap

)

Rotation from the QCD evolution to the physical basis.

Parameters

QCDEvMap

The map in the QCD evolution basis

Returns

the map in the physical basis

Examples

dglap_test.cc, dglap_test_streamlined.cc, and gpd_test.cc.

QCDEvToPhys() [3/3]

std::map< int, Operator > apfel::QCDEvToPhys

(

std::map< int, Operator > const &

QCDEvMap

)

Rotation from the QCD evolution to the physical basis of a map of operators.

Parameters

QCDEvMap

The map of operatoirs in the QCD evolution basis

Returns

the map of operators in the physical basis

report()

void apfel::report

(

std::string const &

what

)

Function that prints information on screen. Effective according to the verbosity level.

Parameters

what	the message to report

SetVerbosityLevel()

void apfel::SetVerbosityLevel

(

int const &

vl

)

Set Verbosity level.

Parameters

vl	verbosity level

Note

possible values of vl: LOW = No informative and warning messages are displayed. Error messages are printed anyway MEDIUM = No informative messages are displayed. Warning and error messages are printed HIGH = All messages are displayed

Sum()

double apfel::Sum

(

Distribution const &

InDist

)

Function that sums the element of a distribution. Specifically, it sums the elements of the joint grid. Combined with the Distribution*Distribution operator, this function is useful to compute scalar products.

Parameters

InDist

distribution to be summed over

UnpackWeights()

std::vector< int > apfel::UnpackWeights

(

std::vector< int > const &

w

)

Function that returns the unpacked weights of the HPL given the input vector.

Parameters

w	the packed vector of weights

warning()

void apfel::warning	(	std::string const &	tag,
		std::string const &	what )

Function that prints warnings on screen. Effective according to the verbosity level.

Parameters

tag	the emitter of the message
what	the warning to report

wgplg()

double apfel::wgplg	(	int const &	n,
		int const &	p,
		double const &	x )

Function for the computation of the Nielsen's generalized dilogs.

Parameters

n	integer argument
p	integer argument
x	real argument

Returns

Note

Implementation translated from CERNLIB WGPLG.

Examples

polylog_test.cc.

Variable Documentation

BuildGtmds

std::function< Set< Distribution >(double const &, double const &, double const &) apfel::BuildGtmds) (std::map< int, GtmdObjects > const &GtmdObj, std::function< Set< Distribution >(double const &)> const &CollGPDs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, GtmdObjects > const &	GtmdObj,
		std::function< Set< Distribution >(double const &)> const &	CollGPDs,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the matched and evolved GTMDs in b-space as functions of the final scale and rapidity.

Parameters

GtmdObj	the GTMD objects
CollGPDs	the set of collinear GPDs to be matched
Alphas	the strong coupling function
PerturbativeOrder	the perturbative order
Ci	the initial-scale variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

Set<Distribution>-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ representing the evolved GTMDs.

BuildTmdFFs

std::function< Set< Distribution >(double const &, double const &, double const &) apfel::BuildTmdFFs) (std::map< int, TmdObjects > const &TmdObj, std::function< Set< Distribution >(double const &)> const &CollFFs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< Set< Distribution >(double const &)> const &	CollFFs,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the matched and evolved TMD FFs in b-space as functions of the final scale and rapidity.

Parameters

TmdObj	the TMD objects
CollFFs	the set of collinear PDFs to be matched
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial-scale variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

Set<Distribution>-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ representing the evolved TMD FFs

BuildTmdJet

std::function< double(double const &, double const &, double const &) apfel::BuildTmdJet) (std::map< int, TmdObjects > const &TmdObj, JetAlgorithm const &JetAlgo, double const &JetR, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &CJ=1, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		JetAlgorithm const &	JetAlgo,
		double const &	JetR,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	CJ = 1,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the TMD of a jet in b-space as functions of the final scale and rapidity.

Parameters

TmdObj	the TMD objects
JetAlgo	the jet algorithm to be used
JetR	the jet radius
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
CJ	jet-scale variation factor (default: 1)
Ci	the initial-scale variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

double-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ representing the evolved jet TMD

BuildTmdPDFs

std::function< Set< Distribution >(double const &, double const &, double const &) apfel::BuildTmdPDFs) (std::map< int, TmdObjects > const &TmdObj, std::function< Set< Distribution >(double const &)> const &CollPDFs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< Set< Distribution >(double const &)> const &	CollPDFs,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the matched and evolved TMD PDFs in b-space as functions of the final scale and rapidity.

Parameters

TmdObj	the TMD objects
CollPDFs	the set of collinear PDFs to be matched
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial-scale variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

Set<Distribution>-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ representing the evolved TMD PDFs

CollinsSoperKernel

std::function< double(double const &, double const &) apfel::CollinsSoperKernel) (std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the perturbative part of the Collins-Soper kernel for quarks.

Parameters

TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial scale-variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

double-valued function of the impact parameter b_T and of the the final renormalisation scale μ. It returns perturbative part of the Collis-Soper kernel for quarks.

EvolutionFactors

std::function< std::vector< double >(double const &, double const &, double const &) apfel::EvolutionFactors) (std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the evolution factors for gluon and quarks.

Parameters

TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial scale-variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

std::vector<double>-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ. The 0-th component contains the gluon evolution factor, the remaining 12, from 1 to 12, are all equal and represent the quark evolution factors.

EvolutionFactorsK

std::function< std::vector< double >(double const &, double const &, double const &) apfel::EvolutionFactorsK) (std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the evolution factors for gluon and quarks. As compared to "EvolutionFactors", this function isolates the double logs into gammaK. This is reminiscent of the qT-resummation typical way of computing the Sudakov form factor.

Parameters

TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial scale-variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

std::vector<double>-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ. The 0-th component contains the gluon evolution factor, the remaining 12, from 1 to 12, are all equal and represent the quark evolution factors.

Gkj

const std::map<std::pair<int, int>, int> apfel::Gkj

Initial value:

=
    {
      
      {{ 0,0}, 0}, {{ 0,1}, 1},           {{ 0,3}, 2},           {{ 0,5}, 3},           {{ 0,7}, 4},           {{ 0,9}, 5},             {{ 0,11}, 6},             
      {{ 1,0}, 7}, {{ 1,1}, 8},           {{ 1,3}, 9},           {{ 1,5},10},           {{ 1,7},11},           {{ 1,9},12},             {{ 1,11},13},             
                               {{2,2},14},                                                                                                                        
      {{ 3,0},15}, {{ 3,1},16},           {{ 3,3},17},           {{ 3,5},18},           {{ 3,7},19},           {{ 3,9},20},             {{ 3,11},21},             
                                                      {{4,4},22},                                                                                                 
      {{ 5,0},23}, {{ 5,1},24},           {{ 5,3},25},           {{ 5,5},26},           {{ 5,7},27},           {{ 5,9},28},             {{ 5,11},29},             
                                                                             {{6,6},30},                                                                          
      {{ 7,0},31}, {{ 7,1},32},           {{ 7,3},33},           {{ 7,5},34},           {{ 7,7},35},           {{ 7,9},36},             {{ 7,11},37},             
                                                                                                    {{8,8},38},                                                   
      {{ 9,0},39}, {{ 9,1},40},           {{ 9,3},41},           {{ 9,5},42},           {{ 9,7},43},           {{ 9,9},44},             {{ 9,11},45},             
                                                                                                                           {{10,10},46},                          
      {{11,0},47}, {{11,1},48},           {{11,3},49},           {{11,5},50},           {{11,7},51},           {{11,9},52},             {{11,11},53},             
                                                                                                                                                     {{12,12},54} 
    }

The map between pair of indices corresponding to the position of the operator in the evolution matrix and its linear index.

GluonAnalyticEvolutionFactor

std::function< double(double const &) apfel::GluonAnalyticEvolutionFactor) (TmdObjects const &TmdObj, double const &mu0, double const &Alphas0, double const &kappa, double const &kappa0, int const &PerturbativeOrder)	(	TmdObjects const &	TmdObj,
		double const &	mu0,
		double const &	Alphas0,
		double const &	kappa,
		double const &	kappa0,
		int const &	PerturbativeOrder )

Analytic evolution factor for the gluon TMD.

Parameters

TmdObj	container of the anomalous dimensions with a fixed number of active flavours
mu0	the strong coupling reference scale
Alphas0	the value of the strong coupling and mu0
kappa	the resummation-scale parameter
kappa0	the ratio mu0 / M (i.e. the alphas reference scale over the hard scale)
PerturbativeOrder	the logarithmic perturbative accuracy

Returns

the gluon Sudakov form factor as function of the impact parameter b

GluonEvolutionFactor

std::function< double(double const &, double const &, double const &) apfel::GluonEvolutionFactor) (std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the evolution factor for the gluon.

Parameters

TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial scale-variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

double-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ. It returns the gluon evolution factor.

HardFactor

std::function< double(double const &) apfel::HardFactor) (std::string const &Process, std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Cf=1)	(	std::string const &	Process,
		std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Cf = 1 )

Function that returns the hard factor.

Parameters

Process	the string corresponding to the process requested
TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Cf	the final scale-variation factor (default: 1)

Returns

double-valued function of the final renormalisation scale μ

InitializeF2CCMinusObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF2CCMinusObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeF2CCMinusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( F2(nu) - F2(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeF2CCPlusObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF2CCPlusObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeF2CCPlusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( F2(nu) + F2(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeF2NCObjectsMassive

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF2NCObjectsMassive) (Grid const &g, std::vector< double > const &Masses, double const &IntEps=1e-5, int const &nxi=150, double const &ximin=0.01, double const &ximax=10000, int const &intdeg=3, double const &lambda=0.0005)	(	Grid const &	g,
		std::vector< double > const &	Masses,
		double const &	IntEps = 1e-5,
		int const &	nxi = 150,
		double const &	ximin = 0.01,
		double const &	ximax = 10000,
		int const &	intdeg = 3,
		double const &	lambda = 0.0005 )

The InitializeF2NCObjectsMassive precomputes the perturbative coefficients of coefficient functions for NC F2 in the massive scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy quark masses
IntEps	the integration accuracy (default: 10-5})
nxi	the number of nodes of the grid in ξ = Q2/M2 (default: 150)
ximin	the lower bound of the grid in ξ (default: 0.001)
ximax	the upper bound of the grid in ξ (default: 100000)
intdeg	the interpolation degree on the grid in ξ (default: 3)
lambda	the value of the parameter in the function ln(ln(ξ/Λ2)) used for the tabulation (default: 0.0005)

Returns

A StructureFunctionObjects-valued function

InitializeF2NCObjectsMassiveZero

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF2NCObjectsMassiveZero) (Grid const &g, std::vector< double > const &Masses, double const &IntEps=1e-5, int const &nxi=150, double const &ximin=0.01, double const &ximax=10000, int const &intdeg=3, double const &lambda=0.0005)	(	Grid const &	g,
		std::vector< double > const &	Masses,
		double const &	IntEps = 1e-5,
		int const &	nxi = 150,
		double const &	ximin = 0.01,
		double const &	ximax = 10000,
		int const &	intdeg = 3,
		double const &	lambda = 0.0005 )

The InitializeF2NCObjectsMassiveZero precomputes the perturbative coefficients of coefficient functions for NC F2 in the massless limit of the massive scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy quark masses
IntEps	the integration accuracy (default: 10-5})
nxi	the number of nodes of the grid in ξ = Q2/M2 (default: 150)
ximin	the lower bound of the grid in ξ (default: 0.001)
ximax	the upper bound of the grid in ξ (default: 100000)
intdeg	the interpolation degree on the grid in ξ (default: 3)
lambda	the value of the parameter in the function ln(ln(ξ/Λ2)) used for the tabulation (default: 0.0005)

Returns

A StructureFunctionObjects-valued function

InitializeF2NCObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF2NCObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeF2NCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC F2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeF2NCObjectsZMT

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF2NCObjectsZMT) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeF2NCObjectsZMT precomputes the perturbative coefficients of coefficient functions for NC F2 for SIA in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeF3CCMinusObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF3CCMinusObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeF3CCMinusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( F3(nu) - F3(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeF3CCPlusObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF3CCPlusObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeF3CCPlusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( F3(nu) + F3(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeF3NCObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF3NCObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeF3NCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC xF3 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeF3NCObjectsZMT

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeF3NCObjectsZMT) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeF3NCObjectsZMT precomputes the perturbative coefficients of coefficient functions for NC xF3 for SIA in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeFLCCMinusObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeFLCCMinusObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeFLCCMinusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( FL(nu) - FL(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeFLCCPlusObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeFLCCPlusObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeFLCCPlusObjectsZM precomputes the perturbative coefficients of coefficient functions for combination ( FL(nu) + FL(nubar) ) / 2 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeFLNCObjectsMassive

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeFLNCObjectsMassive) (Grid const &g, std::vector< double > const &Masses, double const &IntEps=1e-5, int const &nxi=150, double const &ximin=0.01, double const &ximax=10000, int const &intdeg=3, double const &lambda=0.0005)	(	Grid const &	g,
		std::vector< double > const &	Masses,
		double const &	IntEps = 1e-5,
		int const &	nxi = 150,
		double const &	ximin = 0.01,
		double const &	ximax = 10000,
		int const &	intdeg = 3,
		double const &	lambda = 0.0005 )

The InitializeFLNCObjectsMassive precomputes the perturbative coefficients of coefficient functions for NC FL in the massive scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy quark masses
IntEps	the integration accuracy (default: 10-5})
nxi	the number of nodes of the grid in ξ = Q2/M2 (default: 150)
ximin	the lower bound of the grid in ξ (default: 0.001)
ximax	the upper bound of the grid in ξ (default: 100000)
intdeg	the interpolation degree on the grid in ξ (default: 3)
lambda	the value of the parameter in the function ln(ln(ξ/Λ2)) used for the tabulation (default: 0.0005)

Returns

A StructureFunctionObjects-valued function

InitializeFLNCObjectsMassiveZero

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeFLNCObjectsMassiveZero) (Grid const &g, std::vector< double > const &Masses, double const &IntEps=1e-5, int const &nxi=150, double const &ximin=0.01, double const &ximax=10000, int const &intdeg=3, double const &lambda=0.0005)	(	Grid const &	g,
		std::vector< double > const &	Masses,
		double const &	IntEps = 1e-5,
		int const &	nxi = 150,
		double const &	ximin = 0.01,
		double const &	ximax = 10000,
		int const &	intdeg = 3,
		double const &	lambda = 0.0005 )

The InitializeFLNCObjectsMassiveZero precomputes the perturbative coefficients of coefficient functions for NC FL in the massless limit of the massive scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Masses	the heavy quark masses
IntEps	the integration accuracy (default: 10-5})
nxi	the number of nodes of the grid in ξ = Q2/M2 (default: 150)
ximin	the lower bound of the grid in ξ (default: 0.001)
ximax	the upper bound of the grid in ξ (default: 100000)
intdeg	the interpolation degree on the grid in ξ (default: 3)
lambda	the value of the parameter in the function ln(ln(ξ/Λ2)) used for the tabulation (default: 0.0005)

Returns

A StructureFunctionObjects-valued function

InitializeFLNCObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeFLNCObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeFLNCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC FL in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializeFLNCObjectsZMT

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializeFLNCObjectsZMT) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializeFLNCObjectsZMT precomputes the perturbative coefficients of coefficient functions for NC FL for SIA in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

Initializeg1NCObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::Initializeg1NCObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The Initializeg1NCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC xg1 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

Initializeg4NCObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::Initializeg4NCObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The Initializeg4NCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC g4 in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

InitializegLNCObjectsZM

std::function< StructureFunctionObjects(double const &, std::vector< double > const &) apfel::InitializegLNCObjectsZM) (Grid const &g, std::vector< double > const &Thresholds, double const &IntEps=1e-5)	(	Grid const &	g,
		std::vector< double > const &	Thresholds,
		double const &	IntEps = 1e-5 )

The InitializegLNCObjectsZM precomputes the perturbative coefficients of coefficient functions for NC gL in the ZM scheme and store them in the 'StructureFunctionObjects' structure.

Parameters

g	the x-space grid
Thresholds	the heavy quark thresholds
IntEps	the integration accuracy (default: 10-5})

Returns

A StructureFunctionObjects-valued function

MatchGtmds

std::function< Set< Distribution >(double const &) apfel::MatchGtmds) (std::map< int, GtmdObjects > const &GtmdObj, std::function< Set< Distribution >(double const &)> const &CollGPDs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)	(	std::map< int, GtmdObjects > const &	GtmdObj,
		std::function< Set< Distribution >(double const &)> const &	CollGPDs,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1 )

Function that returns the matched TMD GPDs in b-space.

Parameters

GtmdObj	the GTMD objects
CollGPDs	the set of collinear GPDs to be matched
Alphas	the strong coupling function
PerturbativeOrder	the perturbative order
Ci	the initial-scale variation factor

Returns

Set<Distribution>-valued function of the impact parameter b_T representing the matched GTMDs.

MatchingFunctions

std::function< Set< Operator >(double const &) apfel::MatchingFunctions) (std::map< int, GtmdObjects > const &GtmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)	(	std::map< int, GtmdObjects > const &	GtmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1 )

Function that returns the mathing functions for the GTMDs.

Parameters

GtmdObj	the GTMD objects
Alphas	the strong coupling function
PerturbativeOrder	the perturbative order
Ci	the initial-scale variation factor

Returns

Set<Operator>-valued function of the scale mu corresponding to the set of matching functions for GPDs in the evolution basis.

MatchingFunctionsFFs

std::function< Set< Operator >(double const &) apfel::MatchingFunctionsFFs) (std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1 )

Function that returns the mathing functions for the TMD FFs.

Parameters

TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial-scale variation factor

Returns

Set<Operator>-valued function of the scale mu corresponding to the set of matching functions for FFs in the evolution basis.

MatchingFunctionsPDFs

std::function< Set< Operator >(double const &) apfel::MatchingFunctionsPDFs) (std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1 )

Function that returns the mathing functions for the TMD PDFs.

Parameters

TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial-scale variation factor

Returns

Set<Operator>-valued function of the scale mu corresponding to the set of matching functions for PDFs in the evolution basis.

MatchTmdFFs

std::function< Set< Distribution >(double const &) apfel::MatchTmdFFs) (std::map< int, TmdObjects > const &TmdObj, std::function< Set< Distribution >(double const &)> const &CollFFs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< Set< Distribution >(double const &)> const &	CollFFs,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1 )

Function that returns the matched TMD FFs in b-space.

Parameters

TmdObj	the TMD objects
CollFFs	the set of collinear FFs to be matched
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial-scale variation factor

Returns

Set<Distribution>-valued function of the impact parameter b_T representing the matched TMD FFs

MatchTmdJet

std::function< double(double const &, double const &) apfel::MatchTmdJet) (std::map< int, TmdObjects > const &TmdObj, JetAlgorithm const &JetAlgo, double const &tR, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &CJ=1, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		JetAlgorithm const &	JetAlgo,
		double const &	tR,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	CJ = 1,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the jet TMD in b-space at the initial scale.

Parameters

TmdObj	the TMD objects
JetAlgo	the jet algorithm
tR	tangent of half the jet radius (tan(R/2))
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
CJ	jet-scale variation factor (default: 1)
Ci	the initial-scale variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

double-valued function of the impact parameter b_T representing the low-scale jet TMD

MatchTmdPDFs

std::function< Set< Distribution >(double const &) apfel::MatchTmdPDFs) (std::map< int, TmdObjects > const &TmdObj, std::function< Set< Distribution >(double const &)> const &CollPDFs, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< Set< Distribution >(double const &)> const &	CollPDFs,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1 )

Function that returns the matched TMD PDFs in b-space.

Parameters

TmdObj	the TMD objects
CollPDFs	the set of collinear PDFs to be matched
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial-scale variation factor

Returns

Set<Distribution>-valued function of the impact parameter b_T representing the matched TMD PDFs

QuarkAnalyticEvolutionFactor

std::function< double(double const &) apfel::QuarkAnalyticEvolutionFactor) (TmdObjects const &TmdObj, double const &mu0, double const &Alphas0, double const &kappa, double const &kappa0, int const &PerturbativeOrder)	(	TmdObjects const &	TmdObj,
		double const &	mu0,
		double const &	Alphas0,
		double const &	kappa,
		double const &	kappa0,
		int const &	PerturbativeOrder )

Analytic evolution factor for the quark TMD.

Parameters

TmdObj	container of the anomalous dimensions with a fixed number of active flavours
mu0	the strong coupling reference scale
Alphas0	the value of the strong coupling and mu0
kappa	the resummation-scale parameter
kappa0	the ratio mu0 / M (i.e. the alphas reference scale over the hard scale)
PerturbativeOrder	the logarithmic perturbative accuracy

Returns

the quark Sudakov form factor as function of the impact parameter b

QuarkEvolutionFactor

std::function< double(double const &, double const &, double const &) apfel::QuarkEvolutionFactor) (std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the evolution factor for quarks.

Parameters

TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
Ci	the initial scale-variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

double-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ. It returns the quark evolution factor.

QuarkEvolutionFactorxi

std::function< double(double const &, double const &, double const &) apfel::QuarkEvolutionFactorxi) (std::map< int, TmdObjects > const &TmdObj, std::function< double(double const &)> const &Alphas, int const &PerturbativeOrder, double const &xi=1, double const &Ci=1, double const &IntEps=1e-7)	(	std::map< int, TmdObjects > const &	TmdObj,
		std::function< double(double const &)> const &	Alphas,
		int const &	PerturbativeOrder,
		double const &	xi = 1,
		double const &	Ci = 1,
		double const &	IntEps = 1e-7 )

Function that returns the evolution factor for quarks with explicit dependence on the resummation-scale parameter.

Parameters

TmdObj	the TMD objects
Alphas	the strong coupling function
PerturbativeOrder	the logarithmic perturbative order
xi	the resummation-scale parameter (default: 1)
Ci	the initial scale-variation factor (default: 1)
IntEps	the integration accuracy (default: 10-7)

Returns

double-valued function of the impact parameter b_T, the final renormalisation scale μ, and the final rapidity scale ζ. It returns the quark evolution factor.

rk1

template<class U >

std::function< U(double const &, U const &, double const &) apfel::rk1) (std::function< U(double const &t, U const &Obj)> const &f)

(

std::function< U(double const &t, U const &Obj)> const &

f

)

Template function that implements the first order RK algorithm.

Parameters

f	the function on the r.h.s. of the ODE

Returns

the function tha returns the step

rk4

template<class U >

std::function< U(double const &, U const &, double const &) apfel::rk4) (std::function< U(double const &t, U const &Obj)> const &f)

(

std::function< U(double const &t, U const &Obj)> const &

f

)

Template function that implements the fourth order RK algorithm.

Parameters

f	the function on the r.h.s. of the ODE

Returns

the function tha returns the step

RotPhysToPlusMinus

const double apfel::RotPhysToPlusMinus[13][13]

Initial value:

=
  {
    
    {  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.},   
    {  0.,  0.,  0.,  0.,  0.,  1.,  0.,  1.,  0.,  0.,  0.,  0.,  0.},   
    {  0.,  0.,  0.,  0.,  0., -1.,  0.,  1.,  0.,  0.,  0.,  0.,  0.},   
    {  0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.},   
    {  0.,  0.,  0.,  0., -1.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.},   
    {  0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.},   
    {  0.,  0.,  0., -1.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.},   
    {  0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.},   
    {  0.,  0., -1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.},   
    {  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.},   
    {  0., -1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.},   
    {  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.},   
    { -1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.}    
  }

Rotation matrix from the physical basis to the basis of q_{+/-} = q +/- qbar.

RotPhysToQCDEv

const double apfel::RotPhysToQCDEv[6][6]

Initial value:

=
  {
    {  1.,  1.,  1.,  1.,  1.,  1.},    
    { -1.,  1.,  0.,  0.,  0.,  0.},    
    {  1.,  1., -2.,  0.,  0.,  0.},    
    {  1.,  1.,  1., -3.,  0.,  0.},    
    {  1.,  1.,  1.,  1., -4.,  0.},    
    {  1.,  1.,  1.,  1.,  1., -5.}     
  }

Rotation matrix from the physical to the QCD evolution basis. Inverse of RotQCDEvToPhys.

RotPhysToQCDEvFull

const double apfel::RotPhysToQCDEvFull[13][13]

Initial value:

=
  {
    
    {  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.},   
    {  1.,  1.,  1.,  1.,  1.,  1.,  0.,  1.,  1.,  1.,  1.,  1.,  1.},   
    { -1., -1., -1., -1., -1., -1.,  0.,  1.,  1.,  1.,  1.,  1.,  1.},   
    {  0.,  0.,  0.,  0.,  1., -1.,  0., -1.,  1.,  0.,  0.,  0.,  0.},   
    {  0.,  0.,  0.,  0., -1.,  1.,  0., -1.,  1.,  0.,  0.,  0.,  0.},   
    {  0.,  0.,  0., -2.,  1.,  1.,  0.,  1.,  1., -2.,  0.,  0.,  0.},   
    {  0.,  0.,  0.,  2., -1., -1.,  0.,  1.,  1., -2.,  0.,  0.,  0.},   
    {  0.,  0., -3.,  1.,  1.,  1.,  0.,  1.,  1.,  1., -3.,  0.,  0.},   
    {  0.,  0.,  3., -1., -1., -1.,  0.,  1.,  1.,  1., -3.,  0.,  0.},   
    {  0., -4.,  1.,  1.,  1.,  1.,  0.,  1.,  1.,  1.,  1., -4.,  0.},   
    {  0.,  4., -1., -1., -1., -1.,  0.,  1.,  1.,  1.,  1., -4.,  0.},   
    { -5.,  1.,  1.,  1.,  1.,  1.,  0.,  1.,  1.,  1.,  1.,  1., -5.},   
    {  5., -1., -1., -1., -1., -1.,  0.,  1.,  1.,  1.,  1.,  1., -5.}    
  }

Rotation matrix from the physical to the QCD evolution basis for the full bases. Inverse of RotQCDEvToPhysFull.

RotPlusMinusToPhys

const double apfel::RotPlusMinusToPhys[13][13]

Initial value:

=
  {
    
    {   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,  0.5, -0.5},  
    {   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,  0.5, -0.5,   0.,   0.},  
    {   0.,   0.,   0.,   0.,   0.,   0.,   0.,  0.5, -0.5,   0.,   0.,   0.,   0.},  
    {   0.,   0.,   0.,   0.,   0.,  0.5, -0.5,   0.,   0.,   0.,   0.,   0.,   0.},  
    {   0.,   0.,   0.,  0.5, -0.5,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.},  
    {   0.,  0.5, -0.5,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.},  
    {   1.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.},  
    {   0.,  0.5,  0.5,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.},  
    {   0.,   0.,   0.,  0.5, 0.5,    0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.},  
    {   0.,   0.,   0.,   0.,   0.,  0.5,  0.5,   0.,   0.,   0.,   0.,   0.,   0.},  
    {   0.,   0.,   0.,   0.,   0.,   0.,   0.,  0.5,  0.5,   0.,   0.,   0.,   0.},  
    {   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,  0.5,  0.5,   0.,   0.},  
    {   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,  0.5,  0.5}   
  }

Rotation matrix from the basis of q_{+/-} = q +/- qbar to the physical basis. Inverse of RotPhysToPlusMinus.

RotQCDEvToPhys

const double apfel::RotQCDEvToPhys[6][6]

Initial value:

=
  {
    {1./6., -1./2.,  1./6., 1./12., 1./20., 1./30.},    
    {1./6.,  1./2.,  1./6., 1./12., 1./20., 1./30.},    
    {1./6.,     0., -1./3., 1./12., 1./20., 1./30.},    
    {1./6.,     0.,     0., -1./4., 1./20., 1./30.},    
    {1./6.,     0.,     0.,     0., -1./5., 1./30.},    
    {1./6.,     0.,     0.,     0.,     0., -1./6.}     
  }

Rotation matrix from the QCD evolution to the physical basis. Inverse of RotPhysToQCDEv.

RotQCDEvToPhysFull

const double apfel::RotQCDEvToPhysFull[13][13]

Initial value:

=
  {
    { 0.,  1./12., -1./12.,     0.,     0.,      0.,      0.,      0.,      0.,     0.,       0., -1./12.,  1./12.},
    { 0.,  1./12., -1./12.,     0.,     0.,      0.,      0.,      0.,      0., -1./10.,  1./10.,  1./60., -1./60.},
    { 0.,  1./12., -1./12.,     0.,     0.,      0.,      0.,  -1./8.,   1./8.,  1./40., -1./40.,  1./60., -1./60.},
    { 0.,  1./12., -1./12.,     0.,     0.,  -1./6.,   1./6.,  1./24., -1./24.,  1./40., -1./40.,  1./60., -1./60.},
    { 0.,  1./12., -1./12.,  1./4., -1./4.,  1./12., -1./12.,  1./24., -1./24.,  1./40., -1./40.,  1./60., -1./60.},
    { 0.,  1./12., -1./12., -1./4.,  1./4.,  1./12., -1./12.,  1./24., -1./24.,  1./40., -1./40.,  1./60., -1./60.},
    { 1.,      0.,      0.,     0.,     0.,      0.,      0.,      0.,      0.,     0.,       0.,      0.,      0.},
    { 0.,  1./12.,  1./12., -1./4., -1./4.,  1./12.,  1./12.,  1./24.,  1./24.,  1./40.,  1./40.,  1./60.,  1./60.},
    { 0.,  1./12.,  1./12.,  1./4.,  1./4.,  1./12.,  1./12.,  1./24.,  1./24.,  1./40.,  1./40.,  1./60.,  1./60.},
    { 0.,  1./12.,  1./12.,     0.,     0.,  -1./6.,  -1./6.,  1./24.,  1./24.,  1./40.,  1./40.,  1./60.,  1./60.},
    { 0.,  1./12.,  1./12.,     0.,     0.,      0.,      0.,  -1./8.,  -1./8.,  1./40.,  1./40.,  1./60.,  1./60.},
    { 0.,  1./12.,  1./12.,     0.,     0.,      0.,      0.,      0.,      0., -1./10., -1./10.,  1./60.,  1./60.},
    { 0.,  1./12.,  1./12.,     0.,     0.,      0.,      0.,      0.,      0.,     0.,       0., -1./12., -1./12.}
  }

Rotation matrix from the QCD evolution to the physical basis for the full bases. Inverse of RotPhysToQCDEvFull.