def get_gui_algorithm_name(facility): if facility is SANSFacility.ISIS: algorithm_name = "SANSGuiDataProcessorAlgorithm" AlgorithmFactory.subscribe(SANSGuiDataProcessorAlgorithm) else: raise RuntimeError("The facility is currently not supported") return algorithm_name
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_that_selector_is_refreshed_on_alg_load(self): widget = AlgorithmSelectorWidgetMock() widget.refresh = mock.MagicMock() widget.observeUpdate(True) AlgorithmFactory.subscribe(ToyAlgorithm) self.assertTrue(widget.refresh.call_count == 1, "We expect the widget to be refreshed when the Algorithm Factory " "subscribes to a new algorithm. refresh was called " "{} times after subscription.".format(widget.refresh.call_count))
def test_can_toggle_algorithm_factory_notifications(self): widget = AlgorithmSelectorWidgetMock() widget.refresh = mock.MagicMock() widget.observeUpdate(True) widget.observeUpdate(False) AlgorithmFactory.subscribe(ToyAlgorithm) self.assertTrue(widget.refresh.call_count == 0, "We expect the widget to be refreshed when the Algorithm Factory " "subscribes to a new algorithm. refresh was called " "{} times after subscription.".format(widget.refresh.call_count))
def test_class_can_override_standard_algorithm_methods(self): class TestDataProcessor(DataProcessorAlgorithm): def version(self): return 2 def PyInit(self): pass def PyExec(self): pass # end v2 alg AlgorithmFactory.subscribe(TestDataProcessor) assertRaisesNothing(self, AlgorithmManager.createUnmanaged, "TestDataProcessor", 2)
def setUp(self): if self.__class__._registered is None: self.__class__._registered = True AlgorithmFactory.subscribe(TestPyAlgDefaultAttrs) AlgorithmFactory.subscribe(TestPyAlgOverriddenAttrs) AlgorithmFactory.subscribe(TestPyAlgIsRunningReturnsNonBool) AlgorithmFactory.subscribe(CancellableAlg)
def test_explicit_store_in_ADS(self): class SimpleAPIPythonAlgorithm5(PythonAlgorithm): def PyInit(self): pass def PyExec(self): from mantid.simpleapi import CreateSampleWorkspace workspaceInADS = CreateSampleWorkspace(StoreInADS=True) assert(workspaceInADS) AlgorithmFactory.subscribe(SimpleAPIPythonAlgorithm5) alg = SimpleAPIPythonAlgorithm5() alg.initialize() alg.execute() self.assertTrue('workspaceInADS' in mtd)
def test_python_alg_can_use_other_python_alg_through_simple_api(self): """ Runs a test in a separate process as it requires a reload of the whole mantid module """ src = """ from mantid.api import PythonAlgorithm, AlgorithmFactory import mantid.simpleapi as api from mantid.simpleapi import * class %(name)s(PythonAlgorithm): def PyInit(self): pass def PyExec(self): %(execline1)s %(execline2)s AlgorithmFactory.subscribe(%(name)s) """ name1 = "SimpleAPIPythonAlgorithm1" name2 = "SimpleAPIPythonAlgorithm2" src1 = src % {"name":name1,"execline1":name2+"()","execline2":"api."+name2+"()"} src2 = src % {"name":name2,"execline1":"pass","execline2":"pass"} a = TemporaryPythonAlgorithm(name1,src1) b = TemporaryPythonAlgorithm(name2,src2) import subprocess # Try to use algorithm 1 to run algorithm 2 cmd = sys.executable + ' -c "from mantid.simpleapi import %(name)s;%(name)s()"' % {'name':name1} try: subprocess.check_call(cmd,shell=True) except subprocess.CalledProcessError, exc: self.fail("Error occurred running one Python algorithm from another: %s" % str(exc))
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_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_later_store_in_ADS(self): from mantid.api import MatrixWorkspaceProperty from mantid.kernel import Direction class SimpleAPIPythonAlgorithm6(PythonAlgorithm): def PyInit(self): self.declareProperty(MatrixWorkspaceProperty("OutputWorkspace", "", Direction.Output)) def PyExec(self): from mantid.simpleapi import CreateSampleWorkspace workspaceNotInADS = CreateSampleWorkspace(StoreInADS=False) assert(workspaceNotInADS) self.setProperty("OutputWorkspace", workspaceNotInADS) AlgorithmFactory.subscribe(SimpleAPIPythonAlgorithm6) alg = SimpleAPIPythonAlgorithm6() alg.initialize() alg.setPropertyValue("OutputWorkspace", "out") alg.execute() self.assertTrue('out' in mtd) mtd.remove('out')
panel_pos = component.position(panel_index) panel_rel_pos = component.relativePosition(panel_index) # need to move detector in direction in x-z plane panel_offset = panel_rel_pos * (distance / panel_rel_pos.norm()) panel_offset += panel_pos component.setPosition(panel_index, panel_offset) def __get_wavelength(self, exp_info): """ Gets the wavelength from experiment info if provided, otherwise it will try to get the value from the algorithm property. Throws a RuntimeError if a wavelength cannot be found from either. :param exp_info: The experiment info of the run to lookup set wavelength value :return: wavelength value from experiment info if set, or from wavelength property """ if exp_info.run().hasProperty("wavelength"): return exp_info.run().getProperty("wavelength").value else: # Set wavelength value from the backup property, if provided wl_prop = self.getProperty("Wavelength") if not wl_prop.isDefault: return wl_prop.value else: # If wavelength value not set, throw an error raise RuntimeError( "Wavelength not found in sample log and was not provided as input to the algorithm" ) AlgorithmFactory.subscribe(HB3AAdjustSampleNorm)
raise RuntimeError("Failed to determine IPTS directory " + "from path '%s'" % filename) location = filename.find('/', location) direc = filename[0:location + 1] return direc def PyInit(self): self.declareProperty('RunNumber', defaultValue=0, direction=Direction.Input, validator=IntBoundedValidator(lower=1), doc="Extracts the IPTS number for a run") instruments = self.getValidInstruments() self.declareProperty('Instrument', '', StringListValidator(instruments), "Empty uses default instrument") self.declareProperty('Directory', '', direction=Direction.Output) def PyExec(self): instrument = self.getProperty('Instrument').value runnumber = self.getProperty('RunNumber').value direc = self.getIPTSLocal(instrument, runnumber) self.setPropertyValue('Directory', direc) self.log().notice('IPTS directory is: %s' % direc) AlgorithmFactory.subscribe(GetIPTS)
name=self._instrument_name) else: raise ValueError("Unknown instrument %s" % instrument_name) self._atoms = self.getProperty("Atoms").value self._sum_contributions = self.getProperty("SumContributions").value # conversion from str to int self._num_quantum_order_events = int( self.getProperty("QuantumOrderEventsNumber").value) self._scale_by_cross_section = self.getPropertyValue( 'ScaleByCrossSection') self._out_ws_name = self.getPropertyValue('OutputWorkspace') self._calc_partial = (len(self._atoms) > 0) # Sampling mesh is determined by # AbinsModules.AbinsParameters.sampling['min_wavenumber'] # AbinsModules.AbinsParameters.sampling['max_wavenumber'] # and AbinsModules.AbinsParameters.sampling['bin_width'] step = self._bin_width start = AbinsParameters.sampling['min_wavenumber'] stop = AbinsParameters.sampling['max_wavenumber'] + step self._bins = np.arange(start=start, stop=stop, step=step, dtype=AbinsModules.AbinsConstants.FLOAT_TYPE) AlgorithmFactory.subscribe(Abins)
Convert Euler angles to a quaternion """ getV3D = {'X': V3D(1, 0, 0), 'Y': V3D(0, 1, 0), 'Z': V3D(0, 0, 1)} return (Quat(alpha, getV3D[convention[0]]) * Quat(beta, getV3D[convention[1]]) * Quat(gamma, getV3D[convention[2]])) def _eulerToAngleAxis(self, alpha, beta, gamma, convention): """ Convert Euler angles to a angle rotation around an axis """ quat = self._eulerToQuat(alpha, beta, gamma, convention) if quat[0] == 1: return 0, 0, 0, 1 deg = math.acos(quat[0]) scale = math.sin(deg) deg *= 360.0 / math.pi ax0 = quat[1] / scale ax1 = quat[2] / scale ax2 = quat[3] / scale return deg, ax0, ax1, ax2 try: from scipy.optimize import minimize AlgorithmFactory.subscribe(AlignComponents) except ImportError: logger.debug( 'Failed to subscribe algorithm AlignComponets; cannot import minimize from scipy.optimize' )
crop_alg.setProperty("XMin", xmin) crop_alg.setProperty("XMax", xmax) crop_alg.execute() out_ws = crop_alg.getProperty("OutputWorkspace").value # add logs num_spectra = out_ws.getNumberHistograms() run_obj = out_ws.getRun() min_values = [xmin]*num_spectra max_values = [xmax]*num_spectra if run_obj.hasProperty('MDNorm_low'): #TODO: when handling of masking bins is implemented, number of spectra will be different # than the number of limits try: min_values = numpy.maximum(min_values, run_obj.getProperty('MDNorm_low').value).tolist() except ValueError: raise RuntimeError("Could not compare old and new values for 'MDNorm_low' log. "+ "Make sure the length of the old data is equal to the number of spectra") run_obj.addProperty('MDNorm_low', min_values, True) if run_obj.hasProperty('MDNorm_high'): try: max_values = numpy.minimum(max_values, run_obj.getProperty('MDNorm_high').value).tolist() except ValueError: raise RuntimeError("Could not compare old and new values for 'MDNorm_high' log. "+ "Make sure the length of the old data is equal to the number of spectra") run_obj.addProperty('MDNorm_high', [xmax]*num_spectra, True) run_obj.addProperty('MDNorm_spectra_index', numpy.arange(num_spectra).tolist(), True) self.setProperty('OutputWorkspace', out_ws) # Register algorithm with Mantid. AlgorithmFactory.subscribe(CropWorkspaceForMDNorm)
self.input_workspaces['SF_Background'] = self.getPropertyValue( "SFBkgrWorkspace") self.input_workspaces['NSF_Background'] = self.getPropertyValue( "NSFBkgrWorkspace") self.sf_outws_name = self.getPropertyValue("SFOutputWorkspace") self.nsf_outws_name = self.getPropertyValue("NSFOutputWorkspace") # check if possible to apply correction self._can_correct() # apply flipping ratio correction, retrieve the result self._fr_correction() nsf_outws = api.AnalysisDataService.retrieve(self.nsf_outws_name) sf_outws = api.AnalysisDataService.retrieve(self.sf_outws_name) # copy sample logs from data workspace to the output workspace api.CopyLogs(InputWorkspace=self.input_workspaces['SF_Data'], OutputWorkspace=self.sf_outws_name, MergeStrategy='MergeReplaceExisting') api.CopyLogs(InputWorkspace=self.input_workspaces['NSF_Data'], OutputWorkspace=self.nsf_outws_name, MergeStrategy='MergeReplaceExisting') self.setProperty("SFOutputWorkspace", sf_outws) self.setProperty("NSFOutputWorkspace", nsf_outws) return # Register algorithm with Mantid AlgorithmFactory.subscribe(DNSFlippingRatioCorr)
if skip: I = number_omega - I + 2 else: I += 1 AAA += sum_1 * Area_y BBB += sum_2 * Area_y Area += Area_sum * Area_y return AAA, BBB, Area #------------------------------------------------------------------------------ def _distance(self, r1, radius, omega): r = r1 distance = 0. b = r * math.sin(omega) if abs(b) < radius: t = r * math.cos(omega) c = radius * radius - b * b d = math.sqrt(c) if r <= radius: distance = t + d else: distance = d * (1.0 + math.copysign(1.0, t)) return distance #------------------------------------------------------------------------------ # Register algorithm with Mantid AlgorithmFactory.subscribe(CylinderPaalmanPingsCorrection)
convert_alg.execute() workspace = convert_alg.getProperty("OutputWorkspace").value append_to_sans_file_tag(workspace, "_histogram") return workspace def _get_state(self): state_property_manager = self.getProperty("SANSState").value state = create_deserialized_sans_state_from_property_manager(state_property_manager) state.property_manager = state_property_manager return state def _get_monitor_workspace(self): monitor_workspace = self.getProperty("SampleScatterMonitorWorkspace").value return self._get_cloned_workspace(monitor_workspace) def _get_cloned_workspace(self, workspace): clone_name = "CloneWorkspace" clone_options = {"InputWorkspace": workspace, "OutputWorkspace": EMPTY_NAME} clone_alg = create_child_algorithm(self, clone_name, **clone_options) clone_alg.execute() return clone_alg.getProperty("OutputWorkspace").value def _get_progress(self): return Progress(self, start=0.0, end=1.0, nreports=10) # Register algorithm with Mantid AlgorithmFactory.subscribe(SANSBeamCentreFinderMassMethod)
OutputWorkspace=correctedWSName, EnableLogging=subalgLogging) wsCleanup.cleanup(mainWS) return correctedWS def _finalize(self, outWS, wsCleanup): """Do final cleanup and set the output property.""" self.setProperty(common.PROP_OUTPUT_WS, outWS) wsCleanup.cleanup(outWS) wsCleanup.finalCleanup() def _inputWS(self, wsCleanup): """Return the raw input workspace.""" mainWS = self.getProperty(common.PROP_INPUT_WS).value wsCleanup.protect(mainWS) return mainWS def _subtractEC(self, mainWS, wsNames, wsCleanup, subalgLogging): """Subtract the empty container workspace without self-shielding corrections.""" if self.getProperty(common.PROP_EC_WS).isDefault: return mainWS ecWS = self.getProperty(common.PROP_EC_WS).value ecScaling = self.getProperty(common.PROP_EC_SCALING).value subtractedWS = _subtractEC(mainWS, ecWS, ecScaling, wsNames, wsCleanup, subalgLogging) wsCleanup.cleanup(mainWS) return subtractedWS AlgorithmFactory.subscribe(DirectILLApplySelfShielding)
#pylint: disable=no-init from mantid.api import PythonAlgorithm, AlgorithmFactory, ITableWorkspaceProperty, WorkspaceFactory from mantid.kernel import Direction # Create an empty table workspace to be populated by a python script. class CreateEmptyTableWorkspace(PythonAlgorithm): def summary(self): return "Creates an empty TableWorkspace which can be populated with various "\ "types of information." def category(self): return 'Utility\\Workspaces' def PyInit(self): # Declare properties self.declareProperty( ITableWorkspaceProperty("OutputWorkspace", "", Direction.Output), "The name of the table workspace that will be created.") def PyExec(self): tableWS = WorkspaceFactory.createTable() self.setProperty("OutputWorkspace", tableWS) # Register algorithm with Mantid AlgorithmFactory.subscribe(CreateEmptyTableWorkspace)
('Median', collections.OrderedDict()), ('Maximum', collections.OrderedDict()), ('Mean', collections.OrderedDict()), ]) for index in indices_list: column_name = column_names[index] try: column_data = np.array([float(v) for v in in_ws.column(index)]) col_stats = _stats_to_dict(Stats.getStatistics(column_data)) for stat_name in stats: stats[stat_name][column_name] = col_stats[stat_name] out_ws.addColumn('float', column_name) except RuntimeError: logger.notice('Column \'%s\' is not numerical, skipping' % column_name) except: logger.notice('Column \'%s\' is not numerical, skipping' % column_name) for index, stat_name in iteritems(stats): stat = collections.OrderedDict(stat_name) stat['Statistic'] = index out_ws.addRow(stat) self.setProperty('OutputWorkspace', out_ws) # Register algorithm with Mantid AlgorithmFactory.subscribe(StatisticsOfTableWorkspace)
quick_run_alg = self.createChildAlgorithm("IndirectQuickRun", 0.05, 0.95) for num in range(self._number_samples): first_run = self._run_first + num run_numbers = [ str(first_run + idx * self._number_samples) for idx in range(self._number_runs) ] quick_run_alg.setProperty('InputFiles', run_numbers) quick_run_alg.setProperty('Instrument', self._instrument_name) quick_run_alg.setProperty('Analyser', self._analyser) quick_run_alg.setProperty('Reflection', self._reflection) quick_run_alg.setProperty('SpectraRange', self._spectra_range) quick_run_alg.setProperty('ElasticRange', self._elastic_range) quick_run_alg.setProperty('InelasticRange', self._inelastic_range) quick_run_alg.setProperty('TotalRange', self._total_range) quick_run_alg.setProperty('SampleEnvironmentLogName', self._sample_log_name) quick_run_alg.setProperty('SampleEnvironmentLogValue', self._sample_log_value) quick_run_alg.setProperty('MSDFit', self._msd_fit) quick_run_alg.setProperty('WidthFit', self._width_fit) quick_run_alg.setProperty('Plot', self._plot) quick_run_alg.setProperty('Save', self._save) quick_run_alg.execute() AlgorithmFactory.subscribe( IndirectSampleChanger) # Register algorithm with Mantid
# ------------------------------------------------------------ self.setProperty("OutputWorkspace", workspace) # ------------------------------------------------------------ # Diagnostic output # ------------------------------------------------------------ if sum_of_counts: self.setProperty("SumOfCounts", sum_of_counts) if sum_of_norms: self.setProperty("SumOfNormFactors", sum_of_norms) self.setProperty("CalculatedTransmissionWorkspace", calculated_transmission_workspace) self.setProperty("UnfittedTransmissionWorkspace", unfitted_transmission_workspace) def validateInputs(self): errors = dict() # Check that the input can be converted into the right state object try: state = self._get_state() state.validate() except ValueError as err: errors.update({"SANSSingleReduction": str(err)}) return errors def _get_progress(self): return Progress(self, start=0.0, end=1.0, nreports=10) # Register algorithm with Mantid AlgorithmFactory.subscribe(SANSReductionCore)
if skip: I = number_omega - I + 2 else: I += 1 AAA += sum_1 * Area_y BBB += sum_2 * Area_y Area += Area_sum * Area_y return AAA, BBB, Area # ------------------------------------------------------------------------------ def _distance(self, r1, radius, omega): r = r1 distance = 0.0 b = r * math.sin(omega) if abs(b) < radius: t = r * math.cos(omega) c = radius * radius - b * b d = math.sqrt(c) if r <= radius: distance = t + d else: distance = d * (1.0 + math.copysign(1.0, t)) return distance # ------------------------------------------------------------------------------ # Register algorithm with Mantid AlgorithmFactory.subscribe(CylinderPaalmanPingsCorrection)
'energy_min', 'energy_max', 'sample_binning'] log_values = [self._res_name, str(self._background), str(self._elastic), energy_min, energy_max, sample_binning] add_log = self.createChildAlgorithm('AddSampleLogMultiple', enableLogging=False) add_log.setProperty('Workspace', workspace) add_log.setProperty('LogNames', log_names) add_log.setProperty('LogValues', log_values) add_log.setProperty('ParseType', True) # Should determine String/Number type add_log.execute() def _get_properties(self): self._sam_name = self.getPropertyValue('SampleWorkspace') self._sam_ws = self.getProperty('SampleWorkspace').value self._res_name = self.getPropertyValue('ResolutionWorkspace') self._e_min = self.getProperty('EMin').value self._e_max = self.getProperty('EMax').value self._sam_bins = self.getPropertyValue('SampleBins') self._elastic = self.getProperty('Elastic').value self._background = self.getPropertyValue('Background') self._nbet = self.getProperty('NumberBeta').value self._nsig = self.getProperty('NumberSigma').value self._loop = self.getProperty('Loop').value self._erange = [self._e_min, self._e_max] # [sample_bins, resNorm_bins=1] self._nbins = [self._sam_bins, 1] AlgorithmFactory.subscribe(BayesStretch) # Register algorithm with Mantid
wavelength_options = {"InputWorkspace": workspace, "WavelengthLow": wavelength_state.wavelength_low[0], "WavelengthHigh": wavelength_state.wavelength_high[0], "WavelengthStep": wavelength_state.wavelength_step, "WavelengthStepType": RangeStepType.to_string( wavelength_state.wavelength_step_type), "RebinMode": RebinType.to_string(wavelength_state.rebin_type)} wavelength_alg = create_unmanaged_algorithm(wavelength_name, **wavelength_options) wavelength_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME) wavelength_alg.setProperty("OutputWorkspace", workspace) wavelength_alg.execute() converted_workspace = wavelength_alg.getProperty("OutputWorkspace").value append_to_sans_file_tag(converted_workspace, "_wavelength") self.setProperty("OutputWorkspace", converted_workspace) def validateInputs(self): errors = dict() # Check that the input can be converted into the right state object state_property_manager = self.getProperty("SANSState").value try: state = create_deserialized_sans_state_from_property_manager(state_property_manager) state.property_manager = state_property_manager state.validate() except ValueError as err: errors.update({"SANSSMove": str(err)}) return errors # Register algorithm with Mantid AlgorithmFactory.subscribe(SANSConvertToWavelength)
Goniometers=self.getProperty('Goniometers').value, Axis0='{},0,1,0,1'.format(offset), Axis1=self.getProperty('Axis0').value, Axis2=self.getProperty('Axis1').value, Axis3=self.getProperty('Axis2').value) else: SetGoniometer(Workspace=ws_name, Axis0='{},0,1,0,1'.format(offset), Axis1='omega,0,1,0,1', Axis2='chi,0,0,1,1', Axis3='phi,0,1,0,1') else: if self.getProperty('SetGoniometer').value: SetGoniometer( Workspace=ws_name, Goniometers=self.getProperty('Goniometers').value, Axis0=self.getProperty('Axis0').value, Axis1=self.getProperty('Axis1').value, Axis2=self.getProperty('Axis2').value) ConvertUnits(InputWorkspace=ws_name, OutputWorkspace=ws_name, Target='Momentum') CropWorkspaceForMDNorm(InputWorkspace=ws_name, OutputWorkspace=ws_name, XMin=self.XMin, XMax=self.XMax) AlgorithmFactory.subscribe(SingleCrystalDiffuseReduction)
return def PyExec(self): # Input input_list = self.getProperty("WorkspaceNames").value self.outws_name = self.getProperty("OutputWorkspace").valueAsStr self.xaxis = self.getProperty("HorizontalAxis").value self.workspace_names = self._expand_groups(input_list) self.log().information("Workspaces to merge: %i" % (len(self.workspace_names))) # produce warnings is some optional sample logs do not match result = api.CompareSampleLogs(self.workspace_names, self.properties_to_compare, 1e-2) self._merge_workspaces() outws = api.AnalysisDataService.retrieve(self.outws_name) api.CopyLogs(self.workspace_names[0], outws) # remove logs which do not match if result: api.RemoveLogs(outws, result) self.setProperty("OutputWorkspace", outws) return # Register algorithm with Mantid AlgorithmFactory.subscribe(DNSMergeRuns)
maxIndex = ws.getNumberHistograms() - 1 foregroundYs = foregroundWS.dataY(0) foregroundEs = foregroundWS.dataE(0) numpy.square(foregroundEs, out=foregroundEs) for i in sumIndices: if i == beamPosIndex: continue if i < 0 or i > maxIndex: self.log().warning( 'Foreground partially out of the workspace.') ys = ws.readY(i) foregroundYs += ys es = ws.readE(i) foregroundEs += es**2 numpy.sqrt(foregroundEs, out=foregroundEs) self._cleanup.cleanup(ws) AddSampleLog(Workspace=foregroundWS, LogName=common.SampleLogs.SUM_TYPE, LogText=SumType.IN_LAMBDA, LogType='String', EnableLogging=self._subalgLogging) ConvertToDistribution(Workspace=foregroundWS, EnableLogging=self._subalgLogging) return foregroundWS def _sumType(self): return self.getProperty(Prop.SUM_TYPE).value AlgorithmFactory.subscribe(ReflectometryILLSumForeground)
api.AddSampleLog(outws, 'polarisation_comment', LogText=str(pol[1]), LogType='String') # slits api.AddSampleLog(outws, LogName='slit_i_upper_blade_position', LogText=str(metadata.slit_i_upper_blade_position), LogType='Number', LogUnit='mm') api.AddSampleLog(outws, LogName='slit_i_lower_blade_position', LogText=str(metadata.slit_i_lower_blade_position), LogType='Number', LogUnit='mm') api.AddSampleLog(outws, LogName='slit_i_left_blade_position', LogText=str(metadata.slit_i_left_blade_position), LogType='Number', LogUnit='mm') api.AddSampleLog(outws, 'slit_i_right_blade_position', LogText=str(metadata.slit_i_right_blade_position), LogType='Number', LogUnit='mm') # data normalization # add information whether the data are normalized (duration/monitor/no): api.AddSampleLog(outws, LogName='normalized', LogText=norm, LogType='String') outws.setYUnit(yunit) outws.setYUnitLabel(ylabel) self.setProperty("OutputWorkspace", outws) self.log().debug('LoadDNSLegacy: data are loaded to the workspace ' + outws_name) return # Register algorithm with Mantid AlgorithmFactory.subscribe(LoadDNSLegacy)
def serialize_in_log(self, ws_name): r"""Save the serialization of the algorithm in the logs. Parameters ---------- ws_name: str Name of the workspace from which to retrieve and modify the logs """ def jsonify(value): r"""Cast non-standard objects to their closest standard representation to enable JSON serialiation""" if isinstance(value, np.ndarray): return value.tolist() return value if self._as_json is None: self._as_json = json.loads(str(self)) # Force serialization of the following properties even if having # their default values forced = {name: jsonify(self.getProperty(name).value) for name in ('DoIndividual', 'MonitorNorm', 'NormalizeToFirst', 'ReflectionType', 'EnergyBins', 'MomentumTransferBins', 'MaskFile', 'DivideByVanadium')} self._as_json['properties'].update(forced) r = mtd[ws_name].mutableRun() r.addProperty('asString', json.dumps(self._as_json), True) # Register algorithm with Mantid. AlgorithmFactory.subscribe(BASISReduction)
b=self._b, c=self._c, alpha=self._alpha, beta=self._beta, gamma=self._gamma, StoreInADS=False) # new linked predicted peaks linked_peaks_predicted = PredictPeaks( InputWorkspace=linked_peaks, WavelengthMin=self._wavelength_min, WavelengthMax=self._wavelength_max, MinDSpacing=self._min_dspacing, MaxDSpacing=self._max_dspacing, ReflectionCondition=self._reflection_condition, StoreInADS=False) # clean up self.setProperty("LinkedPeaks", linked_peaks) self.setProperty("LinkedPredictedPeaks", linked_peaks_predicted) if mtd.doesExist("linked_peaks"): DeleteWorkspace(linked_peaks) if mtd.doesExist("linked_peaks_predicted"): DeleteWorkspace(linked_peaks_predicted) if self._delete_ws: DeleteWorkspace(self._workspace) # register algorithm with mantid AlgorithmFactory.subscribe(LinkedUBs)
except: raise RuntimeError('Could not find run number for workspace ' + workspace.getName()) def _hasWorkspaceID(workspace_name, workspace_id): """Check that a workspace has the given type""" workspace = AnalysisDataService.retrieve(workspace_name) if isinstance(workspace, WorkspaceGroup): return workspace[0].id() == workspace_id else: return workspace.id() == workspace_id 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)) AlgorithmFactory.subscribe(ReflectometryISISLoadAndProcess)
transmission_workspace = self.getProperty( "TransmissionWorkspace").value return self._get_cloned_workspace( transmission_workspace) if transmission_workspace else None def _get_direct_workspace(self): direct_workspace = self.getProperty("DirectWorkspace").value return self._get_cloned_workspace( direct_workspace) if direct_workspace else None def _get_monitor_workspace(self): monitor_workspace = self.getProperty("ScatterMonitorWorkspace").value return self._get_cloned_workspace(monitor_workspace) def _get_cloned_workspace(self, workspace): clone_name = "CloneWorkspace" clone_options = { "InputWorkspace": workspace, "OutputWorkspace": EMPTY_NAME } clone_alg = create_child_algorithm(self, clone_name, **clone_options) clone_alg.execute() return clone_alg.getProperty("OutputWorkspace").value def _get_progress(self): return Progress(self, start=0.0, end=1.0, nreports=10) # Register algorithm with Mantid AlgorithmFactory.subscribe(SANSBeamCentreFinderCore)
#calculate chi^2 soeName = self.getPropertyValue("ResidualsWorkspace") if (len(soeName)>0): mantid.simpleapi.SignalOverError(__w1-__w2,OutputWorkspace=soeName) self.setProperty("ResidualsWorkspace",soeName) __soe=mantid.mtd[soeName] else: __soe=mantid.simpleapi.SignalOverError(__w1-__w2) __soe2=__soe*__soe __soe2=mantid.simpleapi.ReplaceSpecialValues(__soe2,0,0,0,0) data=__soe2.extractY() chisquared=numpy.sum(data) #write out the Dakota chi squared file f = open(fout,'w') f.write(str(chisquared)+' obj_fn\n') f.close() self.setProperty("ChiSquared",chisquared) #cleanup mantid.simpleapi.DeleteWorkspace(__w1.getName()) mantid.simpleapi.DeleteWorkspace(__w2.getName()) mantid.simpleapi.DeleteWorkspace(__soe2.getName()) if (len(soeName)==0): mantid.simpleapi.DeleteWorkspace(__soe.getName()) AlgorithmFactory.subscribe(DakotaChiSquared)
issues['Height'] = 'Please enter a non-zero number for height' if self._shape == 'FlatPlate': if not self._width: issues['Width'] = 'Please enter a non-zero number for width' if not self._thickness: issues[ 'Thickness'] = 'Please enter a non-zero number for thickness' if self._shape == 'Cylinder': if not self._radius: issues['Radius'] = 'Please enter a non-zero number for radius' if self._shape == 'Annulus': if not self._inner_radius: issues[ 'InnerRadius'] = 'Please enter a non-zero number for inner radius' if not self._outer_radius: issues[ 'OuterRadius'] = 'Please enter a non-zero number for outer radius' # Geometry validation: outer radius > inner radius if not self._outer_radius > self._inner_radius: issues['OuterRadius'] = 'Must be greater than InnerRadius' return issues # Register algorithm with Mantid AlgorithmFactory.subscribe(SimpleShapeMonteCarloAbsorption)
def validateInputs(self): """ Validate algorithm options. """ self._setup() issues = dict() if self._use_can_corrections and self._can_chemical_formula == '': issues['CanChemicalFormula'] = 'Must be set to use can corrections' if self._use_can_corrections and self._can_ws_name is None: issues['UseCanCorrections'] = 'Must specify a can workspace to use can corrections' # Geometry validation: can inner < sample inner < sample outer < can outer if self._sample_inner_radius < self._can_inner_radius: issues['SampleInnerRadius'] = 'Must be greater than CanInnerRadius' if self._sample_outer_radius < self._sample_inner_radius: issues['SampleOuterRadius'] = 'Must be greater than SampleInnerRadius' if self._can_outer_radius < self._sample_outer_radius: issues['CanOuterRadius'] = 'Must be greater than SampleOuterRadius' return issues # Register algorithm with Mantid AlgorithmFactory.subscribe(IndirectAnnulusAbsorption)
raise ValueError(str(re)) # Set up the output ws table. CreateEmptyTableWorkspace(OutputWorkspace=output_ws_name) output_ws = mtd[output_ws_name] for prop_name in PROP_NAMES: output_ws.addColumn(name=prop_name, type='str') # Set up (and iterate over) a "file backed" iterator, which takes care # of loading files and then deleting the resulting workspaces in turn # when we are finished with them. ws_iter = FileBackedWsIterator(filenames) for ws in ws_iter: # Create a single row table for each file. temp_table_name = ws.getName() + "_INFO" CreateLogPropertyTable( InputWorkspaces=ws.getName(), LogPropertyNames=', '.join(PROP_NAMES), GroupPolicy="First", # Include only the 1st child of any groups. OutputWorkspace=temp_table_name) # Add its contents to the output before deleting it. temp_table = mtd[temp_table_name] output_ws.addRow(temp_table.row(0)) DeleteWorkspace(Workspace=temp_table_name) self.setPropertyValue('OutputWorkspace', output_ws_name) # Register algorthm with Mantid. AlgorithmFactory.subscribe(RetrieveRunInfo)
o_el = 1 else: o_el = 0 fitOp = [o_el, bgd, 0, 0] loopOp = self.getProperty('Sequence').value verbOp = self.getProperty('Verbose').value plotOp = self.getPropertyValue('Plot') saveOp = self.getProperty('Save').value workdir = config['defaultsave.directory'] if inType == 'File': spath = os.path.join(workdir, sname+'.nxs') # path name for sample nxs file LoadNexusProcessed(Filename=spath, OutputWorkspace=sname) Smessage = 'Sample from File : '+spath else: Smessage = 'Sample from Workspace : '+sname if rinType == 'File': rpath = os.path.join(workdir, rname+'.nxs') # path name for res nxs file LoadNexusProcessed(Filename=rpath, OutputWorkspace=rname) Rmessage = 'Resolution from File : '+rpath else: Rmessage = 'Resolution from Workspace : '+rname if verbOp: logger.notice(Smessage) logger.notice(Rmessage) Main.QuestRun(sname,rname,nbs,erange,nbins,fitOp,loopOp,plotOp,saveOp) AlgorithmFactory.subscribe(Quest) # Register algorithm with Mantid
@param workspace_suffix Suffix of result workspace name """ if workspace_suffix is None: workspace_suffix = parameter_name col_names = fit_params.getColumnNames() y_values = [] e_values = [] y_values = fit_params.column(col_names.index(parameter_name)) e_values = fit_params.column(col_names.index(parameter_name + '_Err')) ws_name = self._out_ws + '_' + workspace_suffix CreateWorkspace(OutputWorkspace=ws_name, DataX=x_axis, DataY=y_values, DataE=e_values, NSpec=1, UnitX=x_unit, VerticalAxisUnit='Text', VerticalAxisValues=[parameter_name]) return ws_name # Register algorithm with Mantid AlgorithmFactory.subscribe(ResNorm)
out_ws.addColumn('str', 'statistic') stats = { 'standard_deviation': dict(), 'maximum': dict(), 'minimum': dict(), 'mean': dict(), 'median': dict(), } for name in in_ws.getColumnNames(): try: col_stats = _stats_to_dict(Stats.getStatistics(np.array([float(v) for v in in_ws.column(name)]))) for statname in stats: stats[statname][name] = col_stats[statname] out_ws.addColumn('float', name) except ValueError: logger.notice('Column \'%s\' is not numerical, skipping' % name) for name, stat in iteritems(stats): stat1 = dict(stat) stat1['statistic'] = name out_ws.addRow(stat1) self.setProperty('OutputWorkspace', out_ws) # Register algorithm with Mantid AlgorithmFactory.subscribe(StatisticsOfTableWorkspace)
import unittest from mantid.simpleapi import CreateWorkspace, set_properties from mantid.api import (MatrixWorkspaceProperty, AlgorithmFactory, AlgorithmManager, DataProcessorAlgorithm, PythonAlgorithm) from mantid.kernel import Direction from six import iteritems class ChildAlg(PythonAlgorithm): def PyInit(self): pass def PyExec(self): pass AlgorithmFactory.subscribe(ChildAlg) class ParentAlg(DataProcessorAlgorithm): """Dummy workflow algorithm for testing purposes. This just creates an output workspace and runs a child algorithm. """ def PyInit(self): self.declareProperty(MatrixWorkspaceProperty('Workspace', '', Direction.InOut), doc="Name to give the input workspace.") def PyExec(self): alg = self.createChildAlgorithm('ChildAlg') alg.initialize()
""" Correct for sample and container. """ logger.information('Correcting sample and container') factor_workspaces_wavelength = {factor: self._convert_units_wavelength(workspace) for factor, workspace in factor_workspaces.items()} if self._rebin_container_ws: container_workspace = s_api.RebinToWorkspace(WorkspaceToRebin=container_workspace, WorkspaceToMatch=factor_workspaces_wavelength['acc'], OutputWorkspace="rebinned", StoreInADS=False) return self._corrections_approximation(sample_workspace, container_workspace, factor_workspaces_wavelength) def _three_factor_corrections_approximation(self, sample_workspace, container_workspace, factor_workspaces): acc = factor_workspaces['acc'] acsc = factor_workspaces['acsc'] assc = factor_workspaces['assc'] return (sample_workspace - container_workspace * (acsc / acc)) / assc def _two_factor_corrections_approximation(self, sample_workspace, container_workspace, factor_workspaces): acc = factor_workspaces['acc'] ass = factor_workspaces['ass'] return (sample_workspace / ass) - (container_workspace / acc) # Register algorithm with Mantid AlgorithmFactory.subscribe(ApplyPaalmanPingsCorrection)
correctionWSName = wsNames.withSuffix('correction') useFullInstrument = self.getProperty(common.PROP_SIMULATION_INSTRUMENT).value == common.SIMULATION_INSTRUMENT_FULL if useFullInstrument: correctionWS = MonteCarloAbsorption(InputWorkspace=wavelengthWS, OutputWorkspace=correctionWSName, SparseInstrument=False, NumberOfWavelengthPoints=wavelengthPoints, Interpolation='CSpline', EnableLogging=subalgLogging) else: rows = self.getProperty(common.PROP_SPARSE_INSTRUMENT_ROWS).value columns = self.getProperty(common.PROP_SPARSE_INSTRUMENT_COLUMNS).value correctionWS = MonteCarloAbsorption(InputWorkspace=wavelengthWS, OutputWorkspace=correctionWSName, SparseInstrument=True, NumberOfDetectorRows=rows, NumberOfDetectorColumns=columns, NumberOfWavelengthPoints=wavelengthPoints, Interpolation='CSpline', EnableLogging=subalgLogging) wsCleanup.cleanup(wavelengthWS) correctionWS = ConvertUnits(InputWorkspace=correctionWS, OutputWorkspace=correctionWSName, Target='TOF', EMode='Direct', EnableLogging=subalgLogging) return correctionWS AlgorithmFactory.subscribe(DirectILLSelfShielding)
from mantid.api import PythonAlgorithm, AlgorithmFactory, ITableWorkspaceProperty, WorkspaceFactory from mantid.kernel import Direction # Create an empty table workspace to be populated by a python script. class CreateEmptyTableWorkspace(PythonAlgorithm): def summary(self): return "Creates an empty TableWorkspace which can be populated with various types of information." def PyInit(self): # Declare properties self.declareProperty(ITableWorkspaceProperty("OutputWorkspace", "", Direction.Output), "The name of the table workspace that will be created.") def PyExec(self): tableWS = WorkspaceFactory.createTable() self.setProperty("OutputWorkspace", tableWS) # Register algorithm with Mantid AlgorithmFactory.subscribe(CreateEmptyTableWorkspace)
save_alg.setProperty("Filename", path) save_alg.execute() def _plot_result(self, workspaces): from IndirectImport import import_mantidplot mp = import_mantidplot() mp.plotSpectrum(workspaces,0) def _create_ws(self, output_ws, x, y, unit): create_alg = self.createChildAlgorithm("CreateWorkspace", enableLogging = False) create_alg.setProperty("OutputWorkspace", output_ws) create_alg.setProperty("DataX", x) create_alg.setProperty("DataY", y) create_alg.setProperty("Nspec", 1) create_alg.setProperty("UnitX", 'MomentumTransfer') create_alg.execute() mtd.addOrReplace(output_ws, create_alg.getProperty("OutputWorkspace").value) if unit == 'angle': unitx = mtd[output_ws].getAxis(0).setUnit("Label") unitx.setLabel('2theta', 'deg') def _group_ws(self, input_ws, output_ws): group_alg = self.createChildAlgorithm("GroupWorkspaces", enableLogging=False) group_alg.setProperty("InputWorkspaces", input_ws) group_alg.setProperty("OutputWorkspace", output_ws) group_alg.execute() mtd.addOrReplace(output_ws, group_alg.getProperty("OutputWorkspace").value) AlgorithmFactory.subscribe(MuscatElasticReactor) # Register algorithm with Mantid
# list of run_numbers api.AddSampleLog(Workspace=wsOutput, LogName='run_number', LogText=str(pdict['run_number']), LogType='String') self.setProperty("OutputWorkspace", wsOutput) def timingsMatch(self, wsNames): """ :param wsNames: :return: """ for i in range(len(wsNames)): leftWorkspace = wsNames[i] rightWorkspace = wsNames[i + 1] leftXData = api.mtd[leftWorkspace].dataX(0) rightXData = api.mtd[rightWorkspace].dataX(0) leftDeltaX = leftXData[0] - leftXData[1] rightDeltaX = rightXData[0] - rightXData[1] if abs(leftDeltaX - rightDeltaX) >= 1e-4 or abs(rightXData[0] - leftXData[0]) >= 1e-4: raise RuntimeError("Timings don't match") else: return True # Register algorithm with Mantid. AlgorithmFactory.subscribe(TOFTOFMergeRuns)
for i in range(10): ndens = (self._number_density/total_mass)*1e6 xst = self.free_xst(self._masses, scatter_length) attenuation_length = ndens*xst*1e-28 dmur = 2*attenuation_length*self._thickness trans_guess = math.exp(-dmur) self._number_density = ((1-self._transmission_guess)/(1-trans_guess))*self._number_density # Add guesses to output workspaces density_guesses_tbl_ws.addRow([str(i+1), self._number_density]) trans_guesses_tbl_ws.addRow([str(i+1), trans_guess]) self.setProperty("DensityWorkspace", density_guesses_tbl_ws) self.setProperty("TransmissionWorkspace", trans_guesses_tbl_ws) def free_xst(self, Mass, scatter_length): """ Analytic expression for integration of PDCS over E1 and solid angle """ # Neutron rest mass(u) / Mass xs_masses = 1.00867/Mass scatter_len_sq = np.square(scatter_length) cross_section = np.divide((self.FOUR_PI * scatter_len_sq),(np.square(xs_masses+1))) xs_sum = sum(cross_section) return xs_sum AlgorithmFactory.subscribe(VesuvioThickness)
peaks = run.getNumberPeaks() if peaks == 0: AnalysisDataService.remove(str(run)) else: group.append(str(run)) GroupWorkspaces(InputWorkspaces=group, OutputWorkspace=ws_group) OptimizeCrystalPlacement(PeaksWorkspace=ws_group, ModifiedPeaksWorkspace=ws_group, AdjustSampleOffsets=True, MaxSamplePositionChangeMeters=0.005, MaxIndexingError=tolerance) RenameWorkspace(InputWorkspace=str(minR), OutputWorkspace=ws_append) for run in range(minR + 1, maxR): if AnalysisDataService.doesExist(str(run)): CombinePeaksWorkspaces(LHSWorkspace=ws_append, RHSWorkspace=str(run), OutputWorkspace=ws_append) logger.notice( 'Optimized %s sample position: %s\n' % (str(run), mtd[str(run)].getPeak(0).getSamplePos())) AnalysisDataService.remove(str(run)) result = IndexPeaks(PeaksWorkspace=ws_append, Tolerance=tolerance) logger.notice('After Optimization Number indexed: %s error: %s\n' % (result[0], result[1])) AnalysisDataService.remove(ws_group) self.setProperty("OutputWorkspace", ws_append) # Register algorithm with Mantid AlgorithmFactory.subscribe(OptimizeCrystalPlacementByRun)
# Perform the masking number_of_masking_options = 7 progress = Progress(self, start=0.0, end=1.0, nreports=number_of_masking_options) mask_info = state.mask workspace = masker.mask_workspace(mask_info, workspace, component, progress) append_to_sans_file_tag(workspace, "_masked") self.setProperty("Workspace", workspace) progress.report("Completed masking the workspace") def _get_component(self): component_as_string = self.getProperty("Component").value return DetectorType.from_string(component_as_string) def validateInputs(self): errors = dict() # Check that the input can be converted into the right state object state_property_manager = self.getProperty("SANSState").value try: state = create_deserialized_sans_state_from_property_manager(state_property_manager) state.property_manager = state_property_manager state.validate() except ValueError as err: errors.update({"SANSSMask": str(err)}) return errors # Register algorithm with Mantid AlgorithmFactory.subscribe(SANSMaskWorkspace)
Scale(InputWorkspace=convertedToQName, OutputWorkspace=convertedToQName, Factor=scaleFactor) to_group.append(convertedToQName) self._autoCleanup.protect(convertedToQName) progress.report() if len(to_group) > 1: try: stitched = self._outWS + '_stitched' use_manual = self.getProperty( PropertyNames.USE_MANUAL_SCALE_FACTORS).value scale_factors = self.getProperty( PropertyNames.MANUAL_SCALE_FACTORS).value Stitch1DMany(InputWorkspaces=to_group, OutputWorkspace=stitched, UseManualScaleFactors=use_manual, ManualScaleFactors=scale_factors) to_group.append(stitched) except RuntimeError as re: self.log().warning( 'Unable to stitch automatically, consider stitching manually: ' + str(re)) GroupWorkspaces(InputWorkspaces=to_group, OutputWorkspace=self._outWS) self.setProperty(Prop.OUTPUT_WS, self._outWS) self._autoCleanup.finalCleanup() AlgorithmFactory.subscribe(ReflectometryILLAutoProcess)
workspace = self.getProperty("InputWorkspace").value # Component to crop component = self._get_component(workspace) progress = Progress(self, start=0.0, end=1.0, nreports=2) progress.report("Starting to crop component {0}".format(component)) # Crop to the component crop_name = "CropToComponent" crop_options = {"InputWorkspace": workspace, "OutputWorkspace": EMPTY_NAME, "ComponentNames": component} crop_alg = create_unmanaged_algorithm(crop_name, **crop_options) crop_alg.execute() output_workspace = crop_alg.getProperty("OutputWorkspace").value # Change the file tag and set the output append_to_sans_file_tag(output_workspace, "_cropped") self.setProperty("OutputWorkspace", output_workspace) progress.report("Finished cropping") def _get_component(self, workspace): component_as_string = self.getProperty("Component").value component = DetectorType.from_string(component_as_string) return get_component_name(workspace, component) # Register algorithm with Mantid AlgorithmFactory.subscribe(SANSCrop)
def doIterativeSmoothing(self, y, nwindow, maxdepth, depth=0): """ Iterative smoothing procedure to estimate the background in powder diffraction as published in Bruckner J. Appl. Cryst. (2000). 33, 977-979 :param y: signal to smooth :param n: size of window for convolution :param maxdepth: max depth of recursion (i.e. number of iterations) :param depth: current iteration :return: """ # smooth with hat function yy = np.copy(y) yy = np.convolve(yy, np.ones(nwindow) / nwindow, mode="same") # normalise end values effected by convolution ends = np.convolve(np.ones(nwindow), np.ones(nwindow) / nwindow, mode='same') yy[0:nwindow // 2] = yy[0:nwindow // 2] / ends[0:nwindow // 2] yy[-nwindow // 2:] = yy[-nwindow // 2:] / ends[-nwindow // 2:] if depth < maxdepth: # compare pt by pt with original and keep lowest idx = yy > y yy[idx] = y[idx] return self.doIterativeSmoothing(yy, nwindow, maxdepth, depth + 1) else: return yy # register algorithm with mantid AlgorithmFactory.subscribe(EnggEstimateFocussedBackground)
if selected_detector is None: selected_detector = detectors[DetectorType.to_string(DetectorType.LAB)] pos1 = selected_detector.sample_centre_pos1 pos2 = selected_detector.sample_centre_pos2 coordinates = [pos1, pos2] return coordinates def validateInputs(self): errors = dict() # Check that the input can be converted into the right state object state_property_manager = self.getProperty("SANSState").value try: state = create_deserialized_sans_state_from_property_manager(state_property_manager) state.property_manager = state_property_manager state.validate() except ValueError as err: errors.update({"SANSSMove": str(err)}) # Check that if the MoveType is either InitialMove or ElementaryDisplacement, then there are beam coordinates # supplied. In the case of SetToZero these coordinates are ignored if they are supplied coordinates = self.getProperty("BeamCoordinates").value selected_move_type = self._get_move_type() if len(coordinates) == 0 and (selected_move_type is MoveType.ElementaryDisplacement): errors.update({"BeamCoordinates": "Beam coordinates were not specified. An elementary displacement " "requires beam coordinates."}) return errors # Register algorithm with Mantid AlgorithmFactory.subscribe(SANSMove)
"""Create a new workspace with Y and E from directForegroundWS and X and DX data from ws.""" qWSName = self._names.withSuffix(extraLabel + 'in_momentum_transfer') qWS = CreateWorkspace( OutputWorkspace=qWSName, DataX=ws.readX(0), DataY=directForegroundWS.readY(0) [:: -1], # Invert data because wavelength is inversely proportional to Q. DataE=directForegroundWS.readE(0)[::-1], Dx=ws.readDx(0), UnitX=ws.getAxis(0).getUnit().unitID(), ParentWorkspace=directForegroundWS, EnableLogging=self._subalgLogging) return qWS def _TOFChannelWidth(self, sampleLogs): """Return the time of flight bin width.""" return sampleLogs.getProperty('PSD.time_of_flight_0').value def _toPointData(self, ws, extraLabel=''): """Convert ws from binned to point data.""" pointWSName = self._names.withSuffix(extraLabel + 'as_points') pointWS = ConvertToPointData(InputWorkspace=ws, OutputWorkspace=pointWSName, EnableLogging=self._subalgLogging) self._cleanup.cleanup(ws) return pointWS AlgorithmFactory.subscribe(ReflectometryILLConvertToQ)
"C_a", "C_b", "C_c", "C_z", "polarisation", "polarisation_comment"]) logs["values"].extend([metadata.flipper_precession_current, metadata.flipper_z_compensation_current, flipper_status, metadata.a_coil_current, metadata.b_coil_current, metadata.c_coil_current, metadata.z_coil_current, str(pol[0]), str(pol[1])]) logs["units"].extend(["A", "A", "", "A", "A", "A", "A", "", ""]) # slits logs["names"].extend(["slit_i_upper_blade_position", "slit_i_lower_blade_position", "slit_i_left_blade_position", "slit_i_right_blade_position"]) logs["values"].extend([metadata.slit_i_upper_blade_position, metadata.slit_i_lower_blade_position, metadata.slit_i_left_blade_position, metadata.slit_i_right_blade_position]) logs["units"].extend(["mm", "mm", "mm", "mm"]) # add information whether the data are normalized (duration/monitor/no): api.AddSampleLog(outws, LogName='normalized', LogText=norm, LogType='String') api.AddSampleLogMultiple(outws, LogNames=logs["names"], LogValues=logs["values"], LogUnits=logs["units"]) outws.setYUnit(yunit) outws.setYUnitLabel(ylabel) self.setProperty("OutputWorkspace", outws) self.log().debug('LoadDNSLegacy: data are loaded to the workspace ' + outws_name) return # Register algorithm with Mantid AlgorithmFactory.subscribe(LoadDNSLegacy)
move_component(component_name="", move_info=state.move, workspace=workspace, move_type=MoveTypes.RESET_POSITION) move_component(component_name="LAB", move_info=state.move, beam_coordinates=beam_coordinates, move_type=MoveTypes.INITIAL_MOVE, workspace=workspace, is_transmission_workspace=is_trans) def _get_progress_for_file_loading(self, data, state_adjustment): # Get the number of workspaces which are to be loaded number_of_files_to_load = sum(x is not None for x in [ data.sample_scatter, data.sample_transmission, data.sample_direct, data.can_transmission, data.can_transmission, data.can_direct, state_adjustment.calibration ]) progress_steps = number_of_files_to_load + 1 # Check if there is a move operation to be performed # The partitioning of the progress bar is 80% for loading if there is a move else 100% end = 1.0 progress = Progress(self, start=0.0, end=end, nreports=progress_steps) return progress # Register algorithm with Mantid AlgorithmFactory.subscribe(SANSLoad)
# Outputs the calculated density of states to another workspace dos2d = CloneWorkspace(inws) if iqq == 1: dos2d = Transpose(dos2d) for i in range(len(y)): dos2d.setY(i, y[i,:]) dos2d.setE(i, e[i,:]) dos2d.setYUnitLabel(ylabel) # Make a 1D (energy dependent) cut dos1d = Rebin2D(dos2d, [dq[0], dq[1]-dq[0], dq[1]], dosebin, True, True) if cm and input_en_in_meV: dos1d.getAxis(0).setUnit('DeltaE_inWavenumber') dos1d = ScaleX(dos1d, mev2cm) elif not cm and not input_en_in_meV: dos1d.getAxis(0).setUnit('DeltaE') dos1d = ScaleX(dos1d, 1/mev2cm) if absunits: print("Converting to states/energy") # cross-section information is given in barns, but data is in milibarns. sigma = atoms[0].neutron()['tot_scatt_xs'] * 1000 mass = atoms[0].mass dos1d = dos1d * (mass/sigma) * 4 * np.pi self.setProperty("OutputWorkspace", dos1d) DeleteWorkspace(dos2d) DeleteWorkspace(dos1d) AlgorithmFactory.subscribe(ComputeIncoherentDOS)
LHSWorkspace=ws, RHSWorkspace=rebinnedWaterWS, OutputWorkspace=calibratedWSName, EnableLogging=self._subalgLogging ) self._cleanup.cleanup(waterWS) self._cleanup.cleanup(rebinnedWaterWS) self._cleanup.cleanup(ws) return calibratedWS def _calibrateDetectorAngleByDirectBeam(self, ws): """Perform detector position correction for reflected beams.""" direct_line = self.getProperty('DirectBeamForegroundCentre').value calibratedWSName = self._names.withSuffix('reflected_beam_calibration') calibratedWS = SpecularReflectionPositionCorrect( InputWorkspace=ws, OutputWorkspace=calibratedWSName, DetectorComponentName='detector', LinePosition=direct_line, # yes, this is the direct line position! TwoTheta=2*self._theta_from_detector_angles(), PixelSize=common.pixelSize(self._instrumentName), DetectorCorrectionType='RotateAroundSample', DetectorFacesSample=True, EnableLogging=self._subalgLogging ) self._cleanup.cleanup(ws) return calibratedWS AlgorithmFactory.subscribe(ReflectometryILLPreprocess)