Compilation too slow

[vsht]

Hi,

when I run make (with 8 threads) for the following integral

#!/usr/bin/env python3
if __name__ == "__main__":
    from pySecDec import sum_package, loop_package, loop_regions, LoopIntegralFromPropagators
    import pySecDec as psd

    li =     LoopIntegralFromPropagators(
    ['(k + r)**2', 'k**2 - mc**2', '-mb**2 + (l + r)**2', '-mc**2 + (l + q)**2', 'l**2 - mc**2'],
    loop_momenta = ['k', 'l', 'r'],
    powerlist = [1, 1, 1, 1, 1],
    dimensionality = '4 - 2*eps',
    Feynman_parameters = 'x',
    replacement_rules = [('q**2','0')],
    regulators = ['eps']
    )

    import os,shutil
    if os.path.isdir('loopint'):
        if input('The directory loopint already exists, do you want to overwrite it (y/n)? ') in ['y','Y','j']:
            shutil.rmtree('loopint')
        else:
            exit(1)

    loop_package(
    name = 'loopint',
    loop_integral = li,
    requested_orders = [2],
    real_parameters = ['mb', 'mc'],
    contour_deformation = True,
    additional_prefactor = '(1)*exp(3*EulerGamma*eps)',
    decomposition_method = 'geometric'
    )

the compilation never seems to finish due to never ending form workspace overflows. The automatic increase of the Workspace
parameter doesn't seem to help here.

On the contrary, Fiesta gives me the result in no time

SDEvaluate[UF[{l, r, k}, {(k + r)^2, k^2 - mc^2, (l + r)^2 - mb^2, (l + q)^2 - mc^2,  l^2 - mc^2}, {q^2 -> 0, mb -> 4.2, mc -> 1.2}], {1, 1, 1, 1, 1}, 0]
(*
(1065.3460406566296 + 1675.8903991813552*I) + (6.36002718461913 + 0.00008057073979*pm25)/ep^3 + 
 ((-13.39642639222347 - 79.92425176163526*I) + (0.00436005273322 + 0.00993606510463*I)*pm26)/ep^2 + 
 ((-468.14913352474855 + 168.34250189409968*I) + (0.0855696690395 + 0.0871346419159*I)*pm27)/ep + (1.16958511395016 + 0.64293008395652*I)*pm28
*)

I know that pySecDec has some difficulties with eikonal on-shell integrals (cf. Issue #27) but in this case all propagators are quadratic so I don't immediately see why it should be so hard.

Perhaps I'm doing something wrong when generating my Python script?

Cheers,
Vlad

[magv]

Here's the version that works for me:

#!/usr/bin/env python3
import pySecDec as psd

if __name__ == "__main__":
    li = psd.LoopIntegralFromPropagators(
        propagators = [
            '(k + r)^2',
            'k^2 - mc2',
            '(l + r)^2 - mb2',
            '(l + q)^2 - mc2',
            'l^2 - mc2'
        ],
        loop_momenta = ['k', 'l', 'r'],
        powerlist = [1, 1, 1, 1, 1],
        dimensionality = '4 - 2*eps',
        replacement_rules = [('q^2','0')],
        regulators = ['eps']
    )

    import os,shutil
    if os.path.isdir('vsht34'):
        if input('The directory vsht34 already exists, do you want to overwrite it (y/n)? ') in ['y','Y','j']:
            shutil.rmtree('vsht34')
        else:
            exit(1)

    psd.loop_package(
        name = 'vsht34',
        loop_integral = li,
        requested_orders = [2],
        real_parameters = ['mb2', 'mc2'],
        contour_deformation = True,
        additional_prefactor = '(1)*exp(3*EulerGamma*eps)',
        decomposition_method = 'geometric',
        form_work_space = "2500000000",
        form_threads = 8
    )

Sorry for reformatting; I think form_work_space and form_threads are the two changes needed to get FORM to work faster here: turns out that all the sectors but two are fairly simple here, but then the two take a lot of time, so it makes sense to parallelize inside FORM, instead of running many FORM instances. It still takes a while, of course. Not sure why it is so slow here, other than the usual slowdown with high epsilon orders (orders from -3 to 2 are requested here, with a spurious pole at eps^-4).

As a side remark: we do want to optimize the compilation of deep expansions in epsilon (partly due to your examples), but don't expect it to be done soon.

Anyway here's the result I get in 6 seconds of integration:

  (
    +eps^-4*(+0.0000000000000000e+00+0.0000000000000000e+00j)
    +eps^-4*(+0.0000000000000000e+00+0.0000000000000000e+00j)*plusminus
    +eps^-3*(+6.3600000964232173e+00+7.8169403958139919e-09j)
    +eps^-3*(+8.8994299647834828e-08+1.6317434737650884e-08j)*plusminus
    +eps^-2*(-1.3396129904893288e+01+1.8147566022181363e-06j)
    +eps^-2*(+1.6791221561128797e-06+1.6081663316245384e-06j)*plusminus
    +eps^-1*(+3.4028666405350769e+01-1.7777513078195774e-05j)
    +eps^-1*(+2.8235474963978490e-05+2.5353251249714558e-05j)*plusminus
    +eps^0*(+7.6084044527743515e+00+8.9566797897598364e-06j)
    +eps^0*(+1.6686880375490262e-04+1.5586864146259737e-04j)*plusminus
    +eps^1*(-3.6232900461629225e+02-2.3126114775237484e-04j)
    +eps^1*(+8.7037399479198752e-04+8.1219985406518695e-04j)*plusminus
    +eps^2*(+1.8694132080737036e+03-2.3127813954879382e-04j)
    +eps^2*(+4.3443624607138820e-03+4.1126159389531357e-03j)*plusminus
  )

... this doesn't really look like what you have above there. Is this expected?

[vsht]

Hi Vitaly,

thanks a lot for the improved code. With form_work_space and form_threads set accordingly I can finally get
the make part through.

... this doesn't really look like what you have above there. Is this expected?

The discrepancy between pySecDec and Fiesta starts at order 1/ep^2. For this integral I don't have an analytic result,
so I can't really say who is right and who is wrong here...

[vsht]

The discrepancy between pySecDec and Fiesta starts at order 1/ep^2. For this integral I don't have an analytic result,
so I can't really say who is right and who is wrong here...

Sorry, there's actually no discrepancy. It's just that I once again forgot that FIESTA expects $- p^2 + m^2 + i \eta$ as propagators, while
for pySecDec those should be $p^2-m^2 + i \eta$. For

-SDEvaluate[UF[{l, r,   k}, {-(k + r)^2, -k^2 + mc^2, -(l + r)^2 + mb^2, -(l + q)^2 + 
     mc^2, -l^2 + mc^2}, {q^2 -> 0, mb -> 4.2, mc -> 1.2}], {1, 1, 1, 1, 1}, 2]

I get

7.60852483367665 - (-6.35999999999983 + 9.*^-14*pm78)/ep^3 - (13.39612936719147 + 9.33946*^-9*pm79)/ep^2 - (-34.02864873601512 + 4.84572862*^-6*pm80)/ep - 0.00004132335314*pm81 - ep*(362.329040104941 + 0.00026882426669*pm82) - 
 ep^2*(-1869.4144486408948 + 0.00143279360708*pm83)

which is consistent with the pySecDec result.