PVfunctions Class Reference

A class for Passarino-Veltman functions. More...

#include <PVfunctions.h>

Collaboration diagram for PVfunctions:
[legend]

Detailed Description

A class for Passarino-Veltman functions.

Author
HEPfit Collaboration

This class handles the so-called Passarino-Veltman (PV) functions, which appear in one-loop amplitudes. The definitions of the two-point and four-point functions used in the current class are identical to those in LoopTools library [86]. The one-point and three-point functions are identical to those in LoopTools library when bExtraMinusSign is set to false. On the other hand, when bExtraMinusSign is set to true, an extra minus sign is added to them in order to match their definitions to those in [31]. If the preprocessor macro USE_LOOPTOOLS is defined in PVfunctions.h or Makefile, the functions in LoopTools library, called via LoopToolsWrapper class, are employed instead of those defined in the current class.

See, e.g., [116], [110], [118], [68] and [31]

Definition at line 44 of file PVfunctions.h.

Public Member Functions

double A0 (const double mu2, const double m2) const
 \(A_0(m^2)\). More...
 
gslpp::complex 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 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 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 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 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 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 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 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 Bf (const double mu2, const double p2, const double m02, const double m12) const
 \(B_{f}(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex Bfp (const double mu2, const double p2, const double m02, const double m12) const
 \(B_{fp}(p^2; m_0^2, m_1^2)\). More...
 
gslpp::complex 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...
 
double C11 (const double m12, const double m22, const double m32) const
 \(C_{11}(m_1^2, m_2^2, m_3^2)\). More...
 
double C12 (const double m12, const double m22, const double m32) const
 \(C_{12}(m_1^2, m_2^2, m_3^2)\). More...
 
gslpp::complex 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 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...
 
 PVfunctions (const bool bExtraMinusSign)
 Constructor. More...
 

Private Attributes

double ExtraMinusSign
 An overall factor for the one-point and three-point functions, initialized in PVfunctions(). More...
 
Polylogarithms myPolylog
 An object of type Polylogarithms. More...
 

Constructor & Destructor Documentation

PVfunctions::PVfunctions ( const bool  bExtraMinusSign)

Constructor.

The boolean argument bExtraMinusSign controls whether an extra overall minus sign is added to the one-point and three-point functions or not. See also the detailed description of the current class.

Parameters
[in]bExtraMinusSigna flag to control whether an extra overall minus sign is added to the one-point and three-point functions or not

Definition at line 17 of file PVfunctions.cpp.

18 {
19  if (bExtraMinusSign) ExtraMinusSign = -1.0;
20  else ExtraMinusSign = 1.0;
21 }
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374

Member Function Documentation

double PVfunctions::A0 ( const double  mu2,
const double  m2 
) const

\(A_0(m^2)\).

The scalar one-point function \(A_0(m^2)\) is defined as

\[ A_0(m^2) = \frac{(2\pi\mu)^{4-d}}{i\pi^2}\int d^dk\, \frac{1}{k^2-m^2+i\varepsilon}, \]

where the UV divergence is regularized with the dimensional regularization. When bExtraMinusSign=true is passed to the constructor, an extra overall minus sign is added to the above definition.

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 23 of file PVfunctions.cpp.

24 {
25 #ifdef USE_LOOPTOOLS
26  return ( ExtraMinusSign * myLT.PV_A0(mu2, m2) );
27 #else
28  if ( mu2<=0.0 || m2<0.0 )
29  throw std::runtime_error("PVfunctions::A0(): Invalid argument!");
30 
31  const double Tolerance = 1.0e-10;
32  const bool m2zero = (m2 <= mu2*Tolerance);
33 
34  if ( m2zero )
35  return ( 0.0 );
36  else
37  return ( ExtraMinusSign * m2*(-log(m2/mu2)+1.0) );
38 #endif
39 }
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
complex log(const complex &z)
gslpp::complex PVfunctions::B0 ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The scalar two-point function \(B_0(p^2; m_0^2, m_1^2)\) is defined as

\[ B_0(p^2;m_0^2,m_1^2) = \frac{(2\pi\mu)^{4-d}}{i\pi^2}\int d^dk\, \frac{1}{(k^2-m_0^2+i\varepsilon)\left[(k+p)^2-m_1^2+i\varepsilon\right]}\,, \]

where the UV divergence is regularized with the dimensional regularization.

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 41 of file PVfunctions.cpp.

43 {
44 #ifdef USE_LOOPTOOLS
45  return myLT.PV_B0(mu2, p2, m02, m12);
46 #else
47  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
48  throw std::runtime_error("PVfunctions::B0(): Invalid argument!");
49 
50  const double Tolerance = 1.0e-8;
51  const double maxM2 = std::max(p2, std::max(m02, m12));
52  const bool p2zero = (p2 <= maxM2*Tolerance);
53  const bool m02zero = (m02 <= maxM2*Tolerance);
54  const bool m12zero = (m12 <= maxM2*Tolerance);
55  const bool m02_eq_m12 = (fabs(m02 - m12) <= (m02 + m12)*Tolerance);
56 
57  gslpp::complex B0(0.0, 0.0, false);
58  if ( p2zero ) {
59  if ( !m02zero && !m12zero ) {
60  if ( m02_eq_m12 )
61  B0 = - log(m02/mu2);
62  else
63  B0 = - m02/(m02-m12)*log(m02/mu2) + m12/(m02-m12)*log(m12/mu2) + 1.0;
64  } else if ( m02zero && !m12zero )
65  B0 = - log(m12/mu2) + 1.0;
66  else if ( !m02zero && m12zero )
67  B0 = - log(m02/mu2) + 1.0;
68  else if ( m02zero && m12zero )
69  throw std::runtime_error("PVfunctions::B0(): IR divergent! (vanishes in DR)");
70  else
71  throw std::runtime_error("PVfunctions::B0(): Undefined!");
72  } else {
73  if ( !m02zero && !m12zero ) {
74  double m0 = sqrt(m02), m1 = sqrt(m12);
75  double Lambda = sqrt( fabs((p2-m02-m12)*(p2-m02-m12) - 4.0*m02*m12) );
76  double R;
77  if ( p2 > (m0-m1)*(m0-m1) && p2 < (m0+m1)*(m0+m1) ) {
78  if ( p2-m02-m12 > 0.0 ) {
79  if ( p2-m02-m12 > Lambda*Tolerance )
80  R = - Lambda/p2*(atan(Lambda/(p2-m02-m12)) - M_PI);
81  else
82  R = - Lambda/p2*(M_PI/2.0 - M_PI);
83  } else {
84  if ( - (p2-m02-m12) > Lambda*Tolerance )
85  R = - Lambda/p2*atan(Lambda/(p2-m02-m12));
86  else
87  R = - Lambda/p2*( -M_PI/2.0 );
88  }
89  } else
90  R = Lambda/p2*log( fabs((p2-m02-m12+Lambda)/2.0/m0/m1) );
91  B0 = - log(m0*m1/mu2) + (m02-m12)/2.0/p2*log(m12/m02) - R + 2.0;
92  if ( p2 > (m0+m1)*(m0+m1) )
93  B0 += M_PI*Lambda/p2*gslpp::complex::i();// imaginary part
94  } else if ( (m02zero && !m12zero) || (!m02zero && m12zero) ) {
95  double M2;
96  if (!m02zero) M2 = m02;
97  else M2 = m12;
98  B0 = - log(M2/mu2) + 2.0;
99  if ( p2 < M2 )
100  B0 += - (1.0 - M2/p2)*log(1.0 - p2/M2);
101  else if ( p2 > M2 ) {
102  B0 += - (1.0 - M2/p2)*log(p2/M2 - 1.0);
103  B0 += (1.0 - M2/p2)*M_PI*gslpp::complex::i();// imaginary part
104  } else
105  B0 += 0.0;
106  } else if ( m02zero && m12zero ) {
107  if ( p2 < 0.0 )
108  B0 = - log(-p2/mu2) + 2.0;
109  else {
110  B0 = - log(p2/mu2) + 2.0;
111  B0 += M_PI*gslpp::complex::i();// imaginary part
112  }
113  } else
114  throw std::runtime_error("PVfunctions::B0(): Undefined!");
115  }
116  return B0;
117 #endif
118 }
static const complex & i()
gslpp::complex B0(const double mu2, const double p2, const double m02, const double m12) const
.
Definition: PVfunctions.cpp:41
complex log(const complex &z)
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
complex sqrt(const complex &z)
gslpp::complex PVfunctions::B00 ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The tensor two-point PV function \(B_{00}(p^2; m_0^2, m_1^2)\) is defined as

\[ g_{\mu\nu} B_{00}(p^2;m_0^2,m_1^2) + p_\mu p_\nu B_{11}(p^2;m_0^2,m_1^2) = \frac{(2\pi\mu)^{4-d}}{i\pi^2}\int d^dk\, \frac{k_\mu k_\nu}{(k^2-m_0^2+i\varepsilon) \left[(k+p)^2-m_1^2+i\varepsilon\right]}, \]

where the UV divergence is regularized with the dimensional regularization.

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 208 of file PVfunctions.cpp.

210 {
211 #ifdef USE_LOOPTOOLS
212  return myLT.PV_B00(mu2, p2, m02, m12);
213 #else
214  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
215  throw std::runtime_error("PVfunctions::B00(): Invalid argument!");
216 
217  const double Tolerance = 1.0e-8;
218  const double maxM2 = std::max(p2, std::max(m02, m12));
219  const bool p2zero = (p2 <= maxM2*Tolerance);
220  const bool m02zero = (m02 <= maxM2*Tolerance);
221  const bool m12zero = (m12 <= maxM2*Tolerance);
222  const bool m02_eq_m12 = (fabs(m02 - m12) <= (m02 + m12)*Tolerance);
223 
224  gslpp::complex B00(0.0, 0.0, false);
225  if ( p2zero ) {
226  if ( !m02zero && !m12zero ) {
227  if( m02_eq_m12 )
228  B00 = m02/2.0*(- log(m02/mu2) + 1.0);
229  else
230  B00 = 1.0/4.0*(m02 + m12)*(- log(sqrt(m02)*sqrt(m12)/mu2) + 3.0/2.0)
231  - (m02*m02 + m12*m12)/8.0/(m02 - m12)*log(m02/m12);
232  } else if ( (!m02zero && m12zero) || (m02zero && !m12zero) ) {
233  double M2;
234  if ( !m02zero ) M2 = m02;
235  else M2 = m12;
236  B00 = M2/4.0*(- log(M2/mu2) + 3.0/2.0);
237  } else
238  B00 = 0.0;
239  } else {
240  if ( !m02zero && !m12zero ) {
241  if ( m02_eq_m12 )
242  B00 = (6.0*m02 - p2)/18.0 + ExtraMinusSign*A0(mu2,m02)/6.0
243  - (p2 - 4.0*m02)/12.0*B0(mu2,p2,m02,m12);
244  else {
245  double DeltaM2 = m02 - m12;
246  double Lambdabar2 = (p2-m02-m12)*(p2-m02-m12) - 4.0*m02*m12;
247  B00 = (3.0*(m02 + m12) - p2)/18.0
248  - (DeltaM2 + p2)/12.0/p2*(-ExtraMinusSign)*A0(mu2,m02)
249  + (DeltaM2 - p2)/12.0/p2*(-ExtraMinusSign)*A0(mu2,m12)
250  - Lambdabar2*B0(mu2,p2,m02,m12)/12.0/p2;
251  }
252  } else if ( (!m02zero && m12zero) || (m02zero && !m12zero) ) {
253  double M2;
254  if ( !m02zero ) M2 = m02;
255  else M2 = m12;
256  B00 = (3.0*M2 - p2)/18.0 - (M2 + p2)/12.0/p2*(-ExtraMinusSign)*A0(mu2,M2)
257  - (M2 - p2)*(M2 - p2)/12.0/p2*B0(mu2,p2,M2,0.0);
258  } else
259  B00 = - p2/18.0 - p2/12.0*B0(mu2,p2,0.0,0.0);
260  }
261  return B00;
262 #endif
263 }
gslpp::complex B0(const double mu2, const double p2, const double m02, const double m12) const
.
Definition: PVfunctions.cpp:41
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
complex log(const complex &z)
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
double A0(const double mu2, const double m2) const
.
Definition: PVfunctions.cpp:23
gslpp::complex B00(const double mu2, const double p2, const double m02, const double m12) const
.
complex sqrt(const complex &z)
gslpp::complex PVfunctions::B00p ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The function \(B_{00p}(p^2; m_0^2, m_1^2)\) is defined as

\[ B_{00p}(p^2;m_0^2,m_1^2) = \frac{\partial}{\partial p^2} B_{00}(p^2;m_0^2,m_1^2)\,, \]

where the UV divergence is regularized with the dimensional regularization.

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 410 of file PVfunctions.cpp.

412 {
413 #ifdef USE_LOOPTOOLS
414  return myLT.PV_B00p(mu2, p2, m02, m12);
415 #else
416  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
417  throw std::runtime_error("PVfunctions::B00p(): Invalid argument!");
418 
419  const double Tolerance = 1.0e-8;
420  const double maxM2 = std::max(p2, std::max(m02, m12));
421  const bool p2zero = (p2 <= maxM2*Tolerance);
422  const bool m02zero = (m02 <= maxM2*Tolerance);
423  const bool m12zero = (m12 <= maxM2*Tolerance);
424  const bool m02_eq_m12 = (fabs(m02 - m12) <= (m02 + m12)*Tolerance);
425 
426  gslpp::complex B00p(0.0, 0.0, false);
427  double DeltaM2 = m02 - m12;
428  if ( p2zero ) {
429  if ( m02_eq_m12 )
430  B00p = - 1.0/18.0 - 1.0/12.0*B0(mu2,0.0,m02,m12)
431  + (m02 + m12)/6.0*B0p(mu2,0.0,m02,m12);
432  else if ( m02zero || m12zero )
433  B00p = - 1.0/18.0 - 1.0/12.0*B0(mu2,0.0,m02,m12)
434  + (m02 + m12)/6.0*B0p(mu2,0.0,m02,m12) - 1.0/72.0;
435  else
436  B00p = - 1.0/18.0 - 1.0/12.0*B0(mu2,0.0,m02,m12)
437  + (m02 + m12)/6.0*B0p(mu2,0.0,m02,m12)
438  - 1.0/24.0
439  *( (m02*m02 + 10.0*m02*m12 + m12*m12)/3.0/DeltaM2/DeltaM2
440  + 2.0*m02*m12*(m02 + m12)/DeltaM2/DeltaM2/DeltaM2*log(m12/m02) );
441  } else {
442  double Lambdabar2 = (p2-m02-m12)*(p2-m02-m12) - 4.0*m02*m12;
443  if ( m02_eq_m12 )
444  B00p = - 1.0/18.0 - B0(mu2,p2,m02,m12)/12.0
445  - Lambdabar2/12.0/p2*B0p(mu2,p2,m02,m12);
446  else
447  B00p = - 1.0/18.0
448  + DeltaM2/12.0/p2/p2*(- ExtraMinusSign*A0(mu2,m02)
449  + ExtraMinusSign*A0(mu2,m12)
450  + DeltaM2*B0(mu2,p2,m02,m12))
451  - B0(mu2,p2,m02,m12)/12.0
452  - Lambdabar2/12.0/p2*B0p(mu2,p2,m02,m12);
453  }
454  return B00p;
455 #endif
456 }
gslpp::complex B00p(const double mu2, const double p2, const double m02, const double m12) const
.
gslpp::complex B0(const double mu2, const double p2, const double m02, const double m12) const
.
Definition: PVfunctions.cpp:41
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
complex log(const complex &z)
gslpp::complex B0p(const double muIR2, const double p2, const double m02, const double m12) const
.
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
double A0(const double mu2, const double m2) const
.
Definition: PVfunctions.cpp:23
gslpp::complex PVfunctions::B0p ( const double  muIR2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The function \(B_{0p}(p^2; m_0^2, m_1^2)\) is defined as

\[ B_{0p}(p^2;m_0^2,m_1^2) = \frac{\partial}{\partial p^2} B_0(p^2;m_0^2,m_1^2)\,, \]

which is UV finite, while \(B_{0p}(m^2; 0, m^2)\) is IR divergent. The IR divergence is regularized with the dimensional regularization.

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 276 of file PVfunctions.cpp.

278 {
279 #ifdef USE_LOOPTOOLS
280  return myLT.PV_B0p(muIR2, p2, m02, m12);
281 #else
282  if ( muIR2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
283  throw std::runtime_error("PVfunctions::B0p(): Invalid argument!");
284 
285  const double Tolerance = 1.0e-8;
286  const double maxM2 = std::max(p2, std::max(m02, m12));
287  const bool p2zero = (p2 <= maxM2*Tolerance);
288  const bool m02zero = (m02 <= maxM2*Tolerance);
289  const bool m12zero = (m12 <= maxM2*Tolerance);
290  const bool m02_eq_m12 = (fabs(m02 - m12) <= (m02 + m12)*Tolerance);
291 
292  gslpp::complex B0p(0.0, 0.0, false);
293  if ( p2zero ) {
294  if ( !m02zero && !m12zero ) {
295  if ( m02_eq_m12 )
296  B0p = 1.0/6.0/m02;
297  else {
298  double DeltaM2 = m02 - m12;
299  B0p = (m02 + m12)/2.0/pow(DeltaM2,2.0)
300  + m02*m12/pow(DeltaM2,3.0)*log(m12/m02);
301  }
302  } else if ( !m02zero && m12zero )
303  B0p = 1.0/2.0/m02;
304  else if ( m02zero && !m12zero )
305  B0p = 1.0/2.0/m12;
306  else
307  throw std::runtime_error("PVfunctions::B0p(): Undefined!");
308  } else {
309  if ( !m02zero && !m12zero ) {
310  double m0 = sqrt(m02), m1 = sqrt(m12);
311  double Lambda = sqrt( fabs((p2-m02-m12)*(p2-m02-m12) - 4.0*m02*m12) );
312  double Rprime;
313  if ( p2 > (m0-m1)*(m0-m1) && p2 < (m0+m1)*(m0+m1) ) {
314  if ( p2-m02-m12 > 0.0 ) {
315  if ( p2-m02-m12 > Lambda*Tolerance )
316  Rprime = ((p2 - m02 - m12)/Lambda + Lambda/p2)
317  *(atan(Lambda/(p2-m02-m12)) - M_PI);
318  else
319  Rprime = ((p2 - m02 - m12)/Lambda + Lambda/p2)
320  *(M_PI/2.0 - M_PI);
321  } else {
322  if ( - (p2-m02-m12) > Lambda*Tolerance )
323  Rprime = ((p2 - m02 - m12)/Lambda + Lambda/p2)
324  *atan(Lambda/(p2-m02-m12));
325  else
326  Rprime = ((p2 - m02 - m12)/Lambda + Lambda/p2)
327  *( -M_PI/2.0 );
328  }
329  } else
330  Rprime = ((p2 - m02 - m12)/Lambda - Lambda/p2)
331  *log( fabs((p2-m02-m12+Lambda)/2.0/m0/m1) );
332  B0p = - (m02 - m12)/2.0/p2/p2*log(m12/m02) - (Rprime + 1.0)/p2;
333  if ( p2 > (m0+m1)*(m0+m1) )
334  B0p += M_PI/p2*((p2 - m02 - m12)/Lambda - Lambda/p2)
335  *gslpp::complex::i();// imaginary part
336  } else if ( (m02zero && !m12zero) || (!m02zero && m12zero) ) {
337  double M2;
338  if ( !m02zero ) M2 = m02;
339  else M2 = m12;
340  if ( p2 < M2 )
341  B0p = - M2/p2/p2*log(1.0 - p2/M2) - 1.0/p2;
342  else if ( p2 > M2 ) {
343  B0p = - M2/p2/p2*log(p2/M2 - 1.0) - 1.0/p2;
344  B0p += M2/p2/p2*M_PI*gslpp::complex::i();// imaginary part
345  } else /* p2=M2 */
346  B0p = 1.0/2.0/M2*(log(M2/muIR2) - 2.0);
347  } else if ( m02zero && m12zero )
348  B0p = - 1.0/p2;
349  else
350  throw std::runtime_error("PVfunctions::B0p(): Undefined!");
351  }
352  return B0p;
353 #endif
354 }
complex pow(const complex &z1, const complex &z2)
static const complex & i()
complex log(const complex &z)
gslpp::complex B0p(const double muIR2, const double p2, const double m02, const double m12) const
.
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
complex sqrt(const complex &z)
gslpp::complex PVfunctions::B1 ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The vector two-point PV function \(B_1(p^2; m_0^2, m_1^2)\) is defined as

\[ p_\mu B_1(p^2;m_0^2,m_1^2) = \frac{(2\pi\mu)^{4-d}}{i\pi^2}\int d^dk\, \frac{k_\mu}{(k^2-m_0^2+i\varepsilon)\left[(k+p)^2-m_1^2+i\varepsilon\right]}, \]

where the UV divergence is regularized with the dimensional regularization.

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 120 of file PVfunctions.cpp.

122 {
123 #ifdef USE_LOOPTOOLS
124  return myLT.PV_B1(mu2, p2, m02, m12);
125 #else
126  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
127  throw std::runtime_error("PVfunctions::B1(): Invalid argument!");
128 
129  const double Tolerance = 1.0e-8;
130  const double maxM2 = std::max(p2, std::max(m02, m12));
131  const bool p2zero = (p2 <= maxM2*Tolerance);
132  const bool m02zero = (m02 <= maxM2*Tolerance);
133  const bool m12zero = (m12 <= maxM2*Tolerance);
134  const bool m02_eq_m12 = (fabs(m02 - m12) <= (m02 + m12)*Tolerance);
135 
136  gslpp::complex B1(0.0, 0.0, false);
137  double DeltaM2 = m02 - m12;
138  if ( p2zero ) {
139  if ( !m02zero && !m12zero ) {
140  if ( m02_eq_m12 )
141  B1.real() = 1.0/2.0*log(m12/mu2);
142  else {
143  double F0 = - log(m12/m02);
144  double F1 = - 1.0 + m02/DeltaM2*F0;
145  double F2 = - 1.0/2.0 + m02/DeltaM2*F1;
146  B1.real() = 1.0/2.0*( log(m12/mu2) + F2 );
147  }
148  } else if ( m02zero && !m12zero )
149  B1.real() = 1.0/2.0*log(m12/mu2) - 1.0/4.0;
150  else if ( !m02zero && m12zero )
151  B1.real() = 1.0/2.0*log(m02/mu2) - 1.0/4.0;
152  else
153  B1 = 0.0;
154  } else
155  B1 = -1.0/2.0/p2*(- ExtraMinusSign*A0(mu2,m02)
156  + ExtraMinusSign*A0(mu2,m12)
157  + (DeltaM2 + p2)*B0(mu2,p2,m02,m12));
158  return B1;
159 #endif
160 }
const double & real() const
gslpp::complex B1(const double mu2, const double p2, const double m02, const double m12) const
.
gslpp::complex B0(const double mu2, const double p2, const double m02, const double m12) const
.
Definition: PVfunctions.cpp:41
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
complex log(const complex &z)
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
double A0(const double mu2, const double m2) const
.
Definition: PVfunctions.cpp:23
gslpp::complex PVfunctions::B11 ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The tensor two-point PV function \(B_{11}(p^2; m_0^2, m_1^2)\) is defined as

\[ g_{\mu\nu} B_{00}(p^2;m_0^2,m_1^2) + p_\mu p_\nu B_{11}(p^2;m_0^2,m_1^2) = \frac{(2\pi\mu)^{4-d}}{i\pi^2}\int d^dk\, \frac{k_\mu k_\nu}{(k^2-m_0^2+i\varepsilon) \left[(k+p)^2-m_1^2+i\varepsilon\right]}, \]

where the UV divergence is regularized with the dimensional regularization.

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 162 of file PVfunctions.cpp.

164 {
165 #ifdef USE_LOOPTOOLS
166  return myLT.PV_B11(mu2, p2, m02, m12);
167 #else
168  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
169  throw std::runtime_error("PVfunctions::B11(): Invalid argument!");
170 
171  const double Tolerance = 1.0e-8;
172  const double maxM2 = std::max(p2, std::max(m02, m12));
173  const bool p2zero = (p2 <= maxM2*Tolerance);
174  const bool m02zero = (m02 <= maxM2*Tolerance);
175  const bool m12zero = (m12 <= maxM2*Tolerance);
176  const bool m02_eq_m12 = (fabs(m02 - m12) <= (m02 + m12)*Tolerance);
177 
178  gslpp::complex B11(0.0, 0.0, false);
179  double DeltaM2 = m02 - m12;
180  if ( p2zero ) {
181  if ( !m02zero && !m12zero ) {
182  if ( m02_eq_m12 )
183  B11.real() = - 1.0/3.0*log(m12/mu2);
184  else {
185  double F0 = - log(m12/m02);
186  double F1 = - 1.0 + m02/DeltaM2*F0;
187  double F2 = - 1.0/2.0 + m02/DeltaM2*F1;
188  double F3 = - 1.0/3.0 + m02/DeltaM2*F2;
189  B11.real() = - 1.0/3.0*( log(m12/mu2) + F3 );
190  }
191  } else if ( m02zero && !m12zero )
192  B11.real() = - 1.0/3.0*log(m12/mu2) + 1.0/9.0;
193  else if ( !m02zero && m12zero )
194  B11.real() = - 1.0/3.0*log(m02/mu2) + 1.0/9.0;
195  else
196  throw std::runtime_error("PVfunctions::B11(): Undefined!");
197  } else {
198  double Lambdabar2 = (p2-m02-m12)*(p2-m02-m12) - 4.0*m02*m12;
199  B11 = - (3.0*(m02 + m12) - p2)/18.0/p2
200  + (DeltaM2 + p2)/3.0/p2/p2*(-ExtraMinusSign)*A0(mu2,m02)
201  - (DeltaM2 + 2.0*p2)/3.0/p2/p2*(-ExtraMinusSign)*A0(mu2,m12)
202  + (Lambdabar2 + 3.0*p2*m02)/3.0/p2/p2*B0(mu2,p2,m02,m12);
203  }
204  return B11;
205 #endif
206 }
const double & real() const
gslpp::complex B0(const double mu2, const double p2, const double m02, const double m12) const
.
Definition: PVfunctions.cpp:41
gslpp::complex B11(const double mu2, const double p2, const double m02, const double m12) const
.
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
complex log(const complex &z)
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
double A0(const double mu2, const double m2) const
.
Definition: PVfunctions.cpp:23
gslpp::complex PVfunctions::B11p ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The function \(B_{11p}(p^2; m_0^2, m_1^2)\) is defined as

\[ B_{11p}(p^2;m_0^2,m_1^2) = \frac{\partial}{\partial p^2} B_{11}(p^2;m_0^2,m_1^2)\,, \]

where the UV divergence is regularized with the dimensional regularization.

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 381 of file PVfunctions.cpp.

383 {
384 #ifdef USE_LOOPTOOLS
385  return myLT.PV_B11p(mu2, p2, m02, m12);
386 #else
387  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
388  throw std::runtime_error("PVfunctions::B11p(): Invalid argument!");
389 
390  const double Tolerance = 1.0e-8;
391  const double maxM2 = std::max(p2, std::max(m02, m12));
392  const bool p2zero = (p2 <= maxM2*Tolerance);
393 
394  double p4 = p2*p2, p6=p2*p2*p2;
395  double DeltaM2 = m02 - m12;
396  gslpp::complex B11p(0.0, 0.0, false);
397  if ( p2zero )
398  throw std::runtime_error("PVfunctions::B11p(): Undefined!");
399  else {
400  double Lambdabar2 = (p2-m02-m12)*(p2-m02-m12) - 4.0*m02*m12;
401  B11p = (m02 + m12)/6.0/p4 - (2.0*DeltaM2 + p2)/3.0/p6*(-ExtraMinusSign)*A0(mu2,m02)
402  + 2.0*(DeltaM2 + p2)/3.0/p6*(-ExtraMinusSign)*A0(mu2,m12)
403  - (2.0*DeltaM2*DeltaM2 + p2*m02 - 2.0*p2*m12)/3.0/p6*B0(mu2,p2,m02,m12)
404  + (Lambdabar2 + 3.0*p2*m02)/3.0/p4*B0p(mu2,p2,m02,m12);
405  }
406  return B11p;
407 #endif
408 }
gslpp::complex B0(const double mu2, const double p2, const double m02, const double m12) const
.
Definition: PVfunctions.cpp:41
gslpp::complex B11p(const double mu2, const double p2, const double m02, const double m12) const
.
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
gslpp::complex B0p(const double muIR2, const double p2, const double m02, const double m12) const
.
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
double A0(const double mu2, const double m2) const
.
Definition: PVfunctions.cpp:23
gslpp::complex PVfunctions::B1p ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The function \(B_{1p}(p^2; m_0^2, m_1^2)\) is defined as

\[ B_{1p}(p^2;m_0^2,m_1^2) = \frac{\partial}{\partial p^2} B_1(p^2;m_0^2,m_1^2)\,, \]

where the UV divergence is regularized with the dimensional regularization.

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 356 of file PVfunctions.cpp.

358 {
359 #ifdef USE_LOOPTOOLS
360  return myLT.PV_B1p(mu2, p2, m02, m12);
361 #else
362  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
363  throw std::runtime_error("PVfunctions::B1p(): Invalid argument!");
364 
365  const double Tolerance = 1.0e-8;
366  const double maxM2 = std::max(p2, std::max(m02, m12));
367  const bool p2zero = (p2 <= maxM2*Tolerance);
368 
369  gslpp::complex B1p(0.0, 0.0, false);
370  if ( p2zero )
371  throw std::runtime_error("PVfunctions::B1p(): Undefined!");
372  else {
373  double DeltaM2 = m02 - m12;
374  B1p = - ( 2.0*B1(mu2,p2,m02,m12) + B0(mu2,p2,m02,m12)
375  + (DeltaM2 + p2)*B0p(mu2,p2,m02,m12) )/2.0/p2;
376  }
377  return B1p;
378 #endif
379 }
gslpp::complex B1p(const double mu2, const double p2, const double m02, const double m12) const
.
gslpp::complex B1(const double mu2, const double p2, const double m02, const double m12) const
.
gslpp::complex B0(const double mu2, const double p2, const double m02, const double m12) const
.
Definition: PVfunctions.cpp:41
gslpp::complex B0p(const double muIR2, const double p2, const double m02, const double m12) const
.
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
gslpp::complex PVfunctions::Bf ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The function \(B_{f}(p^2; m_0^2, m_1^2)\) is defined as a sum of the two PV functions:

\[ B_f(p^2;m_0^2,m_1^2) = 2 \left[ B_{11}(p^2;m_0^2,m_1^2) + B_{1}(p^2;m_0^2,m_1^2) \right], \]

where the UV divergence is regularized with the dimensional regularization.

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_{f}(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 265 of file PVfunctions.cpp.

267 {
268  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
269  throw std::runtime_error("PVfunctions::Bf(): Invalid argument!");
270 
271  gslpp::complex Bf(0.0, 0.0, false);
272  Bf = 2.0*(B11(mu2,p2,m02,m12) + B1(mu2,p2,m02,m12));
273  return Bf;
274 }
gslpp::complex Bf(const double mu2, const double p2, const double m02, const double m12) const
.
gslpp::complex B1(const double mu2, const double p2, const double m02, const double m12) const
.
gslpp::complex B11(const double mu2, const double p2, const double m02, const double m12) const
.
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
gslpp::complex PVfunctions::Bfp ( const double  mu2,
const double  p2,
const double  m02,
const double  m12 
) const

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

The function \(B_{fp}(p^2; m_0^2, m_1^2)\) is defined as

\[ B_{fp}(p^2;m_0^2,m_1^2) = \frac{\partial}{\partial p^2} B_{f}(p^2;m_0^2,m_1^2)\,, \]

where the UV divergence is regularized with the dimensional regularization.

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_{fp}(p^2; m_0^2, m_1^2)\) in the sense of the \(\overline{\mathrm{MS}}\) scheme

Definition at line 458 of file PVfunctions.cpp.

460 {
461  if ( mu2<=0.0 || p2<0.0 || m02<0.0 || m12<0.0 )
462  throw std::runtime_error("PVfunctions::Bfp(): Invalid argument!");
463 
464  gslpp::complex Bfp(0.0, 0.0, false);
465  Bfp = 2.0*(B11p(mu2,p2,m02,m12) + B1p(mu2,p2,m02,m12));
466  return Bfp;
467 }
gslpp::complex Bfp(const double mu2, const double p2, const double m02, const double m12) const
.
gslpp::complex B1p(const double mu2, const double p2, const double m02, const double m12) const
.
gslpp::complex B11p(const double mu2, const double p2, const double m02, const double m12) const
.
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
gslpp::complex PVfunctions::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)\).

The scalar three-point function \(C_{0}(p_1^2,p_2^2,(p_1+p_2)^2; m_0^2, m_1^2, m_2^2)\) is defined as

\[ C_0(p_1^2,p_2^2,(p_1+p_2)^2; m_0^2,m_1^2,m_2^2) = \frac{1}{i\pi^2}\int d^4k\, \frac{1}{(k^2-m_0^2+i\varepsilon) \left[(k+p_1)^2-m_1^2+i\varepsilon\right] \left[(k+p_1+p_2)^2-m_2^2+i\varepsilon\right]}\,, \]

The current functions handles only the special case of \(p_1^2=p_2^2=0\). When bExtraMinusSign=true is passed to the constructor, an extra overall minus sign is added to the above definition.

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 469 of file PVfunctions.cpp.

471 {
472 #ifdef USE_LOOPTOOLS
473  return ( ExtraMinusSign * myLT.PV_C0(p2, m02, m12, m22) );
474 #else
475  if ( p2<0.0 || m02<0.0 || m12<0.0 || m22<0.0 )
476  throw std::runtime_error("PVfunctions::C0(): Invalid argument!");
477 
478  const double Tolerance = 1.0e-8;
479  const double maxM2 = std::max(p2, std::max(m02, std::max(m12, m22)));
480  const bool p2zero = (p2 <= maxM2*Tolerance);
481  const bool m02zero = (m02 <= maxM2*Tolerance);
482  const bool m12zero = (m12 <= maxM2*Tolerance);
483  const bool m22zero = (m22 <= maxM2*Tolerance);
484  bool diff01 = (fabs(m02 - m12) > (m02 + m12)*Tolerance);
485  bool diff12 = (fabs(m12 - m22) > (m12 + m22)*Tolerance);
486  bool diff20 = (fabs(m22 - m02) > (m22 + m02)*Tolerance);
487 
488  gslpp::complex C0(0.0, 0.0, false);
489  if ( p2zero ) {
490  if ( !m02zero && !m12zero && !m22zero ) {
491  if ( diff01 && diff12 && diff20 )
492  return ( - ( m12/(m02 - m12)*log(m12/m02)
493  - m22/(m02 - m22)*log(m22/m02) )/(m12 - m22) );
494  else if ( !diff01 && diff12 && diff20 )
495  return ( - (- m02 + m22 - m22*log(m22/m02))/(m02 - m22)/(m02 - m22) );
496  else if ( diff01 && !diff12 && diff20 )
497  return ( - ( m02 - m12 + m02*log(m12/m02))/(m02 - m12)/(m02 - m12) );
498  else if ( diff01 && diff12 && !diff20 )
499  return ( - (- m02 + m12 - m12*log(m12/m02))/(m02 - m12)/(m02 - m12) );
500  else
501  return ( 1.0/2.0/m02 );
502  }
503  } else {
504  if ( !diff20 && diff01 ) {
505  double epsilon = 1.0e-12;
506  gsl_complex tmp = gsl_complex_rect(1.0 - 4.0*m02/p2, epsilon);
507  tmp = gsl_complex_sqrt(tmp);
508  gslpp::complex tmp_complex(GSL_REAL(tmp), GSL_IMAG(tmp), false);
509  gslpp::complex x0 = 1.0 - (m02 - m12)/p2;
510  gslpp::complex x1 = (1.0 + tmp_complex)/2.0;
511  gslpp::complex x2 = (1.0 - tmp_complex)/2.0;
512  gslpp::complex x3 = m02/(m02 - m12);
513 
514  if ( x0==x1 || x0==x2 || x0==x3)
515  throw std::runtime_error("PVfunctions::C0(): Undefined-2!");
516 
517  gslpp::complex arg[6];
518  arg[0] = (x0 - 1.0)/(x0 - x1);
519  arg[1] = x0/(x0 - x1);
520  arg[2] = (x0 - 1.0)/(x0 - x2);
521  arg[3] = x0/(x0 - x2);
522  arg[4] = (x0 - 1.0)/(x0 - x3);
523  arg[5] = x0/(x0 - x3);
524 
525  gslpp::complex Li2[6];
526  for (int i=0; i<6; i++) {
527  gsl_sf_result re, im;
528  gsl_sf_complex_dilog_xy_e(arg[i].real(), arg[i].imag(), &re, &im);
529  Li2[i].real() = re.val;
530  Li2[i].imag() = im.val;
531 
532  /* Check the sizes of errors */
533  //std::cout << "re.val=" << re.val << " re.err=" << re.err << std::endl;
534  //std::cout << "im.val=" << im.val << " im.err=" << im.err << std::endl;
535  }
536  C0 = - 1.0/p2*( Li2[0] - Li2[1] + Li2[2] - Li2[3] - Li2[4] + Li2[5]);
537  } else if ( !m02zero && !m22zero && diff20 && m12zero ) {
538  double epsilon = 1.0e-12;
539  double tmp_real = pow((m02+m22-p2),2.0) - 4.0*m02*m22;
540  gsl_complex tmp = gsl_complex_rect(tmp_real, epsilon);
541  tmp = gsl_complex_sqrt(tmp);
542  gslpp::complex tmp_complex(GSL_REAL(tmp), GSL_IMAG(tmp), false);
543  gslpp::complex x1 = (p2 - m02 + m22 + tmp_complex)/2.0/p2;
544  gslpp::complex x2 = (p2 - m02 + m22 - tmp_complex)/2.0/p2;
545 
546  if ( x1==0.0 || x1==1.0 || x2==0.0 || x2==1.0 )
547  throw std::runtime_error("PVfunctions::C0(): Undefined-3!");
548 
549  gslpp::complex arg1 = (x1 - 1.0)/x1;
550  gslpp::complex arg2 = x2/(x2 - 1.0);
551  gsl_complex arg1_tmp = gsl_complex_rect(arg1.real(), arg1.imag());
552  gsl_complex arg2_tmp = gsl_complex_rect(arg2.real(), arg2.imag());
553  C0.real() = - 1.0/p2*( GSL_REAL(gsl_complex_log(arg1_tmp))
554  *GSL_REAL(gsl_complex_log(arg2_tmp))
555  - GSL_IMAG(gsl_complex_log(arg1_tmp))
556  *GSL_IMAG(gsl_complex_log(arg2_tmp)) );
557  C0.imag() = - 1.0/p2*( GSL_REAL(gsl_complex_log(arg1_tmp))
558  *GSL_IMAG(gsl_complex_log(arg2_tmp))
559  + GSL_IMAG(gsl_complex_log(arg1_tmp))
560  *GSL_REAL(gsl_complex_log(arg2_tmp)) );
561  } else if ( m02zero && !m12zero && !m22zero ) {
562  gslpp::complex arg[2];
563  arg[0] = 1.0 - m22/m12;
564  arg[1] = 1.0 - (-p2+m22)/m12;
565  gslpp::complex Li2[2];
566  for (int i=0; i<2; i++) {
567  gsl_sf_result re, im;
568  gsl_sf_complex_dilog_xy_e(arg[i].real(), arg[i].imag(), &re, &im);
569  Li2[i].real() = re.val;
570  Li2[i].imag() = im.val;
571  }
572  C0 = 1./(-p2)*(Li2[0]-Li2[1]);
573  } else if ( !m02zero && !m12zero && !m22zero && diff01 && diff12 ) {
574  double x0 = 1.0 - (m02-m12)/p2;
575  double x1 = -(-p2+m02-m22-sqrt(fabs((m02+m22-p2)*(m02+m22-p2) - 4.*m02*m22)))/p2/2.0;
576  double x2 = -(-p2+m02-m22+sqrt(fabs((m02+m22-p2)*(m02+m22-p2) - 4.*m02*m22)))/p2/2.0;
577  double x3 = m22/(m22-m12);
578 
579  gslpp::complex arg[6];
580  arg[0] = (x0-1.0)/(x0-x1);
581  arg[1] = x0/(x0-x1);
582  arg[2] = (x0-1.0)/(x0-x2);
583  arg[3] = x0/(x0-x2);
584  arg[4] = (x0-1.0)/(x0-x3);
585  arg[5] = x0/(x0-x3);
586 
587  gslpp::complex Li2[6];
588  for (int i=0; i<2; i++) {
589  gsl_sf_result re, im;
590  gsl_sf_complex_dilog_xy_e(arg[i].real(), arg[i].imag(), &re, &im);
591  Li2[i].real() = re.val;
592  Li2[i].imag() = im.val;
593  }
594 
595  C0 = -1.0/p2*(Li2[0] - Li2[1] + Li2[2] - Li2[3] - Li2[4] + Li2[5]);
596  } else
597  throw std::runtime_error("PVfunctions::C0(): Undefined-4!");
598  }
599  return ( - ExtraMinusSign * C0 );
600 #endif
601 }
gslpp::complex C0(const double p2, const double m02, const double m12, const double m22) const
.
complex pow(const complex &z1, const complex &z2)
const double & real() const
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
const double & imag() const
complex log(const complex &z)
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
complex sqrt(const complex &z)
double PVfunctions::C11 ( const double  m12,
const double  m22,
const double  m32 
) const

\(C_{11}(m_1^2, m_2^2, m_3^2)\).

The function \(C_{11}(m_1^2, m_2^2, m_3^2)\) is defined as

\[ C_{11}(m_1^2,m_2^2,m_3^2) = \frac{m_1^4 m_2^2 (2 m_1^2-m_2^2) \log \left(\frac{m_1^2}{m_2^2}\right) +m_1^4 m_3^2 (m_3^2-2 m_1^2) \log \left(\frac{m_1^2}{m_3^2}\right) -m_1^2 (m_1^2-m_2^2) (m_1^2-m_3^2) (m_2^2-m_3^2) +m_2^2 m_3^2 (m_2^2-2 m_1^2) (m_3^2-2 m_1^2) \log \left(\frac{m_2^2}{m_3^2}\right)} {2 (m_1^2-m_2^2)^2 (m_1^2-m_3^2)^2 (m_2^2-m_3^2)}. \]

The definition is taken from Equation (B8) in [14].

Parameters
[in]m12,m22,m32mass squared, \(m_1^2\), \(m_2^2\) and \(m_3^2\)
Returns
\(C_{11}(m_1^2, m_2^2, m_3^2)\)

Definition at line 603 of file PVfunctions.cpp.

604 {
605  if ( m12<=0.0 || m22<=0.0 || m32<=0.0 )
606  throw std::runtime_error("PVfunctions::C11(): Argument is not positive!");
607 
608  const double Tolerance = 2.5e-3;
609  double C11;
610 
611  if ( 2.0*fabs(m12-m22) > (m12+m22)*Tolerance && 2.0*fabs(m12-m32) > (m12+m32)*Tolerance && 2.0*fabs(m22-m32) > (m22+m32)*Tolerance ) {
612  C11=(-m12*(m12-m22)*(m12-m32)*(m22-m32)
613  +m12*m12*m22*(2.0*m12-m22)*log(m12/m22)
614  +m12*m12*m32*(-2.0*m12+m32)*log(m12/m32)
615  +m22*m32*(-2.0*m12+m22)*(-2.0*m12+m32)*log(m22/m32))
616  /(2.0*(m12-m22)*(m12-m22)*(m12-m32)*(m12-m32)*(m22-m32));
617  }
618  else if ( 2.0*fabs(m12-m22) > (m12+m22)*Tolerance && 2.0*fabs(m12-m32) > (m12+m32)*Tolerance && 2.0*fabs(m22-m32) <= (m22+m32)*Tolerance ) {
619  C11=-((-12.0*m12*m12+8.0*m12*(m22+m32)-(m22+m32)*(m22+m32)+8.0*m12*m12*log((2.0*m12)/(m22+m32)))
620  /pow(-2.0*m12+m22+m32,3));
621  }
622  else if ( 2.0*fabs(m12-m22) > (m12+m22)*Tolerance && 2.0*fabs(m12-m32) <= (m12+m32)*Tolerance && 2.0*fabs(m22-m32) > (m22+m32)*Tolerance ) {
623  C11=(3.0*m12*m12-8.0*m12*m22+4.0*m22*m22+6.0*m12*m32-8.0*m22*m32+3.0*m32*m32+8.0*m22*(m12-m22+m32)*log((2.0*m22)/(m12+m32)))
624  /(2.0*pow(m12-2.0*m22+m32,3));
625  }
626  else if ( 2.0*fabs(m12-m22) <= (m12+m22)*Tolerance && 2.0*fabs(m12-m32) <= (m12+m32)*Tolerance && 2.0*fabs(m22-m32) <= (m22+m32)*Tolerance ) {
627  C11=1/(m12+m22+m32);
628  }
629  else {
630  C11=(3.0*m12*m12+6.0*m12*m22+3.0*m22*m22-8.0*m12*m32-8.0*m22*m32+4.0*m32*m32-8.0*m32*(m12+m22-m32)*log((m12+m22)/(2.0*m32)))
631  /(2.0*pow(m12+m22-2.0*m32,3));
632  }
633 
634  return C11;
635 }
complex pow(const complex &z1, const complex &z2)
double C11(const double m12, const double m22, const double m32) const
.
complex log(const complex &z)
double PVfunctions::C12 ( const double  m12,
const double  m22,
const double  m32 
) const

\(C_{12}(m_1^2, m_2^2, m_3^2)\).

The function \(C_{12}(m_1^2, m_2^2, m_3^2)\) is defined as

\[ C_{12}(m_1^2,m_2^2,m_3^2) = \frac{m_1^4 \left(m_2^4 \log \left(\frac{m_1^2}{m_2^2}\right) +m_3^2 (m_3^2-2 m_2^2) \log \left(\frac{m_1^2}{m_3^2}\right)\right) +m_2^4 m_3^2 (2 m_1^2-m_3^2) \log \left(\frac{m_2^2}{m_3^2}\right) +m_3^2 (m_1^2-m_2^2) (m_1^2-m_3^2) (m_2^2-m_3^2)} {2 (m_1^2-m_2^2) (m_1^2-m_3^2)^2 (m_2^2-m_3^2)^2}. \]

The definition is taken from Equation (B9) in [14].

Parameters
[in]m12,m22,m32mass squared, \(m_1^2\), \(m_2^2\) and \(m_3^2\)
Returns
\(C_{12}(m_1^2, m_2^2, m_3^2)\)

Definition at line 637 of file PVfunctions.cpp.

638 {
639  if ( m12<=0.0 || m22<=0.0 || m32<=0.0 )
640  throw std::runtime_error("PVfunctions::C12(): Argument is not positive!");
641 
642  const double Tolerance = 2.5e-3;
643  double C12;
644 
645  if ( 2.0*fabs(m12-m22) > (m12+m22)*Tolerance && 2.0*fabs(m12-m32) > (m12+m32)*Tolerance && 2.0*fabs(m22-m32) > (m22+m32)*Tolerance ) {
646  C12=((m12-m22)*(m12-m32)*(m22-m32)*m32
647  +m12*m12*(m22*m22*log(m12/m22) +m32*(-2.0*m22+m32)*log(m12/m32))
648  +m22*m22*(2.0*m12-m32)*m32*log(m22/m32))
649  /(2.0*(m12-m22)*(m12-m32)*(m12-m32)*(m22-m32)*(m22-m32));
650  }
651  else if ( 2.0*fabs(m12-m22) > (m12+m22)*Tolerance && 2.0*fabs(m12-m32) > (m12+m32)*Tolerance && 2.0*fabs(m22-m32) <= (m22+m32)*Tolerance ) {
652  C12=-(-12.0*m12*m12+8.0*m12*(m22+m32)-(m22+m32)*(m22+m32)+8.0*m12*m12*log((2.0*m12)/(m22+m32)))
653  /(2.0*pow(-2.0*m12+m22+m32,3));
654  }
655  else if ( 2.0*fabs(m12-m22) > (m12+m22)*Tolerance && 2.0*fabs(m12-m32) <= (m12+m32)*Tolerance && 2.0*fabs(m22-m32) > (m22+m32)*Tolerance ) {
656  C12=(m12*m12-8.0*m12*m22+12.0*m22*m22+2.0*m12*m32-8.0*m22*m32+m32*m32-8.0*m22*m22*log((2.0*m22)/(m12+m32)))
657  /(2.0*pow(m12-2.0*m22+m32,3));
658  }
659  else if ( 2.0*fabs(m12-m22) <= (m12+m22)*Tolerance && 2.0*fabs(m12-m32) <= (m12+m32)*Tolerance && 2.0*fabs(m22-m32) <= (m22+m32)*Tolerance ) {
660  C12=1.0/(2.0*(m12+m22+m32));
661  }
662  else {
663  C12=(m12*m12+2.0*m12*m22+m22*m22-4.0*m32*m32-4.0*(m12+m22)*m32*log((m12+m22)/(2.0*m32)))
664  /pow(m12+m22-2.0*m32,3);
665  }
666 
667  return C12;
668 }
complex pow(const complex &z1, const complex &z2)
double C12(const double m12, const double m22, const double m32) const
.
complex log(const complex &z)
gslpp::complex PVfunctions::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)\).

