Extremely poor event generation efficiency with W2

[Christian Speckner]

I've noticed that, while the adaption process seems to converge better in W2 when compared to W1, the event generation efficiency actually is significantly worse. In addition, it seem suspicious to me that the efficiency actually _drops_ during an otherwise nice and clean adaption, and that it even goes down when the number of calls is increased. Consider for example the sindarin

model = SM
alias pr = u:ubar:d:dbar:c:cbar:s:sbar
alias finals = "e+":"e-":"mu+":"mu-"
process test = pr, pr => "e+", "e-", "mu+", "mu-"
sqrts = 14 TeV
beams = p, p => lhapdf
cuts =
   all Pt > 10 GeV [finals] and
   all -0.95 < cos(Theta) < 0.95 [finals, finals]
integrate (test) {}

which produces the result

|=============================================================================|
| It      Calls  Integral[GeV] Error[GeV]  Err[%]    Acc  Eff[%]   Chi2 N[It] |
|=============================================================================|
   1      20000  5.1569483E+00  1.81E+00   35.05   49.56*   0.40
   2      20000  7.2782120E+00  1.05E+00   14.37   20.32*   0.35
   3      20000  1.1765985E+01  1.48E+00   12.58   17.79*   0.74
   4      20000  1.2160287E+01  7.23E-01    5.94    8.40*   0.88
   5      20000  1.2010562E+01  5.11E-01    4.25    6.02*   1.11
|-----------------------------------------------------------------------------|
   5     100000  1.1168648E+01  3.67E-01    3.29   10.39    1.11    7.42   5
|-----------------------------------------------------------------------------|
   6      50000  1.2235931E+01  3.90E-01    3.19    7.13    0.85
   7      50000  1.2159402E+01  2.33E-01    1.91    4.28*   0.67
   8      50000  1.2254449E+01  1.83E-01    1.50    3.34*   0.57
   9      50000  1.2365689E+01  1.64E-01    1.33    2.97*   0.53
  10      50000  1.2409821E+01  1.23E-01    0.99    2.22*   0.51
  11      50000  1.2499192E+01  1.12E-01    0.89    2.00*   0.51
  12      50000  1.2668377E+01  9.97E-02    0.79    1.76*   0.51
  13      50000  1.2701257E+01  9.03E-02    0.71    1.59*   0.48
  14      50000  1.2804816E+01  8.55E-02    0.67    1.49*   0.50
  15      50000  1.2789000E+01  7.47E-02    0.58    1.31*   0.47
|=============================================================================|
  15     500000  1.2639925E+01  3.59E-02    0.28    2.01    0.47    2.88  10
|=============================================================================|

Note the _decrease_ of the efficiency in the adaption process. Increasing the number of calls to

integrate (test) {iterations=5:200000,10:500000}

changes the result to

|=============================================================================|
| It      Calls  Integral[GeV] Error[GeV]  Err[%]    Acc  Eff[%]   Chi2 N[It] |
|=============================================================================|
   1     200000  1.3418301E+01  1.62E+00   12.06   53.94*   0.08
   2     200000  1.1978113E+01  2.70E-01    2.25   10.07*   0.07
   3     200000  1.2553541E+01  1.36E-01    1.09    4.86*   0.84
   4     200000  1.3004889E+01  1.19E-01    0.92    4.10*   0.88
   5     200000  1.3451541E+01  1.07E-01    0.80    3.57*   0.93
|-----------------------------------------------------------------------------|
   5    1000000  1.3007363E+01  6.66E-02    0.51    5.12    0.93   10.71   5
|-----------------------------------------------------------------------------|
   6     500000  1.3450903E+01  1.06E-01    0.79    5.58    0.41
   7     500000  1.3374334E+01  4.62E-02    0.35    2.45*   0.38
   8     500000  1.3444604E+01  3.31E-02    0.25    1.74*   0.38
   9     500000  1.3452555E+01  2.67E-02    0.20    1.40*   0.36
  10     500000  1.3455425E+01  2.27E-02    0.17    1.19*   0.36
  11     500000  1.3469888E+01  1.99E-02    0.15    1.04*   0.36
  12     500000  1.3463809E+01  1.78E-02    0.13    0.94*   0.36
  13     500000  1.3453477E+01  1.62E-02    0.12    0.85*   0.36
  14     500000  1.3452079E+01  1.49E-02    0.11    0.78*   0.36
  15     500000  1.3451726E+01  1.38E-02    0.10    0.73*   0.36
|=============================================================================|
  15    5000000  1.3454139E+01  6.45E-03    0.05    1.07    0.36    0.45  10
|=============================================================================|

Paradoxically, although the error has improved as expected, the efficiency is actually _worse_ with the increased number of calls!

At the same time, integrating this process with W1 with the calls setting

calls = 3,20000,10,50000,3,50000

gives

 ! Using grids and results from file:
    1      60000  1.3226423E+01  1.36E+00   10.29   25.20*  0.15    1.34   3
 !-----------------------------------------------------------------------------
 ! Using grids and results from file:
    2      50000  1.3334956E+01  8.19E-01    6.14   13.73*  0.29
    3      50000  1.2170788E+01  3.11E-01    2.55    5.70*  0.77
    4      50000  1.4675658E+01  1.98E+00   13.48   30.13   0.23
    5      50000  1.3702870E+01  3.84E-01    2.80    6.27   0.42
    6      50000  1.3641691E+01  2.27E-01    1.66    3.72*  1.11
    7      50000  1.3176067E+01  2.35E-01    1.78    3.99   1.36
    8      50000  1.3211461E+01  1.93E-01    1.46    3.26*  1.34
    9      50000  1.3185617E+01  1.66E-01    1.26    2.81*  1.49
   10      50000  1.3403728E+01  1.90E-01    1.42    3.17   1.49
   11      50000  1.3399631E+01  1.97E-01    1.47    3.29   1.35
 !-----------------------------------------------------------------------------
 ! Integrating (fixed wgts.):   3 samples of      50000 calls ...
   12     150000  1.3238828E+01  9.66E-02    0.73    2.83   1.09    0.74   3
 !-----------------------------------------------------------------------------

Notably, although the adaption itself seems poor compared to W2, the efficiency is significantly higher, and also behaves like one would expect: increasing in the adaption process.

[kilian]

First of all, the efficiency is not extremely poor, but still reasonable.

Comparing W1 and W2 with the same iteration setup

calls = 3,20000,10,50000,3,50000

same cuts, and the same process (only u, ubar in initial state), it turns out that there is no difference between the W1 and W2 results. In both cases, accuracy is about 3 and efficiency is 0.6%. Since initial-state summation was buggy in W1, I don't compare the full process. It may be that for the full process, the W1 setup was more efficient (but not by a great margin), but this may as well be faked by not finding the true maximum weight.

Looking more closely, this process has extreme kinematics, with the e+e- invariant mass ranging from the beam energy down to about 5 GeV. Adding a cut on M(e+e-) of 10 GeV immediately improves the efficiency. Furthermore, a histogram of an appropriate simulation with say, 10k events shows that in the corners of phase space the event population is really sparse, so it is very likely that the true maximum weight is not easily found. I'd guess that the observed decrease in efficiency is real, approximating the true max weight more and more closely. But this is just speculation.

To summarize, I think this case is at the limit of Whizard's capability of approximating phase space efficiently (for unweighted events), and I don't see a way of improving this. Closing as won't fix.