1
=== modified file 'UpdateNotes.txt'
2
--- UpdateNotes.txt	2016-02-23 22:55:27 +0000
3
+++ UpdateNotes.txt	2016-02-24 13:54:50 +0000
4
@@ -1,6 +1,12 @@
5
1
Update notes for MadGraph5_aMC@NLO (in reverse time order)
1
Update notes for MadGraph5_aMC@NLO (in reverse time order)
6
2
2
7
3
2.4.0(XX/XX/XX)
3
2.4.0(XX/XX/XX)
8
4
        MZ: new NLO generation mode. It is more efficient from the memory and CPU point of 
9
5
            view, in particular for high-multiplicity processes. 
10
6
            Many thanks to Josh Bendavid for his fundamental contribution for this.
11
7
            The mode can be enabled with
12
8
            > set low_mem_multicore_nlo_generation True
13
9
            before generating the process.
14
4
        VH: Interfaced MadLoop to Samurai and Ninja (the latter is now the default)
10
        VH: Interfaced MadLoop to Samurai and Ninja (the latter is now the default)
15
5
        OM: Adding the possibility to use new syntax for tree-level processes:
11
        OM: Adding the possibility to use new syntax for tree-level processes:
16
6
            QED==2 and QCD>2: The first allows to select exactly a power of the coupling (at amplitude level
12
            QED==2 and QCD>2: The first allows to select exactly a power of the coupling (at amplitude level
17
7
13
18
=== modified file 'madgraph/fks/fks_base.py'
19
--- madgraph/fks/fks_base.py	2015-10-20 10:56:04 +0000
20
+++ madgraph/fks/fks_base.py	2016-02-24 13:54:50 +0000
21
@@ -44,15 +44,18 @@
22
44
    def default_setup(self):
44
    def default_setup(self):
23
45
        """Default values for all properties"""
45
        """Default values for all properties"""
24
46
        super(FKSMultiProcess, self).default_setup()
46
        super(FKSMultiProcess, self).default_setup()
25
47
        self['real_amplitudes'] = diagram_generation.AmplitudeList()
26
48
        self['pdgs'] = []
27
47
        self['born_processes'] = FKSProcessList()
49
        self['born_processes'] = FKSProcessList()
28
48
        if not 'OLP' in self.keys():
50
        if not 'OLP' in self.keys():
29
49
            self['OLP'] = 'MadLoop'
51
            self['OLP'] = 'MadLoop'
30
52
            self['ncores_for_proc_gen'] = 0
31
50
    
53
    
32
51
    def get_sorted_keys(self):
54
    def get_sorted_keys(self):
33
52
        """Return particle property names as a nicely sorted list."""
55
        """Return particle property names as a nicely sorted list."""
34
53
        keys = super(FKSMultiProcess, self).get_sorted_keys()
56
        keys = super(FKSMultiProcess, self).get_sorted_keys()
35
54
        keys += ['born_processes', 'real_amplitudes', 'real_pdgs', 'has_isr', 
57
        keys += ['born_processes', 'real_amplitudes', 'real_pdgs', 'has_isr', 
37
55
                 'has_fsr', 'OLP']
58
                 'has_fsr', 'OLP', 'ncores_for_proc_gen']
38
56
        return keys
59
        return keys
39
57
60
40
58
    def filter(self, name, value):
61
    def filter(self, name, value):
41
@@ -77,10 +80,15 @@
42
77
            if not isinstance(value,str):
80
            if not isinstance(value,str):
43
78
                raise self.PhysicsObjectError, \
81
                raise self.PhysicsObjectError, \
44
79
                    "%s is not a valid string for OLP " % str(value)
82
                    "%s is not a valid string for OLP " % str(value)
45
83
46
84
        if name == 'ncores_for_proc_gen':
47
85
            if not isinstance(value,int):
48
86
                raise self.PhysicsObjectError, \
49
87
                    "%s is not a valid value for ncores_for_proc_gen " % str(value)
50
80
                                                     
88
                                                     
51
81
        return super(FKSMultiProcess,self).filter(name, value)
89
        return super(FKSMultiProcess,self).filter(name, value)
52
82
    
90
    
54
83
    def __init__(self, *arguments, **options):
91
    def __init__(self, procdef=None, options={}):
55
84
        """Initializes the original multiprocess, then generates the amps for the 
92
        """Initializes the original multiprocess, then generates the amps for the 
56
85
        borns, then generate the born processes and the reals.
93
        borns, then generate the born processes and the reals.
57
86
        Real amplitudes are stored in real_amplitudes according on the pdgs of their
94
        Real amplitudes are stored in real_amplitudes according on the pdgs of their
58
@@ -94,17 +102,25 @@
59
94
        for logg in loggers_off:
102
        for logg in loggers_off:
60
95
            logg.setLevel(logging.WARNING)
103
            logg.setLevel(logging.WARNING)
61
96
        
104
        
65
97
        self['real_amplitudes'] = diagram_generation.AmplitudeList()
105
        # OLP option
66
98
        self['pdgs'] = []
106
        olp='MadLoop'
64
99
        
67
100
        if 'OLP' in options.keys():
107
        if 'OLP' in options.keys():
69
101
            self['OLP']=options['OLP']
108
            olp = options['OLP']
70
102
            del options['OLP']
109
            del options['OLP']
71
103
110
72
111
        ncores_for_proc_gen = 0
73
112
        # ncores_for_proc_gen has the following meaning
74
113
        #   0 : do things the old way
75
114
        #   > 0 use ncores_for_proc_gen
76
115
        #   -1 : use all cores
77
116
        if 'ncores_for_proc_gen' in options.keys():
78
117
            ncores_for_proc_gen = options['ncores_for_proc_gen']
79
118
            del options['ncores_for_proc_gen']
80
104
119
81
105
        try:
120
        try:
82
106
            # Now generating the borns for the first time.
121
            # Now generating the borns for the first time.
84
107
            super(FKSMultiProcess, self).__init__(*arguments,**options)
122
            super(FKSMultiProcess, self).__init__(procdef, **options)
85
123
86
108
        except diagram_generation.NoDiagramException as error:
124
        except diagram_generation.NoDiagramException as error:
87
109
            # If no born, then this process most likely does not have any.
125
            # If no born, then this process most likely does not have any.
88
110
            raise NoBornException, "Born diagrams could not be generated for the "+\
126
            raise NoBornException, "Born diagrams could not be generated for the "+\
89
@@ -113,17 +129,9 @@
90
113
               " processes yet, but you can still use MadLoop if you want to "+\
129
               " processes yet, but you can still use MadLoop if you want to "+\
91
114
               "only generate them."+\
130
               "only generate them."+\
92
115
               " For this, use the 'virt=' mode, without multiparticle labels."
131
               " For this, use the 'virt=' mode, without multiparticle labels."
104
116
        
132
105
117
        #check limitation of FKS
133
        self['OLP'] = olp
106
118
        if arguments and isinstance(arguments, MG.Process):
134
        self['ncores_for_proc_gen'] = ncores_for_proc_gen
96
119
            myprocdef = arguments[0]
97
120
            misc.sprint( myprocdef.keys())
98
121
            if myprocdef['perturbation_couplings']!=['QCD']:
99
122
                raise InvalidCmd("FKS for reals only available in QCD for now, you asked %s" \
100
123
                            % ', '.join(myprocdef['perturbation_couplings']))
101
124
            elif myprocdef.get_ninitial()==1:
102
125
                raise InvalidCmd("At this stage aMC@NLO cannot handle decay process.\n"+\
103
126
                 "   Only Leading Order (loop-induced and tree level) decay are supported.") 
107
127
            
135
            
108
128
        #check process definition(s):
136
        #check process definition(s):
109
129
        # a process such as g g > g g will lead to real emissions 
137
        # a process such as g g > g g will lead to real emissions 
110
@@ -164,58 +172,63 @@
111
164
                                                                 'Process', ''),
172
                                                                 'Process', ''),
112
165
                 i + 1, len(amps)))
173
                 i + 1, len(amps)))
113
166
174
115
167
            born = FKSProcess(amp)
175
            born = FKSProcess(amp, ncores_for_proc_gen = self['ncores_for_proc_gen'])
116
168
            self['born_processes'].append(born)
176
            self['born_processes'].append(born)
117
169
            born.generate_reals(self['pdgs'], self['real_amplitudes'])
177
            born.generate_reals(self['pdgs'], self['real_amplitudes'])
118
170
178
155
171
        born_pdg_list = [[l['id'] for l in born.born_proc['legs']] \
179
        if not self['ncores_for_proc_gen']:
156
172
                for born in self['born_processes'] ]
180
            # old generation mode 
157
173
181
158
174
        for born in self['born_processes']:
182
            born_pdg_list = [[l['id'] for l in born.born_proc['legs']] \
159
175
            for real in born.real_amps:
183
                    for born in self['born_processes'] ]
160
176
                real.find_fks_j_from_i(born_pdg_list)
184
161
177
185
            for born in self['born_processes']:
162
178
        if amps:
186
                for real in born.real_amps:
163
179
            if self['process_definitions'][0].get('NLO_mode') == 'all':
187
                    real.find_fks_j_from_i(born_pdg_list)
164
180
                self.generate_virtuals()
188
            if amps:
165
181
            
189
                if self['process_definitions'][0].get('NLO_mode') == 'all':
166
182
            elif not self['process_definitions'][0].get('NLO_mode') in ['all', 'real','LOonly']:
190
                    self.generate_virtuals()
167
183
                raise fks_common.FKSProcessError(\
191
                
168
184
                   "Not a valid NLO_mode for a FKSMultiProcess: %s" % \
192
                elif not self['process_definitions'][0].get('NLO_mode') in ['all', 'real','LOonly']:
169
185
                   self['process_definitions'][0].get('NLO_mode'))
193
                    raise fks_common.FKSProcessError(\
170
186
194
                       "Not a valid NLO_mode for a FKSMultiProcess: %s" % \
171
187
            # now get the total number of diagrams
195
                       self['process_definitions'][0].get('NLO_mode'))
172
188
            n_diag_born = sum([len(amp.get('diagrams')) 
196
173
189
                     for amp in self.get_born_amplitudes()])
197
                # now get the total number of diagrams
174
190
            n_diag_real = sum([len(amp.get('diagrams')) 
198
                n_diag_born = sum([len(amp.get('diagrams')) 
175
191
                     for amp in self.get_real_amplitudes()])
199
                         for amp in self.get_born_amplitudes()])
176
192
            n_diag_virt = sum([len(amp.get('loop_diagrams')) 
200
                n_diag_real = sum([len(amp.get('diagrams')) 
177
193
                     for amp in self.get_virt_amplitudes()])
201
                         for amp in self.get_real_amplitudes()])
178
194
202
                n_diag_virt = sum([len(amp.get('loop_diagrams')) 
179
195
            if n_diag_virt == 0 and n_diag_real ==0 and \
203
                         for amp in self.get_virt_amplitudes()])
180
196
                    not self['process_definitions'][0].get('NLO_mode') == 'LOonly':
204
181
197
                raise fks_common.FKSProcessError(
205
                if n_diag_virt == 0 and n_diag_real ==0 and \
182
198
                        'This process does not have any correction up to NLO in %s'\
206
                        not self['process_definitions'][0].get('NLO_mode') == 'LOonly':
183
199
                        %','.join(perturbation))
207
                    raise fks_common.FKSProcessError(
184
200
208
                            'This process does not have any correction up to NLO in %s'\
185
201
            logger.info(('Generated %d subprocesses with %d real emission diagrams, ' + \
209
                            %','.join(perturbation))
186
202
                        '%d born diagrams and %d virtual diagrams') % \
210
187
203
                                (len(self['born_processes']), n_diag_real, n_diag_born, n_diag_virt))
211
                logger.info(('Generated %d subprocesses with %d real emission diagrams, ' + \
188
204
212
                            '%d born diagrams and %d virtual diagrams') % \
189
205
        for i, logg in enumerate(loggers_off):
213
                                    (len(self['born_processes']), n_diag_real, n_diag_born, n_diag_virt))
190
206
            logg.setLevel(old_levels[i])
214
191
215
            for i, logg in enumerate(loggers_off):
192
216
                logg.setLevel(old_levels[i])
193
207
217
194
208
        self['has_isr'] = any([proc.isr for proc in self['born_processes']])
218
        self['has_isr'] = any([proc.isr for proc in self['born_processes']])
195
209
        self['has_fsr'] = any([proc.fsr for proc in self['born_processes']])
219
        self['has_fsr'] = any([proc.fsr for proc in self['born_processes']])
196
210
220
197
211
    def add(self, other):
221
    def add(self, other):
198
212
        """combines self and other, extending the lists of born/real amplitudes"""
222
        """combines self and other, extending the lists of born/real amplitudes"""
199
223
        self['process_definitions'].extend(other['process_definitions'])
200
224
        self['amplitudes'].extend(other['amplitudes'])
201
213
        self['born_processes'].extend(other['born_processes'])
225
        self['born_processes'].extend(other['born_processes'])
202
214
        self['real_amplitudes'].extend(other['real_amplitudes'])
226
        self['real_amplitudes'].extend(other['real_amplitudes'])
203
215
        self['pdgs'].extend(other['pdgs'])
227
        self['pdgs'].extend(other['pdgs'])
204
216
        self['has_isr'] = self['has_isr'] or other['has_isr']
228
        self['has_isr'] = self['has_isr'] or other['has_isr']
205
217
        self['has_fsr'] = self['has_fsr'] or other['has_fsr']
229
        self['has_fsr'] = self['has_fsr'] or other['has_fsr']
206
218
        self['OLP'] = other['OLP']
230
        self['OLP'] = other['OLP']
207
231
        self['ncores_for_proc_gen'] = other['ncores_for_proc_gen']
208
219
232
209
220
    def get_born_amplitudes(self):
233
    def get_born_amplitudes(self):
210
221
        """return an amplitudelist with the born amplitudes"""
234
        """return an amplitudelist with the born amplitudes"""
211
@@ -394,11 +407,16 @@
212
394
    """The class for a FKS process. Starts from the born process and finds
407
    """The class for a FKS process. Starts from the born process and finds
213
395
    all the possible splittings."""  
408
    all the possible splittings."""  
214
396
    
409
    
216
397
    def __init__(self, start_proc = None, remove_reals = True):
410
    def __init__(self, start_proc = None, remove_reals = True, ncores_for_proc_gen=0):
217
398
        """initialization: starts either from an amplitude or a process,
411
        """initialization: starts either from an amplitude or a process,
218
399
        then init the needed variables.
412
        then init the needed variables.
219
400
        remove_borns tells if the borns not needed for integration will be removed
413
        remove_borns tells if the borns not needed for integration will be removed
221
401
        from the born list (mainly used for testing)"""
414
        from the born list (mainly used for testing)
222
415
        ncores_for_proc_gen has the following meaning
223
416
           0 : do things the old way
224
417
           > 0 use ncores_for_proc_gen
225
418
           -1 : use all cores
226
419
        """
227
402
                
420
                
228
403
        self.splittings = {}
421
        self.splittings = {}
229
404
        self.reals = []
422
        self.reals = []
230
@@ -416,6 +434,7 @@
231
416
        self.nincoming = 0
434
        self.nincoming = 0
232
417
        self.virt_amp = None
435
        self.virt_amp = None
233
418
        self.perturbation = 'QCD'
436
        self.perturbation = 'QCD'
234
437
        self.ncores_for_proc_gen = ncores_for_proc_gen
235
419
438
236
420
        if not remove_reals in [True, False]:
439
        if not remove_reals in [True, False]:
237
421
            raise fks_common.FKSProcessError(\
440
            raise fks_common.FKSProcessError(\
238
@@ -509,7 +528,6 @@
239
509
        self.real_amps = real_amps
528
        self.real_amps = real_amps
240
510
529
241
511
530
242
512
        
243
513
    def generate_reals(self, pdg_list, real_amp_list, combine=True): #test written
531
    def generate_reals(self, pdg_list, real_amp_list, combine=True): #test written
244
514
        """For all the possible splittings, creates an FKSRealProcess.
532
        """For all the possible splittings, creates an FKSRealProcess.
245
515
        It removes double counted configorations from the ones to integrates and
533
        It removes double counted configorations from the ones to integrates and
246
@@ -534,8 +552,9 @@
247
534
        self.find_reals_to_integrate()
552
        self.find_reals_to_integrate()
248
535
        if combine:
553
        if combine:
249
536
            self.combine_real_amplitudes()
554
            self.combine_real_amplitudes()
252
537
        self.generate_real_amplitudes(pdg_list, real_amp_list)
555
        if not self.ncores_for_proc_gen:
253
538
        self.link_born_reals()
556
            self.generate_real_amplitudes(pdg_list, real_amp_list)
254
557
            self.link_born_reals()
255
539
558
256
540
559
257
541
    def link_born_reals(self):
560
    def link_born_reals(self):
258
542
561
259
=== modified file 'madgraph/fks/fks_helas_objects.py'
260
--- madgraph/fks/fks_helas_objects.py	2015-10-01 16:00:08 +0000
261
+++ madgraph/fks/fks_helas_objects.py	2016-02-24 13:54:50 +0000
262
@@ -25,20 +25,183 @@
263
25
import madgraph.fks.fks_base as fks_base
25
import madgraph.fks.fks_base as fks_base
264
26
import madgraph.fks.fks_common as fks_common
26
import madgraph.fks.fks_common as fks_common
265
27
import madgraph.loop.loop_helas_objects as loop_helas_objects
27
import madgraph.loop.loop_helas_objects as loop_helas_objects
266
28
import madgraph.loop.loop_diagram_generation as loop_diagram_generation
267
28
import copy
29
import copy
268
29
import logging
30
import logging
269
30
import array
31
import array
270
32
import multiprocessing
271
33
import signal
272
34
import tempfile
273
35
import cPickle
274
36
import itertools
275
37
import os
276
31
38
277
32
logger = logging.getLogger('madgraph.fks_helas_objects')
39
logger = logging.getLogger('madgraph.fks_helas_objects')
278
33
40
279
34
41
280
42
#functions to be used in the ncores_for_proc_gen mode
281
43
def async_generate_real(args):
282
44
    i = args[0]
283
45
    real_amp = args[1]
284
46
285
47
    #amplitude generation
286
48
    amplitude = real_amp.generate_real_amplitude()
287
49
    helasreal = helas_objects.HelasMatrixElement(amplitude)
288
50
    logger.info('Generating real %s' % \
289
51
            real_amp.process.nice_string(print_weighted=False).replace('Process', 'process'))
290
52
291
53
    # Keep track of already generated color objects, to reuse as
292
54
    # much as possible
293
55
    list_colorize = []
294
56
    list_color_basis = []
295
57
    list_color_matrices = []
296
58
    
297
59
    # Now this keeps track of the color matrices created from the loop-born
298
60
    # color basis. Keys are 2-tuple with the index of the loop and born basis
299
61
    # in the list above and the value is the resulting matrix.
300
62
    dict_loopborn_matrices = {}
301
63
    # The dictionary below is simply a container for convenience to be 
302
64
    # passed to the function process_color.
303
65
    color_information = { 'list_colorize' : list_colorize,
304
66
                          'list_color_basis' : list_color_basis,
305
67
                          'list_color_matrices' : list_color_matrices,
306
68
                          'dict_loopborn_matrices' : dict_loopborn_matrices}
307
69
308
70
    helas_objects.HelasMultiProcess.process_color(helasreal,color_information)
309
71
310
72
    outdata = [amplitude,helasreal]
311
73
312
74
    output = tempfile.NamedTemporaryFile(delete = False)   
313
75
    cPickle.dump(outdata,output,protocol=2)
314
76
    output.close()
315
77
    
316
78
    return [output.name,helasreal.get_num_configs(),helasreal.get_nexternal_ninitial()[0]]
317
79
318
80
319
81
def async_generate_born(args):
320
82
    i = args[0]
321
83
    born = args[1]
322
84
    born_pdg_list = args[2]
323
85
    loop_orders = args[3]
324
86
    pdg_list = args[4]
325
87
    loop_optimized = args[5]
326
88
    OLP = args[6]
327
89
    realmapout = args[7]
328
90
329
91
    logger.info('Generating born %s' % \
330
92
            born.born_proc.nice_string(print_weighted=False).replace('Process', 'process'))
331
93
    
332
94
    #load informations on reals from temp files
333
95
    helasreal_list = []
334
96
    for amp in born.real_amps:
335
97
        idx = pdg_list.index(amp.pdgs)
336
98
        infilename = realmapout[idx]
337
99
        infile = open(infilename,'rb')
338
100
        realdata = cPickle.load(infile)
339
101
        infile.close()
340
102
        amp.amplitude = realdata[0]
341
103
        helasreal_list.append(realdata[1])
342
104
        
343
105
    born.link_born_reals()
344
106
        
345
107
    for amp in born.real_amps:
346
108
        amp.find_fks_j_from_i(born_pdg_list)        
347
109
    
348
110
    # generate the virtuals if needed
349
111
    has_loops = False
350
112
    if born.born_proc.get('NLO_mode') == 'all' and OLP == 'MadLoop':
351
113
        myproc = copy.copy(born.born_proc)
352
114
        # take the orders that are actually used by the matrix element
353
115
        myproc['orders'] = loop_orders
354
116
        myproc['legs'] = fks_common.to_legs(copy.copy(myproc['legs']))
355
117
        myamp = loop_diagram_generation.LoopAmplitude(myproc)
356
118
        if myamp.get('diagrams'):
357
119
            has_loops = True
358
120
            born.virt_amp = myamp
359
121
        
360
122
    helasfull = FKSHelasProcess(born, helasreal_list,
361
123
                                loop_optimized = loop_optimized,
362
124
                                decay_ids=[],
363
125
                                gen_color=False)
364
126
365
127
    processes = helasfull.born_matrix_element.get('processes')
366
128
    
367
129
    metag = helas_objects.IdentifyMETag.create_tag(helasfull.born_matrix_element.get('base_amplitude'))
368
130
    
369
131
    outdata = helasfull
370
132
    
371
133
    output = tempfile.NamedTemporaryFile(delete = False)   
372
134
    cPickle.dump(outdata,output,protocol=2)
373
135
    output.close()
374
136
    
375
137
    return [output.name,metag,has_loops,processes]
376
138
377
139
378
140
def async_finalize_matrix_elements(args):
379
141
380
142
    i = args[0]
381
143
    mefile = args[1]
382
144
    duplist = args[2]
383
145
    
384
146
    infile = open(mefile,'rb')
385
147
    me = cPickle.load(infile)
386
148
    infile.close()    
387
149
388
150
    #set unique id based on position in unique me list
389
151
    me.get('processes')[0].set('uid', i)
390
152
391
153
    # Always create an empty color basis, and the
392
154
    # list of raw colorize objects (before
393
155
    # simplification) associated with amplitude
394
156
    col_basis = color_amp.ColorBasis()
395
157
    new_amp = me.born_matrix_element.get_base_amplitude()
396
158
    me.born_matrix_element.set('base_amplitude', new_amp)
397
159
    colorize_obj = col_basis.create_color_dict_list(new_amp)
398
160
399
161
    col_basis.build()
400
162
    col_matrix = color_amp.ColorMatrix(col_basis)
401
163
402
164
    me.born_matrix_element.set('color_basis',col_basis)
403
165
    me.born_matrix_element.set('color_matrix',col_matrix)
404
166
    
405
167
    for iother,othermefile in enumerate(duplist):
406
168
        infileother = open(othermefile,'rb')
407
169
        otherme = cPickle.load(infileother)
408
170
        infileother.close()
409
171
        me.add_process(otherme)
410
172
        
411
173
    me.set_color_links()    
412
174
        
413
175
    initial_states=[]
414
176
    for fksreal in me.real_processes:
415
177
        # Pick out all initial state particles for the two beams
416
178
            initial_states.append(sorted(list(set((p.get_initial_pdg(1),p.get_initial_pdg(2)) for \
417
179
                                              p in fksreal.matrix_element.get('processes')))))
418
180
    
419
181
    if me.virt_matrix_element:
420
182
        has_virtual = True
421
183
    else:
422
184
        has_virtual = False
423
185
     
424
186
    #data to write to file
425
187
    outdata = me
426
188
427
189
    output = tempfile.NamedTemporaryFile(delete = False)   
428
190
    cPickle.dump(outdata,output,protocol=2)
429
191
    output.close()
430
192
    
431
193
    #data to be returned to parent process (filename plus small objects only)
432
194
    return [output.name,initial_states,me.get_used_lorentz(),me.get_used_couplings(),has_virtual]
433
195
434
196
435
35
class FKSHelasMultiProcess(helas_objects.HelasMultiProcess):
197
class FKSHelasMultiProcess(helas_objects.HelasMultiProcess):
436
36
    """class to generate the helas calls for a FKSMultiProcess"""
198
    """class to generate the helas calls for a FKSMultiProcess"""
437
37
199
438
38
    def get_sorted_keys(self):
200
    def get_sorted_keys(self):
439
39
        """Return particle property names as a nicely sorted list."""
201
        """Return particle property names as a nicely sorted list."""
440
40
        keys = super(FKSHelasMultiProcess, self).get_sorted_keys()
202
        keys = super(FKSHelasMultiProcess, self).get_sorted_keys()
442
41
        keys += ['real_matrix_elements', ['has_isr'], ['has_fsr']]
203
        keys += ['real_matrix_elements', ['has_isr'], ['has_fsr'], 
443
204
                 'used_lorentz', 'used_couplings', 'max_configs', 'max_particles', 'processes']
444
42
        return keys
205
        return keys
445
43
206
446
44
    def filter(self, name, value):
207
    def filter(self, name, value):
447
@@ -61,23 +224,190 @@
448
61
224
449
62
        self.loop_optimized = loop_optimized
225
        self.loop_optimized = loop_optimized
450
63
226
464
64
        # generate the real ME's if they are needed.
227
        self['used_lorentz'] = []
465
65
        # note that it may not be always the case, e.g. it the NLO_mode is LOonly
228
        self['used_couplings'] = []
466
66
        if fksmulti['real_amplitudes']:
229
        self['processes'] = []
467
67
            logger.info('Generating real emission matrix-elements...')
230
468
68
            self['real_matrix_elements'] = self.generate_matrix_elements(
231
        self['max_particles'] = -1
469
69
                    copy.copy(fksmulti['real_amplitudes']), combine_matrix_elements = False)
232
        self['max_configs'] = -1
470
70
        else:
233
471
71
            self['real_matrix_elements'] = helas_objects.HelasMatrixElementList()
234
        if not fksmulti['ncores_for_proc_gen']:
472
72
235
            # generate the real ME's if they are needed.
473
73
        self['matrix_elements'] = self.generate_matrix_elements_fks(
236
            # note that it may not be always the case, e.g. it the NLO_mode is LOonly
474
74
                                fksmulti, 
237
            if fksmulti['real_amplitudes']:
475
75
                                gen_color, decay_ids)
238
                logger.info('Generating real emission matrix-elements...')
476
76
        self['initial_states']=[]
239
                self['real_matrix_elements'] = self.generate_matrix_elements(
477
240
                        copy.copy(fksmulti['real_amplitudes']), combine_matrix_elements = False)
478
241
            else:
479
242
                self['real_matrix_elements'] = helas_objects.HelasMatrixElementList()
480
243
481
244
            self['matrix_elements'] = self.generate_matrix_elements_fks(
482
245
                                    fksmulti, 
483
246
                                    gen_color, decay_ids)
484
247
            self['initial_states']=[]
485
248
            self['has_loops'] = len(self.get_virt_matrix_elements()) > 0 
486
249
487
250
        else: 
488
251
            self['has_loops'] = False
489
252
            #more efficient generation
490
253
            born_procs = fksmulti.get('born_processes')
491
254
            born_pdg_list = [[l['id'] for l in born.born_proc['legs']] \
492
255
            for born in born_procs ]
493
256
            loop_orders = {}
494
257
            for  born in born_procs:
495
258
                for coup, val in fks_common.find_orders(born.born_amp).items():
496
259
                    try:
497
260
                        loop_orders[coup] = max([loop_orders[coup], val])
498
261
                    except KeyError:
499
262
                        loop_orders[coup] = val        
500
263
            pdg_list = []        
501
264
            real_amp_list = []
502
265
            for born in born_procs:
503
266
                for amp in born.real_amps:
504
267
                    if not pdg_list.count(amp.pdgs):
505
268
                        pdg_list.append(amp.pdgs)
506
269
                        real_amp_list.append(amp)
507
270
                        
508
271
            #generating and store in tmp files all output corresponding to each real_amplitude
509
272
            real_out_list = []
510
273
            realmapin = []
511
274
            for i,real_amp in enumerate(real_amp_list):
512
275
                realmapin.append([i,real_amp])
513
276
514
277
            # start the pool instance with a signal instance to catch ctr+c
515
278
            original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
516
279
            if fksmulti['ncores_for_proc_gen'] < 0: # use all cores
517
280
                pool = multiprocessing.Pool(maxtasksperchild=1)
518
281
            else:
519
282
                pool = multiprocessing.Pool(processes=fksmulti['ncores_for_proc_gen'],maxtasksperchild=1)
520
283
            signal.signal(signal.SIGINT, original_sigint_handler)
521
284
522
285
            logger.info('Generating real matrix elements...')
523
286
            try:
524
287
                # the very large timeout passed to get is to be able to catch
525
288
                # KeyboardInterrupts
526
289
                realmapout = pool.map_async(async_generate_real,realmapin).get(9999999)
527
290
            except KeyboardInterrupt:
528
291
                pool.terminate()
529
292
                raise KeyboardInterrupt 
530
293
531
294
            realmapfiles = []
532
295
            for realout in realmapout:
533
296
                realmapfiles.append(realout[0])
534
297
535
298
            logger.info('Generating born and virtual matrix elements...')
536
299
            #now loop over born and consume reals, generate virtuals
537
300
            bornmapin = []
538
301
            OLP=fksmulti['OLP']
539
302
            for i,born in enumerate(born_procs):
540
303
                bornmapin.append([i,born,born_pdg_list,loop_orders,pdg_list,loop_optimized,OLP,realmapfiles])
541
304
542
305
            try:
543
306
                bornmapout = pool.map_async(async_generate_born,bornmapin).get(9999999)
544
307
            except KeyboardInterrupt:
545
308
                pool.terminate()
546
309
                raise KeyboardInterrupt 
547
310
548
311
            #remove real temp files
549
312
            for realtmp in realmapout:
550
313
                os.remove(realtmp[0])
551
314
                
552
315
            logger.info('Collecting infos and finalizing matrix elements...')
553
316
            unique_me_list = []
554
317
            duplicate_me_lists = []
555
318
            for bornout in bornmapout:
556
319
                mefile = bornout[0]
557
320
                metag = bornout[1]
558
321
                has_loops = bornout[2]
559
322
                self['has_loops'] = self['has_loops'] or has_loops
560
323
                processes = bornout[3]
561
324
                self['processes'].extend(processes)
562
325
                unique = True
563
326
                for ime2,bornout2 in enumerate(unique_me_list):
564
327
                    mefile2 = bornout2[0]
565
328
                    metag2 = bornout2[1]
566
329
                    if metag==metag2:
567
330
                        duplicate_me_lists[ime2].append(mefile)
568
331
                        unique = False
569
332
                        break;
570
333
                if unique:
571
334
                    unique_me_list.append(bornout)
572
335
                    duplicate_me_lists.append([])
573
336
            
574
337
            memapin = []
575
338
            for i,bornout in enumerate(unique_me_list):
576
339
                mefile = bornout[0]
577
340
                memapin.append([i,mefile, duplicate_me_lists[i]])
578
341
579
342
            try:
580
343
                memapout = pool.map_async(async_finalize_matrix_elements,memapin).get(9999999)
581
344
            except KeyboardInterrupt:
582
345
                pool.terminate()
583
346
                raise KeyboardInterrupt 
584
347
585
348
            #remove born+virtual temp files
586
349
            for bornout in bornmapout:
587
350
                mefile = bornout[0]
588
351
                os.remove(mefile)
589
352
590
353
            pool.close()
591
354
            pool.join()
592
355
593
356
            #set final list of matrix elements (paths to temp files)
594
357
            matrix_elements = []
595
358
            for meout in memapout:
596
359
                matrix_elements.append(meout[0])
597
360
  
598
361
            self['matrix_elements']=matrix_elements
599
362
  
600
363
            #cache information needed for output which will not be available from
601
364
            #the matrix elements later
602
365
            initial_states = []
603
366
            for meout in memapout:
604
367
                me_initial_states = meout[1]
605
368
                for state in me_initial_states:
606
369
                    initial_states.append(state)
607
370
                              
608
371
            # remove doubles from the list
609
372
            checked = []
610
373
            for e in initial_states:
611
374
                if e not in checked:
612
375
                    checked.append(e)
613
376
            initial_states=checked
614
377
615
378
            self['initial_states']=initial_states
616
379
            
617
380
            helas_list = []
618
381
            for meout in memapout:
619
382
                helas_list.extend(meout[2])
620
383
            self['used_lorentz']=list(set(helas_list))        
621
384
            
622
385
            coupling_list = []
623
386
            for meout in memapout:
624
387
                coupling_list.extend([c for l in meout[3] for c in l])
625
388
            self['used_couplings'] = list(set(coupling_list)) 
626
389
            
627
390
            has_virtuals = False
628
391
            for meout in memapout:
629
392
                if meout[4]:
630
393
                    has_virtuals = True
631
394
                    break
632
395
            self['has_virtuals'] = has_virtuals
633
396
            
634
397
            configs_list = []
635
398
            for meout in realmapout:
636
399
                configs_list.append(meout[1])
637
400
            self['max_configs'] = max(configs_list)
638
401
            
639
402
            nparticles_list = []
640
403
            for meout in realmapout:
641
404
                nparticles_list.append(meout[2])
642
405
            self['max_particles'] = max(nparticles_list)        
643
77
406
644
78
        self['has_isr'] = fksmulti['has_isr']
407
        self['has_isr'] = fksmulti['has_isr']
645
79
        self['has_fsr'] = fksmulti['has_fsr']
408
        self['has_fsr'] = fksmulti['has_fsr']
647
80
        self['has_loops'] = len(self.get_virt_matrix_elements()) > 0 
409
648
410
        logger.info('... Done')
649
81
411
650
82
        for i, logg in enumerate(loggers_off):
412
        for i, logg in enumerate(loggers_off):
651
83
            logg.setLevel(old_levels[i])
413
            logg.setLevel(old_levels[i])
652
@@ -85,19 +415,66 @@
653
85
    def get_used_lorentz(self):
415
    def get_used_lorentz(self):
654
86
        """Return a list of (lorentz_name, conjugate, outgoing) with
416
        """Return a list of (lorentz_name, conjugate, outgoing) with
655
87
        all lorentz structures used by this HelasMultiProcess."""
417
        all lorentz structures used by this HelasMultiProcess."""
660
88
        helas_list = []
418
661
89
        for me in self.get('matrix_elements'):
419
        if not self['used_lorentz']:
662
90
            helas_list.extend(me.get_used_lorentz())
420
            helas_list = []
663
91
        return list(set(helas_list))
421
            for me in self.get('matrix_elements'):
664
422
                helas_list.extend(me.get_used_lorentz())
665
423
            self['used_lorentz'] = list(set(helas_list))
666
424
667
425
        return self['used_lorentz']
668
426
669
92
427
670
93
    def get_used_couplings(self):
428
    def get_used_couplings(self):
671
94
        """Return a list with all couplings used by this
429
        """Return a list with all couplings used by this
672
95
        HelasMatrixElement."""
430
        HelasMatrixElement."""
677
96
        coupling_list = []
431
678
97
        for me in self.get('matrix_elements'):
432
        if not self['used_couplings']:
679
98
            coupling_list.extend([c for l in me.get_used_couplings() for c in l])
433
            coupling_list = []
680
99
        return list(set(coupling_list))
434
            for me in self.get('matrix_elements'):
681
435
                coupling_list.extend([c for l in me.get_used_couplings() for c in l])
682
436
            self['used_couplings'] = list(set(coupling_list))
683
437
684
438
        return self['used_couplings']
685
439
686
440
687
441
    def get_processes(self):
688
442
        """Return a list with all couplings used by this
689
443
        HelasMatrixElement."""
690
444
691
445
        if not self['processes']:
692
446
            process_list = []
693
447
            for me in self.get('matrix_elements'):
694
448
                process_list.extend(me.born_matrix_element.get('processes'))
695
449
            self['processes'] = process_list
696
450
697
451
        return self['processes']
698
452
699
453
700
454
    def get_max_configs(self):
701
455
        """Return max_configs"""
702
456
703
457
        if self['max_configs'] < 0:
704
458
            try:
705
459
                self['max_configs'] = max([me.get_num_configs() \
706
460
                                  for me in self['real_matrix_elements']])
707
461
            except ValueError:
708
462
                self['max_configs'] = max([me.born_matrix_element.get_num_configs() \
709
463
                                  for me in self['matrix_elements']])
710
464
711
465
        return self['max_configs']
712
466
713
467
714
468
    def get_max_particles(self):
715
469
        """Return max_paricles"""
716
470
717
471
        if self['max_particles'] < 0:
718
472
            self['max_particles'] = max([me.get_nexternal_ninitial()[0] \
719
473
                                for me in self['matrix_elements']])
720
474
721
475
        return self['max_particles']
722
100
    
476
    
723
477
724
101
    def get_matrix_elements(self):
478
    def get_matrix_elements(self):
725
102
        """Extract the list of matrix elements"""
479
        """Extract the list of matrix elements"""
726
103
        return self.get('matrix_elements')        
480
        return self.get('matrix_elements')        
727
@@ -240,17 +617,32 @@
728
240
            self.perturbation = fksproc.perturbation
617
            self.perturbation = fksproc.perturbation
729
241
            real_amps_new = []
618
            real_amps_new = []
730
242
            # combine for example u u~ > t t~ and d d~ > t t~
619
            # combine for example u u~ > t t~ and d d~ > t t~
742
243
            for proc in fksproc.real_amps:
620
            if fksproc.ncores_for_proc_gen:
743
244
                fksreal_me = FKSHelasRealProcess(proc, real_me_list, real_amp_list, **opts)
621
                # new NLO (multicore) generation mode 
744
245
                try:
622
                for real_me, proc in itertools.izip(real_me_list,fksproc.real_amps):
745
246
                    other = self.real_processes[self.real_processes.index(fksreal_me)]
623
                    fksreal_me = FKSHelasRealProcess(proc, real_me, **opts)
746
247
                    other.matrix_element.get('processes').extend(\
624
                    try:
747
248
                            fksreal_me.matrix_element.get('processes') )
625
                        other = self.real_processes[self.real_processes.index(fksreal_me)]
748
249
                except ValueError:
626
                        other.matrix_element.get('processes').extend(\
749
250
                    if fksreal_me.matrix_element.get('processes') and \
627
                                fksreal_me.matrix_element.get('processes') )
750
251
                            fksreal_me.matrix_element.get('diagrams'):
628
                    except ValueError:
751
252
                        self.real_processes.append(fksreal_me)
629
                        if fksreal_me.matrix_element.get('processes') and \
752
253
                        real_amps_new.append(proc)
630
                                fksreal_me.matrix_element.get('diagrams'):
753
631
                            self.real_processes.append(fksreal_me)
754
632
                            real_amps_new.append(proc)
755
633
            else:
756
634
                #old mode
757
635
                for proc in fksproc.real_amps:
758
636
                    fksreal_me = FKSHelasRealProcess(proc, real_me_list, real_amp_list, **opts)
759
637
                    try:
760
638
                        other = self.real_processes[self.real_processes.index(fksreal_me)]
761
639
                        other.matrix_element.get('processes').extend(\
762
640
                                fksreal_me.matrix_element.get('processes') )
763
641
                    except ValueError:
764
642
                        if fksreal_me.matrix_element.get('processes') and \
765
643
                                fksreal_me.matrix_element.get('diagrams'):
766
644
                            self.real_processes.append(fksreal_me)
767
645
                            real_amps_new.append(proc)
768
254
            fksproc.real_amps = real_amps_new
646
            fksproc.real_amps = real_amps_new
769
255
            if fksproc.virt_amp:
647
            if fksproc.virt_amp:
770
256
                self.virt_matrix_element = \
648
                self.virt_matrix_element = \
771
@@ -410,23 +802,35 @@
772
410
            self.fks_infos = fksrealproc.fks_infos
802
            self.fks_infos = fksrealproc.fks_infos
773
411
            self.is_to_integrate = fksrealproc.is_to_integrate
803
            self.is_to_integrate = fksrealproc.is_to_integrate
774
412
804
776
413
            if len(real_me_list) != len(real_amp_list):
805
            # real_me_list is a list in the old NLO generation mode;
777
806
            # in the new one it is a matrix element
778
807
            if type(real_me_list) == list and len(real_me_list) != len(real_amp_list):
779
414
                raise fks_common.FKSProcessError(
808
                raise fks_common.FKSProcessError(
780
415
                        'not same number of amplitudes and matrix elements: %d, %d' % \
809
                        'not same number of amplitudes and matrix elements: %d, %d' % \
781
416
                                (len(real_amp_list), len(real_me_list)))
810
                                (len(real_amp_list), len(real_me_list)))
783
417
            if real_me_list and real_amp_list:
811
            if type(real_me_list) == list and real_me_list and real_amp_list:
784
418
                self.matrix_element = copy.deepcopy(real_me_list[real_amp_list.index(fksrealproc.amplitude)])
812
                self.matrix_element = copy.deepcopy(real_me_list[real_amp_list.index(fksrealproc.amplitude)])
785
419
                self.matrix_element['processes'] = copy.deepcopy(self.matrix_element['processes'])
813
                self.matrix_element['processes'] = copy.deepcopy(self.matrix_element['processes'])
786
814
787
815
            elif type(real_me_list) == helas_objects.HelasMatrixElement: 
788
816
                #new NLO generation mode
789
817
                self.matrix_element = real_me_list
790
818
791
420
            else:
819
            else:
801
421
                logger.info('generating matrix element...')
820
802
422
                self.matrix_element = helas_objects.HelasMatrixElement(
821
                if real_me_list and real_amp_list:
803
423
                                                  fksrealproc.amplitude, **opts)
822
                    self.matrix_element = copy.deepcopy(real_me_list[real_amp_list.index(fksrealproc.amplitude)])
804
424
                #generate the color for the real
823
                    self.matrix_element['processes'] = copy.deepcopy(self.matrix_element['processes'])
805
425
                self.matrix_element.get('color_basis').build(
824
                else:
806
426
                                    self.matrix_element.get('base_amplitude'))
825
                    logger.info('generating matrix element...')
807
427
                self.matrix_element.set('color_matrix',
826
                    self.matrix_element = helas_objects.HelasMatrixElement(
808
428
                                 color_amp.ColorMatrix(
827
                                                      fksrealproc.amplitude, **opts)
809
429
                                    self.matrix_element.get('color_basis')))
828
                    #generate the color for the real
810
829
                    self.matrix_element.get('color_basis').build(
811
830
                                        self.matrix_element.get('base_amplitude'))
812
831
                    self.matrix_element.set('color_matrix',
813
832
                                     color_amp.ColorMatrix(
814
833
                                        self.matrix_element.get('color_basis')))
815
430
            #self.fks_j_from_i = fksrealproc.find_fks_j_from_i()
834
            #self.fks_j_from_i = fksrealproc.find_fks_j_from_i()
816
431
            self.fks_j_from_i = fksrealproc.fks_j_from_i
835
            self.fks_j_from_i = fksrealproc.fks_j_from_i
817
432
836
818
433
837
819
=== modified file 'madgraph/interface/amcatnlo_interface.py'
820
--- madgraph/interface/amcatnlo_interface.py	2015-10-20 14:39:50 +0000
821
+++ madgraph/interface/amcatnlo_interface.py	2016-02-24 13:54:50 +0000
822
@@ -24,6 +24,13 @@
823
24
import optparse
24
import optparse
824
25
import subprocess
25
import subprocess
825
26
import shutil
26
import shutil
826
27
import multiprocessing
827
28
import signal
828
29
import tempfile
829
30
import itertools
830
31
import os
831
32
import cPickle
832
33
833
27
34
834
28
import madgraph
35
import madgraph
835
29
from madgraph import MG4DIR, MG5DIR, MadGraph5Error
36
from madgraph import MG4DIR, MG5DIR, MadGraph5Error
836
@@ -52,6 +59,37 @@
837
52
logger = logging.getLogger('cmdprint') # -> stdout
59
logger = logging.getLogger('cmdprint') # -> stdout
838
53
logger_stderr = logging.getLogger('fatalerror') # ->stderr
60
logger_stderr = logging.getLogger('fatalerror') # ->stderr
839
54
61
840
62
# a new function for the improved NLO generation
841
63
glob_directories_map = []
842
64
def generate_directories_fks_async(i):
843
65
        
844
66
    arglist = glob_directories_map[i]
845
67
    
846
68
    curr_exporter = arglist[0]
847
69
    mefile = arglist[1]
848
70
    curr_fortran_model = arglist[2]
849
71
    ime = arglist[3]
850
72
    nme = arglist[4]
851
73
    path = arglist[5]
852
74
    olpopts = arglist[6]
853
75
    
854
76
    infile = open(mefile,'rb')
855
77
    me = cPickle.load(infile)
856
78
    infile.close()      
857
79
    
858
80
    calls = curr_exporter.generate_directories_fks(me, curr_fortran_model, ime, nme, path, olpopts)
859
81
    nexternal = curr_exporter.proc_characteristic['nexternal']
860
82
    ninitial = curr_exporter.proc_characteristic['ninitial']
861
83
    processes = me.born_matrix_element.get('processes')
862
84
    
863
85
    #only available after export has been done, so has to be returned from here
864
86
    max_loop_vertex_rank = -99
865
87
    if me.virt_matrix_element:
866
88
        max_loop_vertex_rank = me.virt_matrix_element.get_max_loop_vertex_rank()  
867
89
    
868
90
    return [calls, curr_exporter.fksdirs, max_loop_vertex_rank, ninitial, nexternal, processes]
869
91
870
92
871
55
class CheckFKS(mg_interface.CheckValidForCmd):
93
class CheckFKS(mg_interface.CheckValidForCmd):
872
56
94
873
57
95
874
@@ -431,16 +469,30 @@
875
431
#                
469
#                
876
432
#                raise self.InvalidCmd("FKS for reals only available in QCD for now, you asked %s" \
470
#                raise self.InvalidCmd("FKS for reals only available in QCD for now, you asked %s" \
877
433
#                        % ', '.join(myprocdef['perturbation_couplings']))
471
#                        % ', '.join(myprocdef['perturbation_couplings']))
878
472
        ##
879
473
880
474
        # if the new nlo process generation mode is enabled, the number of cores to be
881
475
        # used has to be passed
882
476
        # ncores_for_proc_gen has the following meaning
883
477
        #   0 : do things the old way
884
478
        #   > 0 use ncores_for_proc_gen
885
479
        #   -1 : use all cores
886
480
        if self.options['low_mem_multicore_nlo_generation']:
887
481
            if self.options['nb_core']:
888
482
                self.ncores_for_proc_gen = int(self.options['nb_core'])
889
483
            else:
890
484
                self.ncores_for_proc_gen = -1
891
485
        else:
892
486
            self.ncores_for_proc_gen = 0
893
487
894
488
        # this is the options dictionary to pass to the FKSMultiProcess
895
489
        fks_options = {'OLP': self.options['OLP'],
896
490
                       'ignore_six_quark_processes': self.options['ignore_six_quark_processes'],
897
491
                       'ncores_for_proc_gen': self.ncores_for_proc_gen}
898
434
        try:
492
        try:
903
435
            self._fks_multi_proc.add(fks_base.FKSMultiProcess(myprocdef,
493
            self._fks_multi_proc.add(fks_base.FKSMultiProcess(myprocdef,fks_options))
900
436
                                   collect_mirror_procs,
901
437
                                   ignore_six_quark_processes,
902
438
                                   OLP=self.options['OLP']))
904
439
        except AttributeError: 
494
        except AttributeError: 
909
440
            self._fks_multi_proc = fks_base.FKSMultiProcess(myprocdef,
495
            self._fks_multi_proc = fks_base.FKSMultiProcess(myprocdef,fks_options)
906
441
                                   collect_mirror_procs,
907
442
                                   ignore_six_quark_processes,
908
443
                                   OLP=self.options['OLP'])
910
444
496
911
445
497
912
446
    def do_output(self, line):
498
    def do_output(self, line):
913
@@ -498,7 +550,7 @@
914
498
        # Generate the virtuals if from OLP
550
        # Generate the virtuals if from OLP
915
499
        if self.options['OLP']!='MadLoop':
551
        if self.options['OLP']!='MadLoop':
916
500
            self._curr_exporter.generate_virtuals_from_OLP(
552
            self._curr_exporter.generate_virtuals_from_OLP(
918
501
              self._curr_matrix_elements,self._export_dir,self.options['OLP'])
553
              self.born_processes_for_olp,self._export_dir,self.options['OLP'])
919
502
                
554
                
920
503
        # Remember that we have done export
555
        # Remember that we have done export
921
504
        self._done_export = (self._export_dir, self._export_format)
556
        self._done_export = (self._export_dir, self._export_format)
922
@@ -531,41 +583,50 @@
923
531
                                self._fks_multi_proc, 
583
                                self._fks_multi_proc, 
924
532
                                loop_optimized= self.options['loop_optimized_output'])
584
                                loop_optimized= self.options['loop_optimized_output'])
925
533
                    
585
                    
945
534
                    ndiags = sum([len(me.get('diagrams')) for \
586
                    if not self.options['low_mem_multicore_nlo_generation']: 
946
535
                                  me in self._curr_matrix_elements.\
587
                        # generate the code the old way
947
536
                                  get_matrix_elements()])
588
                        ndiags = sum([len(me.get('diagrams')) for \
948
537
                    # assign a unique id number to all process and
589
                                      me in self._curr_matrix_elements.\
949
538
                    # generate a list of possible PDF combinations
590
                                      get_matrix_elements()])
950
539
                    uid = 0 
591
                        # assign a unique id number to all process and
951
540
                    initial_states=[]
592
                        # generate a list of possible PDF combinations
952
541
                    for me in self._curr_matrix_elements.get_matrix_elements():
593
                        uid = 0 
953
542
                        uid += 1 # update the identification number
594
                        initial_states=[]
954
543
                        me.get('processes')[0].set('uid', uid)
595
                        for me in self._curr_matrix_elements.get_matrix_elements():
955
544
                        try:
596
                            uid += 1 # update the identification number
956
545
                            initial_states.append(sorted(list(set((p.get_initial_pdg(1),p.get_initial_pdg(2)) for \
597
                            me.get('processes')[0].set('uid', uid)
938
546
                                                                  p in me.born_matrix_element.get('processes')))))
939
547
                        except IndexError:
940
548
                            initial_states.append(sorted(list(set((p.get_initial_pdg(1)) for \
941
549
                                                                  p in me.born_matrix_element.get('processes')))))
942
550
                    
943
551
                        for fksreal in me.real_processes:
944
552
                        # Pick out all initial state particles for the two beams
957
553
                            try:
598
                            try:
958
554
                                initial_states.append(sorted(list(set((p.get_initial_pdg(1),p.get_initial_pdg(2)) for \
599
                                initial_states.append(sorted(list(set((p.get_initial_pdg(1),p.get_initial_pdg(2)) for \
960
555
                                                             p in fksreal.matrix_element.get('processes')))))
600
                                                                      p in me.born_matrix_element.get('processes')))))
961
556
                            except IndexError:
601
                            except IndexError:
962
557
                                initial_states.append(sorted(list(set((p.get_initial_pdg(1)) for \
602
                                initial_states.append(sorted(list(set((p.get_initial_pdg(1)) for \
965
558
                                                             p in fksreal.matrix_element.get('processes')))))
603
                                                                      p in me.born_matrix_element.get('processes')))))
964
559
                                
966
560
                        
604
                        
975
561
                    # remove doubles from the list
605
                            for fksreal in me.real_processes:
976
562
                    checked = []
606
                            # Pick out all initial state particles for the two beams
977
563
                    for e in initial_states:
607
                                try:
978
564
                        if e not in checked:
608
                                    initial_states.append(sorted(list(set((p.get_initial_pdg(1),p.get_initial_pdg(2)) for \
979
565
                            checked.append(e)
609
                                                                 p in fksreal.matrix_element.get('processes')))))
980
566
                    initial_states=checked
610
                                except IndexError:
981
567
611
                                    initial_states.append(sorted(list(set((p.get_initial_pdg(1)) for \
982
568
                    self._curr_matrix_elements.set('initial_states',initial_states)
612
                                                                 p in fksreal.matrix_element.get('processes')))))
983
613
                                    
984
614
                            
985
615
                        # remove doubles from the list
986
616
                        checked = []
987
617
                        for e in initial_states:
988
618
                            if e not in checked:
989
619
                                checked.append(e)
990
620
                        initial_states=checked
991
621
992
622
                        self._curr_matrix_elements.set('initial_states',initial_states)
993
623
994
624
                    else:
995
625
                        #new NLO generation
996
626
                        if self._curr_matrix_elements['has_loops']:
997
627
                            self._curr_exporter.opt['mp'] = True
998
628
                        self._curr_exporter.model = self._curr_model
999
629
                        ndiags = 0
1000
569
630
1001
570
            cpu_time2 = time.time()
631
            cpu_time2 = time.time()
1002
571
            return ndiags, cpu_time2 - cpu_time1
632
            return ndiags, cpu_time2 - cpu_time1
1003
@@ -586,23 +647,84 @@
1004
586
            for charac in ['has_isr', 'has_fsr', 'has_loops']:
647
            for charac in ['has_isr', 'has_fsr', 'has_loops']:
1005
587
                proc_charac[charac] = self._curr_matrix_elements[charac]
648
                proc_charac[charac] = self._curr_matrix_elements[charac]
1006
588
649
1007
650
            # prepare for the generation
1008
651
            # glob_directories_map is for the new NLO generation
1009
652
            global glob_directories_map
1010
653
            glob_directories_map = []
1011
589
654
1012
655
            self.born_processes_for_olp = []
1013
590
            for ime, me in \
656
            for ime, me in \
1014
591
                enumerate(self._curr_matrix_elements.get('matrix_elements')):
657
                enumerate(self._curr_matrix_elements.get('matrix_elements')):
1022
592
                #me is a FKSHelasProcessFromReals
658
                if not self.options['low_mem_multicore_nlo_generation']:
1023
593
                calls = calls + \
659
                    #me is a FKSHelasProcessFromReals
1024
594
                        self._curr_exporter.generate_directories_fks(me, 
660
                    calls = calls + \
1025
595
                        self._curr_fortran_model, 
661
                            self._curr_exporter.generate_directories_fks(me, 
1026
596
                        ime, len(self._curr_matrix_elements.get('matrix_elements')), 
662
                            self._curr_fortran_model, 
1027
597
                        path,self.options['OLP'])
663
                            ime, len(self._curr_matrix_elements.get('matrix_elements')), 
1028
598
                self._fks_directories.extend(self._curr_exporter.fksdirs)
664
                            path,self.options['OLP'])
1029
665
                    self._fks_directories.extend(self._curr_exporter.fksdirs)
1030
666
                    self.born_processes_for_olp.append(me.born_matrix_element.get('processes')[0])
1031
667
                else:
1032
668
                    glob_directories_map.append(\
1033
669
                            [self._curr_exporter, me, self._curr_fortran_model, 
1034
670
                             ime, len(self._curr_matrix_elements.get('matrix_elements')), 
1035
671
                             path, self.options['OLP']])
1036
672
1037
673
            if self.options['low_mem_multicore_nlo_generation']:
1038
674
                # start the pool instance with a signal instance to catch ctr+c
1039
675
                logger.info('Writing directories...')
1040
676
                original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
1041
677
                if self.ncores_for_proc_gen < 0: # use all cores
1042
678
                    pool = multiprocessing.Pool(maxtasksperchild=1)
1043
679
                else:
1044
680
                    pool = multiprocessing.Pool(processes=self.ncores_for_proc_gen,maxtasksperchild=1)
1045
681
                signal.signal(signal.SIGINT, original_sigint_handler)
1046
682
                try:
1047
683
                    # the very large timeout passed to get is to be able to catch
1048
684
                    # KeyboardInterrupts
1049
685
                    diroutputmap = pool.map_async(generate_directories_fks_async,
1050
686
                                                  range(len(glob_directories_map))).get(9999999)
1051
687
                except KeyboardInterrupt:
1052
688
                    pool.terminate()
1053
689
                    raise KeyboardInterrupt 
1054
690
    
1055
691
                pool.close()
1056
692
                pool.join()
1057
693
                
1058
694
                #clean up tmp files containing final matrix elements
1059
695
                for mefile in self._curr_matrix_elements.get('matrix_elements'):
1060
696
                    os.remove(mefile)
1061
697
1062
698
                for charac in ['nexternal', 'ninitial']:
1063
699
                    proc_charac[charac] = self._curr_exporter.proc_characteristic[charac]
1064
700
                # ninitial and nexternal
1065
701
                proc_charac['nexternal'] = max([diroutput[4] for diroutput in diroutputmap])
1066
702
                ninitial_set = set([diroutput[3] for diroutput in diroutputmap])
1067
703
                if len(ninitial_set) != 1:
1068
704
                    raise MadGraph5Error, ("Invalid ninitial values: %s" % ' ,'.join(list(ninitial_set)))    
1069
705
                proc_charac['ninitial'] = list(ninitial_set)[0]
1070
706
1071
707
                self.born_processes = []
1072
708
                self.born_processes_for_olp = []
1073
709
                max_loop_vertex_ranks = []
1074
710
                
1075
711
                for diroutput in diroutputmap:
1076
712
                    calls = calls + diroutput[0]
1077
713
                    self._fks_directories.extend(diroutput[1])
1078
714
                    max_loop_vertex_ranks.append(diroutput[2])
1079
715
                    self.born_processes.extend(diroutput[5])
1080
716
                    self.born_processes_for_olp.append(diroutput[5][0])
1081
717
1082
718
            else:
1083
719
                max_loop_vertex_ranks = [me.get_max_loop_vertex_rank() for \
1084
720
                                         me in self._curr_matrix_elements.get_virt_matrix_elements()]
1085
721
1086
599
            card_path = os.path.join(path, os.path.pardir, 'SubProcesses', \
722
            card_path = os.path.join(path, os.path.pardir, 'SubProcesses', \
1087
600
                                     'procdef_mg5.dat')
723
                                     'procdef_mg5.dat')
1088
601
            
724
            
1089
602
            if self.options['loop_optimized_output'] and \
725
            if self.options['loop_optimized_output'] and \
1093
603
                    len(self._curr_matrix_elements.get_virt_matrix_elements()) > 0:
726
               len(max_loop_vertex_ranks) > 0:
1094
604
                self._curr_exporter.write_coef_specs_file(\
727
                self._curr_exporter.write_coef_specs_file(max_loop_vertex_ranks)
1092
605
                        self._curr_matrix_elements.get_virt_matrix_elements())
1095
606
            if self._generate_info:
728
            if self._generate_info:
1096
607
                self._curr_exporter.write_procdef_mg5(card_path, #
729
                self._curr_exporter.write_procdef_mg5(card_path, #
1097
608
                                self._curr_model['name'],
730
                                self._curr_model['name'],
1098
609
731
1099
=== modified file 'madgraph/interface/madgraph_interface.py'
1100
--- madgraph/interface/madgraph_interface.py	2016-02-23 22:55:27 +0000
1101
+++ madgraph/interface/madgraph_interface.py	2016-02-24 13:54:50 +0000
1102
@@ -1332,7 +1332,8 @@
1103
1332
1332
1104
1333
        if len(args) == 1 and args[0] in ['complex_mass_scheme',\
1333
        if len(args) == 1 and args[0] in ['complex_mass_scheme',\
1105
1334
                                          'loop_optimized_output',\
1334
                                          'loop_optimized_output',\
1107
1335
                                          'loop_color_flows']:
1335
                                          'loop_color_flows',\
1108
1336
                                          'low_mem_multicore_nlo_generation']:
1109
1336
            args.append('True')
1337
            args.append('True')
1110
1337
1338
1111
1338
        if len(args) > 2 and '=' == args[1]:
1339
        if len(args) > 2 and '=' == args[1]:
1112
@@ -1381,7 +1382,7 @@
1113
1381
            if not args[1].isdigit():
1382
            if not args[1].isdigit():
1114
1382
                raise self.InvalidCmd('%s values should be a integer' % args[0])
1383
                raise self.InvalidCmd('%s values should be a integer' % args[0])
1115
1383
1384
1117
1384
        if args[0] in ['loop_optimized_output', 'loop_color_flows']:
1385
        if args[0] in ['loop_optimized_output', 'loop_color_flows', 'low_mem_multicore_nlo_generation']:
1118
1385
            try:
1386
            try:
1119
1386
                args[1] = banner_module.ConfigFile.format_variable(args[1], bool, args[0])
1387
                args[1] = banner_module.ConfigFile.format_variable(args[1], bool, args[0])
1120
1387
            except Exception:
1388
            except Exception:
1121
@@ -2381,7 +2382,8 @@
1122
2381
2382
1123
2382
        if len(args) == 2:
2383
        if len(args) == 2:
1124
2383
            if args[1] in ['group_subprocesses', 'complex_mass_scheme',\
2384
            if args[1] in ['group_subprocesses', 'complex_mass_scheme',\
1126
2384
                           'loop_optimized_output', 'loop_color_flows']:
2385
                           'loop_optimized_output', 'loop_color_flows',\
1127
2386
                           'low_mem_multicore_nlo_generation']:
1128
2385
                return self.list_completion(text, ['False', 'True', 'default'])
2387
                return self.list_completion(text, ['False', 'True', 'default'])
1129
2386
            elif args[1] in ['ignore_six_quark_processes']:
2388
            elif args[1] in ['ignore_six_quark_processes']:
1130
2387
                return self.list_completion(text, self._multiparticles.keys())
2389
                return self.list_completion(text, self._multiparticles.keys())
1131
@@ -2698,6 +2700,7 @@
1132
2698
2700
1133
2699
    options_madgraph= {'group_subprocesses': 'Auto',
2701
    options_madgraph= {'group_subprocesses': 'Auto',
1134
2700
                          'ignore_six_quark_processes': False,
2702
                          'ignore_six_quark_processes': False,
1135
2703
                          'low_mem_multicore_nlo_generation': False,
1136
2701
                          'complex_mass_scheme': False,
2704
                          'complex_mass_scheme': False,
1137
2702
                          'gauge':'unitary',
2705
                          'gauge':'unitary',
1138
2703
                          'stdout_level':None,
2706
                          'stdout_level':None,
1139
2704
2707
1140
=== modified file 'madgraph/iolibs/export_fks.py'
1141
--- madgraph/iolibs/export_fks.py	2016-02-23 19:44:10 +0000
1142
+++ madgraph/iolibs/export_fks.py	2016-02-24 13:54:50 +0000
1143
@@ -55,6 +55,20 @@
1144
55
_file_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0] + '/'
55
_file_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0] + '/'
1145
56
logger = logging.getLogger('madgraph.export_fks')
56
logger = logging.getLogger('madgraph.export_fks')
1146
57
57
1147
58
1148
59
def make_jpeg_async(args):
1149
60
    Pdir = args[0]
1150
61
    old_pos = args[1]
1151
62
    dir_path = args[2]
1152
63
  
1153
64
    devnull = os.open(os.devnull, os.O_RDWR)
1154
65
  
1155
66
    os.chdir(Pdir)
1156
67
    subprocess.call([os.path.join(old_pos, dir_path, 'bin', 'internal', 'gen_jpeg-pl')],
1157
68
                    stdout = devnull)
1158
69
    os.chdir(os.path.pardir)  
1159
70
1160
71
1161
58
#=================================================================================
72
#=================================================================================
1162
59
# Class for used of the (non-optimized) Loop process
73
# Class for used of the (non-optimized) Loop process
1163
60
#=================================================================================
74
#=================================================================================
1164
@@ -294,12 +308,9 @@
1165
294
    #===========================================================================
308
    #===========================================================================
1166
295
    # write_maxparticles_file
309
    # write_maxparticles_file
1167
296
    #===========================================================================
310
    #===========================================================================
1169
297
    def write_maxparticles_file(self, writer, matrix_elements):
311
    def write_maxparticles_file(self, writer, maxparticles):
1170
298
        """Write the maxparticles.inc file for MadEvent"""
312
        """Write the maxparticles.inc file for MadEvent"""
1171
299
313
1172
300
        maxparticles = max([me.get_nexternal_ninitial()[0] \
1173
301
                              for me in matrix_elements['matrix_elements']])
1174
302
1175
303
        lines = "integer max_particles, max_branch\n"
314
        lines = "integer max_particles, max_branch\n"
1176
304
        lines += "parameter (max_particles=%d) \n" % maxparticles
315
        lines += "parameter (max_particles=%d) \n" % maxparticles
1177
305
        lines += "parameter (max_branch=max_particles-1)"
316
        lines += "parameter (max_branch=max_particles-1)"
1178
@@ -313,16 +324,9 @@
1179
313
    #===========================================================================
324
    #===========================================================================
1180
314
    # write_maxconfigs_file
325
    # write_maxconfigs_file
1181
315
    #===========================================================================
326
    #===========================================================================
1183
316
    def write_maxconfigs_file(self, writer, matrix_elements):
327
    def write_maxconfigs_file(self, writer, maxconfigs):
1184
317
        """Write the maxconfigs.inc file for MadEvent"""
328
        """Write the maxconfigs.inc file for MadEvent"""
1185
318
329
1186
319
        try:
1187
320
            maxconfigs = max([me.get_num_configs() \
1188
321
                            for me in matrix_elements['real_matrix_elements']])
1189
322
        except ValueError:
1190
323
            maxconfigs = max([me.born_matrix_element.get_num_configs() \
1191
324
                            for me in matrix_elements['matrix_elements']])
1192
325
1193
326
        lines = "integer lmaxconfigs\n"
330
        lines = "integer lmaxconfigs\n"
1194
327
        lines += "parameter (lmaxconfigs=%d)" % maxconfigs
331
        lines += "parameter (lmaxconfigs=%d)" % maxconfigs
1195
328
332
1196
@@ -455,7 +459,7 @@
1197
455
        # likely also generate it for each subproc.
459
        # likely also generate it for each subproc.
1198
456
        if OLP=='NJET':
460
        if OLP=='NJET':
1199
457
            filename = 'OLE_order.lh'
461
            filename = 'OLE_order.lh'
1201
458
            self.write_lh_order(filename, matrix_element, OLP)
462
            self.write_lh_order(filename, [matrix_element.born_matrix_element.get('processes')[0]], OLP)
1202
459
        
463
        
1203
460
        if matrix_element.virt_matrix_element:
464
        if matrix_element.virt_matrix_element:
1204
461
                    calls += self.generate_virt_directory( \
465
                    calls += self.generate_virt_directory( \
1205
@@ -683,14 +687,11 @@
1206
683
    #===========================================================================
687
    #===========================================================================
1207
684
    #  create the run_card 
688
    #  create the run_card 
1208
685
    #===========================================================================
689
    #===========================================================================
1210
686
    def create_run_card(self, matrix_elements, history):
690
    def create_run_card(self, processes, history):
1211
687
        """ """
691
        """ """
1212
688
 
692
 
1213
689
        run_card = banner_mod.RunCardNLO()
693
        run_card = banner_mod.RunCardNLO()
1214
690
        
694
        
1215
691
        processes = [me.get('processes') 
1216
692
                                 for me in matrix_elements['matrix_elements']]
1217
693
        
1218
694
        run_card.create_default_for_process(self.proc_characteristic, 
695
        run_card.create_default_for_process(self.proc_characteristic, 
1219
695
                                            history,
696
                                            history,
1220
696
                                            processes)
697
                                            processes)
1221
@@ -709,7 +710,7 @@
1222
709
        self.proc_characteristic['grouped_matrix'] = False
710
        self.proc_characteristic['grouped_matrix'] = False
1223
710
        self.create_proc_charac()
711
        self.create_proc_charac()
1224
711
712
1226
712
        self.create_run_card(matrix_elements, history)
713
        self.create_run_card(matrix_elements.get_processes(), history)
1227
713
#        modelname = self.model.get('name')
714
#        modelname = self.model.get('name')
1228
714
#        if modelname == 'mssm' or modelname.startswith('mssm-'):
715
#        if modelname == 'mssm' or modelname.startswith('mssm-'):
1229
715
#            param_card = os.path.join(self.dir_path, 'Cards','param_card.dat')
716
#            param_card = os.path.join(self.dir_path, 'Cards','param_card.dat')
1230
@@ -723,14 +724,15 @@
1231
723
        self.write_get_mass_width_file(writers.FortranWriter(filename), makeinc, self.model)
724
        self.write_get_mass_width_file(writers.FortranWriter(filename), makeinc, self.model)
1232
724
725
1233
725
#        # Write maxconfigs.inc based on max of ME's/subprocess groups
726
#        # Write maxconfigs.inc based on max of ME's/subprocess groups
1234
727
1235
726
        filename = os.path.join(self.dir_path,'Source','maxconfigs.inc')
728
        filename = os.path.join(self.dir_path,'Source','maxconfigs.inc')
1236
727
        self.write_maxconfigs_file(writers.FortranWriter(filename),
729
        self.write_maxconfigs_file(writers.FortranWriter(filename),
1238
728
                                   matrix_elements)
730
                                   matrix_elements.get_max_configs())
1239
729
        
731
        
1240
730
#        # Write maxparticles.inc based on max of ME's/subprocess groups
732
#        # Write maxparticles.inc based on max of ME's/subprocess groups
1241
731
        filename = os.path.join(self.dir_path,'Source','maxparticles.inc')
733
        filename = os.path.join(self.dir_path,'Source','maxparticles.inc')
1242
732
        self.write_maxparticles_file(writers.FortranWriter(filename),
734
        self.write_maxparticles_file(writers.FortranWriter(filename),
1244
733
                                     matrix_elements)
735
                                     matrix_elements.get_max_particles())
1245
734
736
1246
735
        # Touch "done" file
737
        # Touch "done" file
1247
736
        os.system('touch %s/done' % os.path.join(self.dir_path,'SubProcesses'))
738
        os.system('touch %s/done' % os.path.join(self.dir_path,'SubProcesses'))
1248
@@ -1341,7 +1343,8 @@
1249
1341
                         matrix_element, i,
1343
                         matrix_element, i,
1250
1342
                         fortran_model)
1344
                         fortran_model)
1251
1343
1345
1253
1344
    def generate_virtuals_from_OLP(self,FKSHMultiproc,export_path, OLP):
1346
1254
1347
    def generate_virtuals_from_OLP(self,process_list,export_path, OLP):
1255
1345
        """Generates the library for computing the loop matrix elements
1348
        """Generates the library for computing the loop matrix elements
1256
1346
        necessary for this process using the OLP specified."""
1349
        necessary for this process using the OLP specified."""
1257
1347
        
1350
        
1258
@@ -1350,7 +1353,7 @@
1259
1350
        if not os.path.exists(virtual_path):
1353
        if not os.path.exists(virtual_path):
1260
1351
            os.makedirs(virtual_path)
1354
            os.makedirs(virtual_path)
1261
1352
        filename = os.path.join(virtual_path,'OLE_order.lh')
1355
        filename = os.path.join(virtual_path,'OLE_order.lh')
1263
1353
        self.write_lh_order(filename, FKSHMultiproc.get('matrix_elements'),OLP)
1356
        self.write_lh_order(filename, process_list, OLP)
1264
1354
1357
1265
1355
        fail_msg='Generation of the virtuals with %s failed.\n'%OLP+\
1358
        fail_msg='Generation of the virtuals with %s failed.\n'%OLP+\
1266
1356
            'Please check the virt_generation.log file in %s.'\
1359
            'Please check the virt_generation.log file in %s.'\
1267
@@ -1419,20 +1422,19 @@
1268
1419
        proc_to_label = self.parse_contract_file(
1422
        proc_to_label = self.parse_contract_file(
1269
1420
                                            pjoin(virtual_path,'OLE_order.olc'))
1423
                                            pjoin(virtual_path,'OLE_order.olc'))
1270
1421
1424
1272
1422
        self.write_BinothLHA_inc(FKSHMultiproc,proc_to_label,\
1425
        self.write_BinothLHA_inc(process_list,proc_to_label,\
1273
1423
                                              pjoin(export_path,'SubProcesses'))
1426
                                              pjoin(export_path,'SubProcesses'))
1274
1424
        
1427
        
1275
1425
        # Link the contract file to within the SubProcess directory
1428
        # Link the contract file to within the SubProcess directory
1276
1426
        ln(pjoin(virtual_path,'OLE_order.olc'),pjoin(export_path,'SubProcesses'))
1429
        ln(pjoin(virtual_path,'OLE_order.olc'),pjoin(export_path,'SubProcesses'))
1277
1427
        
1430
        
1279
1428
    def write_BinothLHA_inc(self, FKSHMultiproc, proc_to_label, SubProcPath):
1431
    def write_BinothLHA_inc(self, processes, proc_to_label, SubProcPath):
1280
1429
        """ Write the file Binoth_proc.inc in each SubProcess directory so as 
1432
        """ Write the file Binoth_proc.inc in each SubProcess directory so as 
1281
1430
        to provide the right process_label to use in the OLP call to get the
1433
        to provide the right process_label to use in the OLP call to get the
1282
1431
        loop matrix element evaluation. The proc_to_label is the dictionary of
1434
        loop matrix element evaluation. The proc_to_label is the dictionary of
1283
1432
        the format of the one returned by the function parse_contract_file."""
1435
        the format of the one returned by the function parse_contract_file."""
1284
1433
        
1436
        
1287
1434
        for matrix_element in FKSHMultiproc.get('matrix_elements'):
1437
        for proc in processes:
1286
1435
            proc = matrix_element.get('processes')[0]
1288
1436
            name = "P%s"%proc.shell_string()
1438
            name = "P%s"%proc.shell_string()
1289
1437
            proc_pdgs=(tuple([leg.get('id') for leg in proc.get('legs') if \
1439
            proc_pdgs=(tuple([leg.get('id') for leg in proc.get('legs') if \
1290
1438
                                                         not leg.get('state')]),
1440
                                                         not leg.get('state')]),
1291
@@ -1608,26 +1610,19 @@
1292
1608
    # write_lh_order
1610
    # write_lh_order
1293
1609
    #===============================================================================
1611
    #===============================================================================
1294
1610
    #test written
1612
    #test written
1296
1611
    def write_lh_order(self, filename, matrix_elements, OLP='MadLoop'):
1613
    def write_lh_order(self, filename, process_list, OLP='MadLoop'):
1297
1612
        """Creates the OLE_order.lh file. This function should be edited according
1614
        """Creates the OLE_order.lh file. This function should be edited according
1298
1613
        to the OLP which is used. For now it is generic."""
1615
        to the OLP which is used. For now it is generic."""
1299
1614
        
1616
        
1300
1615
        if isinstance(matrix_elements,fks_helas_objects.FKSHelasProcess):
1301
1616
            fksborns=fks_helas_objects.FKSHelasProcessList([matrix_elements])
1302
1617
        elif isinstance(matrix_elements,fks_helas_objects.FKSHelasProcessList):
1303
1618
            fksborns= matrix_elements
1304
1619
        else:
1305
1620
            raise fks_common.FKSProcessError('Wrong type of argument for '+\
1306
1621
                                  'matrix_elements in function write_lh_order.')
1307
1622
        
1617
        
1309
1623
        if len(fksborns)==0:
1618
        if len(process_list)==0:
1310
1624
            raise fks_common.FKSProcessError('No matrix elements provided to '+\
1619
            raise fks_common.FKSProcessError('No matrix elements provided to '+\
1311
1625
                                                 'the function write_lh_order.')
1620
                                                 'the function write_lh_order.')
1312
1626
            return
1621
            return
1313
1627
        
1622
        
1314
1628
        # We assume the orders to be common to all Subprocesses
1623
        # We assume the orders to be common to all Subprocesses
1315
1629
        
1624
        
1317
1630
        orders = fksborns[0].orders 
1625
        orders = process_list[0].get('orders') 
1318
1631
        if 'QED' in orders.keys() and 'QCD' in orders.keys():
1626
        if 'QED' in orders.keys() and 'QCD' in orders.keys():
1319
1632
            QED=orders['QED']
1627
            QED=orders['QED']
1320
1633
            QCD=orders['QCD']
1628
            QCD=orders['QCD']
1321
@@ -1639,12 +1634,12 @@
1322
1639
            QCD=orders['QCD']
1634
            QCD=orders['QCD']
1323
1640
        else:
1635
        else:
1324
1641
            QED, QCD = self.get_qed_qcd_orders_from_weighted(\
1636
            QED, QCD = self.get_qed_qcd_orders_from_weighted(\
1326
1642
                    fksborns[0].get_nexternal_ninitial()[0]-1, # -1 is because the function returns nexternal of the real emission
1637
                    len(process_list[0].get('legs')),
1327
1643
                    orders['WEIGHTED'])
1638
                    orders['WEIGHTED'])
1328
1644
1639
1329
1645
        replace_dict = {}
1640
        replace_dict = {}
1330
1646
        replace_dict['mesq'] = 'CHaveraged'
1641
        replace_dict['mesq'] = 'CHaveraged'
1332
1647
        replace_dict['corr'] = ' '.join(matrix_elements[0].get('processes')[0].\
1642
        replace_dict['corr'] = ' '.join(process_list[0].\
1333
1648
                                                  get('perturbation_couplings'))
1643
                                                  get('perturbation_couplings'))
1334
1649
        replace_dict['irreg'] = 'CDR'
1644
        replace_dict['irreg'] = 'CDR'
1335
1650
        replace_dict['aspow'] = QCD
1645
        replace_dict['aspow'] = QCD
1336
@@ -1652,8 +1647,10 @@
1337
1652
        replace_dict['modelfile'] = './param_card.dat'
1647
        replace_dict['modelfile'] = './param_card.dat'
1338
1653
        replace_dict['params'] = 'alpha_s'
1648
        replace_dict['params'] = 'alpha_s'
1339
1654
        proc_lines=[]
1649
        proc_lines=[]
1342
1655
        for fksborn in fksborns:
1650
        for proc in process_list:
1343
1656
            proc_lines.append(fksborn.get_lh_pdg_string())
1651
            proc_lines.append('%s -> %s' % \
1344
1652
                    (' '.join(str(l['id']) for l in proc['legs'] if not l['state']),
1345
1653
                     ' '.join(str(l['id']) for l in proc['legs'] if l['state'])))
1346
1657
        replace_dict['pdgs'] = '\n'.join(proc_lines)
1654
        replace_dict['pdgs'] = '\n'.join(proc_lines)
1347
1658
        replace_dict['symfin'] = 'Yes'
1655
        replace_dict['symfin'] = 'Yes'
1348
1659
        content = \
1656
        content = \
1349
@@ -3300,7 +3297,7 @@
1350
3300
    #===============================================================================
3297
    #===============================================================================
1351
3301
    # write_coef_specs
3298
    # write_coef_specs
1352
3302
    #===============================================================================
3299
    #===============================================================================
1354
3303
    def write_coef_specs_file(self, virt_me_list):
3300
    def write_coef_specs_file(self, max_loop_vertex_ranks):
1355
3304
        """ writes the coef_specs.inc in the DHELAS folder. Should not be called in the 
3301
        """ writes the coef_specs.inc in the DHELAS folder. Should not be called in the 
1356
3305
        non-optimized mode"""
3302
        non-optimized mode"""
1357
3306
        filename = os.path.join(self.dir_path, 'Source', 'DHELAS', 'coef_specs.inc')
3303
        filename = os.path.join(self.dir_path, 'Source', 'DHELAS', 'coef_specs.inc')
1358
@@ -3308,7 +3305,6 @@
1359
3308
        replace_dict = {}
3305
        replace_dict = {}
1360
3309
        replace_dict['max_lwf_size'] = 4 
3306
        replace_dict['max_lwf_size'] = 4 
1361
3310
3307
1362
3311
        max_loop_vertex_ranks = [me.get_max_loop_vertex_rank() for me in virt_me_list]
1363
3312
        replace_dict['vertex_max_coefs'] = max(\
3308
        replace_dict['vertex_max_coefs'] = max(\
1364
3313
                [q_polynomial.get_number_of_coefs_for_rank(n) 
3309
                [q_polynomial.get_number_of_coefs_for_rank(n) 
1365
3314
                    for n in max_loop_vertex_ranks])
3310
                    for n in max_loop_vertex_ranks])
1366
3315
3311
1367
=== modified file 'madgraph/iolibs/template_files/loop_optimized/compute_color_flows.inc'
1368
--- madgraph/iolibs/template_files/loop_optimized/compute_color_flows.inc	2015-07-03 00:47:03 +0000
1369
+++ madgraph/iolibs/template_files/loop_optimized/compute_color_flows.inc	2016-02-24 13:54:50 +0000
1370
@@ -357,7 +357,7 @@
1371
357
C  
357
C  
1372
358
C LOCAL VARIABLES 
358
C LOCAL VARIABLES 
1373
359
C
359
C
1375
360
	  INTEGER I, J, M, N, K, SQSOINDEX, DOUBLEFACT
360
	  INTEGER I, J, M, N, K, ISQSO, DOUBLEFACT
1376
361
	  %(complex_dp_format)s COLOR_COEF
361
	  %(complex_dp_format)s COLOR_COEF
1377
362
C  
362
C  
1378
363
C FUNCTIONS
363
C FUNCTIONS
1379
@@ -401,8 +401,8 @@
1380
401
  IF (LoopColorFlowMatrix(I,I)%%Denom.LT.0) COLOR_COEF=COLOR_COEF*IMAG1
401
  IF (LoopColorFlowMatrix(I,I)%%Denom.LT.0) COLOR_COEF=COLOR_COEF*IMAG1
1381
402
  DO M=1,NLOOPAMPSO
402
  DO M=1,NLOOPAMPSO
1382
403
    DO N=M,NLOOPAMPSO
403
    DO N=M,NLOOPAMPSO
1385
404
      SQSOINDEX = %(proc_prefix)sML5SQSOINDEX(M,N)
404
      ISQSO = %(proc_prefix)sML5SQSOINDEX(M,N)
1386
405
      IF(CHOSEN_SO_CONFIGS(SQSOINDEX)) THEN
405
      IF(CHOSEN_SO_CONFIGS(ISQSO)) THEN
1387
406
        IF(M.ne.N) THEN
406
        IF(M.ne.N) THEN
1388
407
          DOUBLEFACT=2 
407
          DOUBLEFACT=2 
1389
408
        ELSE 
408
        ELSE 
1390
@@ -452,7 +452,7 @@
1391
452
C  
452
C  
1392
453
C LOCAL VARIABLES 
453
C LOCAL VARIABLES 
1393
454
C
454
C
1395
455
	  INTEGER I, J, M, N, K, SQSOINDEX, DOUBLEFACT
455
	  INTEGER I, J, M, N, K, ISQSO, DOUBLEFACT
1396
456
## if(LoopInduced) {
456
## if(LoopInduced) {
1397
457
	  INTEGER LOWERBOUND
457
	  INTEGER LOWERBOUND
1398
458
## }
458
## }
1399
@@ -550,15 +550,15 @@
1400
550
      	CALL %(proc_prefix)sML5GET_ORDERS_FOR_AMPSOINDEX(M,ORDERS_A)
550
      	CALL %(proc_prefix)sML5GET_ORDERS_FOR_AMPSOINDEX(M,ORDERS_A)
1401
551
      	CALL %(proc_prefix)sML5GET_ORDERS_FOR_AMPSOINDEX(N,ORDERS_B)
551
      	CALL %(proc_prefix)sML5GET_ORDERS_FOR_AMPSOINDEX(N,ORDERS_B)
1402
552
C Now figure out to which SQSOINDEX these orders together correspond to *in the Born subroutine* (Notice the absence of the ML5 prefix in the functions used then)
552
C Now figure out to which SQSOINDEX these orders together correspond to *in the Born subroutine* (Notice the absence of the ML5 prefix in the functions used then)
1404
553
        SQSOINDEX = %(proc_prefix)sSQSOINDEX(%(proc_prefix)sSOINDEX_FOR_AMPORDERS(ORDERS_A),%(proc_prefix)sSOINDEX_FOR_AMPORDERS(ORDERS_B))
553
        ISQSO = %(proc_prefix)sSQSOINDEX(%(proc_prefix)sSOINDEX_FOR_AMPORDERS(ORDERS_A),%(proc_prefix)sSOINDEX_FOR_AMPORDERS(ORDERS_B))
1405
554
        IF(J.ne.I) THEN
554
        IF(J.ne.I) THEN
1406
555
          DOUBLEFACT=2 
555
          DOUBLEFACT=2 
1407
556
        ELSE 
556
        ELSE 
1408
557
          DOUBLEFACT=1
557
          DOUBLEFACT=1
1409
558
        ENDIF
558
        ENDIF
1410
559
        TEMP(1) = DOUBLEFACT*HEL_MULT*DBLE(COLOR_COEF*JAMPB(I,M)*DCONJG(JAMPB(J,N)))
559
        TEMP(1) = DOUBLEFACT*HEL_MULT*DBLE(COLOR_COEF*JAMPB(I,M)*DCONJG(JAMPB(J,N)))
1413
560
        RES(0,SQSOINDEX) = RES(0,SQSOINDEX) + TEMP(1)
560
        RES(0,ISQSO) = RES(0,ISQSO) + TEMP(1)
1414
561
        IF((.not.FILTER_SO).or.SQSO_TARGET.eq.-1.or.SQSO_TARGET.eq.SQSOINDEX) THEN
561
        IF((.not.FILTER_SO).or.SQSO_TARGET.eq.-1.or.SQSO_TARGET.eq.ISQSO) THEN
1415
562
          RES(0,0) = RES(0,0) + TEMP(1)
562
          RES(0,0) = RES(0,0) + TEMP(1)
1416
563
        ENDIF
563
        ENDIF
1417
564
      ENDDO
564
      ENDDO
1418
@@ -591,7 +591,7 @@
1419
591
	  ENDIF
591
	  ENDIF
1420
592
      DO N=LOWERBOUND,NLOOPAMPSO
592
      DO N=LOWERBOUND,NLOOPAMPSO
1421
593
## }
593
## }
1423
594
        SQSOINDEX = %(proc_prefix)sML5SQSOINDEX(M,N)
594
        ISQSO = %(proc_prefix)sML5SQSOINDEX(M,N)
1424
595
## if(LoopInduced){
595
## if(LoopInduced){
1425
596
        IF(J.ne.I) THEN
596
        IF(J.ne.I) THEN
1426
597
          DOUBLEFACT=2 
597
          DOUBLEFACT=2 
1427
@@ -626,14 +626,14 @@
1428
626
## if(not LoopInduced){      
626
## if(not LoopInduced){      
1429
627
          TEMP(K) = 2.0d0*HEL_MULT*DBLE(COLOR_COEF*JAMPL(K,I,M)*DCONJG(JAMPB(J,N)))
627
          TEMP(K) = 2.0d0*HEL_MULT*DBLE(COLOR_COEF*JAMPL(K,I,M)*DCONJG(JAMPB(J,N)))
1430
628
## }
628
## }
1432
629
          RES(K,SQSOINDEX) = RES(K,SQSOINDEX) + TEMP(K)
629
          RES(K,ISQSO) = RES(K,ISQSO) + TEMP(K)
1433
630
## if(LoopInduced and MadEventOutput){
630
## if(LoopInduced and MadEventOutput){
1434
631
		  DO config_i=1,nconfigs
631
		  DO config_i=1,nconfigs
1436
632
            AMP2_ALL(K,config_i,SQSOINDEX) = AMP2_ALL(K,config_i,SQSOINDEX) + TEMP_AMP2(K,config_i)
632
            AMP2_ALL(K,config_i,ISQSO) = AMP2_ALL(K,config_i,ISQSO) + TEMP_AMP2(K,config_i)
1437
633
		  ENDDO
633
		  ENDDO
1438
634
## }
634
## }
1439
635
        ENDDO
635
        ENDDO
1441
636
        IF((.NOT.FILTER_SO).OR.SQSO_TARGET.eq.-1.or.SQSO_TARGET.eq.SQSOINDEX) THEN
636
        IF((.NOT.FILTER_SO).OR.SQSO_TARGET.eq.-1.or.SQSO_TARGET.eq.ISQSO) THEN
1442
637
          DO K=1,3
637
          DO K=1,3
1443
638
            RES(K,0) = RES(K,0) + TEMP(K)
638
            RES(K,0) = RES(K,0) + TEMP(K)
1444
639
## if(LoopInduced and MadEventOutput){
639
## if(LoopInduced and MadEventOutput){
1445
640
640
1446
=== modified file 'madgraph/loop/loop_exporters.py'
1447
--- madgraph/loop/loop_exporters.py	2016-02-23 22:55:27 +0000
1448
+++ madgraph/loop/loop_exporters.py	2016-02-24 13:54:50 +0000
1449
@@ -45,6 +45,7 @@
1450
45
import madgraph.various.diagram_symmetry as diagram_symmetry
45
import madgraph.various.diagram_symmetry as diagram_symmetry
1451
46
import madgraph.various.process_checks as process_checks
46
import madgraph.various.process_checks as process_checks
1452
47
import madgraph.various.progressbar as pbar
47
import madgraph.various.progressbar as pbar
1453
48
import madgraph.various.q_polynomial as q_polynomial
1454
48
import madgraph.core.color_amp as color_amp
49
import madgraph.core.color_amp as color_amp
1455
49
import madgraph.iolibs.helas_call_writers as helas_call_writers
50
import madgraph.iolibs.helas_call_writers as helas_call_writers
1456
50
import models.check_param_card as check_param_card
51
import models.check_param_card as check_param_card
1457
@@ -2314,7 +2315,7 @@
1458
2314
2315
1459
2315
        writer.writelines(file,context=self.get_context(matrix_element))
2316
        writer.writelines(file,context=self.get_context(matrix_element))
1460
2316
    
2317
    
1462
2317
    def fix_coef_specs(self, overall_max_lwf_size, overall_max_loop_vert_rank):
2318
    def fix_coef_specs(self, overall_max_lwf_spin, overall_max_loop_vert_rank):
1463
2318
        """ If processes with different maximum loop wavefunction size or
2319
        """ If processes with different maximum loop wavefunction size or
1464
2319
        different maximum loop vertex rank have to be output together, then
2320
        different maximum loop vertex rank have to be output together, then
1465
2320
        the file 'coef.inc' in the HELAS Source folder must contain the overall
2321
        the file 'coef.inc' in the HELAS Source folder must contain the overall
1466
@@ -2325,7 +2326,11 @@
1467
2325
        coef_specs_path=os.path.join(self.dir_path,'Source','DHELAS',\
2326
        coef_specs_path=os.path.join(self.dir_path,'Source','DHELAS',\
1468
2326
                                                               'coef_specs.inc')
2327
                                                               'coef_specs.inc')
1469
2327
        os.remove(coef_specs_path)
2328
        os.remove(coef_specs_path)
1471
2328
        
2329
       
1472
2330
        spin_to_wf_size = {1:4,2:4,3:4,4:16,5:16}
1473
2331
        overall_max_lwf_size = spin_to_wf_size[overall_max_lwf_spin]
1474
2332
        overall_max_loop_vert_coefs = q_polynomial.get_number_of_coefs_for_rank(
1475
2333
                                                     overall_max_loop_vert_rank)
1476
2329
        # Replace it by the appropriate value
2334
        # Replace it by the appropriate value
1477
2330
        IncWriter=writers.FortranWriter(coef_specs_path,'w')
2335
        IncWriter=writers.FortranWriter(coef_specs_path,'w')
1478
2331
        IncWriter.writelines("""INTEGER MAXLWFSIZE
2336
        IncWriter.writelines("""INTEGER MAXLWFSIZE
1479
@@ -2333,7 +2338,7 @@
1480
2333
                           INTEGER VERTEXMAXCOEFS
2338
                           INTEGER VERTEXMAXCOEFS
1481
2334
                           PARAMETER (VERTEXMAXCOEFS=%(vertex_max_coefs)d)"""\
2339
                           PARAMETER (VERTEXMAXCOEFS=%(vertex_max_coefs)d)"""\
1482
2335
                           %{'max_lwf_size':overall_max_lwf_size,
2340
                           %{'max_lwf_size':overall_max_lwf_size,
1484
2336
                             'vertex_max_coefs':overall_max_loop_vert_rank})
2341
                             'vertex_max_coefs':overall_max_loop_vert_coefs})
1485
2337
        IncWriter.close()
2342
        IncWriter.close()
1486
2338
2343
1487
2339
    def setup_check_sa_replacement_dictionary(self, matrix_element, \
2344
    def setup_check_sa_replacement_dictionary(self, matrix_element, \
1488
2340
2345
1489
=== modified file 'madgraph/various/banner.py'
1490
--- madgraph/various/banner.py	2016-02-18 11:42:56 +0000
1491
+++ madgraph/various/banner.py	2016-02-24 13:54:50 +0000
1492
@@ -1990,7 +1990,7 @@
1493
1990
        # check for beam_id
1990
        # check for beam_id
1494
1991
        beam_id = set()
1991
        beam_id = set()
1495
1992
        for proc in proc_def:
1992
        for proc in proc_def:
1497
1993
            for leg in proc[0]['legs']:
1993
            for leg in proc['legs']:
1498
1994
                if not leg['state']:
1994
                if not leg['state']:
1499
1995
                    beam_id.add(leg['id'])
1995
                    beam_id.add(leg['id'])
1500
1996
        if any(i in beam_id for i in [1,-1,2,-2,3,-3,4,-4,5,-5,21,22]):
1996
        if any(i in beam_id for i in [1,-1,2,-2,3,-3,4,-4,5,-5,21,22]):
1501
1997
1997
1502
=== added directory 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall'
1503
=== added file 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%CT_interface.f'
1504
--- tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%CT_interface.f	1970-01-01 00:00:00 +0000
1505
+++ tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%CT_interface.f	2016-02-24 13:54:50 +0000
1506
@@ -0,0 +1,278 @@
1507
1
      SUBROUTINE CTLOOP(NLOOPLINE,PL,M2L,RANK,RES,STABLE)
1508
2
C     
1509
3
C     Generated by MadGraph5_aMC@NLO v. %(version)s, %(date)s
1510
4
C     By the MadGraph5_aMC@NLO Development Team
1511
5
C     Visit launchpad.net/madgraph5 and amcatnlo.web.cern.ch
1512
6
C     
1513
7
C     Interface between MG5 and CutTools.
1514
8
C     
1515
9
C     Process: d~ u > w+ WEIGHTED=2 QED=1 [ all = QCD ]
1516
10
C     Process: s~ c > w+ WEIGHTED=2 QED=1 [ all = QCD ]
1517
11
C     
1518
12
C     
1519
13
C     CONSTANTS 
1520
14
C     
1521
15
      INTEGER    NEXTERNAL
1522
16
      PARAMETER (NEXTERNAL=3)
1523
17
      LOGICAL CHECKPCONSERVATION
1524
18
      PARAMETER (CHECKPCONSERVATION=.TRUE.)
1525
19
      REAL*8 NORMALIZATION
1526
20
      PARAMETER (NORMALIZATION = 1.D0/(16.D0*3.14159265358979323846D0*
1527
21
     $ *2))
1528
22
C     
1529
23
C     ARGUMENTS 
1530
24
C     
1531
25
      INTEGER NLOOPLINE, RANK
1532
26
      REAL*8 PL(0:3,NLOOPLINE)
1533
27
      REAL*8 PCT(0:3,0:NLOOPLINE-1)
1534
28
      COMPLEX*16 M2L(NLOOPLINE)
1535
29
      COMPLEX*16 M2LCT(0:NLOOPLINE-1)
1536
30
      COMPLEX*16 RES(3)
1537
31
      LOGICAL STABLE
1538
32
C     
1539
33
C     LOCAL VARIABLES 
1540
34
C     
1541
35
      COMPLEX*16 R1, ACC
1542
36
      INTEGER I, J, K
1543
37
      LOGICAL CTINIT, TIRINIT, GOLEMINIT
1544
38
      COMMON/REDUCTIONCODEINIT/CTINIT,TIRINIT,GOLEMINIT
1545
39
C     
1546
40
C     EXTERNAL FUNCTIONS
1547
41
C     
1548
42
      EXTERNAL LOOPNUM
1549
43
      EXTERNAL MPLOOPNUM
1550
44
C     
1551
45
C     GLOBAL VARIABLES
1552
46
C     
1553
47
      INCLUDE 'coupl.inc'
1554
48
      INTEGER CTMODE
1555
49
      REAL*8 LSCALE
1556
50
      COMMON/CT/LSCALE,CTMODE
1557
51
1558
52
      INTEGER ID,SQSOINDEX,R
1559
53
      COMMON/LOOP/ID,SQSOINDEX,R
1560
54
1561
55
C     ----------
1562
56
C     BEGIN CODE
1563
57
C     ----------
1564
58
1565
59
C     INITIALIZE CUTTOOLS IF NEEDED
1566
60
      IF (CTINIT) THEN
1567
61
        CTINIT=.FALSE.
1568
62
        CALL INITCT()
1569
63
      ENDIF
1570
64
1571
65
C     YOU CAN FIND THE DETAILS ABOUT THE DIFFERENT CTMODE AT THE
1572
66
C      BEGINNING OF THE FILE CTS_CUTS.F90 IN THE CUTTOOLS DISTRIBUTION
1573
67
1574
68
C     CONVERT THE MASSES TO BE COMPLEX
1575
69
      DO I=1,NLOOPLINE
1576
70
        M2LCT(I-1)=M2L(I)
1577
71
      ENDDO
1578
72
1579
73
C     CONVERT THE MOMENTA FLOWING IN THE LOOP LINES TO CT CONVENTIONS
1580
74
      DO I=0,3
1581
75
        DO J=0,(NLOOPLINE-1)
1582
76
          PCT(I,J)=0.D0
1583
77
        ENDDO
1584
78
      ENDDO
1585
79
      DO I=0,3
1586
80
        DO J=1,NLOOPLINE
1587
81
          PCT(I,0)=PCT(I,0)+PL(I,J)
1588
82
        ENDDO
1589
83
      ENDDO
1590
84
      IF (CHECKPCONSERVATION) THEN
1591
85
        IF (PCT(0,0).GT.1.D-6) THEN
1592
86
          WRITE(*,*) 'energy is not conserved ',PCT(0,0)
1593
87
          STOP 'energy is not conserved'
1594
88
        ELSEIF (PCT(1,0).GT.1.D-6) THEN
1595
89
          WRITE(*,*) 'px is not conserved ',PCT(1,0)
1596
90
          STOP 'px is not conserved'
1597
91
        ELSEIF (PCT(2,0).GT.1.D-6) THEN
1598
92
          WRITE(*,*) 'py is not conserved ',PCT(2,0)
1599
93
          STOP 'py is not conserved'
1600
94
        ELSEIF (PCT(3,0).GT.1.D-6) THEN
1601
95
          WRITE(*,*) 'pz is not conserved ',PCT(3,0)
1602
96
          STOP 'pz is not conserved'
1603
97
        ENDIF
1604
98
      ENDIF
1605
99
      DO I=0,3
1606
100
        DO J=1,(NLOOPLINE-1)
1607
101
          DO K=1,J
1608
102
            PCT(I,J)=PCT(I,J)+PL(I,K)
1609
103
          ENDDO
1610
104
        ENDDO
1611
105
      ENDDO
1612
106
1613
107
      CALL CTSXCUT(CTMODE,LSCALE,MU_R,NLOOPLINE,LOOPNUM,MPLOOPNUM,RANK
1614
108
     $ ,PCT,M2LCT,RES,ACC,R1,STABLE)
1615
109
      RES(1)=NORMALIZATION*2.0D0*DBLE(RES(1))
1616
110
      RES(2)=NORMALIZATION*2.0D0*DBLE(RES(2))
1617
111
      RES(3)=NORMALIZATION*2.0D0*DBLE(RES(3))
1618
112
C     WRITE(*,*) 'Loop ID',ID,' =',RES(1),RES(2),RES(3)
1619
113
      END
1620
114
1621
115
      SUBROUTINE INITCT()
1622
116
C     
1623
117
C     INITIALISATION OF CUTTOOLS
1624
118
C     
1625
119
C     LOCAL VARIABLES 
1626
120
C     
1627
121
      REAL*8 THRS
1628
122
      LOGICAL EXT_NUM_FOR_R1
1629
123
C     
1630
124
C     GLOBAL VARIABLES 
1631
125
C     
1632
126
      INCLUDE 'MadLoopParams.inc'
1633
127
C     ----------
1634
128
C     BEGIN CODE
1635
129
C     ----------
1636
130
1637
131
C     DEFAULT PARAMETERS FOR CUTTOOLS
1638
132
C     -------------------------------  
1639
133
C     THRS1 IS THE PRECISION LIMIT BELOW WHICH THE MP ROUTINES
1640
134
C      ACTIVATES
1641
135
      THRS=CTSTABTHRES
1642
136
C     LOOPLIB SET WHAT LIBRARY CT USES
1643
137
C     1 -> LOOPTOOLS
1644
138
C     2 -> AVH
1645
139
C     3 -> QCDLOOP
1646
140
      LOOPLIB=CTLOOPLIBRARY
1647
141
C     MADLOOP'S NUMERATOR IN THE OPEN LOOP IS MUCH FASTER THAN THE
1648
142
C      RECONSTRUCTED ONE IN CT. SO WE BETTER USE MADLOOP ONE IN THIS
1649
143
C      CASE.
1650
144
      EXT_NUM_FOR_R1=.TRUE.
1651
145
C     -------------------------------	  
1652
146
1653
147
C     The initialization below is for CT v1.8.+
1654
148
      CALL CTSINIT(THRS,LOOPLIB,EXT_NUM_FOR_R1)
1655
149
C     The initialization below is for the older stable CT v1.7, still
1656
150
C      used for now in the beta release.
1657
151
C     CALL CTSINIT(THRS,LOOPLIB)
1658
152
1659
153
      END
1660
154
1661
155
      SUBROUTINE LOOP_3(W1, W2, W3, M1, M2, M3,  RANK, SQUAREDSOINDEX
1662
156
     $ , LOOPNUM)
1663
157
      INTEGER    NEXTERNAL
1664
158
      PARAMETER (NEXTERNAL=3)
1665
159
      INTEGER    NLOOPLINE
1666
160
      PARAMETER (NLOOPLINE=3)
1667
161
      INTEGER    NWAVEFUNCS
1668
162
      PARAMETER (NWAVEFUNCS=3)
1669
163
      INTEGER    NLOOPGROUPS
1670
164
      PARAMETER (NLOOPGROUPS=1)
1671
165
      INTEGER    NCOMB
1672
166
      PARAMETER (NCOMB=12)
1673
167
C     These are constants related to the split orders
1674
168
      INTEGER    NSQUAREDSO
1675
169
      PARAMETER (NSQUAREDSO=1)
1676
170
C     
1677
171
C     ARGUMENTS 
1678
172
C     
1679
173
      INTEGER W1, W2, W3
1680
174
      COMPLEX*16 M1, M2, M3
1681
175
1682
176
      INTEGER RANK, LSYMFACT
1683
177
      INTEGER LOOPNUM, SQUAREDSOINDEX
1684
178
C     
1685
179
C     LOCAL VARIABLES 
1686
180
C     
1687
181
      REAL*8 PL(0:3,NLOOPLINE)
1688
182
      COMPLEX*16 M2L(NLOOPLINE)
1689
183
      INTEGER PAIRING(NLOOPLINE),WE(3)
1690
184
      INTEGER I, J, K, TEMP,I_LIB
1691
185
      LOGICAL COMPLEX_MASS,DOING_QP
1692
186
C     
1693
187
C     GLOBAL VARIABLES
1694
188
C     
1695
189
      INCLUDE 'MadLoopParams.inc'
1696
190
      INTEGER ID,SQSOINDEX,R
1697
191
      COMMON/LOOP/ID,SQSOINDEX,R
1698
192
1699
193
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
1700
194
      COMMON/INIT/CHECKPHASE, HELDOUBLECHECKED
1701
195
1702
196
      INTEGER HELOFFSET
1703
197
      INTEGER GOODHEL(NCOMB)
1704
198
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
1705
199
      COMMON/FILTERS/GOODAMP,GOODHEL,HELOFFSET
1706
200
1707
201
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
1708
202
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
1709
203
      COMMON/LOOPRES/LOOPRES,S
1710
204
1711
205
1712
206
      COMPLEX*16 W(20,NWAVEFUNCS)
1713
207
      COMMON/W/W
1714
208
      REAL*8 LSCALE
1715
209
      INTEGER CTMODE
1716
210
      COMMON/CT/LSCALE,CTMODE
1717
211
      INTEGER LIBINDEX
1718
212
      COMMON/I_LIB/LIBINDEX
1719
213
1720
214
C     ----------
1721
215
C     BEGIN CODE
1722
216
C     ----------
1723
217
1724
218
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED).OR.GOODAMP(SQUAREDSOIND
1725
219
     $ EX,LOOPNUM)) THEN
1726
220
        WE(1)=W1
1727
221
        WE(2)=W2
1728
222
        WE(3)=W3
1729
223
        M2L(1)=M3**2
1730
224
        M2L(2)=M1**2
1731
225
        M2L(3)=M2**2
1732
226
        DO I=1,NLOOPLINE
1733
227
          PAIRING(I)=1
1734
228
        ENDDO
1735
229
1736
230
        R=RANK
1737
231
        ID=LOOPNUM
1738
232
        SQSOINDEX=SQUAREDSOINDEX
1739
233
        DO I=0,3
1740
234
          TEMP=1
1741
235
          DO J=1,NLOOPLINE
1742
236
            PL(I,J)=0.D0
1743
237
            DO K=TEMP,(TEMP+PAIRING(J)-1)
1744
238
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
1745
239
            ENDDO
1746
240
            TEMP=TEMP+PAIRING(J)
1747
241
          ENDDO
1748
242
        ENDDO
1749
243
C       Determine whether the integral is with complex masses or not
1750
244
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
1751
245
C        still
1752
246
C       not able to deal with complex masses
1753
247
        COMPLEX_MASS=.FALSE.
1754
248
        DO I=1,NLOOPLINE
1755
249
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
1756
250
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
1757
251
            COMPLEX_MASS=.TRUE.
1758
252
            EXIT
1759
253
          ENDIF
1760
254
        ENDDO
1761
255
C       Determine it uses qp or not
1762
256
        DOING_QP=.FALSE.
1763
257
        IF(CTMODE.GE.4)DOING_QP=.TRUE.
1764
258
C       Choose the correct loop library
1765
259
        CALL CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS
1766
260
     $   ,DOING_QP,I_LIB)
1767
261
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
1768
262
C         USE CUTTOOLS
1769
263
          CALL CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX
1770
264
     $     ,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1771
265
        ELSE
1772
266
C         USE TIR
1773
267
          CALL TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL,M2L
1774
268
     $     ,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX
1775
269
     $     ,LOOPNUM))
1776
270
        ENDIF
1777
271
      ELSE
1778
272
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1779
273
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1780
274
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1781
275
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
1782
276
      ENDIF
1783
277
      END
1784
278
1785
0
279
1786
=== added file 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%GOLEM_interface.f'
1787
--- tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%GOLEM_interface.f	1970-01-01 00:00:00 +0000
1788
+++ tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%GOLEM_interface.f	2016-02-24 13:54:50 +0000
1789
@@ -0,0 +1,760 @@
1790
1
      SUBROUTINE GOLEMLOOP(NLOOPLINE,PL,M2L,RANK,RES,STABLE)
1791
2
C     
1792
3
C     Generated by MadGraph5_aMC@NLO v. %(version)s, %(date)s
1793
4
C     By the MadGraph5_aMC@NLO Development Team
1794
5
C     Visit launchpad.net/madgraph5 and amcatnlo.web.cern.ch
1795
6
C     
1796
7
C     Interface between MG5 and Golem95.
1797
8
C     The Golem95 version should be higher than 1.3.0.
1798
9
C     It supports RANK = NLOOPLINE + 1 tensor integrals when 1 <
1799
10
C      NLOOPLINE < 6.
1800
11
C     
1801
12
C     Process: d~ u > w+ WEIGHTED=2 QED=1 [ all = QCD ]
1802
13
C     Process: s~ c > w+ WEIGHTED=2 QED=1 [ all = QCD ]
1803
14
C     
1804
15
C     
1805
16
C     MODULES
1806
17
C     
1807
18
      USE MATRICE_S
1808
19
      USE FORM_FACTOR_TYPE, ONLY: FORM_FACTOR
1809
20
      USE PRECISION_GOLEM, ONLY: KI
1810
21
      USE TENS_COMB
1811
22
      USE TENS_REC
1812
23
      USE FORM_FACTOR_1P, ONLY: A10
1813
24
      USE FORM_FACTOR_2P, ONLY: A20
1814
25
      USE FORM_FACTOR_3P, ONLY: A30
1815
26
      USE FORM_FACTOR_4P, ONLY: A40
1816
27
      USE FORM_FACTOR_5P, ONLY: A50
1817
28
      USE FORM_FACTOR_6P, ONLY: A60
1818
29
      IMPLICIT NONE
1819
30
C     
1820
31
C     CONSTANTS 
1821
32
C     
1822
33
      INTEGER    NEXTERNAL
1823
34
      PARAMETER (NEXTERNAL=3)
1824
35
      LOGICAL CHECKPCONSERVATION
1825
36
      PARAMETER (CHECKPCONSERVATION=.TRUE.)
1826
37
      REAL*8 NORMALIZATION
1827
38
      PARAMETER (NORMALIZATION = 1.D0/(16.D0*3.14159265358979323846D0*
1828
39
     $ *2))
1829
40
      REAL(KI),DIMENSION(0:3),PARAMETER::NULL_VEC = (/0.0_KI,0.0_KI
1830
41
     $ ,0.0_KI,0.0_KI/)
1831
42
C     GOLEM_RUN_MODE = 1: Use directly MadLoop tensorial coefficients
1832
43
C     GOLEM_RUN_MODE = 2: Reconstruct the tensorial coefficeints
1833
44
C      directly from 
1834
45
C     numerator using golem internal reconstruction routine
1835
46
C     GOLEM_RUN_MODE = 3: Cross-checked reconstructed coefficients
1836
47
C      against
1837
48
C     MadLoop internal ones.
1838
49
      INTEGER GOLEM_RUN_MODE
1839
50
      PARAMETER (GOLEM_RUN_MODE=1)
1840
51
C     The following is the acceptance threshold used for GOLEM_RUN_MODE
1841
52
C      = 3
1842
53
      REAL*8 COEF_CHECK_THRS
1843
54
      DATA COEF_CHECK_THRS/1.0D-13/
1844
55
      COMMON/COEF_CHECK_THRS/COEF_CHECK_THRS
1845
56
1846
57
      LOGICAL PASS_COEF_CHECK
1847
58
C     
1848
59
C     ARGUMENTS 
1849
60
C     
1850
61
      INTEGER NLOOPLINE, RANK
1851
62
      REAL*8 PL(0:3,NLOOPLINE)
1852
63
      REAL*8 PCT(0:3,0:NLOOPLINE-1)
1853
64
      REAL(KI) PGOLEM(NLOOPLINE,0:3)
1854
65
      COMPLEX*16 M2L(NLOOPLINE)
1855
66
      COMPLEX(KI) M2LGOLEM(NLOOPLINE)
1856
67
      COMPLEX*16 RES(3)
1857
68
      LOGICAL STABLE
1858
69
C     
1859
70
C     LOCAL VARIABLES 
1860
71
C     
1861
72
      INTEGER I, J, K
1862
73
      TYPE(FORM_FACTOR)::RES_GOLEM
1863
74
1864
75
      COMPLEX(KI)::COEFFS0,COEFFS0_REC
1865
76
      TYPE(COEFF_TYPE_1)::COEFFS1,COEFFS1_REC
1866
77
      TYPE(COEFF_TYPE_2)::COEFFS2,COEFFS2_REC
1867
78
      TYPE(COEFF_TYPE_3)::COEFFS3,COEFFS3_REC
1868
79
      TYPE(COEFF_TYPE_4)::COEFFS4,COEFFS4_REC
1869
80
      TYPE(COEFF_TYPE_5)::COEFFS5,COEFFS5_REC
1870
81
      TYPE(COEFF_TYPE_6)::COEFFS6,COEFFS6_REC
1871
82
1872
83
C     The pinch propagator optimization is not used, so for now it is
1873
84
C     always 0.
1874
85
      INTEGER PINCH
1875
86
C     
1876
87
C     EXTERNAL FUNCTIONS
1877
88
C     
1878
89
      COMPLEX(KI) GOLEM_LOOPNUM
1879
90
      EXTERNAL GOLEM_LOOPNUM
1880
91
      LOGICAL COMPARE_COEFS_0
1881
92
      LOGICAL COMPARE_COEFS_1
1882
93
      LOGICAL COMPARE_COEFS_2
1883
94
      LOGICAL COMPARE_COEFS_3
1884
95
      LOGICAL COMPARE_COEFS_4
1885
96
      LOGICAL COMPARE_COEFS_5
1886
97
      LOGICAL COMPARE_COEFS_6
1887
98
C     
1888
99
C     GLOBAL VARIABLES
1889
100
C     
1890
101
      INCLUDE 'coupl.inc'
1891
102
      INTEGER CTMODE
1892
103
      REAL*8 LSCALE
1893
104
      COMMON/CT/LSCALE,CTMODE
1894
105
1895
106
      INTEGER ID,SQSOINDEX,R
1896
107
      COMMON/LOOP/ID,SQSOINDEX,R
1897
108
1898
109
      LOGICAL CTINIT, TIRINIT, GOLEMINIT
1899
110
      COMMON/REDUCTIONCODEINIT/CTINIT, TIRINIT,GOLEMINIT
1900
111
1901
112
      INTEGER NLOOPGROUPS
1902
113
      PARAMETER (NLOOPGROUPS=1)
1903
114
      INTEGER LOOPMAXCOEFS
1904
115
      PARAMETER (LOOPMAXCOEFS=15)
1905
116
      INTEGER NSQUAREDSO
1906
117
      PARAMETER (NSQUAREDSO=1)
1907
118
1908
119
      COMPLEX*16 LOOPCOEFS(0:LOOPMAXCOEFS-1,NSQUAREDSO,NLOOPGROUPS)
1909
120
      COMMON/LCOEFS/LOOPCOEFS
1910
121
C     ----------
1911
122
C     BEGIN CODE
1912
123
C     ----------
1913
124
1914
125
C     INITIALIZE CUTTOOLS IF NEEDED
1915
126
      IF (GOLEMINIT) THEN
1916
127
        GOLEMINIT=.FALSE.
1917
128
        CALL INITGOLEM()
1918
129
      ENDIF
1919
130
1920
131
C     No stability test intrisic to Golem95 now
1921
132
      STABLE=.TRUE.
1922
133
1923
134
C     This initialization must be done for each reduction because we
1924
135
C     have not setup anyoptimization using pinched propagators yet.
1925
136
      CALL INITGOLEM95(NLOOPLINE)
1926
137
      PINCH = 0
1927
138
1928
139
C     YOU CAN FIND THE DETAILS ABOUT THE DIFFERENT CTMODE AT THE
1929
140
C      BEGINNING OF THE FILE CTS_CUTS.F90 IN THE CUTTOOLS DISTRIBUTION
1930
141
1931
142
C     CONVERT THE MASSES TO BE COMPLEX
1932
143
      DO I=1,NLOOPLINE
1933
144
        M2LGOLEM(I)=M2L(I)
1934
145
      ENDDO
1935
146
1936
147
C     CONVERT THE MOMENTA FLOWING IN THE LOOP LINES TO CT CONVENTIONS
1937
148
      DO I=0,3
1938
149
        DO J=0,(NLOOPLINE-1)
1939
150
          PCT(I,J)=0.D0
1940
151
        ENDDO
1941
152
      ENDDO
1942
153
      DO I=0,3
1943
154
        DO J=1,NLOOPLINE
1944
155
          PCT(I,0)=PCT(I,0)+PL(I,J)
1945
156
        ENDDO
1946
157
      ENDDO
1947
158
      IF (CHECKPCONSERVATION) THEN
1948
159
        IF (PCT(0,0).GT.1.D-6) THEN
1949
160
          WRITE(*,*) 'energy is not conserved ',PCT(0,0)
1950
161
          STOP 'energy is not conserved'
1951
162
        ELSEIF (PCT(1,0).GT.1.D-6) THEN
1952
163
          WRITE(*,*) 'px is not conserved ',PCT(1,0)
1953
164
          STOP 'px is not conserved'
1954
165
        ELSEIF (PCT(2,0).GT.1.D-6) THEN
1955
166
          WRITE(*,*) 'py is not conserved ',PCT(2,0)
1956
167
          STOP 'py is not conserved'
1957
168
        ELSEIF (PCT(3,0).GT.1.D-6) THEN
1958
169
          WRITE(*,*) 'pz is not conserved ',PCT(3,0)
1959
170
          STOP 'pz is not conserved'
1960
171
        ENDIF
1961
172
      ENDIF
1962
173
      DO I=0,3
1963
174
        DO J=1,(NLOOPLINE-1)
1964
175
          DO K=1,J
1965
176
            PCT(I,J)=PCT(I,J)+PL(I,K)
1966
177
          ENDDO
1967
178
        ENDDO
1968
179
      ENDDO
1969
180
1970
181
C     Now convert the loop momenta to Golem95 conventions
1971
182
      DO I=0,3
1972
183
        PGOLEM(1,I)=0.0E0_KI
1973
184
        DO J=2,NLOOPLINE
1974
185
          PGOLEM(J,I)=PCT(I,J-1)
1975
186
        ENDDO
1976
187
      ENDDO
1977
188
1978
189
C     Fill in the kinematic s-matrix while taking care of on-shell
1979
190
C      limits.
1980
191
      CALL SETUP_KIN_MATRIX(NLOOPLINE,PGOLEM,M2LGOLEM)
1981
192
C     Construct the golem internal matrices derived from the kinetic
1982
193
C      one.
1983
194
      CALL PREPARESMATRIX()
1984
195
1985
196
C     Fill in the golem coefficents and compute the loop
1986
197
      IF(GOLEM_RUN_MODE.EQ.2)THEN
1987
198
        RES_GOLEM = EVALUATE_B(GOLEM_LOOPNUM,PGOLEM,0,RANK)
1988
199
      ELSE
1989
200
        PASS_COEF_CHECK=.TRUE.
1990
201
        SELECT CASE(RANK)
1991
202
        CASE(0)
1992
203
        CALL FILL_GOLEM_COEFFS_0(LOOPCOEFS(0,SQSOINDEX,ID),COEFFS0)
1993
204
        IF(GOLEM_RUN_MODE.EQ.3)THEN
1994
205
          COEFFS0_REC = GOLEM_LOOPNUM(NULL_VEC,0.0_KI)
1995
206
          PASS_COEF_CHECK=COMPARE_COEFS_0(COEFFS0,COEFFS0_REC)
1996
207
        ENDIF
1997
208
        CASE(1)
1998
209
        CALL FILL_GOLEM_COEFFS_1(LOOPCOEFS(0,SQSOINDEX,ID),COEFFS1)
1999
210
        IF(GOLEM_RUN_MODE.EQ.3)THEN
2000
211
          CALL RECONSTRUCT1(GOLEM_LOOPNUM,COEFFS1_REC)
2001
212
          PASS_COEF_CHECK=COMPARE_COEFS_1(COEFFS1,COEFFS1_REC)
2002
213
        ENDIF
2003
214
        CASE(2)
2004
215
        CALL FILL_GOLEM_COEFFS_2(LOOPCOEFS(0,SQSOINDEX,ID),COEFFS2)
2005
216
        IF(GOLEM_RUN_MODE.EQ.3)THEN
2006
217
          CALL RECONSTRUCT2(GOLEM_LOOPNUM,COEFFS2_REC)
2007
218
          PASS_COEF_CHECK=COMPARE_COEFS_2(COEFFS2,COEFFS2_REC)
2008
219
        ENDIF
2009
220
        CASE(3)
2010
221
        CALL FILL_GOLEM_COEFFS_3(LOOPCOEFS(0,SQSOINDEX,ID),COEFFS3)
2011
222
        IF(GOLEM_RUN_MODE.EQ.3)THEN
2012
223
          CALL RECONSTRUCT3(GOLEM_LOOPNUM,COEFFS3_REC)
2013
224
          PASS_COEF_CHECK=COMPARE_COEFS_3(COEFFS3,COEFFS3_REC)
2014
225
        ENDIF
2015
226
        CASE(4)
2016
227
        CALL FILL_GOLEM_COEFFS_4(LOOPCOEFS(0,SQSOINDEX,ID),COEFFS4)
2017
228
        IF(GOLEM_RUN_MODE.EQ.3)THEN
2018
229
          CALL RECONSTRUCT4(GOLEM_LOOPNUM,COEFFS4_REC)
2019
230
          PASS_COEF_CHECK=COMPARE_COEFS_4(COEFFS4,COEFFS4_REC)
2020
231
        ENDIF
2021
232
        CASE(5)
2022
233
        CALL FILL_GOLEM_COEFFS_5(LOOPCOEFS(0,SQSOINDEX,ID),COEFFS5)
2023
234
        IF(GOLEM_RUN_MODE.EQ.3)THEN
2024
235
          CALL RECONSTRUCT5(GOLEM_LOOPNUM,COEFFS5_REC)
2025
236
          PASS_COEF_CHECK=COMPARE_COEFS_5(COEFFS5,COEFFS5_REC)
2026
237
        ENDIF
2027
238
        CASE(6)
2028
239
        CALL FILL_GOLEM_COEFFS_6(LOOPCOEFS(0,SQSOINDEX,ID),COEFFS6)
2029
240
        IF(GOLEM_RUN_MODE.EQ.3)THEN
2030
241
          CALL RECONSTRUCT6(GOLEM_LOOPNUM,COEFFS6_REC)
2031
242
          PASS_COEF_CHECK=COMPARE_COEFS_6(COEFFS6,COEFFS6_REC)
2032
243
        ENDIF
2033
244
        CASE DEFAULT
2034
245
        WRITE(*,*)'Not yet implemented in Golem95 for rank= ',RANK
2035
246
        STOP
2036
247
        END SELECT
2037
248
2038
249
        IF(.NOT.PASS_COEF_CHECK)THEN
2039
250
          WRITE(*,*)'Coefs mismatch for ID ',ID,' and rank ',RANK
2040
251
          WRITE(*,*)'Coefs form MadLoop5:'
2041
252
          SELECT CASE(RANK)
2042
253
          CASE(0)
2043
254
          WRITE(*,*)'Constant coef = ',COEFFS0
2044
255
          CASE(1)
2045
256
          CALL PRINT_COEFFS(COEFFS1)
2046
257
          CASE(2)
2047
258
          CALL PRINT_COEFFS(COEFFS2)
2048
259
          CASE(3)
2049
260
          CALL PRINT_COEFFS(COEFFS3)
2050
261
          CASE(4)
2051
262
          CALL PRINT_COEFFS(COEFFS4)
2052
263
          CASE(5)
2053
264
          CALL PRINT_COEFFS(COEFFS5)
2054
265
          CASE(6)
2055
266
          CALL PRINT_COEFFS(COEFFS6)
2056
267
          END SELECT
2057
268
          WRITE(*,*)'Coefs reconstructed by Golem95:'
2058
269
          SELECT CASE(RANK)
2059
270
          CASE(0)
2060
271
          WRITE(*,*)'Constant coef = ',COEFFS0_REC
2061
272
          CASE(1)
2062
273
          CALL PRINT_COEFFS(COEFFS1_REC)
2063
274
          CASE(2)
2064
275
          CALL PRINT_COEFFS(COEFFS2_REC)
2065
276
          CASE(3)
2066
277
          CALL PRINT_COEFFS(COEFFS3_REC)
2067
278
          CASE(4)
2068
279
          CALL PRINT_COEFFS(COEFFS4_REC)
2069
280
          CASE(5)
2070
281
          CALL PRINT_COEFFS(COEFFS5_REC)
2071
282
          CASE(6)
2072
283
          CALL PRINT_COEFFS(COEFFS6_REC)
2073
284
          END SELECT
2074
285
          STOP
2075
286
        ENDIF
2076
287
2077
288
        SELECT CASE(NLOOPLINE)
2078
289
        CASE(1)
2079
290
        WRITE(*,*)'Golem95 cannot handle with tadpole yet'
2080
291
        STOP
2081
292
        CASE(2)
2082
293
        SELECT CASE(RANK)
2083
294
        CASE(0)
2084
295
        RES_GOLEM = COEFFS0*A20(PINCH)
2085
296
        CASE(1)
2086
297
        RES_GOLEM = CONTRACT2_1(COEFFS1,PGOLEM,PINCH)
2087
298
        CASE(2)
2088
299
        RES_GOLEM = CONTRACT2_2(COEFFS2,PGOLEM,PINCH)
2089
300
        CASE(3)
2090
301
        RES_GOLEM = CONTRACT2_3(COEFFS3,PGOLEM,PINCH)
2091
302
        CASE DEFAULT
2092
303
        WRITE(*,*)'Golem95 cannot handle with: N,r = ',2,RANK
2093
304
        STOP
2094
305
        END SELECT
2095
306
        CASE(3)
2096
307
        SELECT CASE(RANK)
2097
308
        CASE(0)
2098
309
        RES_GOLEM = COEFFS0*A30(PINCH)
2099
310
        CASE(1)
2100
311
        RES_GOLEM = CONTRACT3_1(COEFFS1,PGOLEM,PINCH)
2101
312
        CASE(2)
2102
313
        RES_GOLEM = CONTRACT3_2(COEFFS2,PGOLEM,PINCH)
2103
314
        CASE(3)
2104
315
        RES_GOLEM = CONTRACT3_3(COEFFS3,PGOLEM,PINCH)
2105
316
        CASE(4)
2106
317
        RES_GOLEM = CONTRACT3_4(COEFFS4,PGOLEM,PINCH)
2107
318
        CASE DEFAULT
2108
319
        WRITE(*,*)'Golem95 cannot handle with: N,r = ',3,RANK
2109
320
        STOP
2110
321
        END SELECT
2111
322
        CASE(4)
2112
323
        SELECT CASE(RANK)
2113
324
        CASE(0)
2114
325
        RES_GOLEM = COEFFS0*A40(PINCH)
2115
326
        CASE(1)
2116
327
        RES_GOLEM = CONTRACT4_1(COEFFS1,PGOLEM,PINCH)
2117
328
        CASE(2)
2118
329
        RES_GOLEM = CONTRACT4_2(COEFFS2,PGOLEM,PINCH)
2119
330
        CASE(3)
2120
331
        RES_GOLEM = CONTRACT4_3(COEFFS3,PGOLEM,PINCH)
2121
332
        CASE(4)
2122
333
        RES_GOLEM = CONTRACT4_4(COEFFS4,PGOLEM,PINCH)
2123
334
        CASE(5)
2124
335
        RES_GOLEM = CONTRACT4_5(COEFFS5,PGOLEM,PINCH)
2125
336
        CASE DEFAULT
2126
337
        WRITE(*,*)'Golem95 cannot handle with: N,r = ',4,RANK
2127
338
        STOP
2128
339
        END SELECT
2129
340
        CASE(5)
2130
341
        SELECT CASE(RANK)
2131
342
        CASE(0)
2132
343
        RES_GOLEM = COEFFS0*A50(PINCH)
2133
344
        CASE(1)
2134
345
        RES_GOLEM = CONTRACT5_1(COEFFS1,PGOLEM,PINCH)
2135
346
        CASE(2)
2136
347
        RES_GOLEM = CONTRACT5_2(COEFFS2,PGOLEM,PINCH)
2137
348
        CASE(3)
2138
349
        RES_GOLEM = CONTRACT5_3(COEFFS3,PGOLEM,PINCH)
2139
350
        CASE(4)
2140
351
        RES_GOLEM = CONTRACT5_4(COEFFS4,PGOLEM,PINCH)
2141
352
        CASE(5)
2142
353
        RES_GOLEM = CONTRACT5_5(COEFFS5,PGOLEM,PINCH)
2143
354
        CASE(6)
2144
355
        RES_GOLEM = CONTRACT5_6(COEFFS6,PGOLEM,PINCH)
2145
356
        CASE DEFAULT
2146
357
        WRITE(*,*)'Golem95 cannot handle with: N,r = ',5,RANK
2147
358
        STOP
2148
359
        END SELECT
2149
360
        CASE(6)
2150
361
        SELECT CASE(RANK)
2151
362
        CASE(0)
2152
363
        RES_GOLEM = COEFFS0*A60(PINCH)
2153
364
        CASE(1)
2154
365
        RES_GOLEM = CONTRACT6_1(COEFFS1,PGOLEM,PINCH)
2155
366
        CASE(2)
2156
367
        RES_GOLEM = CONTRACT6_2(COEFFS2,PGOLEM,PINCH)
2157
368
        CASE(3)
2158
369
        RES_GOLEM = CONTRACT6_3(COEFFS3,PGOLEM,PINCH)
2159
370
        CASE(4)
2160
371
        RES_GOLEM = CONTRACT6_4(COEFFS4,PGOLEM,PINCH)
2161
372
        CASE(5)
2162
373
        RES_GOLEM = CONTRACT6_5(COEFFS5,PGOLEM,PINCH)
2163
374
        CASE(6)
2164
375
        RES_GOLEM = CONTRACT6_6(COEFFS6,PGOLEM,PINCH)
2165
376
        CASE DEFAULT
2166
377
        WRITE(*,*)'Golem95 cannot handle with: N,r = ',6,RANK
2167
378
        STOP
2168
379
        END SELECT
2169
380
        CASE DEFAULT
2170
381
        WRITE(*,*)'Golem95 cannot handle with: N = ',NLOOPLINE
2171
382
        STOP
2172
383
        END SELECT
2173
384
      ENDIF
2174
385
2175
386
      RES(1)=NORMALIZATION*2.0D0*DBLE(RES_GOLEM%%C+2.0*LOG(MU_R)
2176
387
     $ *RES_GOLEM%%B+2.0*LOG(MU_R)**2*RES_GOLEM%%A)
2177
388
      RES(2)=NORMALIZATION*2.0D0*DBLE(RES_GOLEM%%B+2.0*LOG(MU_R)
2178
389
     $ *RES_GOLEM%%A)
2179
390
      RES(3)=NORMALIZATION*2.0D0*DBLE(RES_GOLEM%%A)
2180
391
C     WRITE(*,*) 'Loop ID',ID,' =',RES(1),RES(2),RES(3)
2181
392
2182
393
C     Finally free golem memory and cache
2183
394
      CALL EXITGOLEM95()
2184
395
2185
396
      END
2186
397
2187
398
      FUNCTION GOLEM_LOOPNUM(Q,MU2)
2188
399
      USE PRECISION_GOLEM, ONLY: KI
2189
400
      REAL(KI),DIMENSION(0:3),INTENT(IN)::Q
2190
401
      REAL(KI),INTENT(IN)::MU2
2191
402
      COMPLEX(KI)::GOLEM_LOOPNUM
2192
403
2193
404
      COMPLEX*16 QQ(0:3),NUM
2194
405
      INTEGER I
2195
406
2196
407
      DO I=0,3
2197
408
        QQ(I)=CMPLX(Q(I),0.0D0,KIND=16)
2198
409
      ENDDO
2199
410
2200
411
      CALL LOOPNUM(QQ,NUM)
2201
412
      GOLEM_LOOPNUM=NUM
2202
413
      RETURN
2203
414
      END FUNCTION
2204
415
2205
416
      SUBROUTINE INITGOLEM()
2206
417
C     
2207
418
C     INITIALISATION OF GOLEM
2208
419
C     
2209
420
C     
2210
421
C     MODULE
2211
422
C     
2212
423
      USE PARAMETRE
2213
424
C     
2214
425
C     LOCAL VARIABLES 
2215
426
C     
2216
427
      REAL*8 THRS
2217
428
      LOGICAL EXT_NUM_FOR_R1
2218
429
C     
2219
430
C     GLOBAL VARIABLES 
2220
431
C     
2221
432
      INCLUDE 'MadLoopParams.inc'
2222
433
C     ----------
2223
434
C     BEGIN CODE
2224
435
C     ----------
2225
436
2226
437
C     DEFAULT PARAMETERS FOR GOLEM
2227
438
C     -------------------------------  
2228
439
C     One can chose here to have either just the rational R1 piece 
2229
440
C     or everything but the R2
2230
441
      RAT_OR_TOT_PAR = TOT
2231
442
2232
443
      END
2233
444
2234
445
      SUBROUTINE SETUP_KIN_MATRIX(NLOOPLINE,PGOLEM,M2L)
2235
446
C     
2236
447
C     MODULE
2237
448
C     
2238
449
      USE MATRICE_S
2239
450
      USE PRECISION_GOLEM, ONLY: KI
2240
451
C     
2241
452
C     ARGUMENTS
2242
453
C     
2243
454
      INTEGER NLOOPLINE
2244
455
      REAL(KI) PGOLEM(NLOOPLINE,0:3)
2245
456
      COMPLEX(KI) M2L(NLOOPLINE)
2246
457
2247
458
C     
2248
459
C     GLOBAL VARIABLES
2249
460
C     
2250
461
      INCLUDE 'MadLoopParams.inc'
2251
462
      INTEGER CTMODE
2252
463
      REAL*8 LSCALE
2253
464
      COMMON/CT/LSCALE,CTMODE
2254
465
      REAL*8 REF_NORMALIZATION
2255
466
C     
2256
467
C     LOCAL VARIABLES
2257
468
C     
2258
469
      INTEGER I,J,K
2259
470
      COMPLEX(KI) DIFFSQ
2260
471
C     ----------
2261
472
C     BEGIN CODE
2262
473
C     ----------
2263
474
2264
475
      DO I=1,NLOOPLINE
2265
476
        DO J=1,NLOOPLINE
2266
477
          IF(I.EQ.J)THEN
2267
478
            S_MAT(I,J)=-(M2L(I)+M2L(J))
2268
479
          ELSE
2269
480
            DIFFSQ = (CMPLX(PGOLEM(I,0),0.0_KI,KIND=KI)-CMPLX(PGOLEM(J
2270
481
     $       ,0),0.0_KI,KIND=KI))**2
2271
482
            DO K=1,3
2272
483
              DIFFSQ = DIFFSQ-(CMPLX(PGOLEM(I,K),0.0_KI,KIND=KI)
2273
484
     $         -CMPLX(PGOLEM(J,K),0.0_KI,KIND=KI))**2
2274
485
            ENDDO
2275
486
            S_MAT(I,J)=DIFFSQ-M2L(I)-M2L(J)
2276
487
            IF(M2L(I).NE.0.0D0)THEN
2277
488
              IF(ABS((DIFFSQ-M2L(I))/M2L(I)).LT.OSTHRES)THEN
2278
489
                S_MAT(I,J)=-M2L(J)
2279
490
              ENDIF
2280
491
            ENDIF
2281
492
            IF(M2L(J).NE.0.0D0)THEN
2282
493
              IF(ABS((DIFFSQ-M2L(J))/M2L(J)).LT.OSTHRES)THEN
2283
494
                S_MAT(I,J)=-M2L(I)
2284
495
              ENDIF
2285
496
            ENDIF
2286
497
C           Chose what seems the most appropriate way to compare
2287
498
C           massless onshellness. (here we pick the energy component)
2288
499
            REF_NORMALIZATION=(PGOLEM(I,0)+PGOLEM(J,0))**2
2289
500
            IF(REF_NORMALIZATION.NE.0.0D0)THEN
2290
501
              IF(ABS(DIFFSQ/REF_NORMALIZATION).LT.OSTHRES)THEN
2291
502
                S_MAT(I,J)=-(M2L(I)+M2L(J))
2292
503
              ENDIF
2293
504
            ENDIF
2294
505
          ENDIF
2295
506
        ENDDO
2296
507
      ENDDO
2297
508
2298
509
      END
2299
510
2300
511
      FUNCTION COMPARE_COEFS_0(COEFS_A,COEFS_B)
2301
512
2302
513
      USE PRECISION_GOLEM, ONLY: KI
2303
514
      COMPLEX(KI) COEFS_A,COEFS_B
2304
515
      REAL*8 COEF_CHECK_THRS
2305
516
      COMMON/COEF_CHECK_THRS/COEF_CHECK_THRS
2306
517
      REAL*8 DENOM,NUM
2307
518
      LOGICAL COMPARE_COEFS_0
2308
519
2309
520
      NUM = ABS(COEFS_A-COEFS_B)
2310
521
      DENOM = ABS(COEFS_A+COEFS_B)
2311
522
      IF(DENOM.GT.0D0)THEN
2312
523
        COMPARE_COEFS_0=((NUM/DENOM).LT.COEF_CHECK_THRS)
2313
524
      ELSE
2314
525
        COMPARE_COEFS_0=(NUM.LT.COEF_CHECK_THRS)
2315
526
      ENDIF
2316
527
2317
528
      END
2318
529
2319
530
      FUNCTION COMPARE_COEFS_1(COEFS_A,COEFS_B)
2320
531
2321
532
      USE TENS_REC
2322
533
      TYPE(COEFF_TYPE_1)COEFS_A,COEFS_B
2323
534
      REAL*8 COEF_CHECK_THRS
2324
535
      COMMON/COEF_CHECK_THRS/COEF_CHECK_THRS
2325
536
      REAL*8 DENOM,NUM
2326
537
      LOGICAL COMPARE_COEFS_1
2327
538
2328
539
      NUM = ABS(COEFS_A%%C0-COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1-COEFS_B%%C1))
2329
540
      DENOM = ABS(COEFS_A%%C0+COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1+COEFS_B%%C1
2330
541
     $ ))
2331
542
2332
543
      IF(DENOM.GT.0D0)THEN
2333
544
        COMPARE_COEFS_1=((NUM/DENOM).LT.COEF_CHECK_THRS)
2334
545
      ELSE
2335
546
        COMPARE_COEFS_1=(NUM.LT.COEF_CHECK_THRS)
2336
547
      ENDIF
2337
548
2338
549
      END
2339
550
2340
551
      FUNCTION COMPARE_COEFS_2(COEFS_A,COEFS_B)
2341
552
2342
553
      USE TENS_REC
2343
554
      TYPE(COEFF_TYPE_2) COEFS_A,COEFS_B
2344
555
      REAL*8 COEF_CHECK_THRS
2345
556
      COMMON/COEF_CHECK_THRS/COEF_CHECK_THRS
2346
557
      REAL*8 DENOM,NUM
2347
558
      LOGICAL COMPARE_COEFS_2
2348
559
2349
560
      NUM = ABS(COEFS_A%%C0-COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1-COEFS_B%%C1))
2350
561
     $ +SUM(ABS(COEFS_A%%C2-COEFS_B%%C2))
2351
562
      DENOM = ABS(COEFS_A%%C0+COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1+COEFS_B%%C1
2352
563
     $ ))+SUM(ABS(COEFS_A%%C2+COEFS_B%%C2))
2353
564
      IF(DENOM.GT.0D0)THEN
2354
565
        COMPARE_COEFS_2=((NUM/DENOM).LT.COEF_CHECK_THRS)
2355
566
      ELSE
2356
567
        COMPARE_COEFS_2=(NUM.LT.COEF_CHECK_THRS)
2357
568
      ENDIF
2358
569
2359
570
      END
2360
571
2361
572
      FUNCTION COMPARE_COEFS_3(COEFS_A,COEFS_B)
2362
573
2363
574
      USE TENS_REC
2364
575
      TYPE(COEFF_TYPE_3) COEFS_A, COEFS_B
2365
576
      REAL*8 COEF_CHECK_THRS
2366
577
      COMMON/COEF_CHECK_THRS/COEF_CHECK_THRS
2367
578
      REAL*8 DENOM,NUM
2368
579
      LOGICAL COMPARE_COEFS_3
2369
580
2370
581
      NUM = ABS(COEFS_A%%C0-COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1-COEFS_B%%C1))
2371
582
     $ +SUM(ABS(COEFS_A%%C2-COEFS_B%%C2))+SUM(ABS(COEFS_A%%C3-COEFS_B%%C3))
2372
583
      DENOM = ABS(COEFS_A%%C0+COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1+COEFS_B%%C1
2373
584
     $ ))+SUM(ABS(COEFS_A%%C2+COEFS_B%%C2))+SUM(ABS(COEFS_A%%C3+COEFS_B%%C3
2374
585
     $ ))
2375
586
      IF(DENOM.GT.0D0)THEN
2376
587
        COMPARE_COEFS_3=((NUM/DENOM).LT.COEF_CHECK_THRS)
2377
588
      ELSE
2378
589
        COMPARE_COEFS_3=(NUM.LT.COEF_CHECK_THRS)
2379
590
      ENDIF
2380
591
2381
592
      END
2382
593
2383
594
      FUNCTION COMPARE_COEFS_4(COEFS_A,COEFS_B)
2384
595
2385
596
      USE TENS_REC
2386
597
      TYPE(COEFF_TYPE_4) COEFS_A, COEFS_B
2387
598
      REAL*8 COEF_CHECK_THRS
2388
599
      COMMON/COEF_CHECK_THRS/COEF_CHECK_THRS
2389
600
      REAL*8 DENOM,NUM
2390
601
      LOGICAL COMPARE_COEFS_4
2391
602
2392
603
      NUM = ABS(COEFS_A%%C0-COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1-COEFS_B%%C1))
2393
604
     $ +SUM(ABS(COEFS_A%%C2-COEFS_B%%C2))+SUM(ABS(COEFS_A%%C3-COEFS_B%%C3)
2394
605
     $ )+SUM(ABS(COEFS_A%%C4-COEFS_B%%C4))
2395
606
      DENOM = ABS(COEFS_A%%C0+COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1+COEFS_B%%C1
2396
607
     $ ))+SUM(ABS(COEFS_A%%C2+COEFS_B%%C2))+SUM(ABS(COEFS_A%%C3+COEFS_B%%C3
2397
608
     $ ))+SUM(ABS(COEFS_A%%C4+COEFS_B%%C4))
2398
609
      IF(DENOM.GT.0D0)THEN
2399
610
        COMPARE_COEFS_4=((NUM/DENOM).LT.COEF_CHECK_THRS)
2400
611
      ELSE
2401
612
        COMPARE_COEFS_4=(NUM.LT.COEF_CHECK_THRS)
2402
613
      ENDIF
2403
614
2404
615
      END
2405
616
2406
617
      FUNCTION COMPARE_COEFS_5(COEFS_A,COEFS_B)
2407
618
2408
619
      USE TENS_REC
2409
620
      TYPE(COEFF_TYPE_5) COEFS_A,COEFS_B
2410
621
      REAL*8 COEF_CHECK_THRS
2411
622
      COMMON/COEF_CHECK_THRS/COEF_CHECK_THRS
2412
623
      REAL*8 DENOM,NUM
2413
624
      LOGICAL COMPARE_COEFS_5
2414
625
2415
626
      NUM = ABS(COEFS_A%%C0-COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1-COEFS_B%%C1))
2416
627
     $ +SUM(ABS(COEFS_A%%C2-COEFS_B%%C2))+SUM(ABS(COEFS_A%%C3-COEFS_B%%C3)
2417
628
     $ )+SUM(ABS(COEFS_A%%C4-COEFS_B%%C4))
2418
629
      DENOM = ABS(COEFS_A%%C0+COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1+COEFS_B%%C1
2419
630
     $ ))+SUM(ABS(COEFS_A%%C2+COEFS_B%%C2))+SUM(ABS(COEFS_A%%C3+COEFS_B%%C3
2420
631
     $ ))+SUM(ABS(COEFS_A%%C4+COEFS_B%%C4))
2421
632
      IF(DENOM.GT.0D0)THEN
2422
633
        COMPARE_COEFS_5=((NUM/DENOM).LT.COEF_CHECK_THRS)
2423
634
      ELSE
2424
635
        COMPARE_COEFS_5=(NUM.LT.COEF_CHECK_THRS)
2425
636
      ENDIF
2426
637
2427
638
      END
2428
639
2429
640
      FUNCTION COMPARE_COEFS_6(COEFS_A,COEFS_B)
2430
641
2431
642
      USE TENS_REC
2432
643
      TYPE(COEFF_TYPE_6) COEFS_A,COEFS_B
2433
644
      REAL*8 COEF_CHECK_THRS
2434
645
      COMMON/COEF_CHECK_THRS/COEF_CHECK_THRS
2435
646
      REAL*8 DENOM,NUM
2436
647
      LOGICAL COMPARE_COEFS_6
2437
648
2438
649
      NUM = ABS(COEFS_A%%C0-COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1-COEFS_B%%C1))
2439
650
     $ +SUM(ABS(COEFS_A%%C2-COEFS_B%%C2))+SUM(ABS(COEFS_A%%C3-COEFS_B%%C3)
2440
651
     $ )+SUM(ABS(COEFS_A%%C4-COEFS_B%%C4))
2441
652
      DENOM = ABS(COEFS_A%%C0+COEFS_B%%C0)+SUM(ABS(COEFS_A%%C1+COEFS_B%%C1
2442
653
     $ ))+SUM(ABS(COEFS_A%%C2+COEFS_B%%C2))+SUM(ABS(COEFS_A%%C3+COEFS_B%%C3
2443
654
     $ ))+SUM(ABS(COEFS_A%%C4+COEFS_B%%C4))
2444
655
      IF(DENOM.GT.0D0)THEN
2445
656
        COMPARE_COEFS_6=((NUM/DENOM).LT.COEF_CHECK_THRS)
2446
657
      ELSE
2447
658
        COMPARE_COEFS_6=(NUM.LT.COEF_CHECK_THRS)
2448
659
      ENDIF
2449
660
2450
661
      END
2451
662
2452
663
2453
664
      SUBROUTINE FILL_GOLEM_COEFFS_0(ML_COEFS,GOLEM_COEFS)
2454
665
      USE PRECISION_GOLEM, ONLY: KI
2455
666
      INCLUDE 'coef_specs.inc'
2456
667
      COMPLEX*16 ML_COEFS(0:LOOP_MAXCOEFS-1)
2457
668
      COMPLEX(KI) GOLEM_COEFS
2458
669
      GOLEM_COEFS=ML_COEFS(0)
2459
670
      END
2460
671
2461
672
      SUBROUTINE FILL_GOLEM_COEFFS_1(ML_COEFS,GOLEM_COEFS)
2462
673
      USE TENS_REC, ONLY: COEFF_TYPE_1
2463
674
      INCLUDE 'coef_specs.inc'
2464
675
      COMPLEX*16 ML_COEFS(0:LOOP_MAXCOEFS-1)
2465
676
      TYPE(COEFF_TYPE_1) GOLEM_COEFS
2466
677
C     Constant coefficient 
2467
678
      GOLEM_COEFS%%C0=ML_COEFS(0)
2468
679
C     Coefficient q(0)
2469
680
      GOLEM_COEFS%%C1(1,1)=-ML_COEFS(1)
2470
681
C     Coefficient q(1)
2471
682
      GOLEM_COEFS%%C1(2,1)=-ML_COEFS(2)
2472
683
C     Coefficient q(2)
2473
684
      GOLEM_COEFS%%C1(3,1)=-ML_COEFS(3)
2474
685
C     Coefficient q(3)
2475
686
      GOLEM_COEFS%%C1(4,1)=-ML_COEFS(4)
2476
687
      END
2477
688
2478
689
      SUBROUTINE FILL_GOLEM_COEFFS_2(ML_COEFS,GOLEM_COEFS)
2479
690
      USE TENS_REC, ONLY: COEFF_TYPE_2
2480
691
      INCLUDE 'coef_specs.inc'
2481
692
      COMPLEX*16 ML_COEFS(0:LOOP_MAXCOEFS-1)
2482
693
      TYPE(COEFF_TYPE_2) GOLEM_COEFS
2483
694
C     Constant coefficient 
2484
695
      GOLEM_COEFS%%C0=ML_COEFS(0)
2485
696
C     Coefficient q(0)
2486
697
      GOLEM_COEFS%%C1(1,1)=-ML_COEFS(1)
2487
698
C     Coefficient q(0)^2
2488
699
      GOLEM_COEFS%%C1(1,2)= ML_COEFS(5)
2489
700
C     Coefficient q(1)
2490
701
      GOLEM_COEFS%%C1(2,1)=-ML_COEFS(2)
2491
702
C     Coefficient q(1)^2
2492
703
      GOLEM_COEFS%%C1(2,2)= ML_COEFS(7)
2493
704
C     Coefficient q(2)
2494
705
      GOLEM_COEFS%%C1(3,1)=-ML_COEFS(3)
2495
706
C     Coefficient q(2)^2
2496
707
      GOLEM_COEFS%%C1(3,2)= ML_COEFS(10)
2497
708
C     Coefficient q(3)
2498
709
      GOLEM_COEFS%%C1(4,1)=-ML_COEFS(4)
2499
710
C     Coefficient q(3)^2
2500
711
      GOLEM_COEFS%%C1(4,2)= ML_COEFS(14)
2501
712
C     Coefficient q(0)*q(1)
2502
713
      GOLEM_COEFS%%C2(1,1)= ML_COEFS(6)
2503
714
C     Coefficient q(0)*q(2)
2504
715
      GOLEM_COEFS%%C2(2,1)= ML_COEFS(8)
2505
716
C     Coefficient q(0)*q(3)
2506
717
      GOLEM_COEFS%%C2(3,1)= ML_COEFS(11)
2507
718
C     Coefficient q(1)*q(2)
2508
719
      GOLEM_COEFS%%C2(4,1)= ML_COEFS(9)
2509
720
C     Coefficient q(1)*q(3)
2510
721
      GOLEM_COEFS%%C2(5,1)= ML_COEFS(12)
2511
722
C     Coefficient q(2)*q(3)
2512
723
      GOLEM_COEFS%%C2(6,1)= ML_COEFS(13)
2513
724
      END
2514
725
2515
726
      SUBROUTINE FILL_GOLEM_COEFFS_3(ML_COEFS,GOLEM_COEFS)
2516
727
      USE TENS_REC, ONLY: COEFF_TYPE_3
2517
728
      INCLUDE 'coef_specs.inc'
2518
729
      COMPLEX*16 ML_COEFS(0:LOOP_MAXCOEFS-1)
2519
730
      TYPE(COEFF_TYPE_3) GOLEM_COEFS
2520
731
C     Dummy routine for FILL_GOLEM_COEFS_3
2521
732
      STOP 'ERROR: 3 > 2'
2522
733
      END
2523
734
2524
735
      SUBROUTINE FILL_GOLEM_COEFFS_4(ML_COEFS,GOLEM_COEFS)
2525
736
      USE TENS_REC, ONLY: COEFF_TYPE_4
2526
737
      INCLUDE 'coef_specs.inc'
2527
738
      COMPLEX*16 ML_COEFS(0:LOOP_MAXCOEFS-1)
2528
739
      TYPE(COEFF_TYPE_4) GOLEM_COEFS
2529
740
C     Dummy routine for FILL_GOLEM_COEFS_4
2530
741
      STOP 'ERROR: 4 > 2'
2531
742
      END
2532
743
2533
744
      SUBROUTINE FILL_GOLEM_COEFFS_5(ML_COEFS,GOLEM_COEFS)
2534
745
      USE TENS_REC, ONLY: COEFF_TYPE_5
2535
746
      INCLUDE 'coef_specs.inc'
2536
747
      COMPLEX*16 ML_COEFS(0:LOOP_MAXCOEFS-1)
2537
748
      TYPE(COEFF_TYPE_5) GOLEM_COEFS
2538
749
C     Dummy routine for FILL_GOLEM_COEFS_5
2539
750
      STOP 'ERROR: 5 > 2'
2540
751
      END
2541
752
2542
753
      SUBROUTINE FILL_GOLEM_COEFFS_6(ML_COEFS,GOLEM_COEFS)
2543
754
      USE TENS_REC, ONLY: COEFF_TYPE_6
2544
755
      INCLUDE 'coef_specs.inc'
2545
756
      COMPLEX*16 ML_COEFS(0:LOOP_MAXCOEFS-1)
2546
757
      TYPE(COEFF_TYPE_6) GOLEM_COEFS
2547
758
C     Dummy routine for FILL_GOLEM_COEFS_6
2548
759
      STOP 'ERROR: 6 > 2'
2549
760
      END
2550
0
761
2551
=== added file 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%TIR_interface.f'
2552
--- tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%TIR_interface.f	1970-01-01 00:00:00 +0000
2553
+++ tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%TIR_interface.f	2016-02-24 13:54:50 +0000
2554
@@ -0,0 +1,423 @@
2555
1
      SUBROUTINE TIRLOOP(I_SQSO,I_LOOPGROUP,I_LIB,NLOOPLINE,PL,M2L
2556
2
     $ ,RANK,RES,STABLE)
2557
3
C     
2558
4
C     Generated by MadGraph5_aMC@NLO v. %(version)s, %(date)s
2559
5
C     By the MadGraph5_aMC@NLO Development Team
2560
6
C     Visit launchpad.net/madgraph5 and amcatnlo.web.cern.ch
2561
7
C     
2562
8
C     Interface between MG5 and TIR.
2563
9
C     
2564
10
C     Process: d~ u > w+ WEIGHTED=2 QED=1 [ all = QCD ]
2565
11
C     Process: s~ c > w+ WEIGHTED=2 QED=1 [ all = QCD ]
2566
12
C     
2567
13
C     
2568
14
C     CONSTANTS 
2569
15
C     
2570
16
      INTEGER NLOOPGROUPS
2571
17
      PARAMETER (NLOOPGROUPS=1)
2572
18
C     These are constants related to the split orders
2573
19
      INTEGER NSQUAREDSO
2574
20
      PARAMETER (NSQUAREDSO=1)
2575
21
      INTEGER LOOPMAXCOEFS
2576
22
      PARAMETER (LOOPMAXCOEFS=15)
2577
23
      INTEGER    NEXTERNAL
2578
24
      PARAMETER (NEXTERNAL=3)
2579
25
      LOGICAL CHECKPCONSERVATION
2580
26
      PARAMETER (CHECKPCONSERVATION=.TRUE.)
2581
27
      REAL*8 NORMALIZATION
2582
28
      PARAMETER (NORMALIZATION = 1.D0/(16.D0*3.14159265358979323846D0*
2583
29
     $ *2))
2584
30
C     
2585
31
C     ARGUMENTS 
2586
32
C     
2587
33
      INTEGER I_SQSO,I_LOOPGROUP,I_LIB
2588
34
      INTEGER NLOOPLINE, RANK
2589
35
      REAL*8 PL(0:3,NLOOPLINE)
2590
36
      REAL*8 PCT(0:3,0:NLOOPLINE-1)
2591
37
      REAL*8 PDEN(0:3,NLOOPLINE-1)
2592
38
      COMPLEX*16 M2L(NLOOPLINE)
2593
39
      COMPLEX*16 M2LCT(0:NLOOPLINE-1)
2594
40
      COMPLEX*16 RES(3)
2595
41
      LOGICAL STABLE
2596
42
C     
2597
43
C     LOCAL VARIABLES 
2598
44
C     
2599
45
      INTEGER I, J, K
2600
46
      INTEGER NLOOPCOEFS
2601
47
      LOGICAL CTINIT, TIRINIT, GOLEMINIT
2602
48
      COMMON/REDUCTIONCODEINIT/CTINIT,TIRINIT,GOLEMINIT
2603
49
2604
50
C     This variable will be used to detect changes in the TIR library
2605
51
C      used so as to force the reset of the TIR filter.
2606
52
      INTEGER LAST_LIB_USED
2607
53
      DATA LAST_LIB_USED/-1/
2608
54
2609
55
      COMPLEX*16 TIRCOEFS(0:LOOPMAXCOEFS-1,3)
2610
56
      COMPLEX*16 PJCOEFS(0:LOOPMAXCOEFS-1,3)
2611
57
C     
2612
58
C     EXTERNAL FUNCTIONS
2613
59
C     
2614
60
C     
2615
61
C     GLOBAL VARIABLES
2616
62
C     
2617
63
      INCLUDE 'MadLoopParams.inc'
2618
64
      INCLUDE 'coupl.inc'
2619
65
      INTEGER CTMODE
2620
66
      REAL*8 LSCALE
2621
67
      COMMON/CT/LSCALE,CTMODE
2622
68
2623
69
C     The argument ILIB is the TIR library to be used for that
2624
70
C      specific library.
2625
71
      INTEGER LIBINDEX
2626
72
      COMMON/I_LIB/LIBINDEX
2627
73
2628
74
      COMPLEX*16 LOOPCOEFS(0:LOOPMAXCOEFS-1,NSQUAREDSO,NLOOPGROUPS)
2629
75
      COMMON/LCOEFS/LOOPCOEFS
2630
76
C     ----------
2631
77
C     BEGIN CODE
2632
78
C     ----------
2633
79
2634
80
C     Initialize for the very first time ML is called LAST_ILIB with
2635
81
C      the first ILIB used.
2636
82
      IF(LAST_LIB_USED.EQ.-1) THEN
2637
83
        LAST_LIB_USED = MLREDUCTIONLIB(LIBINDEX)
2638
84
      ELSE
2639
85
C       We changed the TIR library so we must refresh the cache.
2640
86
        IF(MLREDUCTIONLIB(LIBINDEX).NE.LAST_LIB_USED) THEN
2641
87
          LAST_LIB_USED = MLREDUCTIONLIB(LIBINDEX)
2642
88
          CALL CLEAR_TIR_CACHE()
2643
89
        ENDIF
2644
90
      ENDIF
2645
91
2646
92
      IF (MLREDUCTIONLIB(I_LIB).EQ.4) THEN
2647
93
C       Using Golem95
2648
94
C       PDEN is dummy for Golem95 so we just initialize it to zero
2649
95
C        here so as to use it for the function SWITCHORDER
2650
96
        DO I=0,3
2651
97
          DO J=1,NLOOPLINE-1
2652
98
            PDEN(I,J)=0.0D0
2653
99
          ENDDO
2654
100
        ENDDO
2655
101
        CALL SWITCH_ORDER(CTMODE,NLOOPLINE,PL,PDEN,M2L)
2656
102
        CALL GOLEMLOOP(NLOOPLINE,PL,M2L,RANK,RES,STABLE)
2657
103
        RETURN
2658
104
      ENDIF
2659
105
2660
106
C     INITIALIZE TIR IF NEEDED
2661
107
      IF (TIRINIT) THEN
2662
108
        TIRINIT=.FALSE.
2663
109
        CALL INITTIR()
2664
110
      ENDIF
2665
111
2666
112
C     CONVERT THE MASSES TO BE COMPLEX
2667
113
      DO I=1,NLOOPLINE
2668
114
        M2LCT(I-1)=M2L(I)
2669
115
      ENDDO
2670
116
2671
117
C     CONVERT THE MOMENTA FLOWING IN THE LOOP LINES TO CT CONVENTIONS
2672
118
      DO I=0,3
2673
119
        DO J=0,(NLOOPLINE-1)
2674
120
          PCT(I,J)=0.D0
2675
121
        ENDDO
2676
122
      ENDDO
2677
123
      DO I=0,3
2678
124
        DO J=1,NLOOPLINE
2679
125
          PCT(I,0)=PCT(I,0)+PL(I,J)
2680
126
        ENDDO
2681
127
      ENDDO
2682
128
      IF (CHECKPCONSERVATION) THEN
2683
129
        IF (PCT(0,0).GT.1.D-6) THEN
2684
130
          WRITE(*,*) 'energy is not conserved ',PCT(0,0)
2685
131
          STOP 'energy is not conserved'
2686
132
        ELSEIF (PCT(1,0).GT.1.D-6) THEN
2687
133
          WRITE(*,*) 'px is not conserved ',PCT(1,0)
2688
134
          STOP 'px is not conserved'
2689
135
        ELSEIF (PCT(2,0).GT.1.D-6) THEN
2690
136
          WRITE(*,*) 'py is not conserved ',PCT(2,0)
2691
137
          STOP 'py is not conserved'
2692
138
        ELSEIF (PCT(3,0).GT.1.D-6) THEN
2693
139
          WRITE(*,*) 'pz is not conserved ',PCT(3,0)
2694
140
          STOP 'pz is not conserved'
2695
141
        ENDIF
2696
142
      ENDIF
2697
143
      DO I=0,3
2698
144
        DO J=1,(NLOOPLINE-1)
2699
145
          DO K=1,J
2700
146
            PCT(I,J)=PCT(I,J)+PL(I,K)
2701
147
          ENDDO
2702
148
        ENDDO
2703
149
      ENDDO
2704
150
2705
151
      DO I=0,3
2706
152
        DO J=1,(NLOOPLINE-1)
2707
153
          PDEN(I,J)=PCT(I,J)
2708
154
        ENDDO
2709
155
      ENDDO
2710
156
C     NUMBER OF INDEPEDENT LOOPCOEFS FOR RANK=RANK
2711
157
      NLOOPCOEFS=0
2712
158
      DO I=0,RANK
2713
159
        NLOOPCOEFS=NLOOPCOEFS+(3+I)*(2+I)*(1+I)/6
2714
160
      ENDDO
2715
161
      SELECT CASE(MLREDUCTIONLIB(I_LIB))
2716
162
      CASE(2)
2717
163
C     PJFry++
2718
164
      WRITE(*,*) 'ERROR:: PJFRY++ is not interfaced.'
2719
165
      STOP
2720
166
      CASE(3)
2721
167
C     IREGI
2722
168
      CALL IMLOOP(CTMODE,IREGIMODE,NLOOPLINE,LOOPMAXCOEFS,RANK,PDEN
2723
169
     $ ,M2L,MU_R,PJCOEFS,STABLE)
2724
170
C     CONVERT TO MADLOOP CONVENTION
2725
171
      CALL CONVERT_IREGI_COEFFS(RANK,PJCOEFS,TIRCOEFS)
2726
172
      END SELECT
2727
173
      DO I=1,3
2728
174
        RES(I)=(0.0D0,0.0D0)
2729
175
        DO J=0,NLOOPCOEFS-1
2730
176
          RES(I)=RES(I)+LOOPCOEFS(J,I_SQSO,I_LOOPGROUP)*TIRCOEFS(J,I)
2731
177
        ENDDO
2732
178
      ENDDO
2733
179
      RES(1)=NORMALIZATION*2.0D0*DBLE(RES(1))
2734
180
      RES(2)=NORMALIZATION*2.0D0*DBLE(RES(2))
2735
181
      RES(3)=NORMALIZATION*2.0D0*DBLE(RES(3))
2736
182
C     WRITE(*,*) 'Loop ID',ID,' =',RES(1),RES(2),RES(3)
2737
183
      END
2738
184
2739
185
      SUBROUTINE SWITCH_ORDER(CTMODE,NLOOPLINE,PL,PDEN,M2L)
2740
186
      IMPLICIT NONE
2741
187
2742
188
      INTEGER CTMODE,NLOOPLINE
2743
189
2744
190
      REAL*8 PL(0:3,NLOOPLINE)
2745
191
      REAL*8 PDEN(0:3,NLOOPLINE-1)
2746
192
      COMPLEX*16 M2L(NLOOPLINE)
2747
193
      REAL*8 NEW_PL(0:3,NLOOPLINE)
2748
194
      REAL*8 NEW_PDEN(0:3,NLOOPLINE-1)
2749
195
      COMPLEX*16 NEW_M2L(NLOOPLINE)
2750
196
2751
197
      INTEGER I,J,K
2752
198
2753
199
      IF (CTMODE.NE.2.AND.CTMODE.NE.4) THEN
2754
200
        RETURN
2755
201
      ENDIF
2756
202
2757
203
      IF (NLOOPLINE.LE.2) THEN
2758
204
        RETURN
2759
205
      ENDIF
2760
206
2761
207
      DO I=1,NLOOPLINE-1
2762
208
        DO J=0,3
2763
209
          NEW_PDEN(J,NLOOPLINE-I) = PDEN(J,I)
2764
210
        ENDDO
2765
211
      ENDDO
2766
212
      DO I=1,NLOOPLINE-1
2767
213
        DO J=0,3
2768
214
          PDEN(J,I) = NEW_PDEN(J,I)
2769
215
        ENDDO
2770
216
      ENDDO
2771
217
2772
218
      DO I=2,NLOOPLINE
2773
219
        NEW_M2L(I)=M2L(NLOOPLINE-I+2)
2774
220
      ENDDO
2775
221
      DO I=2,NLOOPLINE
2776
222
        M2L(I)=NEW_M2L(I)
2777
223
      ENDDO
2778
224
2779
225
2780
226
      DO I=1,NLOOPLINE
2781
227
        DO J=0,3
2782
228
          NEW_PL(J,I) = -PL(J,NLOOPLINE+1-I)
2783
229
        ENDDO
2784
230
      ENDDO
2785
231
      DO I=1,NLOOPLINE
2786
232
        DO J=0,3
2787
233
          PL(J,I) = NEW_PL(J,I)
2788
234
        ENDDO
2789
235
      ENDDO
2790
236
2791
237
      END
2792
238
2793
239
      SUBROUTINE INITTIR()
2794
240
C     
2795
241
C     INITIALISATION OF TIR
2796
242
C     
2797
243
C     LOCAL VARIABLES 
2798
244
C     
2799
245
      REAL*8 THRS
2800
246
      LOGICAL EXT_NUM_FOR_R1
2801
247
C     
2802
248
C     GLOBAL VARIABLES 
2803
249
C     
2804
250
      INCLUDE 'MadLoopParams.inc'
2805
251
      LOGICAL CTINIT, TIRINIT, GOLEMINIT
2806
252
      COMMON/REDUCTIONCODEINIT/CTINIT,TIRINIT,GOLEMINIT
2807
253
2808
254
C     ----------
2809
255
C     BEGIN CODE
2810
256
C     ----------
2811
257
2812
258
C     DEFAULT PARAMETERS FOR TIR
2813
259
C     -------------------------------  
2814
260
C     THRS1 IS THE PRECISION LIMIT BELOW WHICH THE MP ROUTINES
2815
261
C      ACTIVATES
2816
262
C     USE THE SAME MADLOOP PARAMETER IN CUTTOOLS AND TIR
2817
263
C     IT IS NECESSARY TO INITIALIZE CT BECAUSE IREGI USES THE VERSION
2818
264
C      OF ONELOOP
2819
265
C     FROM CUTTOOLS LIBRARY
2820
266
      THRS=CTSTABTHRES
2821
267
C     LOOPLIB SET WHAT LIBRARY CT USES
2822
268
C     1 -> LOOPTOOLS
2823
269
C     2 -> AVH
2824
270
C     3 -> QCDLOOP
2825
271
      LOOPLIB=CTLOOPLIBRARY
2826
272
      CALL INITIREGI(IREGIRECY,LOOPLIB,1D-6)
2827
273
C     The initialization below is for CT v1.9.2+
2828
274
      IF (CTINIT) THEN
2829
275
        CTINIT=.FALSE.
2830
276
        CALL INITCT()
2831
277
      ENDIF
2832
278
      END
2833
279
2834
280
      SUBROUTINE CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS
2835
281
     $ ,DOING_QP,I_LIB)
2836
282
C     
2837
283
C     CHOOSE THE CORRECT LOOP LIB
2838
284
C     Example:
2839
285
C     MLReductionLib=3|2|1 and LIBINDEX=3
2840
286
C     IF THE LOOP IS BEYOND THE SCOPE OF LOOP LIB MLReductionLib(3)=1
2841
287
C     USE LIBINDEX=1, and LIBINDEX=2 ...
2842
288
C     IF IT IS STILL NOT GOOD,STOP
2843
289
C     
2844
290
      IMPLICIT NONE
2845
291
C     
2846
292
C     CONSTANTS
2847
293
C     
2848
294
      INTEGER NLOOPLIB,QP_NLOOPLIB
2849
295
      PARAMETER (NLOOPLIB=4,QP_NLOOPLIB=1)
2850
296
C     
2851
297
C     ARGUMENTS
2852
298
C     
2853
299
      INTEGER LIBINDEX,NLOOPLINE,RANK,I_LIB
2854
300
      LOGICAL COMPLEX_MASS,DOING_QP
2855
301
C     
2856
302
C     LOCAL VARIABLES
2857
303
C     
2858
304
      INTEGER I,J_LIB,LIBNUM,SELECT_LIBINDEX
2859
305
      LOGICAL LPASS
2860
306
C     
2861
307
C     GLOBAL VARIABLES
2862
308
C     
2863
309
      INCLUDE 'MadLoopParams.inc'
2864
310
C     TILL NOW, ONLY CUTTOOLS PROVIDE QP
2865
311
      LOGICAL QP_TOOLS_AVAILABLE
2866
312
      INTEGER INDEX_QP_TOOLS(QP_NLOOPLIB)
2867
313
      COMMON/LOOP_TOOLS/QP_TOOLS_AVAILABLE,INDEX_QP_TOOLS
2868
314
C     ----------
2869
315
C     BEGIN CODE
2870
316
C     ----------
2871
317
2872
318
      IF(DOING_QP)THEN
2873
319
C       QP EVALUATION, ONLY CUTTOOLS
2874
320
        IF(.NOT.QP_TOOLS_AVAILABLE)THEN
2875
321
          STOP 'No qp tools available, please make sure MLReductionLi'
2876
322
     $     //'b is correct'
2877
323
        ENDIF
2878
324
        J_LIB=0
2879
325
        SELECT_LIBINDEX=LIBINDEX
2880
326
        DO WHILE(J_LIB.EQ.0)
2881
327
          DO I=1,QP_NLOOPLIB
2882
328
            IF(INDEX_QP_TOOLS(I).EQ.SELECT_LIBINDEX)THEN
2883
329
              J_LIB=I
2884
330
              EXIT
2885
331
            ENDIF
2886
332
          ENDDO
2887
333
          IF(J_LIB.EQ.0)THEN
2888
334
            SELECT_LIBINDEX=SELECT_LIBINDEX+1
2889
335
            IF(SELECT_LIBINDEX.GT.NLOOPLIB.OR.MLREDUCTIONLIB(SELECT_LIB
2890
336
     $       INDEX).EQ.0)SELECT_LIBINDEX=1
2891
337
          ENDIF
2892
338
        ENDDO
2893
339
        I=J_LIB
2894
340
        I_LIB=SELECT_LIBINDEX
2895
341
        LIBNUM=MLREDUCTIONLIB(I_LIB)
2896
342
        DO
2897
343
        CALL DETECT_LOOPLIB(LIBNUM,NLOOPLINE,RANK,COMPLEX_MASS,LPASS)
2898
344
        IF(LPASS)EXIT
2899
345
        I=I+1
2900
346
        IF(I.GT.QP_NLOOPLIB.AND.INDEX_QP_TOOLS(I).EQ.0)THEN
2901
347
          I=1
2902
348
        ENDIF
2903
349
        IF(I.EQ.J_LIB)THEN
2904
350
          STOP 'No qp loop library can deal with this integral'
2905
351
        ENDIF
2906
352
        I_LIB=INDEX_QP_TOOLS(I)
2907
353
        LIBNUM=MLREDUCTIONLIB(I_LIB)
2908
354
        ENDDO
2909
355
      ELSE
2910
356
C       DP EVALUATION
2911
357
        I_LIB=LIBINDEX
2912
358
        LIBNUM=MLREDUCTIONLIB(I_LIB)
2913
359
        DO
2914
360
        CALL DETECT_LOOPLIB(LIBNUM,NLOOPLINE,RANK,COMPLEX_MASS,LPASS)
2915
361
        IF(LPASS)EXIT
2916
362
        I_LIB=I_LIB+1
2917
363
        IF(I_LIB.GT.NLOOPLIB.OR.MLREDUCTIONLIB(I_LIB).EQ.0)THEN
2918
364
          I_LIB=1
2919
365
        ENDIF
2920
366
        IF(I_LIB.EQ.LIBINDEX)THEN
2921
367
          STOP 'No dp loop library can deal with this integral'
2922
368
        ENDIF
2923
369
        LIBNUM=MLREDUCTIONLIB(I_LIB)
2924
370
        ENDDO
2925
371
      ENDIF
2926
372
      RETURN
2927
373
      END
2928
374
2929
375
      SUBROUTINE CLEAR_TIR_CACHE()
2930
376
C     No TIR caching implemented, this is dummy. (The subroutine is
2931
377
C      kept as it might be called by the MC).
2932
378
      CONTINUE
2933
379
      END SUBROUTINE
2934
380
2935
381
2936
382
2937
383
      SUBROUTINE CONVERT_IREGI_COEFFS(RANK,IREGICOEFS,TIRCOEFS)
2938
384
C     GLOABLE VARIABLES
2939
385
      INCLUDE 'coef_specs.inc'
2940
386
C     ARGUMENTS
2941
387
      INTEGER RANK
2942
388
      COMPLEX*16 IREGICOEFS(0:LOOP_MAXCOEFS-1,3)
2943
389
      COMPLEX*16 TIRCOEFS(0:LOOP_MAXCOEFS-1,3)
2944
390
C     Reduction Coefficient 1
2945
391
      TIRCOEFS(0,1:3)=IREGICOEFS(0,1:3)
2946
392
      IF(RANK.LE.0)RETURN
2947
393
C     Reduction Coefficient q(0)
2948
394
      TIRCOEFS(1,1:3)=IREGICOEFS(1,1:3)
2949
395
C     Reduction Coefficient q(1)
2950
396
      TIRCOEFS(2,1:3)=IREGICOEFS(2,1:3)
2951
397
C     Reduction Coefficient q(2)
2952
398
      TIRCOEFS(3,1:3)=IREGICOEFS(3,1:3)
2953
399
C     Reduction Coefficient q(3)
2954
400
      TIRCOEFS(4,1:3)=IREGICOEFS(4,1:3)
2955
401
      IF(RANK.LE.1)RETURN
2956
402
C     Reduction Coefficient q(0)^2
2957
403
      TIRCOEFS(5,1:3)=IREGICOEFS(5,1:3)
2958
404
C     Reduction Coefficient q(0)*q(1)
2959
405
      TIRCOEFS(6,1:3)=IREGICOEFS(6,1:3)
2960
406
C     Reduction Coefficient q(1)^2
2961
407
      TIRCOEFS(7,1:3)=IREGICOEFS(9,1:3)
2962
408
C     Reduction Coefficient q(0)*q(2)
2963
409
      TIRCOEFS(8,1:3)=IREGICOEFS(7,1:3)
2964
410
C     Reduction Coefficient q(1)*q(2)
2965
411
      TIRCOEFS(9,1:3)=IREGICOEFS(10,1:3)
2966
412
C     Reduction Coefficient q(2)^2
2967
413
      TIRCOEFS(10,1:3)=IREGICOEFS(12,1:3)
2968
414
C     Reduction Coefficient q(0)*q(3)
2969
415
      TIRCOEFS(11,1:3)=IREGICOEFS(8,1:3)
2970
416
C     Reduction Coefficient q(1)*q(3)
2971
417
      TIRCOEFS(12,1:3)=IREGICOEFS(11,1:3)
2972
418
C     Reduction Coefficient q(2)*q(3)
2973
419
      TIRCOEFS(13,1:3)=IREGICOEFS(13,1:3)
2974
420
C     Reduction Coefficient q(3)^2
2975
421
      TIRCOEFS(14,1:3)=IREGICOEFS(14,1:3)
2976
422
      IF(RANK.LE.2)RETURN
2977
423
      END
2978
0
424
2979
=== added file 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%born_matrix.f'
2980
--- tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%born_matrix.f	1970-01-01 00:00:00 +0000
2981
+++ tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%born_matrix.f	2016-02-24 13:54:50 +0000
2982
@@ -0,0 +1,540 @@
2983
1
      SUBROUTINE SMATRIX(P,ANS_SUMMED)
2984
2
C     
2985
3
C     Simple routine wrapper to provide the same interface for
2986
4
C     backward compatibility for usage without split orders.
2987
5
C     
2988
6
C     
2989
7
C     CONSTANTS
2990
8
C     
2991
9
      INTEGER    NEXTERNAL
2992
10
      PARAMETER (NEXTERNAL=3)
2993
11
      INTEGER NSQAMPSO
2994
12
      PARAMETER (NSQAMPSO=1)
2995
13
C     
2996
14
C     ARGUMENTS 
2997
15
C     
2998
16
      REAL*8 P(0:3,NEXTERNAL), ANS_SUMMED
2999
17
C     
3000
18
C     VARIABLES
3001
19
C     
3002
20
      INTEGER I
3003
21
      REAL*8 ANS(0:NSQAMPSO)
3004
22
C     
3005
23
C     BEGIN CODE
3006
24
C     
3007
25
      CALL SMATRIX_SPLITORDERS(P,ANS)
3008
26
      ANS_SUMMED=ANS(0)
3009
27
3010
28
      END
3011
29
3012
30
      SUBROUTINE SMATRIXHEL(P,HEL,ANS)
3013
31
      IMPLICIT NONE
3014
32
C     
3015
33
C     CONSTANT
3016
34
C     
3017
35
      INTEGER    NEXTERNAL
3018
36
      PARAMETER (NEXTERNAL=3)
3019
37
      INTEGER                 NCOMB
3020
38
      PARAMETER (             NCOMB=12)
3021
39
C     
3022
40
C     ARGUMENTS 
3023
41
C     
3024
42
      REAL*8 P(0:3,NEXTERNAL),ANS
3025
43
      INTEGER HEL
3026
44
C     
3027
45
C     GLOBAL VARIABLES
3028
46
C     
3029
47
      INTEGER USERHEL
3030
48
      COMMON/HELUSERCHOICE/USERHEL
3031
49
C     ----------
3032
50
C     BEGIN CODE
3033
51
C     ----------
3034
52
      USERHEL=HEL
3035
53
      CALL SMATRIX(P,ANS)
3036
54
      USERHEL=-1
3037
55
3038
56
      END
3039
57
3040
58
      SUBROUTINE SMATRIX_SPLITORDERS(P,ANS)
3041
59
C     
3042
60
C     Generated by MadGraph5_aMC@NLO v. %(version)s, %(date)s
3043
61
C     By the MadGraph5_aMC@NLO Development Team
3044
62
C     Visit launchpad.net/madgraph5 and amcatnlo.web.cern.ch
3045
63
C     
3046
64
C     MadGraph StandAlone Version
3047
65
C     
3048
66
C     Returns amplitude squared summed/avg over colors
3049
67
C     and helicities
3050
68
C     for the point in phase space P(0:3,NEXTERNAL)
3051
69
C     
3052
70
C     Process: d~ u > w+ WEIGHTED=2 QED=1 [ all = QCD ]
3053
71
C     Process: s~ c > w+ WEIGHTED=2 QED=1 [ all = QCD ]
3054
72
C     
3055
73
      IMPLICIT NONE
3056
74
C     
3057
75
C     CONSTANTS
3058
76
C     
3059
77
      INTEGER    NEXTERNAL
3060
78
      PARAMETER (NEXTERNAL=3)
3061
79
      INTEGER                 NCOMB
3062
80
      PARAMETER (             NCOMB=12)
3063
81
      INTEGER NSQAMPSO
3064
82
      PARAMETER (NSQAMPSO=1)
3065
83
      INTEGER HELAVGFACTOR
3066
84
      PARAMETER (HELAVGFACTOR=4)
3067
85
      LOGICAL CHOSEN_SO_CONFIGS(NSQAMPSO)
3068
86
      DATA CHOSEN_SO_CONFIGS/.TRUE./
3069
87
      COMMON/CHOSEN_BORN_SQSO/CHOSEN_SO_CONFIGS
3070
88
C     
3071
89
C     ARGUMENTS 
3072
90
C     
3073
91
      REAL*8 P(0:3,NEXTERNAL),ANS(0:NSQAMPSO)
3074
92
C     
3075
93
C     LOCAL VARIABLES 
3076
94
C     
3077
95
      INTEGER NHEL(NEXTERNAL,NCOMB),NTRY
3078
96
      REAL*8 T(NSQAMPSO), BUFF
3079
97
      INTEGER IHEL,IDEN, I
3080
98
      INTEGER JC(NEXTERNAL)
3081
99
      LOGICAL GOODHEL(NCOMB)
3082
100
      DATA NTRY/0/
3083
101
      DATA GOODHEL/NCOMB*.FALSE./
3084
102
      DATA (NHEL(I,   1),I=1,3) /-1, 1,-1/
3085
103
      DATA (NHEL(I,   2),I=1,3) /-1, 1, 0/
3086
104
      DATA (NHEL(I,   3),I=1,3) /-1, 1, 1/
3087
105
      DATA (NHEL(I,   4),I=1,3) /-1,-1,-1/
3088
106
      DATA (NHEL(I,   5),I=1,3) /-1,-1, 0/
3089
107
      DATA (NHEL(I,   6),I=1,3) /-1,-1, 1/
3090
108
      DATA (NHEL(I,   7),I=1,3) / 1, 1,-1/
3091
109
      DATA (NHEL(I,   8),I=1,3) / 1, 1, 0/
3092
110
      DATA (NHEL(I,   9),I=1,3) / 1, 1, 1/
3093
111
      DATA (NHEL(I,  10),I=1,3) / 1,-1,-1/
3094
112
      DATA (NHEL(I,  11),I=1,3) / 1,-1, 0/
3095
113
      DATA (NHEL(I,  12),I=1,3) / 1,-1, 1/
3096
114
      DATA IDEN/36/
3097
115
C     
3098
116
C     GLOBAL VARIABLES
3099
117
C     
3100
118
      INTEGER USERHEL
3101
119
      DATA USERHEL/-1/
3102
120
      COMMON/HELUSERCHOICE/USERHEL
3103
121
3104
122
C     ----------
3105
123
C     BEGIN CODE
3106
124
C     ----------
3107
125
      NTRY=NTRY+1
3108
126
      DO IHEL=1,NEXTERNAL
3109
127
        JC(IHEL) = +1
3110
128
      ENDDO
3111
129
      DO I=1,NSQAMPSO
3112
130
        ANS(I) = 0D0
3113
131
      ENDDO
3114
132
      DO IHEL=1,NCOMB
3115
133
        IF (USERHEL.EQ.-1.OR.USERHEL.EQ.IHEL) THEN
3116
134
          IF (GOODHEL(IHEL) .OR. NTRY .LT. 2 .OR.USERHEL.NE.-1) THEN
3117
135
            CALL MATRIX(P ,NHEL(1,IHEL),JC(1), T)
3118
136
            BUFF=0D0
3119
137
            DO I=1,NSQAMPSO
3120
138
              ANS(I)=ANS(I)+T(I)
3121
139
              BUFF=BUFF+T(I)
3122
140
            ENDDO
3123
141
            IF (BUFF .NE. 0D0 .AND. .NOT.    GOODHEL(IHEL)) THEN
3124
142
              GOODHEL(IHEL)=.TRUE.
3125
143
            ENDIF
3126
144
          ENDIF
3127
145
        ENDIF
3128
146
      ENDDO
3129
147
      ANS(0)=0.0D0
3130
148
      DO I=1,NSQAMPSO
3131
149
        ANS(I)=ANS(I)/DBLE(IDEN)
3132
150
        IF (CHOSEN_SO_CONFIGS(I)) THEN
3133
151
          ANS(0)=ANS(0)+ANS(I)
3134
152
        ENDIF
3135
153
      ENDDO
3136
154
      IF(USERHEL.NE.-1) THEN
3137
155
        ANS(0)=ANS(0)*HELAVGFACTOR
3138
156
        DO I=1,NSQAMPSO
3139
157
          ANS(I)=ANS(I)*HELAVGFACTOR
3140
158
        ENDDO
3141
159
      ENDIF
3142
160
      END
3143
161
3144
162
      SUBROUTINE SMATRIXHEL_SPLITORDERS(P,HEL,ANS)
3145
163
      IMPLICIT NONE
3146
164
C     
3147
165
C     CONSTANT
3148
166
C     
3149
167
      INTEGER    NEXTERNAL
3150
168
      PARAMETER (NEXTERNAL=3)
3151
169
      INTEGER                 NCOMB
3152
170
      PARAMETER (             NCOMB=12)
3153
171
      INTEGER NSQAMPSO
3154
172
      PARAMETER (NSQAMPSO=1)
3155
173
C     
3156
174
C     ARGUMENTS 
3157
175
C     
3158
176
      REAL*8 P(0:3,NEXTERNAL),ANS(0:NSQAMPSO)
3159
177
      INTEGER HEL
3160
178
C     
3161
179
C     GLOBAL VARIABLES
3162
180
C     
3163
181
      INTEGER USERHEL
3164
182
      COMMON/HELUSERCHOICE/USERHEL
3165
183
C     ----------
3166
184
C     BEGIN CODE
3167
185
C     ----------
3168
186
      USERHEL=HEL
3169
187
      CALL SMATRIX_SPLITORDERS(P,ANS)
3170
188
      USERHEL=-1
3171
189
3172
190
      END
3173
191
3174
192
      SUBROUTINE MATRIX(P,NHEL,IC,RES)
3175
193
C     
3176
194
C     Generated by MadGraph5_aMC@NLO v. %(version)s, %(date)s
3177
195
C     By the MadGraph5_aMC@NLO Development Team
3178
196
C     Visit launchpad.net/madgraph5 and amcatnlo.web.cern.ch
3179
197
C     
3180
198
C     Returns amplitude squared summed/avg over colors
3181
199
C     for the point with external lines W(0:6,NEXTERNAL)
3182
200
C     
3183
201
C     Process: d~ u > w+ WEIGHTED=2 QED=1 [ all = QCD ]
3184
202
C     Process: s~ c > w+ WEIGHTED=2 QED=1 [ all = QCD ]
3185
203
C     
3186
204
      IMPLICIT NONE
3187
205
C     
3188
206
C     CONSTANTS
3189
207
C     
3190
208
      INTEGER    NGRAPHS
3191
209
      PARAMETER (NGRAPHS=1)
3192
210
      INTEGER    NEXTERNAL
3193
211
      PARAMETER (NEXTERNAL=3)
3194
212
      INTEGER    NWAVEFUNCS, NCOLOR
3195
213
      PARAMETER (NWAVEFUNCS=3, NCOLOR=1)
3196
214
      INTEGER NAMPSO, NSQAMPSO
3197
215
      PARAMETER (NAMPSO=1, NSQAMPSO=1)
3198
216
      REAL*8     ZERO
3199
217
      PARAMETER (ZERO=0D0)
3200
218
      COMPLEX*16 IMAG1
3201
219
      PARAMETER (IMAG1=(0D0,1D0))
3202
220
C     
3203
221
C     ARGUMENTS 
3204
222
C     
3205
223
      REAL*8 P(0:3,NEXTERNAL)
3206
224
      INTEGER NHEL(NEXTERNAL), IC(NEXTERNAL)
3207
225
      REAL*8 RES(NSQAMPSO)
3208
226
C     
3209
227
C     LOCAL VARIABLES 
3210
228
C     
3211
229
      INTEGER I,J,M,N
3212
230
      COMPLEX*16 ZTEMP
3213
231
      REAL*8 DENOM(NCOLOR), CF(NCOLOR,NCOLOR)
3214
232
      COMPLEX*16 AMP(NGRAPHS)
3215
233
      COMPLEX*16 JAMP(NCOLOR,NAMPSO)
3216
234
      COMPLEX*16 W(20,NWAVEFUNCS)
3217
235
      COMPLEX*16 DUM0,DUM1
3218
236
      DATA DUM0, DUM1/(0D0, 0D0), (1D0, 0D0)/
3219
237
C     
3220
238
C     FUNCTION
3221
239
C     
3222
240
      INTEGER SQSOINDEX
3223
241
C     
3224
242
C     GLOBAL VARIABLES
3225
243
C     
3226
244
      INCLUDE 'coupl.inc'
3227
245
C     
3228
246
C     COLOR DATA
3229
247
C     
3230
248
      DATA DENOM(1)/1/
3231
249
      DATA (CF(I,  1),I=  1,  1) /    3/
3232
250
C     1 T(1,2)
3233
251
C     ----------
3234
252
C     BEGIN CODE
3235
253
C     ----------
3236
254
      CALL OXXXXX(P(0,1),ZERO,NHEL(1),-1*IC(1),W(1,1))
3237
255
      CALL IXXXXX(P(0,2),ZERO,NHEL(2),+1*IC(2),W(1,2))
3238
256
      CALL VXXXXX(P(0,3),MDL_MW,NHEL(3),+1*IC(3),W(1,3))
3239
257
C     Amplitude(s) for diagram number 1
3240
258
      CALL FFV2_0(W(1,2),W(1,1),W(1,3),GC_47,AMP(1))
3241
259
C     JAMPs contributing to orders QCD=0
3242
260
      JAMP(1,1)=-AMP(1)
3243
261
3244
262
      RES = 0.D0
3245
263
      DO M = 1, NAMPSO
3246
264
        DO I = 1, NCOLOR
3247
265
          ZTEMP = (0.D0,0.D0)
3248
266
          DO J = 1, NCOLOR
3249
267
            ZTEMP = ZTEMP + CF(J,I)*JAMP(J,M)
3250
268
          ENDDO
3251
269
          DO N = 1, NAMPSO
3252
270
            RES(SQSOINDEX(M,N)) = RES(SQSOINDEX(M,N)) + ZTEMP
3253
271
     $       *DCONJG(JAMP(I,N))/DENOM(I)
3254
272
          ENDDO
3255
273
        ENDDO
3256
274
      ENDDO
3257
275
3258
276
      END
3259
277
3260
278
      SUBROUTINE GET_ME(P, ALPHAS, NHEL ,ANS)
3261
279
      IMPLICIT NONE
3262
280
C     
3263
281
C     CONSTANT
3264
282
C     
3265
283
      INTEGER    NEXTERNAL
3266
284
      PARAMETER (NEXTERNAL=3)
3267
285
C     
3268
286
C     ARGUMENTS 
3269
287
C     
3270
288
      REAL*8 P(0:3,NEXTERNAL),ANS
3271
289
      INTEGER NHEL
3272
290
      DOUBLE PRECISION ALPHAS
3273
291
      REAL*8 PI
3274
292
CF2PY INTENT(OUT) :: ANS
3275
293
CF2PY INTENT(IN) :: NHEL
3276
294
CF2PY INTENT(IN) :: P(0:3,NEXTERNAL)
3277
295
CF2PY INTENT(IN) :: ALPHAS
3278
296
C     ROUTINE FOR F2PY to read the benchmark point.    
3279
297
C     the include file with the values of the parameters and masses 
3280
298
      INCLUDE 'coupl.inc'
3281
299
3282
300
      PI = 3.141592653589793D0
3283
301
      G = 2* DSQRT(ALPHAS*PI)
3284
302
      CALL UPDATE_AS_PARAM()
3285
303
      IF (NHEL.NE.0) THEN
3286
304
        CALL SMATRIXHEL(P, NHEL, ANS)
3287
305
      ELSE
3288
306
        CALL SMATRIX(P, ANS)
3289
307
      ENDIF
3290
308
      RETURN
3291
309
      END
3292
310
3293
311
      SUBROUTINE INITIALISE(PATH)
3294
312
C     ROUTINE FOR F2PY to read the benchmark point.    
3295
313
      IMPLICIT NONE
3296
314
      CHARACTER*180 PATH
3297
315
CF2PY INTENT(IN) :: PATH
3298
316
      CALL SETPARA(PATH)  !first call to setup the paramaters    
3299
317
      RETURN
3300
318
      END
3301
319
3302
320
3303
321
C     Set of functions to handle the array indices of the split orders
3304
322
3305
323
3306
324
      INTEGER FUNCTION SQSOINDEX(ORDERINDEXA, ORDERINDEXB)
3307
325
C     
3308
326
C     This functions plays the role of the interference matrix. It can
3309
327
C      be hardcoded or 
3310
328
C     made more elegant using hashtables if its execution speed ever
3311
329
C      becomes a relevant
3312
330
C     factor. From two split order indices, it return the corresponding
3313
331
C      index in the squared 
3314
332
C     order canonical ordering.
3315
333
C     
3316
334
C     CONSTANTS
3317
335
C     
3318
336
3319
337
      INTEGER    NSO, NSQUAREDSO, NAMPSO
3320
338
      PARAMETER (NSO=1, NSQUAREDSO=1, NAMPSO=1)
3321
339
C     
3322
340
C     ARGUMENTS
3323
341
C     
3324
342
      INTEGER ORDERINDEXA, ORDERINDEXB
3325
343
C     
3326
344
C     LOCAL VARIABLES
3327
345
C     
3328
346
      INTEGER I, SQORDERS(NSO)
3329
347
      INTEGER AMPSPLITORDERS(NAMPSO,NSO)
3330
348
      DATA (AMPSPLITORDERS(  1,I),I=  1,  1) /    0/
3331
349
      COMMON/AMPSPLITORDERS/AMPSPLITORDERS
3332
350
C     
3333
351
C     FUNCTION
3334
352
C     
3335
353
      INTEGER SOINDEX_FOR_SQUARED_ORDERS
3336
354
C     
3337
355
C     BEGIN CODE
3338
356
C     
3339
357
      DO I=1,NSO
3340
358
        SQORDERS(I)=AMPSPLITORDERS(ORDERINDEXA,I)+AMPSPLITORDERS(ORDERI
3341
359
     $   NDEXB,I)
3342
360
      ENDDO
3343
361
      SQSOINDEX=SOINDEX_FOR_SQUARED_ORDERS(SQORDERS)
3344
362
      END
3345
363
3346
364
      INTEGER FUNCTION SOINDEX_FOR_SQUARED_ORDERS(ORDERS)
3347
365
C     
3348
366
C     This functions returns the integer index identifying the squared
3349
367
C      split orders list passed in argument which corresponds to the
3350
368
C      values of the following list of couplings (and in this order).
3351
369
C     ['QCD']
3352
370
C     
3353
371
C     CONSTANTS
3354
372
C     
3355
373
      INTEGER    NSO, NSQSO, NAMPSO
3356
374
      PARAMETER (NSO=1, NSQSO=1, NAMPSO=1)
3357
375
C     
3358
376
C     ARGUMENTS
3359
377
C     
3360
378
      INTEGER ORDERS(NSO)
3361
379
C     
3362
380
C     LOCAL VARIABLES
3363
381
C     
3364
382
      INTEGER I,J
3365
383
      INTEGER SQSPLITORDERS(NSQSO,NSO)
3366
384
      DATA (SQSPLITORDERS(  1,I),I=  1,  1) /    0/
3367
385
      COMMON/SQPLITORDERS/SQPLITORDERS
3368
386
C     
3369
387
C     BEGIN CODE
3370
388
C     
3371
389
      DO I=1,NSQSO
3372
390
        DO J=1,NSO
3373
391
          IF (ORDERS(J).NE.SQSPLITORDERS(I,J)) GOTO 1009
3374
392
        ENDDO
3375
393
        SOINDEX_FOR_SQUARED_ORDERS = I
3376
394
        RETURN
3377
395
 1009   CONTINUE
3378
396
      ENDDO
3379
397
3380
398
      WRITE(*,*) 'ERROR:: Stopping in function'
3381
399
      WRITE(*,*) 'SOINDEX_FOR_SQUARED_ORDERS'
3382
400
      WRITE(*,*) 'Could not find squared orders ',(ORDERS(I),I=1,NSO)
3383
401
      STOP
3384
402
3385
403
      END
3386
404
3387
405
      SUBROUTINE GET_NSQSO_BORN(NSQSO)
3388
406
C     
3389
407
C     Simple subroutine returning the number of squared split order
3390
408
C     contributions returned when calling smatrix_split_orders 
3391
409
C     
3392
410
3393
411
      INTEGER    NSQUAREDSO
3394
412
      PARAMETER  (NSQUAREDSO=1)
3395
413
3396
414
      INTEGER NSQSO
3397
415
3398
416
      NSQSO=NSQUAREDSO
3399
417
3400
418
      END
3401
419
3402
420
C     This is the inverse subroutine of SOINDEX_FOR_SQUARED_ORDERS.
3403
421
C      Not directly useful, but provided nonetheless.
3404
422
      SUBROUTINE GET_SQUARED_ORDERS_FOR_SOINDEX(SOINDEX,ORDERS)
3405
423
C     
3406
424
C     This functions returns the orders identified by the squared
3407
425
C      split order index in argument. Order values correspond to
3408
426
C      following list of couplings (and in this order):
3409
427
C     ['QCD']
3410
428
C     
3411
429
C     CONSTANTS
3412
430
C     
3413
431
      INTEGER    NSO, NSQSO
3414
432
      PARAMETER (NSO=1, NSQSO=1)
3415
433
C     
3416
434
C     ARGUMENTS
3417
435
C     
3418
436
      INTEGER SOINDEX, ORDERS(NSO)
3419
437
C     
3420
438
C     LOCAL VARIABLES
3421
439
C     
3422
440
      INTEGER I
3423
441
      INTEGER SQPLITORDERS(NSQSO,NSO)
3424
442
      COMMON/SQPLITORDERS/SQPLITORDERS
3425
443
C     
3426
444
C     BEGIN CODE
3427
445
C     
3428
446
      IF (SOINDEX.GT.0.AND.SOINDEX.LE.NSQSO) THEN
3429
447
        DO I=1,NSO
3430
448
          ORDERS(I) =  SQPLITORDERS(SOINDEX,I)
3431
449
        ENDDO
3432
450
        RETURN
3433
451
      ENDIF
3434
452
3435
453
      WRITE(*,*) 'ERROR:: Stopping function GET_SQUARED_ORDERS_FOR_SOI'
3436
454
     $ //'NDEX'
3437
455
      WRITE(*,*) 'Could not find squared orders index ',SOINDEX
3438
456
      STOP
3439
457
3440
458
      END SUBROUTINE
3441
459
3442
460
C     This is the inverse subroutine of getting amplitude SO orders.
3443
461
C      Not directly useful, but provided nonetheless.
3444
462
      SUBROUTINE GET_ORDERS_FOR_AMPSOINDEX(SOINDEX,ORDERS)
3445
463
C     
3446
464
C     This functions returns the orders identified by the split order
3447
465
C      index in argument. Order values correspond to following list of
3448
466
C      couplings (and in this order):
3449
467
C     ['QCD']
3450
468
C     
3451
469
C     CONSTANTS
3452
470
C     
3453
471
      INTEGER    NSO, NAMPSO
3454
472
      PARAMETER (NSO=1, NAMPSO=1)
3455
473
C     
3456
474
C     ARGUMENTS
3457
475
C     
3458
476
      INTEGER SOINDEX, ORDERS(NSO)
3459
477
C     
3460
478
C     LOCAL VARIABLES
3461
479
C     
3462
480
      INTEGER I
3463
481
      INTEGER AMPSPLITORDERS(NAMPSO,NSO)
3464
482
      COMMON/AMPSPLITORDERS/AMPSPLITORDERS
3465
483
C     
3466
484
C     BEGIN CODE
3467
485
C     
3468
486
      IF (SOINDEX.GT.0.AND.SOINDEX.LE.NAMPSO) THEN
3469
487
        DO I=1,NSO
3470
488
          ORDERS(I) =  AMPSPLITORDERS(SOINDEX,I)
3471
489
        ENDDO
3472
490
        RETURN
3473
491
      ENDIF
3474
492
3475
493
      WRITE(*,*) 'ERROR:: Stopping function GET_ORDERS_FOR_AMPSOINDEX'
3476
494
      WRITE(*,*) 'Could not find amplitude split orders index ',SOINDEX
3477
495
      STOP
3478
496
3479
497
      END SUBROUTINE
3480
498
3481
499
C     This function is not directly useful, but included for completene
3482
500
C     ss
3483
501
      INTEGER FUNCTION SOINDEX_FOR_AMPORDERS(ORDERS)
3484
502
C     
3485
503
C     This functions returns the integer index identifying the
3486
504
C      amplitude split orders passed in argument which correspond to
3487
505
C      the values of the following list of couplings (and in this
3488
506
C      order):
3489
507
C     ['QCD']
3490
508
C     
3491
509
C     CONSTANTS
3492
510
C     
3493
511
      INTEGER    NSO, NAMPSO
3494
512
      PARAMETER (NSO=1, NAMPSO=1)
3495
513
C     
3496
514
C     ARGUMENTS
3497
515
C     
3498
516
      INTEGER ORDERS(NSO)
3499
517
C     
3500
518
C     LOCAL VARIABLES
3501
519
C     
3502
520
      INTEGER I,J
3503
521
      INTEGER AMPSPLITORDERS(NAMPSO,NSO)
3504
522
      COMMON/AMPSPLITORDERS/AMPSPLITORDERS
3505
523
C     
3506
524
C     BEGIN CODE
3507
525
C     
3508
526
      DO I=1,NAMPSO
3509
527
        DO J=1,NSO
3510
528
          IF (ORDERS(J).NE.AMPSPLITORDERS(I,J)) GOTO 1009
3511
529
        ENDDO
3512
530
        SOINDEX_FOR_AMPORDERS = I
3513
531
        RETURN
3514
532
 1009   CONTINUE
3515
533
      ENDDO
3516
534
3517
535
      WRITE(*,*) 'ERROR:: Stopping function SOINDEX_FOR_AMPORDERS'
3518
536
      WRITE(*,*) 'Could not find squared orders ',(ORDERS(I),I=1,NSO)
3519
537
      STOP
3520
538
3521
539
      END
3522
540
3523
0
541
3524
=== added file 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%check_sa.f'
3525
--- tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%check_sa.f	1970-01-01 00:00:00 +0000
3526
+++ tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%check_sa.f	2016-02-24 13:54:50 +0000
3527
@@ -0,0 +1,756 @@
3528
1
      PROGRAM DRIVER
3529
2
C     *****************************************************************
3530
3
C     ********
3531
4
C     THIS IS THE DRIVER FOR CHECKING THE STANDALONE MATRIX ELEMENT.
3532
5
C     IT USES A SIMPLE PHASE SPACE GENERATOR
3533
6
C     *****************************************************************
3534
7
C     ********
3535
8
      IMPLICIT NONE
3536
9
C     
3537
10
C     CONSTANTS  
3538
11
C     
3539
12
      REAL*8 ZERO
3540
13
      PARAMETER (ZERO=0D0)
3541
14
3542
15
      LOGICAL READPS
3543
16
      PARAMETER (READPS = .FALSE.)
3544
17
3545
18
      INTEGER NPSPOINTS
3546
19
      PARAMETER (NPSPOINTS = 4)
3547
20
3548
21
C     integer nexternal and number particles (incoming+outgoing) in
3549
22
C      the me 
3550
23
      INTEGER NEXTERNAL, NINCOMING
3551
24
      PARAMETER (NEXTERNAL=3,NINCOMING=2)
3552
25
3553
26
      CHARACTER(512) MADLOOPRESOURCEPATH
3554
27
3555
28
C     
3556
29
C     INCLUDE FILES
3557
30
C     
3558
31
C     the include file with the values of the parameters and masses   
3559
32
C        
3560
33
      INCLUDE 'coupl.inc'
3561
34
C     particle masses
3562
35
      REAL*8 PMASS(NEXTERNAL)
3563
36
C     integer    n_max_cg
3564
37
      INCLUDE 'ngraphs.inc'
3565
38
      INCLUDE 'nsqso_born.inc'
3566
39
      INCLUDE 'nsquaredSO.inc'
3567
40
3568
41
C     
3569
42
C     LOCAL
3570
43
C     
3571
44
      INTEGER I,J,K
3572
45
C     four momenta. Energy is the zeroth component.
3573
46
      REAL*8 P(0:3,NEXTERNAL)
3574
47
      INTEGER MATELEM_ARRAY_DIM
3575
48
      REAL*8 , ALLOCATABLE :: MATELEM(:,:)
3576
49
      REAL*8 SQRTS,AO2PI,TOTMASS
3577
50
C     sqrt(s)= center of mass energy 
3578
51
      REAL*8 PIN(0:3), POUT(0:3)
3579
52
      CHARACTER*120 BUFF(NEXTERNAL)
3580
53
      INTEGER RETURNCODE, UNITS, TENS, HUNDREDS
3581
54
      INTEGER NSQUAREDSO_LOOP
3582
55
      REAL*8 , ALLOCATABLE :: PREC_FOUND(:)
3583
56
3584
57
C     
3585
58
C     GLOBAL VARIABLES
3586
59
C     
3587
60
C     This is from ML code for the list of split orders selected by
3588
61
C     the process definition
3589
62
C     
3590
63
      INTEGER NLOOPCHOSEN
3591
64
      CHARACTER*20 CHOSEN_LOOP_SO_INDICES(NSQUAREDSO)
3592
65
      LOGICAL CHOSEN_LOOP_SO_CONFIGS(NSQUAREDSO)
3593
66
      COMMON/CHOSEN_LOOP_SQSO/CHOSEN_LOOP_SO_CONFIGS
3594
67
      INTEGER NBORNCHOSEN
3595
68
      CHARACTER*20 CHOSEN_BORN_SO_INDICES(NSQSO_BORN)
3596
69
      LOGICAL CHOSEN_BORN_SO_CONFIGS(NSQSO_BORN)
3597
70
      COMMON/CHOSEN_BORN_SQSO/CHOSEN_BORN_SO_CONFIGS
3598
71
3599
72
C     
3600
73
C     SAVED VARIABLES
3601
74
C     
3602
75
      LOGICAL INIT
3603
76
      DATA INIT/.TRUE./
3604
77
      COMMON/INITCHECKSA/INIT
3605
78
C     
3606
79
C     EXTERNAL
3607
80
C     
3608
81
      REAL*8 DOT
3609
82
      EXTERNAL DOT
3610
83
3611
84
C     
3612
85
C     BEGIN CODE
3613
86
C     
3614
87
C     
3615
88
3616
89
      IF (INIT) THEN
3617
90
        INIT=.FALSE.
3618
91
        CALL GET_ANSWER_DIMENSION(MATELEM_ARRAY_DIM)
3619
92
        ALLOCATE(MATELEM(0:3,0:MATELEM_ARRAY_DIM))
3620
93
        CALL GET_NSQSO_LOOP(NSQUAREDSO_LOOP)
3621
94
        ALLOCATE(PREC_FOUND(0:NSQUAREDSO_LOOP))
3622
95
3623
96
C       INITIALIZATION CALLS
3624
97
C       
3625
98
C       Call to initialize the values of the couplings, masses and
3626
99
C        widths 
3627
100
C       used in the evaluation of the matrix element. The primary
3628
101
C        parameters of the
3629
102
C       models are read from Cards/param_card.dat. The secondary
3630
103
C        parameters are calculated
3631
104
C       in Source/MODEL/couplings.f. The values are stored in common
3632
105
C        blocks that are listed
3633
106
C       in coupl.inc .
3634
107
C       first call to setup the paramaters
3635
108
        CALL SETPARA('param_card.dat')
3636
109
C       set up masses
3637
110
        INCLUDE 'pmass.inc'
3638
111
3639
112
      ENDIF
3640
113
3641
114
3642
115
C     Start by initializing what is the squared split orders indices
3643
116
C      chosen
3644
117
      NLOOPCHOSEN=0
3645
118
      DO I=1,NSQUAREDSO
3646
119
        IF (CHOSEN_LOOP_SO_CONFIGS(I)) THEN
3647
120
          NLOOPCHOSEN=NLOOPCHOSEN+1
3648
121
          WRITE(CHOSEN_LOOP_SO_INDICES(NLOOPCHOSEN),'(I3,A2)') I,'L)'
3649
122
        ENDIF
3650
123
      ENDDO
3651
124
      NBORNCHOSEN=0
3652
125
      DO I=1,NSQSO_BORN
3653
126
        IF (CHOSEN_BORN_SO_CONFIGS(I)) THEN
3654
127
          NBORNCHOSEN=NBORNCHOSEN+1
3655
128
          WRITE(CHOSEN_BORN_SO_INDICES(NBORNCHOSEN),'(I3,A2)') I,'B)'
3656
129
        ENDIF
3657
130
      ENDDO
3658
131
3659
132
      AO2PI=G**2/(8.D0*(3.14159265358979323846D0**2))
3660
133
3661
134
      WRITE(*,*) 'AO2PI=',AO2PI
3662
135
C     Now use a simple multipurpose PS generator (RAMBO) just to get a 
3663
136
C     RANDOM set of four momenta of given masses pmass(i) to be used
3664
137
C      to evaluate 
3665
138
C     the madgraph matrix-element.       
3666
139
C     Alternatevely, here the user can call or set the four momenta at
3667
140
C      his will, see below.
3668
141
C     
3669
142
      IF(NINCOMING.EQ.1) THEN
3670
143
        SQRTS=PMASS(1)
3671
144
      ELSE
3672
145
        TOTMASS = 0.0D0
3673
146
        DO I=1,NEXTERNAL
3674
147
          TOTMASS = TOTMASS + PMASS(I)
3675
148
        ENDDO
3676
149
C       CMS energy in GEV
3677
150
        SQRTS=MAX(1000D0,2.0D0*TOTMASS)
3678
151
      ENDIF
3679
152
3680
153
      CALL PRINTOUT()
3681
154
3682
155
3683
156
3684
157
      DO K=1,NPSPOINTS
3685
158
3686
159
        IF(READPS) THEN
3687
160
          OPEN(967, FILE='PS.input', ERR=976, STATUS='OLD', ACTION='RE'
3688
161
     $     //'AD')
3689
162
          DO I=1,NEXTERNAL
3690
163
            READ(967,*,END=978) P(0,I),P(1,I),P(2,I),P(3,I)
3691
164
          ENDDO
3692
165
          GOTO 978
3693
166
 976      CONTINUE
3694
167
          STOP 'Could not read the PS.input phase-space point.'
3695
168
 978      CONTINUE
3696
169
          CLOSE(967)
3697
170
        ELSE
3698
171
          IF ((NINCOMING.EQ.2).AND.((NEXTERNAL - NINCOMING .EQ.1))
3699
172
     $     ) THEN
3700
173
            IF (PMASS(3).EQ.0.0D0) THEN
3701
174
              STOP 'Cannot generate 2>1 kin. config. with m3=0.0d0'
3702
175
            ELSE
3703
176
C             deal with the case of only one particle in the final
3704
177
C              state
3705
178
              P(0,1) = PMASS(3)/2D0
3706
179
              P(1,1) = 0D0
3707
180
              P(2,1) = 0D0
3708
181
              P(3,1) = PMASS(3)/2D0
3709
182
              IF (PMASS(1).GT.0D0) THEN
3710
183
                P(3,1) = DSQRT(PMASS(3)**2/4D0 - PMASS(1)**2)
3711
184
              ENDIF
3712
185
              P(0,2) = PMASS(3)/2D0
3713
186
              P(1,2) = 0D0
3714
187
              P(2,2) = 0D0
3715
188
              P(3,2) = -PMASS(3)/2D0
3716
189
              IF (PMASS(2) > 0D0) THEN
3717
190
                P(3,2) = -DSQRT(PMASS(3)**2/4D0 - PMASS(1)**2)
3718
191
              ENDIF
3719
192
              P(0,3) = PMASS(3)
3720
193
              P(1,3) = 0D0
3721
194
              P(2,3) = 0D0
3722
195
              P(3,3) = 0D0
3723
196
            ENDIF
3724
197
          ELSE
3725
198
            CALL GET_MOMENTA(SQRTS,PMASS,P)
3726
199
          ENDIF
3727
200
        ENDIF
3728
201
3729
202
        DO I=0,3
3730
203
          PIN(I)=0.0D0
3731
204
          DO J=1,NINCOMING
3732
205
            PIN(I)=PIN(I)+P(I,J)
3733
206
          ENDDO
3734
207
        ENDDO
3735
208
3736
209
C       In standalone mode, always use sqrt_s as the renormalization
3737
210
C        scale.
3738
211
        SQRTS=DSQRT(DABS(DOT(PIN(0),PIN(0))))
3739
212
        MU_R=SQRTS
3740
213
3741
214
C       Update the couplings with the new MU_R
3742
215
        CALL UPDATE_AS_PARAM()
3743
216
3744
217
C       Optionally the user can set where to find the MadLoop5_resource
3745
218
C       s folder.
3746
219
C       Otherwise it will look for it automatically and find it if it
3747
220
C        has not
3748
221
C       been moved
3749
222
C       MadLoopResourcePath = '<MadLoop5_resources_path>'
3750
223
C       CALL SETMADLOOPPATH(MadLoopResourcePath)
3751
224
C       To force the stabiliy check to also be performed in the
3752
225
C        initialization phase
3753
226
C       CALL FORCE_STABILITY_CHECK(.TRUE.)
3754
227
C       To chose a particular tartget split order, SOTARGET is an
3755
228
C        integer labeling
3756
229
C       the possible squared order couplings contributions (only in
3757
230
C        optimized mode)
3758
231
C       CALL SET_COUPLINGORDERS_TARGET(SOTARGET)
3759
232
3760
233
3761
234
C       
3762
235
C       Now we can call the matrix element
3763
236
C       
3764
237
        CALL SLOOPMATRIX_THRES(P,MATELEM,-1.0D0,PREC_FOUND,RETURNCODE)
3765
238
3766
239
C       
3767
240
C       write the information on the four momenta 
3768
241
C       
3769
242
        IF (K.EQ.NPSPOINTS) THEN
3770
243
          WRITE (*,*)
3771
244
          WRITE (*,*) ' Phase space point:'
3772
245
          WRITE (*,*)
3773
246
          WRITE (*,*) '---------------------------------'
3774
247
          WRITE (*,*)  'n  E  px py pz m'
3775
248
          DO I=1,NEXTERNAL
3776
249
            WRITE (*,'(i2,1x,5e15.7)') I, P(0,I),P(1,I),P(2,I),P(3,I)
3777
250
     $       ,DSQRT(DABS(DOT(P(0,I),P(0,I))))
3778
251
          ENDDO
3779
252
          WRITE (*,*) '---------------------------------'
3780
253
          WRITE (*,*) 'Detailed result for each coupling order'
3781
254
     $     //'s combination.'
3782
255
          WRITE(*,*) 'All Born contributions are of split order'
3783
256
     $     //'s (QCD=0)'
3784
257
          WRITE (*,*) '---------------------------------'
3785
258
          WRITE(*,*) 'All loop contributions are of split order'
3786
259
     $     //'s (QCD=2)'
3787
260
          WRITE (*,*) '---------------------------------'
3788
261
          UNITS=MOD(RETURNCODE,10)
3789
262
          TENS=(MOD(RETURNCODE,100)-UNITS)/10
3790
263
          HUNDREDS=(RETURNCODE-TENS*10-UNITS)/100
3791
264
          IF (HUNDREDS.EQ.1) THEN
3792
265
            IF (TENS.EQ.3.OR.TENS.EQ.4) THEN
3793
266
              WRITE(*,*) 'Unknown numerical stability because MadLoo'
3794
267
     $         //'p is in the initialization stage.'
3795
268
            ELSE
3796
269
              WRITE(*,*) 'Unknown numerical stability, check CTModeRu'
3797
270
     $         //'n value in MadLoopParams.dat.'
3798
271
            ENDIF
3799
272
          ELSEIF (HUNDREDS.EQ.2) THEN
3800
273
            WRITE(*,*) 'Stable kinematic configuration (SPS).'
3801
274
          ELSEIF (HUNDREDS.EQ.3) THEN
3802
275
            WRITE(*,*) 'Unstable kinematic configuration (UPS).'
3803
276
            WRITE(*,*) 'Quadruple precision rescue successful.'
3804
277
          ELSEIF (HUNDREDS.EQ.4) THEN
3805
278
            WRITE(*,*) 'Exceptional kinematic configuration (EPS).'
3806
279
            WRITE(*,*) 'Both double an quadruple precision computation'
3807
280
     $       //'s, are unstable.'
3808
281
          ENDIF
3809
282
          IF (TENS.EQ.2.OR.TENS.EQ.4) THEN
3810
283
            WRITE(*,*) 'Quadruple precision computation used.'
3811
284
          ENDIF
3812
285
          IF (HUNDREDS.NE.1) THEN
3813
286
            IF (PREC_FOUND(0).GT.0.0D0) THEN
3814
287
              WRITE(*,'(1x,a23,1x,1e10.2)') 'Relative accuracy     ='
3815
288
     $         ,PREC_FOUND(0)
3816
289
            ELSEIF (PREC_FOUND(0).EQ.0.0D0) THEN
3817
290
              WRITE(*,'(1x,a23,1x,1e10.2,1x,a30)') 'Relative accuracy'
3818
291
     $         //'     =',PREC_FOUND(0),'(i.e. beyond double precisio'
3819
292
     $         //'n)'
3820
293
            ELSE
3821
294
              WRITE(*,*) 'Estimated accuracy could not be computed fo'
3822
295
     $         //'r an unknown reason.'
3823
296
            ENDIF
3824
297
          ENDIF
3825
298
          WRITE (*,*) '---------------------------------'
3826
299
          IF (NBORNCHOSEN.EQ.0) THEN
3827
300
            WRITE (*,*) 'No Born contribution satisfied the square'
3828
301
     $       //'d order constraints.'
3829
302
          ELSE IF (NBORNCHOSEN.NE.NSQSO_BORN) THEN
3830
303
            WRITE (*,*) 'Selected squared coupling orders combinatio'
3831
304
     $       //'n for the Born summed result below:'
3832
305
            WRITE (*,*) (CHOSEN_BORN_SO_INDICES(I),I=1,NBORNCHOSEN)
3833
306
          ENDIF
3834
307
          IF (NLOOPCHOSEN.NE.NSQUAREDSO) THEN
3835
308
            WRITE (*,*) 'Selected squared coupling orders combinatio'
3836
309
     $       //'n for the loop summed result below:'
3837
310
            WRITE (*,*) (CHOSEN_LOOP_SO_INDICES(I),I=1,NLOOPCHOSEN)
3838
311
          ENDIF
3839
312
          WRITE (*,*) '---------------------------------'
3840
313
          WRITE (*,*) 'Matrix element born   = ', MATELEM(0,0)
3841
314
     $     , ' GeV^',-(2*NEXTERNAL-8)
3842
315
          WRITE (*,*) 'Matrix element finite = ', MATELEM(1,0)
3843
316
     $     , ' GeV^',-(2*NEXTERNAL-8)
3844
317
          WRITE (*,*) 'Matrix element 1eps   = ', MATELEM(2,0)
3845
318
     $     , ' GeV^',-(2*NEXTERNAL-8)
3846
319
          WRITE (*,*) 'Matrix element 2eps   = ', MATELEM(3,0)
3847
320
     $     , ' GeV^',-(2*NEXTERNAL-8)
3848
321
          WRITE (*,*) '---------------------------------'
3849
322
          IF (MATELEM(0,0).NE.0.0D0) THEN
3850
323
            WRITE (*,*) 'finite / (born*ao2pi) = ', MATELEM(1,0)
3851
324
     $       /MATELEM(0,0)/AO2PI
3852
325
            WRITE (*,*) '1eps   / (born*ao2pi) = ', MATELEM(2,0)
3853
326
     $       /MATELEM(0,0)/AO2PI
3854
327
            WRITE (*,*) '2eps   / (born*ao2pi) = ', MATELEM(3,0)
3855
328
     $       /MATELEM(0,0)/AO2PI
3856
329
          ELSE
3857
330
            WRITE (*,*) 'finite / ao2pi      = ', MATELEM(1,0)/AO2PI
3858
331
            WRITE (*,*) '1eps   / ao2pi      = ', MATELEM(2,0)/AO2PI
3859
332
            WRITE (*,*) '2eps   / ao2pi      = ', MATELEM(3,0)/AO2PI
3860
333
          ENDIF
3861
334
          WRITE (*,*) '---------------------------------'
3862
335
3863
336
          OPEN(69, FILE='result.dat', ERR=976, ACTION='WRITE')
3864
337
          DO I=1,NEXTERNAL
3865
338
            WRITE (69,'(a2,1x,5e25.15)') 'PS',P(0,I),P(1,I),P(2,I),P(3
3866
339
     $       ,I)
3867
340
          ENDDO
3868
341
          WRITE (69,'(a3,1x,i2)') 'EXP',-(2*NEXTERNAL-8)
3869
342
          WRITE (69,'(a4,1x,1e25.15)') 'BORN',MATELEM(0,0)
3870
343
          IF (MATELEM(0,0).NE.0.0D0) THEN
3871
344
            WRITE (69,'(a3,1x,1e25.15)') 'FIN',MATELEM(1,0)/MATELEM(0
3872
345
     $       ,0)/AO2PI
3873
346
            WRITE (69,'(a4,1x,1e25.15)') '1EPS',MATELEM(2,0)/MATELEM(0
3874
347
     $       ,0)/AO2PI
3875
348
            WRITE (69,'(a4,1x,1e25.15)') '2EPS',MATELEM(3,0)/MATELEM(0
3876
349
     $       ,0)/AO2PI
3877
350
          ELSE
3878
351
            WRITE (69,'(a3,1x,1e25.15)') 'FIN',MATELEM(1,0)/AO2PI
3879
352
            WRITE (69,'(a4,1x,1e25.15)') '1EPS',MATELEM(2,0)/AO2PI
3880
353
            WRITE (69,'(a4,1x,1e25.15)') '2EPS',MATELEM(3,0)/AO2PI
3881
354
          ENDIF
3882
355
          WRITE (69,'(a6,1x,1e25.15)') 'ASO2PI',AO2PI
3883
356
          WRITE (69,*) 'Export_Format Default'
3884
357
          WRITE (69,'(a7,1x,i3)') 'RETCODE',RETURNCODE
3885
358
          WRITE (69,'(a3,1x,1e10.4)') 'ACC',PREC_FOUND(0)
3886
359
          WRITE (69,*) 'Born_kept',(CHOSEN_BORN_SO_CONFIGS(I),I=1
3887
360
     $     ,NSQSO_BORN)
3888
361
          WRITE (69,*) 'Loop_kept',(CHOSEN_LOOP_SO_CONFIGS(I),I=1
3889
362
     $     ,NSQUAREDSO)
3890
363
          WRITE (69,*) 'Born_SO_Results 0'
3891
364
          WRITE (69,*) 'SO_Born BORN ',MATELEM(0,1)
3892
365
          WRITE (69,*) 'Split_Orders_Names QCD'
3893
366
          WRITE (69,*) 'Loop_SO_Results 2'
3894
367
          WRITE (69,*) 'SO_Loop ACC  ',PREC_FOUND(1)
3895
368
          WRITE (69,*) 'SO_Loop FIN  ',MATELEM(1,1)
3896
369
          WRITE (69,*) 'SO_Loop 1EPS ',MATELEM(2,1)
3897
370
          WRITE (69,*) 'SO_Loop 2EPS ',MATELEM(3,1)
3898
371
          CLOSE(69)
3899
372
        ELSE
3900
373
          WRITE (*,*) 'PS Point #',K,' done.'
3901
374
        ENDIF
3902
375
      ENDDO
3903
376
3904
377
C     C
3905
378
C     C      Copy down here (or read in) the four momenta as a string. 
3906
379
C     C      
3907
380
C     C
3908
381
C     buff(1)=" 1   0.5630480E+04  0.0000000E+00  0.0000000E+00 
3909
382
C      0.5630480E+04"
3910
383
C     buff(2)=" 2   0.5630480E+04  0.0000000E+00  0.0000000E+00
3911
384
C      -0.5630480E+04"
3912
385
C     buff(3)=" 3   0.5466073E+04  0.4443190E+03  0.2446331E+04
3913
386
C      -0.4864732E+04"
3914
387
C     buff(4)=" 4   0.8785819E+03 -0.2533886E+03  0.2741971E+03 
3915
388
C      0.7759741E+03"
3916
389
C     buff(5)=" 5   0.4916306E+04 -0.1909305E+03 -0.2720528E+04 
3917
390
C      0.4088757E+04"
3918
391
C     C
3919
392
C     C      Here the k,E,px,py,pz are read from the string into the
3920
393
C      momenta array.
3921
394
C     C      k=1,2          : incoming
3922
395
C     C      k=3,nexternal  : outgoing
3923
396
C     C
3924
397
C     do i=1,nexternal
3925
398
C     read (buff(i),*) k, P(0,i),P(1,i),P(2,i),P(3,i)
3926
399
C     enddo
3927
400
C     
3928
401
C     C print the momenta out
3929
402
C     
3930
403
C     do i=1,nexternal
3931
404
C     write (*,'(i2,1x,5e15.7)') i, P(0,i),P(1,i),P(2,i),P(3,i), 
3932
405
C     &dsqrt(dabs(DOT(p(0,i),p(0,i))))
3933
406
C     enddo
3934
407
C     
3935
408
C     CALL SLOOPMATRIX(P,MATELEM)
3936
409
C     
3937
410
C     write (*,*) "-------------------------------------------------"
3938
411
C     write (*,*) "Matrix element = ", MATELEM(1), " GeV^",-(2*nexterna
3939
412
C     l-8)      
3940
413
C     write (*,*) "-------------------------------------------------"
3941
414
3942
415
      DEALLOCATE(MATELEM)
3943
416
      DEALLOCATE(PREC_FOUND)
3944
417
3945
418
      END
3946
419
3947
420
3948
421
3949
422
3950
423
      DOUBLE PRECISION FUNCTION DOT(P1,P2)
3951
424
C     *************************************************************
3952
425
C     4-Vector Dot product
3953
426
C     *************************************************************
3954
427
      IMPLICIT NONE
3955
428
      DOUBLE PRECISION P1(0:3),P2(0:3)
3956
429
      DOT=P1(0)*P2(0)-P1(1)*P2(1)-P1(2)*P2(2)-P1(3)*P2(3)
3957
430
      END
3958
431
3959
432
3960
433
      SUBROUTINE GET_MOMENTA(ENERGY,PMASS,P)
3961
434
C     auxiliary function to change convention between madgraph and
3962
435
C      rambo
3963
436
C     four momenta.         
3964
437
      IMPLICIT NONE
3965
438
      INTEGER NEXTERNAL, NINCOMING
3966
439
      PARAMETER (NEXTERNAL=3,NINCOMING=2)
3967
440
C     ARGUMENTS
3968
441
      REAL*8 ENERGY,PMASS(NEXTERNAL),P(0:3,NEXTERNAL),PRAMBO(4,10),WGT
3969
442
C     LOCAL
3970
443
      INTEGER I
3971
444
      REAL*8 ETOT2,MOM,M1,M2,E1,E2
3972
445
3973
446
      ETOT2=ENERGY**2
3974
447
      M1=PMASS(1)
3975
448
      M2=PMASS(2)
3976
449
      MOM=(ETOT2**2 - 2*ETOT2*M1**2 + M1**4 - 2*ETOT2*M2**2 - 2*M1**2
3977
450
     $ *M2**2 + M2**4)/(4.*ETOT2)
3978
451
      MOM=DSQRT(MOM)
3979
452
      E1=DSQRT(MOM**2+M1**2)
3980
453
      E2=DSQRT(MOM**2+M2**2)
3981
454
C     write (*,*) e1+e2,mom
3982
455
3983
456
      IF(NINCOMING.EQ.2) THEN
3984
457
3985
458
        P(0,1)=E1
3986
459
        P(1,1)=0D0
3987
460
        P(2,1)=0D0
3988
461
        P(3,1)=MOM
3989
462
3990
463
        P(0,2)=E2
3991
464
        P(1,2)=0D0
3992
465
        P(2,2)=0D0
3993
466
        P(3,2)=-MOM
3994
467
3995
468
        CALL RAMBO(NEXTERNAL-2,ENERGY,PMASS(3),PRAMBO,WGT)
3996
469
        DO I=3, NEXTERNAL
3997
470
          P(0,I)=PRAMBO(4,I-2)
3998
471
          P(1,I)=PRAMBO(1,I-2)
3999
472
          P(2,I)=PRAMBO(2,I-2)
4000
473
          P(3,I)=PRAMBO(3,I-2)
4001
474
        ENDDO
4002
475
4003
476
      ELSEIF(NINCOMING.EQ.1) THEN
4004
477
4005
478
        P(0,1)=ENERGY
4006
479
        P(1,1)=0D0
4007
480
        P(2,1)=0D0
4008
481
        P(3,1)=0D0
4009
482
4010
483
        CALL RAMBO(NEXTERNAL-1,ENERGY,PMASS(2),PRAMBO,WGT)
4011
484
        DO I=2, NEXTERNAL
4012
485
          P(0,I)=PRAMBO(4,I-1)
4013
486
          P(1,I)=PRAMBO(1,I-1)
4014
487
          P(2,I)=PRAMBO(2,I-1)
4015
488
          P(3,I)=PRAMBO(3,I-1)
4016
489
        ENDDO
4017
490
      ENDIF
4018
491
4019
492
      RETURN
4020
493
      END
4021
494
4022
495
4023
496
      SUBROUTINE RAMBO(N,ET,XM,P,WT)
4024
497
C     *****************************************************************
4025
498
C     *****
4026
499
C     RAMBO                                         *
4027
500
C     RA(NDOM)  M(OMENTA)  B(EAUTIFULLY)  O(RGANIZED)                 
4028
501
C      *
4029
502
C     *
4030
503
C     A DEMOCRATIC MULTI-PARTICLE PHASE SPACE GENERATOR               
4031
504
C      *
4032
505
C     AUTHORS:  S.D. ELLIS,  R. KLEISS,  W.J. STIRLING                
4033
506
C      *
4034
507
C     THIS IS VERSION 1.0 -  WRITTEN BY R. KLEISS                     
4035
508
C      *
4036
509
C     -- ADJUSTED BY HANS KUIJF, WEIGHTS ARE LOGARITHMIC (20-08-90)   
4037
510
C      *
4038
511
C     *
4039
512
C     N  = NUMBER OF PARTICLES                                        
4040
513
C      *
4041
514
C     ET = TOTAL CENTRE-OF-MASS ENERGY                                
4042
515
C      *
4043
516
C     XM = PARTICLE MASSES ( DIM=NEXTERNAL-nincoming )                
4044
517
C      *
4045
518
C     P  = PARTICLE MOMENTA ( DIM=(4,NEXTERNAL-nincoming) )           
4046
519
C      *
4047
520
C     WT = WEIGHT OF THE EVENT                                        
4048
521
C      *
4049
522
C     *****************************************************************
4050
523
C     *****
4051
524
      IMPLICIT REAL*8(A-H,O-Z)
4052
525
      INTEGER NEXTERNAL, NINCOMING
4053
526
      PARAMETER (NEXTERNAL=3,NINCOMING=2)
4054
527
      DIMENSION XM(NEXTERNAL-NINCOMING),P(4,NEXTERNAL-NINCOMING)
4055
528
      DIMENSION Q(4,NEXTERNAL-NINCOMING),Z(NEXTERNAL-NINCOMING),R(4)
4056
529
     $ ,B(3),P2(NEXTERNAL-NINCOMING),XM2(NEXTERNAL-NINCOMING)
4057
530
     $ ,E(NEXTERNAL-NINCOMING),V(NEXTERNAL-NINCOMING),IWARN(5)
4058
531
      SAVE ACC,ITMAX,IBEGIN,IWARN
4059
532
      DATA ACC/1.D-14/,ITMAX/6/,IBEGIN/0/,IWARN/5*0/
4060
533
C     
4061
534
C     INITIALIZATION STEP: FACTORIALS FOR THE PHASE SPACE WEIGHT
4062
535
      IF(IBEGIN.NE.0) GOTO 103
4063
536
      IBEGIN=1
4064
537
      TWOPI=8.*DATAN(1.D0)
4065
538
      PO2LOG=LOG(TWOPI/4.)
4066
539
      Z(2)=PO2LOG
4067
540
      DO 101 K=3,(NEXTERNAL-NINCOMING)
4068
541
 101  Z(K)=Z(K-1)+PO2LOG-2.*LOG(DFLOAT(K-2))
4069
542
      DO 102 K=3,(NEXTERNAL-NINCOMING)
4070
543
 102  Z(K)=(Z(K)-LOG(DFLOAT(K-1)))
4071
544
C     
4072
545
C     CHECK ON THE NUMBER OF PARTICLES
4073
546
 103  IF(N.GT.1.AND.N.LT.101) GOTO 104
4074
547
      PRINT 1001,N
4075
548
      STOP
4076
549
C     
4077
550
C     CHECK WHETHER TOTAL ENERGY IS SUFFICIENT; COUNT NONZERO MASSES
4078
551
 104  XMT=0.
4079
552
      NM=0
4080
553
      DO 105 I=1,N
4081
554
      IF(XM(I).NE.0.D0) NM=NM+1
4082
555
 105  XMT=XMT+ABS(XM(I))
4083
556
      IF(XMT.LE.ET) GOTO 201
4084
557
      PRINT 1002,XMT,ET
4085
558
      STOP
4086
559
C     
4087
560
C     THE PARAMETER VALUES ARE NOW ACCEPTED
4088
561
C     
4089
562
C     GENERATE N MASSLESS MOMENTA IN INFINITE PHASE SPACE
4090
563
 201  DO 202 I=1,N
4091
564
      R1=RN(1)
4092
565
      C=2.*R1-1.
4093
566
      S=SQRT(1.-C*C)
4094
567
      F=TWOPI*RN(2)
4095
568
      R1=RN(3)
4096
569
      R2=RN(4)
4097
570
      Q(4,I)=-LOG(R1*R2)
4098
571
      Q(3,I)=Q(4,I)*C
4099
572
      Q(2,I)=Q(4,I)*S*COS(F)
4100
573
 202  Q(1,I)=Q(4,I)*S*SIN(F)
4101
574
C     
4102
575
C     CALCULATE THE PARAMETERS OF THE CONFORMAL TRANSFORMATION
4103
576
      DO 203 I=1,4
4104
577
 203  R(I)=0.
4105
578
      DO 204 I=1,N
4106
579
      DO 204 K=1,4
4107
580
 204  R(K)=R(K)+Q(K,I)
4108
581
      RMAS=SQRT(R(4)**2-R(3)**2-R(2)**2-R(1)**2)
4109
582
      DO 205 K=1,3
4110
583
 205  B(K)=-R(K)/RMAS
4111
584
      G=R(4)/RMAS
4112
585
      A=1./(1.+G)
4113
586
      X=ET/RMAS
4114
587
C     
4115
588
C     TRANSFORM THE Q'S CONFORMALLY INTO THE P'S
4116
589
      DO 207 I=1,N
4117
590
      BQ=B(1)*Q(1,I)+B(2)*Q(2,I)+B(3)*Q(3,I)
4118
591
      DO 206 K=1,3
4119
592
 206  P(K,I)=X*(Q(K,I)+B(K)*(Q(4,I)+A*BQ))
4120
593
 207  P(4,I)=X*(G*Q(4,I)+BQ)
4121
594
C     
4122
595
C     CALCULATE WEIGHT AND POSSIBLE WARNINGS
4123
596
      WT=PO2LOG
4124
597
      IF(N.NE.2) WT=(2.*N-4.)*LOG(ET)+Z(N)
4125
598
      IF(WT.GE.-180.D0) GOTO 208
4126
599
      IF(IWARN(1).LE.5) PRINT 1004,WT
4127
600
      IWARN(1)=IWARN(1)+1
4128
601
 208  IF(WT.LE. 174.D0) GOTO 209
4129
602
      IF(IWARN(2).LE.5) PRINT 1005,WT
4130
603
      IWARN(2)=IWARN(2)+1
4131
604
C     
4132
605
C     RETURN FOR WEIGHTED MASSLESS MOMENTA
4133
606
 209  IF(NM.NE.0) GOTO 210
4134
607
C     RETURN LOG OF WEIGHT
4135
608
      WT=WT
4136
609
      RETURN
4137
610
C     
4138
611
C     MASSIVE PARTICLES: RESCALE THE MOMENTA BY A FACTOR X
4139
612
 210  XMAX=SQRT(1.-(XMT/ET)**2)
4140
613
      DO 301 I=1,N
4141
614
      XM2(I)=XM(I)**2
4142
615
 301  P2(I)=P(4,I)**2
4143
616
      ITER=0
4144
617
      X=XMAX
4145
618
      ACCU=ET*ACC
4146
619
 302  F0=-ET
4147
620
      G0=0.
4148
621
      X2=X*X
4149
622
      DO 303 I=1,N
4150
623
      E(I)=SQRT(XM2(I)+X2*P2(I))
4151
624
      F0=F0+E(I)
4152
625
 303  G0=G0+P2(I)/E(I)
4153
626
      IF(ABS(F0).LE.ACCU) GOTO 305
4154
627
      ITER=ITER+1
4155
628
      IF(ITER.LE.ITMAX) GOTO 304
4156
629
      PRINT 1006,ITMAX
4157
630
      GOTO 305
4158
631
 304  X=X-F0/(X*G0)
4159
632
      GOTO 302
4160
633
 305  DO 307 I=1,N
4161
634
      V(I)=X*P(4,I)
4162
635
      DO 306 K=1,3
4163
636
 306  P(K,I)=X*P(K,I)
4164
637
 307  P(4,I)=E(I)
4165
638
C     
4166
639
C     CALCULATE THE MASS-EFFECT WEIGHT FACTOR
4167
640
      WT2=1.
4168
641
      WT3=0.
4169
642
      DO 308 I=1,N
4170
643
      WT2=WT2*V(I)/E(I)
4171
644
 308  WT3=WT3+V(I)**2/E(I)
4172
645
      WTM=(2.*N-3.)*LOG(X)+LOG(WT2/WT3*ET)
4173
646
C     
4174
647
C     RETURN FOR  WEIGHTED MASSIVE MOMENTA
4175
648
      WT=WT+WTM
4176
649
      IF(WT.GE.-180.D0) GOTO 309
4177
650
      IF(IWARN(3).LE.5) PRINT 1004,WT
4178
651
      IWARN(3)=IWARN(3)+1
4179
652
 309  IF(WT.LE. 174.D0) GOTO 310
4180
653
      IF(IWARN(4).LE.5) PRINT 1005,WT
4181
654
      IWARN(4)=IWARN(4)+1
4182
655
C     RETURN LOG OF WEIGHT
4183
656
 310  WT=WT
4184
657
      RETURN
4185
658
C     
4186
659
 1001 FORMAT(' RAMBO FAILS: # OF PARTICLES =',I5,' IS NOT ALLOWED')
4187
660
 1002 FORMAT(' RAMBO FAILS: TOTAL MASS =',D15.6,' IS NOT',' SMALLE'
4188
661
     $ //'R THAN TOTAL ENERGY =',D15.6)
4189
662
 1004 FORMAT(' RAMBO WARNS: WEIGHT = EXP(',F20.9,') MAY UNDERFLOW')
4190
663
 1005 FORMAT(' RAMBO WARNS: WEIGHT = EXP(',F20.9,') MAY  OVERFLOW')
4191
664
 1006 FORMAT(' RAMBO WARNS:',I3,' ITERATIONS DID NOT GIVE THE'
4192
665
     $ ,' DESIRED ACCURACY =',D15.6)
4193
666
      END
4194
667
4195
668
      FUNCTION RN(IDUMMY)
4196
669
      REAL*8 RN,RAN
4197
670
      SAVE INIT
4198
671
      DATA INIT /1/
4199
672
      IF (INIT.EQ.1) THEN
4200
673
        INIT=0
4201
674
        CALL RMARIN(1802,9373)
4202
675
        END IF
4203
676
C       
4204
677
 10     CALL RANMAR(RAN)
4205
678
        IF (RAN.LT.1D-16) GOTO 10
4206
679
        RN=RAN
4207
680
C       
4208
681
        END
4209
682
4210
683
4211
684
4212
685
        SUBROUTINE RANMAR(RVEC)
4213
686
C       -----------------
4214
687
C       Universal random number generator proposed by Marsaglia and
4215
688
C        Zaman
4216
689
C       in report FSU-SCRI-87-50
4217
690
C       In this version RVEC is a double precision variable.
4218
691
        IMPLICIT REAL*8(A-H,O-Z)
4219
692
        COMMON/ RASET1 / RANU(97),RANC,RANCD,RANCM
4220
693
        COMMON/ RASET2 / IRANMR,JRANMR
4221
694
        SAVE /RASET1/,/RASET2/
4222
695
        UNI = RANU(IRANMR) - RANU(JRANMR)
4223
696
        IF(UNI .LT. 0D0) UNI = UNI + 1D0
4224
697
        RANU(IRANMR) = UNI
4225
698
        IRANMR = IRANMR - 1
4226
699
        JRANMR = JRANMR - 1
4227
700
        IF(IRANMR .EQ. 0) IRANMR = 97
4228
701
        IF(JRANMR .EQ. 0) JRANMR = 97
4229
702
        RANC = RANC - RANCD
4230
703
        IF(RANC .LT. 0D0) RANC = RANC + RANCM
4231
704
        UNI = UNI - RANC
4232
705
        IF(UNI .LT. 0D0) UNI = UNI + 1D0
4233
706
        RVEC = UNI
4234
707
        END
4235
708
4236
709
        SUBROUTINE RMARIN(IJ,KL)
4237
710
C       -----------------
4238
711
C       Initializing routine for RANMAR, must be called before
4239
712
C        generating
4240
713
C       any pseudorandom numbers with RANMAR. The input values should
4241
714
C        be in
4242
715
C       the ranges 0<=ij<=31328 ; 0<=kl<=30081
4243
716
        IMPLICIT REAL*8(A-H,O-Z)
4244
717
        COMMON/ RASET1 / RANU(97),RANC,RANCD,RANCM
4245
718
        COMMON/ RASET2 / IRANMR,JRANMR
4246
719
        SAVE /RASET1/,/RASET2/
4247
720
C       This shows correspondence between the simplified input seeds
4248
721
C        IJ, KL
4249
722
C       and the original Marsaglia-Zaman seeds I,J,K,L.
4250
723
C       To get the standard values in the Marsaglia-Zaman paper
4251
724
C        (i=12,j=34
4252
725
C       k=56,l=78) put ij=1802, kl=9373
4253
726
        I = MOD( IJ/177 , 177 ) + 2
4254
727
        J = MOD( IJ     , 177 ) + 2
4255
728
        K = MOD( KL/169 , 178 ) + 1
4256
729
        L = MOD( KL     , 169 )
4257
730
        DO 300 II = 1 , 97
4258
731
        S =  0D0
4259
732
        T = .5D0
4260
733
        DO 200 JJ = 1 , 24
4261
734
        M = MOD( MOD(I*J,179)*K , 179 )
4262
735
        I = J
4263
736
        J = K
4264
737
        K = M
4265
738
        L = MOD( 53*L+1 , 169 )
4266
739
        IF(MOD(L*M,64) .GE. 32) S = S + T
4267
740
        T = .5D0*T
4268
741
 200    CONTINUE
4269
742
        RANU(II) = S
4270
743
 300    CONTINUE
4271
744
        RANC  =   362436D0 / 16777216D0
4272
745
        RANCD =  7654321D0 / 16777216D0
4273
746
        RANCM = 16777213D0 / 16777216D0
4274
747
        IRANMR = 97
4275
748
        JRANMR = 33
4276
749
        END
4277
750
4278
751
4279
752
4280
753
4281
754
4282
755
4283
756
4284
0
757
4285
=== added file 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%check_sa_born_splitOrders.f'
4286
--- tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%check_sa_born_splitOrders.f	1970-01-01 00:00:00 +0000
4287
+++ tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%check_sa_born_splitOrders.f	2016-02-24 13:54:50 +0000
4288
@@ -0,0 +1,524 @@
4289
1
      PROGRAM DRIVER
4290
2
C     *****************************************************************
4291
3
C     *********
4292
4
C     THIS IS THE DRIVER FOR CHECKING THE STANDALONE MATRIX ELEMENT.
4293
5
C     IT USES A SIMPLE PHASE SPACE GENERATOR
4294
6
C     Fabio Maltoni - 3rd Febraury 2007
4295
7
C     *****************************************************************
4296
8
C     *********
4297
9
      IMPLICIT NONE
4298
10
C     
4299
11
C     CONSTANTS  
4300
12
C     
4301
13
      REAL*8 ZERO
4302
14
      PARAMETER (ZERO=0D0)
4303
15
      INTEGER NSPLITORDERS
4304
16
      PARAMETER (NSPLITORDERS=1)
4305
17
C     
4306
18
C     INCLUDE FILES
4307
19
C     
4308
20
C     ---  the include file with the values of the parameters and
4309
21
C      masses	
4310
22
      INCLUDE 'coupl.inc'
4311
23
C     integer nexternal and number particles (incoming+outgoing) in
4312
24
C      the me 
4313
25
      INTEGER NEXTERNAL, NINCOMING
4314
26
      PARAMETER (NEXTERNAL=3,NINCOMING=2)
4315
27
C     ---  particle masses
4316
28
      REAL*8 PMASS(NEXTERNAL)
4317
29
      REAL*8 TOTALMASS
4318
30
C     ---  integer    n_max_cg
4319
31
      INCLUDE 'ngraphs.inc'  !how many diagrams (could be useful to know...)
4320
32
4321
33
C     
4322
34
C     LOCAL
4323
35
C     
4324
36
      INTEGER I,J,K
4325
37
      REAL*8 P(0:3,NEXTERNAL)  ! four momenta. Energy is the zeroth component.
4326
38
      REAL*8 SQRTS  ! sqrt(s)= center of mass energy
4327
39
      REAL*8 MATELEM, MATELEMS(0:NSPLITORDERS)
4328
40
      REAL*8 PIN(0:3), POUT(0:3)
4329
41
      CHARACTER*120 BUFF(NEXTERNAL)
4330
42
4331
43
      INTEGER NCHOSEN
4332
44
      CHARACTER*20 CHOSEN_SO_INDICES(NSPLITORDERS)
4333
45
4334
46
C     
4335
47
C     EXTERNAL
4336
48
C     
4337
49
      REAL*8 DOT
4338
50
      EXTERNAL DOT
4339
51
4340
52
      LOGICAL CHOSEN_SO_CONFIGS(NSPLITORDERS)
4341
53
      COMMON/CHOSEN_BORN_SQSO/CHOSEN_SO_CONFIGS
4342
54
4343
55
C     -----
4344
56
C     BEGIN CODE
4345
57
C     -----
4346
58
C     
4347
59
C     Start by initializing what is the squared split orders indices
4348
60
C      chosen
4349
61
      NCHOSEN=0
4350
62
      DO I=1,NSPLITORDERS
4351
63
        IF (CHOSEN_SO_CONFIGS(I)) THEN
4352
64
          NCHOSEN=NCHOSEN+1
4353
65
          WRITE(CHOSEN_SO_INDICES(NCHOSEN),'(I3,A1)') I,')'
4354
66
        ENDIF
4355
67
      ENDDO
4356
68
4357
69
C     ---  INITIALIZATION CALLS
4358
70
C     
4359
71
C     ---  Call to initialize the values of the couplings, masses and
4360
72
C      widths 
4361
73
C     used in the evaluation of the matrix element. The primary
4362
74
C      parameters of the
4363
75
C     models are read from Cards/param_card.dat. The secondary
4364
76
C      parameters are calculated
4365
77
C     in Source/MODEL/couplings.f. The values are stored in common
4366
78
C      blocks that are listed
4367
79
C     in coupl.inc .
4368
80
4369
81
      CALL SETPARA('param_card.dat')  !first call to setup the paramaters
4370
82
      INCLUDE 'pmass.inc'  !set up masses
4371
83
4372
84
      TOTALMASS = 0.0D0
4373
85
      DO I=1,NEXTERNAL
4374
86
        TOTALMASS = TOTALMASS + PMASS(I)
4375
87
      ENDDO
4376
88
4377
89
C     ---  Now use a simple multipurpose PS generator (RAMBO) just to
4378
90
C      get a 
4379
91
C     RANDOM set of four momenta of given masses pmass(i) to be used
4380
92
C      to evaluate 
4381
93
C     the madgraph matrix-element.       
4382
94
C     Alternatevely, here the user can call or set the four momenta at
4383
95
C      his will, see below.
4384
96
C     
4385
97
      IF(NINCOMING.EQ.1) THEN
4386
98
        SQRTS=PMASS(1)
4387
99
      ELSE
4388
100
        SQRTS=1000D0  !CMS energy in GEV
4389
101
        IF (SQRTS.LE.2.0D0*TOTALMASS) THEN
4390
102
          SQRTS = 2.0D0*TOTALMASS
4391
103
        ENDIF
4392
104
      ENDIF
4393
105
4394
106
      CALL PRINTOUT()
4395
107
4396
108
      CALL GET_MOMENTA(SQRTS,PMASS,P)
4397
109
C     
4398
110
C     write the information on the four momenta 
4399
111
C     
4400
112
      WRITE (*,*)
4401
113
      WRITE (*,*) ' Phase space point:'
4402
114
      WRITE (*,*)
4403
115
      WRITE (*,*) '-----------------------------'
4404
116
      WRITE (*,*)  'n   E   px   py   pz   m '
4405
117
      DO I=1,NEXTERNAL
4406
118
        WRITE (*,'(i2,1x,5e15.7)') I, P(0,I),P(1,I),P(2,I),P(3,I)
4407
119
     $   ,DSQRT(DABS(DOT(P(0,I),P(0,I))))
4408
120
      ENDDO
4409
121
      WRITE (*,*) '-----------------------------'
4410
122
4411
123
C     
4412
124
C     Now we can call the matrix element!
4413
125
C     
4414
126
      CALL SMATRIX_SPLITORDERS(P,MATELEMS)
4415
127
      MATELEM=MATELEMS(0)
4416
128
      WRITE(*,*) '1) Matrix element for (QCD=0) = ',MATELEMS(1)
4417
129
C     
4418
130
      IF (NCHOSEN.NE.NSPLITORDERS) THEN
4419
131
        WRITE (*,*) 'Selected squared coupling orders combination fo'
4420
132
     $   //'r the sum below:'
4421
133
        WRITE (*,*) (CHOSEN_SO_INDICES(I),I=1,NCHOSEN)
4422
134
      ENDIF
4423
135
      WRITE (*,*) 'Total Matrix element = ', MATELEM, ' GeV^',
4424
136
     $ -(2*NEXTERNAL-8)
4425
137
      WRITE (*,*) '-----------------------------'
4426
138
4427
139
C     c
4428
140
C     c      Copy down here (or read in) the four momenta as a string. 
4429
141
C     c      
4430
142
C     c
4431
143
C     buff(1)=" 1   0.5630480E+04  0.0000000E+00  0.0000000E+00 
4432
144
C      0.5630480E+04"
4433
145
C     buff(2)=" 2   0.5630480E+04  0.0000000E+00  0.0000000E+00
4434
146
C      -0.5630480E+04"
4435
147
C     buff(3)=" 3   0.5466073E+04  0.4443190E+03  0.2446331E+04
4436
148
C      -0.4864732E+04"
4437
149
C     buff(4)=" 4   0.8785819E+03 -0.2533886E+03  0.2741971E+03 
4438
150
C      0.7759741E+03"
4439
151
C     buff(5)=" 5   0.4916306E+04 -0.1909305E+03 -0.2720528E+04 
4440
152
C      0.4088757E+04"
4441
153
C     c
4442
154
C     c      Here the k,E,px,py,pz are read from the string into the
4443
155
C      momenta array.
4444
156
C     c      k=1,2          : incoming
4445
157
C     c      k=3,nexternal  : outgoing
4446
158
C     c
4447
159
C     do i=1,nexternal
4448
160
C     read (buff(i),*) k, P(0,i),P(1,i),P(2,i),P(3,i)
4449
161
C     enddo
4450
162
C     
4451
163
C     c- print the momenta out
4452
164
C     
4453
165
C     do i=1,nexternal
4454
166
C     write (*,'(i2,1x,5e15.7)') i, P(0,i),P(1,i),P(2,i),P(3,i), 
4455
167
C     .dsqrt(dabs(DOT(p(0,i),p(0,i))))
4456
168
C     enddo
4457
169
C     
4458
170
C     CALL SMATRIX(P,MATELEM)
4459
171
C     
4460
172
C     write (*,*) "-------------------------------------------------"
4461
173
C     write (*,*) "Matrix element = ", MATELEM, " GeV^",-(2*nexternal-8
4462
174
C     )	
4463
175
C     write (*,*) "-------------------------------------------------"
4464
176
4465
177
      END
4466
178
4467
179
4468
180
4469
181
4470
182
      DOUBLE PRECISION FUNCTION DOT(P1,P2)
4471
183
C     *****************************************************************
4472
184
C     ***********
4473
185
C     4-Vector Dot product
4474
186
C     *****************************************************************
4475
187
C     ***********
4476
188
      IMPLICIT NONE
4477
189
      DOUBLE PRECISION P1(0:3),P2(0:3)
4478
190
      DOT=P1(0)*P2(0)-P1(1)*P2(1)-P1(2)*P2(2)-P1(3)*P2(3)
4479
191
      END
4480
192
4481
193
4482
194
      SUBROUTINE GET_MOMENTA(ENERGY,PMASS,P)
4483
195
C     ---- auxiliary function to change convention between madgraph
4484
196
C      and rambo
4485
197
C     ---- four momenta. 	  
4486
198
      IMPLICIT NONE
4487
199
C     integer nexternal and number particles (incoming+outgoing) in
4488
200
C      the me 
4489
201
      INTEGER NEXTERNAL, NINCOMING
4490
202
      PARAMETER (NEXTERNAL=3,NINCOMING=2)
4491
203
C     ARGUMENTS
4492
204
      REAL*8 ENERGY,PMASS(NEXTERNAL),P(0:3,NEXTERNAL),PRAMBO(4,10),WGT
4493
205
C     LOCAL
4494
206
      INTEGER I
4495
207
      REAL*8 ETOT2,MOM,M1,M2,E1,E2
4496
208
4497
209
      ETOT2=ENERGY**2
4498
210
      M1=PMASS(1)
4499
211
      M2=PMASS(2)
4500
212
      MOM=(ETOT2**2 - 2*ETOT2*M1**2 + M1**4 - 2*ETOT2*M2**2 - 2*M1**2
4501
213
     $ *M2**2 + M2**4)/(4.*ETOT2)
4502
214
      MOM=DSQRT(MOM)
4503
215
      E1=DSQRT(MOM**2+M1**2)
4504
216
      E2=DSQRT(MOM**2+M2**2)
4505
217
      WRITE (*,*) E1+E2,MOM
4506
218
4507
219
      IF(NINCOMING.EQ.2) THEN
4508
220
4509
221
        P(0,1)=E1
4510
222
        P(1,1)=0D0
4511
223
        P(2,1)=0D0
4512
224
        P(3,1)=MOM
4513
225
4514
226
        P(0,2)=E2
4515
227
        P(1,2)=0D0
4516
228
        P(2,2)=0D0
4517
229
        P(3,2)=-MOM
4518
230
4519
231
        CALL RAMBO(NEXTERNAL-2,ENERGY,PMASS(3),PRAMBO,WGT)
4520
232
        DO I=3, NEXTERNAL
4521
233
          P(0,I)=PRAMBO(4,I-2)
4522
234
          P(1,I)=PRAMBO(1,I-2)
4523
235
          P(2,I)=PRAMBO(2,I-2)
4524
236
          P(3,I)=PRAMBO(3,I-2)
4525
237
        ENDDO
4526
238
4527
239
      ELSEIF(NINCOMING.EQ.1) THEN
4528
240
4529
241
        P(0,1)=ENERGY
4530
242
        P(1,1)=0D0
4531
243
        P(2,1)=0D0
4532
244
        P(3,1)=0D0
4533
245
4534
246
        CALL RAMBO(NEXTERNAL-1,ENERGY,PMASS(2),PRAMBO,WGT)
4535
247
        DO I=2, NEXTERNAL
4536
248
          P(0,I)=PRAMBO(4,I-1)
4537
249
          P(1,I)=PRAMBO(1,I-1)
4538
250
          P(2,I)=PRAMBO(2,I-1)
4539
251
          P(3,I)=PRAMBO(3,I-1)
4540
252
        ENDDO
4541
253
      ENDIF
4542
254
4543
255
      RETURN
4544
256
      END
4545
257
4546
258
4547
259
      SUBROUTINE RAMBO(N,ET,XM,P,WT)
4548
260
C     *****************************************************************
4549
261
C     ******
4550
262
C     *                       RAMBO                                   
4551
263
C           *
4552
264
C     *    RA(NDOM)  M(OMENTA)  B(EAUTIFULLY)  O(RGANIZED)            
4553
265
C           *
4554
266
C     *                                                               
4555
267
C           *
4556
268
C     *    A DEMOCRATIC MULTI-PARTICLE PHASE SPACE GENERATOR          
4557
269
C           *
4558
270
C     *    AUTHORS:  S.D. ELLIS,  R. KLEISS,  W.J. STIRLING           
4559
271
C           *
4560
272
C     *    THIS IS VERSION 1.0 -  WRITTEN BY R. KLEISS                
4561
273
C           *
4562
274
C     *    -- ADJUSTED BY HANS KUIJF, WEIGHTS ARE LOGARITHMIC
4563
275
C      (20-08-90)    *
4564
276
C     *                                                               
4565
277
C           *
4566
278
C     *    N  = NUMBER OF PARTICLES                                   
4567
279
C           *
4568
280
C     *    ET = TOTAL CENTRE-OF-MASS ENERGY                           
4569
281
C           *
4570
282
C     *    XM = PARTICLE MASSES ( DIM=NEXTERNAL-nincoming )           
4571
283
C           *
4572
284
C     *    P  = PARTICLE MOMENTA ( DIM=(4,NEXTERNAL-nincoming) )      
4573
285
C           *
4574
286
C     *    WT = WEIGHT OF THE EVENT                                   
4575
287
C           *
4576
288
C     *****************************************************************
4577
289
C     ******
4578
290
      IMPLICIT REAL*8(A-H,O-Z)
4579
291
C     integer nexternal and number particles (incoming+outgoing) in
4580
292
C      the me 
4581
293
      INTEGER NEXTERNAL, NINCOMING
4582
294
      PARAMETER (NEXTERNAL=3,NINCOMING=2)
4583
295
      DIMENSION XM(NEXTERNAL-NINCOMING),P(4,NEXTERNAL-NINCOMING)
4584
296
      DIMENSION Q(4,NEXTERNAL-NINCOMING),Z(NEXTERNAL-NINCOMING),R(4)
4585
297
     $ , B(3),P2(NEXTERNAL-NINCOMING),XM2(NEXTERNAL-NINCOMING)
4586
298
     $ , E(NEXTERNAL-NINCOMING),V(NEXTERNAL-NINCOMING),IWARN(5)
4587
299
      SAVE ACC,ITMAX,IBEGIN,IWARN
4588
300
      DATA ACC/1.D-14/,ITMAX/6/,IBEGIN/0/,IWARN/5*0/
4589
301
C     *
4590
302
C     * INITIALIZATION STEP: FACTORIALS FOR THE PHASE SPACE WEIGHT
4591
303
      IF(IBEGIN.NE.0) GOTO 103
4592
304
      IBEGIN=1
4593
305
      TWOPI=8.*DATAN(1.D0)
4594
306
      PO2LOG=LOG(TWOPI/4.)
4595
307
      Z(2)=PO2LOG
4596
308
      DO 101 K=3,NEXTERNAL-NINCOMING-1
4597
309
 101  Z(K)=Z(K-1)+PO2LOG-2.*LOG(DFLOAT(K-2))
4598
310
      DO 102 K=3,NEXTERNAL-NINCOMING-1
4599
311
 102  Z(K)=(Z(K)-LOG(DFLOAT(K-1)))
4600
312
C     *
4601
313
C     * CHECK ON THE NUMBER OF PARTICLES
4602
314
 103  IF(N.GT.1.AND.N.LT.101) GOTO 104
4603
315
      PRINT 1001,N
4604
316
      STOP
4605
317
C     *
4606
318
C     * CHECK WHETHER TOTAL ENERGY IS SUFFICIENT; COUNT NONZERO MASSES
4607
319
 104  XMT=0.
4608
320
      NM=0
4609
321
      DO 105 I=1,N
4610
322
      IF(XM(I).NE.0.D0) NM=NM+1
4611
323
 105  XMT=XMT+ABS(XM(I))
4612
324
      IF(XMT.LE.ET) GOTO 201
4613
325
      PRINT 1002,XMT,ET
4614
326
      STOP
4615
327
C     *
4616
328
C     * THE PARAMETER VALUES ARE NOW ACCEPTED
4617
329
C     *
4618
330
C     * GENERATE N MASSLESS MOMENTA IN INFINITE PHASE SPACE
4619
331
 201  DO 202 I=1,N
4620
332
      R1=RN(1)
4621
333
      C=2.*R1-1.
4622
334
      S=SQRT(1.-C*C)
4623
335
      F=TWOPI*RN(2)
4624
336
      R1=RN(3)
4625
337
      R2=RN(4)
4626
338
      Q(4,I)=-LOG(R1*R2)
4627
339
      Q(3,I)=Q(4,I)*C
4628
340
      Q(2,I)=Q(4,I)*S*COS(F)
4629
341
 202  Q(1,I)=Q(4,I)*S*SIN(F)
4630
342
C     *
4631
343
C     * CALCULATE THE PARAMETERS OF THE CONFORMAL TRANSFORMATION
4632
344
      DO 203 I=1,4
4633
345
 203  R(I)=0.
4634
346
      DO 204 I=1,N
4635
347
      DO 204 K=1,4
4636
348
 204  R(K)=R(K)+Q(K,I)
4637
349
      RMAS=SQRT(R(4)**2-R(3)**2-R(2)**2-R(1)**2)
4638
350
      DO 205 K=1,3
4639
351
 205  B(K)=-R(K)/RMAS
4640
352
      G=R(4)/RMAS
4641
353
      A=1./(1.+G)
4642
354
      X=ET/RMAS
4643
355
C     *
4644
356
C     * TRANSFORM THE Q'S CONFORMALLY INTO THE P'S
4645
357
      DO 207 I=1,N
4646
358
      BQ=B(1)*Q(1,I)+B(2)*Q(2,I)+B(3)*Q(3,I)
4647
359
      DO 206 K=1,3
4648
360
 206  P(K,I)=X*(Q(K,I)+B(K)*(Q(4,I)+A*BQ))
4649
361
 207  P(4,I)=X*(G*Q(4,I)+BQ)
4650
362
C     *
4651
363
C     * CALCULATE WEIGHT AND POSSIBLE WARNINGS
4652
364
      WT=PO2LOG
4653
365
      IF(N.NE.2) WT=(2.*N-4.)*LOG(ET)+Z(N)
4654
366
      IF(WT.GE.-180.D0) GOTO 208
4655
367
      IF(IWARN(1).LE.5) PRINT 1004,WT
4656
368
      IWARN(1)=IWARN(1)+1
4657
369
 208  IF(WT.LE. 174.D0) GOTO 209
4658
370
      IF(IWARN(2).LE.5) PRINT 1005,WT
4659
371
      IWARN(2)=IWARN(2)+1
4660
372
C     *
4661
373
C     * RETURN FOR WEIGHTED MASSLESS MOMENTA
4662
374
 209  IF(NM.NE.0) GOTO 210
4663
375
C     * RETURN LOG OF WEIGHT
4664
376
      WT=WT
4665
377
      RETURN
4666
378
C     *
4667
379
C     * MASSIVE PARTICLES: RESCALE THE MOMENTA BY A FACTOR X
4668
380
 210  XMAX=SQRT(1.-(XMT/ET)**2)
4669
381
      DO 301 I=1,N
4670
382
      XM2(I)=XM(I)**2
4671
383
 301  P2(I)=P(4,I)**2
4672
384
      ITER=0
4673
385
      X=XMAX
4674
386
      ACCU=ET*ACC
4675
387
 302  F0=-ET
4676
388
      G0=0.
4677
389
      X2=X*X
4678
390
      DO 303 I=1,N
4679
391
      E(I)=SQRT(XM2(I)+X2*P2(I))
4680
392
      F0=F0+E(I)
4681
393
 303  G0=G0+P2(I)/E(I)
4682
394
      IF(ABS(F0).LE.ACCU) GOTO 305
4683
395
      ITER=ITER+1
4684
396
      IF(ITER.LE.ITMAX) GOTO 304
4685
397
      PRINT 1006,ITMAX
4686
398
      GOTO 305
4687
399
 304  X=X-F0/(X*G0)
4688
400
      GOTO 302
4689
401
 305  DO 307 I=1,N
4690
402
      V(I)=X*P(4,I)
4691
403
      DO 306 K=1,3
4692
404
 306  P(K,I)=X*P(K,I)
4693
405
 307  P(4,I)=E(I)
4694
406
C     *
4695
407
C     * CALCULATE THE MASS-EFFECT WEIGHT FACTOR
4696
408
      WT2=1.
4697
409
      WT3=0.
4698
410
      DO 308 I=1,N
4699
411
      WT2=WT2*V(I)/E(I)
4700
412
 308  WT3=WT3+V(I)**2/E(I)
4701
413
      WTM=(2.*N-3.)*LOG(X)+LOG(WT2/WT3*ET)
4702
414
C     *
4703
415
C     * RETURN FOR  WEIGHTED MASSIVE MOMENTA
4704
416
      WT=WT+WTM
4705
417
      IF(WT.GE.-180.D0) GOTO 309
4706
418
      IF(IWARN(3).LE.5) PRINT 1004,WT
4707
419
      IWARN(3)=IWARN(3)+1
4708
420
 309  IF(WT.LE. 174.D0) GOTO 310
4709
421
      IF(IWARN(4).LE.5) PRINT 1005,WT
4710
422
      IWARN(4)=IWARN(4)+1
4711
423
C     * RETURN LOG OF WEIGHT
4712
424
 310  WT=WT
4713
425
      RETURN
4714
426
C     *
4715
427
 1001 FORMAT(' RAMBO FAILS: # OF PARTICLES =',I5,' IS NOT ALLOWED')
4716
428
 1002 FORMAT(' RAMBO FAILS: TOTAL MASS =',D15.6,' IS NOT SMALLER THA'
4717
429
     $ //'N TOTAL ENERGY =',D15.6)
4718
430
 1004 FORMAT(' RAMBO WARNS: WEIGHT = EXP(',F20.9,') MAY UNDERFLOW')
4719
431
 1005 FORMAT(' RAMBO WARNS: WEIGHT = EXP(',F20.9,') MAY  OVERFLOW')
4720
432
 1006 FORMAT(' RAMBO WARNS:',I3,' ITERATIONS DID NOT GIVE THE DESIRE'
4721
433
     $ //'D ACCURACY =',D15.6)
4722
434
      END
4723
435
4724
436
      FUNCTION RN(IDUMMY)
4725
437
      REAL*8 RN,RAN
4726
438
      SAVE INIT
4727
439
      DATA INIT /1/
4728
440
      IF (INIT.EQ.1) THEN
4729
441
        INIT=0
4730
442
        CALL RMARIN(1802,9373)
4731
443
        END IF
4732
444
C       *
4733
445
 10     CALL RANMAR(RAN)
4734
446
        IF (RAN.LT.1D-16) GOTO 10
4735
447
        RN=RAN
4736
448
C       *
4737
449
        END
4738
450
4739
451
4740
452
4741
453
        SUBROUTINE RANMAR(RVEC)
4742
454
C       *     -----------------
4743
455
C       * Universal random number generator proposed by Marsaglia and
4744
456
C        Zaman
4745
457
C       * in report FSU-SCRI-87-50
4746
458
C       * In this version RVEC is a double precision variable.
4747
459
        IMPLICIT REAL*8(A-H,O-Z)
4748
460
        COMMON/ RASET1 / RANU(97),RANC,RANCD,RANCM
4749
461
        COMMON/ RASET2 / IRANMR,JRANMR
4750
462
        SAVE /RASET1/,/RASET2/
4751
463
        UNI = RANU(IRANMR) - RANU(JRANMR)
4752
464
        IF(UNI .LT. 0D0) UNI = UNI + 1D0
4753
465
        RANU(IRANMR) = UNI
4754
466
        IRANMR = IRANMR - 1
4755
467
        JRANMR = JRANMR - 1
4756
468
        IF(IRANMR .EQ. 0) IRANMR = 97
4757
469
        IF(JRANMR .EQ. 0) JRANMR = 97
4758
470
        RANC = RANC - RANCD
4759
471
        IF(RANC .LT. 0D0) RANC = RANC + RANCM
4760
472
        UNI = UNI - RANC
4761
473
        IF(UNI .LT. 0D0) UNI = UNI + 1D0
4762
474
        RVEC = UNI
4763
475
        END
4764
476
4765
477
        SUBROUTINE RMARIN(IJ,KL)
4766
478
C       *     -----------------
4767
479
C       * Initializing routine for RANMAR, must be called before
4768
480
C        generating
4769
481
C       * any pseudorandom numbers with RANMAR. The input values
4770
482
C        should be in
4771
483
C       * the ranges 0<=ij<=31328 ; 0<=kl<=30081
4772
484
        IMPLICIT REAL*8(A-H,O-Z)
4773
485
        COMMON/ RASET1 / RANU(97),RANC,RANCD,RANCM
4774
486
        COMMON/ RASET2 / IRANMR,JRANMR
4775
487
        SAVE /RASET1/,/RASET2/
4776
488
C       * This shows correspondence between the simplified input seeds
4777
489
C        IJ, KL
4778
490
C       * and the original Marsaglia-Zaman seeds I,J,K,L.
4779
491
C       * To get the standard values in the Marsaglia-Zaman paper
4780
492
C        (i=12,j=34
4781
493
C       * k=56,l=78) put ij=1802, kl=9373
4782
494
        I = MOD( IJ/177 , 177 ) + 2
4783
495
        J = MOD( IJ     , 177 ) + 2
4784
496
        K = MOD( KL/169 , 178 ) + 1
4785
497
        L = MOD( KL     , 169 )
4786
498
        DO 300 II = 1 , 97
4787
499
        S =  0D0
4788
500
        T = .5D0
4789
501
        DO 200 JJ = 1 , 24
4790
502
        M = MOD( MOD(I*J,179)*K , 179 )
4791
503
        I = J
4792
504
        J = K
4793
505
        K = M
4794
506
        L = MOD( 53*L+1 , 169 )
4795
507
        IF(MOD(L*M,64) .GE. 32) S = S + T
4796
508
        T = .5D0*T
4797
509
 200    CONTINUE
4798
510
        RANU(II) = S
4799
511
 300    CONTINUE
4800
512
        RANC  =   362436D0 / 16777216D0
4801
513
        RANCD =  7654321D0 / 16777216D0
4802
514
        RANCM = 16777213D0 / 16777216D0
4803
515
        IRANMR = 97
4804
516
        JRANMR = 33
4805
517
        END
4806
518
4807
519
4808
520
4809
521
4810
522
4811
523
4812
524
4813
0
525
4814
=== added file 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%coef_specs.inc'
4815
--- tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%coef_specs.inc	1970-01-01 00:00:00 +0000
4816
+++ tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%coef_specs.inc	2016-02-24 13:54:50 +0000
4817
@@ -0,0 +1,6 @@
4818
1
      INTEGER MAXLWFSIZE
4819
2
      PARAMETER (MAXLWFSIZE=4)
4820
3
      INTEGER LOOP_MAXCOEFS
4821
4
      PARAMETER (LOOP_MAXCOEFS=15)
4822
5
      INTEGER VERTEXMAXCOEFS
4823
6
      PARAMETER (VERTEXMAXCOEFS=5)
4824
0
7
4825
=== added file 'tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%improve_ps.f'
4826
--- tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%improve_ps.f	1970-01-01 00:00:00 +0000
4827
+++ tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%improve_ps.f	2016-02-24 13:54:50 +0000
4828
@@ -0,0 +1,981 @@
4829
1
      SUBROUTINE IMPROVE_PS_POINT_PRECISION(P)
4830
2
      IMPLICIT NONE
4831
3
C     
4832
4
C     CONSTANTS
4833
5
C     
4834
6
      INTEGER    NEXTERNAL
4835
7
      PARAMETER (NEXTERNAL=3)
4836
8
C     
4837
9
C     ARGUMENTS 
4838
10
C     
4839
11
      DOUBLE PRECISION P(0:3,NEXTERNAL)
4840
12
      REAL*16 QP_P(0:3,NEXTERNAL)
4841
13
C     
4842
14
C     LOCAL VARIABLES 
4843
15
C     
4844
16
      INTEGER I,J
4845
17
4846
18
C     ----------
4847
19
C     BEGIN CODE
4848
20
C     ----------
4849
21
4850
22
      DO I=1,NEXTERNAL
4851
23
        DO J=0,3
4852
24
          QP_P(J,I)=P(J,I)
4853
25
        ENDDO
4854
26
      ENDDO
4855
27
4856
28
      CALL MP_IMPROVE_PS_POINT_PRECISION(QP_P)
4857
29
4858
30
      DO I=1,NEXTERNAL
4859
31
        DO J=0,3
4860
32
          P(J,I)=QP_P(J,I)
4861
33
        ENDDO
4862
34
      ENDDO
4863
35
4864
36
      END
4865
37
4866
38
4867
39
      SUBROUTINE MP_IMPROVE_PS_POINT_PRECISION(P)
4868
40
      IMPLICIT NONE
4869
41
C     
4870
42
C     CONSTANTS
4871
43
C     
4872
44
      INTEGER    NEXTERNAL
4873
45
      PARAMETER (NEXTERNAL=3)
4874
46
C     
4875
47
C     ARGUMENTS 
4876
48
C     
4877
49
      REAL*16 P(0:3,NEXTERNAL)
4878
50
C     
4879
51
C     LOCAL VARIABLES 
4880
52
C     
4881
53
      INTEGER I,J
4882
54
      INTEGER ERRCODE,ERRCODETMP
4883
55
      REAL*16 NEWP(0:3,NEXTERNAL)
4884
56
C     
4885
57
C     FUNCTIONS
4886
58
C     
4887
59
      LOGICAL MP_IS_PHYSICAL
4888
60
C     
4889
61
C     SAVED VARIABLES
4890
62
C     
4891
63
      INCLUDE 'MadLoopParams.inc'
4892
64
C     
4893
65
C     SAVED VARIABLES
4894
66
C     
4895
67
      INTEGER WARNED
4896
68
      DATA WARNED/0/
4897
69
4898
70
      LOGICAL TOLD_SUPPRESS
4899
71
      DATA TOLD_SUPPRESS/.FALSE./
4900
72
C     ----------
4901
73
C     BEGIN CODE
4902
74
C     ----------
4903
75
4904
76
C     ERROR CODES CONVENTION
4905
77
C     
4906
78
C     1         ::  None physical PS point input
4907
79
C     100-1000  ::  Error in the origianl method for restoring
4908
80
C      precision
4909
81
C     1000-9999 ::  Error when restoring precision ala PSMC
4910
82
C     
4911
83
      ERRCODETMP=0
4912
84
      ERRCODE=0
4913
85
4914
86
      DO J=1,NEXTERNAL
4915
87
        DO I=0,3
4916
88
          NEWP(I,J)=P(I,J)
4917
89
        ENDDO
4918
90
      ENDDO
4919
91
4920
92
C     Check the sanity of the original PS point
4921
93
      IF (.NOT.MP_IS_PHYSICAL(NEWP,WARNED)) THEN
4922
94
        ERRCODE = 1
4923
95
        WRITE(*,*) 'ERROR:: The input PS point is not precise enough.'
4924
96
        GOTO 100
4925
97
      ENDIF
4926
98
4927
99
C     Now restore the precision
4928
100
      IF (IMPROVEPSPOINT.EQ.1) THEN
4929
101
        CALL MP_PSMC_IMPROVE_PS_POINT_PRECISION(NEWP,ERRCODE,WARNED)
4930
102
      ELSEIF((IMPROVEPSPOINT.EQ.2).OR.(IMPROVEPSPOINT.LE.0)) THEN
4931
103
        CALL MP_ORIG_IMPROVE_PS_POINT_PRECISION(NEWP,ERRCODE,WARNED)
4932
104
      ENDIF
4933
105
      IF (ERRCODE.NE.0) THEN
4934
106
        IF (WARNED.LT.20) THEN
4935
107
          WRITE(*,*) 'INFO:: Attempting to rescue the precisio'
4936
108
     $     //'n improvement with an alternative method.'
4937
109
          WARNED=WARNED+1
4938
110
        ENDIF
4939
111
        IF (IMPROVEPSPOINT.EQ.1) THEN
4940
112
          CALL MP_ORIG_IMPROVE_PS_POINT_PRECISION(NEWP,ERRCODETMP
4941
113
     $     ,WARNED)
4942
114
        ELSEIF((IMPROVEPSPOINT.EQ.2).OR.(IMPROVEPSPOINT.LE.0)) THEN
4943
115
          CALL MP_PSMC_IMPROVE_PS_POINT_PRECISION(NEWP,ERRCODETMP
4944
116
     $     ,WARNED)
4945
117
        ENDIF
4946
118
        IF (ERRCODETMP.NE.0) GOTO 100
4947
119
      ENDIF
4948
120
4949
121
C     Report to the user or update the PS point.
4950
122
4951
123
      GOTO 101
4952
124
 100  CONTINUE
4953
125
      IF (WARNED.LT.20) THEN
4954
126
        WRITE(*,*) 'WARNING:: This PS point could not be improved'
4955
127
     $   //'. Error code = ',ERRCODE,ERRCODETMP
4956
128
        CALL MP_WRITE_MOM(P)
4957
129
        WARNED = WARNED +1
4958
130
      ENDIF
4959
131
      GOTO 102
4960
132
 101  CONTINUE
4961
133
      DO J=1,NEXTERNAL
4962
134
        DO I=0,3
4963
135
          P(I,J)=NEWP(I,J)
4964
136
        ENDDO
4965
137
      ENDDO
4966
138
 102  CONTINUE
4967
139
4968
140
      IF (WARNED.GE.20.AND..NOT.TOLD_SUPPRESS) THEN
4969
141
        WRITE(*,*) 'INFO:: Further warnings from the improve_p'
4970
142
     $   //'s routine will now be supressed.'
4971
143
        TOLD_SUPPRESS=.TRUE.
4972
144
      ENDIF
4973
145
4974
146
      END
4975
147
4976
148
4977
149
      FUNCTION MP_IS_CLOSE(P,NEWP,WARNED)
4978
150
      IMPLICIT NONE
4979
151
C     
4980
152
C     CONSTANTS
4981
153
C     
4982
154
      INTEGER    NEXTERNAL
4983
155
      PARAMETER (NEXTERNAL=3)
4984
156
      REAL*16 ZERO
4985
157
      PARAMETER (ZERO=0.0E+00_16)
4986
158
      REAL*16 THRS_CLOSE
4987
159
      PARAMETER (THRS_CLOSE=1.0E-02_16)
4988
160
C     
4989
161
C     ARGUMENTS 
4990
162
C     
4991
163
      REAL*16 P(0:3,NEXTERNAL), NEWP(0:3,NEXTERNAL)
4992
164
      LOGICAL MP_IS_CLOSE
4993
165
      INTEGER WARNED
4994
166
C     
4995
167
C     LOCAL VARIABLES 
4996
168
C     
4997
169
      INTEGER I,J
4998
170
      REAL*16 REF,REF2
4999
171
      DOUBLE PRECISION BUFFDP
5000
172
Status:	Merged
Merged at revision:	344
Proposed branch:	lp:~maddevelopers/mg5amcnlo/2.3.4-low-memory
Merge into:	lp:~maddevelopers/mg5amcnlo/2.3.4
Diff against target:	20865 lines (+19155/-274) 106 files modified UpdateNotes.txt (+6/-0) madgraph/fks/fks_base.py (+79/-60) madgraph/fks/fks_helas_objects.py (+449/-45) madgraph/interface/amcatnlo_interface.py (+171/-49) madgraph/interface/madgraph_interface.py (+6/-3) madgraph/iolibs/export_fks.py (+38/-42) madgraph/iolibs/template_files/loop_optimized/compute_color_flows.inc (+11/-11) madgraph/loop/loop_exporters.py (+8/-3) madgraph/various/banner.py (+1/-1) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%CT_interface.f (+278/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%GOLEM_interface.f (+760/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%TIR_interface.f (+423/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%born_matrix.f (+540/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%check_sa.f (+756/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%check_sa_born_splitOrders.f (+524/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%coef_specs.inc (+6/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%improve_ps.f (+981/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%loop_matrix.f (+2267/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%loop_num.f (+131/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%mp_compute_loop_coefs.f (+296/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%nexternal.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%ngraphs.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%nsqso_born.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%nsquaredSO.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%pmass.inc (+3/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%V0_dxu_wp%polynomial.f (+455/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%b_sf_001.f (+153/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%born.f (+292/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%born_conf.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%born_hel.f (+151/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%born_leshouche.inc (+8/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%born_maxamps.inc (+3/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%born_ngraphs.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%born_nhel.inc (+3/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%coloramps.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%config_subproc_map.inc (+1/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%configs_and_props_decl.inc (+12/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%fks_info.inc (+53/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%get_color.f (+48/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%leshouche_decl.inc (+7/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%matrix_1.f (+172/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%matrix_2.f (+172/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%matrix_3.f (+172/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%nFKSconfigs.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%ncombs.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%nexternal.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%ngraphs.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%parton_lum_1.f (+112/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%parton_lum_2.f (+110/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%parton_lum_3.f (+110/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%parton_lum_chooser.f (+23/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%pmass.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%real_from_born_configs.inc (+6/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%real_me_chooser.f (+22/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%sborn_sf.f (+17/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_dxu_wp%sborn_sf_dum.f (+13/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%CT_interface.f (+278/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%GOLEM_interface.f (+760/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%TIR_interface.f (+423/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%born_matrix.f (+540/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%check_sa.f (+756/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%check_sa_born_splitOrders.f (+524/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%coef_specs.inc (+6/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%improve_ps.f (+981/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%loop_matrix.f (+2267/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%loop_num.f (+131/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%mp_compute_loop_coefs.f (+296/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%nexternal.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%ngraphs.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%nsqso_born.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%nsquaredSO.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%pmass.inc (+3/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%V0_udx_wp%polynomial.f (+455/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%b_sf_001.f (+153/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%born.f (+292/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%born_conf.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%born_hel.f (+151/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%born_leshouche.inc (+8/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%born_maxamps.inc (+3/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%born_ngraphs.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%born_nhel.inc (+3/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%coloramps.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%config_subproc_map.inc (+1/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%configs_and_props_decl.inc (+12/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%fks_info.inc (+53/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%get_color.f (+48/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%leshouche_decl.inc (+7/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%matrix_1.f (+172/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%matrix_2.f (+172/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%matrix_3.f (+172/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%nFKSconfigs.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%ncombs.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%nexternal.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%ngraphs.inc (+2/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%parton_lum_1.f (+112/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%parton_lum_2.f (+110/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%parton_lum_3.f (+110/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%parton_lum_chooser.f (+23/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%pmass.inc (+4/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%real_from_born_configs.inc (+6/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%real_me_chooser.f (+22/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%sborn_sf.f (+17/-0) tests/input_files/IOTestsComparison/IOExportFKSTest/test_ppw_fksall/%SubProcesses%P0_udx_wp%sborn_sf_dum.f (+13/-0) tests/time_db (+59/-57) tests/unit_tests/iolibs/test_export_fks.py (+93/-0) tests/unit_tests/iolibs/test_export_fks_EW.py (+6/-3)
To merge this branch:	bzr merge lp:~maddevelopers/mg5amcnlo/2.3.4-low-memory
Related bugs:	Link a bug report
Reviewer	Date Requested	Status
Valentin Hirschi	2016-02-17	Approve on 2016-02-26
Olivier Mattelaer	2016-02-17	Approve on 2016-02-24
Rikkert Frederix	2016-02-17	Approve on 2016-02-18
Stefano Frixione	2016-02-17	Pending
MadDevelopers	2016-02-17	Pending
Review via email: mp+286337@code.launchpad.net