The scalar four-point function \(D_{0}(p_1^2,p_2^2,p_3^2,p_4^2,(p_1+p_2)^2,(p_2+p_3)^2; m_0^2, m_1^2, m_2^2, m_3^2)\) is defined as

\begin{eqnarray*} &&D_0(p_1^2,p_2^2,p_3^2,p_4^2,(p_1+p_2)^2,(p_2+p_3)^2; m_0^2,m_1^2,m_2^2,m_3^2) \\ &&\quad = \frac{1}{i\pi^2}\int d^4k\, \frac{1}{(k^2-m_0^2+i\varepsilon) \left[(k+p_1)^2-m_1^2+i\varepsilon\right] \left[(k+p_1+p_2)^2-m_2^2+i\varepsilon\right] \left[(k+p_1+p_2+p_3)^2-m_2^2+i\varepsilon\right]}\,, \end{eqnarray*}

where \(p_1+p_2+p_3+p_4=0\). The current functions handles only the special case of \(p_1^2=p_2^2=p_3^2=p_4^2=0\).

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)\)
Warning
Only the case of \(s=t=0\) has been implemented. Other cases can be computed with the help of LoopTools library, by setting the preprocessor macro USE_LOOPTOOLS.

Definition at line 670 of file PVfunctions.cpp.

