def notify_subscribers(self, *args, **kwargs): Observable.notify_subscribers(self, *args, **kwargs)
def notify_subscribers(self, arg=["", "", ""]): Observable.notify_subscribers(self, arg)
class PhaseTablePresenter(object): def __init__(self, view, context): self.view = view self.context = context self.current_alg = None self.group_change_observer = GenericObserver( self.update_current_groups_list) self.run_change_observer = GenericObserver( self.update_current_run_list) self.instrument_changed_observer = GenericObserver( self.update_current_phase_tables) self.phase_table_calculation_complete_notifier = Observable() self.phase_quad_calculation_complete_nofifier = Observable() self.update_current_phase_tables() def update_view_from_model(self): for key, item in self.context.phase_context.options_dict.items(): setattr(self.view, key, item) def update_model_from_view(self): for key in self.context.phase_context.options_dict: self.context.phase_context.options_dict[key] = getattr( self.view, key, None) def cancel(self): if self.current_alg is not None: self.current_alg.cancel() def handle_calulate_phase_table_clicked(self): self.update_model_from_view() self.calculation_thread = self.create_calculation_thread() self.calculation_thread.threadWrapperSetUp( self.handle_phase_table_calculation_started, self.handle_calculation_success, self.handle_calculation_error) self.calculation_thread.start() def create_calculation_thread(self): self._calculation_model = ThreadModelWrapper( self.calculate_phase_table) return thread_model.ThreadModel(self._calculation_model) def handle_calculate_phase_quad_button_clicked(self): self.update_model_from_view() self.phasequad_calculation_thread = self.create_phase_quad_calculation_thread( ) self.phasequad_calculation_thread.threadWrapperSetUp( self.handle_calculation_started, self.handle_calculation_success, self.handle_calculation_error) self.phasequad_calculation_thread.start() def create_phase_quad_calculation_thread(self): self._phasequad_calculation_model = ThreadModelWrapper( self.calculate_phase_quad) return thread_model.ThreadModel(self._phasequad_calculation_model) def calculate_phase_quad(self): parameters = self.get_parameters_for_phase_quad() self.current_alg = mantid.AlgorithmManager.create("PhaseQuad") phase_quad = run_PhaseQuad(parameters, self.current_alg) self.current_alg = None self.add_phase_quad_to_ADS(parameters['InputWorkspace'], parameters['PhaseTable'], phase_quad) def get_parameters_for_phase_quad(self): parameters = {} if self.context.phase_context.options_dict[ 'phase_table_for_phase_quad'] == 'Construct': parameters['PhaseTable'] = self.calculate_phase_table() else: parameters['PhaseTable'] = self.context.phase_context.options_dict[ 'phase_table_for_phase_quad'] parameters['InputWorkspace'] = self.context.phase_context.options_dict[ 'phase_quad_input_workspace'] return parameters def add_phase_quad_to_ADS(self, input_workspace, input_phase_table, phase_quad): run = re.search('[0-9]+', input_workspace).group() phasequad_workspace_name = get_phase_quad_workspace_name( input_workspace, input_phase_table) phase_table_group = get_phase_table_workspace_group_name( phasequad_workspace_name, self.context.data_context.instrument) directory = get_base_data_directory(self.context, run) + phase_table_group muon_workspace_wrapper = MuonWorkspaceWrapper( phase_quad, directory + phasequad_workspace_name) muon_workspace_wrapper.show() self.context.phase_context.add_phase_quad(muon_workspace_wrapper) self.phase_quad_calculation_complete_nofifier.notify_subscribers() def handle_calculation_started(self): self.view.disable_widget() self.view.enable_phasequad_cancel() def handle_phase_table_calculation_started(self): self.view.disable_widget() self.view.enable_cancel() def handle_calculation_error(self, error): self.view.enable_widget() self.view.warning_popup(error) self.view.disable_cancel() self.current_alg = None def handle_calculation_success(self): self.phase_table_calculation_complete_notifier.notify_subscribers() self.update_current_phase_tables() self.view.enable_widget() self.view.disable_cancel() self.current_alg = None def calculate_phase_table(self): parameters = self.create_parameters_for_cal_muon_phase_algorithm() self.current_alg = mantid.AlgorithmManager.create( "CalMuonDetectorPhases") detector_table, fitting_information = run_CalMuonDetectorPhases( parameters, self.current_alg) self.current_alg = None self.add_phase_table_to_ADS(parameters['DetectorTable'], detector_table) self.add_fitting_info_to_ADS_if_required(parameters['DetectorTable'], fitting_information) return parameters['DetectorTable'] def add_phase_table_to_ADS(self, base_name, detector_table): run = re.search('[0-9]+', base_name).group() phase_table_group = get_phase_table_workspace_group_name( base_name, self.context.data_context.instrument) directory = get_base_data_directory(self.context, run) + phase_table_group muon_workspace_wrapper = MuonWorkspaceWrapper(detector_table, directory + base_name) muon_workspace_wrapper.show() self.context.phase_context.add_phase_table(muon_workspace_wrapper) def add_fitting_info_to_ADS_if_required(self, base_name, fitting_information): if not self.view.output_fit_information: return run = re.search('[0-9]+', base_name).group() phase_table_group = get_phase_table_workspace_group_name( base_name, self.context.data_context.instrument) fitting_workspace_name = get_fitting_workspace_name(base_name) directory = get_base_data_directory(self.context, run) + phase_table_group muon_workspace_wrapper = MuonWorkspaceWrapper( fitting_information, directory + fitting_workspace_name) muon_workspace_wrapper.show() def create_parameters_for_cal_muon_phase_algorithm(self): parameters = {} parameters['FirstGoodData'] = self.context.phase_context.options_dict[ 'first_good_time'] parameters['LastGoodData'] = self.context.phase_context.options_dict[ 'last_good_time'] parameters['InputWorkspace'] = self.context.phase_context.options_dict[ 'input_workspace'] forward_group = self.context.phase_context.options_dict[ 'forward_group'] parameters['ForwardSpectra'] = self.context.group_pair_context[ forward_group].detectors backward_group = self.context.phase_context.options_dict[ 'backward_group'] parameters['BackwardSpectra'] = self.context.group_pair_context[ backward_group].detectors parameters['DetectorTable'] = parameters['InputWorkspace'].replace( '_raw_data', '') + "; PhaseTable" parameters['DetectorTable'] = get_phase_table_workspace_name( parameters['InputWorkspace'], forward_group, backward_group) return parameters def update_current_run_list(self): self.view.set_input_combo_box(self.context.getGroupedWorkspaceNames()) self.view.set_group_combo_boxes( self.context.group_pair_context.group_names) self.update_model_from_view() def update_current_groups_list(self): self.view.set_group_combo_boxes( self.context.group_pair_context.group_names) self.update_model_from_view() def update_current_phase_tables(self): phase_table_list = self.context.phase_context.get_phase_table_list( self.context.data_context.instrument) phase_table_list.append('Construct') self.view.set_phase_table_combo_box(phase_table_list)
class MuonContext(object): def __init__(self, muon_data_context=None, muon_gui_context=None, muon_group_context=None, base_directory='Muon Data', muon_phase_context=None, workspace_suffix=' MA', fitting_context=None): self._data_context = muon_data_context self._gui_context = muon_gui_context self._group_pair_context = muon_group_context self._phase_context = muon_phase_context self.fitting_context = fitting_context self.base_directory = base_directory self.workspace_suffix = workspace_suffix self.ads_observer = MuonContextADSObserver( self.remove_workspace_by_name, self.clear_context) self.gui_context.update({ 'DeadTimeSource': 'None', 'LastGoodDataFromFile': True, 'selected_group_pair': '' }) self.update_view_from_model_notifier = Observable() @property def data_context(self): return self._data_context @property def gui_context(self): return self._gui_context @property def group_pair_context(self): return self._group_pair_context @property def phase_context(self): return self._phase_context def calculate_group(self, group_name, run, rebin=False): group_workspace = calculate_group_data(self, group_name, run, rebin) group_asymmetry, group_asymmetry_unnormalised = estimate_group_asymmetry_data( self, group_name, run, rebin) return group_workspace, group_asymmetry, group_asymmetry_unnormalised def calculate_pair(self, pair_name, run, rebin=False): return calculate_pair_data(self, pair_name, run, rebin) def show_all_groups(self): self.calculate_all_groups() for run in self._data_context.current_runs: for group_name in self._group_pair_context.group_names: run_as_string = run_list_to_string(run) directory = get_base_data_directory( self, run_as_string) + get_group_data_directory( self, run_as_string) name = get_group_data_workspace_name(self, group_name, run_as_string, rebin=False) asym_name = get_group_asymmetry_name(self, group_name, run_as_string, rebin=False) asym_name_unnorm = get_group_asymmetry_unnorm_name( self, group_name, run_as_string, 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, rebin=True) asym_name = get_group_asymmetry_name(self, group_name, run_as_string, rebin=True) asym_name_unnorm = get_group_asymmetry_unnorm_name( self, group_name, run_as_string, 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) + 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 calculate_all_pairs(self): for run in self._data_context.current_runs: for pair_name in self._group_pair_context.pair_names: pair_asymmetry_workspace = self.calculate_pair(pair_name, run) self.group_pair_context[pair_name].update_asymmetry_workspace( pair_asymmetry_workspace, run) if self._do_rebin(): pair_asymmetry_workspace = self.calculate_pair(pair_name, run, rebin=True) self.group_pair_context[ pair_name].update_asymmetry_workspace( pair_asymmetry_workspace, run, rebin=True) def calculate_all_groups(self): for run in self._data_context.current_runs: for group_name in self._group_pair_context.group_names: group_workspace, group_asymmetry, group_asymmetry_unormalised = self.calculate_group( group_name, run) self.group_pair_context[group_name].update_workspaces( run, group_workspace, group_asymmetry, group_asymmetry_unormalised, rebin=False) if self._do_rebin(): group_workspace, group_asymmetry, group_asymmetry_unormalised = self.calculate_group( group_name, run, rebin=True) self.group_pair_context[group_name].update_workspaces( run, group_workspace, group_asymmetry, group_asymmetry_unormalised, rebin=True) def update_current_data(self): # Update the current data; resetting the groups and pairs to their default values if len(self.data_context.current_runs) > 0: self.data_context.update_current_data() if not self.group_pair_context.groups: self.group_pair_context.reset_group_and_pairs_to_default( self.data_context.current_workspace, self.data_context.instrument, self.data_context.main_field_direction) else: self.data_context.clear() 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 _do_rebin(self): return (self.gui_context['RebinType'] == 'Fixed' and 'RebinFixed' in self.gui_context and self.gui_context['RebinFixed']) or\ (self.gui_context['RebinType'] == 'Variable' and 'RebinVariable' in self.gui_context and self.gui_context['RebinVariable']) def get_workspace_names_for_FFT_analysis(self, use_raw=True): workspace_options = self.get_names_of_workspaces_to_fit( runs='All', group_and_pair='All', phasequad=True, rebin=not use_raw) return workspace_options def get_detectors_excluded_from_default_grouping_tables(self): groups, _, _ = get_default_grouping( self.data_context.current_workspace, self.data_context.instrument, self.data_context.main_field_direction) detectors_in_group = [] for group in groups: detectors_in_group += group.detectors detectors_in_group = set(detectors_in_group) return [ det for det in range(1, self.data_context.num_detectors) if det not in detectors_in_group ] # Get the groups/pairs for active WS 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 first_good_data(self, run): if not self.data_context.get_loaded_data_for_run(run): return 0.0 if self.gui_context['FirstGoodDataFromFile']: return self.data_context.get_loaded_data_for_run( run)["FirstGoodData"] else: if 'FirstGoodData' in self.gui_context: return self.gui_context['FirstGoodData'] else: self.gui_context[ 'FirstGoodData'] = self.data_context.get_loaded_data_for_run( run)["FirstGoodData"] return self.gui_context['FirstGoodData'] def last_good_data(self, run): if not self.data_context.get_loaded_data_for_run(run): return 0.0 if self.gui_context['LastGoodDataFromFile']: return round( max( self.data_context.get_loaded_data_for_run(run) ["OutputWorkspace"][0].workspace.dataX(0)), 2) else: if 'LastGoodData' in self.gui_context: return self.gui_context['LastGoodData'] else: self.gui_context['LastGoodData'] = round( max( self.data_context.get_loaded_data_for_run(run) ["OutputWorkspace"][0].workspace.dataX(0)), 2) return self.gui_context['LastGoodData'] def dead_time_table(self, run): if self.gui_context['DeadTimeSource'] == 'FromADS': return self.gui_context['DeadTimeTable'] elif self.gui_context['DeadTimeSource'] == 'FromFile': return self.data_context.get_loaded_data_for_run( run)["DataDeadTimeTable"] elif self.gui_context['DeadTimeSource'] == 'None': return None 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 get_list_of_binned_or_unbinned_workspaces_from_equivalents( self, input_list): equivalent_list = [] for item in input_list: if 'PhaseQuad' in item: equivalent_list.append(item) equivalent_group_pair = self.group_pair_context.get_equivalent_group_pair( item) if equivalent_group_pair: equivalent_list.append(equivalent_group_pair) return equivalent_list def remove_workspace_by_name(self, workspace_name): self.data_context.remove_workspace_by_name(workspace_name) self.group_pair_context.remove_workspace_by_name(workspace_name) self.phase_context.remove_workspace_by_name(workspace_name) self.fitting_context.remove_workspace_by_name(workspace_name) self.update_view_from_model_notifier.notify_subscribers(workspace_name) def clear_context(self): self.data_context.clear() self.group_pair_context.clear() self.phase_context.clear() self.fitting_context.clear() self.update_view_from_model_notifier.notify_subscribers()
class FittingContext(object): """Context specific to fitting. It holds details are any fits performed including: - input workspaces - parameters - function names """ def __init__(self, fit_list=None): self.fit_list = fit_list if fit_list is not None else [] # Register callbacks with this object to observe when new fits # are added self.new_fit_notifier = Observable() self._number_of_fits = 0 self._number_of_fits_cache = 0 def __len__(self): """ :return: The number of fits in the list """ return len(self.fit_list) def add_fit_from_values(self, parameter_workspace, fit_function_name, input_workspace, output_workspace_names, global_parameters=None): """ Add a new fit information object based on the raw values. See FitInformation constructor for details are arguments. """ self.add_fit( FitInformation(parameter_workspace, fit_function_name, input_workspace, output_workspace_names, global_parameters)) def add_fit(self, fit): """ Add a new fit to the context. Subscribers are notified of the update. :param fit: A new FitInformation object """ if fit in self.fit_list: self.fit_list.pop(self.fit_list.index(fit)) self.fit_list.append(fit) self._number_of_fits += 1 self.new_fit_notifier.notify_subscribers() def fit_function_names(self): """ :return: a list of unique function names used in the fit """ return list(set([fit.fit_function_name for fit in self.fit_list])) def find_output_workspaces_for_input_workspace_name( self, input_workspace_name): """ Find the fits in the list whose input workspace matches :param input_workspace_name: The name of the input_workspace :return: A list of matching fits """ workspace_list = [] for fit in self.fit_list: for index, workspace in enumerate(fit.input_workspaces): if workspace == input_workspace_name: workspace_list.append(fit.output_workspace_names[index]) return workspace_list def remove_workspace_by_name(self, workspace_name): list_of_fits_to_remove = [] for fit in self.fit_list: if workspace_name in fit.output_workspace_names or workspace_name == fit.parameter_workspace_name: self._number_of_fits_cache = 0 list_of_fits_to_remove.append(fit) for fit in list_of_fits_to_remove: index = self.fit_list.index(fit) if index >= len(self.fit_list) - self._number_of_fits: self._number_of_fits -= 1 self.fit_list.remove(fit) def log_names(self, filter_fn=None): """ The names of the logs on the workspaces associated with all of the workspaces. :filter_fn: An optional unary function to filter the names out. For more information see FitInformation.log_names :return: A list of names of logs """ return [ name for fit in self.fit_list for name in fit.log_names(filter_fn) ] def clear(self): self.fit_list = [] def remove_latest_fit(self, number_of_fits_to_remove): self.fit_list = self.fit_list[:-number_of_fits_to_remove] self._number_of_fits = self._number_of_fits_cache self.new_fit_notifier.notify_subscribers() @property def number_of_fits(self): return self._number_of_fits @number_of_fits.setter def number_of_fits(self, value): self._number_of_fits_cache = self._number_of_fits self._number_of_fits = value
def notify_subscribers(self, arg=None): Observable.notify_subscribers(self, arg)
class PhaseTablePresenter(object): def __init__(self, view, context): self.view = view self.context = context self.current_alg = None self.group_change_observer = GenericObserver(self.update_current_groups_list) self.run_change_observer = GenericObserver(self.update_current_run_list) self.instrument_changed_observer = GenericObserver(self.update_current_phase_tables) self.phase_table_calculation_complete_notifier = Observable() self.phase_quad_calculation_complete_nofifier = Observable() self.update_current_phase_tables() def update_view_from_model(self): for key, item in self.context.phase_context.options_dict.items(): setattr(self.view, key, item) def update_model_from_view(self): for key in self.context.phase_context.options_dict: self.context.phase_context.options_dict[key] = getattr(self.view, key, None) def cancel(self): if self.current_alg is not None: self.current_alg.cancel() def handle_calulate_phase_table_clicked(self): self.update_model_from_view() self.calculation_thread = self.create_calculation_thread() self.calculation_thread.threadWrapperSetUp(self.handle_phase_table_calculation_started, self.handle_calculation_success, self.handle_calculation_error) self.calculation_thread.start() def create_calculation_thread(self): self._calculation_model = ThreadModelWrapper(self.calculate_phase_table) return thread_model.ThreadModel(self._calculation_model) def handle_calculate_phase_quad_button_clicked(self): self.update_model_from_view() self.phasequad_calculation_thread = self.create_phase_quad_calculation_thread() self.phasequad_calculation_thread.threadWrapperSetUp(self.handle_calculation_started, self.handle_calculation_success, self.handle_calculation_error) self.phasequad_calculation_thread.start() def create_phase_quad_calculation_thread(self): self._phasequad_calculation_model = ThreadModelWrapper(self.calculate_phase_quad) return thread_model.ThreadModel(self._phasequad_calculation_model) def calculate_phase_quad(self): parameters = self.get_parameters_for_phase_quad() self.current_alg = mantid.AlgorithmManager.create("PhaseQuad") phase_quad = run_PhaseQuad(parameters, self.current_alg) self.current_alg = None self.add_phase_quad_to_ADS(parameters['InputWorkspace'], parameters['PhaseTable'], phase_quad) def get_parameters_for_phase_quad(self): parameters = {} if self.context.phase_context.options_dict['phase_table_for_phase_quad'] == 'Construct': parameters['PhaseTable'] = self.calculate_phase_table() else: parameters['PhaseTable'] = self.context.phase_context.options_dict['phase_table_for_phase_quad'] parameters['InputWorkspace'] = self.context.phase_context.options_dict['phase_quad_input_workspace'] return parameters def add_phase_quad_to_ADS(self, input_workspace, input_phase_table, phase_quad): run = re.search('[0-9]+', input_workspace).group() phasequad_workspace_name = get_phase_quad_workspace_name(input_workspace, input_phase_table) phase_table_group = get_phase_table_workspace_group_name(phasequad_workspace_name, self.context.data_context.instrument) directory = get_base_data_directory(self.context, run) + phase_table_group muon_workspace_wrapper = MuonWorkspaceWrapper(phase_quad, directory + phasequad_workspace_name) muon_workspace_wrapper.show() self.context.phase_context.add_phase_quad(muon_workspace_wrapper) self.phase_quad_calculation_complete_nofifier.notify_subscribers() def handle_calculation_started(self): self.view.disable_widget() self.view.enable_phasequad_cancel() def handle_phase_table_calculation_started(self): self.view.disable_widget() self.view.enable_cancel() def handle_calculation_error(self, error): self.view.enable_widget() self.view.warning_popup(error) self.view.disable_cancel() self.current_alg = None def handle_calculation_success(self): self.phase_table_calculation_complete_notifier.notify_subscribers() self.update_current_phase_tables() self.view.enable_widget() self.view.disable_cancel() self.current_alg = None def calculate_phase_table(self): parameters = self.create_parameters_for_cal_muon_phase_algorithm() self.current_alg = mantid.AlgorithmManager.create("CalMuonDetectorPhases") detector_table, fitting_information = run_CalMuonDetectorPhases(parameters, self.current_alg) self.current_alg = None self.add_phase_table_to_ADS(parameters['DetectorTable'], detector_table) self.add_fitting_info_to_ADS_if_required(parameters['DetectorTable'], fitting_information) return parameters['DetectorTable'] def add_phase_table_to_ADS(self, base_name, detector_table): run = re.search('[0-9]+', base_name).group() phase_table_group = get_phase_table_workspace_group_name(base_name, self.context.data_context.instrument) directory = get_base_data_directory(self.context, run) + phase_table_group muon_workspace_wrapper = MuonWorkspaceWrapper(detector_table, directory + base_name) muon_workspace_wrapper.show() self.context.phase_context.add_phase_table(muon_workspace_wrapper) def add_fitting_info_to_ADS_if_required(self, base_name, fitting_information): if not self.view.output_fit_information: return run = re.search('[0-9]+', base_name).group() phase_table_group = get_phase_table_workspace_group_name(base_name, self.context.data_context.instrument) fitting_workspace_name = get_fitting_workspace_name(base_name) directory = get_base_data_directory(self.context, run) + phase_table_group muon_workspace_wrapper = MuonWorkspaceWrapper(fitting_information, directory + fitting_workspace_name) muon_workspace_wrapper.show() def create_parameters_for_cal_muon_phase_algorithm(self): parameters = {} parameters['FirstGoodData'] = self.context.phase_context.options_dict['first_good_time'] parameters['LastGoodData'] = self.context.phase_context.options_dict['last_good_time'] parameters['InputWorkspace'] = self.context.phase_context.options_dict['input_workspace'] forward_group = self.context.phase_context.options_dict['forward_group'] parameters['ForwardSpectra'] = self.context.group_pair_context[forward_group].detectors backward_group = self.context.phase_context.options_dict['backward_group'] parameters['BackwardSpectra'] = self.context.group_pair_context[backward_group].detectors parameters['DetectorTable'] = parameters['InputWorkspace'].replace('_raw_data', '') + "; PhaseTable" parameters['DetectorTable'] = get_phase_table_workspace_name(parameters['InputWorkspace'], forward_group, backward_group) return parameters def update_current_run_list(self): self.view.set_input_combo_box(self.context.getGroupedWorkspaceNames()) self.view.set_group_combo_boxes(self.context.group_pair_context.group_names) self.update_model_from_view() def update_current_groups_list(self): self.view.set_group_combo_boxes(self.context.group_pair_context.group_names) self.update_model_from_view() def update_current_phase_tables(self): phase_table_list = self.context.phase_context.get_phase_table_list(self.context.data_context.instrument) phase_table_list.append('Construct') self.view.set_phase_table_combo_box(phase_table_list)
def notify_subscribers(self, *args, **kwargs): Observable.notify_subscribers(self, *args)