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 get_plot_title(self): """ Generates a title for the plot based on current instrument group and run numbers :return: Plot titles """ flattened_run_list = [ item for sublist in self.context.data_context.current_runs for item in sublist ] instrument = self.context.data_context.instrument plot_titles = [] if self._view.is_tiled_plot(): if self._view.get_tiled_by_type() == 'run': for run in flattened_run_list: plot_titles.append(instrument + str(run)) else: for grouppair in self.context.group_pair_context.selected_groups + \ self.context.group_pair_context.selected_pairs: title = self.context.data_context.instrument + ' ' + run_list_to_string(flattened_run_list) + \ ' ' + str(grouppair) plot_titles.append(title) return plot_titles else: return [ self.context.data_context.instrument + ' ' + run_list_to_string(flattened_run_list) ]
def getWorkspaceNames(self, use_raw): pair_names = list(self.context.group_pair_context.pair_names) group_names = list(self.context.group_pair_context.group_names) run_numbers = self.context.data_context.current_runs final_options = [] for run in run_numbers: final_options += [ wsName.get_raw_data_workspace_name(self.context, run_list_to_string(run), period=str(period + 1)) + " (PhaseQuad)" for period in range(self.context.data_context.num_periods(run)) ] for name in pair_names: final_options.append( wsName.get_pair_data_workspace_name( self.context, str(name), run_list_to_string(run), not use_raw)) for group_name in group_names: final_options.append( wsName.get_group_asymmetry_name(self.context, str(group_name), run_list_to_string(run), not use_raw)) return final_options
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 _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 show_all_groups(self): self.calculate_all_groups() for run in self._data_context.current_runs: with WorkspaceGroupDefinition(): for group in self._group_pair_context.groups: 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=False) asym_name = get_group_asymmetry_name(self, group_name, run_as_string, periods, rebin=False) asym_name_unnorm = get_group_asymmetry_unnorm_name( self, group_name, run_as_string, periods, rebin=False) self.group_pair_context[group_name].show_raw( run, directory + name, directory + asym_name, asym_name_unnorm) if self._do_rebin(): name = get_group_data_workspace_name(self, group_name, run_as_string, periods, rebin=True) asym_name = get_group_asymmetry_name(self, group_name, run_as_string, periods, rebin=True) asym_name_unnorm = get_group_asymmetry_unnorm_name( self, group_name, run_as_string, periods, rebin=True) self.group_pair_context[group_name].show_rebin( run, directory + name, directory + asym_name, asym_name_unnorm)
def show_all_pairs(self): self.calculate_all_pairs() for run in self._data_context.current_runs: for pair_name in self._group_pair_context.pair_names: run_as_string = run_list_to_string(run) name = get_pair_data_workspace_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_data_workspace_name( self, pair_name, run_as_string, rebin=True) self.group_pair_context[ pair_name].show_rebin(run, directory + name)
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 get_names_of_workspaces_to_fit(self, runs='', group_and_pair='', phasequad=False, rebin=False): if group_and_pair == 'All': group = self.group_pair_context.group_names pair = self.group_pair_context.pair_names else: group_pair_list = group_and_pair.replace(' ', '').split(',') group = [group for group in group_pair_list if group in self.group_pair_context.group_names] pair = [pair for pair in group_pair_list if pair in self.group_pair_context.pair_names] if runs == 'All': run_list = self.data_context.current_runs else: run_list = [run_string_to_list(item) for item in runs.replace(' ', '').split(',')] flat_list = [] for sublist in run_list: flat_list += [[run] for run in sublist if len(sublist) > 1] run_list += flat_list run_list = [run for run in run_list if run in self.data_context.current_runs] group_names = self.group_pair_context.get_group_workspace_names(run_list, group, rebin) pair_names = self.group_pair_context.get_pair_workspace_names(run_list, pair, rebin) phasequad_names = [] if phasequad: for run in run_list: run_string = run_list_to_string(run) phasequad_names += self.phase_context.get_phase_quad(self.data_context.instrument, run_string) return group_names + pair_names + phasequad_names
def calculate_pair(self, pair_name, run, rebin=False): run_as_string = run_list_to_string(run) name = get_pair_data_workspace_name(self, pair_name, run_as_string, rebin=rebin) return calculate_pair_data(self, pair_name, run, rebin, name)
def getGroupedWorkspaceNames(self): run_numbers = self.data_context.current_runs runs = [ wsName.get_raw_data_workspace_name( self, run_list_to_string(run_number), period=str(period + 1)) for run_number in run_numbers for period in range(self.data_context.num_periods(run_number))] return runs
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) group_nodes += [child] return group_nodes
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 get_plot_title(self): """ Generates a title for the plot based on current instrument group and run numbers :return: """ flattened_run_list = [ item for sublist in self.context.data_context.current_runs for item in sublist] return self.context.data_context.instrument + ' ' + run_list_to_string(flattened_run_list) + ' ' + \ self.context.group_pair_context.selected
def get_workspace_names_for_FFT_analysis(self, use_raw=True): pair_names = list(self.group_pair_context.pair_names) group_names = list(self.group_pair_context.group_names) run_numbers = self.data_context.current_runs workspace_options = [] for run in run_numbers: workspace_options += self.phase_context.get_phase_quad(self.data_context.instrument, run_list_to_string(run)) for name in pair_names: workspace_options.append( wsName.get_pair_data_workspace_name(self, str(name), run_list_to_string(run), not use_raw)) for group_name in group_names: workspace_options.append( wsName.get_group_asymmetry_name(self, str(group_name), run_list_to_string(run), not use_raw)) return workspace_options
def getWorkspaceNames(self, use_raw): pair_names = list(self.context.group_pair_context.pair_names) group_names = list(self.context.group_pair_context.group_names) run_numbers = self.context.data_context.current_runs final_options = [] for run in run_numbers: final_options += [ wsName.get_raw_data_workspace_name(self.context, run_list_to_string(run), period=str(period + 1)) + " (PhaseQuad)" for period in range(self.context.data_context.num_periods(run))] for name in pair_names: final_options.append( wsName.get_pair_data_workspace_name(self.context, str(name), run_list_to_string(run), not use_raw)) for group_name in group_names: final_options.append( wsName.get_group_asymmetry_name(self.context, str(group_name), run_list_to_string(run), not use_raw)) return final_options
def get_workspace_names_for_FFT_analysis(self, use_raw=True): pair_names = list(self.group_pair_context.pair_names) group_names = list(self.group_pair_context.group_names) run_numbers = self.data_context.current_runs workspace_options = [] for run in run_numbers: workspace_options += self.phase_context.get_phase_quad(self.data_context.instrument, run_list_to_string(run)) for name in pair_names: workspace_options.append( wsName.get_pair_data_workspace_name(self, str(name), run_list_to_string(run), not use_raw)) for group_name in group_names: workspace_options.append( wsName.get_group_asymmetry_name(self, str(group_name), run_list_to_string(run), not use_raw)) return workspace_options
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 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 getNPoints(self): run_numbers = self.context.data_context.current_runs ws = [wsName.get_raw_data_workspace_name(self.context, run_list_to_string(run_number)) for run_number in run_numbers] self.N_points = 1 for name in ws: data = mantid.AnalysisDataService.retrieve(name) if self.N_points < len(data.readX(0)): self.N_points = len(data.readX(0)) return self.N_points
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 run(self): try: # refer to the output of the loading widget (e.g. for co-adding) runs = run_list_to_string(self.current_run) except Exception: # extract from sample logs run_log = self.get_sample_log("run_number") if run_log: runs = run_log.value else: runs = 0 return runs
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 show_all_pairs(self): self.calculate_all_pairs() for run in self._data_context.current_runs: for pair_name in self._group_pair_context.pair_names: run_as_string = run_list_to_string(run) name = get_pair_data_workspace_name(self, pair_name, run_as_string, rebin=False) directory = get_base_data_directory(self, run_as_string) + get_pair_data_directory(self, run_as_string) self.group_pair_context[pair_name].show_raw(run, directory + name) if self._do_rebin(): name = get_pair_data_workspace_name(self, pair_name, run_as_string, rebin=True) self.group_pair_context[pair_name].show_rebin(run, directory + 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 _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 calculate_group(self, group, run, rebin=False): 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 match return nothing here. The caller then needs to handle this gracefully. if not periods: return None, None, None name = get_group_data_workspace_name(self, group.name, run_as_string, periods_as_string, rebin=rebin) asym_name = get_group_asymmetry_name(self, group.name, run_as_string, periods_as_string, rebin=rebin) asym_name_unnorm = get_group_asymmetry_unnorm_name(self, group.name, run_as_string, periods_as_string, rebin=rebin) group_workspace = calculate_group_data(self, group, run, rebin, name, periods) group_asymmetry, group_asymmetry_unnormalised = estimate_group_asymmetry_data( self, group, run, rebin, asym_name, asym_name_unnorm, periods) return group_workspace, group_asymmetry, group_asymmetry_unnormalised
def show_raw_data(self): for run in self.data_context.current_runs: 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'] directory = get_base_data_directory(self, run_string) + get_raw_data_directory(self, run_string) if len(loaded_workspace) > 1: # Multi-period data for i, single_ws in enumerate(loaded_workspace): name = directory + get_raw_data_workspace_name(self, run_string, period=str(i + 1)) single_ws.show(name) else: # Single period data name = directory + get_raw_data_workspace_name(self, run_string) loaded_workspace[0].show(name)
def show_raw_data(self): for run in self.data_context.current_runs: 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'] directory = get_base_data_directory(self, run_string) + get_raw_data_directory(self, run_string) if len(loaded_workspace) > 1: # Multi-period data for i, single_ws in enumerate(loaded_workspace): name = directory + get_raw_data_workspace_name(self, run_string, period=str(i + 1)) single_ws.show(name) else: # Single period data name = directory + get_raw_data_workspace_name(self, run_string) loaded_workspace[0].show(name)
def get_names_of_time_domain_workspaces_to_fit( self, runs='', group_and_pair='', phasequad=False, rebin=False): group, pair = self.get_group_and_pair(group_and_pair) run_list = self.get_runs(runs) group_names = self.group_pair_context.get_group_workspace_names( run_list, group, rebin) pair_names = self.group_pair_context.get_pair_workspace_names( run_list, pair, rebin) phasequad_names = [] if phasequad: for run in run_list: run_string = run_list_to_string(run) phasequad_names += self.phase_context.get_phase_quad( self.data_context.instrument, run_string) return group_names + pair_names + phasequad_names
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.data_context._loaded_data.get_data( run=run, instrument=self.data_context.instrument )['workspace']['DataDeadTimeTable'] 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.data_context._loaded_data.get_data( run=run, instrument=self.data_context.instrument )['workspace']['DataDeadTimeTable'] = 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 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 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 calculate_group(self, group_name, run, rebin=False): run_as_string = run_list_to_string(run) name = get_group_data_workspace_name(self, group_name, run_as_string, rebin=rebin) asym_name = get_group_asymmetry_name(self, group_name, run_as_string, rebin=rebin) asym_name_unnorm = get_group_asymmetry_unnorm_name(self, group_name, run_as_string, rebin=rebin) group_workspace = calculate_group_data(self, group_name, run, rebin, name) group_asymmetry, group_asymmetry_unnormalised = estimate_group_asymmetry_data( self, group_name, run, rebin, asym_name, asym_name_unnorm) return group_workspace, group_asymmetry, group_asymmetry_unnormalised
def get_fit_workspace_names_from_groups_and_runs(self, runs, groups_and_pairs): workspace_names = [] for run in runs: for group_or_pair in groups_and_pairs: if group_or_pair in self.context.group_pair_context.selected_pairs: workspace_names += [ get_pair_asymmetry_name( self.context, group_or_pair, run, not self.fitting_options["fit_to_raw"]) ] elif group_or_pair in self.context.group_pair_context.selected_groups: period_string = run_list_to_string( self.context.group_pair_context[group_or_pair].periods) workspace_names += [ get_group_asymmetry_name( self.context, group_or_pair, run, period_string, not self.fitting_options["fit_to_raw"]) ] return workspace_names
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 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 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 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 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 test_run_list_to_string_throws_if_more_than_100_runs(self): run_list = [i for i in range(150)] with self.assertRaises(IndexError) as context: utils.run_list_to_string(run_list) self.assertTrue("Too many runs (150) must be <100" in str(context.exception))
def getGroupedWorkspaceNames(self): run_numbers = self.data_context.current_runs runs = [ wsName.get_raw_data_workspace_name(self, run_list_to_string(run_number), period=str(period + 1)) for run_number in run_numbers for period in range(self.data_context.num_periods(run_number))] return runs
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 add_group_to_view(self, group): self._view.disable_updates() assert isinstance(group, MuonGroup) entry = [str(group.name), run_utils.run_list_to_string(group.detectors, False), str(group.n_detectors)] self._view.add_entry_to_table(entry) self._view.enable_updates()