672 {
673  if ( m02<0.0 || m12<0.0 || m22<0.0 || m32<0.0 )
674  throw std::runtime_error("PVfunctions::D0(): Invalid argument!");
675 
676  const double Tolerance = 1.0e-8;
677  const double maxM2 = std::max(s, std::max(t, std::max(m02, std::max(m12, std::max(m22, m32)))));
678  const bool szero = (s <= maxM2*Tolerance);
679  const bool tzero = (t <= maxM2*Tolerance);
680  const bool m02zero = (m02 <= maxM2*Tolerance);
681  const bool m12zero = (m12 <= maxM2*Tolerance);
682  const bool m22zero = (m22 <= maxM2*Tolerance);
683  const bool m32zero = (m32 <= maxM2*Tolerance);
684  bool diff01 = (fabs(m02 - m12) > (m02 + m12)*Tolerance);
685  bool diff02 = (fabs(m02 - m22) > (m02 + m22)*Tolerance);
686  bool diff03 = (fabs(m02 - m32) > (m02 + m32)*Tolerance);
687  bool diff23 = (fabs(m22 - m32) > (m22 + m32)*Tolerance);
688 
689  if ( szero && tzero ) {
690  if ( diff01 )
691  return ( ( ExtraMinusSign * C0(0.0, m02, m22, m32)
692  - ExtraMinusSign * C0(0.0, m12, m22, m32) ) / (m02 - m12) );
693  else {
694  if ( !m02zero && !m12zero && !m22zero && !m32zero ) {
695  if ( diff02 && diff03 && diff23 )
696  return ( - 1.0/(m02 - m22)/(m02 - m32)
697  + m22/(m02 - m22)/(m02 - m22)/(m32 - m22)*log(m22/m02)
698  + m32/(m02 - m32)/(m02 - m32)/(m22 - m32)*log(m32/m02) );
699  else if ( !diff02 && diff03 && diff23 )
700  return ( (m02*m02 - m32*m32 + 2.0*m02*m32*log(m32/m02))
701  /2.0/m02/(m02 - m32)/(m02 - m32)/(m02 - m32) );
702  else if ( diff02 && !diff03 && diff23 )
703  return ( (m02*m02 - m22*m22 + 2.0*m02*m22*log(m22/m02))
704  /2.0/m02/(m02 - m22)/(m02 - m22)/(m02 - m22) );
705  else if ( diff02 && diff03 && !diff23 )
706  return ( ( - 2.0*m02 + 2.0*m22 - (m02 + m22)*log(m22/m02))
707  /(m02 - m22)/(m02 - m22)/(m02 - m22) );
708  else
709  return ( 1.0/6.0/m02/m02 );
710  } else
711  throw std::runtime_error("PVfunctions::D0(): Undefined!");
712  }
713  }
714 
715 #ifdef USE_LOOPTOOLS
716  return myLT.PV_D0(s, t, m02, m12, m22, m32);
717 #else
718  gslpp::complex D0(0.0, 0.0, false);
719 
720  if ( s>0.0 && t<0.0 && !m02zero && m12zero && !diff02 && !m32zero
721  && m02!=m32 && t-m32+m02!=0.0 && t-m32!=0.0 ) {
722  //D0(s,t; m02, 0.0, m02, m32)
723 
724  /*
725  double x1, x2;
726  if ( s >= 4.0*m02 ) {
727  x1 = (1.0 - sqrt(1.0 - 4.0*m02/s))/2.0;
728  x2 = (1.0 + sqrt(1.0 - 4.0*m02/s))/2.0;
729  } else {
730  throw std::runtime_error("PVfunctions::D0(): Undefined!");
731  }
732  double x3 = m32/(m32 - m02);
733  double x4 = (t - m32)/(t - m32 + m02);
734  double d4 = 1.0 - 4.0*m02*t*(t - m32 + m02)/(s*(t - m32)*(t - m32));
735  double x1tilde, x2tilde;
736  if ( d4 >= 0.0 ) {
737  x1tilde = x4/2.0*(1.0 - sqrt(d4));
738  x2tilde = x4/2.0*(1.0 + sqrt(d4));
739  } else {
740  throw std::runtime_error("PVfunctions::D0(): Undefined!");
741  }
742  */
743 
744  /* Write codes! */
745 
746  throw std::runtime_error("PVfunctions::D0(): Undefined!");
747  } else if ( s>0.0 && t<0.0 && !m02zero && m12zero && !diff02 && m32zero ) {
748  //D0(s,t; m02, 0.0, m02, 0.0)
749 
750  throw std::runtime_error("PVfunctions::D0(): Undefined!");
751  } else
752  throw std::runtime_error("PVfunctions::D0(): Undefined!");
753 
754  return D0;
755 #endif
756 }
gslpp::complex C0(const double p2, const double m02, const double m12, const double m22) const
.
gslpp::complex D0(const double s, const double t, const double m02, const double m12, const double m22, const double m32) const
.
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
complex log(const complex &z)
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
gslpp::complex PVfunctions::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)\).

