#! /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, )