a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
Public Member Functions | List of all members
LoopToolsWrapper Class Reference
LoopFunctions

A wrapper class for LoopTools library. More...

#include <LoopToolsWrapper.h>

Detailed Description

A wrapper class for LoopTools library.

Author
HEPfit Collaboration
Copyright
GNU General Public License

This class is responsible for the interface to LoopTools library [134].

See [134] and the webpage of LoopTools.

See also the documentation of PVfunctions class for the definitions of the loop functions.

Attention
The preprocessor macro USE_LOOPTOOLS has to be set in order to use the current wrapper class. See also PVfunctions.h.

Definition at line 32 of file LoopToolsWrapper.h.

Public Member Functions

 LoopToolsWrapper ()
 The default constructor. More...
 
double PV_A0 (const double mu2, const double m2) const
 \(A_0(m^2)\). More...
 
gslpp::complex PV_B0 (const double mu2, const double p2, const double m02, const double m12) const
 \(B_0(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex PV_B00 (const double mu2, const double p2, const double m02, const double m12) const
 \(B_{00}(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex PV_B00p (const double mu2, const double p2, const double m02, const double m12) const
 \(B_{00p}(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex PV_B0p (const double muIR2, const double p2, const double m02, const double m12) const
 \(B_{0p}(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex PV_B1 (const double mu2, const double p2, const double m02, const double m12) const
 \(B_1(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex PV_B11 (const double mu2, const double p2, const double m02, const double m12) const
 \(B_{11}(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex PV_B11p (const double mu2, const double p2, const double m02, const double m12) const
 \(B_{11p}(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex PV_B1p (const double mu2, const double p2, const double m02, const double m12) const
 \(B_{1p}(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex PV_C0 (const double p2, const double m02, const double m12, const double m22) const
 \(C_{0}(0,0,p^2; m_0^2, m_1^2, m_2^2)\). More...
 
gslpp::complex PV_D0 (const double s, const double t, const double m02, const double m12, const double m22, const double m32) const
 \(D_{0}(0,0,0,0,s,t; m_0^2, m_1^2, m_2^2, m_3^2)\). More...
 
gslpp::complex PV_D00 (const double s, const double t, const double m02, const double m12, const double m22, const double m32) const
 \(D_{00}(0,0,0,0,s,t; m_0^2, m_1^2, m_2^2, m_3^2)\). More...
 
virtual ~LoopToolsWrapper ()
 The default destructor. More...
 

Constructor & Destructor Documentation

◆ LoopToolsWrapper()

LoopToolsWrapper::LoopToolsWrapper ( )

The default constructor.

Definition at line 19 of file LoopToolsWrapper.cpp.

20 {
21 #ifdef USE_LOOPTOOLS
22  if (!LoopToolsInit) {
23  //std::cout << std::endl;
24  ltini();
25  std::cout << std::endl;
26  LoopToolsInit = true;
27  }
28 
29  /* set the photon mass regulating IR divergences to 0, which means that
30  * dimensional regularization is employed for IR divergences and that
31  * the finite piece is returned from an IR-divergent loop function. */
32  setlambda(0.0);
33 #endif
34 }

◆ ~LoopToolsWrapper()

LoopToolsWrapper::~LoopToolsWrapper ( )
virtual

The default destructor.

Definition at line 36 of file LoopToolsWrapper.cpp.

37 {
38  //#ifdef USE_LOOPTOOLS
39  // for debug
40  //std::cout << std::endl
41  // << "************* LoopTools ****************" << std::endl;
42  //ltexi();
43  //std::cout << "****************************************" << std::endl;
44  //#endif
45 }

Member Function Documentation

◆ PV_A0()

double LoopToolsWrapper::PV_A0 ( const double  mu2,
const double  m2 
) const

\(A_0(m^2)\).

Parameters
[in]mu2the renormalization scale squared, \(\mu^2\)
[in]m2mass squared, \(m^2\)
Returns
the finite part of \(A_0(m^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 49 of file LoopToolsWrapper.cpp.

50 {
51  setmudim(mu2);
52  std::complex<double> A0val = A0(m2);
53  return ( A0val.real() );
54 }

◆ PV_B0()

gslpp::complex LoopToolsWrapper::PV_B0 ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

\(B_0(p^2; m_0^2, m_1^2)\).

Parameters
[in]mu2the renormalization scale squared, \(\mu^2\)
[in]p2momentum squared, \(p^2\)
[in]m02,m12mass squared, \(m_0^2\) and \(m_1^2\)
Returns
the finite part of \(B_0(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 56 of file LoopToolsWrapper.cpp.

58 {
59  setmudim(mu2);
60  std::complex<double> B0val = B0(p2, m02, m12);
61  return gslpp::complex( B0val.real(), B0val.imag(), false );
62 }

◆ PV_B00()

gslpp::complex LoopToolsWrapper::PV_B00 ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

\(B_{00}(p^2; m_0^2, m_1^2)\).

Parameters
[in]mu2the renormalization scale squared, \(\mu^2\)
[in]p2momentum squared, \(p^2\)
[in]m02,m12mass squared, \(m_0^2\) and \(m_1^2\)
Returns
the finite part of \(B_{00}(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 80 of file LoopToolsWrapper.cpp.

82 {
83  setmudim(mu2);
84  std::complex<double> B00val = B00(p2, m02, m12);
85  return gslpp::complex( B00val.real(), B00val.imag(), false );
86 }

◆ PV_B00p()

gslpp::complex LoopToolsWrapper::PV_B00p ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

\(B_{00p}(p^2; m_0^2, m_1^2)\).

Parameters
[in]mu2the renormalization scale squared, \(\mu^2\)
[in]p2momentum squared, \(p^2\)
[in]m02,m12mass squared, \(m_0^2\) and \(m_1^2\)
Returns
the finite part of \(B_{00p}(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 112 of file LoopToolsWrapper.cpp.

114 {
115  setmudim(mu2);
116  std::complex<double> B00pval = DB00(p2, m02, m12);
117  return gslpp::complex( B00pval.real(), B00pval.imag(), false );
118 }

◆ PV_B0p()

gslpp::complex LoopToolsWrapper::PV_B0p ( const double  muIR2,
const double  p2,
const double  m02,
const double  m12 
) const

\(B_{0p}(p^2; m_0^2, m_1^2)\).

Parameters
[in]muIR2the renormalization scale squared for the IR divergence, \(\mu_{\mathrm{IR}}^2\)
[in]p2momentum squared, \(p^2\)
[in]m02,m12mass squared, \(m_0^2\) and \(m_1^2\)
Returns
the finite part of \(B_{0p}(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 88 of file LoopToolsWrapper.cpp.

90 {
91  setmudim(muIR2);
92  std::complex<double> B0pval = DB0(p2, m02, m12);
93  return gslpp::complex( B0pval.real(), B0pval.imag(), false );
94 }

◆ PV_B1()

gslpp::complex LoopToolsWrapper::PV_B1 ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

\(B_1(p^2; m_0^2, m_1^2)\).

Parameters
[in]mu2the renormalization scale squared, \(\mu^2\)
[in]p2momentum squared, \(p^2\)
[in]m02,m12mass squared, \(m_0^2\) and \(m_1^2\)
Returns
the finite part of \(B_1(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 64 of file LoopToolsWrapper.cpp.

66 {
67  setmudim(mu2);
68  std::complex<double> B1val = B1(p2, m02, m12);
69  return gslpp::complex( B1val.real(), B1val.imag(), false );
70 }

◆ PV_B11()

gslpp::complex LoopToolsWrapper::PV_B11 ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

\(B_{11}(p^2; m_0^2, m_1^2)\).

Parameters
[in]mu2the renormalization scale squared, \(\mu^2\)
[in]p2momentum squared, \(p^2\)
[in]m02,m12mass squared, \(m_0^2\) and \(m_1^2\)
Returns
the finite part of \(B_{11}(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 72 of file LoopToolsWrapper.cpp.

74 {
75  setmudim(mu2);
76  std::complex<double> B11val = B11(p2, m02, m12);
77  return gslpp::complex( B11val.real(), B11val.imag(), false );
78 }

◆ PV_B11p()

gslpp::complex LoopToolsWrapper::PV_B11p ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

\(B_{11p}(p^2; m_0^2, m_1^2)\).

Parameters
[in]mu2the renormalization scale squared, \(\mu^2\)
[in]p2momentum squared, \(p^2\)
[in]m02,m12mass squared, \(m_0^2\) and \(m_1^2\)
Returns
the finite part of \(B_{11p}(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 104 of file LoopToolsWrapper.cpp.

106 {
107  setmudim(mu2);
108  std::complex<double> B11pval = DB11(p2, m02, m12);
109  return gslpp::complex( B11pval.real(), B11pval.imag(), false );
110 }

◆ PV_B1p()

gslpp::complex LoopToolsWrapper::PV_B1p ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

\(B_{1p}(p^2; m_0^2, m_1^2)\).

Parameters
[in]mu2the renormalization scale squared, \(\mu^2\)
[in]p2momentum squared, \(p^2\)
[in]m02,m12mass squared, \(m_0^2\) and \(m_1^2\)
Returns
the finite part of \(B_{1p}(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 96 of file LoopToolsWrapper.cpp.

98 {
99  setmudim(mu2);
100  std::complex<double> B1pval = DB1(p2, m02, m12);
101  return gslpp::complex( B1pval.real(), B1pval.imag(), false );
102 }

◆ PV_C0()

gslpp::complex LoopToolsWrapper::PV_C0 ( const double  p2,
const double  m02,
const double  m12,
const double  m22 
) const

\(C_{0}(0,0,p^2; m_0^2, m_1^2, m_2^2)\).

Parameters
[in]p2momentum squared, \(p^2\)
[in]m02,m12,m22mass squared, \(m_0^2\), \(m_1^2\) and \(m_2^2\)
Returns
\(C_{0}(0,0,p^2; m_0^2, m_1^2, m_2^2)\)

Definition at line 120 of file LoopToolsWrapper.cpp.

122 {
123  std::complex<double> C0val = C0(0.0, 0.0, p2, m02, m12, m22);
124  return gslpp::complex( C0val.real(), C0val.imag(), false );
125 }

◆ PV_D0()

gslpp::complex LoopToolsWrapper::PV_D0 ( const double  s,
const double  t,
const double  m02,
const double  m12,
const double  m22,
const double  m32 
) const

\(D_{0}(0,0,0,0,s,t; m_0^2, m_1^2, m_2^2, m_3^2)\).

Parameters
[in]s,tmomentum squared, \(s\) and \(t\)
[in]m02,m12,m22,m32mass squared, \(m_0^2\), \(m_1^2\), \(m_2^2\) and \(m_3^2\)
Returns
\(D_{0}(0,0,0,0,s,t; m_0^2, m_1^2, m_2^2, m_3^2)\)

Definition at line 127 of file LoopToolsWrapper.cpp.

129 {
130  std::complex<double> D0val = D0(0.0, 0.0, 0.0, 0.0, s, t, m02, m12, m22, m32);
131  return gslpp::complex( D0val.real(), D0val.imag(), false );
132 }

◆ PV_D00()

gslpp::complex LoopToolsWrapper::PV_D00 ( const double  s,
const double  t,
const double  m02,
const double  m12,
const double  m22,
const double  m32 
) const

\(D_{00}(0,0,0,0,s,t; m_0^2, m_1^2, m_2^2, m_3^2)\).

Parameters
[in]s,tmomentum squared, \(s\) and \(t\)
[in]m02,m12,m22,m32mass squared, \(m_0^2\), \(m_1^2\), \(m_2^2\) and \(m_3^2\)
Returns
\(D_{00}(0,0,0,0,s,t; m_0^2, m_1^2, m_2^2, m_3^2)\)
Warning
This function does not work.

Definition at line 134 of file LoopToolsWrapper.cpp.

136 {
137 // cannot be compiled?
138 // std::complex<double> D00val = D0i(dd00, 0.0, 0.0, 0.0, 0.0, s, t, m02, m12, m22, m32);
139 // return gslpp::complex( D00val.real(), D00val.imag(), false );
140 
141  throw std::runtime_error("LoopToolsWrapper::PV_D00: Not implemented!");
142 }
The documentation for this class was generated from the following files:
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35