The tensor four-point function \(D_{0}(p_1^2,p_2^2,p_3^2,p_4^2,(p_1+p_2)^2,(p_2+p_3)^2; m_0^2, m_1^2, m_2^2, m_3^2)\) is defined as

\begin{eqnarray*} &&g_{\mu\nu} D_{00}(p_1^2,p_2^2,p_3^2,p_4^2,(p_1+p_2)^2,(p_2+p_3)^2; m_0^2,m_1^2,m_2^2,m_3^2) + \sum_{i,j=1}^{3}q_{i\mu}q_{j\mu} D_{ij}(p_1^2,p_2^2,p_3^2,p_4^2,(p_1+p_2)^2,(p_2+p_3)^2; m_0^2,m_1^2,m_2^2,m_3^2) \\ &&\quad = \frac{1}{i\pi^2}\int d^4k\, \frac{k_\mu k_\nu}{(k^2-m_0^2+i\varepsilon) \left[(k+p_1)^2-m_1^2+i\varepsilon\right] \left[(k+p_1+p_2)^2-m_2^2+i\varepsilon\right] \left[(k+p_1+p_2+p_3)^2-m_2^2+i\varepsilon\right]}\,, \end{eqnarray*}

where \(q_N=\sum_{i=1}^N p_i\) and \(p_1+p_2+p_3+p_4=0\). The current functions handles only the special case of \(p_1^2=p_2^2=p_3^2=p_4^2=0\).

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
Only the case of \(s=t=0\) has been implemented. Other cases can be computed with the help of LoopTools library, by setting the preprocessor macro USE_LOOPTOOLS.

