def fit_gaussian(self): """ Fit Gaussian on TGraph. """ LGR.info('Fit Gaussian on TGraph.') self._toolbox_graph.fit('gaus', ['measurements']) self._draw_save('Gaussian_fit', ['measurements'])
def _classify_particles_susy(self, id_particle): """ Classify integer id_particle into SUSY subcategory (see self._classify_particles()) for details. """ if id_particle == 1000021: return 1 elif id_particle == 1000022: return 2 elif id_particle == 1000023: return 3 elif id_particle == 1000024: return 4 elif id_particle == 1000025: return 5 elif id_particle in [ 1000001, 1000002, 1000003, 1000004, 2000001, 2000002, 2000003, 2000004 ]: return 6 elif id_particle in [1000005, 1000006, 2000005, 2000006]: return 7 elif id_particle in [ 1000011, 1000012, 1000013, 1000014, 1000015, 1000016, 2000011, 2000012, 2000013, 2000014, 2000015, 2000016 ]: return 8 elif id_particle == 1000037: return 9 elif id_particle == 1000035: return 10 else: LGR.warning( 'Decay channel category for SUSY particle %s not ' 'found.', id_particle) return 0
def set_axis(self, axis_x, axis_y): """ Set axis labels. """ # Set the main label axis_x = self._get_axis_label(axis_x) axis_y = self._get_axis_label(axis_y) ## Add all additional labels from the dictionaries #for key, value in axis_x_add.iteritems(): # if value == 0: # axis_x += ' = {}'.format(self._get_axis_label(key)) # elif value > 0: # axis_x += ' = {} - {}'.format(self._get_axis_label(key), value) # else: # axis_x += ' = {} + {}'.format(self._get_axis_label(key), # abs(value)) #for key, value in axis_y_add.iteritems(): # if value == 0: # axis_y += ' = {}'.format(self._get_axis_label(key)) # elif value > 0: # axis_y += ' = {} - {}'.format(self._get_axis_label(key), value) # else: # axis_y += ' = {} + {}'.format(self._get_axis_label(key), # abs(value)) ## Add unit #axis_x += ' [GeV]' #axis_y += ' [GeV]' self.set_axis_x(axis_x) self.set_axis_y(axis_y) LGR.debug('Set x axis to %s', axis_x) LGR.debug('Set y axis to %s', axis_y)
def _set_parameter_slha(self, idx, parameter): """ Set parameter in SUSYHIT input file. """ LGR.debug('Set index %s to %s in SLHA.', idx, parameter) # Set regular expressions in SLHA file slha_in = '^ {} '.format(idx) slha_out = ' {} '.format(idx) # Read file with open( '{}/{}.in'.format(self._dir_susyhit, self._get_susyhit_filename()), 'r') as f_in: lines = f_in.readlines() # Make changes and overwrite file with open( '{}/{}.in'.format(self._dir_susyhit, self._get_susyhit_filename()), 'w') as f_in: has_replacement = False for line in lines: t_new = subn('{}.*'.format(slha_in), '{}{}'.format(slha_out, parameter), line) if t_new[1] > 0: LGR.debug('Replaced "%s" with "%s" in input file.', line.rstrip(), t_new[0].rstrip()) has_replacement = True f_in.write(t_new[0]) if not has_replacement: raise RuntimeError('No replacement in SUSYHIT input file has ' 'been done.')
def _skip_point( self, coordinate_x, # pylint: disable=no-self-use coordinate_y): """ Throw warning that point (x/y) will be skipped. """ self._error = True LGR.warning('Skip point (%4d/%4d).', coordinate_x, coordinate_y)
def make_s_curve(self): """ Call a sequence of functions to get the S-curves. """ LGR.info('Integrate TGraphs to get S-curves.') self._toolbox_graph.integrate_graphs(['measurements']) self._draw_save('S-curve_unnormalized', ['scurves']) LGR.info('Normalize S-curves.') self._toolbox_graph.normalize() self._draw_save('S-curve', ['scurves'])
def check_if_file_exists(path_file): """ Check if file exists on file system or on eos. """ # if path_file starts with root://, we have to look on eos if path_file.startswith('root://'): LGR.info('File seems to reside on eos. I will not check its ' 'presence. Further errors might be due to non-' 'existing file.') elif not isfile(path_file): raise IOError('The file {0} does not exist.'.format(path_file)) return True
def _get_m(self, id_particle): """ Return mass of particle with ID id_particle. """ with open('{}/susyhit_slha.out'.format(self._dir_susyhit), 'r') as f_susyhit: f_susyhit_mass = dropwhile(lambda l: not search('^BLOCK MASS', l), f_susyhit) for line in f_susyhit_mass: if search('^ *{}'.format(id_particle), line): mass = float((line.split())[1]) LGR.debug('Found mass %s for particle %s from line %s.', mass, id_particle, line.rstrip()) return abs(mass)
def make_maps(self, coordinate, prefix): """ Make 2d maps of MPA, showing fit characteristics. """ LGR.info('Make 2d maps.') self.set_name('map') if coordinate in [0, 1, 2]: geometry = [range(32, 48), range(31, 15, -1), range(0, 16)] else: geometry = [range(15, -1, -1), range(16, 32), range(47, 31, -1)] self._floorplan.set_geometry(geometry, prefix) self._floorplan.fill_maps(self._toolbox_graph.get_fits(), coordinate, prefix)
def _run_external( self, name, cmd, # pylint: disable=no-self-use check_for_error=True): """ Run external software, such as SUSYHIT or SModelS. """ # If logging level is not set to debug, suppress output LGR.debug('Output from %s:', name) if LGR.getEffectiveLevel() > 10: cmd += ' &> /dev/null' # Logic inverted: bash success (0) is python failure if system(cmd) and check_for_error: raise RuntimeError('Could not run {}.'.format(name))
def run(shard_id, ERROR_LOG_PROBABILITY): Logger = LGR(Lock(), '../LogFiles/Consumer/Logs-', 'log_file_shard_' + str(shard_id) + "_") while True: try: consumer(shard_id, ERROR_LOG_PROBABILITY, Logger) except Exception as e: # print (e) # Run consumer again if any runtime exeption happens. Logger.log("Exception occured. " + str(e)) consumer(shard_id, ERROR_LOG_PROBABILITY, Logger)
def _check_lsp(self): """ Check that the LSP is a neutralino1. """ min_mass = '1e10' with open('{}/susyhit_slha.out'.format(self._dir_susyhit), 'r') as f_susyhit: for line in f_susyhit: # Check for SUSY masses if search('^ *[12]000', line): mass = abs(float((line.split())[1])) id_particle = int((line.split())[0]) if mass < min_mass: min_mass = mass min_id = id_particle if min_id == 1000022: return True else: LGR.warning('LSP is %s', min_id) return False
def retrieve_graphs(self): """ Retrieve TGraphs. """ LGR.info('Retrieve TGraphs from ROOT file.') # Open ROOT file f_in = TFile(self._path, 'READ') # Get TGraphs from ROOT file and fill list in ToolboxTGraph object graphs = [] for s_graph in self._s_graphs: graph = f_in.Get(str(s_graph)) check_if_object(graph, TGraph) graphs.append(graph) self._toolbox_graph.fill_graphs(graphs) self._toolbox_graph.fill_numbering(self._s_graphs) LGR.info('Create plot with original TGraphs.') self._draw_save('Gaussian', ['measurements'])
def _check_susyhit_output(self): """ Check SUSYHIT output file for errors. """ line_warning = 2 with open('{}/suspect2.out'.format(self._dir_susyhit), 'r') as f_suspect2: for line in f_suspect2: if line_warning == 0: errorline = line.split('.') errorline.pop() for err in errorline: if err != '' and int(err) != 0: LGR.warning('SUSYHIT reports an error.') return False if line_warning != 2: line_warning -= 1 if line.startswith('STOP'): LGR.warning('SUSYHIT reports an error: %s', line.rstrip()) return False if line.startswith('Warning'): line_warning -= 1 return True
def get_xs(self, com, path): """ Get cross section from SLHA. """ # Regex to be searched in SLHA file if com == 13: regex_xs = r'XSECTION *1\.30E\+04 *2212 2212 2' elif com == 8: regex_xs = r'XSECTION *8\.00E\+03 *2212 2212 2' else: raise ValueError('Only cross-sections of 8 or 13 TeV are allowed.') with open('{}/susyhit_slha.out'.format(path), 'r') as f_susyhit: found_xsec = False for line in f_susyhit: if found_xsec: # Multiply by 1000. to get cross section in fb self._xs.append(1000. * float(line.split()[6])) found_xsec = False # If the xs matches, set bool, next line will have the xs if search(regex_xs, line): LGR.debug(line.rstrip()) self._p1.append(int(line.split()[5])) self._p2.append(int(line.split()[6])) found_xsec = True
def do_scan(self): # pylint: disable=too-many-branches,too-many-statements """ Loops over the different mass combinations and calls appropriate functions to set masses in the SUSYHIT input file and to fill the python dictionary. """ # Make backup SUSYHIT input file system('mv {}/{}.in{{,.orig}}'.format(self._dir_susyhit, self._get_susyhit_filename())) # Copy template input file system('cp {}.template {}/{}.in'.format(self._get_susyhit_filename(), self._dir_susyhit, self._get_susyhit_filename())) # Fill SM dictionary self._fill_dict_sm() # # Calculate total number of different mass combinations # total = len(M_GLUINOS) * len(M_CHARGINOS1) * len(M_NEUTRALINOS1) total = len(self.l_prmtr_x) * len(self.l_prmtr_y) # Define counter to count from 1 to total counter = 0 # Create MassScanPlots object for plotting plots = MassScanPlots() # Set the plot axis labels plots.set_axis(self._prmtr_id_x, self._prmtr_id_y) # Set the text describing the different parameter values plots.set_text(self._prmtr_id_x, self._d_prmtr_x_add, self._d_prmtr_x_scale) plots.set_text(self._prmtr_id_y, self._d_prmtr_y_add, self._d_prmtr_y_scale) for prmtr_x in self.l_prmtr_x: for prmtr_y in self.l_prmtr_y: # Clear SUSY dictionary (SM can stay) self._d_susy.clear() counter += 1 # Reset error self._error = False LGR.info('Processing mass combination %3d of %3d: (%4d/%4d).', counter, total, prmtr_x, prmtr_y) LGR.debug('prmtr_x = %4d - prmtr_y = %4d', prmtr_x, prmtr_y) self._set_parameter_all(prmtr_x, prmtr_y) # Run SUSYHIT self._run_external('SUSYHIT', 'cd {} && ./run'.format(self._dir_susyhit)) if not self._check_susyhit_output(): self._skip_point(prmtr_x, prmtr_y) # Check for LSP if not self._error and not self._check_lsp(): self._skip_point(prmtr_x, prmtr_y) # Get particle masses if not self._error and self._calc_masses: self._get_masses() # Get particle lifetimes if not self._error and self._calc_br: self._get_ctau() # Calculate cross-section with SModelS if not self._error and (self._calc_xs or self._calc_mu): # 8 TeV cross-sections to check if the model is already # excluded and 13 TeV cross-sections for cross-sections # itself for com in [8, 13]: self._run_external( 'SModelS', 'runTools xseccomputer ' '-p -s {} -f {}/susyhit_slha.out'.format( com, self._dir_susyhit)) # Apply k-factors self._apply_k_factor() if self._calc_xs: self._get_xs() # Move SUSYHIT output system('cp {}/susyhit_slha.out susyhit_slha_{}_{}.out'.format( self._dir_susyhit, prmtr_x, prmtr_y)) system('cp {}/suspect2.out suspect2_{}_{}.out'.format( self._dir_susyhit, prmtr_x, prmtr_y)) # Check if models are already excluded if not self._error and self._calc_mu: self._run_external( 'SModelS', 'timeout 1800 runSModelS ' '-o smodels_summary.txt ' '-f {}/susyhit_slha.out'.format(self._dir_susyhit), False) self._mu = self._get_mu() # Move SModelS output file system('mv smodels_summary.txt smodels_summary_{}_{}.txt ' '2>/dev/null'.format(prmtr_x, prmtr_y)) LGR.debug('Excluded signal strength: %s', self._mu) # Calculate branching ratios into final states if not self._error and self._calc_br: self._get_br_all() if not self._br_leptons or \ not self._br_jets or \ not self._br_photons: LGR.warning('Some branching ratios are empty.') self._skip_point(prmtr_x, prmtr_y) # Get decay channels if not self._error and self._calc_br: self._dc_gluino = self._get_dcs(self._id_gluino) self._dc_chargino1 = self._get_dcs(self._id_chargino1) self._dc_chargino2 = self._get_dcs(self._id_chargino2) self._dc_neutralino2 = self._get_dcs(self._id_neutralino2) self._dc_neutralino3 = self._get_dcs(self._id_neutralino3) self._dc_neutralino4 = self._get_dcs(self._id_neutralino4) self._dc_sdown_l = self._get_dcs(self._id_sdown_l) self._dc_sdown_r = self._get_dcs(self._id_sdown_r) self._dc_sup_l = self._get_dcs(self._id_sup_l) self._dc_sup_r = self._get_dcs(self._id_sup_r) self._dc_sstrange_l = self._get_dcs(self._id_sstrange_l) self._dc_sstrange_r = self._get_dcs(self._id_sstrange_r) self._dc_scharm_l = self._get_dcs(self._id_scharm_l) self._dc_scharm_r = self._get_dcs(self._id_scharm_r) # If there was an error, empty all values if self._error: self._reset() plots = self._fill_plots(plots, prmtr_x, prmtr_y) # Restore backup SUSYHIT input file system('mv {}/{}.in{{.orig,}}'.format(self._dir_susyhit, self._get_susyhit_filename())) # Throw error when no list is filled if len(plots.coordinate_x) == 0: raise RuntimeError('Nothing to plot.') return plots
def _classify_particles_sm(self, id_particles): """ Classify list id_particles into SM subcategory (see self._classify_particles() for details. """ # 0 means undefined cat_sm = 0 if len(id_particles) == 1: if id_particles[0] == 21: # g cat_sm = 7 elif id_particles[0] == 22: # y cat_sm = 8 elif id_particles[0] == 23: # Z cat_sm = 10 elif id_particles[0] == 24: # W cat_sm = 9 elif id_particles[0] == 25: # h cat_sm = 11 elif id_particles[0] in [1, 2, 3, 4, 5]: # q cat_sm = 12 elif id_particles[0] == 6: # t cat_sm = 13 elif id_particles[0] in [11, 12, 13, 14, 15, 16]: # l cat_sm = 14 elif len(id_particles) == 2: if id_particles[0] in [1, 2, 3, 4, 5]: if id_particles[1] in [1, 2, 3, 4, 5]: # qq cat_sm = 1 elif id_particles[1] in [6]: # qt cat_sm = 3 elif id_particles[0] in [6]: if id_particles[1] in [1, 2, 3, 4, 5]: # qt cat_sm = 3 elif id_particles[1] in [6]: # tt cat_sm = 2 elif id_particles[0] in [11, 13, 15]: if id_particles[1] in [11, 13, 15]: # ll cat_sm = 4 elif id_particles[1] in [12, 14, 16]: # nu l cat_sm = 5 elif id_particles[0] in [12, 14, 16]: if id_particles[1] in [11, 13, 15]: # nu l cat_sm = 5 elif id_particles[1] in [12, 14, 16]: # nu nu cat_sm = 6 if cat_sm == 0: LGR.warning( 'Decay channel category for SM particle(s) %s not ' 'found.', id_particles) return cat_sm
def _get_br_1leg(self, id_parent): """ Get branching ratio into particles for one particle. """ br_leptons_1leg = [] br_jets_1leg = [] br_photons_1leg = [] LGR.debug('Branching ratios for particle %s:', id_parent) # Loop over all decay modes for list_decay in self._prob_tree(id_parent): LGR.debug('list_decay: %s', list_decay) br_single = list_decay[0] # Check if we have unknown particles in the final state has_unknowns = False # Calculate number of particles for specific decay mode no_leptons = 0 no_jets = 0 no_photons = 0 for id_particle in list_decay[1]: if self._is_unknown(id_particle): has_unknowns = True no_leptons += self._is_lepton(id_particle) no_jets += self._is_jet(id_particle) no_photons += self._is_photon(id_particle) # Calculate total branching ratio for consistency; # this number will not exactly add up to 1, since rare decay modes # are missing and due to obnoxious python rounding errors if has_unknowns: continue # Make sure lists are long enough self._expand_list(br_leptons_1leg, no_leptons) self._expand_list(br_jets_1leg, no_jets) self._expand_list(br_photons_1leg, no_photons) # Fill branching ratio br_leptons_1leg[no_leptons] += br_single br_jets_1leg[no_jets] += br_single br_photons_1leg[no_photons] += br_single # If all lists are empty, we don't get any particles (LSP production) if not (br_leptons_1leg and br_jets_1leg and br_photons_1leg): br_leptons_1leg = [1] br_jets_1leg = [1] br_photons_1leg = [1] LGR.debug('Branching ratios into leptons: %s', br_leptons_1leg) LGR.debug('Branching ratios into jets: %s', br_jets_1leg) LGR.debug('Branching ratios into photons: %s', br_photons_1leg) LGR.debug('Total branching ratio: %s', sum(br_leptons_1leg)) return br_leptons_1leg, br_jets_1leg, br_photons_1leg
def _get_brs(self, id_parent_1, id_parent_2=-1., weight=1.): """ Get probabilites for branching into one, two, ... leptons and jets. This includes the combinatorics from 2 parent particles. The probabilities are weighted by weight. """ # If id_parent_2 is not set, set it to same value as id_parent_1 if id_parent_2 < 0: id_parent_2 = id_parent_1 br_leptons_1leg_1, br_jets_1leg_1, br_photons_1leg_1 = \ self._get_br_1leg(id_parent_1) # Don't call self._get_br_1leg() again if both parent particles are the # same if id_parent_2 == id_parent_1: br_leptons_1leg_2 = br_leptons_1leg_1 br_jets_1leg_2 = br_jets_1leg_1 br_photons_1leg_2 = br_photons_1leg_1 else: br_leptons_1leg_2, br_jets_1leg_2, br_photons_1leg_2 = \ self._get_br_1leg(id_parent_2) # Create list with right length br_leptons_2leg = [0] * (len(br_leptons_1leg_1) + len(br_leptons_1leg_2) - 1) br_jets_2leg = [0] * (len(br_jets_1leg_1) + len(br_jets_1leg_2) - 1) br_photons_2leg = [0] * (len(br_photons_1leg_1) + len(br_photons_1leg_2) - 1) # Combinatorics going from one leg to two legs for idx_l1, br_l1 in enumerate(br_leptons_1leg_1): for idx_l2, br_l2 in enumerate(br_leptons_1leg_2): br_leptons_2leg[idx_l1 + idx_l2] += br_l1 * br_l2 for idx_j1, br_j1 in enumerate(br_jets_1leg_1): for idx_j2, br_j2 in enumerate(br_jets_1leg_2): br_jets_2leg[idx_j1 + idx_j2] += br_j1 * br_j2 for idx_l1, br_l1 in enumerate(br_photons_1leg_1): for idx_l2, br_l2 in enumerate(br_photons_1leg_2): br_photons_2leg[idx_l1 + idx_l2] += br_l1 * br_l2 # If total branching ratio (for both legs) is under a certain # threshold, throw a warning; this can have many reasons, like unknown # (ignored) particle decays, or thresholds to limit computing time #if sum(br_leptons_2leg) < .9: # LGR.warning('The defined threshold led to a total branching ' # 'ratio of %s. You might want to consider lowering the ' # 'threshold.', sum(br_leptons_2leg)) LGR.debug('Parent particle (1st leg): %s', id_parent_1) LGR.debug('Parent particle (2nd leg): %s', id_parent_2) LGR.debug('Branching ratios into leptons (1st leg): %s', br_leptons_1leg_1) LGR.debug('Branching ratios into leptons (2nd leg): %s', br_leptons_1leg_2) LGR.debug('Branching ratios into leptons (both legs): %s', br_leptons_2leg) # Fill class variables for idx, br in enumerate(br_leptons_2leg): try: self._br_leptons[idx] += weight * br except IndexError: self._br_leptons.append(weight * br) for idx, br in enumerate(br_jets_2leg): try: self._br_jets[idx] += weight * br except IndexError: self._br_jets.append(weight * br) for idx, br in enumerate(br_photons_2leg): try: self._br_photons[idx] += weight * br except IndexError: self._br_photons.append(weight * br)
def _fill_dict_susy(self, id_particle): """ Translate SUSYHIT output into python dictionaries. The format of the dictionary is: dict[id_particle] = [ [prob., [child1, child2, ...]], [prob., [child1, child2, ...]], ... ] """ # Open SUSYHIT output file with open('{}/susyhit_slha.out'.format( self._dir_susyhit)) as f_susyhit_out: # Select range to be read from file f_susyhit_out_start = dropwhile( lambda l: not search('^DECAY *{}'.format(abs(id_particle)), l), f_susyhit_out) f_susyhit_out_range = takewhile( lambda l: not search('^# *PDG', l) and not search( '^XSECTION', l), f_susyhit_out_start) # LGR.debug('Range selected from SUSYHIT output file for particle ' # '%s:', id_particle) # List of all decays list_decays = [] # Loop over selected range and filter out comments for line in ifilterfalse(lambda l: search('^ *#|^DECAY', l), f_susyhit_out_range): # LGR.debug(line.rstrip()) # Split line into list, format is # [prob., # of childs, child1, child2, ..., comments] list_line_str_comments = line.rstrip().split() # LGR.debug('list: %s', list_line_str_comments) # Skip empty lines if len(list_line_str_comments) == 0: continue # Strip all comments from list_line_comments list_line_str = list( takewhile(lambda m: not str(m).startswith('#'), list_line_str_comments)) # LGR.debug('list stripped from comments: %s', list_line_str) del list_line_str_comments # list_line_str needs to have length of at least 4, otherwise # something's wrong with the input if len(list_line_str) < 3: raise IndexError('list_line_str {} needs to have at least ' '4 elements. Something seems to be wrong ' 'with the input.'.format(list_line_str)) # Convert first element (branching ratio) to float # and other elements (number of daughter particles and particle # ID's) to integers list_line = [] list_line.append(float(list_line_str[0])) list_line.append([int(x) for x in list_line_str[1:]]) # LGR.debug('list as numbers: %s', list_line) del list_line_str # According to SLHA format, second number per line should be # number of daughter particles if list_line[1][0] + 1 != len(list_line[1]): raise IndexError('According to SLHA format, second number ' 'per line should be number of daugher ' 'particles. Something seems to be wrong ' 'with the input.') # Once we checked for consistency, we can remove list_line[1], # since it is redundant del list_line[1][0] if isnan(list_line[0]): LGR.warning('Some decays have a branching ratio of "NaN" ' 'in the SUSYHIT output file. These decays are ' 'skipped.') continue # Fill list of decays list_decays.append(list_line) del list_line # Check if list of decays is empty if not list_decays: # If it is a SM particle, it probably needs to be filled by # hand, if it is a SUSY particle, it will be ignored #if abs(id_particle) < 1000000: # raise IndexError('SM particle {} could not be found in ' # 'dictionary. Maybe it needs to be filled' # ' by hand?'.format(id_particle)) # If the particle has no known decay modes, according to # SUSYHIT, then we define its decay to 100 % into the unknown # (and ignored) particle 999 (which is a final state) list_decays.append([1., [999]]) LGR.warning( 'Added particle %s to list of ignored particles. ' 'It does not seem to have any decay modes in the ' 'SUSYHIT output file.', id_particle) # Loop over list_decays to print debug information and sum up # branching ratios sum_br = 0 for list_decay in list_decays: sum_br += list_decay[0] LGR.debug('list_decay: %s', list_decay) # Fill dictionary self._d_susy[abs(id_particle)] = list_decays LGR.info( 'Filled decay modes from particle with ID %s into ' 'dictionary.', id_particle)
from Logger import Logger as LGR from threading import Lock, Thread from AWS_CREDS import Kinesis Logger = LGR(Lock(), '../LogFiles/Producer/Logs-', 'log_file_') LOG_FILE_PREFIX = "log_" from producer_meetups import Producer_Meetups as ProducerMeetups from producer_reddit import Producer_Reddit as ProducerReddit from producer_twitter import Producer_Twitter as ProducerTwitter try: objKinesis = Kinesis(Logger) PM, PR, PT = ProducerMeetups(Logger, objKinesis), ProducerReddit( Logger, objKinesis), ProducerTwitter(Logger, objKinesis, MULTIPLE_POST_SEND_LIMIT=100) reddit_thread = Thread(target=PR.run) print("Running Reddit production stream...") twitter_thread = Thread(target=PT.run) print("Running Twitter production stream...") meetups_thread = Thread(target=PM.run) print("Running Meetup production stream...") reddit_thread.start() twitter_thread.start() meetups_thread.start()
def _set_parameter_all(self, prmtr_x, prmtr_y): """ Set all parameters in the SLHA file. """ # Set main parameter in x # Some combinations are concatenated for axis labeling if self._prmtr_id_x == 4142: for newprmtr in range(41, 43): self._set_parameter_slha(newprmtr, prmtr_x) elif self._prmtr_id_x == 44454748: for newprmtr in [44, 45, 47, 48]: self._set_parameter_slha(newprmtr, prmtr_x) elif self._prmtr_id_x == 313233343536: for newprmtr in range(31, 37): self._set_parameter_slha(newprmtr, prmtr_x) else: self._set_parameter_slha(self._prmtr_id_x, prmtr_x) # Set main parameter in y if self._prmtr_id_y == 4142: for newprmtr in range(41, 43): self._set_parameter_slha(newprmtr, prmtr_y) elif self._prmtr_id_y == 44454748: for newprmtr in [44, 45, 47, 48]: self._set_parameter_slha(newprmtr, prmtr_y) elif self._prmtr_id_y == 313233343536: for newprmtr in range(31, 37): self._set_parameter_slha(newprmtr, prmtr_y) else: self._set_parameter_slha(self._prmtr_id_y, prmtr_y) # Set additional parameters in x (with possibly scale and offset) for key in set(self._d_prmtr_x_add.keys() + self._d_prmtr_x_scale.keys()): if key == 4142: for newkey in range(41, 43): scale = self._d_prmtr_x_scale[key] value = self._d_prmtr_x_add[key] self._set_parameter_slha(newkey, scale * prmtr_x + value) elif key == 44454748: for newkey in [44, 45, 47, 48]: scale = self._d_prmtr_x_scale[key] value = self._d_prmtr_x_add[key] self._set_parameter_slha(newkey, scale * prmtr_x + value) elif key == 313233343536: for newkey in range(31, 37): scale = self._d_prmtr_x_scale[key] value = self._d_prmtr_x_add[key] self._set_parameter_slha(newkey, scale * prmtr_x + value) else: scale = self._d_prmtr_x_scale[key] value = self._d_prmtr_x_add[key] self._set_parameter_slha(key, scale * prmtr_x + value) # Set additional parameters in y (with possibly scale and offset) for key in set(self._d_prmtr_y_add.keys() + self._d_prmtr_y_scale.keys()): if key == 4142: for newkey in range(41, 43): scale = self._d_prmtr_y_scale[key] value = self._d_prmtr_y_add[key] self._set_parameter_slha(newkey, scale * prmtr_y + value) elif key == 44454748: for newkey in [44, 45, 47, 48]: scale = self._d_prmtr_y_scale[key] value = self._d_prmtr_y_add[key] LGR.warning(self._d_prmtr_y_add) self._set_parameter_slha(newkey, scale * prmtr_y + value) elif key == 313233343536: for newkey in range(31, 37): scale = self._d_prmtr_y_scale[key] value = self._d_prmtr_y_add[key] self._set_parameter_slha(newkey, scale * prmtr_y + value) else: scale = self._d_prmtr_y_scale[key] value = self._d_prmtr_y_add[key] self._set_parameter_slha(key, scale * prmtr_y + value)