def test_that_can_add_workspaces_to_WorkspaceGroup_when_not_in_ADS(self): ws1 = WorkspaceFactory.create("Workspace2D", 2, 2, 2) ws2 = WorkspaceFactory.create("Workspace2D", 2, 2, 2) ws_group = WorkspaceGroup() ws_group.addWorkspace(ws1) ws_group.addWorkspace(ws2) self.assertEqual(ws_group.size(), 2)
def _loadFullprofPrfFile(self, prffilename): """ Load Fullprof .prf file """ # 1. Parse the file to dictionary infodict, data = self._parseFullprofPrfFile(prffilename) # 2. Export information to table file tablews = WorkspaceFactory.createTable() tablews.addColumn("str", "Name") tablews.addColumn("double", "Value") for parname in infodict.keys(): parvalue = infodict[parname] tablews.addRow([parname, parvalue]) # 3. Export the data workspace datasize = len(data) print "Data Size = ", datasize dataws = WorkspaceFactory.create("Workspace2D", 4, datasize, datasize) for i in xrange(datasize): for j in xrange(4): dataws.dataX(j)[i] = data[i][0] dataws.dataY(j)[i] = data[i][j + 1] dataws.dataE(j)[i] = 1.0 return (tablews, dataws)
def _loadFullprofPrfFile(self, prffilename): """ Load Fullprof .prf file """ # 1. Parse the file to dictionary infodict, data = self._parseFullprofPrfFile(prffilename) # 2. Export information to table file tablews = WorkspaceFactory.createTable() tablews.addColumn("str", "Name") tablews.addColumn("double", "Value") for parname in infodict.keys(): parvalue = infodict[parname] tablews.addRow([parname, parvalue]) # 3. Export the data workspace datasize = len(data) print "Data Size = ", datasize dataws = WorkspaceFactory.create("Workspace2D", 4, datasize, datasize) for i in xrange(datasize): for j in xrange(4): dataws.dataX(j)[i] = data[i][0] dataws.dataY(j)[i] = data[i][j+1] dataws.dataE(j)[i] = 1.0 return (tablews, dataws)
def test_remove_workspace_by_name_will_remove_a_fit_containing_a_specific_parameter_workspace( self): output_ws = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) table_workspace = WorkspaceFactory.createTable() output_ws_wrap1 = StaticWorkspaceWrapper("Output1", output_ws) parameter_ws_wrap1 = StaticWorkspaceWrapper("Parameter1", table_workspace) covariance_ws_wrap1 = StaticWorkspaceWrapper("Covariance1", table_workspace) output_ws_wrap2 = StaticWorkspaceWrapper("Output2", output_ws) parameter_ws_wrap2 = StaticWorkspaceWrapper("Parameter2", table_workspace) covariance_ws_wrap2 = StaticWorkspaceWrapper("Covariance2", table_workspace) fit1 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) fit2 = FitInformation(["Input2"], "GausOsc", [output_ws_wrap2], parameter_ws_wrap2, covariance_ws_wrap2) self.fitting_context.active_fit_history = [fit1, fit2] self.fitting_context.remove_workspace_by_name("Parameter1") self.assertEqual(self.fitting_context.active_fit_history[0], fit2) self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2)
def test_creating_a_workspace_from_another_with_different_size(self): clean = self._create_clean_workspace(nhist=2, xlength=4, ylength=3) nhist = 4 xlength = 6 ylength = 5 copy = WorkspaceFactory.create(clean, nhist, xlength, ylength) self._verify(copy, nhist, xlength, ylength)
def test_creating_a_workspace_from_another_with_different_size(self): clean = self._create_clean_workspace(nhist=2, xlength=3, ylength=4) nhist = 4 xlength = 5 ylength = 6 copy = WorkspaceFactory.create(clean, nhist, xlength, ylength) self._verify(copy, nhist, xlength, ylength)
def test_creating_a_workspace_from_another_gives_one_of_same_size(self): nhist = 2 xlength = 3 ylength = 4 clean = self._create_clean_workspace(nhist, xlength, ylength) copy = WorkspaceFactory.create(clean) self._verify(copy, nhist, xlength, ylength)
def _fill_s_1d_workspace(self, s_points=None, workspace=None, protons_number=None, nucleons_number=None): """ Puts 1D S into workspace. :param protons_number: number of protons in the given type of atom :param nucleons_number: number of nucleons in the given type of atom :param s_points: dynamical factor for the given atom :param workspace: workspace to be filled with S """ if protons_number is not None: s_points = s_points * self._scale * self.get_cross_section( scattering=self._scale_by_cross_section, protons_number=protons_number, nucleons_number=nucleons_number) dim = 1 length = s_points.size wrk = WorkspaceFactory.create("Workspace2D", NVectors=dim, XLength=length + 1, YLength=length) for i in range(dim): wrk.getSpectrum(i).setDetectorID(i + 1) wrk.setX(0, self._bins) wrk.setY(0, s_points) AnalysisDataService.addOrReplace(workspace, wrk) # Set correct units on workspace self.set_workspace_units(workspace, layout="1D")
def test_creating_a_workspace_from_another_gives_one_of_same_size(self): nhist = 2 xlength = 4 ylength = 3 clean = self._create_clean_workspace(nhist, xlength, ylength) copy = WorkspaceFactory.create(clean) self._verify(copy, nhist, xlength, ylength)
def test_that_all_latest_fits_will_return_the_two_most_recent_unique_fits( self): output_ws = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) table_workspace = WorkspaceFactory.createTable() output_ws_wrap1 = StaticWorkspaceWrapper("Output1", output_ws) parameter_ws_wrap1 = StaticWorkspaceWrapper("Parameter1", table_workspace) covariance_ws_wrap1 = StaticWorkspaceWrapper("Covariance1", table_workspace) output_ws_wrap2 = StaticWorkspaceWrapper("Output2", output_ws) parameter_ws_wrap2 = StaticWorkspaceWrapper("Parameter2", table_workspace) covariance_ws_wrap2 = StaticWorkspaceWrapper("Covariance2", table_workspace) fit1 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) fit2 = FitInformation(["Input2"], "GausOsc", [output_ws_wrap2], parameter_ws_wrap2, covariance_ws_wrap2) fit3 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) self.fitting_context.active_fit_history = [fit1, fit2, fit3] self.assertEqual(self.fitting_context.active_fit_history[0], fit1) self.assertEqual(self.fitting_context.active_fit_history[1], fit2) self.assertEqual(self.fitting_context.active_fit_history[2], fit3) # fit3 == fit1 and fit3 is more recent, so 'all_latest_fits' will only return the most recent unique fits. self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2) self.assertEqual(self.fitting_context.all_latest_fits()[1], fit3)
def test_create_results_table_with_logs_selected(self): workspace = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) workspace.mutableRun().addProperty("sample_temp", 50, True) workspace.mutableRun().addProperty("sample_magn_field", 2, True) _, model = create_test_model(('ws1',), 'func1', self.parameters, [StaticWorkspaceWrapper('ws1', workspace)], self.logs) selected_results = [('ws1', 0)] table = model.create_results_table(self.log_names, selected_results) expected_cols = ['workspace_name'] + self.log_names + [ 'f0.Height', 'f0.HeightError', 'f0.PeakCentre', 'f0.PeakCentreError', 'f0.Sigma', 'f0.SigmaError', 'f1.Height', 'f1.HeightError', 'f1.PeakCentre', 'f1.PeakCentreError', 'f1.Sigma', 'f1.SigmaError', 'Cost function value' ] expected_types = (TableColumnType.NoType, TableColumnType.X, TableColumnType.X, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y) avg_log_values = 50., 2.0 expected_content = [ ('ws1_Parameters', avg_log_values[0], avg_log_values[1], self.f0_height[0], self.f0_height[1], self.f0_centre[0], self.f0_centre[1], self.f0_sigma[0], self.f0_sigma[1], self.f1_height[0], self.f1_height[1], self.f1_centre[0], self.f1_centre[1], self.f1_sigma[0], self.f1_sigma[1], self.cost_function[0]) ] self._assert_table_matches_expected(zip(expected_cols, expected_types), expected_content, table, model.results_table_name())
def setUp(self): self.results_context = ResultsContext() self.result_table_names = ["Name1", "Name2"] workspace = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) add_ws_to_ads("Name1", workspace) add_ws_to_ads("Name2", workspace)
def create_test_workspace(ws_name=None, time_series_logs=None, string_value_logs=None): """ Create a test workspace. :param ws_name: An optional name for the workspace :param time_series_logs: A set of (name, (values,...)) :param string_value_logs: A set of (name, value) pairs :return: The new workspace """ fake_ws = WorkspaceFactory.create('Workspace2D', 1, 1, 1) run = fake_ws.run() if time_series_logs is not None: for name, values in time_series_logs: tsp = FloatTimeSeriesProperty(name) for item in values: try: time, value = item[0], item[1] except TypeError: time, value = "2000-05-01T12:00:00", item tsp.addValue(time, value) run.addProperty(name, tsp, replace=True) if string_value_logs is not None: for name, value in string_value_logs: run.addProperty(name, StringPropertyWithValue(name, value), replace=True) ws_name = ws_name if ws_name is not None else 'fitting_context_model_test' AnalysisDataService.Instance().addOrReplace(ws_name, fake_ws) return fake_ws
def test_that_all_latest_fits_will_return_the_two_most_recent_unique_fits(self): output_ws = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) table_workspace = WorkspaceFactory.createTable() output_ws_wrap1 = StaticWorkspaceWrapper("Output1", output_ws) parameter_ws_wrap1 = StaticWorkspaceWrapper("Parameter1", table_workspace) covariance_ws_wrap1 = StaticWorkspaceWrapper("Covariance1", table_workspace) output_ws_wrap2 = StaticWorkspaceWrapper("Output2", output_ws) parameter_ws_wrap2 = StaticWorkspaceWrapper("Parameter2", table_workspace) covariance_ws_wrap2 = StaticWorkspaceWrapper("Covariance2", table_workspace) fit1 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) fit2 = FitInformation(["Input2"], "GausOsc", [output_ws_wrap2], parameter_ws_wrap2, covariance_ws_wrap2) fit3 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) self.fitting_context.tf_asymmetry_mode = True self.fitting_context.simultaneous_fitting_mode = True self.fitting_context.active_fit_history = [fit1, fit2, fit3] self.assertEqual(self.fitting_context.active_fit_history[0], fit1) self.assertEqual(self.fitting_context.active_fit_history[1], fit2) self.assertEqual(self.fitting_context.active_fit_history[2], fit3) self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2) self.assertEqual(self.fitting_context.all_latest_fits()[1], fit3) self.fitting_context.tf_asymmetry_mode = False self.assertEqual(self.fitting_context.active_fit_history, []) self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2) self.assertEqual(self.fitting_context.all_latest_fits()[1], fit3)
def test_setting_spectra_from_array_using_incorrect_index_raises_error(self): nvectors = 2 xlength = 11 ylength = 10 test_ws = WorkspaceFactory.create("Workspace2D", nvectors, xlength, ylength) xvalues = np.arange(xlength) self.assertRaises(RuntimeError, test_ws.setX, 3, xvalues)
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!")
def test_that_get_item_scope_works_not_in_ads(self): with self._HoldWsGroup() as group: # Note we want to create this inline so our ref is through getItem group.addWorkspace(WorkspaceFactory.create("Workspace2D", 1, 1, 1)) ws = group.getItem(0) self.assertFalse(ws.name()) # Not in ADS so should be no name self.assertEqual(len(AnalysisDataService.getObjectNames()), 0) # Now the group should be deleted, this should continue to work now self.assertFalse(ws.name())
def _create_dummy_workspace(self, name): wrk = WorkspaceFactory.create("Workspace2D", NVectors=1, XLength=2, YLength=1) wrk.setX(0, [0, 1]) wrk.setY(0, [0]) AnalysisDataService.addOrReplace(name, wrk) return wrk
def test_setting_spectra_from_array_of_incorrect_length_raises_error(self): nvectors = 2 xlength = 11 ylength = 10 test_ws = WorkspaceFactory.create("Workspace2D", nvectors, xlength, ylength) values = np.arange(xlength + 1) self.assertRaises(ValueError, test_ws.setX, 0, values) self.assertRaises(ValueError, test_ws.setY, 0, values) self.assertRaises(ValueError, test_ws.setE, 0, values)
def runTest(self): PDLoadCharacterizations(Filename=self.char_file, OutputWorkspace='characterizations', SpectrumIDs='1', L2='3.18', Polar='90', Azimuthal='0') self.wksp_mem = os.path.basename(self.data_file).split('.')[0] self.wksp_mem, self.wksp_file = self.wksp_mem + '_mem', self.wksp_mem + '_file' # load then process LoadEventAndCompress(Filename=self.data_file, OutputWorkspace=self.wksp_mem, MaxChunkSize=16, FilterBadPulses=0) LoadDiffCal(Filename=self.cal_file, InputWorkspace=self.wksp_mem, WorkspaceName='PG3') PDDetermineCharacterizations(InputWorkspace=self.wksp_mem, Characterizations='characterizations', ReductionProperties='__snspowderreduction_inner') # set-up the absorption calculation num_wl_bins = 200 prop_manager = PropertyManagerDataService.retrieve('__snspowderreduction_inner') wl_min, wl_max = prop_manager['wavelength_min'].value, prop_manager['wavelength_max'].value # 0.05, 2.20 absorptionWS = WorkspaceFactory.create(mtd[self.wksp_mem], NVectors=mtd[self.wksp_mem].getNumberHistograms(), XLength=num_wl_bins+1, YLength=num_wl_bins) xaxis = np.arange(0., float(num_wl_bins + 1)) * (wl_max - wl_min) / (num_wl_bins) + wl_min for i in range(absorptionWS.getNumberHistograms()): absorptionWS.setX(i, xaxis) absorptionWS.getAxis(0).setUnit('Wavelength') mantid.api.AnalysisDataService.addOrReplace('V_abs', absorptionWS) SetSample(InputWorkspace='V_abs', Material={'ChemicalFormula': 'V', 'SampleNumberDensity': 0.0721}, Geometry={'Shape': 'Cylinder', 'Height': 6.97, 'Radius': (0.63 / 2), 'Center': [0., 0., 0.]}) self.assertEqual(absorptionWS.getNumberBins(), num_wl_bins) # calculate the absorption CylinderAbsorption(InputWorkspace='V_abs', OutputWorkspace='V_abs', NumberOfSlices=20, NumberOfAnnuli=3) # do the work in memory ConvertUnits(InputWorkspace=self.wksp_mem, OutputWorkspace=self.wksp_mem, Target='Wavelength') Divide(LHSWorkspace=self.wksp_mem, RHSWorkspace='V_abs', OutputWorkspace=self.wksp_mem) ConvertUnits(InputWorkspace=self.wksp_mem, OutputWorkspace=self.wksp_mem, Target='TOF') AlignAndFocusPowder(InputWorkspace=self.wksp_mem, OutputWorkspace=self.wksp_mem, GroupingWorkspace='PG3_group', CalibrationWorkspace='PG3_cal', MaskWorkspace='PG3_mask', Params=-.0002, CompressTolerance=0.01, PrimaryFlightPath=60, SpectrumIDs='1', L2='3.18', Polar='90', Azimuthal='0', ReductionProperties='__snspowderreduction_inner') NormaliseByCurrent(InputWorkspace=self.wksp_mem, OutputWorkspace=self.wksp_mem) ConvertUnits(InputWorkspace=self.wksp_mem, OutputWorkspace=self.wksp_mem, Target='dSpacing') # everything inside the algorithm AlignAndFocusPowderFromFiles(Filename=self.data_file, OutputWorkspace=self.wksp_file, GroupingWorkspace='PG3_group', CalibrationWorkspace='PG3_cal', MaskWorkspace='PG3_mask', AbsorptionWorkspace='V_abs', Params=-.0002, CompressTolerance=0.01, PrimaryFlightPath=60, SpectrumIDs='1', L2='3.18', Polar='90', Azimuthal='0', ReductionProperties='__snspowderreduction_inner') NormaliseByCurrent(InputWorkspace=self.wksp_file, OutputWorkspace=self.wksp_file) ConvertUnits(InputWorkspace=self.wksp_file, OutputWorkspace=self.wksp_file, Target='dSpacing')
def create_test_workspace(model, num_bins): workspace = WorkspaceFactory.create("Workspace2D", NVectors=1, XLength=num_bins, YLength=num_bins) for i in range(1, num_bins): noise = random.uniform(0.8, 1.2) x_value = i * 1.2 workspace.dataX(0)[i] = x_value workspace.dataY(0)[i] = noise * model(x_value) workspace.dataE(0)[i] = 1 return workspace
def test_setting_spectra_from_array_of_incorrect_shape_raises_error(self): nvectors = 2 xlength = 11 ylength = 10 test_ws = WorkspaceFactory.create("Workspace2D", nvectors, xlength, ylength) values = np.linspace(0,1,num=xlength-1) values = values.reshape(5,2) self.assertRaises(ValueError, test_ws.setX, 0, values) self.assertRaises(ValueError, test_ws.setY, 0, values) self.assertRaises(ValueError, test_ws.setE, 0, values)
def PyExec(self): input_ws = self.getProperty("InputWorkspace").value output_ws_name = self.getProperty('OutputWorkspace').valueAsStr from_quantity = self.getProperty("From").value to_quantity = self.getProperty("To").value if input_ws.name() == output_ws_name: output_ws = input_ws else: output_ws = WorkspaceFactory.create(input_ws) self.setProperty('OutputWorkspace', output_ws) if from_quantity == to_quantity: logger.warning( 'The input and output functions are the same. Nothing to be done' ) return c = Converter() transformation = { Gr: { GKr: c.G_to_GK, gr: c.G_to_g }, GKr: { Gr: c.GK_to_G, gr: c.GK_to_g }, gr: { Gr: c.g_to_G, GKr: c.g_to_GK } } sample_kwargs = { "<b_coh>^2": input_ws.sample().getMaterial().cohScatterLengthSqrd(), "<b_tot^2>": input_ws.sample().getMaterial().totalScatterLengthSqrd(), "rho": input_ws.sample().getMaterial().numberDensity } for sp_num in range(input_ws.getNumberHistograms()): x = input_ws.readX(sp_num) output_ws.setX(sp_num, x) y = input_ws.readY(sp_num) e = input_ws.readE(sp_num) if len(x) == len(y) + 1: x = 0.5 * (x[:-1] + x[1:]) new_y, new_e = transformation[from_quantity][to_quantity]( x, y, e, **sample_kwargs) output_ws.setY(sp_num, new_y) output_ws.setE(sp_num, new_e)
def __create_outputws(donor: Union[str, Workspace2D], numSpec, numPeaks): '''The resulting workspace needs to be added to the ADS''' # convert the d-space table to a Workspace2d if donor: donor = mtd[str(donor)] else: donor = 'Workspace2D' output = WorkspaceFactory.create(donor, NVectors=numSpec, XLength=numPeaks, YLength=numPeaks) output.getAxis(0).setUnit('dSpacing') return output
def test_setxy_data_coerced_correctly_to_float64(self): nbins = 10 nspec = 2 xdata = np.arange(nbins+1) ydata = np.arange(nbins) ws = WorkspaceFactory.create("Workspace2D", NVectors=nspec, XLength=nbins+1, YLength=nbins) for i in range(nspec): ws.setX(i, xdata) ws.setY(i, ydata) # Verify x_expected, y_expected = np.vstack((xdata, xdata)), np.vstack((ydata, ydata)) x_extracted, y_extracted = ws.extractX(), ws.extractY() self.assertTrue(np.array_equal(x_expected, x_extracted)) self.assertTrue(np.array_equal(y_expected, y_extracted))
def test_setxy_accepts_python_list(self): nbins = 10 nspec = 2 xdata = list(range(nbins+1)) ydata = list(range(nbins)) ws = WorkspaceFactory.create("Workspace2D", NVectors=nspec, XLength=nbins+1, YLength=nbins) for i in range(nspec): ws.setX(i, xdata) ws.setY(i, ydata) # Verify xdata, ydata = np.array(xdata), np.array(ydata) x_expected, y_expected = np.vstack((xdata, xdata)), np.vstack((ydata, ydata)) x_extracted, y_extracted = ws.extractX(), ws.extractY() self.assertTrue(np.array_equal(x_expected, x_extracted)) self.assertTrue(np.array_equal(y_expected, y_extracted))
def test_rebinnedOutput(self): rebin = WorkspaceFactory.create("RebinnedOutput", 2, 3, 2) self.assertFalse(rebin.nonZeroF()) fv = rebin.readF(1) rebin.dataY(1)[:] = 10.0 rebin.dataE(1)[:] = 1.0 twos = np.ones(len(fv)) * 2.0 rebin.setF(1, twos) self.assertTrue(rebin.nonZeroF()) rebin.setFinalized(False) rebin.setSqrdErrors(False) rebin.unfinalize() self.assertFalse(rebin.isFinalized()) yv = rebin.readY(1) ev = rebin.readE(1) self.assertAlmostEqual(yv[0], 10.0) self.assertAlmostEqual(ev[0], 1.0) rebin.finalize(True) self.assertTrue(rebin.isFinalized()) self.assertTrue(rebin.hasSqrdErrors()) yv = rebin.readY(1) ev = rebin.readE(1) self.assertAlmostEqual(yv[0], 5.0) self.assertAlmostEqual(ev[0], 0.25) rebin.finalize(False) self.assertTrue(rebin.isFinalized()) self.assertFalse(rebin.hasSqrdErrors()) yv = rebin.readY(1) ev = rebin.readE(1) self.assertAlmostEqual(yv[0], 5.0) self.assertAlmostEqual(ev[0], 0.5) rebin.unfinalize() self.assertFalse(rebin.isFinalized()) yv = rebin.readY(1) ev = rebin.readE(1) self.assertAlmostEqual(yv[0], 10.0) self.assertAlmostEqual(ev[0], 1.0) rebin.scaleF(2.0) fv = rebin.readF(1) self.assertAlmostEqual(fv[0], 4.0)
def extract_peak_info(wksp: Union[str, Workspace2D], outputname: str, peak_position: float): """ Extract information about a single peak from a Workspace2D. The input workspace is expected to have common x-axis of observed d-spacing. The y-values and errors are extracted. The output workspace will be a single spectra with the x-axis being the detector-id. The y-values and errors are extracted from the input workspace. """ # confirm that the input is a workspace pointer wksp = mtd[str(wksp)] numSpec = wksp.getNumberHistograms() # get the index into the x/y arrays of the peak position peak_index = wksp.readX(0).searchsorted(peak_position) # create a workspace to put the result into single = WorkspaceFactory.create('Workspace2D', NVectors=1, XLength=wksp.getNumberHistograms(), YLength=wksp.getNumberHistograms()) single.setTitle('d-spacing={}\\A'.format(wksp.readX(0)[peak_index])) # get a handle to map the detector positions detids = wksp.detectorInfo().detectorIDs() have_detids = bool(len(detids) > 0) # fill in the data values x = single.dataX(0) y = single.dataY(0) e = single.dataE(0) start_detid = np.searchsorted(detids, 0) for wksp_index in range(numSpec): if have_detids: x[wksp_index] = detids[start_detid + wksp_index] else: x[wksp_index] = wksp_index y[wksp_index] = wksp.readY(wksp_index)[peak_index] e[wksp_index] = wksp.readE(wksp_index)[peak_index] # add the workspace to the AnalysisDataService mtd.addOrReplace(outputname, single) return mtd[outputname]
def _fill_s_2d_workspace(self, s_points=None, workspace=None, protons_number=None, nucleons_number=None): from mantid.api import NumericAxis from abins.constants import MILLI_EV_TO_WAVENUMBER if protons_number is not None: s_points = s_points * self.get_cross_section( scattering=self._scale_by_cross_section, protons_number=protons_number, nucleons_number=nucleons_number) n_q_values, n_freq_bins = s_points.shape n_q_bins = self._q_bins.size assert n_q_values + 1 == n_q_bins if self._energy_units == 'meV': energy_bins = self._bins / MILLI_EV_TO_WAVENUMBER else: energy_bins = self._bins wrk = WorkspaceFactory.create("Workspace2D", NVectors=n_freq_bins, XLength=n_q_bins, YLength=n_q_values) freq_axis = NumericAxis.create(n_freq_bins) freq_offset = (energy_bins[1] - energy_bins[0]) / 2 for i, freq in enumerate(energy_bins[1:]): wrk.setX(i, self._q_bins) wrk.setY(i, s_points[:, i].T) freq_axis.setValue(i, freq + freq_offset) wrk.replaceAxis(1, freq_axis) AnalysisDataService.addOrReplace(workspace, wrk) self.set_workspace_units(workspace, layout="2D", energy_units=self._energy_units)
def create_test_fits(input_workspaces, function_name, parameters, output_workspace_names=None, global_parameters=None): """ Create a list of fits :param input_workspaces: The input workspaces :param function_name: The name of the function :param parameters: The parameters list :param output_workspace_names: A list of workspace names :param global_parameters: An optional list of tied parameters :return: A list of Fits """ workspace = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) output_workspace_names = output_workspace_names if output_workspace_names is not None else [ StaticWorkspaceWrapper('test-output-ws', workspace) ] # Convert parameters to fit table-like structure fit_table = [{ 'Name': name, 'Value': value, 'Error': error } for name, (value, error) in parameters.items()] fits = [] for name in input_workspaces: parameter_workspace = mock.NonCallableMagicMock() parameter_workspace.workspace.__iter__.return_value = fit_table parameter_workspace.workspace_name = name + '_Parameters' fits.append( FitInformation([name], function_name, output_workspace_names, parameter_workspace, mock.Mock(), global_parameters)) return fits
def test_setting_spectra_from_array_sets_expected_values(self): nvectors = 2 xlength = 11 ylength = 10 test_ws = WorkspaceFactory.create("Workspace2D", nvectors, xlength, ylength) ws_index = 1 values = np.linspace(0, 1, xlength) test_ws.setX(ws_index, values) ws_values = test_ws.readX(ws_index) self.assertTrue(np.array_equal(values, ws_values)) values = np.ones(ylength) test_ws.setY(ws_index, values) ws_values = test_ws.readY(ws_index) self.assertTrue(np.array_equal(values, ws_values)) values = np.sqrt(values) test_ws.setE(ws_index, values) ws_values = test_ws.readE(ws_index) self.assertTrue(np.array_equal(values, ws_values))
def test_create_results_table_with_logs_missing_from_some_workspaces_raises(self): workspace = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) parameters = OrderedDict([('f0.Height', (100, 0.1))]) logs = [('log1', (1., 2.)), ('log2', (3., 4.)), ('log3', (4., 5.)), ('log4', (5., 6.))] fits_logs1 = create_test_fits(('ws1',), 'func1', parameters, output_workspace_names=[StaticWorkspaceWrapper('test-ws1-ws', workspace)]) add_logs(fits_logs1[0].input_workspaces[0], logs[:2]) fits_logs2 = create_test_fits(('ws2',), 'func1', parameters, output_workspace_names=[StaticWorkspaceWrapper('test-ws2-ws', workspace)]) add_logs(fits_logs2[0].input_workspaces[0], logs[2:]) fitting_context = TFAsymmetryFittingContext() fitting_context.fit_list = fits_logs1 + fits_logs2 model = ResultsTabModel(fitting_context, ResultsContext()) selected_results = [('ws1', 0), ('ws2', 1)] selected_logs = ['log1', 'log3'] self.assertRaises(IndexError, model.create_results_table, selected_logs, selected_results)
def PyExec(self): input_ws = self.getProperty("InputWorkspace").value output_ws_name = self.getProperty('OutputWorkspace').valueAsStr from_quantity = self.getProperty("From").value to_quantity = self.getProperty("To").value if input_ws.name() == output_ws_name: output_ws = input_ws else: output_ws = WorkspaceFactory.create(input_ws) self.setProperty('OutputWorkspace', output_ws) if from_quantity == to_quantity: logger.warning('The input and output functions are the same. Nothing to be done') return c = Converter() transformation = {SQ: {FQ: c.S_to_F, FKQ: c.S_to_FK, DCS: c.S_to_DCS}, FQ: {SQ: c.F_to_S, FKQ: c.F_to_FK, DCS: c.F_to_DCS}, FKQ: {SQ: c.FK_to_S, FQ: c.FK_to_F, DCS: c.FK_to_DCS}, DCS: {SQ: c.DCS_to_S, FQ: c.DCS_to_F, FKQ: c.DCS_to_FK}} if input_ws.sample().getMaterial(): sample_kwargs = {"<b_coh>^2": input_ws.sample().getMaterial().cohScatterLengthSqrd(), "<b_tot^2>": input_ws.sample().getMaterial().totalScatterLengthSqrd(), "rho": input_ws.sample().getMaterial().numberDensity} else: sample_kwargs = dict() for sp_num in range(input_ws.getNumberHistograms()): x = input_ws.readX(sp_num) output_ws.setX(sp_num, x) y = input_ws.readY(sp_num) e = input_ws.readE(sp_num) if len(x) == len(y) + 1: x = 0.5 * (x[:-1] + x[1:]) new_y, new_e = transformation[from_quantity][to_quantity](x, y, e, **sample_kwargs) output_ws.setY(sp_num, new_y) output_ws.setE(sp_num, new_e)
def _fill_s_1d_workspace(self, s_points=None, workspace=None, protons_number=None, nucleons_number=None): """ Puts 1D S into workspace. :param protons_number: number of protons in the given type fo atom :param nucleons_number: number of nucleons in the given type of atom :param s_points: dynamical factor for the given atom :param workspace: workspace to be filled with S """ if protons_number is not None: s_points = s_points * self._scale * self._get_cross_section(protons_number=protons_number, nucleons_number=nucleons_number) dim = 1 length = s_points.size wrk = WorkspaceFactory.create("Workspace2D", NVectors=dim, XLength=length + 1, YLength=length) for i in range(dim): wrk.getSpectrum(i).setDetectorID(i + 1) wrk.setX(0, self._bins) wrk.setY(0, s_points) AnalysisDataService.addOrReplace(workspace, wrk) # Set correct units on workspace self._set_workspace_units(wrk=workspace)
def PyExec(self): input_ws = self.getProperty("InputWorkspace").value output_ws_name = self.getProperty('OutputWorkspace').valueAsStr from_quantity = self.getProperty("From").value to_quantity = self.getProperty("To").value if(input_ws.name()==output_ws_name): output_ws=input_ws else: output_ws=WorkspaceFactory.create(input_ws) self.setProperty('OutputWorkspace', output_ws) if(from_quantity==to_quantity): logger.warning('The input and output functions are the same. Nothing to be done') return c=Converter() transformation={'G(r)':{'GK(r)':c.G_to_GK, 'g(r)':c.G_to_g}, 'GK(r)':{'G(r)':c.GK_to_G, 'g(r)':c.GK_to_g}, 'g(r)':{'G(r)':c.g_to_G, 'GK(r)':c.g_to_GK}} sample_kwargs={"<b_coh>^2":input_ws.sample().getMaterial().cohScatterLengthSqrd(), "<b_tot^2>":input_ws.sample().getMaterial().totalScatterLengthSqrd(), "rho":input_ws.sample().getMaterial().numberDensity} if ((sample_kwargs["<b_coh>^2"]<=0) or (sample_kwargs["<b_tot^2>"]<=0) or (sample_kwargs["rho"]<=0)): raise RuntimeError('Please run SetSampleMaterial algorithm before running'+ ' this algorithm') for sp_num in range(input_ws.getNumberHistograms()): x = input_ws.readX(sp_num) output_ws.setX(sp_num,x) y = input_ws.readY(sp_num) e = input_ws.readE(sp_num) if len(x)==len(y)+1: x = 0.5*(x[:-1]+x[1:]) new_y, new_e=transformation[from_quantity][to_quantity](x,y,e,**sample_kwargs) output_ws.setY(sp_num,new_y) output_ws.setE(sp_num,new_e)
def _loadFullprofDataFile(self, datafilename): """ Parse a Fullprof (multiple) column file """ # Import file datafile = open(datafilename, "r") rawlines = datafile.readlines() datafile.close() # Parse head iline = 0 parseheader = True #title = "" while iline < len(rawlines) and parseheader is True: line = rawlines[iline].strip() if len(line) > 0: if line.count("BANK") != 0: # line information terms = line.split() if terms[0] != 'BANK': raise NotImplementedError("First word must be 'BANK', but not %s" % (terms[0])) #bankid = int(terms[1]) numdata = int(terms[2]) numlines = int(terms[3]) parseheader = False # ENDIF # ENDIF iline += 1 # ENDWHILE (iline) # Data vectors vecx = [] vecy = [] vece = [] for i in xrange(iline, len(rawlines)): line = rawlines[i].strip() if len(line) == 0: continue terms = line.split() numitems = len(terms) if numitems % 3 != 0: print "%d-th line '%s' is not a data line" % (i, line) continue numpts = numitems/3 for j in xrange(numpts): x = float(terms[j*3]) y = float(terms[j*3+1]) e = float(terms[j*3+2]) vecx.append(x) vecy.append(y) vece.append(e) # ENDFOR # ENDFOR (i) # Check self.log().notice("Expected to read %d data points; Exactly read %d data points. " % (numdata*numlines, len(vecx))) # Create output workspaces tablews = WorkspaceFactory.createTable() # Create the data workspace datasize = len(vecx) dataws = WorkspaceFactory.create("Workspace2D", 1, datasize, datasize) for i in xrange(datasize): dataws.dataX(0)[i] = vecx[i] dataws.dataY(0)[i] = vecy[i] dataws.dataE(0)[i] = vece[i] return (tablews, dataws)
def _create_clean_workspace(self, nhist, xlength, ylength): return WorkspaceFactory.create("Workspace2D", NVectors=nhist, XLength=xlength, YLength=ylength)
def PyExec(self): fn = self.getPropertyValue("Filename") wsn = self.getPropertyValue("OutputWorkspace") monitor_workspace_name = self.getPropertyValue("OutputMonitorWorkspace") if monitor_workspace_name == "": self.setPropertyValue("OutputMonitorWorkspace", wsn+'_Monitors') #print (fn, wsn) self.override_angle = self.getPropertyValue("AngleOverride") self.fxml = self.getPropertyValue("InstrumentXML") #load data parms_dict, det_udet, det_count, det_tbc, data = self.read_file(fn) nrows=int(parms_dict['NDET']) #nbins=int(parms_dict['NTC']) xdata = np.array(det_tbc) xdata_mon = np.linspace(xdata[0],xdata[-1], len(xdata)) ydata=data.astype(np.float) ydata=ydata.reshape(nrows,-1) edata=np.sqrt(ydata) #CreateWorkspace(OutputWorkspace=wsn,DataX=xdata,DataY=ydata,DataE=edata, # NSpec=nrows,UnitX='TOF',WorkspaceTitle='Data',YUnitLabel='Counts') nr,nc=ydata.shape ws = WorkspaceFactory.create("Workspace2D", NVectors=nr, XLength=nc+1, YLength=nc) for i in range(nrows): ws.setX(i, xdata) ws.setY(i, ydata[i]) ws.setE(i, edata[i]) ws.getAxis(0).setUnit('tof') AnalysisDataService.addOrReplace(wsn,ws) #self.setProperty("OutputWorkspace", wsn) #print ("ws:", wsn) #ws=mtd[wsn] # fix the x values for the monitor for i in range(nrows-2,nrows): ws.setX(i,xdata_mon) self.log().information("set detector IDs") #set detetector IDs for i in range(nrows): ws.getSpectrum(i).setDetectorID(det_udet[i]) #Sample_logs the header values are written into the sample logs log_names=[str(sl.encode('ascii','ignore').decode()) for sl in parms_dict.keys()] log_values=[str(sl.encode('ascii','ignore').decode()) if isinstance(sl,UnicodeType) else str(sl) for sl in parms_dict.values()] for i in range(len(log_values)): if ('nan' in log_values[i]) or ('NaN' in log_values[i]): log_values[i] = '-1.0' AddSampleLogMultiple(Workspace=wsn, LogNames=log_names,LogValues=log_values) SetGoniometer(Workspace=wsn, Goniometers='Universal') if (self.fxml == ""): LoadInstrument(Workspace=wsn, InstrumentName = "Exed", RewriteSpectraMap= True) else: LoadInstrument(Workspace=wsn, Filename = self.fxml, RewriteSpectraMap= True) try: RotateInstrumentComponent(Workspace=wsn, ComponentName='Tank', Y=1, Angle=-float(parms_dict['phi'].encode('ascii','ignore')), RelativeRotation=False) except: self.log().warning("The instrument does not contain a 'Tank' component. " "This means that you are using a custom XML instrument definition. " "OMEGA_MAG will be ignored.") self.log().warning("Please make sure that the detector positions in the instrument definition are correct.") # Separate monitors into seperate workspace __temp_monitors = ExtractSpectra(InputWorkspace = wsn, WorkspaceIndexList = ','.join([str(s) for s in range(nrows-2, nrows)]), OutputWorkspace = self.getPropertyValue("OutputMonitorWorkspace")) # ExtractSpectra(InputWorkspace = wsn, WorkspaceIndexList = ','.join([str(s) for s in range(nrows-2, nrows)]), # OutputWorkspace = wsn + '_Monitors') MaskDetectors(Workspace = wsn, WorkspaceIndexList = ','.join([str(s) for s in range(nrows-2, nrows)])) RemoveMaskedSpectra(InputWorkspace = wsn, OutputWorkspace = wsn) self.setProperty("OutputWorkspace", wsn) self.setProperty("OutputMonitorWorkspace", __temp_monitors)
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!")
def _makeEmptyDataWorkspace(self): """ Make an empty data workspace (Workspace2D) """ dataws = WorkspaceFactory.create("Workspace2D", 1, 1, 1) return dataws