class MaskingTablePresenter(object): DISPLAY_WORKSPACE_NAME = "__sans_mask_display_dummy_workspace" class ConcreteMaskingTableListener(MaskingTable.MaskingTableListener): def __init__(self, presenter): super(MaskingTablePresenter.ConcreteMaskingTableListener, self).__init__() self._presenter = presenter def on_row_changed(self): self._presenter.on_row_changed() def on_update_rows(self): self._presenter.on_update_rows() def on_display(self): self._presenter.on_display() class DisplayMaskListener(WorkHandler.WorkListener): def __init__(self, presenter): super(MaskingTablePresenter.DisplayMaskListener, self).__init__() self._presenter = presenter def on_processing_finished(self, result): self._presenter.on_processing_finished_masking_display(result) def on_processing_error(self, error): self._presenter.on_processing_error_masking_display(error) def __init__(self, parent_presenter): super(MaskingTablePresenter, self).__init__() self._view = None self._parent_presenter = parent_presenter self._work_handler = WorkHandler() self._logger = Logger("SANS") def on_row_changed(self): row_index = self._view.get_current_row() state = self.get_state(row_index, file_lookup=False) if state: self.display_masking_information(state) def on_display(self): # Get the state information for the selected row. # Disable the button self._view.set_display_mask_button_to_processing() try: row_index = self._view.get_current_row() state = self.get_state(row_index) except Exception as e: self.on_processing_error_masking_display(e) raise Exception(str(e)) # propagate errors for run_tab_presenter to deal with else: if not state: self._logger.information("You can only show a masked workspace if a user file has been loaded and there" "valid sample scatter entry has been provided in the selected row.") return # Run the task listener = MaskingTablePresenter.DisplayMaskListener(self) state_copy = copy.copy(state) self._work_handler.process(listener, load_and_mask_workspace, 0, state_copy, self.DISPLAY_WORKSPACE_NAME) def on_processing_finished_masking_display(self, result): # Enable button self._view.set_display_mask_button_to_normal() # Display masked workspace self._display(result) def on_processing_error_masking_display(self, error): self._logger.warning("There has been an error. See more: {}".format(error)) # Enable button self._view.set_display_mask_button_to_normal() def on_processing_error(self, error): pass def on_update_rows(self): """ Update the row selection in the combobox """ current_row_index = self._view.get_current_row() valid_row_indices = self._parent_presenter.get_row_indices() new_row_index = -1 if current_row_index in valid_row_indices: new_row_index = current_row_index elif len(valid_row_indices) > 0: new_row_index = valid_row_indices[0] self._view.update_rows(valid_row_indices) if new_row_index != -1: self.set_row(new_row_index) self.on_row_changed() def set_row(self, index): self._view.set_row(index) def set_view(self, view): if view: self._view = view # Set up row selection listener listener = MaskingTablePresenter.ConcreteMaskingTableListener(self) self._view.add_listener(listener) # Set the default gui self._set_default_gui() def _set_default_gui(self): self._view.update_rows([]) self.display_masking_information(state=None) def get_state(self, index, file_lookup=True): return self._parent_presenter.get_state_for_row(index, file_lookup=file_lookup) @staticmethod def _append_single_spectrum_mask(spectrum_mask, container, detector_name, prefix): if spectrum_mask: for item in spectrum_mask: detail = prefix + str(item) container.append(masking_information(first="Spectrum", second=detector_name, third=detail)) @staticmethod def _append_strip_spectrum_mask(strip_mask_start, strip_mask_stop, container, detector_name, prefix): if strip_mask_start and strip_mask_stop: for start, stop in zip(strip_mask_start, strip_mask_stop): detail = prefix + str(start) + ">" + prefix + str(stop) container.append(masking_information(first="Strip", second=detector_name, third=detail)) @staticmethod def _append_block_spectrum_mask(horizontal_mask_start, horizontal_mask_stop, vertical_mask_start, vertical_mask_stop, container, detector_name): if horizontal_mask_start and horizontal_mask_stop and vertical_mask_start and vertical_mask_stop: for h_start, h_stop, v_start, v_stop in zip(horizontal_mask_start, horizontal_mask_stop, vertical_mask_start, vertical_mask_stop): detail = "H{}>H{}+V{}>V{}".format(h_start, h_stop, v_start, v_stop) container.append(masking_information(first="Strip", second=detector_name, third=detail)) @staticmethod def _append_spectrum_block_cross_mask(horizontal_mask, vertical_mask, container, detector_name): if horizontal_mask and vertical_mask: for h, v in zip(horizontal_mask, vertical_mask): detail = "H{}+V{}".format(h, v) container.append(masking_information(first="Strip", second=detector_name, third=detail)) @staticmethod def _get_spectrum_masks(mask_detector_info): detector_name = mask_detector_info.detector_name spectrum_masks = [] # ------------------------------- # Get the vertical spectrum masks # ------------------------------- single_vertical_strip_mask = mask_detector_info.single_vertical_strip_mask MaskingTablePresenter._append_single_spectrum_mask(single_vertical_strip_mask, spectrum_masks, detector_name, "V") range_vertical_strip_start = mask_detector_info.range_vertical_strip_start range_vertical_strip_stop = mask_detector_info.range_vertical_strip_stop MaskingTablePresenter._append_strip_spectrum_mask(range_vertical_strip_start, range_vertical_strip_stop, spectrum_masks, detector_name, "V") # --------------------------------- # Get the horizontal spectrum masks # --------------------------------- single_horizontal_strip_mask = mask_detector_info.single_horizontal_strip_mask MaskingTablePresenter._append_single_spectrum_mask(single_horizontal_strip_mask, spectrum_masks, detector_name, "H") range_horizontal_strip_start = mask_detector_info.range_horizontal_strip_start range_horizontal_strip_stop = mask_detector_info.range_horizontal_strip_stop MaskingTablePresenter._append_strip_spectrum_mask(range_horizontal_strip_start, range_horizontal_strip_stop, spectrum_masks, detector_name, "H") # --------------------------------- # Get the block masks # --------------------------------- block_horizontal_start = mask_detector_info.block_horizontal_start block_horizontal_stop = mask_detector_info.block_horizontal_stop block_vertical_start = mask_detector_info.block_vertical_start block_vertical_stop = mask_detector_info.block_vertical_stop MaskingTablePresenter._append_block_spectrum_mask(block_horizontal_start, block_horizontal_stop, block_vertical_start, block_vertical_stop, spectrum_masks, detector_name) block_cross_horizontal = mask_detector_info.block_cross_horizontal block_cross_vertical = mask_detector_info.block_cross_vertical MaskingTablePresenter._append_spectrum_block_cross_mask(block_cross_horizontal, block_cross_vertical, spectrum_masks, detector_name) # --------------------------------- # Get spectrum masks # --------------------------------- single_spectra = mask_detector_info.single_spectra MaskingTablePresenter._append_single_spectrum_mask(single_spectra, spectrum_masks, detector_name, "S") spectrum_range_start = mask_detector_info.spectrum_range_start spectrum_range_stop = mask_detector_info.spectrum_range_stop MaskingTablePresenter._append_strip_spectrum_mask(spectrum_range_start, spectrum_range_stop, spectrum_masks, detector_name, "S") return spectrum_masks @staticmethod def _get_time_masks_general(mask_info): container = [] bin_mask_general_start = mask_info.bin_mask_general_start bin_mask_general_stop = mask_info.bin_mask_general_stop if bin_mask_general_start and bin_mask_general_stop: for start, stop in zip(bin_mask_general_start, bin_mask_general_stop): detail = "{}-{}".format(start, stop) container.append(masking_information(first="Time", second="", third=detail)) return container @staticmethod def _get_time_masks(mask_info): container = [] bin_mask_start = mask_info.bin_mask_start bin_mask_stop = mask_info.bin_mask_stop detector_name = mask_info.detector_name if bin_mask_start and bin_mask_stop: for start, stop in zip(bin_mask_start, bin_mask_stop): detail = "{}-{}".format(start, stop) container.append(masking_information(first="Time", second=detector_name, third=detail)) return container @staticmethod def _get_arm_mask(mask_info): container = [] beam_stop_arm_width = mask_info.beam_stop_arm_width beam_stop_arm_angle = mask_info.beam_stop_arm_angle beam_stop_arm_pos1 = mask_info.beam_stop_arm_pos1 if mask_info.beam_stop_arm_pos1 else 0. beam_stop_arm_pos2 = mask_info.beam_stop_arm_pos2 if mask_info.beam_stop_arm_pos2 else 0. if beam_stop_arm_width and beam_stop_arm_angle: detail = "LINE {}, {}, {}, {}".format(beam_stop_arm_width, beam_stop_arm_angle, beam_stop_arm_pos1, beam_stop_arm_pos2) container.append(masking_information(first="Arm", second="", third=detail)) return container @staticmethod def _get_phi_mask(mask_info): container = [] phi_min = mask_info.phi_min phi_max = mask_info.phi_max use_mask_phi_mirror = mask_info.use_mask_phi_mirror if phi_min and phi_max: if use_mask_phi_mirror: detail = "L/PHI {} {}".format(phi_min, phi_max) else: detail = "L/PHI/NOMIRROR{} {}".format(phi_min, phi_max) container.append(masking_information(first="Phi", second="", third=detail)) return container @staticmethod def _get_mask_files(mask_info): container = [] mask_files = mask_info.mask_files if mask_files: for mask_file in mask_files: container.append(masking_information(first="Mask file", second="", third=mask_file)) return container @staticmethod def _get_radius(mask_info): container = [] radius_min = mask_info.radius_min radius_max = mask_info.radius_max if radius_min: detail = "infinite-cylinder, r = {}".format(radius_min) container.append(masking_information(first="Beam stop", second="", third=detail)) if radius_max: detail = "infinite-cylinder, r = {}".format(radius_max) container.append(masking_information(first="Corners", second="", third=detail)) return container def _generate_masking_information(self, state): if state is None: return [] mask_info = state.mask masks = [] mask_info_lab = mask_info.detectors[DetectorType.to_string(DetectorType.LAB)] mask_info_hab = mask_info.detectors[DetectorType.to_string(DetectorType.HAB)] if DetectorType.to_string(DetectorType.HAB) in mask_info.detectors else None # noqa # Add the radius mask radius_mask = self._get_radius(mask_info) masks.extend(radius_mask) # Add the spectrum masks for LAB spectrum_masks_lab = self._get_spectrum_masks(mask_info_lab) masks.extend(spectrum_masks_lab) # Add the spectrum masks for HAB if mask_info_hab: spectrum_masks_hab = self._get_spectrum_masks(mask_info_hab) masks.extend(spectrum_masks_hab) # Add the general time mask time_masks_general = self._get_time_masks_general(mask_info) masks.extend(time_masks_general) # Add the time masks for LAB time_masks_lab = self._get_time_masks(mask_info_lab) masks.extend(time_masks_lab) # Add the time masks for HAB if mask_info_hab: time_masks_hab = self._get_time_masks(mask_info_hab) masks.extend(time_masks_hab) # Add arm mask arm_mask = self._get_arm_mask(mask_info) masks.extend(arm_mask) # Add phi mask phi_mask = self._get_phi_mask(mask_info) masks.extend(phi_mask) # Add mask files mask_files = self._get_mask_files(mask_info) masks.extend(mask_files) return masks def get_masking_information(self, state): table_entries = [] if state is not None: table_entries = self._generate_masking_information(state) return table_entries def display_masking_information(self, state): table_entries = self.get_masking_information(state) self._view.set_table(table_entries) @staticmethod def _display(masked_workspace): if masked_workspace and AnalysisDataService.doesExist(masked_workspace.name()): instrument_win = mantidplot.getInstrumentView(masked_workspace.name()) instrument_win.show()
class MaskingTablePresenter(object): DISPLAY_WORKSPACE_NAME = "__sans_mask_display_dummy_workspace" class ConcreteMaskingTableListener(MaskingTable.MaskingTableListener): def __init__(self, presenter): super(MaskingTablePresenter.ConcreteMaskingTableListener, self).__init__() self._presenter = presenter def on_row_changed(self): self._presenter.on_row_changed() def on_update_rows(self): self._presenter.on_update_rows() def on_display(self): self._presenter.on_display() class DisplayMaskListener(WorkHandler.WorkListener): def __init__(self, presenter): super(MaskingTablePresenter.DisplayMaskListener, self).__init__() self._presenter = presenter def on_processing_finished(self, result): self._presenter.on_processing_finished_masking_display(result) def on_processing_error(self, error): self._presenter.on_processing_error_masking_display(error) def __init__(self, parent_presenter): super(MaskingTablePresenter, self).__init__() self._view = None self._parent_presenter = parent_presenter self._work_handler = WorkHandler() self._logger = Logger("SANS") def on_row_changed(self): row_index = self._view.get_current_row() state = self.get_state(row_index) if state: self.display_masking_information(state) def on_display(self): # Get the state information for the selected row. row_index = self._view.get_current_row() state = self.get_state(row_index) if not state: self._logger.information( "You can only show a masked workspace if a user file has been loaded and there" "valid sample scatter entry has been provided in the selected row." ) return # Disable the button self._view.set_display_mask_button_to_processing() # Run the task listener = MaskingTablePresenter.DisplayMaskListener(self) state_copy = copy.copy(state) self._work_handler.process(listener, load_and_mask_workspace, state_copy, self.DISPLAY_WORKSPACE_NAME) def on_processing_finished_masking_display(self, result): # Enable button self._view.set_display_mask_button_to_normal() # Display masked workspace self._display(result) def on_processing_error_masking_display(self, error): self._logger.warning( "There has been an error. See more: {}".format(error)) def on_processing_error(self, error): pass def on_update_rows(self): """ Update the row selection in the combobox """ current_row_index = self._view.get_current_row() valid_row_indices = self._parent_presenter.get_row_indices() new_row_index = -1 if current_row_index in valid_row_indices: new_row_index = current_row_index elif len(valid_row_indices) > 0: new_row_index = valid_row_indices[0] self._view.update_rows(valid_row_indices) if new_row_index != -1: self.set_row(new_row_index) self.on_row_changed() def set_row(self, index): self._view.set_row(index) def set_view(self, view): if view: self._view = view # Set up row selection listener listener = MaskingTablePresenter.ConcreteMaskingTableListener(self) self._view.add_listener(listener) # Set the default gui self._set_default_gui() def _set_default_gui(self): self._view.update_rows([]) self.display_masking_information(state=None) def get_state(self, index): return self._parent_presenter.get_state_for_row(index) @staticmethod def _append_single_spectrum_mask(spectrum_mask, container, detector_name, prefix): if spectrum_mask: for item in spectrum_mask: detail = prefix + str(item) container.append( masking_information(first="Spectrum", second=detector_name, third=detail)) @staticmethod def _append_strip_spectrum_mask(strip_mask_start, strip_mask_stop, container, detector_name, prefix): if strip_mask_start and strip_mask_stop: for start, stop in zip(strip_mask_start, strip_mask_stop): detail = prefix + str(start) + ">" + prefix + str(stop) container.append( masking_information(first="Strip", second=detector_name, third=detail)) @staticmethod def _append_block_spectrum_mask(horizontal_mask_start, horizontal_mask_stop, vertical_mask_start, vertical_mask_stop, container, detector_name): if horizontal_mask_start and horizontal_mask_stop and vertical_mask_start and vertical_mask_stop: for h_start, h_stop, v_start, v_stop in zip( horizontal_mask_start, horizontal_mask_stop, vertical_mask_start, vertical_mask_stop): detail = "H{}>H{}+V{}>V{}".format(h_start, h_stop, v_start, v_stop) container.append( masking_information(first="Strip", second=detector_name, third=detail)) @staticmethod def _append_spectrum_block_cross_mask(horizontal_mask, vertical_mask, container, detector_name): if horizontal_mask and vertical_mask: for h, v in zip(horizontal_mask, vertical_mask): detail = "H{}+V{}".format(h, v) container.append( masking_information(first="Strip", second=detector_name, third=detail)) @staticmethod def _get_spectrum_masks(mask_detector_info): detector_name = mask_detector_info.detector_name spectrum_masks = [] # ------------------------------- # Get the vertical spectrum masks # ------------------------------- single_vertical_strip_mask = mask_detector_info.single_vertical_strip_mask MaskingTablePresenter._append_single_spectrum_mask( single_vertical_strip_mask, spectrum_masks, detector_name, "V") range_vertical_strip_start = mask_detector_info.range_vertical_strip_start range_vertical_strip_stop = mask_detector_info.range_vertical_strip_stop MaskingTablePresenter._append_strip_spectrum_mask( range_vertical_strip_start, range_vertical_strip_stop, spectrum_masks, detector_name, "V") # --------------------------------- # Get the horizontal spectrum masks # --------------------------------- single_horizontal_strip_mask = mask_detector_info.single_horizontal_strip_mask MaskingTablePresenter._append_single_spectrum_mask( single_horizontal_strip_mask, spectrum_masks, detector_name, "H") range_horizontal_strip_start = mask_detector_info.range_horizontal_strip_start range_horizontal_strip_stop = mask_detector_info.range_horizontal_strip_stop MaskingTablePresenter._append_strip_spectrum_mask( range_horizontal_strip_start, range_horizontal_strip_stop, spectrum_masks, detector_name, "H") # --------------------------------- # Get the block masks # --------------------------------- block_horizontal_start = mask_detector_info.block_horizontal_start block_horizontal_stop = mask_detector_info.block_horizontal_stop block_vertical_start = mask_detector_info.block_vertical_start block_vertical_stop = mask_detector_info.block_vertical_stop MaskingTablePresenter._append_block_spectrum_mask( block_horizontal_start, block_horizontal_stop, block_vertical_start, block_vertical_stop, spectrum_masks, detector_name) block_cross_horizontal = mask_detector_info.block_cross_horizontal block_cross_vertical = mask_detector_info.block_cross_vertical MaskingTablePresenter._append_spectrum_block_cross_mask( block_cross_horizontal, block_cross_vertical, spectrum_masks, detector_name) # --------------------------------- # Get spectrum masks # --------------------------------- single_spectra = mask_detector_info.single_spectra MaskingTablePresenter._append_single_spectrum_mask( single_spectra, spectrum_masks, detector_name, "S") spectrum_range_start = mask_detector_info.spectrum_range_start spectrum_range_stop = mask_detector_info.spectrum_range_stop MaskingTablePresenter._append_strip_spectrum_mask( spectrum_range_start, spectrum_range_stop, spectrum_masks, detector_name, "S") return spectrum_masks @staticmethod def _get_time_masks_general(mask_info): container = [] bin_mask_general_start = mask_info.bin_mask_general_start bin_mask_general_stop = mask_info.bin_mask_general_stop if bin_mask_general_start and bin_mask_general_stop: for start, stop in zip(bin_mask_general_start, bin_mask_general_stop): detail = "{}-{}".format(start, stop) container.append( masking_information(first="Time", second="", third=detail)) return container @staticmethod def _get_time_masks(mask_info): container = [] bin_mask_start = mask_info.bin_mask_start bin_mask_stop = mask_info.bin_mask_stop detector_name = mask_info.detector_name if bin_mask_start and bin_mask_stop: for start, stop in zip(bin_mask_start, bin_mask_stop): detail = "{}-{}".format(start, stop) container.append( masking_information(first="Time", second=detector_name, third=detail)) return container @staticmethod def _get_arm_mask(mask_info): container = [] beam_stop_arm_width = mask_info.beam_stop_arm_width beam_stop_arm_angle = mask_info.beam_stop_arm_angle beam_stop_arm_pos1 = mask_info.beam_stop_arm_pos1 if mask_info.beam_stop_arm_pos1 else 0. beam_stop_arm_pos2 = mask_info.beam_stop_arm_pos2 if mask_info.beam_stop_arm_pos2 else 0. if beam_stop_arm_width and beam_stop_arm_angle: detail = "LINE {}, {}, {}, {}".format(beam_stop_arm_width, beam_stop_arm_angle, beam_stop_arm_pos1, beam_stop_arm_pos2) container.append( masking_information(first="Arm", second="", third=detail)) return container @staticmethod def _get_phi_mask(mask_info): container = [] phi_min = mask_info.phi_min phi_max = mask_info.phi_max use_mask_phi_mirror = mask_info.use_mask_phi_mirror if phi_min and phi_max: if use_mask_phi_mirror: detail = "L/PHI {} {}".format(phi_min, phi_max) else: detail = "L/PHI/NOMIRROR{} {}".format(phi_min, phi_max) container.append( masking_information(first="Phi", second="", third=detail)) return container @staticmethod def _get_mask_files(mask_info): container = [] mask_files = mask_info.mask_files if mask_files: for mask_file in mask_files: container.append( masking_information(first="Mask file", second="", third=mask_file)) return container @staticmethod def _get_radius(mask_info): container = [] radius_min = mask_info.radius_min radius_max = mask_info.radius_max if radius_min: detail = "infinite-cylinder, r = {}".format(radius_min) container.append( masking_information(first="Beam stop", second="", third=detail)) if radius_max: detail = "infinite-cylinder, r = {}".format(radius_max) container.append( masking_information(first="Corners", second="", third=detail)) return container def _generate_masking_information(self, state): if state is None: return [] mask_info = state.mask masks = [] mask_info_lab = mask_info.detectors[DetectorType.to_string( DetectorType.LAB)] mask_info_hab = mask_info.detectors[DetectorType.to_string( DetectorType.HAB)] if DetectorType.to_string( DetectorType.HAB) in mask_info.detectors else None # noqa # Add the radius mask radius_mask = self._get_radius(mask_info) masks.extend(radius_mask) # Add the spectrum masks for LAB spectrum_masks_lab = self._get_spectrum_masks(mask_info_lab) masks.extend(spectrum_masks_lab) # Add the spectrum masks for HAB if mask_info_hab: spectrum_masks_hab = self._get_spectrum_masks(mask_info_hab) masks.extend(spectrum_masks_hab) # Add the general time mask time_masks_general = self._get_time_masks_general(mask_info) masks.extend(time_masks_general) # Add the time masks for LAB time_masks_lab = self._get_time_masks(mask_info_lab) masks.extend(time_masks_lab) # Add the time masks for HAB if mask_info_hab: time_masks_hab = self._get_time_masks(mask_info_hab) masks.extend(time_masks_hab) # Add arm mask arm_mask = self._get_arm_mask(mask_info) masks.extend(arm_mask) # Add phi mask phi_mask = self._get_phi_mask(mask_info) masks.extend(phi_mask) # Add mask files mask_files = self._get_mask_files(mask_info) masks.extend(mask_files) return masks def get_masking_information(self, state): table_entries = [] if state is not None: table_entries = self._generate_masking_information(state) return table_entries def display_masking_information(self, state): table_entries = self.get_masking_information(state) self._view.set_table(table_entries) @staticmethod def _display(masked_workspace): if masked_workspace and AnalysisDataService.doesExist( masked_workspace.name()): instrument_win = mantidplot.getInstrumentView( masked_workspace.name()) instrument_win.show()
class BeamCentrePresenter(object): class ConcreteBeamCentreListener(BeamCentre.BeamCentreListener): def __init__(self, presenter): self._presenter = presenter def on_run_clicked(self): self._presenter.on_run_clicked() class CentreFinderListener(WorkHandler.WorkListener): def __init__(self, presenter): super(BeamCentrePresenter.CentreFinderListener, self).__init__() self._presenter = presenter def on_processing_finished(self, result): self._presenter.on_processing_finished_centre_finder(result) def on_processing_error(self, error): self._presenter.on_processing_error_centre_finder(error) def __init__(self, parent_presenter, SANSCentreFinder, work_handler=None, beam_centre_model=None): self._view = None self._parent_presenter = parent_presenter self._work_handler = WorkHandler( ) if not work_handler else work_handler self._logger = Logger("SANS") self._beam_centre_model = BeamCentreModel( SANSCentreFinder) if not beam_centre_model else beam_centre_model def set_view(self, view): if view: self._view = view # Set up run listener listener = BeamCentrePresenter.ConcreteBeamCentreListener(self) self._view.add_listener(listener) # Set the default gui self._view.set_options(self._beam_centre_model) # Connect view signals self.connect_signals() def connect_signals(self): self._view.r_min_line_edit.textChanged.connect( self._validate_radius_values) self._view.r_max_line_edit.textChanged.connect( self._validate_radius_values) def on_update_instrument(self, instrument): self._beam_centre_model.set_scaling(instrument) self._view.on_update_instrument(instrument) def on_update_rows(self): self._beam_centre_model.reset_inst_defaults( self._parent_presenter.instrument) def on_processing_finished_centre_finder(self, result): # Enable button self._view.set_run_button_to_normal() # Update Centre Positions in model and GUI if self._beam_centre_model.update_lab: self._beam_centre_model.lab_pos_1 = result['pos1'] self._beam_centre_model.lab_pos_2 = result['pos2'] self._view.lab_pos_1 = self._beam_centre_model.lab_pos_1 * self._beam_centre_model.scale_1 self._view.lab_pos_2 = self._beam_centre_model.lab_pos_2 * self._beam_centre_model.scale_2 if self._beam_centre_model.update_hab: self._beam_centre_model.hab_pos_1 = result['pos1'] self._beam_centre_model.hab_pos_2 = result['pos2'] self._view.hab_pos_1 = self._beam_centre_model.hab_pos_1 * self._beam_centre_model.scale_1 self._view.hab_pos_2 = self._beam_centre_model.hab_pos_2 * self._beam_centre_model.scale_2 def on_processing_error_centre_finder(self, error): self._logger.warning( "There has been an error. See more: {}".format(error)) self._view.set_run_button_to_normal() def on_processing_error(self, error): self._view.set_run_button_to_normal() def on_run_clicked(self): self._work_handler.wait_for_done() # Get the state information for the first row. state = self._parent_presenter.get_state_for_row(0) if not state: self._logger.information( "You can only calculate the beam centre if a user file has been loaded and there" "valid sample scatter entry has been provided in the selected row." ) return # Disable the button self._view.set_run_button_to_processing() #Update model self._update_beam_model_from_view() # Run the task listener = BeamCentrePresenter.CentreFinderListener(self) state_copy = copy.copy(state) self._work_handler.process(listener, self._beam_centre_model.find_beam_centre, 0, state_copy) def _update_beam_model_from_view(self): self._beam_centre_model.r_min = self._view.r_min self._beam_centre_model.r_max = self._view.r_max self._beam_centre_model.max_iterations = self._view.max_iterations self._beam_centre_model.tolerance = self._view.tolerance self._beam_centre_model.left_right = self._view.left_right self._beam_centre_model.verbose = self._view.verbose self._beam_centre_model.COM = self._view.COM self._beam_centre_model.up_down = self._view.up_down self._beam_centre_model.lab_pos_1 = self._view.lab_pos_1 / self._beam_centre_model.scale_1 self._beam_centre_model.lab_pos_2 = self._view.lab_pos_2 / self._beam_centre_model.scale_2 self._beam_centre_model.hab_pos_1 = self._view.hab_pos_1 / self._beam_centre_model.scale_1 self._beam_centre_model.hab_pos_2 = self._view.hab_pos_2 / self._beam_centre_model.scale_2 self._beam_centre_model.q_min = self._view.q_min self._beam_centre_model.q_max = self._view.q_max self._beam_centre_model.component = self._view.component self._beam_centre_model.update_hab = self._view.update_hab self._beam_centre_model.update_lab = self._view.update_lab def update_centre_positions(self, state_model): lab_pos_1 = getattr(state_model, 'lab_pos_1') lab_pos_2 = getattr(state_model, 'lab_pos_2') hab_pos_1 = getattr(state_model, 'hab_pos_1') if getattr( state_model, 'hab_pos_1') else lab_pos_1 hab_pos_2 = getattr(state_model, 'hab_pos_2') if getattr( state_model, 'hab_pos_2') else lab_pos_2 self._view.lab_pos_1 = lab_pos_1 self._view.lab_pos_2 = lab_pos_2 self._view.hab_pos_1 = hab_pos_1 self._view.hab_pos_2 = hab_pos_2 def update_hab_selected(self): self._beam_centre_model.update_hab = True self._beam_centre_model.update_lab = False # HAB is selected, so ensure update HAB is enabled and checked self._view.enable_update_hab(True) # Disable and deselect update LAB self._view.enable_update_lab(False) def update_lab_selected(self): self._beam_centre_model.update_hab = False self._beam_centre_model.update_lab = True # LAB is selected, so ensure update LAB is enabled and checked self._view.enable_update_lab(True) # Disable and deselect update HAB self._view.enable_update_hab(False) def update_all_selected(self): self._beam_centre_model.update_hab = True self._beam_centre_model.update_lab = True self._view.enable_update_hab(True) self._view.enable_update_lab(True) def set_on_state_model(self, attribute_name, state_model): attribute = getattr(self._view, attribute_name) if attribute or isinstance(attribute, bool): setattr(state_model, attribute_name, attribute) def set_on_view(self, attribute_name, state_model): attribute = getattr(state_model, attribute_name) if attribute or isinstance( attribute, bool ): # We need to be careful here. We don't want to set empty strings, or None, but we want to set boolean values. # noqa setattr(self._view, attribute_name, attribute) def _validate_radius_values(self): min_value = getattr(self._view, "r_min_line_edit").text() max_value = getattr(self._view, "r_max_line_edit").text() try: min_value = float(min_value) max_value = float(max_value) except ValueError: # one of the values is empty pass else: if min_value == max_value == 0: self._view.run_button.setEnabled(False) return if min_value >= max_value: if self._view.run_button.isEnabled(): # Only post to logger once per disabling self._logger.notice( "Minimum radius is larger than maximum radius. " "Cannot find beam centre with current settings.") self._view.run_button.setEnabled(False) else: self._view.run_button.setEnabled(True)
class DiagnosticsPagePresenter(object): class ConcreteDiagnosticsPageListener(DiagnosticsPage.DiagnosticsPageListener): def __init__(self, presenter): self._presenter = presenter def on_browse_clicked(self): pass def on_horizontal_clicked(self): self._presenter.on_horizontal_clicked() def on_vertical_clicked(self): self._presenter.on_vertical_clicked() def on_time_clicked(self): self._presenter.on_time_clicked() class IntegralListener(WorkHandler.WorkListener): def __init__(self, presenter): super(DiagnosticsPagePresenter.IntegralListener, self).__init__() self._presenter = presenter def on_processing_finished(self, result): self._presenter.on_processing_finished_integral(result) def on_processing_error(self, error): self._presenter.on_processing_error_integral(error) def __init__(self, parent_presenter, WorkHandler, run_integral, create_state, facility): super(DiagnosticsPagePresenter, self).__init__() self._view = None self._facility = facility self._parent_presenter = parent_presenter self._work_handler = WorkHandler() self.run_integral = run_integral self._logger = Logger("SANS") self._create_state = create_state def set_view(self, view, instrument): if view: self._view = view # Set up run listener listener = DiagnosticsPagePresenter.ConcreteDiagnosticsPageListener(self) self._view.add_listener(listener) # Set up combo box self.set_instrument_settings(instrument) def set_instrument_settings(self, instrument=None): detector_list = get_detector_strings_for_diagnostic_page(instrument) self._view.set_detectors(detector_list) def on_user_file_load(self, user_file): self._view.user_file_name = user_file def on_horizontal_clicked(self): input_file = self._view.run_input period = self._view.period state_model_with_view_update = self._parent_presenter._get_state_model_with_view_update() state = self._create_state(state_model_with_view_update, input_file, period, self._facility) mask = self._view.horizontal_mask range = self._view.horizontal_range listener = DiagnosticsPagePresenter.IntegralListener(self) detector = get_detector_from_gui_selection(self._view.detector) self._work_handler.process(listener, self.run_integral, range, mask, IntegralEnum.Horizontal, detector, state) def on_vertical_clicked(self): input_file = self._view.run_input period = self._view.period state_model_with_view_update = self._parent_presenter._get_state_model_with_view_update() state = self._create_state(state_model_with_view_update, input_file, period, self._facility) mask = self._view.vertical_mask range = self._view.vertical_range listener = DiagnosticsPagePresenter.IntegralListener(self) detector = get_detector_from_gui_selection(self._view.detector) self._work_handler.process(listener, self.run_integral, range, mask, IntegralEnum.Vertical, detector, state) def on_time_clicked(self): input_file = self._view.run_input period = self._view.period state_model_with_view_update = self._parent_presenter._get_state_model_with_view_update() state = self._create_state(state_model_with_view_update, input_file, period, self._facility) mask = self._view.time_mask range = self._view.time_range listener = DiagnosticsPagePresenter.IntegralListener(self) detector = get_detector_from_gui_selection(self._view.detector) self._work_handler.process(listener, self.run_integral, range, mask, IntegralEnum.Time, detector, state) def on_processing_finished_integral(self, result): pass def on_processing_error_integral(self, error): pass
class BeamCentrePresenter(object): class ConcreteBeamCentreListener(BeamCentre.BeamCentreListener): def __init__(self, presenter): self._presenter = presenter def on_run_clicked(self): self._presenter.on_run_clicked() class CentreFinderListener(WorkHandler.WorkListener): def __init__(self, presenter): super(BeamCentrePresenter.CentreFinderListener, self).__init__() self._presenter = presenter def on_processing_finished(self, result): self._presenter.on_processing_finished_centre_finder(result) def on_processing_error(self, error): self._presenter.on_processing_error_centre_finder(error) def __init__(self, parent_presenter, WorkHandler, BeamCentreModel, SANSCentreFinder): super(BeamCentrePresenter, self).__init__() self._view = None self._parent_presenter = parent_presenter self._work_handler = WorkHandler() self._logger = Logger("SANS") self._beam_centre_model = BeamCentreModel(SANSCentreFinder) def set_view(self, view): if view: self._view = view # Set up run listener listener = BeamCentrePresenter.ConcreteBeamCentreListener(self) self._view.add_listener(listener) # Set the default gui self._view.set_options(self._beam_centre_model) def on_update_instrument(self, instrument): self._beam_centre_model.set_scaling(instrument) self._view.on_update_instrument(instrument) def on_update_rows(self): self._view.set_options(self._beam_centre_model) state = self._parent_presenter.get_state_for_row(0) if state: self._beam_centre_model.reset_to_defaults_for_instrument(state_data=state.data) def on_processing_finished_centre_finder(self, result): # Enable button self._view.set_run_button_to_normal() # Update Centre Positions in model and GUI if self._beam_centre_model.update_lab: self._beam_centre_model.lab_pos_1 = result['pos1'] self._beam_centre_model.lab_pos_2 = result['pos2'] self._view.lab_pos_1 = self._beam_centre_model.lab_pos_1 * self._beam_centre_model.scale_1 self._view.lab_pos_2 = self._beam_centre_model.lab_pos_2 * self._beam_centre_model.scale_2 if self._beam_centre_model.update_hab: self._beam_centre_model.hab_pos_1 = result['pos1'] self._beam_centre_model.hab_pos_2 = result['pos2'] self._view.hab_pos_1 = self._beam_centre_model.hab_pos_1 * self._beam_centre_model.scale_1 self._view.hab_pos_2 = self._beam_centre_model.hab_pos_2 * self._beam_centre_model.scale_2 def on_processing_error_centre_finder(self, error): self._logger.warning("There has been an error. See more: {}".format(error)) self._view.set_run_button_to_normal() def on_processing_error(self, error): self._view.set_run_button_to_normal() def on_run_clicked(self): # Get the state information for the first row. state = self._parent_presenter.get_state_for_row(0) if not state: self._logger.information("You can only calculate the beam centre if a user file has been loaded and there" "valid sample scatter entry has been provided in the selected row.") return # Disable the button self._view.set_run_button_to_processing() #Update model self._update_beam_model_from_view() # Run the task listener = BeamCentrePresenter.CentreFinderListener(self) state_copy = copy.copy(state) self._work_handler.process(listener, self._beam_centre_model.find_beam_centre, state_copy) def _update_beam_model_from_view(self): self._beam_centre_model.r_min = self._view.r_min self._beam_centre_model.r_max = self._view.r_max self._beam_centre_model.max_iterations = self._view.max_iterations self._beam_centre_model.tolerance = self._view.tolerance self._beam_centre_model.left_right = self._view.left_right self._beam_centre_model.verbose = self._view.verbose self._beam_centre_model.COM = self._view.COM self._beam_centre_model.up_down = self._view.up_down self._beam_centre_model.lab_pos_1 = self._view.lab_pos_1 / self._beam_centre_model.scale_1 self._beam_centre_model.lab_pos_2 = self._view.lab_pos_2 / self._beam_centre_model.scale_2 self._beam_centre_model.hab_pos_1 = self._view.hab_pos_1 / self._beam_centre_model.scale_1 self._beam_centre_model.hab_pos_2 = self._view.hab_pos_2 / self._beam_centre_model.scale_2 self._beam_centre_model.q_min = self._view.q_min self._beam_centre_model.q_max = self._view.q_max self._beam_centre_model.component = self._view.component self._beam_centre_model.update_hab = self._view.update_hab self._beam_centre_model.update_lab = self._view.update_lab def update_centre_positions(self, state_model): lab_pos_1 = getattr(state_model, 'lab_pos_1') lab_pos_2 = getattr(state_model, 'lab_pos_2') hab_pos_1 = getattr(state_model, 'hab_pos_1') if getattr(state_model, 'hab_pos_1') else lab_pos_1 hab_pos_2 = getattr(state_model, 'hab_pos_2') if getattr(state_model, 'hab_pos_2') else lab_pos_2 self._view.lab_pos_1 = lab_pos_1 self._view.lab_pos_2 = lab_pos_2 self._view.hab_pos_1 = hab_pos_1 self._view.hab_pos_2 = hab_pos_2 def set_on_state_model(self, attribute_name, state_model): attribute = getattr(self._view, attribute_name) if attribute or isinstance(attribute, bool): setattr(state_model, attribute_name, attribute) def set_on_view(self, attribute_name, state_model): attribute = getattr(state_model, attribute_name) if attribute or isinstance(attribute, bool): # We need to be careful here. We don't want to set empty strings, or None, but we want to set boolean values. # noqa setattr(self._view, attribute_name, attribute)
class BeamCentrePresenter(object): class ConcreteBeamCentreListener(BeamCentre.BeamCentreListener): def __init__(self, presenter): self._presenter = presenter def on_run_clicked(self): self._presenter.on_run_clicked() class CentreFinderListener(WorkHandler.WorkListener): def __init__(self, presenter): super(BeamCentrePresenter.CentreFinderListener, self).__init__() self._presenter = presenter def on_processing_finished(self, result): self._presenter.on_processing_finished_centre_finder(result) def on_processing_error(self, error): self._presenter.on_processing_error_centre_finder(error) def __init__(self, parent_presenter, WorkHandler, BeamCentreModel, SANSCentreFinder): super(BeamCentrePresenter, self).__init__() self._view = None self._parent_presenter = parent_presenter self._work_handler = WorkHandler() self._logger = Logger("SANS") self._beam_centre_model = BeamCentreModel(SANSCentreFinder) def set_view(self, view): if view: self._view = view # Set up run listener listener = BeamCentrePresenter.ConcreteBeamCentreListener(self) self._view.add_listener(listener) # Set the default gui self._view.set_options(self._beam_centre_model) def on_update_instrument(self, instrument): self._beam_centre_model.set_scaling(instrument) self._view.on_update_instrument(instrument) def on_update_rows(self): file_information = self._parent_presenter._table_model.get_file_information_for_row(0) if file_information: self._beam_centre_model.reset_to_defaults_for_instrument(file_information=file_information) self._view.set_options(self._beam_centre_model) def on_processing_finished_centre_finder(self, result): # Enable button self._view.set_run_button_to_normal() # Update Centre Positions in model and GUI if self._beam_centre_model.update_lab: self._beam_centre_model.lab_pos_1 = result['pos1'] self._beam_centre_model.lab_pos_2 = result['pos2'] self._view.lab_pos_1 = self._beam_centre_model.lab_pos_1 * self._beam_centre_model.scale_1 self._view.lab_pos_2 = self._beam_centre_model.lab_pos_2 * self._beam_centre_model.scale_2 if self._beam_centre_model.update_hab: self._beam_centre_model.hab_pos_1 = result['pos1'] self._beam_centre_model.hab_pos_2 = result['pos2'] self._view.hab_pos_1 = self._beam_centre_model.hab_pos_1 * self._beam_centre_model.scale_1 self._view.hab_pos_2 = self._beam_centre_model.hab_pos_2 * self._beam_centre_model.scale_2 def on_processing_error_centre_finder(self, error): self._logger.warning("There has been an error. See more: {}".format(error)) self._view.set_run_button_to_normal() def on_processing_error(self, error): self._view.set_run_button_to_normal() def on_run_clicked(self): # Get the state information for the first row. state = self._parent_presenter.get_state_for_row(0) if not state: self._logger.information("You can only calculate the beam centre if a user file has been loaded and there" "valid sample scatter entry has been provided in the selected row.") return # Disable the button self._view.set_run_button_to_processing() #Update model self._update_beam_model_from_view() # Run the task listener = BeamCentrePresenter.CentreFinderListener(self) state_copy = copy.copy(state) self._work_handler.process(listener, self._beam_centre_model.find_beam_centre, 0, state_copy) def _update_beam_model_from_view(self): self._beam_centre_model.r_min = self._view.r_min self._beam_centre_model.r_max = self._view.r_max self._beam_centre_model.max_iterations = self._view.max_iterations self._beam_centre_model.tolerance = self._view.tolerance self._beam_centre_model.left_right = self._view.left_right self._beam_centre_model.verbose = self._view.verbose self._beam_centre_model.COM = self._view.COM self._beam_centre_model.up_down = self._view.up_down self._beam_centre_model.lab_pos_1 = self._view.lab_pos_1 / self._beam_centre_model.scale_1 self._beam_centre_model.lab_pos_2 = self._view.lab_pos_2 / self._beam_centre_model.scale_2 self._beam_centre_model.hab_pos_1 = self._view.hab_pos_1 / self._beam_centre_model.scale_1 self._beam_centre_model.hab_pos_2 = self._view.hab_pos_2 / self._beam_centre_model.scale_2 self._beam_centre_model.q_min = self._view.q_min self._beam_centre_model.q_max = self._view.q_max self._beam_centre_model.component = self._view.component self._beam_centre_model.update_hab = self._view.update_hab self._beam_centre_model.update_lab = self._view.update_lab def update_centre_positions(self, state_model): lab_pos_1 = getattr(state_model, 'lab_pos_1') lab_pos_2 = getattr(state_model, 'lab_pos_2') hab_pos_1 = getattr(state_model, 'hab_pos_1') if getattr(state_model, 'hab_pos_1') else lab_pos_1 hab_pos_2 = getattr(state_model, 'hab_pos_2') if getattr(state_model, 'hab_pos_2') else lab_pos_2 self._view.lab_pos_1 = lab_pos_1 self._view.lab_pos_2 = lab_pos_2 self._view.hab_pos_1 = hab_pos_1 self._view.hab_pos_2 = hab_pos_2 def set_on_state_model(self, attribute_name, state_model): attribute = getattr(self._view, attribute_name) if attribute or isinstance(attribute, bool): setattr(state_model, attribute_name, attribute) def set_on_view(self, attribute_name, state_model): attribute = getattr(state_model, attribute_name) if attribute or isinstance(attribute, bool): # We need to be careful here. We don't want to set empty strings, or None, but we want to set boolean values. # noqa setattr(self._view, attribute_name, attribute)
class DiagnosticsPagePresenter(object): class ConcreteDiagnosticsPageListener(DiagnosticsPage.DiagnosticsPageListener): def __init__(self, presenter): self._presenter = presenter def on_browse_clicked(self): pass def on_horizontal_clicked(self): self._presenter.on_horizontal_clicked() def on_vertical_clicked(self): self._presenter.on_vertical_clicked() def on_time_clicked(self): self._presenter.on_time_clicked() class IntegralListener(WorkHandler.WorkListener): def __init__(self, presenter): super(DiagnosticsPagePresenter.IntegralListener, self).__init__() self._presenter = presenter def on_processing_finished(self, result): self._presenter.on_processing_finished_integral(result) def on_processing_error(self, error): self._presenter.on_processing_error_integral(error) def __init__(self, parent_presenter, WorkHandler, run_integral, create_state, facility): self._view = None self._facility = facility self._parent_presenter = parent_presenter self._work_handler = WorkHandler() self.run_integral = run_integral self._logger = Logger("SANS") self._create_state = create_state def set_view(self, view, instrument): if view: self._view = view # Set up run listener listener = DiagnosticsPagePresenter.ConcreteDiagnosticsPageListener(self) self._view.add_listener(listener) # Set up combo box self.set_instrument_settings(instrument) def set_instrument_settings(self, instrument=None): detector_list = get_detector_strings_for_diagnostic_page(instrument) self._view.set_detectors(detector_list) def on_user_file_load(self, user_file): self._view.user_file_name = user_file def on_horizontal_clicked(self): self._view.disable_integrals() input_file = self._view.run_input period = self._view.period state_model_with_view_update = self._parent_presenter._get_state_model_with_view_update() state = self._create_state(state_model_with_view_update, input_file, period, self._facility) mask = self._view.horizontal_mask range = self._view.horizontal_range listener = DiagnosticsPagePresenter.IntegralListener(self) detector = get_detector_from_gui_selection(self._view.detector) self._work_handler.process(listener, self.run_integral, 0, range, mask, IntegralEnum.Horizontal, detector, state) def on_vertical_clicked(self): self._view.disable_integrals() input_file = self._view.run_input period = self._view.period state_model_with_view_update = self._parent_presenter._get_state_model_with_view_update() state = self._create_state(state_model_with_view_update, input_file, period, self._facility) mask = self._view.vertical_mask range = self._view.vertical_range listener = DiagnosticsPagePresenter.IntegralListener(self) detector = get_detector_from_gui_selection(self._view.detector) self._work_handler.process(listener, self.run_integral, 0, range, mask, IntegralEnum.Vertical, detector, state) def on_time_clicked(self): self._view.disable_integrals() input_file = self._view.run_input period = self._view.period state_model_with_view_update = self._parent_presenter._get_state_model_with_view_update() state = self._create_state(state_model_with_view_update, input_file, period, self._facility) mask = self._view.time_mask range = self._view.time_range listener = DiagnosticsPagePresenter.IntegralListener(self) detector = get_detector_from_gui_selection(self._view.detector) self._work_handler.process(listener, self.run_integral, 0, range, mask, IntegralEnum.Time, detector, state) def on_processing_finished_integral(self, result): self._view.enable_integrals() def on_processing_error_integral(self, error): self._view.enable_integrals()