def test_python_alg_can_use_other_python_alg_through_simple_api(self): class SimpleAPIPythonAlgorithm1(PythonAlgorithm): def PyInit(self): pass def PyExec(self): from mantid.simpleapi import SimpleAPIPythonAlgorithm2 SimpleAPIPythonAlgorithm2() class SimpleAPIPythonAlgorithm2(PythonAlgorithm): def PyInit(self): pass def PyExec(self): pass AlgorithmFactory.subscribe(SimpleAPIPythonAlgorithm1) AlgorithmFactory.subscribe(SimpleAPIPythonAlgorithm2) # --------------------------------------------------------- alg1 = SimpleAPIPythonAlgorithm1() alg1.initialize() # Puts function in simpleapi globals simpleapi_alg1_func = simpleapi._create_algorithm_function("SimpleAPIPythonAlgorithm1", 1, alg1) alg2 = SimpleAPIPythonAlgorithm1() alg2.initialize() # Puts function in simpleapi globals simpleapi._create_algorithm_function("SimpleAPIPythonAlgorithm2", 1, alg2) try: simpleapi_alg1_func() except RuntimeError as exc: self.fail("Running algorithm 2 from 1 failed: " + str(exc))
def test_python_alg_can_use_other_python_alg_through_simple_api(self): class SimpleAPIPythonAlgorithm1(PythonAlgorithm): def PyInit(self): pass def PyExec(self): from mantid.simpleapi import SimpleAPIPythonAlgorithm2 SimpleAPIPythonAlgorithm2() class SimpleAPIPythonAlgorithm2(PythonAlgorithm): def PyInit(self): pass def PyExec(self): pass AlgorithmFactory.subscribe(SimpleAPIPythonAlgorithm1) AlgorithmFactory.subscribe(SimpleAPIPythonAlgorithm2) # --------------------------------------------------------- alg1 = SimpleAPIPythonAlgorithm1() alg1.initialize() # Puts function in simpleapi globals simpleapi_alg1_func = simpleapi._create_algorithm_function( "SimpleAPIPythonAlgorithm1", 1, alg1) alg2 = SimpleAPIPythonAlgorithm1() alg2.initialize() # Puts function in simpleapi globals simpleapi._create_algorithm_function("SimpleAPIPythonAlgorithm2", 1, alg2) try: simpleapi_alg1_func() except RuntimeError as exc: self.fail("Running algorithm 2 from 1 failed: " + str(exc))
def test_optional_workspaces_are_ignored_if_not_present_in_output_even_if_given_as_input( self): # Test algorithm from mantid.api import AlgorithmManager, PropertyMode, PythonAlgorithm, MatrixWorkspaceProperty, WorkspaceFactory from mantid.kernel import Direction class OptionalWorkspace(PythonAlgorithm): def PyInit(self): self.declareProperty( MatrixWorkspaceProperty("RequiredWorkspace", "", Direction.Output)) self.declareProperty( MatrixWorkspaceProperty("OptionalWorkspace", "", Direction.Output, PropertyMode.Optional)) def PyExec(self): ws = WorkspaceFactory.create("Workspace2D", NVectors=1, YLength=1, XLength=1) ws.dataY(0)[0] = 5 self.setProperty("RequiredWorkspace", ws) self.getLogger().notice("done!") AlgorithmFactory.subscribe(OptionalWorkspace) # temporarily attach it to simpleapi module name = "OptionalWorkspace" algm_object = AlgorithmManager.createUnmanaged(name, 1) algm_object.initialize() simpleapi._create_algorithm_function(name, 1, algm_object) # Create the wrapper # Call with no optional output specified result = simpleapi.OptionalWorkspace(RequiredWorkspace="required") self.assertTrue(isinstance(result, MatrixWorkspace)) self.assertAlmostEqual(5, result.readY(0)[0], places=12) mtd.remove("required") # Call with both outputs specified result = simpleapi.OptionalWorkspace(RequiredWorkspace="required", OptionalWorkspace="optional") self.assertTrue(isinstance(result, MatrixWorkspace)) self.assertAlmostEqual(5, result.readY(0)[0], places=12) mtd.remove("required") # Tidy up simple api function del simpleapi.OptionalWorkspace
def test_slice(self, alg_mock): # set up slice algorithm AlgorithmFactory.subscribe(Slice) alg_mock.Slice = wrap_algorithm( _create_algorithm_function('Slice', 1, Slice())) plot = compute_slice('test_ws', self.q_axis, self.e_axis, False) self.assertEqual(plot.get_signal().shape, (30, 25))
def test_optional_workspaces_are_ignored_if_not_present_in_output_even_if_given_as_input(self): # Test algorithm from mantid.api import ( AlgorithmManager, PropertyMode, PythonAlgorithm, MatrixWorkspaceProperty, WorkspaceFactory, ) from mantid.kernel import Direction class OptionalWorkspace(PythonAlgorithm): def PyInit(self): self.declareProperty(MatrixWorkspaceProperty("RequiredWorkspace", "", Direction.Output)) self.declareProperty( MatrixWorkspaceProperty("OptionalWorkspace", "", Direction.Output, PropertyMode.Optional) ) def PyExec(self): ws = WorkspaceFactory.create("Workspace2D", NVectors=1, YLength=1, XLength=1) ws.dataY(0)[0] = 5 self.setProperty("RequiredWorkspace", ws) self.getLogger().notice("done!") AlgorithmFactory.subscribe(OptionalWorkspace) # temporarily attach it to simpleapi module name = "OptionalWorkspace" algm_object = AlgorithmManager.createUnmanaged(name, 1) algm_object.initialize() simpleapi._create_algorithm_function(name, 1, algm_object) # Create the wrapper # Call with no optional output specified result = simpleapi.OptionalWorkspace(RequiredWorkspace="required") self.assertTrue(isinstance(result, MatrixWorkspace)) self.assertAlmostEqual(5, result.readY(0)[0], places=12) mtd.remove("required") # Call with both outputs specified result = simpleapi.OptionalWorkspace(RequiredWorkspace="required", OptionalWorkspace="optional") self.assertTrue(isinstance(result, MatrixWorkspace)) self.assertAlmostEqual(5, result.readY(0)[0], places=12) mtd.remove("required") # Tidy up simple api function del simpleapi.OptionalWorkspace
def test_validate_inputs_with_errors_stops_algorithm(self): class ValidateInputsTest(PythonAlgorithm): def PyInit(self): self.declareProperty("Prop1", 1.0) self.declareProperty("Prop2", 2.0) def validateInputs(self): return {"Prop1":"Value is less than Prop2"} def PyExec(self): pass AlgorithmFactory.subscribe(ValidateInputsTest) # --------------------------------------------------------- alg_obj = ValidateInputsTest() alg_obj.initialize() simpleapi_func = simpleapi._create_algorithm_function("ValidateInputsTest", 1, alg_obj) # call self.assertRaises(RuntimeError, simpleapi_func, Prop1=2.5, Prop2=3.5)
def test_validate_inputs_with_errors_stops_algorithm(self): class ValidateInputsTest(PythonAlgorithm): def PyInit(self): self.declareProperty("Prop1", 1.0) self.declareProperty("Prop2", 2.0) def validateInputs(self): return {"Prop1":"Value is less than Prop2"} def PyExec(self): pass AlgorithmFactory.subscribe(ValidateInputsTest) # --------------------------------------------------------- alg_obj = ValidateInputsTest() alg_obj.initialize() simpleapi_func = simpleapi._create_algorithm_function("ValidateInputsTest", 1, alg_obj) # call self.assertRaises(RuntimeError, simpleapi_func, Prop1=2.5, Prop2=3.5)
""" Sets up mslice specific algorithms. This code executes when the module is imported (and should be imported first) as it can affect other imports. """ from mantid.api import AlgorithmFactory import mantid.simpleapi as s_api from mslice.models.cut.cut_algorithm import Cut from mslice.models.projection.powder.make_projection import MakeProjection from mslice.models.slice.slice_algorithm import Slice AlgorithmFactory.subscribe(MakeProjection) AlgorithmFactory.subscribe(Slice) AlgorithmFactory.subscribe(Cut) s_api._create_algorithm_function('MakeProjection', 1, MakeProjection()) s_api._create_algorithm_function('Slice', 1, Slice()) s_api._create_algorithm_function('Cut', 1, Cut())
def test_slice(self, alg_mock): # set up slice algorithm AlgorithmFactory.subscribe(Slice) alg_mock.Slice = wrap_algorithm(_create_algorithm_function('Slice', 1, Slice())) plot = compute_slice('test_ws', self.q_axis, self.e_axis, False) self.assertEqual(plot.get_signal().shape, (30, 25))
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)