def validateWorkspaces(self, valNames=None, mismatchName=None): """ Performs a check that two workspaces are equal using the CheckWorkspacesMatch algorithm. Loads one workspace from a nexus file if appropriate. Returns true if: the workspaces match OR the validate method has not been overridden. Returns false if the workspace do not match. The reason will be in the log. """ if valNames is None: valNames = self.validate() from mantid.simpleapi import SaveNexus, AlgorithmManager checker = AlgorithmManager.create("CheckWorkspacesMatch") checker.setLogging(True) checker.setPropertyValue("Workspace1", valNames[0]) checker.setPropertyValue("Workspace2", valNames[1]) checker.setPropertyValue("Tolerance", str(self.tolerance)) if hasattr(self, "tolerance_is_reller") and self.tolerance_is_reller: checker.setPropertyValue("ToleranceRelerr", "1") for d in self.disableChecking: checker.setPropertyValue("Check" + d, "0") checker.execute() if checker.getPropertyValue("Result") != "Success!": print self.__class__.__name__ if mismatchName: SaveNexus(InputWorkspace=valNames[0], Filename=self.__class__.__name__ + mismatchName + "-mismatch.nxs") else: SaveNexus(InputWorkspace=valNames[0], Filename=self.__class__.__name__ + "-mismatch.nxs") return False return True
def validateWorkspaces(self, valNames=None, mismatchName=None): ''' Performs a check that two workspaces are equal using the CompareWorkspaces algorithm. Loads one workspace from a nexus file if appropriate. Returns true if: the workspaces match OR the validate method has not been overridden. Returns false if the workspace do not match. The reason will be in the log. ''' if valNames is None: valNames = self.validate() checker = AlgorithmManager.create("CompareWorkspaces") checker.setLogging(True) checker.setPropertyValue("Workspace1", valNames[0]) checker.setPropertyValue("Workspace2", valNames[1]) checker.setProperty("Tolerance", float(self.tolerance)) if hasattr(self, 'tolerance_is_reller') and self.tolerance_is_reller: checker.setProperty("ToleranceRelerr", True) for d in self.disableChecking: checker.setProperty("Check"+d, False) checker.execute() if not checker.getProperty("Result").value: print(self.__class__.__name__) if mismatchName: SaveNexus(InputWorkspace=valNames[0], Filename=self.__class__.__name__+mismatchName+'-mismatch.nxs') else: SaveNexus(InputWorkspace=valNames[0], Filename=self.__class__.__name__+'-mismatch.nxs') return False return True
def __init__(self, acquisitionMode): """ Create the export model by providing an aquisition mode. Args: acquisitionMode (str): acquisition mode """ self._exportAlgorithms = { k: v for k, v in RundexSettings.EXPORT_ALGORITHMS[acquisitionMode].items() } self._exportExtensions = dict() self._exportDocs = dict() for a in self._exportAlgorithms.keys(): if a in RundexSettings.EXPORT_ALGO_EXTENSION: self._exportExtensions[a] = \ RundexSettings.EXPORT_ALGO_EXTENSION[a] try: alg = AlgorithmManager.createUnmanaged(a) self._exportDocs[a] = alg.summary() except: pass self._pool = DrillAlgorithmPool() self._pool.signals.taskError.connect(self._onTaskError) self._pool.signals.taskSuccess.connect(self._onTaskSuccess) self._exports = dict() self._successExports = dict()
def test_sort_x_works_child(self): # Create unsorted workspace parent = AlgorithmManager.createUnmanaged('Load') create_ws_alg = parent.createChildAlgorithm("CreateWorkspace") dataX = [4., 3., 2., 1.] dataY = [1., 2., 3.] dataE = [1., 2., 3.] create_ws_alg.setProperty("DataX", dataX) create_ws_alg.setProperty("DataY", dataY) create_ws_alg.setProperty("DataE", dataE) create_ws_alg.setProperty("UnitX",'TOF') create_ws_alg.setProperty("Distribution", False) create_ws_alg.execute() # Run the algorithm sort_alg = parent.createChildAlgorithm("SortXAxis") sort_alg.setProperty("InputWorkspace", create_ws_alg.getProperty("OutputWorkspace").value) sort_alg.execute() # Check the resulting data values. Sorting operation should have resulted in no changes sortedws = sort_alg.getProperty("OutputWorkspace").value sortedX = sortedws.readX(0) sortedY = sortedws.readY(0) sortedE = sortedws.readE(0) self.assertEqual(sorted(dataX), sortedX.tolist()) dataY.reverse() dataE.reverse() self.assertEqual(dataY, sortedY.tolist()) self.assertEqual(dataE, sortedE.tolist())
def test_sort_x_works_child(self): # Create unsorted workspace parent = AlgorithmManager.createUnmanaged('Load') create_ws_alg = parent.createChildAlgorithm("CreateWorkspace") dataX = [4., 3., 2., 1.] dataY = [1., 2., 3.] dataE = [1., 2., 3.] create_ws_alg.setProperty("DataX", dataX) create_ws_alg.setProperty("DataY", dataY) create_ws_alg.setProperty("DataE", dataE) create_ws_alg.setProperty("UnitX", 'TOF') create_ws_alg.setProperty("Distribution", False) create_ws_alg.execute() # Run the algorithm sort_alg = parent.createChildAlgorithm("SortXAxis") sort_alg.setProperty( "InputWorkspace", create_ws_alg.getProperty("OutputWorkspace").value) sort_alg.execute() # Check the resulting data values. Sorting operation should have resulted in no changes sortedws = sort_alg.getProperty("OutputWorkspace").value sortedX = sortedws.readX(0) sortedY = sortedws.readY(0) sortedE = sortedws.readE(0) self.assertEqual(sorted(dataX), sortedX.tolist()) dataY.reverse() dataE.reverse() self.assertEqual(dataY, sortedY.tolist()) self.assertEqual(dataE, sortedE.tolist())
def test_incorrect_run_number(self): alg = AlgorithmManager.create('LoadElementalAnalysisData') alg.setChild(True) alg.initialize() alg.setProperty('Run', 1) alg.setProperty('GroupWorkspace', '1') errors = alg.validateInputs() self.assertTrue("Run" in errors) self.assertEquals(len(errors), 1) self.assertFalse(AnalysisDataService.doesExist("1"))
def run_reduction(input_workspace: EventWorkspace, workspace_name: str, settings_file: str, output_dir: str): # Run reduction # Get the angle angle = get_angle(input_workspace) params = find_angle_parameters_from_settings_json(settings_file, angle) alg = AlgorithmManager.create("ReflectometryISISLoadAndProcess") properties = { "InputRunList": workspace_name, "FirstTransmissionRunList": params.first_transmission_run_list, "SecondTransmissionRunList": params.second_transmission_run_list, "ThetaIn": angle, "DetectorCorrectionType": params.detector_correction_type, "MonitorBackgroundWavelengthMin": params.monitor_background_wavelength_min, "MonitorBackgroundWavelengthMax": params.monitor_background_wavelength_max, "MonitorIntegrationWavelengthMin": params.monitor_integration_wavelength_min, "MonitorIntegrationWavelengthMax": params.monitor_integration_wavelength_max, "WavelengthMin": params.wavelength_min, "WavelengthMax": params.wavelength_max, "I0MonitorIndex": params.i_zero_monitor_index, "AnalysisMode": params.analysis_mode, "StartOverlap": params.start_overlap, "EndOverlap": params.end_overlap, "ScaleRHSWorkspace": params.scale_rhs_workspace, "TransmissionProcessingInstructions": params.transmission_processing_instructions, "ProcessingInstructions": params.processing_instructions } alg.setProperties(properties) alg.execute() # Save reduced data as Nexus files OutputWorkspace = alg.getPropertyValue("OutputWorkspace") OutputWorkspaceBinned = alg.getPropertyValue("OutputWorkspaceBinned") SaveNexus(OutputWorkspace, os.path.join(output_dir, OutputWorkspace + ".nxs")) SaveNexus(OutputWorkspaceBinned, os.path.join(output_dir, OutputWorkspaceBinned + ".nxs")) # Save a copy of the .json settings file copy(settings_file, output_dir) return OutputWorkspaceBinned
def checkWorkspacesMatch(self, ws1, ws2): from mantid.simpleapi import SaveNexus, AlgorithmManager checker = AlgorithmManager.create("CheckWorkspacesMatch") checker.setLogging(True) checker.setPropertyValue("Workspace1", ws1) checker.setPropertyValue("Workspace2", ws2) checker.setPropertyValue("Tolerance", str(self.tolerance)) checker.setPropertyValue("CheckInstrument","0") checker.execute() if checker.getPropertyValue("Result") != 'Success!': print self.__class__.__name__ SaveNexus(InputWorkspace=ws2,Filename=self.__class__.__name__+'-mismatch.nxs') return False return True
def validate(self): results = 'SCDR_output' reference = 'SingleCrystalDiffuseReduction.nxs' Load(Filename=reference,OutputWorkspace=reference) checker = AlgorithmManager.create("CompareMDWorkspaces") checker.setLogging(True) checker.setPropertyValue("Workspace1",results) checker.setPropertyValue("Workspace2",reference) checker.setPropertyValue("Tolerance", "1e-7") checker.execute() if checker.getPropertyValue("Equals") != "1": print(" Workspaces do not match, result: ",checker.getPropertyValue("Result")) print(self.__class__.__name__) SaveMD(InputWorkspace=results,Filename=self.__class__.__name__+'-mismatch.nxs') return False return True
def validate(self): results = 'CMRSCMD_output_HKL' reference = 'ConvertMultipleRunsToSingleCrystalMD_HKL.nxs' Load(Filename=reference,OutputWorkspace=reference) checker = AlgorithmManager.create("CompareMDWorkspaces") checker.setLogging(True) checker.setPropertyValue("Workspace1",results) checker.setPropertyValue("Workspace2",reference) checker.setPropertyValue("Tolerance", "1e-5") checker.setPropertyValue("IgnoreBoxID", "1") checker.execute() if checker.getPropertyValue("Equals") != "1": print(" Workspaces do not match, result: ",checker.getPropertyValue("Result")) print(self.__class__.__name__) SaveMD(InputWorkspace=results,Filename=self.__class__.__name__+'-mismatch.nxs') return False return True
def fit_tof_iteration(sample_data, container_data, runs, flags): """ Performs a single iterations of the time of flight corrections and fitting workflow. :param sample_data: Loaded sample data workspaces :param container_data: Loaded container data workspaces :param runs: A string specifying the runs to process :param flags: A dictionary of flags to control the processing :return: Tuple of (workspace group name, pre correction fit parameters, final fit parameters, chi^2 values) """ # Transform inputs into something the algorithm can understand if isinstance(flags['masses'][0], list): mass_values = _create_profile_strs_and_mass_list(copy.deepcopy(flags['masses'][0]))[0] profiles_strs = [] for mass_spec in flags['masses']: profiles_strs.append(_create_profile_strs_and_mass_list(mass_spec)[1]) else: mass_values, profiles_strs = _create_profile_strs_and_mass_list(flags['masses']) background_str = _create_background_str(flags.get('background', None)) intensity_constraints = _create_intensity_constraint_str(flags['intensity_constraints']) # The simpleapi function won't have been created so do it by hand VesuvioTOFFit = _create_algorithm_function("VesuvioTOFFit", 1, AlgorithmManager.createUnmanaged("VesuvioTOFFit")) VesuvioCorrections = _create_algorithm_function("VesuvioCorrections", 1, AlgorithmManager.createUnmanaged("VesuvioCorrections")) num_spec = sample_data.getNumberHistograms() pre_correct_pars_workspace = None pars_workspace = None max_fit_iterations = flags.get('max_fit_iterations', 5000) output_groups = [] chi2_values = [] for index in range(num_spec): if isinstance(profiles_strs, list): profiles = profiles_strs[index] else: profiles = profiles_strs suffix = _create_fit_workspace_suffix(index, sample_data, flags['fit_mode'], flags['spectra'], flags.get('iteration', None)) # Corrections corrections_args = dict() # Need to do a fit first to obtain the parameter table pre_correction_pars_name = runs + "_params_pre_correction" + suffix corrections_fit_name = "__vesuvio_corrections_fit" VesuvioTOFFit(InputWorkspace=sample_data, WorkspaceIndex=index, Masses=mass_values, MassProfiles=profiles, Background=background_str, IntensityConstraints=intensity_constraints, OutputWorkspace=corrections_fit_name, FitParameters=pre_correction_pars_name, MaxIterations=max_fit_iterations, Minimizer=flags['fit_minimizer']) DeleteWorkspace(corrections_fit_name) corrections_args['FitParameters'] = pre_correction_pars_name # Add the mutiple scattering arguments corrections_args.update(flags['ms_flags']) corrected_data_name = runs + "_tof_corrected" + suffix linear_correction_fit_params_name = runs + "_correction_fit_scale" + suffix if flags.get('output_verbose_corrections', False): corrections_args["CorrectionWorkspaces"] = runs + "_correction" + suffix corrections_args["CorrectedWorkspaces"] = runs + "_corrected" + suffix if container_data is not None: corrections_args["ContainerWorkspace"] = container_data VesuvioCorrections(InputWorkspace=sample_data, OutputWorkspace=corrected_data_name, LinearFitResult=linear_correction_fit_params_name, WorkspaceIndex=index, GammaBackground=flags.get('gamma_correct', False), Masses=mass_values, MassProfiles=profiles, IntensityConstraints=intensity_constraints, MultipleScattering=True, GammaBackgroundScale=flags.get('fixed_gamma_scaling', 0.0), ContainerScale=flags.get('fixed_container_scaling', 0.0), **corrections_args) # Final fit fit_ws_name = runs + "_data" + suffix pars_name = runs + "_params" + suffix fit_result = VesuvioTOFFit(InputWorkspace=corrected_data_name, WorkspaceIndex=0, # Corrected data always has a single histogram Masses=mass_values, MassProfiles=profiles, Background=background_str, IntensityConstraints=intensity_constraints, OutputWorkspace=fit_ws_name, FitParameters=pars_name, MaxIterations=max_fit_iterations, Minimizer=flags['fit_minimizer']) chi2_values.append(fit_result[-1]) DeleteWorkspace(corrected_data_name) # Process parameter tables if pre_correct_pars_workspace is None: pre_correct_pars_workspace = _create_param_workspace(num_spec, mtd[pre_correction_pars_name]) if pars_workspace is None: pars_workspace = _create_param_workspace(num_spec, mtd[pars_name]) _update_fit_params(pre_correct_pars_workspace, index, mtd[pre_correction_pars_name], suffix[1:]) _update_fit_params(pars_workspace, index, mtd[pars_name], suffix[1:]) DeleteWorkspace(pre_correction_pars_name) DeleteWorkspace(pars_name) # Process spectrum group # Note the ordering of operations here gives the order in the WorkspaceGroup group_name = runs + suffix output_workspaces = [fit_ws_name, linear_correction_fit_params_name] if flags.get('output_verbose_corrections', False): output_workspaces += mtd[corrections_args["CorrectionWorkspaces"]].getNames() output_workspaces += mtd[corrections_args["CorrectedWorkspaces"]].getNames() UnGroupWorkspace(corrections_args["CorrectionWorkspaces"]) UnGroupWorkspace(corrections_args["CorrectedWorkspaces"]) output_groups.append(GroupWorkspaces(InputWorkspaces=output_workspaces, OutputWorkspace=group_name)) # Output the parameter workspaces AnalysisDataService.Instance().addOrReplace(runs + "_params_pre_correction" + suffix, pre_correct_pars_workspace) AnalysisDataService.Instance().addOrReplace(runs + "_params" + suffix, pars_workspace) if len(output_groups) > 1: result_ws = output_groups else: result_ws = output_groups[0] return (result_ws, pre_correct_pars_workspace, pars_workspace, chi2_values)