Example #1
0
    psd.loop_package(

    name = 'banana_3mass',

    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)
    form_optimization_level = 4,

    # the WorkSpace parameter for FORM
    form_work_space = '200M',

    # 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',

    # 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,
    
    # list of qmc integral transforms for which to build code
    pylink_qmc_transforms = ['korobov2x2']

    )
    psd.loop_package(

    name = 'hyperelliptic',

    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)
    form_optimization_level = 4,

    # 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',

    # 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,

    )
    Mandelstam_symbols = ['s12', 's23']
    mass_symbols = ['mt2', 'mH2', 'mZ2']

    psd.loop_package(
        name='hz2L_nonplanar',
        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)
        form_optimization_level=4,

        # the WorkSpace parameter for FORM
        form_work_space='200M',

        # 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',

        # there are no symmetries
        use_dreadnaut=False,
        use_Pak=False,
    )
Example #4
0
    psd.loop_package(

    name = 'triangle2L_split',

    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 = [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`` 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,

    # there are singularities at one due to ``s = mZ^2``
    split = True,

    )
Example #5
0
                                                            ('p2*p2', '0'),
                                                            ('p3*p3', '0'),
                                                            ('p1*p2', 's/2'),
                                                            ('p1*p3', 't/2'),
                                                            ('p2*p3',
                                                             '(mm-s-t)/2')])

    Mandelstam_symbols = ['s', 't']
    mass_symbols = ['mm']

    psd.loop_package(
        name='Nbox2L_split_c',
        loop_integral=li,
        real_parameters=Mandelstam_symbols + mass_symbols,
        additional_prefactor='1',

        # 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=4,

        # the method to be used for the sector decomposition
        # valid values are ``iterative`` and ``geometric``
        decomposition_method='iterative',
        contour_deformation=True,

        # there are singularities at one due to ``p4*p4 = mm``
        #split = True # not needed for (quasi-)finite integrals
        pylink_qmc_transforms=['korobov3'])
                                                            ('p1*p2', 's/2'),
                                                            ('p2*p3',
                                                             'pp4/2-s/2-t/2'),
                                                            ('p1*p3', 't/2')])

    Mandelstam_symbols = ['s', 't', 'pp4']
    mass_symbols = ['msq']

    psd.loop_package(
        name='elliptic2L_euclidean',
        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='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=False)
Example #7
0
    psd.loop_package(

    name = 'triangle3L',

    loop_integral = li,

    real_parameters = Mandelstam_symbols + mass_symbols,

    #additional_prefactor = 'gamma( (4-2*eps)/2-1 )**3',
    additional_prefactor = '(-eps*gamma(-eps))**3', # work around slow gamma expansion in sympy 1.0

    # 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 = '100M',

    # 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',

    contour_deformation = False

    )
Example #8
0
    psd.loop_package(

    name = 'formfactor4L',

    loop_integral = li,

    # normalization as defined in equation (2.4) of arXiv:1510.06758
    additional_prefactor = sp.gamma(li.dimensionality/2 - 1) ** li.L,

    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 = [1],

    # the optimization level to use in FORM (can be 0, 1, 2, 3, 4)
    form_optimization_level = 4,

    # 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 = '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',

    contour_deformation = False,

    # there are no symmetries
    use_dreadnaut = False,
    use_Pak = False,

    )
    psd.loop_package(
        name='bubble2L_full',
        loop_integral=li,
        real_parameters=Mandelstam_symbols + mass_symbols,

        #additional_prefactor = '''gamma(1-2*eps)/(gamma(1+eps)*gamma(1+eps)*gamma(1-eps)*gamma(1-eps))*msq**(1+2*eps)''',
        # in hep-ph/9605392 the i^2 from i*Pi^(D/2) per loop is pulled out
        additional_prefactor='-1',

        # the highest order of the final epsilon expansion
        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='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',

        # whether or not to produce code to perform the contour deformation
        contour_deformation=True,
    )