#! /usr/bin/env python3
from pySecDec.loop_integral import loop_package
import pySecDec as psd
if __name__ == "__main__":
li = psd.loop_integral.LoopIntegralFromGraph(internal_lines=[['m', [1, 2]],
['m', [1, 2]],
['m', [1,
2]]],
external_lines=[['p1', 1],
['p2', 2]],
powerlist=[1, 1, 1],
replacement_rules=[
('p1*p1', 's'),
('p2*p2', 's')
],
dimensionality='3-2*eps')
loop_package(name='se2l3dM',
loop_integral=li,
real_parameters=['s', 'm'],
requested_order=-1,
form_optimization_level=2,
form_work_space='100M',
contour_deformation=False,
decomposition_method='iterative')
loop_package(
name = 'F1diminc2_21',
additional_prefactor = '-exp(2*EulerGamma*eps)',
loop_integral = li,
real_parameters = Mandelstam_symbols + mass_symbols,
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders = [4],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level = 2,
# the WorkSpace parameter for FORM
form_work_space = '1G',
# the method to be used for the sector decomposition
# valid values are ``iterative`` or ``geometric`` or ``geometric_ku``
decomposition_method = 'iterative',
# if you choose ``geometric[_ku]`` and 'normaliz' is not in your
# $PATH, you can set the path to the 'normaliz' command-line
# executable here
#normaliz_executable='/path/to/normaliz',
# whether or not to produce code to perform the contour deformation
# contour deformation is not required if we only want to compute euclidean points (all Mandelstam invariants negative)
contour_deformation = True
)
loop_package(
name = 'crossint5',
loop_integral = li,
real_parameters = Mandelstam_symbols + mass_symbols,
# additional_prefactor = '-((gamma(1-eps)**2*gamma(1+eps))/gamma(1-2*eps)/exp(-EulerGamma*eps)/3**eps)**(-2)/gamma(2*eps + 2)',
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders = [2],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level = 2,
# the WorkSpace parameter for FORM
form_work_space = '500M',
# the method to be used for the sector decomposition
# valid values are ``iterative`` or ``geometric`` or ``geometric_ku``
decomposition_method = 'geometric',
# if you choose ``geometric[_ku]`` and 'normaliz' is not in your
# $PATH, you can set the path to the 'normaliz' command-line
# executable here
#normaliz_executable='/path/to/normaliz',
)
#!/usr/bin/env python3
from pySecDec.loop_integral import loop_package
import pySecDec as psd
if __name__ == "__main__":
li = psd.loop_integral.LoopIntegralFromPropagators(
loop_momenta=['k1', 'k2'],
Lorentz_indices=['mu'],
propagators=['k1^2 - m1sq', 'k2^2 - m2sq', '(k1+k2)^2 - m3sq'],
numerator='2*k1(mu)*k2(mu)',
)
loop_package(
name='tadpole2L_rank2',
loop_integral=li,
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders=[0],
real_parameters=['m1sq', 'm2sq', 'm3sq'],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level=3,
# contour deformation is not required because there are no external legs
contour_deformation=False,
# make sure the retun type is double
enforce_complex=True,
)
#!/usr/bin/env python3
from pySecDec.loop_integral import loop_package
import pySecDec as psd
if __name__ == "__main__":
# Example used to demonstrate symmetry finder in Stephen Jones ACAT Proceedings 2017
li = psd.loop_integral.LoopIntegralFromGraph(
internal_lines=[[0, [1, 4]], [0, [1, 5]], [0, [2, 3]], [0, [2, 7]],
[0, [3, 8]], [0, [4, 6]], [0, [5, 6]], [0, [5, 7]],
[0, [7, 8]], [0, [6, 8]]],
external_lines=[['p1', 1], ['p2', 2], ['p3', 3], ['p4', 4]],
powerlist=[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
replacement_rules=[('p1*p1', 0), ('p2*p2', 0), ('p3*p3', 0),
('p4*p4', 0), ('p1*p2', 's/2'), ('p2*p3', 't/2'),
('p1*p3', '-s/2-t/2')])
Mandelstam_symbols = ['s', 't']
mass_symbols = []
loop_package(name='box3L',
loop_integral=li,
real_parameters=Mandelstam_symbols + mass_symbols,
requested_orders=[0],
decomposition_method='iterative',
contour_deformation=False,
use_Pak=True,
use_dreadnaut=False)
#!/usr/bin/env python3
from pySecDec.loop_integral import loop_package
import pySecDec as psd
if __name__ == "__main__":
li = psd.loop_integral.LoopIntegralFromPropagators(
propagators=["(k1+p1)^2", "(k2-p1)^2", "(k2-p2)^2", "(k1+p2)^2"],
loop_momenta=["k1", "k2"],
replacement_rules=[("p1^2", "0"), ("p2^2", "0"), ("p1*p2", "es12/2")],
regulator="eps",
dimensionality="6-2*eps",
)
loop_package(
name="bubble2L_factorizing",
loop_integral=li,
requested_orders=[-2],
form_optimization_level=4,
decomposition_method="geometric",
real_parameters=['es12'],
# Contour deformation is not needed but should not alter the result.
# However, a bug caused wrong results when contour deformation was active.
contour_deformation=True,
)
(k2 - p123)**2, (k2 - p1234)**2, (k1 + k2)**2
]
li = psd.loop_integral.LoopIntegralFromPropagators(
propagators=propagators,
loop_momenta=loop_momenta,
external_momenta=external_momenta,
replacement_rules=replacement_rules,
powerlist=[1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1],
)
loop_package(
name='pentabox',
loop_integral=li,
use_Pak=False, # no symmetries
real_parameters=Mandelstam_symbols,
requested_orders=[0],
decomposition_method='geometric',
form_work_space='1G',
# additional_prefactor = 'exp(2*EulerGamma*eps)',
)
# pentabox from arxiv:1511.09404
# analytic result available in ancillary files (Mathematica Notebook)
# s12 -> 3.1604938271604937, s23 -> -2.2115856637445197, s34 -> 0.9876543209876543, s45 -> 0.7901234567901234, s51 -> -1.8026785963650396, xp -> 1.125
# result (with additional prefator 'exp(2*EulerGamma*eps)'):
# - 0.176721 * eps^-4
# + (0.298436 -0.395075 I)*eps^-3
# + (0.0865349 +1.13206 I)*eps^-2
# + ((-2.6549-3.2401 I)+(0.0060391 -0.0121267 I) r1)*eps^-1
# + (14.9462 -9.49785 I)+(0.0135741 -0.0114979*I)*r1
('p3*p4', 't/2')
],
dimensionality= '6-2*eps'
)
Mandelstam_symbols = ['t','u']
mass_symbols = []
loop_package(
name = 'yyyy_box6Dim',
loop_integral = li,
real_parameters = Mandelstam_symbols + mass_symbols,
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders = [0],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level = 2,
# the method to be used for the sector decomposition
# valid values are ``iterative`` and ``geometric``
decomposition_method = 'iterative',
# pass code_writer.make_package to generate the old style pySecDec output
package_generator=make_package
)
Mandelstam_symbols = ['s1','s2','sij']
mass_symbols = ['m1','m2']
loop_package(
name = 'bubble1L_dot_rank4',
loop_integral = li,
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders = [0],
complex_parameters =['s1','s2','sij'],
real_parameters =['m1','m2'],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level = 3,
# the WorkSpace parameter for FORM
form_work_space = '500M',
# whether or not to produce code to perform the contour deformation
# contour deformation is not required if we only want to compute euclidean points (all Mandelstam invariants negative)
contour_deformation = True,
package_generator=psd.code_writer.make_package
)
('k1*k2', 's/2'), ('k1*k4', '-3*msq/28+s/2+t/2'),
('k2*k4', 'msq/2-t/2')])
Mandelstam_symbols = ['s', 't']
mass_symbols = ['msq']
loop_package(
name='box2L_jw',
loop_integral=li,
real_parameters=Mandelstam_symbols + mass_symbols,
#additional_prefactor = '(s/msq)**(3/2)',
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders=[0],
# the optimization level to use in FORM (can be 0, 1, 2, 3)
form_optimization_level=2,
# the WorkSpace parameter for FORM
form_work_space='2000M',
# the method to be used for the sector decomposition
# valid values are ``iterative`` and ``geometric``
decomposition_method='iterative',
# if you choose ``geometric`` and 'normaliz' is not in your
# $PATH, you can set the path to the 'normaliz' command-line
# executable here
#normaliz_executable='/path/to/normaliz',
contour_deformation=True)
#!/usr/bin/env python3
from pySecDec.loop_integral import loop_package
import pySecDec as psd
if __name__ == "__main__":
#li = psd.loop_integral.LoopIntegralFromPropagators(
#propagators = ['(k1-p1)**2','(k2-p1)**2','k2**2','k1**2','(k2-k1)**2'],
#loop_momenta = ['k1','k2'],
li = psd.loop_integral.LoopIntegralFromGraph(
internal_lines=[[0, [1, 2]], [0, [2, 3]], [0, [3, 4]], [0, [4, 1]],
[0, [2, 4]]],
external_lines=[['p1', 1], ['p1', 3]],
powerlist=['eps', 1, 'eps', 1, 1],
dimensionality='2-2*eps',
regulator='eps',
replacement_rules=[('p1*p1', 's')])
loop_package(
name='regulator_in_powerlist',
loop_integral=li,
requested_orders=[0],
real_parameters=['s'],
decomposition_method='geometric',
)
('p2*p3', '-s/2'),
('p1*p3', '-s/2'),
('m**2', 'msq')
])
Mandelstam_symbols = ['s']
mass_symbols = ['msq']
loop_package(
name='triangle',
loop_integral=li,
real_parameters=Mandelstam_symbols + mass_symbols,
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders=[0],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level=2,
# the WorkSpace parameter for FORM
form_work_space='100M',
# the method to be used for the sector decomposition
# valid values are ``iterative`` and ``geometric``
decomposition_method='geometric',
# if you choose ``geometric`` and 'normaliz' is not in your
# $PATH, you can set the path to the 'normaliz' command-line
# executable here
#normaliz_executable='/path/to/normaliz',
package_generator=psd.code_writer.make_package)
('p1*p4', 't/2'),
('p2*p4', '-t/2-s/2'),
('p3*p4', 's/2'),
])
Mandelstam_symbols = ['s', 't']
mass_symbols = []
loop_package(
name='boxNP6',
loop_integral=li,
additional_prefactor='-gamma(3+2*eps)',
real_parameters=Mandelstam_symbols + mass_symbols,
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders=[0],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level=2,
# the WorkSpace parameter for FORM
form_work_space='1G',
# the method to be used for the sector decomposition
# valid values are ``iterative`` and ``geometric``
decomposition_method='iterative',
# there are singularities at one
split=True,
)
loop_package(
name = 'A92',
loop_integral = li,
real_parameters = Mandelstam_symbols + mass_symbols,
#additional_prefactor = 'gamma( (4-2*eps)/2-1 )**3',
additional_prefactor = '-eps**3*(gamma(-eps))**3',
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders = [0],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level = 2,
# the WorkSpace parameter for FORM
form_work_space = '100M',
# the method to be used for the sector decomposition
# valid values are ``iterative`` or ``geometric`` or ``geometric_ku``
decomposition_method = 'geometric',
# if you choose ``geometric[_ku]`` and 'normaliz' is not in your
# $PATH, you can set the path to the 'normaliz' command-line
# executable here
#normaliz_executable='/path/to/normaliz',
contour_deformation = False
)
loop_package(
name='pentagon_1L',
loop_integral=li,
real_parameters=Mandelstam_symbols,
complex_parameters=mass_symbols,
additional_prefactor=
'''gamma(1-2*eps)/(gamma(1+eps)*gamma(1-eps)**2)''',
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_orders=[0],
# the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
form_optimization_level=2,
# the WorkSpace parameter for FORM
form_work_space='500M',
# the method to be used for the sector decomposition
# valid values are ``iterative`` or ``geometric`` or ``geometric_ku``
#decomposition_method = 'iterative',
decomposition_method='geometric',
# if you choose ``geometric[_ku]`` and 'normaliz' is not in your
# $PATH, you can set the path to the 'normaliz' command-line
# executable here
#normaliz_executable='/path/to/normaliz',
# whether or not to produce code to perform the contour deformation
# contour deformation is not required if we only want to compute euclidean points (all Mandelstam invariants negative)
contour_deformation=True,
# no symmetries --> no need to run the full symmetry finder
#use_Pak = False,
)
#!/usr/bin/env python3
from pySecDec.loop_integral import loop_package
import pySecDec as psd
if __name__ == "__main__":
#li = psd.loop_integral.LoopIntegralFromPropagators(
#propagators = ['(k1-p1)**2','(k2-p1)**2','k2**2','k1**2','(k2-k1)**2'],
#loop_momenta = ['k1','k2'],
li = psd.loop_integral.LoopIntegralFromGraph(
internal_lines = [[0,[1,2]],[0,[2,3]],[0,[3,4]],[0,[4,1]],[0,[2,4]]],
external_lines = [['p1',1],['p1',3]],
powerlist = ['eps',1,'eps',1,1],
dimensionality = '2-2*eps',
regulator = 'eps',
replacement_rules = [('p1*p1','s')]
)
loop_package(
name = 'regulator_in_powerlist',
loop_integral = li,
requested_orders = [0],
real_parameters = ['s'],
decomposition_method = 'geometric',
package_generator=psd.code_writer.make_package
)
loop_package(
name = 'ladder2g',
loop_integral = li,
real_parameters = Mandelstam_symbols+mass_symbols,
#complex_parameters = mass_symbols,
# the highest order of the final epsilon expansion --> change this value to whatever you think is appropriate
requested_order = 0,
#requested_orders = [0],
# the optimization level to use in FORM (can be 0, 1, 2, 3)
form_optimization_level = 4,
# the WorkSpace parameter for FORM
form_work_space = '2G',
# the method to be used for the sector decomposition
# valid values are ``iterative`` or ``geometric`` or ``geometric_ku``
decomposition_method = 'geometric',
# if you choose ``geometric[_ku]`` and 'normaliz' is not in your
# $PATH, you can set the path to the 'normaliz' command-line
# executable here
#normaliz_executable='/path/to/normaliz',
)
# - Demonstrates VEGAS with a low nstart giving wrong results (with an underestimated error)
#
li = psd.loop_integral.LoopIntegralFromPropagators(
propagators=[
'-m2+(l1+q1)**2',
'-m2+l1**2',
'-m2+(l1-q2)**2',
'-m2+(l2-q2)**2',
'-m2+(l2+q1+q3)**2',
'-m2+(l2+q1)**2',
'(l1-l2)**2',
],
powerlist=[1, 1, 1, 1, 1, 1, 1],
loop_momenta=['l1', 'l2'],
replacement_rules=[('q1*q1', 0), ('q2*q2', 0), ('q3*q3', 0),
('q1*q2', 's/2'), ('q1*q3', 't/2'),
('q2*q3', '-s/2-t/2')])
Mandelstam_symbols = ['s', 't']
mass_symbols = ['m2']
loop_package(
name='box2L',
loop_integral=li,
real_parameters=Mandelstam_symbols + mass_symbols,
additional_prefactor='m2*s**2',
requested_order=0,
# the optimization level to use in FORM (can be 0, 1, 2, 3)
form_optimization_level=2,
decomposition_method='iterative',
contour_deformation=True)
# Example provided by Krzysztof Grzanka 23/01/2020
#
li = psd.loop_integral.LoopIntegralFromPropagators(
propagators=[
'k1 ** 2', ' (k1 - k2) ** 2', ' k2 ** 2', ' (k1 - k3) ** 2',
' (k2 - k3) ** 2', ' k3**2 - 1', ' (k1 + p1) ** 2',
' (k2 + p1) ** 2'
],
loop_momenta=['k1', 'k2', 'k3'],
powerlist=[1, 1, 1, 1, 1, 1, 1, 1],
replacement_rules=[('p1*p1', '1')])
Mandelstam_symbols = []
mass_symbols = []
loop_package(
name='bubble',
additional_prefactor='exp(3*EulerGamma*eps)',
loop_integral=li,
real_parameters=Mandelstam_symbols + mass_symbols,
complex_parameters=[],
requested_order=0,
form_optimization_level=2,
form_work_space='2G',
decomposition_method='iterative',
normaliz_executable='normaliz',
contour_deformation=True,
split=True,
)
