def show_group(self, run, group, rebin): run_as_string = run_list_to_string(run) group_name = group.name periods = run_list_to_string(group.periods) directory = get_base_data_directory(self, run_as_string) name = get_group_data_workspace_name(self, group_name, run_as_string, periods, rebin=rebin) asym_name = get_group_asymmetry_name(self, group_name, run_as_string, periods, rebin=rebin) asym_name_unnorm = get_group_asymmetry_unnorm_name(self, group_name, run_as_string, periods, rebin=rebin) if not rebin: self.group_pair_context[group_name].show_raw( run, directory + name, directory + asym_name, asym_name_unnorm) else: self.group_pair_context[group_name].show_rebin( run, directory + name, directory + asym_name, asym_name_unnorm)
def _create_XML_subElement_for_groups(root_node, groups): group_nodes = [] for group in groups: child = ET.SubElement(root_node, 'group', name=group.name) id_string = run_string_utils.run_list_to_string(group.detectors) ids = ET.SubElement(child, 'ids', val=id_string) child.extend(ids) period_string = run_string_utils.run_list_to_string(group.periods) periods = ET.SubElement(child, 'periods', val=period_string) child.extend(periods) group_nodes += [child] return group_nodes
def _calculate_counts_or_asymmetry(self, calculation_func, run, group, rebin=False): """Calculates the counts or asymmetry workspace depending on the 'calculation_func' that is provided.""" run_as_string = run_list_to_string(run) periods_as_string = run_list_to_string(group.periods) # A user requirement is that processing can continue if a period is missing from some # of the runs. This filters out periods which are not in a given run. periods = [period for period in group.periods if period <= self.num_periods(run)] if not periods: return None return calculation_func(run, group, periods, run_as_string, periods_as_string, rebin)
def add_group_to_view(self, group, state, color, tooltip): self._view.disable_updates() assert isinstance(group, MuonGroup) entry = [str(group.name), run_utils.run_list_to_string(group.periods), state, run_utils.run_list_to_string(group.detectors, False), str(group.n_detectors)] self._view.add_entry_to_table(entry, color, tooltip) self._view.enable_updates()
def current_runs(self) -> list: """Returns the currently selected run number in a list. If co-add is selected, there are multiple runs.""" for run_list in self._data_context.current_runs: if run_list_to_string( run_list) == self._corrections_context.current_run_string: return run_list return None
def calculate_phasequad(self, phasequad, run, rebin): parameters = {} parameters['PhaseTable'] = phasequad.phase_table run_string = run_list_to_string(run) ws_name = get_pair_phasequad_name(self, add_phasequad_extensions( phasequad.name), run_string, rebin=rebin) parameters['InputWorkspace'] = self._run_deadtime(run_string, ws_name) runs = self._data_context.current_runs if runs: parameters['InputWorkspace'] = run_crop_workspace( parameters['InputWorkspace'], self.first_good_data(runs[0]), self.last_good_data(runs[0])) phase_quad = run_PhaseQuad(parameters, ws_name) if rebin: dt = self._get_bin_width(phase_quad) phase_quad = self._run_rebin(phase_quad, True) phase_quad = self._average_by_bin_widths(phase_quad, dt) workspaces = split_phasequad(phase_quad) return workspaces
def show_raw_data(self): self.ads_observer.observeRename(False) for run in self.data_context.current_runs: with WorkspaceGroupDefinition(): run_string = run_list_to_string(run) loaded_workspace = self.data_context._loaded_data.get_data(run=run, instrument=self.data_context.instrument)['workspace'][ 'OutputWorkspace'] loaded_workspace_deadtime_table = self.corrections_context.get_default_dead_time_table_name_for_run( self.data_context.instrument, run) directory = get_base_data_directory( self, run_string) deadtime_name = get_deadtime_data_workspace_name(self.data_context.instrument, str(run[0]), workspace_suffix=self.workspace_suffix) MuonWorkspaceWrapper(loaded_workspace_deadtime_table).show(directory + deadtime_name) self.corrections_context.set_default_dead_time_table_name_for_run(self.data_context.instrument, run, deadtime_name) if len(loaded_workspace) > 1: # Multi-period data for i, single_ws in enumerate(loaded_workspace): name = directory + get_raw_data_workspace_name(self.data_context.instrument, run_string, multi_period=True, period=str(i + 1), workspace_suffix=self.workspace_suffix) single_ws.show(name) else: # Single period data name = directory + get_raw_data_workspace_name(self.data_context.instrument, run_string, multi_period=False, workspace_suffix=self.workspace_suffix) loaded_workspace[0].show(name) self.ads_observer.observeRename(True)
def set_run_edit_from_list(self, run_list): new_list = [] for run_item in run_list: if isinstance(run_item, int): new_list += [run_item] elif isinstance(run_item, list): for run in run_item: new_list += [run] run_string = run_utils.run_list_to_string(new_list) self._view.set_run_edit_text(run_string)
def calculate_diff(self, diff: MuonDiff, run: List[int], rebin: bool=False): try: positive_workspace_name = self._group_pair_context[diff.positive].get_asymmetry_workspace_for_run(run, rebin) negative_workspace_name = self._group_pair_context[diff.negative].get_asymmetry_workspace_for_run(run, rebin) except KeyError: # A key error here means the requested workspace does not exist so return None return None run_as_string = run_list_to_string(run) output_workspace_name = get_diff_asymmetry_name(self, diff.name, run_as_string, rebin=rebin) return run_minus(positive_workspace_name, negative_workspace_name, output_workspace_name)
def getWorkspaceNames(self): # get runs run_list = [run_list_to_string(run) for run in self.context.data_context.current_runs] self.view.addRuns(run_list) # get periods self._load_periods() # get min number of points as a power of 2 start = int( math.ceil(math.log(self.context.data_context.num_points) / math.log(2.0))) values = [str(2**k) for k in range(start, 21)] self.view.addNPoints(values)
def create_multiple_field_directions_error_message(self, run_list): transverse = [] longitudinal = [] for run in run_list: field_direction = self._loaded_data.get_main_field_direction( run=run, instrument=self.instrument) if field_direction.lower() == 'transverse': transverse += run elif field_direction.lower() == 'longitudinal': longitudinal += run else: return 'Unrecognised field direction {} for run {}'.format( field_direction, run) message = 'MainFieldDirection changes within current run set:\n' message += 'transverse field runs {}\n'.format( run_list_to_string(transverse)) message += 'longitudinal field runs {}\n'.format( run_list_to_string(longitudinal)) return message
def calculate_pair(self, pair: MuonPair, run: List[int], rebin: bool=False): try: forward_group_workspace_name = self._group_pair_context[pair.forward_group].get_counts_workspace_for_run(run, rebin) backward_group_workspace_name = self._group_pair_context[pair.backward_group].get_counts_workspace_for_run(run, rebin) except KeyError: # A key error here means the requested workspace does not exist so return None return None run_as_string = run_list_to_string(run) output_workspace_name = get_pair_asymmetry_name(self, pair.name, run_as_string, rebin=rebin) return calculate_pair_data(pair, forward_group_workspace_name, backward_group_workspace_name, output_workspace_name)
def getGroupedWorkspaceNames(self): run_numbers = self.data_context.current_runs runs = [ wsName.get_raw_data_workspace_name( self.data_context.instrument, run_list_to_string(run_number), self.data_context.is_multi_period(), period=str(period + 1), workspace_suffix=self.workspace_suffix) for run_number in run_numbers for period in range(self.data_context.num_periods(run_number))] return runs
def show_diff(self, run: list, diff: MuonDiff): diff_name = diff.name run_as_string = run_list_to_string(run) name = get_diff_asymmetry_name(self, diff_name, run_as_string, rebin=False) directory = get_base_data_directory(self, run_as_string) self.group_pair_context[diff_name].show_raw(run, directory + name) if self._do_rebin(): name = get_diff_asymmetry_name(self, diff_name, run_as_string, rebin=True) self.group_pair_context[diff_name].show_rebin(run, directory + name)
def show_pair(self, run: list, pair: MuonPair): pair_name = pair.name # Do not want to rename phasequad parts here if "_Re_" in pair_name or "_Im_" in pair_name: return run_as_string = run_list_to_string(run) name = get_pair_asymmetry_name(self, pair_name, run_as_string, rebin=False) directory = get_base_data_directory(self, run_as_string) self.group_pair_context[pair_name].show_raw(run, directory + name) if self._do_rebin(): name = get_pair_asymmetry_name(self, pair_name, run_as_string, rebin=True) self.group_pair_context[pair_name].show_rebin(run, directory + name)
def _calculate_phasequads(self, phasequad_obj, rebin): for run in self._data_context.current_runs: if self._data_context.num_periods(run) > 1: raise ValueError("Cannot support multiple periods") ws_list = self.calculate_phasequad(phasequad_obj, run, rebin) run_string = run_list_to_string(run) directory = get_base_data_directory(self, run_string) for ws in ws_list: muon_workspace_wrapper = MuonWorkspaceWrapper(directory + ws) muon_workspace_wrapper.show() phasequad_obj.update_asymmetry_workspaces(ws_list, run, rebin=rebin)
def test_run_list_to_string_removes_duplicated_runs(self): run_list = [1, 1, 2, 2, 3, 4, 5, 3] run_string = utils.run_list_to_string(run_list) self.assertEqual(run_string, "1-5")
def run_number_strings(self) -> list: """Returns a list of run number strings from the context. Its a string because of co-add mode.""" return [ run_list_to_string(run_list) for run_list in self._data_context.current_runs ]
def create_tiled_keys(self, tiled_by): if tiled_by == "Group/Pair": keys = self.context.group_pair_context.selected_groups_and_pairs else: keys = [run_list_to_string(item) for item in self.context.data_context.current_runs] return keys
def test_run_list_to_string_for_consecutive_runs(self): run_list = [1, 2, 3, 4, 5] run_string = utils.run_list_to_string(run_list) self.assertEqual(run_string, "1-5")
def test_run_list_to_string_doesnt_throw_if_more_than_100_runs(self): run_list = [i for i in range(150)] utils.run_list_to_string(run_list)
def test_run_list_to_string_orders_run_numbers(self): run_list = [5, 3, 2, 4, 1] run_string = utils.run_list_to_string(run_list) self.assertEqual(run_string, "1-5")
def gen_run_list(self): run_list = [] for run in self.context.data_context.current_runs: run_list.append(run_list_to_string(run)) return run_list
def test_run_list_to_string_removes_negative_runs(self): run_list = [-1, 1, 2, -2, 3, 4, 5, -3] run_string = utils.run_list_to_string(run_list) self.assertEqual(run_string, "1-5")
def get_pre_process_workspace_name(run: Iterable[int], instrument: str) -> str: workspace_name = "".join(["__", instrument, run_list_to_string(run), "_pre_processed_data"]) return workspace_name
def test_run_list_to_string_handles_non_consecutive_runs(self): run_lists = [[1, 3, 4, 5], [0, 1, 2, 3, 8, 9, 199, 200]] run_strings = ["1,3-5", "0-3,8-9,199-200"] for i in range(len(run_lists)): self.assertEqual(utils.run_list_to_string(run_lists[i]), run_strings[i])
def test_run_list_to_string_orders_non_consecutive_runs(self): run_list = [50, 49, 48, 3, 2, 1] run_string = utils.run_list_to_string(run_list) self.assertEqual(run_string, "1-3,48-50")
def __str__(self): return run_list_to_string(list(self._runs))