def update_log_workspace_group(self): # both ws and name needed in event a ws is renamed and ws.name() is no longer correct if not self._data_workspaces: self.delete_logs() return if not self._log_workspaces: self.create_log_workspace_group() else: for log in self._log_names: if not ADS.doesExist(log): self.make_log_table(log) self._log_workspaces.add(log) if not ADS.doesExist("run_info"): self.make_runinfo_table() self._log_workspaces.add("run_info") # update log tables self.remove_all_log_rows() for irow, (ws_name, ws) in enumerate( self._data_workspaces.get_loaded_ws_dict().items()): try: self.add_log_to_table(ws_name, ws, irow) except Exception as e: logger.warning( f"Unable to output log workspaces for workspace {ws_name}: " + str(e))
def cleanup(self): if AnalysisDataService.doesExist(self._input_wksp): DeleteWorkspace(self._input_wksp) if AnalysisDataService.doesExist(self._output_wksp): DeleteWorkspace(self._output_wksp) if AnalysisDataService.doesExist(self._correction_wksp): DeleteWorkspace(self._correction_wksp)
def cleanup(self): if AnalysisDataService.doesExist(self._input_wksp): DeleteWorkspace(self._input_wksp) if AnalysisDataService.doesExist(self._output_wksp): DeleteWorkspace(self._output_wksp) if AnalysisDataService.doesExist(self._correction_wksp): DeleteWorkspace(self._correction_wksp)
def test_calibrate(self): data = self.corelli calibrate(data['workspace'], data['bank_name'], data['wire_positions'], data['peaks_form'], fitPar=data['fit_parameters'], outputPeak=True, parameters_table_group='parameters_table_group') # Check the table workspaces containing the polynomial coefficients assert AnalysisDataService.doesExist('parameters_table_group') workspace = mtd['parameters_table_group'] for tube_number, name in enumerate(workspace.getNames()): assert name == f'parameters_table_group_{tube_number}' assert AnalysisDataService.doesExist(name) # Check the values of the coefficients for the first and last tube for tube_index, expected in [(0, { 'A0': -0.446804, 'A1': 0.003513, 'A2': 0.0 }), (15, { 'A0': -0.452107, 'A1': 0.003528, 'A2': 0.00 })]: workspace = mtd[f'parameters_table_group_{tube_index}'] for row in workspace: if row['Name'] in expected: self.assertAlmostEqual(expected[row['Name']], row['Value'], delta=1.e-6) DeleteWorkspaces(['CalibTable', 'parameters_table_group', 'PeakTable'])
def apply_calibration(workspace: WorkspaceTypes, calibration_table: InputTable, output_workspace: Optional[str] = None, show_instrument: bool = False) -> Workspace2D: r""" Calibrate the detector positions with an input table, and open the instrument view if so requested. :param workspace: input Workspace2D containing total neutron counts per pixel :param calibration_table: a TableWorskpace containing one column for detector ID and one column for its calibrated XYZ coordinates, in meters :param output_workspace: name of the output workspace containing calibrated detectors. If `None`, then the output workspace name will be the input workspace plus the suffix `_calibrated` :param show_instrument: open the instrument view for `output_workspace` :raises AssertionError: either `workspace` or `calibration_table` are not found """ assert AnalysisDataService.doesExist(str(workspace)), f'No worksapce {str(workspace)} found' assert AnalysisDataService.doesExist(str(calibration_table)), f'No table {str(calibration_table)} found' if output_workspace is None: output_workspace = str(workspace) + '_calibrated' CloneWorkspace(InputWorkspace=workspace, OutputWorkspace=output_workspace) ApplyCalibration(Workspace=output_workspace, CalibrationTable=calibration_table) if show_instrument is True and None not in (InstrumentViewPresenter, InstrumentViewPresenter): instrument_presenter = QAppThreadCall(InstrumentViewPresenter)(mtd[output_workspace]) QAppThreadCall(instrument_presenter.show_view)() return mtd[output_workspace]
def chop_data(self, split_ws_name=None, info_ws_name=None, do_tof_correction=False): """ chop data and save to GSAS file :param split_ws_name: :param info_ws_name: :param TOF correction :return: """ # get data file names, splitters workspace and output directory from reduction setup object raw_file_name = self._reductionSetup.locate_event_nexus() if split_ws_name is None: split_ws_name, info_ws_name = self._reductionSetup.get_splitters(throw_not_set=True) elif info_ws_name is None: raise RuntimeError( 'Splitters workspace name must be given with information workspace name.') useless, output_directory = self._reductionSetup.get_chopped_directory( True, nexus_only=True) if do_tof_correction: raise RuntimeError('Not implemented for TOF correction yet.') # get number of target workspace number_target_ws, is_epoch_time = chop_utility.get_number_chopped_ws(split_ws_name) # load data from file to workspace event_ws_name = os.path.split(raw_file_name)[1].split('.')[0] mantid_helper.load_nexus(data_file_name=raw_file_name, output_ws_name=event_ws_name, meta_data_only=False) if number_target_ws < MAX_CHOPPED_WORKSPACE_IN_MEM: # chop event workspace with regular method # TODO/DEBUG - Split workspace won't be deleted at this stage status, ret_obj = mantid_helper.split_event_data(raw_ws_name=event_ws_name, split_ws_name=split_ws_name, info_table_name=info_ws_name, target_ws_name=None, tof_correction=do_tof_correction, output_directory=output_directory, delete_split_ws=False) else: # chop event workspace to too many target workspaces which cannot be hold in memory # simultaneously status, ret_obj = self.chop_data_large_number_targets(event_ws_name, tof_correction=do_tof_correction, output_dir=output_directory, is_epoch_time=is_epoch_time, num_target_ws=number_target_ws, delete_split_ws=True) # TODO - NIGHT (Nice) - save the split workspace for future reference # delete raw workspace # TODO/ISSUE/NOWNOW - Requiring a user option for this! print('[INFO] Deleting raw event workspace {0} which {1} exists.' ''.format(event_ws_name, AnalysisDataService.doesExist(event_ws_name))) if AnalysisDataService.doesExist(event_ws_name): mantid_helper.delete_workspace(event_ws_name) return status, ret_obj
def split_to_single_bank(self, gss_ws_name): """ Split a multiple-bank GSAS workspace to a set of single-spectrum MatrixWorkspace Parameters ---------- gss_ws_name Returns ------- Name of grouped workspace and list """ # check assert isinstance(gss_ws_name, str) assert AnalysisDataService.doesExist(gss_ws_name) # get workspace gss_ws = AnalysisDataService.retrieve(gss_ws_name) ws_list = list() angle_list = list() if gss_ws.getNumberHistograms() == 1: # input is already a single-spectrum workspace ws_list.append(gss_ws_name) else: num_spec = gss_ws.getNumberHistograms() for i_ws in range(num_spec): # split this one to a single workspace out_ws_name = '%s_bank%d' % (gss_ws_name, i_ws + 1) # also can use ExtractSpectra() simpleapi.CropWorkspace(InputWorkspace=gss_ws_name, OutputWorkspace=out_ws_name, StartWorkspaceIndex=i_ws, EndWorkspaceIndex=i_ws) assert AnalysisDataService.doesExist(out_ws_name) ws_list.append(out_ws_name) # END-FOR # END-IF # calculate bank angles for ws_name in ws_list: bank_angle = calculate_bank_angle(ws_name) angle_list.append(bank_angle) # group all the workspace ws_group_name = gss_ws_name + '_group' simpleapi.GroupWorkspaces(InputWorkspaces=ws_list, OutputWorkspace=ws_group_name) self._braggDataDict[ws_group_name] = (gss_ws_name, ws_list) return ws_group_name, ws_list, angle_list
def test_add_workspace_to_ADS_adds_workspace_to_ads_in_correct_group_structure( self): workspace = CreateWorkspace([0, 0], [0, 0]) workspace_name = 'test_workspace_name' workspace_directory = 'root/' self.model.add_workspace_to_ADS(workspace, workspace_name, workspace_directory) self.assertTrue(AnalysisDataService.doesExist(workspace_name)) self.assertTrue(AnalysisDataService.doesExist('root'))
def _removeWorkspace(workspace_name): """Remove the workspace with the given name, including any child workspaces if it is a group. If a corresponding monitors workspace exists, remove that too.""" if AnalysisDataService.doesExist(workspace_name): workspace = AnalysisDataService.retrieve(workspace_name) if isinstance(workspace, WorkspaceGroup): # Remove child workspaces first while workspace.getNumberOfEntries(): _removeWorkspace(workspace[0].name()) AnalysisDataService.remove(workspace_name) # If a corresponding monitors workspace also exists, remove that too if AnalysisDataService.doesExist(_monitorWorkspace(workspace_name)): _removeWorkspace(_monitorWorkspace(workspace_name))
def _removeWorkspace(workspace_name): """Remove the workspace with the given name, including any child workspaces if it is a group. If a corresponding monitors workspace exists, remove that too.""" if AnalysisDataService.doesExist(workspace_name): workspace = AnalysisDataService.retrieve(workspace_name) if isinstance(workspace, WorkspaceGroup): # Remove child workspaces first while workspace.getNumberOfEntries(): _removeWorkspace(workspace[0].name()) AnalysisDataService.remove(workspace_name) # If a corresponding monitors workspace also exists, remove that too if AnalysisDataService.doesExist(_monitorWorkspace(workspace_name)): _removeWorkspace(_monitorWorkspace(workspace_name))
def update_log_workspace_group(self): # both ws and name needed in event a ws is renamed and ws.name() is no longer correct if not self._log_workspaces: self.create_log_workspace_group() else: for log in self._log_names: if not ADS.doesExist(log): self.make_log_table(log) self._log_workspaces.add(log) if not ADS.doesExist("run_info"): self.make_runinfo_table() self._log_workspaces.add("run_info") # update log tables for irow, (ws_name, ws) in enumerate(self._loaded_workspaces.items()): self.add_log_to_table(ws_name, ws, irow) # rename write_log_row
def retrieve_hkl_from_spice_table(self): """ Get averaged HKL from SPICE table HKL will be averaged from SPICE table by assuming the value in SPICE might be right :return: """ # get SPICE table spice_table_name = get_spice_table_name(self._myExpNumber, self._myScanNumber) assert AnalysisDataService.doesExist(spice_table_name), 'Spice table for Exp %d Scan %d cannot be found.' \ '' % (self._myExpNumber, self._myScanNumber) spice_table_ws = AnalysisDataService.retrieve(spice_table_name) # get HKL column indexes h_col_index = spice_table_ws.getColumnNames().index('h') k_col_index = spice_table_ws.getColumnNames().index('k') l_col_index = spice_table_ws.getColumnNames().index('l') # scan each Pt. hkl = numpy.array([0., 0., 0.]) num_rows = spice_table_ws.rowCount() for row_index in range(num_rows): mi_h = spice_table_ws.cell(row_index, h_col_index) mi_k = spice_table_ws.cell(row_index, k_col_index) mi_l = spice_table_ws.cell(row_index, l_col_index) hkl += numpy.array([mi_h, mi_k, mi_l]) # END-FOR self._spiceHKL = hkl/num_rows return
def add_directory_structure(dirs): """ create the nested WorkspaceGroup structure in the ADS specified by the stored directory attribute. dirs = ["dir1", "dir2"] eg. ['Muon Data', 'MUSR72105', 'MUSR72105 Raw Data'] """ if not dirs: return if len(dirs) > len(set(dirs)): raise ValueError("Group names must be unique") for directory in dirs: if not AnalysisDataService.doesExist(directory): workspace_group = WorkspaceGroup() AnalysisDataService.addOrReplace(directory, workspace_group) elif not isinstance(AnalysisDataService.retrieve(directory), WorkspaceGroup): AnalysisDataService.remove(directory) workspace_group = WorkspaceGroup() AnalysisDataService.addOrReplace(directory, workspace_group) else: # exists and is a workspace group pass # Create the nested group structure in the ADS previous_dir = "" for i, directory in enumerate(dirs): if i == 0: previous_dir = directory continue if not AnalysisDataService.retrieve(previous_dir).__contains__( directory): AnalysisDataService.retrieve(previous_dir).add(directory) previous_dir = directory
def runTest(self): UseCompatibilityMode() LARMOR() Set1D() Detector("DetectorBench") MaskFile( 'USER_LARMOR_151B_LarmorTeam_80tubes_BenchRot1p4_M4_r3699.txt') Gravity(True) AddRuns(('13065', '13065'), 'LARMOR', 'nxs', lowMem=True) AssignSample('13065-add.nxs') WavRangeReduction(2, 4, DefaultTrans) # Clean up for element in AnalysisDataService.getObjectNames(): if AnalysisDataService.doesExist( element) and element != "13065p1rear_1D_2.0_4.0": AnalysisDataService.remove(element) paths = [ os.path.join(config['defaultsave.directory'], 'LARMOR00013065-add.nxs'), os.path.join(config['defaultsave.directory'], 'SANS2D00013065.log') ] # noqa for path in paths: if os.path.exists(path): os.remove(path)
def load_files(self, filenames_string, xunit): self._last_added = [] filenames = [name.strip() for name in filenames_string.split(",")] for filename in filenames: ws_name = self._generate_workspace_name(filename, xunit) if ws_name not in self._loaded_workspaces: try: if not ADS.doesExist(ws_name): ws = Load(filename, OutputWorkspace=ws_name) if xunit != "TOF": ConvertUnits(InputWorkspace=ws, OutputWorkspace=ws_name, Target=xunit) else: ws = ADS.retrieve(ws_name) if ws.getNumberHistograms() == 1: self._loaded_workspaces[ws_name] = ws if ws_name not in self._background_workspaces: self._background_workspaces[ws_name] = None self._last_added.append(ws_name) self.add_log_to_table(ws_name, ws) else: logger.warning( f"Invalid number of spectra in workspace {ws_name}. Skipping loading of file.") except RuntimeError as e: logger.error( f"Failed to load file: {filename}. Error: {e}. \n Continuing loading of other files.") else: logger.warning(f"File {ws_name} has already been loaded")
def get_weighted_peak_centres(self): """ Get the peak centers found in peak workspace. Guarantees: the peak centers and its weight (detector counts) are exported :return: 2-tuple: list of 3-tuple (Qx, Qy, Qz) list of double (Det_Counts) """ # get PeaksWorkspace if AnalysisDataService.doesExist(self._myPeakWorkspaceName) is False: raise RuntimeError('PeaksWorkspace %s does ot exit.' % self._myPeakWorkspaceName) peak_ws = AnalysisDataService.retrieve(self._myPeakWorkspaceName) # get peak center, peak intensity and etc. peak_center_list = list() peak_intensity_list = list() num_peaks = peak_ws.getNumberPeaks() for i_peak in range(num_peaks): peak_i = peak_ws.getPeak(i_peak) center_i = peak_i.getQSampleFrame() intensity_i = peak_i.getIntensity() peak_center_list.append((center_i.X(), center_i.Y(), center_i.Z())) peak_intensity_list.append(intensity_i) # END-FOR return peak_center_list, peak_intensity_list
def _update_high_q(self, _ws=None): """ Update High-Q data set """ self._high_q_data = self.update_data(self._content.high_q_combo, None, None, self._content.high_scale_edit) self._high_q_modified = False file_in = str(self._content.high_q_combo.lineEdit().text()) if len(file_in.strip()) == 0: self._high_q_data = None elif os.path.isfile(file_in) or AnalysisDataService.doesExist(file_in): self._high_q_data = DataSet(file_in) try: self._high_q_data.load(True) except (AttributeError, ImportError, NameError, TypeError, ValueError, Warning): self._high_q_data = None util.set_valid(self._content.high_q_combo.lineEdit(), False) QtGui.QMessageBox.warning(self, "Error loading file", "Could not load %s.\nMake sure you pick the XML output from the reduction." % file_in) return self._content.high_scale_edit.setText("1.0") util.set_valid(self._content.high_q_combo.lineEdit(), True) else: self._high_q_data = None util.set_valid(self._content.high_q_combo.lineEdit(), False)
def _update_high_q(self, _ws=None): """ Update High-Q data set """ self._high_q_data = self.update_data(self._content.high_q_combo, None, None, self._content.high_scale_edit) self._high_q_modified = False file_in = str(self._content.high_q_combo.lineEdit().text()) if len(file_in.strip()) == 0: self._high_q_data = None elif os.path.isfile(file_in) or AnalysisDataService.doesExist(file_in): self._high_q_data = DataSet(file_in) try: self._high_q_data.load(True) except (AttributeError, ImportError, NameError, TypeError, ValueError, Warning): self._high_q_data = None util.set_valid(self._content.high_q_combo.lineEdit(), False) QtGui.QMessageBox.warning( self, "Error loading file", "Could not load %s.\nMake sure you pick the XML output from the reduction." % file_in) return self._content.high_scale_edit.setText("1.0") util.set_valid(self._content.high_q_combo.lineEdit(), True) else: self._high_q_data = None util.set_valid(self._content.high_q_combo.lineEdit(), False)
def testCalculateEfficiencyCorretionInvalidStoreADSCheck(self): self.cleanup() corr_wksp = CalculateEfficiencyCorrection( WavelengthRange=self._wavelengths, Alpha=self._alpha, StoreInADS=False) self.assertFalse(AnalysisDataService.doesExist(corr_wksp.name()))
def testCalculateEfficiencyCorretionInvalidStoreADSCheck(self): self.cleanup() corr_wksp = CalculateEfficiencyCorrection( WavelengthRange=self._wavelengths, Alpha=self._alpha, StoreInADS=False) self.assertFalse(AnalysisDataService.doesExist(corr_wksp.name()))
def edit_matrix_workspace(sq_name, scale_factor, shift, edited_sq_name=None): """ Edit the matrix workspace of S(Q) by scaling and shift :param sq_name: name of the SofQ workspace :param scale_factor: :param shift: :param edited_sq_name: workspace for the edited S(Q) :return: """ # get the workspace if AnalysisDataService.doesExist(sq_name) is False: raise RuntimeError( 'S(Q) workspace {0} cannot be found in ADS.'.format(sq_name)) if edited_sq_name is not None: simpleapi.CloneWorkspace(InputWorkspace=sq_name, OutputWorkspace=edited_sq_name) sq_ws = AnalysisDataService.retrieve(edited_sq_name) else: sq_ws = AnalysisDataService.retrieve(sq_name) # get the vector of Y sq_ws = sq_ws * scale_factor sq_ws = sq_ws + shift if sq_ws.name() != edited_sq_name: simpleapi.DeleteWorkspace(Workspace=edited_sq_name) simpleapi.RenameWorkspace(InputWorkspace=sq_ws, OutputWorkspace=edited_sq_name) assert sq_ws is not None, 'S(Q) workspace cannot be None.' print('[DB...BAT] S(Q) workspace that is edit is {0}'.format(sq_ws))
def __init__(self, exp_number, scan_number_list, matrix_ws_name, scan_spectrum_map, spectrum_scan_map): """ initialization :param exp_number: :param scan_number_list: :param matrix_ws_name: :param scan_spectrum_map: :param spectrum_scan_map: """ # check input check_integer('Experiment number', exp_number) check_list('Scan numbers', scan_number_list) check_string('Workspace2D name', matrix_ws_name) check_dictionary('Scan number spectrum number mapping', scan_spectrum_map) check_dictionary('Spectrum number scan number mapping', spectrum_scan_map) if AnalysisDataService.doesExist(matrix_ws_name) is False: raise RuntimeError('Workspace {} does not exist.'.format(matrix_ws_name)) # store self._exp_number = exp_number self._scan_number_list = scan_number_list[:] self._matrix_ws_name = matrix_ws_name self._scan_spectrum_map = scan_spectrum_map self._spectrum_scan_map = spectrum_scan_map # TODO - 20180814 - Add pt number, rio name and integration direction for future check! # others self._model_ws_name = None return
def _group_workspaces(self, workspaces, output_ws_name): """ Groups all the given workspaces into a group with the given name. If the group already exists it will add them to that group. """ if not self.getProperty(Prop.GROUP_TOF).value: return workspaces = self._collapse_workspace_groups(workspaces) if not workspaces: return if AnalysisDataService.doesExist(output_ws_name): ws_group = AnalysisDataService.retrieve(output_ws_name) if not isinstance(ws_group, WorkspaceGroup): raise RuntimeError( 'Cannot group TOF workspaces, a workspace called TOF already exists' ) else: for ws in workspaces: if ws not in ws_group: ws_group.add(ws) else: alg = self.createChildAlgorithm("GroupWorkspaces") alg.setProperty("InputWorkspaces", workspaces) alg.setProperty("OutputWorkspace", output_ws_name) alg.execute() ws_group = alg.getProperty("OutputWorkspace").value AnalysisDataService.addOrReplace(output_ws_name, ws_group) return ws_group
def test_correct_tube_to_ideal_tube(self): # Verify the quadratic fit works data = self.y_quad_data # fit the Y-coordinates to the pixel positions with a default quadratic function fitted_coordinates = correct_tube_to_ideal_tube( data['tube_points'], data['ideal_tube_coordinates'], data['detector_count'], parameters_table='parameters') # Verify the fitted coordinates are the ideal_tube_coordinates assert_allclose( [fitted_coordinates[int(n)] for n in data['tube_points']], data['ideal_tube_coordinates'], atol=0.0001) # Compare fitting coefficients assert AnalysisDataService.doesExist('parameters') # here retrieve the fitting coefficients from the 'parameters' table and compare to the expected values expected = data['coefficients'] for row in mtd['parameters']: if row['Name'] in expected: self.assertAlmostEqual(row['Value'], expected[row['Name']], places=6) # a bit of clean-up DeleteWorkspaces([ 'PolyFittingWorkspace', 'QF_NormalisedCovarianceMatrix', 'QF_Parameters', 'QF_Workspace', 'parameters' ])
def test_batch_reduction_on_multiperiod_file(self): # Arrange # Build the data information data_builder = get_data_builder(SANSFacility.ISIS) data_builder.set_sample_scatter("SANS2D0005512") data_info = data_builder.build() # Get the rest of the state from the user file user_file_director = StateDirectorISIS(data_info) user_file_director.set_user_file("MASKSANS2Doptions.091A") # Set the reduction mode to LAB user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB) state = user_file_director.construct() # Act states = [state] self._run_batch_reduction(states, use_optimizations=False) # Assert # We only assert that the expected workspaces exist on the ADS expected_workspaces = ["5512p1rear_1D_2.0_14.0Phi-45.0_45.0", "5512p2rear_1D_2.0_14.0Phi-45.0_45.0", "5512p3rear_1D_2.0_14.0Phi-45.0_45.0", "5512p4rear_1D_2.0_14.0Phi-45.0_45.0", "5512p5rear_1D_2.0_14.0Phi-45.0_45.0", "5512p6rear_1D_2.0_14.0Phi-45.0_45.0", "5512p7rear_1D_2.0_14.0Phi-45.0_45.0", "5512p8rear_1D_2.0_14.0Phi-45.0_45.0", "5512p9rear_1D_2.0_14.0Phi-45.0_45.0", "5512p10rear_1D_2.0_14.0Phi-45.0_45.0", "5512p11rear_1D_2.0_14.0Phi-45.0_45.0", "5512p12rear_1D_2.0_14.0Phi-45.0_45.0", "5512p13rear_1D_2.0_14.0Phi-45.0_45.0"] for element in expected_workspaces: self.assertTrue(AnalysisDataService.doesExist(element)) # Clean up for element in expected_workspaces: AnalysisDataService.remove(element)
def edit_matrix_workspace(sq_name, scale_factor, shift, edited_sq_name=None): """ Edit the matrix workspace of S(Q) by scaling and shift :param sq_name: name of the SofQ workspace :param scale_factor: :param shift: :param edited_sq_name: workspace for the edited S(Q) :return: """ # get the workspace if AnalysisDataService.doesExist(sq_name) is False: raise RuntimeError('S(Q) workspace {0} cannot be found in ADS.'.format(sq_name)) if edited_sq_name is not None: simpleapi.CloneWorkspace(InputWorkspace=sq_name, OutputWorkspace=edited_sq_name) sq_ws = AnalysisDataService.retrieve(edited_sq_name) else: sq_ws = AnalysisDataService.retrieve(sq_name) # get the vector of Y sq_ws = sq_ws * scale_factor sq_ws = sq_ws + shift if sq_ws.name() != edited_sq_name: simpleapi.DeleteWorkspace(Workspace=edited_sq_name) simpleapi.RenameWorkspace(InputWorkspace=sq_ws, OutputWorkspace=edited_sq_name) assert sq_ws is not None, 'S(Q) workspace cannot be None.' print('[DB...BAT] S(Q) workspace that is edit is {0}'.format(sq_ws))
def load_bragg_file(self, file_name): """ Load Bragg diffraction file (including 3-column data file, GSAS file) for Rietveld """ # load with different file type base_file_name = os.path.basename(file_name).lower() gss_ws_name = os.path.basename(file_name).split('.')[0] if base_file_name.endswith('.gss') or base_file_name.endswith('.gsa') or base_file_name.endswith('.gda'): simpleapi.LoadGSS(Filename=file_name, OutputWorkspace=gss_ws_name) elif base_file_name.endswith('.nxs'): simpleapi.LoadNexusProcessed(Filename=file_name, OutputWorkspace=gss_ws_name) simpleapi.ConvertUnits(InputWorkspace=gss_ws_name, OutputWorkspace=gss_ws_name, EMode='Elastic', Target='TOF') elif base_file_name.endswith('.dat'): simpleapi.LoadAscii(Filename=file_name, OutputWorkspace=gss_ws_name, Unit='TOF') else: raise RuntimeError('File %s is not of a supported type.' % file_name) self._braggDataList.append(gss_ws_name) # check assert AnalysisDataService.doesExist(gss_ws_name) angle_list = AddieDriver.calculate_bank_angle(gss_ws_name) return gss_ws_name, angle_list
def change_plot_guess(self, plot_guess, parameter_dict): try: fit_function = parameter_dict['Function'] data_ws_name = parameter_dict['InputWorkspace'] except KeyError: return if self.context.workspace_suffix == MUON_ANALYSIS_SUFFIX: guess_ws_name = MUON_ANALYSIS_GUESS_WS elif self.context.workspace_suffix == FREQUENCY_DOMAIN_ANALYSIS_SUFFIX: guess_ws_name = FREQUENCY_DOMAIN_ANALYSIS_GUESS_WS else: guess_ws_name = '__unknown_interface_fitting_guess' # Handle case of function removed if fit_function is None and plot_guess: self.context.fitting_context.notify_plot_guess_changed( plot_guess, None) elif fit_function is None or data_ws_name == '': return else: # evaluate the current function on the workspace if plot_guess: try: EvaluateFunction(InputWorkspace=data_ws_name, Function=fit_function, StartX=parameter_dict['StartX'], EndX=parameter_dict['EndX'], OutputWorkspace=guess_ws_name) except RuntimeError: mantid.logger.error('Could not evaluate the function.') return if AnalysisDataService.doesExist(guess_ws_name): self.context.fitting_context.notify_plot_guess_changed( plot_guess, guess_ws_name)
def load_files(self, filenames_string): self._last_added = [] filenames = [name.strip() for name in filenames_string.split(",")] for filename in filenames: ws_name = self._generate_workspace_name(filename) if ws_name not in self._loaded_workspaces: try: if not ADS.doesExist(ws_name): ws = Load(filename, OutputWorkspace=ws_name) else: ws = ADS.retrieve(ws_name) if ws.getNumberHistograms() == 1: self._loaded_workspaces[ws_name] = ws if ws_name not in self._bg_sub_workspaces: self._bg_sub_workspaces[ws_name] = None if ws_name not in self._bg_params: self._bg_params[ws_name] = [] self._last_added.append(ws_name) else: logger.warning( f"Invalid number of spectra in workspace {ws_name}. Skipping loading of file.") except RuntimeError as e: logger.error( f"Failed to load file: {filename}. Error: {e}. \n Continuing loading of other files.") else: logger.warning(f"File {ws_name} has already been loaded") self.update_log_workspace_group()
def _isValidWorkspace(self, workspace_name, workspace_id): """Returns true, if the workspace of name workspace_name is a valid reflectometry workspace of type workspace_id. Otherwise, deletes the workspace if the user requested to reload invalid workspaces, or raises an error otherwise """ if not _hasWorkspaceID(workspace_name, workspace_id): message = 'Workspace ' + workspace_name + ' exists but is not a ' + workspace_id if self._reload: self.log().information(message) _removeWorkspace(workspace_name) return False else: raise RuntimeError(message) # For event workspaces, the monitors workspace must also exist, otherwise it's not valid if workspace_id == "EventWorkspace": if not AnalysisDataService.doesExist( _monitorWorkspace(workspace_name)): message = 'Monitors workspace ' + workspace_name + '_monitors does not exist' if self._reload: self.log().information(message) _removeWorkspace(workspace_name) return False else: raise RuntimeError(message) return True
def _plot_vanadium_curves(): van_curve_twin_ws = "__engggui_vanadium_curves_twin_ws" if Ads.doesExist(van_curve_twin_ws): DeleteWorkspace(van_curve_twin_ws) CloneWorkspace(InputWorkspace="engggui_vanadium_curves", OutputWorkspace=van_curve_twin_ws) van_curves_ws = Ads.retrieve(van_curve_twin_ws) fig = plt.figure() gs = gridspec.GridSpec(1, 2) curve_plot_bank_1 = fig.add_subplot(gs[0], projection="mantid") curve_plot_bank_2 = fig.add_subplot(gs[1], projection="mantid") curve_plot_bank_1.plot(van_curves_ws, wkspIndex=0) curve_plot_bank_1.plot(van_curves_ws, wkspIndex=1) curve_plot_bank_1.plot(van_curves_ws, wkspIndex=2) curve_plot_bank_1.set_title("Engg GUI Vanadium Curves Bank 1") curve_plot_bank_1.legend(["Data", "Calc", "Diff"]) curve_plot_bank_2.plot(van_curves_ws, wkspIndex=3) curve_plot_bank_2.plot(van_curves_ws, wkspIndex=4) curve_plot_bank_2.plot(van_curves_ws, wkspIndex=5) curve_plot_bank_2.set_title("Engg GUI Vanadium Curves Bank 2") curve_plot_bank_2.legend(["Data", "Calc", "Diff"]) fig.show()
def append_data_file(self, data_file, workspace=None): """ Append a file to be processed. @param data_file: name of the file to be processed @param workspace: optional name of the workspace for this data, default will be the name of the file TODO: this needs to be an ordered list """ if data_file is None: if AnalysisDataService.doesExist(workspace): self._data_files[workspace] = None return else: raise RuntimeError( "Trying to append a data set without a file name or an existing workspace." ) if isinstance(data_file, list): if workspace is None: # Use the first file to determine the workspace name workspace = extract_workspace_name(data_file[0]) else: if workspace is None: workspace = extract_workspace_name(data_file) self._data_files[workspace] = data_file
def _generate_tof_fit_workspace(difa, difc, tzero, bank): bank_ws = Ads.retrieve(CalibrationModel._generate_table_workspace_name(bank)) x_val = [] y_val = [] y2_val = [] difa_to_plot = difa difc_to_plot = difc tzero_to_plot = tzero for irow in range(0, bank_ws.rowCount()): x_val.append(bank_ws.cell(irow, 0)) y_val.append(bank_ws.cell(irow, 5)) y2_val.append(pow(x_val[irow], 2) * difa_to_plot + x_val[irow] * difc_to_plot + tzero_to_plot) ws1 = CreateWorkspace(DataX=x_val, DataY=y_val, UnitX="Expected Peaks Centre (dSpacing A)", YUnitLabel="Fitted Peaks Centre(TOF, us)") ws2 = CreateWorkspace(DataX=x_val, DataY=y2_val) output_ws = "engggui_tof_peaks_bank_" + str(bank) if Ads.doesExist(output_ws): DeleteWorkspace(output_ws) AppendSpectra(ws1, ws2, OutputWorkspace=output_ws) DeleteWorkspace(ws1) DeleteWorkspace(ws2)
def _update_high_q(self, ws=None): """ Update High-Q data set """ self._high_q_data = self.update_data(self._content.high_q_combo, None, None, self._content.high_scale_edit) self._high_q_modified = False file = str(self._content.high_q_combo.lineEdit().text()) if len(file.strip())==0: self._high_q_data = None elif os.path.isfile(file) or AnalysisDataService.doesExist(file): self._high_q_data = DataSet(file) try: self._high_q_data.load(True) except: self._high_q_data = None util.set_valid(self._content.high_q_combo.lineEdit(), False) QtGui.QMessageBox.warning(self, "Error loading file", "Could not load %s.\nMake sure you pick the XML output from the reduction." % file) return self._content.high_scale_edit.setText("1.0") npts = self._high_q_data.get_number_of_points() util.set_valid(self._content.high_q_combo.lineEdit(), True) else: self._high_q_data = None util.set_valid(self._content.high_q_combo.lineEdit(), False)
def load_bragg_by_filename(file_name): """ Load Bragg diffraction file (including 3-column data file, GSAS file) for Rietveld """ # load with different file type base_file_name = os.path.basename(file_name).lower() gss_ws_name = os.path.basename(file_name).split('.')[0] if base_file_name.endswith('.gss') or base_file_name.endswith( '.gsa') or base_file_name.endswith('.gda'): simpleapi.LoadGSS(Filename=file_name, OutputWorkspace=gss_ws_name) elif base_file_name.endswith('.nxs'): simpleapi.LoadNexusProcessed(Filename=file_name, OutputWorkspace=gss_ws_name) simpleapi.ConvertUnits(InputWorkspace=gss_ws_name, OutputWorkspace=gss_ws_name, EMode='Elastic', Target='TOF') elif base_file_name.endswith('.dat'): simpleapi.LoadAscii(Filename=file_name, OutputWorkspace=gss_ws_name, Unit='TOF') else: raise RuntimeError('File %s is not of a supported type.' % file_name) # check assert AnalysisDataService.doesExist(gss_ws_name) angle_list = addie.utilities.workspaces.calculate_bank_angle(gss_ws_name) return gss_ws_name, angle_list
def _update_high_q(self, ws=None): """ Update High-Q data set """ self._high_q_data = self.update_data(self._content.high_q_combo, None, None, self._content.high_scale_edit) self._high_q_modified = False file = str(self._content.high_q_combo.lineEdit().text()) if len(file.strip()) == 0: self._high_q_data = None elif os.path.isfile(file) or AnalysisDataService.doesExist(file): self._high_q_data = DataSet(file) try: self._high_q_data.load(True) except: self._high_q_data = None util.set_valid(self._content.high_q_combo.lineEdit(), False) QtGui.QMessageBox.warning( self, "Error loading file", "Could not load %s.\nMake sure you pick the XML output from the reduction." % file) return self._content.high_scale_edit.setText("1.0") npts = self._high_q_data.get_number_of_points() util.set_valid(self._content.high_q_combo.lineEdit(), True) else: self._high_q_data = None util.set_valid(self._content.high_q_combo.lineEdit(), False)
def _group_workspaces(self, workspaces, output_ws_name): """ Groups all the given workspaces into a group with the given name. If the group already exists it will add them to that group. """ if len(workspaces) < 1: return workspaces = self._collapse_workspace_groups(workspaces) if not workspaces: return if AnalysisDataService.doesExist(output_ws_name): ws_group = AnalysisDataService.retrieve(output_ws_name) if not isinstance(ws_group, WorkspaceGroup): raise RuntimeError( 'Cannot group TOF workspaces, a workspace called TOF already exists' ) else: for ws in workspaces: if ws not in ws_group: ws_group.add(ws) else: alg = self.createChildAlgorithm("GroupWorkspaces") alg.setProperty("InputWorkspaces", list(workspaces)) alg.setProperty("OutputWorkspace", output_ws_name) alg.execute() ws_group = alg.getProperty("OutputWorkspace").value # We can't add the group as an output property or it will duplicate # the history for the contained workspaces, so add it directly to # the ADS AnalysisDataService.addOrReplace(output_ws_name, ws_group)
def retrieve_hkl_from_spice_table(self): """ Get averaged HKL from SPICE table HKL will be averaged from SPICE table by assuming the value in SPICE might be right :return: """ # get SPICE table spice_table_name = get_spice_table_name(self._myExpNumber, self._myScanNumber) assert AnalysisDataService.doesExist(spice_table_name), 'Spice table for exp %d scan %d cannot be found.' \ '' % (self._myExpNumber, self._myScanNumber) spice_table_ws = AnalysisDataService.retrieve(spice_table_name) # get HKL column indexes h_col_index = spice_table_ws.getColumnNames().index('h') k_col_index = spice_table_ws.getColumnNames().index('k') l_col_index = spice_table_ws.getColumnNames().index('l') # scan each Pt. hkl = numpy.array([0., 0., 0.]) num_rows = spice_table_ws.rowCount() for row_index in xrange(num_rows): mi_h = spice_table_ws.cell(row_index, h_col_index) mi_k = spice_table_ws.cell(row_index, k_col_index) mi_l = spice_table_ws.cell(row_index, l_col_index) hkl += numpy.array([mi_h, mi_k, mi_l]) # END-FOR self._spiceHKL = hkl/num_rows return
def get_weighted_peak_centres(self): """ Get the peak centers found in peak workspace. Guarantees: the peak centers and its weight (detector counts) are exported :return: 2-tuple: list of 3-tuple (Qx, Qy, Qz) list of double (Det_Counts) """ # get PeaksWorkspace if AnalysisDataService.doesExist(self._myPeakWorkspaceName) is False: raise RuntimeError('PeaksWorkspace %s does ot exit.' % self._myPeakWorkspaceName) peak_ws = AnalysisDataService.retrieve(self._myPeakWorkspaceName) # get peak center, peak intensity and etc. peak_center_list = list() peak_intensity_list = list() num_peaks = peak_ws.getNumberPeaks() for i_peak in xrange(num_peaks): peak_i = peak_ws.getPeak(i_peak) center_i = peak_i.getQSampleFrame() intensity_i = peak_i.getIntensity() peak_center_list.append((center_i.X(), center_i.Y(), center_i.Z())) peak_intensity_list.append(intensity_i) # END-FOR return peak_center_list, peak_intensity_list
def test_batch_reduction_on_period_time_sliced_wavelength_range_data(self): # Arrange # Build the data information file_information_factory = SANSFileInformationFactory() file_information = file_information_factory.create_sans_file_information( "SANS2D0005512") data_builder = get_data_builder(SANSFacility.ISIS, file_information) data_builder.set_sample_scatter("SANS2D0005512") data_builder.set_sample_scatter_period(1) data_info = data_builder.build() # Get the rest of the state from the user file user_filename = "MASKSANS2Doptions.091A" user_file_director = StateBuilder.new_instance( file_information=file_information, data_information=data_info, user_filename=user_filename) state = user_file_director.get_all_states() # Set the reduction mode to LAB state.reduction.reduction_mode = ReductionMode.LAB state.slice.start_time = [1.0, 3.0] state.slice.end_time = [3.0, 5.0] start = [1.0, 1.0] end = [3.0, 2.0] state.wavelength.wavelength_low = start state.wavelength.wavelength_high = end state.adjustment.normalize_to_monitor.wavelength_low = start state.adjustment.normalize_to_monitor.wavelength_high = end state.adjustment.calculate_transmission.wavelength_low = start state.adjustment.calculate_transmission.wavelength_high = end state.adjustment.wavelength_and_pixel_adjustment.wavelength_low = start state.adjustment.wavelength_and_pixel_adjustment.wavelength_high = end # Act states = [state] self._run_batch_reduction(states, use_optimizations=False) # Assert # We only assert that the expected workspaces exist on the ADS expected_workspaces = [ "5512_p1rear_1D_1.0_2.0Phi-45.0_45.0_t1.00_T3.00", "5512_p1rear_1D_1.0_2.0Phi-45.0_45.0_t3.00_T5.00", "5512_p1rear_1D_1.0_3.0Phi-45.0_45.0_t1.00_T3.00", "5512_p1rear_1D_1.0_3.0Phi-45.0_45.0_t3.00_T5.00" ] for element in expected_workspaces: self.assertTrue(AnalysisDataService.doesExist(element)) # Clean up for element in expected_workspaces: AnalysisDataService.remove(element)
def export_to_rmcprofile(ws_name, output_file_name, comment='', ws_index=0): """ Export a workspace 2D to a 2 column data for RMCProfile """ # check inputs assert isinstance( ws_name, str), 'Workspace name {0} must be a string but not a {1}.'.format( ws_name, str(ws_name)) assert isinstance( output_file_name, str ), 'Output file name {0} must be a string but not a {1}.'.format( output_file_name, type(output_file_name)) assert isinstance( comment, str), 'Comment {0} must be a string but not a {1}.'.format( comment, type(comment)) assert isinstance( ws_index, int), 'Workspace index must be an integer but not a {1}.'.format( ws_index, type(ws_index)) # convert to point data from histogram simpleapi.ConvertToPointData(InputWorkspace=ws_name, OutputWorkspace=ws_name) # get workspace for vecX and vecY if AnalysisDataService.doesExist(ws_name): workspace = AnalysisDataService.retrieve(ws_name) else: raise RuntimeError( 'Workspace {0} does not exist in ADS.'.format(ws_name)) if not 0 <= ws_index < workspace.getNumberHistograms(): raise RuntimeError( 'Workspace index {0} is out of range.'.format(ws_index)) vec_x = workspace.readX(ws_index) vec_y = workspace.readY(ws_index) # write to buffer wbuf = '' wbuf += '{0}\n'.format(len(vec_x)) wbuf += '{0}\n'.format(comment) for index in range(len(vec_x)): wbuf += ' {0} {1}\n'.format(vec_x[index], vec_y[index]) # write to file try: ofile = open(output_file_name, 'w') ofile.write(wbuf) ofile.close() except IOError as io_err: raise RuntimeError( 'Unable to export data to file {0} in RMCProfile format due to {1}.' .format(output_file_name, io_err)) return
def testCalculateEfficiencyCorretionStoreADSCheck(self): self.cleanup() alg_test = run_algorithm("CalculateEfficiencyCorrection", WavelengthRange=self._wavelengths, Alpha=self._alpha, OutputWorkspace=self._output_wksp) self.assertTrue(alg_test.isExecuted()) self.assertTrue(AnalysisDataService.doesExist(self._output_wksp))
def _display(masked_workspace): if masked_workspace and AnalysisDataService.doesExist(masked_workspace.name()): if PYQT4: instrument_win = mantidplot.getInstrumentView(masked_workspace.name()) instrument_win.show() else: instrument_win = InstrumentViewPresenter(masked_workspace) instrument_win.view.show()
def test_that_load_dead_time_from_filename_places_table_in_ADS(self): filename = 'MUSR00022725.nsx' name = utils.load_dead_time_from_filename(filename) dead_time_table = AnalysisDataService.retrieve(name) self.assertEqual(name, 'MUSR00022725_deadTimes') self.assertTrue(AnalysisDataService.doesExist(name)) self.assertTrue(isinstance(dead_time_table, ITableWorkspace))
def _create_sensitivity(self): if IS_IN_MANTIDPLOT and self.options_callback is not None: # Get patch information patch_ws = "" if AnalysisDataService.doesExist(self.patch_ws): patch_ws = self.patch_ws try: reduction_table_ws = self.options_callback() patch_output = AnalysisDataService.doesExist(patch_ws) filename = self._content.sensitivity_file_edit.text() script = "ComputeSensitivity(Filename='%s',\n" % filename script += " ReductionProperties='%s',\n" % reduction_table_ws script += " OutputWorkspace='sensitivity',\n" script += " PatchWorkspace='%s')\n" % patch_ws mantidplot.runPythonScript(script, True) except: print "Could not compute sensitivity" print sys.exc_value
def _workspaceExistsAndIsValid(self, workspace_name, isTrans): """Return true, if the given workspace exists in the ADS and is valid""" if not AnalysisDataService.doesExist(workspace_name): self.log().information('Workspace ' + workspace_name + ' does not exist') return False self.log().information('Workspace ' + workspace_name + ' exists') if not isTrans and self._slicingEnabled(): return self._isValidWorkspace(workspace_name, "EventWorkspace") else: return self._isValidWorkspace(workspace_name, "Workspace2D")
def _renameWorkspaceBasedOnRunNumber(self, workspace_name, isTrans): """Rename the given workspace based on its run number and a standard prefix""" new_name = self._prefixedName(_getRunNumberAsString(workspace_name), isTrans) if new_name != workspace_name: RenameWorkspace(InputWorkspace=workspace_name, OutputWorkspace=new_name) # Also rename the monitor workspace, if there is one if AnalysisDataService.doesExist(_monitorWorkspace(workspace_name)): RenameWorkspace(InputWorkspace=_monitorWorkspace(workspace_name), OutputWorkspace=_monitorWorkspace(new_name)) return new_name
def set_data_ws_name(self, md_ws_name): """ Set the name of MDEventWorkspace with merged Pts. :param md_ws_name: :return: """ assert isinstance(md_ws_name, str) assert AnalysisDataService.doesExist(md_ws_name) self._myDataMDWorkspaceName = md_ws_name return
def load_meta_data(cls, file_path, outputWorkspace): try: if IN_MANTIDPLOT: script = "LoadEventNexus(Filename='%s', OutputWorkspace='%s', MetaDataOnly=True)" % (file_path, outputWorkspace) execute_script(script) if not AnalysisDataService.doesExist(outputWorkspace): return False else: LoadEventNexus(Filename=file_path, OutputWorkspace=outputWorkspace, MetaDataOnly=True) return True except: return False
def load_meta_data(cls, file_path, outputWorkspace): try: if IN_MANTIDPLOT: script = "LoadSpice2D(Filename='%s', OutputWorkspace='%s')" % (file_path, outputWorkspace) mantidplot.runPythonScript(script, True) if not AnalysisDataService.doesExist(outputWorkspace): return False else: api.LoadSpice2D(Filename=file_path, OutputWorkspace=outputWorkspace) return True except: return False
def __init__(self, exp_number, scan_number, peak_ws_name): """ Initialization Purpose: set up unchanged parameters including experiment number, scan number and peak workspace's name """ # check assert isinstance(exp_number, int) and isinstance(scan_number, int) assert isinstance(peak_ws_name, str), 'Peak workspace name %s must be a string.' \ 'but not %s.' % (str(peak_ws_name), str(type(peak_ws_name))) assert AnalysisDataService.doesExist(peak_ws_name), 'Peak workspace %s does not' \ 'exist.' % peak_ws_name # set self._myExpNumber = exp_number self._myScanNumber = scan_number self._myPeakWorkspaceName = peak_ws_name # self._myDataMDWorkspaceName = None # Define class variable # HKL list self._calculatedHKL = None # user specified HKL self._spiceHKL = None # spice HKL self._prevHKL = numpy.array([0., 0., 0.]) # previous HKL # magnetic peak set up self._kShiftVector = [0, 0, 0] self._absorptionCorrection = 1. # peak center and PeaksWorkspace self._avgPeakCenter = None self._myPeakWSKey = (None, None, None) self._myPeakIndex = None self._myLastPeakUB = None self._myIntensity = None self._gaussIntensity = 0. self._gaussStdDev = 0. self._lorenzFactor = None # peak integration result self._integrationDict = None self._ptIntensityDict = None # some motor/goniometer information for further correction self._movingMotorTuple = None # Figure print self._fingerPrint = '{0:.7f}.{1}'.format(time.time(), random.randint(0, 10000000)) return
def _deleteWorkspaces(self, workspaces): """ Deletes a list of workspaces if they exist but ignores any errors @param workspaces: list of workspaces to try to delete """ for wk in workspaces: try: if AnalysisDataService.doesExist(wk): AnalysisDataService.remove(wk) except: #if the workspace can't be deleted this function does nothing pass
def test_batch_reduction_on_time_sliced_file(self): # Arrange # Build the data information file_information_factory = SANSFileInformationFactory() file_information = file_information_factory.create_sans_file_information("SANS2D00034484") data_builder = get_data_builder(SANSFacility.ISIS, file_information) data_builder.set_sample_scatter("SANS2D00034484") data_builder.set_sample_transmission("SANS2D00034505") data_builder.set_sample_direct("SANS2D00034461") data_builder.set_can_scatter("SANS2D00034481") data_builder.set_can_transmission("SANS2D00034502") data_builder.set_can_direct("SANS2D00034461") data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs") data_info = data_builder.build() # Get the rest of the state from the user file user_file_director = StateDirectorISIS(data_info, file_information) user_file_director.set_user_file("USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt") # Set the reduction mode to LAB user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # COMPATIBILITY BEGIN -- Remove when appropriate # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # Since we are dealing with event based data but we want to compare it with histogram data from the # old reduction system we need to enable the compatibility mode user_file_director.set_compatibility_builder_use_compatibility_mode(True) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # COMPATIBILITY END # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! user_file_director.set_slice_event_builder_start_time([1.0,3.0]) user_file_director.set_slice_event_builder_end_time([3.0,5.0]) state = user_file_director.construct() # Act states = [state] self._run_batch_reduction(states, use_optimizations=False) expected_workspaces = ["34484rear_1D_1.75_16.5_t1.00_T3.00", "34484rear_1D_1.75_16.5_t3.00_T5.00"] reference_file_names = ["SANS2D_event_slice_referance_t1.00_T3.00.nxs", "SANS2D_event_slice_referance_t3.00_T5.00.nxs"] for element, reference_file in zip(expected_workspaces, reference_file_names): self.assertTrue(AnalysisDataService.doesExist(element)) # Evaluate it up to a defined point self._compare_workspace(element, reference_file) # Clean up for element in expected_workspaces: AnalysisDataService.remove(element)
def test_batch_reduction_on_period_time_sliced_wavelength_range_data(self): # Arrange # Build the data information file_information_factory = SANSFileInformationFactory() file_information = file_information_factory.create_sans_file_information("SANS2D0005512") data_builder = get_data_builder(SANSFacility.ISIS, file_information) data_builder.set_sample_scatter("SANS2D0005512") data_builder.set_sample_scatter_period(1) data_info = data_builder.build() # Get the rest of the state from the user file user_file_director = StateDirectorISIS(data_info, file_information) user_file_director.set_user_file("MASKSANS2Doptions.091A") # Set the reduction mode to LAB user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB) user_file_director.set_slice_event_builder_start_time([1.0, 3.0]) user_file_director.set_slice_event_builder_end_time([3.0, 5.0]) state = user_file_director.construct() start = [1.0, 1.0] end = [3.0, 2.0] state.wavelength.wavelength_low = start state.wavelength.wavelength_high = end state.adjustment.normalize_to_monitor.wavelength_low = start state.adjustment.normalize_to_monitor.wavelength_high = end state.adjustment.calculate_transmission.wavelength_low = start state.adjustment.calculate_transmission.wavelength_high = end state.adjustment.wavelength_and_pixel_adjustment.wavelength_low = start state.adjustment.wavelength_and_pixel_adjustment.wavelength_high = end # Act states = [state] self._run_batch_reduction(states, use_optimizations=False) # Assert # We only assert that the expected workspaces exist on the ADS expected_workspaces = ["5512p1rear_1D_1.0_2.0Phi-45.0_45.0_t1.00_T3.00", "5512p1rear_1D_1.0_2.0Phi-45.0_45.0_t3.00_T5.00", "5512p1rear_1D_1.0_3.0Phi-45.0_45.0_t1.00_T3.00", "5512p1rear_1D_1.0_3.0Phi-45.0_45.0_t3.00_T5.00" ] for element in expected_workspaces: self.assertTrue(AnalysisDataService.doesExist(element)) # Clean up for element in expected_workspaces: AnalysisDataService.remove(element)
def get_already_loaded_calibration_workspace(full_file_path): """ Gets a calibration workspace from the ADS if it exists. :param full_file_path: the full file path to the calibration workspace :return: a handle to the calibration workspace or None """ calibration_workspace_name = get_expected_calibration_workspace_name(full_file_path) if AnalysisDataService.doesExist(calibration_workspace_name): output_ws = AnalysisDataService.retrieve(calibration_workspace_name) else: output_ws = None return output_ws
def clone_workspace(src_name, target_name): """clone workspace :param src_name: :param target_name: :return: """ # check assert isinstance(src_name, str), 'blabla' assert isinstance(target_name, str), 'blabla' # check existence if AnalysisDataService.doesExist(src_name): simpleapi.CloneWorkspace(InputWorkspace=src_name, OutputWorkspace=target_name) else: raise RuntimeError('Workspace with name {0} does not exist in ADS. CloneWorkspace fails!'.format(src_name))
def _isValidWorkspace(self, workspace_name, workspace_id): """Returns true, if the workspace of name workspace_name is a valid reflectometry workspace of type workspace_id and deletes the workspace otherwise""" if not _hasWorkspaceID(workspace_name, workspace_id): self.log().information('Workspace ' + workspace_name + ' exists but is not a ' + workspace_id) _removeWorkspace(workspace_name) return False # For event workspaces, the monitors workspace must also exist, otherwise it's not valid if workspace_id == "EventWorkspace": if not AnalysisDataService.doesExist(_monitorWorkspace(workspace_name)): self.log().information('Monitors workspace ' + workspace_name + '_monitors does not exist') _removeWorkspace(workspace_name) return False return True
def process_inputs(self): """ process input properties :return: input event workspace, binning parameter workspace, gsas file name, output workspace name, ipts number """ # get input properties input_ws_name = self.getPropertyValue("InputWorkspace") bin_par_ws_name = self.getPropertyValue('BinningTable') if len(bin_par_ws_name) > 0: bin_par_ws_exist = AnalysisDataService.doesExist(bin_par_ws_name) else: bin_par_ws_exist = False # event workspace is required for re-binning input_workspace = AnalysisDataService.retrieve(input_ws_name) if input_workspace.id() != 'EventWorkspace' and bin_par_ws_exist: self.log().warning('Input workspace {0} must be an EventWorkspace if rebin is required by {1}' ''.format(input_workspace, bin_par_ws_name)) elif input_workspace.getAxis(0).getUnit().unitID() != "TOF": raise NotImplementedError("InputWorkspace must be in unit as TOF.") # processing binning parameters if bin_par_ws_exist: binning_parameter_list = self.process_binning_param_table(input_workspace, bin_par_ws_name) else: binning_parameter_list = None # gsas file name (output) gss_file_name = self.getPropertyValue("GSSFilename") # output workspace name output_ws_name = self.getPropertyValue("OutputWorkspace") # IPTS-number ipts_number = self.getProperty("IPTS").value if ipts_number == mantid.kernel.Property.EMPTY_INT: try: run_number = input_workspace.run().getProperty('run').value ipts_number = api.GetIPTS(Instrument='VULCAN', RunNumber=run_number) except RuntimeError: ipts_number = 0 # GSAS parm file name parm_file_name = self.getPropertyValue("GSSParmFileName") return input_workspace, binning_parameter_list, gss_file_name, output_ws_name, ipts_number, parm_file_name
def _process_binning_parameters(self, bin_par_str): """ process binning parameters in string. there are two types of binning parameters that are accepted 1. regular x0, dx0, x1, dx1, etc or 2. workspace name: workspace index :param bin_par_str: :return: """ if bin_par_str.count(':') == 0: # parse regular binning parameters terms = bin_par_str.split(',') # in string format try: bin_param = [float(term) for term in terms] except ValueError: raise RuntimeError('Binning parameters {0} have non-float terms.'.format(bin_par_str)) elif bin_par_str.count(':') == 1: # in workspace name : workspace index mode terms = bin_par_str.split(':') ref_ws_name = terms[0].strip() if AnalysisDataService.doesExist(ref_ws_name) is False: raise RuntimeError('Workspace {0} does not exist (FYI {1})' ''.format(ref_ws_name, bin_par_str)) try: ws_index = int(terms[1].strip()) except ValueError: raise RuntimeError('{0} is supposed to be an integer for workspace index but not of type {1}.' ''.format(terms[1], type(terms[1]))) ref_tof_ws = AnalysisDataService.retrieve(ref_ws_name) if ws_index < 0 or ws_index >= ref_tof_ws.getNumberHistograms(): raise RuntimeError('Workspace index {0} must be in range [0, {1})' ''.format(ws_index, ref_tof_ws.getNumberHistograms())) ref_tof_vec = ref_tof_ws.readX(ws_index) delta_tof_vec = ref_tof_vec[1:] - ref_tof_vec[:-1] bin_param = numpy.empty((ref_tof_vec.size + delta_tof_vec.size), dtype=ref_tof_vec.dtype) bin_param[0::2] = ref_tof_vec bin_param[1::2] = delta_tof_vec self.log().warning('Binning parameters: size = {0}\n{1}'.format(len(bin_param), bin_param)) else: raise RuntimeError('Binning format {0} is not supported.'.format(bin_par_str)) return bin_param
def test_that_batch_reduction_evaluates_LAB(self): # Arrange # Build the data information file_information_factory = SANSFileInformationFactory() file_information = file_information_factory.create_sans_file_information("SANS2D00034484") data_builder = get_data_builder(SANSFacility.ISIS, file_information) data_builder.set_sample_scatter("SANS2D00034484") data_builder.set_sample_transmission("SANS2D00034505") data_builder.set_sample_direct("SANS2D00034461") data_builder.set_can_scatter("SANS2D00034481") data_builder.set_can_transmission("SANS2D00034502") data_builder.set_can_direct("SANS2D00034461") data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs") data_info = data_builder.build() # Get the rest of the state from the user file user_file_director = StateDirectorISIS(data_info, file_information) user_file_director.set_user_file("USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt") # Set the reduction mode to LAB user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # COMPATIBILITY BEGIN -- Remove when appropriate # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # Since we are dealing with event based data but we want to compare it with histogram data from the # old reduction system we need to enable the compatibility mode user_file_director.set_compatibility_builder_use_compatibility_mode(True) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # COMPATIBILITY END # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! state = user_file_director.construct() # Act states = [state] self._run_batch_reduction(states, use_optimizations=False) workspace_name = "34484rear_1D_1.75_16.5" output_workspace = AnalysisDataService.retrieve(workspace_name) # Evaluate it up to a defined point reference_file_name = "SANS2D_ws_D20_reference_LAB_1D.nxs" self._compare_workspace(output_workspace, reference_file_name) if AnalysisDataService.doesExist(workspace_name): AnalysisDataService.remove(workspace_name)