← Back to branch summary

~maddevelopers/mg5amcnlo/2.9.4

« back to all changes in this revision

Viewing changes to tests/parallel_tests/test_ML5.py

pass to v2.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/parallel_tests/test_ML5.py
 
1
import logging.config
 
2
import logging
 
3
import pydoc
 
4
import os
 
5
import loop_me_comparator
 
6
import me_comparator
 
7
import unittest
 
8
 
 
9
 
 
10
from madgraph import MG5DIR
 
11
from madgraph import MadGraph5Error
 
12
from madgraph.iolibs.files import cp
 
13
 
 
14
#Look for MG5/MG4 path
 
15
_mg5_path = os.sep.join(os.path.realpath(__file__).split(os.sep)[:-3])
 
16
_file_path = os.path.dirname(os.path.realpath(__file__))
 
17
_pickle_path = os.path.join(_file_path, 'input_files', 'ML_parallel_saved_runs')
 
18
 
 
19
# The processes below are treated all together because they are relatively quick
 
20
 
 
21
ML4_processes_short = [('u u~ > d d~',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
22
                       ('d g > d g',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
23
                       ('g g > d d~',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
24
                       ('e+ e- > d d~',{'QED':2,'QCD':0},['QCD'],{'QCD':2,'QED':4}),
 
25
                       ('g g > t t~',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
26
                       ('d~ d > g a',{'QED':1,'QCD':1},['QCD'],{'QCD':4,'QED':2}),
 
27
                       ('d~ d > g z',{'QED':1,'QCD':1},['QCD'],{'QCD':4,'QED':2})]
 
28
 
 
29
ML5_processes_short = [('u u~ > d d~',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
30
                       ('d g > d g',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
31
                       ('d~ u~ > d~ u~',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}), 
 
32
                       ('g u~ > g u~',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
33
                       ('g g > d d~',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
34
                       ('g g > t t~',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
35
                       ('g g > g g',{'QCD':2,'QED':0},['QCD'],{'QCD':6,'QED':0}),
 
36
                       ('d~ d > g a',{'QED':1,'QCD':1},['QCD'],{'QCD':4,'QED':2}),
 
37
                       ('u~ u > g z',{'QED':1,'QCD':1},['QCD'],{'QCD':4,'QED':2}),
 
38
                       ('e+ e- > d d~',{'QED':2,'QCD':0},['QCD'],{'QCD':2,'QED':4}),
 
39
                       ('d u~ > w- g',{'QED':1,'QCD':1},['QCD'],{'QCD':4,'QED':2})]
 
40
 
 
41
def procToFolderName(proc):
 
42
    """ Transform a string proc like 'u u~ > e+ e-' to a string for a folder name
 
43
    which would be uux_epem"""
 
44
    res=''.join(proc.split(' '))
 
45
    equiv_strings = [('+','p'),('-','m'),('~','x'),('>','_')]
 
46
    for eq in equiv_strings:
 
47
        res=res.replace(eq[0],eq[1])
 
48
    return res
 
49
 
 
50
# The longer processes below are treated one by one so that they can be better
 
51
# independently checked/updated (especially the corresponding reference pickle.)
 
52
 
 
53
ML4_processes_long =  [
 
54
                       # The process below is for testing the parallel tests only
 
55
                       ('e+ e- > d d~',{'QCD':0,'QED':2},['QCD'],{'QCD':2,'QED':4}),
 
56
                       # Below are the processes really tested
 
57
                       ('g g > h t t~',{'QCD':2,'QED':2},['QCD'],{'QCD':6,'QED':4}), 
 
58
                       ('d d~ > w+ w- g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4}),
 
59
                       ('d~ d > z z g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4}),
 
60
                       ('d~ d > z g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),
 
61
                       ('d~ d > a g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),
 
62
                       ('g g > z t t~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),
 
63
                       ('g g > a t t~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})]
 
64
 
 
65
ML4_processes_long_dic = dict((procToFolderName(elem[0]),elem) for elem in \
 
66
                                                             ML4_processes_long)
 
67
 
 
68
ML5_processes_long =  [('g g > h t t~',{'QCD':2,'QED':1},['QCD'],{'QCD':6,'QED':2}), 
 
69
                       ('d d~ > w+ w- g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4}),
 
70
                       ('d~ d > z z g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4}),
 
71
                       ('s s~ > a z g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4}),                       
 
72
                       ('d~ d > z g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),
 
73
                       ('d~ d > a g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),
 
74
                       ('d~ u > w+ g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),
 
75
                       ('g g > w- d~ u',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),                       
 
76
                       ('g g > z t t~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),
 
77
                       ('g g > a t t~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}),
 
78
                       ('g g > h h t t~',{'QCD':2,'QED':2},['QCD'],{'QCD':6,'QED':4}),
 
79
                       ('u u~ > w+ w- b b~',{'QCD':2,'QED':2},['QCD'],{'QCD':6,'QED':4}),                       
 
80
                       ('g g > g g g',{'QCD':3,'QED':0},['QCD'],{'QCD':8,'QED':0}),
 
81
                       ('u u~ > z z z',{'QED':3,'QCD':0},['QCD'],{'QCD':2,'QED':6}),
 
82
                       ('u d~ > h t b~',{'QED':3,'QCD':0},['QCD'],{'QCD':2,'QED':6}),
 
83
                       ('u u~ > w+ w- z',{'QED':3,'QCD':0},['QCD'],{'QCD':2,'QED':6}),
 
84
                       ('g g > g t t~',{'QED':0,'QCD':3},['QCD'],{'QCD':8,'QED':0}),
 
85
                       ('g s > e- ve~ c',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4}),
 
86
                       ('g g > z c c~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})]
 
87
 
 
88
ML5_processes_long_dic = dict((procToFolderName(elem[0]),elem) for elem in \
 
89
                                                             ML5_processes_long)
 
90
 
 
91
class ML5Test(unittest.TestCase):
 
92
    """ A class to test ML5 versus runs from older versions or ML4 """
 
93
 
 
94
    test_model_name = 'loop_sm-parallel_test'
 
95
    test_model_name_c_massive = 'loop_sm-parallel_test_c_massive'
 
96
 
 
97
    def setUp(self):
 
98
        """ Here we just copy the hidden restrict_card to a regular one.
 
99
        And we don't bother making it hidden again after the test."""
 
100
        cp(os.path.join(_mg5_path,'models','loop_sm','.restrict_parallel_test.dat'),
 
101
           os.path.join(_mg5_path,'models','loop_sm','restrict_parallel_test.dat'))
 
102
        cp(os.path.join(_mg5_path,'models','loop_sm',
 
103
                                       '.restrict_parallel_test_c_massive.dat'),
 
104
           os.path.join(_mg5_path,'models','loop_sm',
 
105
                                        'restrict_parallel_test_c_massive.dat'))
 
106
 
 
107
    @staticmethod
 
108
    def create_pickle(my_proc_list, pickle_file, runner, ref_runner=None,
 
109
                      model = 'loop_sm-parallel_test', energy = 2000):
 
110
        """ Create a pickle with name 'pickle_file' on the specified processes
 
111
        and also possibly using the PS points provided by the reference runner """
 
112
        
 
113
        my_comp = loop_me_comparator.LoopMEComparator()
 
114
        if not ref_runner is None:
 
115
            my_comp.set_me_runners(ref_runner,runner)
 
116
        else:
 
117
            my_comp.set_me_runners(runner)
 
118
        my_comp.run_comparison(my_proc_list,model=model,energy=energy)
 
119
 
 
120
        loop_me_comparator.LoopPickleRunner.store_comparison( 
 
121
            os.path.join(_pickle_path,pickle_file),
 
122
            [runner.proc_list,runner.res_list],
 
123
            runner.model,runner.name,energy=runner.energy)
 
124
        
 
125
    def compare_processes(self, my_proc_list = [], model = 'loop_sm-parallel_test',
 
126
            pickle_file = "", energy = 2000, tolerance = 1e-06, filename = "",
 
127
            chosen_runner = "ML5_opt"):
 
128
        """ A helper function to compare processes. 
 
129
        Note that the chosen_runner is what runner should to create the reference
 
130
        pickle if missing"""
 
131
        
 
132
        # Print out progress if it is a run for an individual process
 
133
        if len(my_proc_list)==1:
 
134
            print "\n== %s =="%my_proc_list[0][0]
 
135
        else:
 
136
            print "\n== %s =="%filename
 
137
        
 
138
        # Check if pickle exists, if not create it        
 
139
        if pickle_file!="" and not os.path.isfile(os.path.join(_pickle_path,pickle_file)):
 
140
            print " => Computing reference evaluation with %s"%chosen_runner
 
141
            self.create_loop_pickle(my_proc_list, model,
 
142
                                             pickle_file, energy, chosen_runner)
 
143
            print "\n => Done with %s evaluation"%chosen_runner
 
144
        # Load the stored runner
 
145
        if pickle_file != "":
 
146
            stored_runner = me_comparator.PickleRunner.find_comparisons(
 
147
                              os.path.join(_pickle_path,pickle_file))[0]
 
148
 
 
149
        # Create a MERunner object for MadLoop 5 optimized
 
150
        ML5_opt = loop_me_comparator.LoopMG5Runner()
 
151
        ML5_opt.setup(_mg5_path, optimized_output=True, temp_dir=filename)
 
152
    
 
153
        # Create a MERunner object for MadLoop 5 default
 
154
        ML5_default = loop_me_comparator.LoopMG5Runner()
 
155
        ML5_default.setup(_mg5_path, optimized_output=False, temp_dir=filename) 
 
156
 
 
157
        # Create and setup a comparator
 
158
        my_comp = loop_me_comparator.LoopMEComparator()
 
159
        
 
160
        # Always put the saved run first if you use it, so that the corresponding PS
 
161
        # points will be used.
 
162
        if pickle_file != "":
 
163
            my_comp.set_me_runners(stored_runner,ML5_opt,ML5_default)
 
164
        else:
 
165
            my_comp.set_me_runners(ML5_opt,ML5_default)
 
166
        
 
167
        # Run the actual comparison
 
168
        my_comp.run_comparison(my_proc_list,
 
169
                           model=model,
 
170
                           energy=energy)
 
171
        
 
172
        # Print the output
 
173
        my_comp.output_result(filename=os.path.join(_mg5_path,filename+'.log'))
 
174
 
 
175
        # Assert that all process comparisons passed the tolerance cut
 
176
        my_comp.assert_processes(self, tolerance)
 
177
 
 
178
        # Do some cleanup
 
179
        my_comp.cleanup()
 
180
 
 
181
    def create_loop_pickle(self, my_proc_list, model, pickle_file, energy, \
 
182
                                                                 chosen_runner):
 
183
        """ Create the pickle file for reference for the arguments here."""
 
184
#       print "Creating loop pickle for chosen_runner=",chosen_runner
 
185
        allowed_chosen_runners = ['ML4','ML5_opt','ML5_default'] 
 
186
        if chosen_runner not in allowed_chosen_runners:
 
187
            raise MadGraph5Error, 'The reference runner can only be in %s.'%\
 
188
                                                          allowed_chosen_runners
 
189
        
 
190
        runner = None
 
191
        if chosen_runner == 'ML5_opt':
 
192
            runner = loop_me_comparator.LoopMG5Runner()
 
193
            runner.setup(_mg5_path, optimized_output=True)
 
194
        if chosen_runner == 'ML5_default':
 
195
            runner = loop_me_comparator.LoopMG5Runner()
 
196
            runner.setup(_mg5_path, optimized_output=False)
 
197
        if chosen_runner == 'ML4':
 
198
            runner = loop_me_comparator.LoopMG4Runner()
 
199
            # Replace here the path of your ML4 installation
 
200
            runner.setup('/Users/valentin/Documents/Work/aMC@NLO_v4/ML4ParrallelTest/NLOComp')
 
201
        
 
202
        self.create_pickle(my_proc_list,pickle_file, runner, ref_runner=None, \
 
203
                                                      model=model,energy=energy)
 
204
        # Clean up the runner only if it is not ML4
 
205
        if chosen_runner != 'ML4':
 
206
            runner.cleanup()
 
207
 
 
208
    #===========================================================================
 
209
    # First tests consisting in a list of quick 2>2 processes to be run together
 
210
    #===========================================================================
 
211
 
 
212
    def test_short_ML5_sm_vs_stored_ML5(self):
 
213
        self.compare_processes(ML5_processes_short,model = self.test_model_name,
 
214
                                   pickle_file = 'ml5_short_parallel_tests.pkl',
 
215
                                        filename = 'ptest_short_ml5_vs_old_ml5',
 
216
                                                            chosen_runner='ML5')
 
217
 
 
218
    # In principle since previous version of ML5 has been validated against ML4, 
 
219
    # it is not necessary to test both against ML4 and the old ML5.
 
220
    def test_short_ML5_sm_vs_stored_ML4(self):
 
221
        self.compare_processes(ML4_processes_short,model = self.test_model_name,
 
222
                                    pickle_file = 'ml4_short_parallel_test.pkl',
 
223
                                            filename = 'ptest_short_ml5_vs_ml4',
 
224
                                                            chosen_runner='ML4')
 
225
 
 
226
    # The tests below probe one quite long process at a time individually, so
 
227
    # one can better manage them.
 
228
    
 
229
    #===========================================================================
 
230
    # First the long checks against results available in MadLoop4
 
231
    #===========================================================================
 
232
 
 
233
#   Use the quick process below for testing the parallel test
 
234
    def notest_long_sm_vs_stored_ML4_epem_ddx(self):
 
235
        proc = 'epem_ddx'
 
236
        self.compare_processes([ML4_processes_long_dic[proc]], 
 
237
               model = self.test_model_name, pickle_file = 'ml4_sm_%s.pkl'%proc,
 
238
               filename = 'ptest_long_sm_vs_ml4_%s'%proc, chosen_runner = 'ML4')
 
239
 
 
240
#   ('g g > h t t~',{'QCD':2,'QED':1},['QCD'],{'QCD':6,'QED':2})
 
241
    def test_long_sm_vs_stored_ML4_gg_httx(self):
 
242
        proc = 'gg_httx'
 
243
        self.compare_processes([ML4_processes_long_dic[proc]], 
 
244
               model = self.test_model_name, pickle_file = 'ml4_sm_%s.pkl'%proc,
 
245
               filename = 'ptest_long_sm_vs_ml4_%s'%proc, chosen_runner = 'ML4')
 
246
 
 
247
#   ('d d~ > w+ w- g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4})    
 
248
    def test_long_sm_vs_stored_ML4_ddx_wpwmg(self):
 
249
        proc = 'ddx_wpwmg'
 
250
        self.compare_processes([ML4_processes_long_dic[proc]], 
 
251
               model = self.test_model_name, pickle_file = 'ml4_sm_%s.pkl'%proc,
 
252
                                      filename = 'ptest_long_sm_vs_ml4_%s'%proc)
 
253
 
 
254
#   ('d~ d > z z g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4})
 
255
    def test_long_sm_vs_stored_ML4_dxd_zzg(self):
 
256
        proc = 'dxd_zzg'
 
257
        self.compare_processes([ML4_processes_long_dic[proc]], 
 
258
               model = self.test_model_name, pickle_file = 'ml4_sm_%s.pkl'%proc,
 
259
               filename = 'ptest_long_sm_vs_ml4_%s'%proc, chosen_runner = 'ML4')
 
260
 
 
261
#   ('d~ d > z g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
262
    def test_long_sm_vs_stored_ML4_dxd_zgg(self):
 
263
        proc = 'dxd_zgg'
 
264
        self.compare_processes([ML4_processes_long_dic[proc]], 
 
265
               model = self.test_model_name, pickle_file = 'ml4_sm_%s.pkl'%proc,
 
266
               filename = 'ptest_long_sm_vs_ml4_%s'%proc, chosen_runner = 'ML4')
 
267
 
 
268
#   ('d~ d > a g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
269
    def test_long_sm_vs_stored_ML4_dxd_agg(self):
 
270
        proc = 'dxd_agg'
 
271
        self.compare_processes([ML4_processes_long_dic[proc]], 
 
272
               model = self.test_model_name, pickle_file = 'ml4_sm_%s.pkl'%proc,
 
273
               filename = 'ptest_long_sm_vs_ml4_%s'%proc, chosen_runner = 'ML4')
 
274
 
 
275
#   ('g g > z t t~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
276
    def test_long_sm_vs_stored_ML4_gg_zttx(self):
 
277
        proc = 'gg_zttx'
 
278
        self.compare_processes([ML4_processes_long_dic[proc]], 
 
279
               model = self.test_model_name, pickle_file = 'ml4_sm_%s.pkl'%proc,
 
280
               filename = 'ptest_long_sm_vs_ml4_%s'%proc, chosen_runner = 'ML4')
 
281
 
 
282
#   ('g g > a t t~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
283
    def test_long_sm_vs_stored_ML4_gg_attx(self):
 
284
        proc = 'gg_zttx'
 
285
        self.compare_processes([ML4_processes_long_dic[proc]], 
 
286
               model = self.test_model_name, pickle_file = 'ml4_sm_%s.pkl'%proc,
 
287
               filename = 'ptest_long_sm_vs_ml4_%s'%proc, chosen_runner = 'ML4')
 
288
 
 
289
    #===========================================================================
 
290
    # Now the long checks against results previsouly generated in MadLoop 5.
 
291
    #===========================================================================
 
292
 
 
293
#   ('g g > g t t~ ',{'QED':0,'QCD':3},['QCD'],{'QCD':8,'QED':0})
 
294
    def test_long_sm_vs_stored_ML5_gg_gttx(self):
 
295
        proc = "gg_gttx"
 
296
        self.compare_processes([ML5_processes_long_dic[proc]],
 
297
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
298
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
299
                                                      chosen_runner = 'ML5_opt')
 
300
 
 
301
#   ('g g > h t t~',{'QCD':2,'QED':1},['QCD'],{'QCD':6,'QED':2})
 
302
    def test_long_sm_vs_stored_ML5_gg_httx(self):
 
303
        proc = "gg_httx"
 
304
        self.compare_processes([ML5_processes_long_dic[proc]],
 
305
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
306
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
307
                                                      chosen_runner = 'ML5_opt')
 
308
 
 
309
#   ('d d~ > w+ w- g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4})
 
310
    def test_long_sm_vs_stored_ML5_ddx_wpwmg(self):
 
311
        proc = "ddx_wpwmg"
 
312
        self.compare_processes([ML5_processes_long_dic[proc]],
 
313
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
314
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
315
                                                      chosen_runner = 'ML5_opt')
 
316
 
 
317
#   ('d~ d > z z g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4})
 
318
    def test_long_sm_vs_stored_ML5_dxd_zzg(self):
 
319
        proc = "dxd_zzg"
 
320
        self.compare_processes([ML5_processes_long_dic[proc]],
 
321
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
322
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
323
                                                      chosen_runner = 'ML5_opt')
 
324
    
 
325
#   ('s s~ > a z g',{'QED':2,'QCD':1},['QCD'],{'QCD':4,'QED':4})
 
326
    def test_long_sm_vs_stored_ML5_ssx_azg(self):
 
327
        proc = "ssx_azg"
 
328
        self.compare_processes([ML5_processes_long_dic[proc]],
 
329
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
330
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
331
                                                      chosen_runner = 'ML5_opt')
 
332
    
 
333
#   ('d~ d > z g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
334
    def test_long_sm_vs_stored_ML5_dxd_zgg(self):
 
335
        proc = "dxd_zgg"
 
336
        self.compare_processes([ML5_processes_long_dic[proc]],
 
337
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
338
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
339
                                                      chosen_runner = 'ML5_opt')
 
340
 
 
341
#   ('d~ d > a g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
342
    def test_long_sm_vs_stored_ML5_dxd_agg(self):
 
343
        proc = "dxd_agg"
 
344
        self.compare_processes([ML5_processes_long_dic[proc]],
 
345
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
346
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
347
                                                      chosen_runner = 'ML5_opt')
 
348
 
 
349
#   ('d~ u > w+ g g',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
350
    def test_long_sm_vs_stored_ML5_dxu_wpgg(self):
 
351
        proc = "dxu_wpgg"
 
352
        self.compare_processes([ML5_processes_long_dic[proc]],
 
353
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
354
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
355
                                                      chosen_runner = 'ML5_opt')
 
356
 
 
357
#   ('g g > w- d~ u',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2}) 
 
358
    def test_long_sm_vs_stored_ML5_gg_wmdxu(self):
 
359
        proc = "gg_wmdxu"
 
360
        self.compare_processes([ML5_processes_long_dic[proc]],
 
361
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
362
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
363
                                                      chosen_runner = 'ML5_opt')
 
364
                      
 
365
#   ('g g > z t t~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
366
    def test_long_sm_vs_stored_ML5_gg_zttx(self):
 
367
        proc = "gg_zttx"
 
368
        self.compare_processes([ML5_processes_long_dic[proc]],
 
369
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
370
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
371
                                                      chosen_runner = 'ML5_opt')
 
372
 
 
373
#   ('g g > a t t~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
374
    def test_long_sm_vs_stored_ML5_gg_attx(self):
 
375
        proc = "gg_attx"
 
376
        self.compare_processes([ML5_processes_long_dic[proc]],
 
377
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
378
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
379
                                                      chosen_runner = 'ML5_opt')
 
380
 
 
381
#   ('g g > h h t t~',{'QCD':2,'QED':2},['QCD'],{'QCD':6,'QED':4})
 
382
    def test_long_sm_vs_stored_ML5_gg_hhttx(self):
 
383
        proc = "gg_hhttx"
 
384
        self.compare_processes([ML5_processes_long_dic[proc]],
 
385
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
386
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
387
                                                      chosen_runner = 'ML5_opt')
 
388
 
 
389
#   ('u u~ > w+ w- b b~',{'QCD':2,'QED':2},['QCD'],{'QCD':6,'QED':4})
 
390
    def test_long_sm_vs_stored_ML5_uux_wpwmbbx(self):
 
391
        proc = "uux_wpwmbbx"
 
392
        self.compare_processes([ML5_processes_long_dic[proc]],
 
393
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
394
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
395
                                                      chosen_runner = 'ML5_opt')
 
396
             
 
397
#   ('g g > g g g',{'QCD':3,'QED':0},['QCD'],{'QCD':8,'QED':0})
 
398
#   The chosen PS point for this process turns out to be  unstable, so that 
 
399
#   MadLoop goes to quadruple precision. The agreement is then fine (10e-14!)
 
400
#   but it takes several hours for the non-optimized evaluation. So better skip
 
401
#   it unless you explicitly want to try out quad prec behaviors.
 
402
    def notest_long_sm_vs_stored_ML5_gg_ggg(self):
 
403
        proc = "gg_ggg"
 
404
        self.compare_processes([ML5_processes_long_dic[proc]],
 
405
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
406
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
407
                                                      chosen_runner = 'ML5_opt')
 
408
 
 
409
#   ('u u~ > z z z',{'QED':3,'QCD':0},['QCD'],{'QCD':2,'QED':6})
 
410
    def test_long_sm_vs_stored_ML5_uux_zzz(self):
 
411
        proc = "uux_zzz"
 
412
        self.compare_processes([ML5_processes_long_dic[proc]],
 
413
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
414
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
415
                                                      chosen_runner = 'ML5_opt')
 
416
 
 
417
#   ('u d~ > h t b~',{'QED':3,'QCD':0},['QCD'],{'QCD':2,'QED':6}),
 
418
    def test_long_sm_vs_stored_ML5_udx_htbx(self):
 
419
        proc = "udx_htbx"
 
420
        self.compare_processes([ML5_processes_long_dic[proc]],
 
421
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
422
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
423
                                                      chosen_runner = 'ML5_opt')
 
424
 
 
425
#   ('u u~ > w+ w- z',{'QED':3,'QCD':0},['QCD'],{'QCD':2,'QED':6})
 
426
    def test_long_sm_vs_stored_ML5_uux_wpwmz(self):
 
427
        proc = "uux_wpwmz"
 
428
        self.compare_processes([ML5_processes_long_dic[proc]],
 
429
               model = self.test_model_name, pickle_file = 'ml5_sm_%s.pkl'%proc,
 
430
                                  filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
431
                                                      chosen_runner = 'ML5_opt')
 
432
        
 
433
#    ('g s > e- ve~ c',{'QED':2,'QCD':1},['QCD'],{'QCD':3,'QED':2})
 
434
    def test_long_sm_vs_stored_ML5_gs_emvexc(self):
 
435
        proc = "gs_emvexc"
 
436
        self.compare_processes([ML5_processes_long_dic[proc]],
 
437
            model = self.test_model_name_c_massive, 
 
438
            pickle_file = 'ml5_sm_%s.pkl'%proc,
 
439
            filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
440
            chosen_runner = 'ML5_opt')
 
441
        
 
442
#   ('g g > z c c~',{'QED':1,'QCD':2},['QCD'],{'QCD':6,'QED':2})
 
443
    def test_long_sm_vs_stored_ML5_gg_zccx(self):
 
444
        proc = "gg_zccx"
 
445
        self.compare_processes([ML5_processes_long_dic[proc]],
 
446
               model = self.test_model_name_c_massive,
 
447
               pickle_file = 'ml5_sm_%s.pkl'%proc,
 
448
               filename = 'ptest_long_sm_vs_old_ml5_%s'%proc,
 
449
               chosen_runner = 'ML5_opt')
 
450
 
 
451