Definition at line 758 of file PVfunctions.cpp.

760 {
761  if ( m02<0.0 || m12<0.0 || m22<0.0 || m32<0.0 )
762  throw std::runtime_error("PVfunctions::D00(): Invalid argument!");
763 
764  const double Tolerance = 1.0e-8;
765  const double maxM2 = std::max(s, std::max(t, std::max(m02, std::max(m12, std::max(m22, m32)))));
766  const bool szero = (s <= maxM2*Tolerance);
767  const bool tzero = (t <= maxM2*Tolerance);
768  const bool m02zero = (m02 <= maxM2*Tolerance);
769  const bool m12zero = (m12 <= maxM2*Tolerance);
770  const bool m22zero = (m22 <= maxM2*Tolerance);
771  const bool m32zero = (m32 <= maxM2*Tolerance);
772  bool diff01 = (fabs(m02 - m12) > (m02 + m12)*Tolerance);
773  bool diff02 = (fabs(m02 - m22) > (m02 + m22)*Tolerance);
774  bool diff03 = (fabs(m02 - m32) > (m02 + m32)*Tolerance);
775  bool diff23 = (fabs(m22 - m32) > (m22 + m32)*Tolerance);
776 
777  if ( szero && tzero ) {
778  if ( diff01 )
779  return ( 0.25/(m02 - m12)*(m02*ExtraMinusSign*C0(0.0, m02, m22, m32)
780  - m12*ExtraMinusSign*C0(0.0, m12, m22, m32)) );
781  else {
782  if ( !m02zero && !m12zero && !m22zero && !m32zero ) {
783  if ( diff02 && diff03 && diff23 )
784  return ( m02/4.0/(m02 - m22)/(m32 - m02)
785  + m22*m22/4.0/(m02 - m22)/(m02 - m22)/(m32 - m22)*log(m22/m02)
786  + m32*m32/4.0/(m02 - m32)/(m02 - m32)/(m22 - m32)*log(m32/m02) );
787  else if ( !diff02 && diff03 && diff23 )
788  return ( ( - m02*m02 + 4.0*m02*m32 - 3.0*m32*m32
789  + 2.0*m32*m32*log(m32/m02) )
790  /8.0/(m02 - m32)/(m02 - m32)/(m02 - m32) );
791  else if ( diff02 && !diff03 && diff23 )
792  return ( ( - m02*m02 + 4.0*m02*m22 - 3.0*m22*m22
793  + 2.0*m22*m22*log(m22/m02) )
794  /8.0/(m02 - m22)/(m02 - m22)/(m02 - m22) );
795  else if ( diff02 && diff03 && !diff23 )
796  return ( ( - m02*m02 + m22*m22 - 2.0*m02*m22*log(m22/m02) )
797  /4.0/(m02 - m22)/(m02 - m22)/(m02 - m22) );
798  else
799  return ( - 1.0/12.0/m02 );
800  } else
801  throw std::runtime_error("PVfunctions::D00(): Undefined!");
802  }
803  }
804 
805 #ifdef USE_LOOPTOOLS
806  return myLT.PV_D00(s, t, m02, m12, m22, m32);
807 #else
808  gslpp::complex D00(0.0, 0.0, false);
809 
810  throw std::runtime_error("PVfunctions::D00(): Undefined!");
811 
812  return D00;
813 #endif
814 }
gslpp::complex C0(const double p2, const double m02, const double m12, const double m22) const
.
gslpp::complex D00(const double s, const double t, const double m02, const double m12, const double m22, const double m32) const
.
double ExtraMinusSign
An overall factor for the one-point and three-point functions, initialized in PVfunctions().
Definition: PVfunctions.h:374
complex log(const complex &z)
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35

Member Data Documentation

double PVfunctions::ExtraMinusSign
private

An overall factor for the one-point and three-point functions, initialized in PVfunctions().

Definition at line 374 of file PVfunctions.h.

Polylogarithms PVfunctions::myPolylog
private

An object of type Polylogarithms.

Definition at line 375 of file PVfunctions.h.


The documentation for this class was generated from the following files: