def __init__(self, matrix_elements, python_helas_call_writer):
"""Initiate with matrix elements, helas call writer.
Generate the process matrix element functions as strings."""
self.config_maps = {}
if isinstance(matrix_elements, helas_objects.HelasMultiProcess):
self.matrix_elements = matrix_elements.get('matrix_elements')
elif isinstance(matrix_elements,
group_subprocs.SubProcessGroup):
self.config_maps = matrix_elements.get('diagram_maps')
self.matrix_elements = matrix_elements.get('matrix_elements')
elif isinstance(matrix_elements,
helas_objects.HelasMatrixElementList):
self.matrix_elements = matrix_elements
elif isinstance(matrix_elements,
helas_objects.HelasMatrixElement):
self.matrix_elements = helas_objects.HelasMatrixElementList(\
[matrix_elements])
if not self.matrix_elements:
raise MadGraph5Error("No matrix elements to export")
self.model = self.matrix_elements[0].get('processes')[0].get('model')
self.helas_call_writer = python_helas_call_writer
if not isinstance(self.helas_call_writer, helas_call_writers.PythonUFOHelasCallWriter):
raise Exception, \
"helas_call_writer not PythonUFOHelasCallWriter"
self.matrix_methods = {}
def __init__(self, fksmulti, loop_optimized = False, gen_color =True, decay_ids =[]):
"""Initialization from a FKSMultiProcess"""
#swhich the other loggers off
loggers_off = [logging.getLogger('madgraph.diagram_generation'),
logging.getLogger('madgraph.helas_objects')]
old_levels = [logg.level for logg in loggers_off]
for logg in loggers_off:
logg.setLevel(logging.WARNING)
self.loop_optimized = loop_optimized
# generate the real ME's if they are needed.
# note that it may not be always the case, e.g. it the NLO_mode is LOonly
if fksmulti['real_amplitudes']:
logger.info('Generating real emission matrix-elements...')
self['real_matrix_elements'] = self.generate_matrix_elements(
copy.copy(fksmulti['real_amplitudes']), combine_matrix_elements = False)
else:
self['real_matrix_elements'] = helas_objects.HelasMatrixElementList()
self['matrix_elements'] = self.generate_matrix_elements_fks(
fksmulti,
gen_color, decay_ids)
self['initial_states']=[]
self['has_isr'] = fksmulti['has_isr']
self['has_fsr'] = fksmulti['has_fsr']
self['has_loops'] = len(self.get_virt_matrix_elements()) > 0
for i, logg in enumerate(loggers_off):
logg.setLevel(old_levels[i])
def split_lepton_grouping(self):
"""Return a list of grouping where they are no groupoing over the leptons."""
output = SubProcessGroupList()
for group in self:
new_mes = {}
for me in group['matrix_elements']:
tags = {}
for proc in me['processes']:
ids = proc.get_final_ids_after_decay()
ids = tuple(
[t if abs(t) in [11, 13, 15] else 0 for t in ids])
if ids not in tags:
tags[ids] = base_objects.ProcessList()
tags[ids].append(proc)
for tag in tags:
new_me = copy.copy(me)
new_me['processes'] = tags[tag]
if tag not in new_mes:
new_mes[tag] = helas_objects.HelasMatrixElementList()
new_mes[tag].append(new_me)
for tag in tags:
new_group = copy.copy(group)
new_group['matrix_elements'] = new_mes[tag]
new_group.set('name', new_group.generate_name(\
new_group['matrix_elements'][0]['processes'][0],
criteria='madweight'))
output.append(new_group)
return output
def default_setup(self):
"""Define object and give default values"""
self['number'] = 0
self['name'] = ""
self['amplitudes'] = diagram_generation.AmplitudeList()
self['matrix_elements'] = helas_objects.HelasMatrixElementList()
self['mapping_diagrams'] = []
self['diagram_maps'] = {}
self['diagrams_for_configs'] = []
self['amplitude_map'] = {}
def generate_helas_decay_chain_subproc_groups(self):
"""Combine core_groups and decay_groups to give
HelasDecayChainProcesses and new diagram_maps.
"""
# Combine decays
matrix_elements = \
helas_objects.HelasMultiProcess.generate_matrix_elements(\
diagram_generation.AmplitudeList(\
self.get('decay_chain_amplitudes')))
# For each matrix element, check which group it should go into and
# calculate diagram_maps
me_assignments = {}
for me in matrix_elements:
group_assignment = self.assign_group_to_decay_process(\
me.get('processes')[0])
assert group_assignment
try:
me_assignments[group_assignment].append(me)
except KeyError:
me_assignments[group_assignment] = [me]
# Create subprocess groups corresponding to the different
# group_assignments
subproc_groups = SubProcessGroupList()
for key in sorted(me_assignments.keys()):
group = SubProcessGroup()
group.set('matrix_elements', helas_objects.HelasMatrixElementList(\
me_assignments[key]))
group.set('number', group.get('matrix_elements')[0].\
get('processes')[0].get('id'))
group.set('name', group.generate_name(\
group.get('matrix_elements')[0].\
get('processes')[0]))
subproc_groups.append(group)
return subproc_groups
def __init__(self,
fksmulti,
loop_optimized=False,
gen_color=True,
decay_ids=[]):
"""Initialization from a FKSMultiProcess"""
#swhich the other loggers off
loggers_off = [
logging.getLogger('madgraph.diagram_generation'),
logging.getLogger('madgraph.helas_objects')
]
old_levels = [logg.level for logg in loggers_off]
for logg in loggers_off:
logg.setLevel(logging.WARNING)
self.loop_optimized = loop_optimized
self['used_lorentz'] = []
self['used_couplings'] = []
self['processes'] = []
self['max_particles'] = -1
self['max_configs'] = -1
if not fksmulti['ncores_for_proc_gen']:
# generate the real ME's if they are needed.
# note that it may not be always the case, e.g. it the NLO_mode is LOonly
if fksmulti['real_amplitudes']:
logger.info('Generating real emission matrix-elements...')
self['real_matrix_elements'] = self.generate_matrix_elements(
copy.copy(fksmulti['real_amplitudes']),
combine_matrix_elements=False)
else:
self[
'real_matrix_elements'] = helas_objects.HelasMatrixElementList(
)
self['matrix_elements'] = self.generate_matrix_elements_fks(
fksmulti, gen_color, decay_ids)
self['initial_states'] = []
self['has_loops'] = len(self.get_virt_matrix_elements()) > 0
else:
self['has_loops'] = False
#more efficient generation
born_procs = fksmulti.get('born_processes')
born_pdg_list = [[l['id'] for l in born.born_proc['legs']] \
for born in born_procs ]
loop_orders = {}
for born in born_procs:
for coup, val in fks_common.find_orders(born.born_amp).items():
try:
loop_orders[coup] = max([loop_orders[coup], val])
except KeyError:
loop_orders[coup] = val
pdg_list = []
real_amp_list = []
for born in born_procs:
for amp in born.real_amps:
if not pdg_list.count(amp.pdgs):
pdg_list.append(amp.pdgs)
real_amp_list.append(amp)
#generating and store in tmp files all output corresponding to each real_amplitude
real_out_list = []
realmapin = []
for i, real_amp in enumerate(real_amp_list):
realmapin.append([i, real_amp])
# start the pool instance with a signal instance to catch ctr+c
original_sigint_handler = signal.signal(signal.SIGINT,
signal.SIG_IGN)
if fksmulti['ncores_for_proc_gen'] < 0: # use all cores
pool = multiprocessing.Pool(maxtasksperchild=1)
else:
pool = multiprocessing.Pool(
processes=fksmulti['ncores_for_proc_gen'],
maxtasksperchild=1)
signal.signal(signal.SIGINT, original_sigint_handler)
logger.info('Generating real matrix elements...')
try:
# the very large timeout passed to get is to be able to catch
# KeyboardInterrupts
realmapout = pool.map_async(async_generate_real,
realmapin).get(9999999)
except KeyboardInterrupt:
pool.terminate()
raise KeyboardInterrupt
realmapfiles = []
for realout in realmapout:
realmapfiles.append(realout[0])
logger.info('Generating born and virtual matrix elements...')
#now loop over born and consume reals, generate virtuals
bornmapin = []
OLP = fksmulti['OLP']
for i, born in enumerate(born_procs):
bornmapin.append([
i, born, born_pdg_list, loop_orders, pdg_list,
loop_optimized, OLP, realmapfiles
])
try:
bornmapout = pool.map_async(async_generate_born,
bornmapin).get(9999999)
except KeyboardInterrupt:
pool.terminate()
raise KeyboardInterrupt
#remove real temp files
for realtmp in realmapout:
os.remove(realtmp[0])
logger.info('Collecting infos and finalizing matrix elements...')
unique_me_list = []
duplicate_me_lists = []
for bornout in bornmapout:
mefile = bornout[0]
metag = bornout[1]
has_loops = bornout[2]
self['has_loops'] = self['has_loops'] or has_loops
processes = bornout[3]
self['processes'].extend(processes)
self['max_particles'] = max(
[self['max_configs']] +
[len(p['legs']) + 1 for p in bornout[3]])
self['max_configs'] = max(self['max_configs'], bornout[4])
unique = True
for ime2, bornout2 in enumerate(unique_me_list):
mefile2 = bornout2[0]
metag2 = bornout2[1]
if metag == metag2:
duplicate_me_lists[ime2].append(mefile)
unique = False
break
if unique:
unique_me_list.append(bornout)
duplicate_me_lists.append([])
memapin = []
for i, bornout in enumerate(unique_me_list):
mefile = bornout[0]
memapin.append([i, mefile, duplicate_me_lists[i]])
try:
memapout = pool.map_async(async_finalize_matrix_elements,
memapin).get(9999999)
except KeyboardInterrupt:
pool.terminate()
raise KeyboardInterrupt
#remove born+virtual temp files
for bornout in bornmapout:
mefile = bornout[0]
os.remove(mefile)
pool.close()
pool.join()
#set final list of matrix elements (paths to temp files)
matrix_elements = []
for meout in memapout:
matrix_elements.append(meout[0])
self['matrix_elements'] = matrix_elements
#cache information needed for output which will not be available from
#the matrix elements later
initial_states = []
for meout in memapout:
me_initial_states = meout[1]
for state in me_initial_states:
initial_states.append(state)
# remove doubles from the list
checked = []
for e in initial_states:
if e not in checked:
checked.append(e)
initial_states = checked
self['initial_states'] = initial_states
helas_list = []
for meout in memapout:
helas_list.extend(meout[2])
self['used_lorentz'] = list(set(helas_list))
coupling_list = []
for meout in memapout:
coupling_list.extend([c for l in meout[3] for c in l])
self['used_couplings'] = list(set(coupling_list))
has_virtuals = False
for meout in memapout:
if meout[4]:
has_virtuals = True
break
self['has_virtuals'] = has_virtuals
configs_list = [self['max_configs']]
for meout in realmapout:
configs_list.append(meout[1])
self['max_configs'] = max(configs_list)
nparticles_list = [self['max_particles']]
for meout in realmapout:
nparticles_list.append(meout[2])
self['max_particles'] = max(nparticles_list)
self['has_isr'] = fksmulti['has_isr']
self['has_fsr'] = fksmulti['has_fsr']
logger.info('... Done')
for i, logg in enumerate(loggers_off):
logg.setLevel(old_levels[i])
def get_matrix_elements(self):
"""Extract the list of matrix elements"""
return helas_objects.HelasMatrixElementList(\
sum([group.get('matrix_elements') for group in self], []))