def run_sequential(systems, lbtime, run_iovs): result_iovs = IOVSet() for system in systems: log.info(" -- running for %s", system) system_result = run_one(system, lbtime, run_iovs) print_system_iovs(system_result) if system_result: result_iovs.extend(system_result) return result_iovs
def merge_input_variables(self, inputs): """ Merge multiple variables together for many channels. Takes a list of IOVSets, one for each DCSC_Variable. """ result = [] info_states = IOVSet(iov_type=GoodIOV) # Reassign inputs to be a list of dictionaries with # Key=channel_id and Val=IOVSet inputs = [iovs.by_channel for iovs in inputs] # set of channel ids all_channels = sorted(set(y for x in inputs for y in x.keys())) tally_system_states = config.opts.tally_system_states for channel in all_channels: # Handle one channel at a time for variable merging c_inputs = [x[channel] for x in inputs] # Merge "good" state across multiple variables result.append(self.merge_inputs(channel, *c_inputs)) if tally_system_states: # Merge Input information across multiple variables info_state = self.merge_input_information(channel, *c_inputs) info_states.extend(info_state) if tally_system_states: # Print a tally of the states for the different systems from DQUtils.ext import tally def pretty(state): return "/".join(x[0] for x in state) chans, iovs = zip(*sorted(six.iteritems(info_states.by_channel))) for since, until, states in process_iovs(self.run_iovs, *iovs): if states[0]._is_empty: # Not inside a run continue statetally = tally(pretty(x.good) for x in states[1:]) print(since, until, statetally) return result
def calculate_result(self, inputs_by_output, global_variables): """ Terrible name for a method. Calculate the iov extents and dead fractions for all output channels. In other words, the IoVs to be written to DCSOFL for this subdetector. """ result = IOVSet(iov_type=DCSOFL_IOV) # loop over output channel dictionary for channel, input_iovs in sorted(six.iteritems(inputs_by_output)): these_globals = self.select_globals(channel, global_variables) args = channel, input_iovs, these_globals result.extend(self.calculate_result_for_output(*args)) return result
def run_parallel(systems, lbtime, run_iovs, N): pool = Pool(N if N > 0 else len(systems)) results = [] for system in systems: result = pool.apply_async(run_one, (system, lbtime, run_iovs)) results.append(result) all_results = IOVSet() for system, result in zip(systems, map(lambda x: x.get(), results)): log.info(" -- result for %s", system) print_system_iovs(result) if result: all_results.extend(result) return all_results
def calculate_virtual_defects(primary_iovs, evaluation_order, virtual_output_channels, primary_output_channels, since, until, ignore): """ Returns a list of IoVs for a given query in the normal COOL order (sorted by channelID, then by since) """ if since == None: since = 0 if until == None: until = 2**63 - 1 since, until = RunLumi(since), RunLumi(until) result = defaultdict(IOVSet) primary_by_channel = primary_iovs.by_channel # Copy desired primary channels to the result for primary_channel, primary_iovs in primary_by_channel.iteritems(): if primary_channel in primary_output_channels: if ignore and primary_channel in ignore: continue result[primary_channel] = primary_iovs args = primary_by_channel, evaluation_order, since, until, ignore # Skip vfgen loop if there is no virtual logic to compute vfgen = [] if not evaluation_order else generate_virtual_defects(*args) for since, until, virtual_iovs in vfgen: if bad_iov(since, until): continue for output_name in virtual_output_channels: # Consider the state of each desired output for this # (since, until) and write it to output_iovs iov = virtual_iovs.get(output_name) if iov and iov.present: result[output_name].add(since, until, *iov[2:]) # Sort them by traditional COOL sort ordering (by channelId first, # then by since. `iovs` are already ordered by since.) result_list = IOVSet() for channel, iovs in sorted(result.iteritems()): result_list.extend(iovs.solidify(DEFECT_IOV)) return result_list
def run(self, lbtime, run_iovs): self.evaluate_inputs(lbtime) result = IOVSet() for variable in self.variables: result.extend(variable.iovs) return result