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], []))