def test_that_can_load_isis_nexus_file_with_event_data_and_multi_period(self): # Arrange state = SANSLoadTest._get_simple_state(sample_scatter="LARMOR00013065.nxs", calibration="80tubeCalibration_18-04-2016_r9330-9335.nxs") # Act output_workspace_names = {"SampleScatterWorkspace": "sample_scatter", "SampleScatterMonitorWorkspace": "sample_monitor_scatter"} load_alg = self._run_load(state, publish_to_cache=True, use_cached=True, move_workspace=False, output_workspace_names=output_workspace_names) # Assert expected_number_of_workspaces = [4, 0, 0, 0, 0, 0] expected_number_on_ads = 1 workspace_type = [EventWorkspace, None, None, None, None, None] self._do_test_output(load_alg, expected_number_of_workspaces, expected_number_on_ads, workspace_type) # Check that calibration is added self.assertTrue(SANSLoadTest._has_calibration_been_applied(load_alg)) # Confirm that the ADS workspace contains the calibration file try: AnalysisDataService.retrieve("80tubeCalibration_18-04-2016_r9330-9335") on_ads = True except RuntimeError: on_ads = False self.assertTrue(on_ads) # Cleanup remove_all_workspaces_from_ads()
def testConvertUnits(self): # test whether CorrectTof+ConvertUnits+ConvertToDistribution will give the same result as TOFTOFConvertTOFToDeltaE OutputWorkspaceName = "outputws1" alg_test = run_algorithm("CorrectTOF", InputWorkspace=self._input_ws, EPPTable=self._table, OutputWorkspace=OutputWorkspaceName) self.assertTrue(alg_test.isExecuted()) wscorr = AnalysisDataService.retrieve(OutputWorkspaceName) # convert units, convert to distribution alg_cu = run_algorithm("ConvertUnits", InputWorkspace=wscorr, Target='DeltaE', EMode='Direct', EFixed=2.27, OutputWorkspace=OutputWorkspaceName+'_dE') ws_dE = AnalysisDataService.retrieve(OutputWorkspaceName+'_dE') alg_cd = run_algorithm("ConvertToDistribution", Workspace=ws_dE) # create reference data for X axis tof1 = 2123.33867005 dataX = self._input_ws.readX(0) - tof1 tel = 8189.5 - tof1 factor = m_n*1e+15/eV newX = 0.5*factor*16.0*(1/tel**2 - 1/dataX**2) # compare # self.assertEqual(newX[0], ws_dE.readX(0)[0]) self.assertTrue(np.allclose(newX, ws_dE.readX(0), atol=0.01)) # create reference data for Y axis and compare to the output tof = dataX[:-1] + 5.25 newY = self._input_ws.readY(0)*tof**3/(factor*10.5*16.0) # compare self.assertTrue(np.allclose(newY, ws_dE.readY(0), rtol=0.01)) run_algorithm("DeleteWorkspace", Workspace=ws_dE) run_algorithm("DeleteWorkspace", Workspace=wscorr)
def test_DNSFRSelfCorrection(self): outputWorkspaceName = "DNSFlippingRatioCorrTest_Test4" # consider normalization=1.0 as set in self._create_fake_workspace dataws_sf = self.__sf_nicrws - self.__sf_bkgrws dataws_nsf = self.__nsf_nicrws - self.__nsf_bkgrws alg_test = run_algorithm("DNSFlippingRatioCorr", SFDataWorkspace=dataws_sf, NSFDataWorkspace=dataws_nsf, SFNiCrWorkspace=self.__sf_nicrws.getName(), NSFNiCrWorkspace=self.__nsf_nicrws.getName(), SFBkgrWorkspace=self.__sf_bkgrws.getName(), NSFBkgrWorkspace=self.__nsf_bkgrws.getName(), SFOutputWorkspace=outputWorkspaceName+'SF', NSFOutputWorkspace=outputWorkspaceName+'NSF') self.assertTrue(alg_test.isExecuted()) # check whether the data are correct ws_sf = AnalysisDataService.retrieve(outputWorkspaceName + 'SF') ws_nsf = AnalysisDataService.retrieve(outputWorkspaceName + 'NSF') # dimensions self.assertEqual(24, ws_sf.getNumberHistograms()) self.assertEqual(24, ws_nsf.getNumberHistograms()) self.assertEqual(2, ws_sf.getNumDims()) self.assertEqual(2, ws_nsf.getNumDims()) # data array: spin-flip must be zero for i in range(24): self.assertAlmostEqual(0.0, ws_sf.readY(i)[0]) # data array: non spin-flip must be nsf - sf^2/nsf nsf = np.array(dataws_nsf.extractY()) sf = np.array(dataws_sf.extractY()) refdata = nsf + sf for i in range(24): self.assertAlmostEqual(refdata[i][0], ws_nsf.readY(i)[0]) run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName + 'SF') run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName + 'NSF') run_algorithm("DeleteWorkspace", Workspace=dataws_sf) run_algorithm("DeleteWorkspace", Workspace=dataws_nsf) return
def edit_matrix_workspace(sq_name, scale_factor, shift, edited_sq_name=None): """ Edit the matrix workspace of S(Q) by scaling and shift :param sq_name: name of the SofQ workspace :param scale_factor: :param shift: :param edited_sq_name: workspace for the edited S(Q) :return: """ # get the workspace if AnalysisDataService.doesExist(sq_name) is False: raise RuntimeError('S(Q) workspace {0} cannot be found in ADS.'.format(sq_name)) if edited_sq_name is not None: simpleapi.CloneWorkspace(InputWorkspace=sq_name, OutputWorkspace=edited_sq_name) sq_ws = AnalysisDataService.retrieve(edited_sq_name) else: sq_ws = AnalysisDataService.retrieve(sq_name) # get the vector of Y sq_ws = sq_ws * scale_factor sq_ws = sq_ws + shift if sq_ws.name() != edited_sq_name: simpleapi.DeleteWorkspace(Workspace=edited_sq_name) simpleapi.RenameWorkspace(InputWorkspace=sq_ws, OutputWorkspace=edited_sq_name) assert sq_ws is not None, 'S(Q) workspace cannot be None.' print('[DB...BAT] S(Q) workspace that is edit is {0}'.format(sq_ws))
def test_that_can_find_can_reduction_if_it_exists(self): # Arrange test_director = TestDirector() state = test_director.construct() tagged_workspace_names = {None: "test_ws", OutputParts.Count: "test_ws_count", OutputParts.Norm: "test_ws_norm"} SANSFunctionsTest._prepare_workspaces(number_of_workspaces=4, tagged_workspace_names=tagged_workspace_names, state=state, reduction_mode=ISISReductionMode.LAB) # Act workspace, workspace_count, workspace_norm = get_reduced_can_workspace_from_ads(state, output_parts=True, reduction_mode=ISISReductionMode.LAB) # noqa # Assert self.assertTrue(workspace is not None) self.assertTrue(workspace.name() == AnalysisDataService.retrieve("test_ws").name()) self.assertTrue(workspace_count is not None) self.assertTrue(workspace_count.name() == AnalysisDataService.retrieve("test_ws_count").name()) self.assertTrue(workspace_norm is not None) self.assertTrue(workspace_norm.name() == AnalysisDataService.retrieve("test_ws_norm").name()) # Clean up SANSFunctionsTest._remove_workspaces()
def _check_if_all_multi_period_workspaces_have_the_same_position(self, base_name, number_of_workspaces): reference_name = base_name + str(1) reference_workspace = AnalysisDataService.retrieve(reference_name) reference_position, reference_rotation = self._get_position_and_rotation(reference_workspace) for index in range(2, number_of_workspaces + 1): ws_name = base_name + str(index) workspace = AnalysisDataService.retrieve(ws_name) position, rotation = self._get_position_and_rotation(workspace) self.assertEqual(position, reference_position) self.assertEqual(rotation, reference_rotation)
def calculate_peak_center(self): """ Calculate peak's center by averaging the peaks found and stored in PeakWorkspace :return: """ # Go through the peak workspaces to calculate peak center with weight (monitor and counts) peak_ws = AnalysisDataService.retrieve(self._myPeakWorkspaceName) # spice table workspace spice_table_name = get_spice_table_name(self._myExpNumber, self._myScanNumber) spice_table_ws = AnalysisDataService.retrieve(spice_table_name) pt_spice_row_dict = build_pt_spice_table_row_map(spice_table_ws) det_col_index = spice_table_ws.getColumnNames().index('detector') monitor_col_index = spice_table_ws.getColumnNames().index('monitor') num_found_peaks = peak_ws.rowCount() q_sample_sum = numpy.array([0., 0., 0.]) weight_sum = 0. for i_peak in xrange(num_found_peaks): # get peak peak_i = peak_ws.getPeak(i_peak) run_number = peak_i.getRunNumber() # get Pt. number pt_number = run_number % self._myScanNumber # get row number and then detector counts and monitor counts if pt_number not in pt_spice_row_dict: # skip print '[Error] Scan %d Peak %d Pt %d cannot be located.' % (self._myScanNumber, i_peak, pt_number) continue row_index = pt_spice_row_dict[pt_number] det_counts = spice_table_ws.cell(row_index, det_col_index) monitor_counts = spice_table_ws.cell(row_index, monitor_col_index) if monitor_counts < 1.: # skip zero-count continue # convert q sample from V3D to ndarray q_i = peak_i.getQSampleFrame() q_array = numpy.array([q_i.X(), q_i.Y(), q_i.Z()]) # calculate weight weight_i = float(det_counts)/float(monitor_counts) # contribute to total weight_sum += weight_i q_sample_sum += q_array * weight_i # set non-normalized peak intensity as detector counts (roughly) peak_i.setIntensity(det_counts) # END-FOR (i_peak) self._avgPeakCenter = q_sample_sum/weight_sum return
def test_genHKLList(self): """ Test to load a .hkl file """ # Set up alg_test = run_algorithm("CreateLeBailFitInput", ReflectionsFile = "", MaxHKL = "12,12,12", FullprofParameterFile = "2011B_HR60b2.irf", Bank = 2, LatticeConstant = 4.66, GenerateBraggReflections = True, InstrumentParameterWorkspace = "PG3_Bank2_Foo2", BraggPeakParameterWorkspace = "Arb_Peaks" ) # Execute self.assertTrue(alg_test.isExecuted()) # Verify some values # Profile parameter workspace paramws = AnalysisDataService.retrieve("PG3_Bank2_Foo2") paramname0 = paramws.cell(0, 0) if paramname0.lower() == "bank": numrowgood = 28 else: numrowgood = 27 #print "Parameter name of first line = ", paramname0 #self.assertEqual(numrowgood, paramws.rowCount()) paramnames = [] for i in range(paramws.rowCount()): paramname = paramws.cell(i, 0) paramnames.append(paramname) self.assertEqual(paramnames.count("LatticeConstant"), 1) # Bragg peak list braggws = AnalysisDataService.retrieve("Arb_Peaks") self.assertEqual(braggws.rowCount() > 20, True) # 4. Delete the test hkl file AnalysisDataService.remove("PG3_Bank2_Foo2") AnalysisDataService.remove("Arb_Peaks") return
def test_LoadPartiallyValidFilesMultipleLogValues(self): outputWorskapceName = "LoadLogPropertyTableTest_Test2" alg_test = run_algorithm( "LoadLogPropertyTable", FirstFile="emu00006473.nxs", LastFile="emu00006475.nxs", LogNames="Temp_Sample,dur", OutputWorkspace=outputWorskapceName, ) self.assertTrue(alg_test.isExecuted()) # Verify some values tablews = AnalysisDataService.retrieve(outputWorskapceName) self.assertEqual(2, tablews.rowCount()) self.assertEqual(3, tablews.columnCount()) self.assertEqual(6473, tablews.cell(0, 0)) self.assertAlmostEqual(200.078, tablews.cell(0, 1), 2) self.assertEqual("8697", tablews.cell(0, 2)) self.assertEqual(6475, tablews.cell(1, 0)) self.assertAlmostEqual(283.523, tablews.cell(1, 1), 2) self.assertEqual("5647", tablews.cell(1, 2)) run_algorithm("DeleteWorkspace", Workspace=outputWorskapceName) return
def test_LoadValidFilesComments(self): outputWorskapceName = "LoadLogPropertyTableTest_Test1" alg_test = run_algorithm( "LoadLogPropertyTable", FirstFile="MUSR00015189.nxs", LastFile="MUSR00015193.nxs", LogNames="comment", OutputWorkspace=outputWorskapceName, ) self.assertTrue(alg_test.isExecuted()) # Verify some values tablews = AnalysisDataService.retrieve(outputWorskapceName) self.assertEqual(5, tablews.rowCount()) self.assertEqual(2, tablews.columnCount()) self.assertEqual("18.95MHz 100W", tablews.cell(0, 1)) self.assertEqual(15189, tablews.cell(0, 0)) self.assertEqual(15193, tablews.cell(4, 0)) run_algorithm("DeleteWorkspace", Workspace=outputWorskapceName) return
def test_temperature_log_is_time_series(self): outputWorkspaceName = "output_ws" EditInstrumentGeometry(self._input_ws, L2="4,8", Polar="0,15", Azimuthal="0,0", DetectorIDs="1,2") AddTimeSeriesLog( self._input_ws, 'temperature', '2010-09-14T04:20:12', Value='0.0') AddTimeSeriesLog( self._input_ws, 'temperature', '2010-09-14T04:20:13', Value='0.0') AddTimeSeriesLog( self._input_ws, 'temperature', '2010-09-14T04:20:14', Value='0.0') alg_test = run_algorithm("ComputeCalibrationCoefVan", VanadiumWorkspace=self._input_ws, EPPTable=self._table, OutputWorkspace=outputWorkspaceName) self.assertTrue(alg_test.isExecuted()) wsoutput = AnalysisDataService.retrieve(outputWorkspaceName) self._checkDWF(wsoutput, 0.0)
def convert_fit_parameter_table_to_dict(table_name): """ :param table_name: :return: """ # table workspace assert isinstance(table_name, str), 'blabla' table_ws = AnalysisDataService.retrieve(table_name) # create dictionary fit_param_dict = dict() params_list = table_ws.getColumnNames() # ['wsindex', 'peakindex', 'Height', 'PeakCentre', 'Sigma', 'A0', 'A1', 'chi2'] # go through all lines num_rows = table_ws.rowCount() for irow in range(num_rows): value_dict = dict() ws_index = None for iparam, par_name in enumerate(params_list): value_i = table_ws.cell(irow, iparam) if par_name == 'wsindex': ws_index = int(value_i) else: value_dict[par_name] = float(value_i) # END-FOR (column) assert ws_index is not None fit_param_dict[ws_index] = value_dict # END-FOR (row) return fit_param_dict
def test_LoadTOF(self): outputWorkspaceName = "LoadDNSLegacyTest_Test7" filename = "dnstof.d_dat" tof1 = 424.668 # must be changed if L1 will change alg_test = run_algorithm("LoadDNSLegacy", Filename=filename, Normalization='no', OutputWorkspace=outputWorkspaceName) self.assertTrue(alg_test.isExecuted()) # Verify some values ws = AnalysisDataService.retrieve(outputWorkspaceName) # dimensions self.assertEqual(24, ws.getNumberHistograms()) self.assertEqual(100, ws.getNumberBins()) # data array self.assertEqual(8, ws.readY(19)[37]) # must be changed after comissioning will be finished self.assertAlmostEqual(tof1, ws.readX(0)[0], 3) self.assertAlmostEqual(tof1+40.1*100, ws.readX(0)[100], 3) # sample logs run = ws.getRun() self.assertEqual(-7.5, run.getProperty('deterota').value) self.assertEqual(100, run.getProperty('tof_channels').value) self.assertEqual(51428, run.getProperty('mon_sum').value) self.assertEqual('z', run.getProperty('polarisation').value) self.assertEqual(33, run.getProperty('EPP').value) # check that EPP is taken from file self.assertEqual('7', str(run.getProperty('polarisation_comment').value)) self.assertEqual('no', run.getProperty('normalized').value) # check whether detector bank is rotated det = ws.getDetector(0) self.assertAlmostEqual(7.5, ws.detectorSignedTwoTheta(det)*180/pi) run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName) return
def test_DNSMomentumTransfer(self): outputWorkspaceName = "DNSMergeRunsTest_Test4" alg_test = run_algorithm("DNSMergeRuns", WorkspaceNames=self.workspaces, OutputWorkspace=outputWorkspaceName, HorizontalAxis='|Q|') self.assertTrue(alg_test.isExecuted()) # check whether the data are correct ws = AnalysisDataService.retrieve(outputWorkspaceName) # dimensions self.assertEqual(96, ws.blocksize()) self.assertEqual(2, ws.getNumDims()) self.assertEqual(1, ws.getNumberHistograms()) # data array # reference values ttheta = np.round(np.radians(self.angles), 4) qarr = np.sort(4.0*np.pi*np.sin(0.5*ttheta)/4.2) # read the merged values dataX = ws.extractX()[0] for i in range(len(self.angles)): self.assertAlmostEqual(qarr[i], dataX[i]) # check that the intensity has not been changed dataY = ws.extractY()[0] for i in range(len(dataY)): self.assertAlmostEqual(1.0, dataY[i]) run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName) return
def test_TwoTheta(self): # check whether the 2theta angles the same as in the data workspace outputWorkspaceName = "DNSDetCorrVanaTest_Test5" # rotate detector bank to different angles api.LoadInstrument(self.__dataws, InstrumentName='DNS') api.LoadInstrument(self.__vanaws, InstrumentName='DNS') api.LoadInstrument(self.__bkgrws, InstrumentName='DNS') api.RotateInstrumentComponent(self.__dataws, "bank0", X=0, Y=1, Z=0, Angle=-7.53) api.RotateInstrumentComponent(self.__vanaws, "bank0", X=0, Y=1, Z=0, Angle=-8.02) api.RotateInstrumentComponent(self.__bkgrws, "bank0", X=0, Y=1, Z=0, Angle=-8.54) # run correction alg_test = run_algorithm("DNSDetEffCorrVana", InputWorkspace=self.__dataws.getName(), OutputWorkspace=outputWorkspaceName, VanaWorkspace=self.__vanaws.getName(), BkgWorkspace=self.__bkgrws.getName()) self.assertTrue(alg_test.isExecuted()) # check dimensions and angles ws = AnalysisDataService.retrieve(outputWorkspaceName) # dimensions self.assertEqual(24, ws.getNumberHistograms()) self.assertEqual(2, ws.getNumDims()) # angles tthetas = np.array([7.53 + i*5 for i in range(24)]) for i in range(24): det = ws.getDetector(i) self.assertAlmostEqual(tthetas[i], np.degrees(ws.detectorSignedTwoTheta(det))) run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName) return
def test_LoadWavelength(self): outputWorkspaceName = "LoadDNSLegacyTest_Test8" filename = "dn134011vana.d_dat" alg_test = run_algorithm("LoadDNSLegacy", Filename=filename, Normalization='no', OutputWorkspace=outputWorkspaceName, CoilCurrentsTable=self.curtable, Wavelength=5.7) self.assertTrue(alg_test.isExecuted()) # Verify some values ws = AnalysisDataService.retrieve(outputWorkspaceName) # dimensions self.assertEqual(24, ws.getNumberHistograms()) self.assertEqual(2, ws.getNumDims()) # data array self.assertEqual(31461, ws.readY(1)) self.assertEqual(13340, ws.readY(23)) self.assertAlmostEqual(5.7, ws.readX(1)[0], 3) self.assertAlmostEqual(5.7, ws.readX(23)[0], 3) # sample logs run = ws.getRun() self.assertEqual(5.7, run.getProperty('wavelength').value) self.assertAlmostEqual(2.51782, run.getProperty('Ei').value, 3) run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName) return
def save_workspaces(self, workspaces_to_save=None): """ Use the private method _get_workspaces_to_save to get a list of workspaces that are present in the ADS to save to the directory that was passed at object creation time, it will also add each of them to the output_list private instance variable on the WorkspaceSaver class. :param workspaces_to_save: List of Strings; The workspaces that are to be saved to the project. """ # Handle getting here and nothing has been given passed if workspaces_to_save is None: return for workspace_name in workspaces_to_save: # Get the workspace from the ADS workspace = ADS.retrieve(workspace_name) place_to_save_workspace = os.path.join(self.directory, workspace_name) from mantid.simpleapi import SaveMD, SaveNexusProcessed try: if isinstance(workspace, MDHistoWorkspace) or isinstance(workspace, IMDEventWorkspace): # Save normally using SaveMD SaveMD(InputWorkspace=workspace_name, Filename=place_to_save_workspace + ".nxs") else: # Save normally using SaveNexusProcessed SaveNexusProcessed(InputWorkspace=workspace_name, Filename=place_to_save_workspace + ".nxs") except Exception: logger.warning("Couldn't save workspace in project: " + workspace) self.output_list.append(workspace_name)
def retrieve_hkl_from_spice_table(self): """ Get averaged HKL from SPICE table HKL will be averaged from SPICE table by assuming the value in SPICE might be right :return: """ # get SPICE table spice_table_name = get_spice_table_name(self._myExpNumber, self._myScanNumber) assert AnalysisDataService.doesExist(spice_table_name), 'Spice table for exp %d scan %d cannot be found.' \ '' % (self._myExpNumber, self._myScanNumber) spice_table_ws = AnalysisDataService.retrieve(spice_table_name) # get HKL column indexes h_col_index = spice_table_ws.getColumnNames().index('h') k_col_index = spice_table_ws.getColumnNames().index('k') l_col_index = spice_table_ws.getColumnNames().index('l') # scan each Pt. hkl = numpy.array([0., 0., 0.]) num_rows = spice_table_ws.rowCount() for row_index in xrange(num_rows): mi_h = spice_table_ws.cell(row_index, h_col_index) mi_k = spice_table_ws.cell(row_index, k_col_index) mi_l = spice_table_ws.cell(row_index, l_col_index) hkl += numpy.array([mi_h, mi_k, mi_l]) # END-FOR self._spiceHKL = hkl/num_rows return
def get_average_omega(exp_number, scan_number): """Get average omega (omega-theta) :param exp_number: :param scan_number: :return: """ # get table workspace spice_table_name = util4.get_spice_table_name(exp_number, scan_number) spice_table = AnalysisDataService.retrieve(spice_table_name) # column index col_omega_index = spice_table.getColumnNames().index('omega') col_2theta_index = spice_table.getColumnNames().index('2theta') # get the vectors vec_size = spice_table.rowCount() vec_omega = numpy.ndarray(shape=(vec_size, ), dtype='float') vec_2theta = numpy.ndarray(shape=(vec_size, ), dtype='float') for i_row in range(vec_size): vec_omega[i_row] = spice_table.cell(i_row, col_omega_index) vec_2theta[i_row] = spice_table.cell(i_row, col_2theta_index) # END-FOR vec_omega -= vec_2theta * 0.5 return numpy.sum(vec_omega)
def test_LoadPRFFile(self): """ Test to load a .prf file """ # 1. Create test .prf file prffilename = "test.prf" self._createPrfFile(prffilename) # 2. Execute the algorithm alg_test = run_algorithm("LoadFullprofFile", Filename = prffilename, OutputWorkspace = "Data", PeakParameterWorkspace = "Info") self.assertTrue(alg_test.isExecuted()) # 3. Check data dataws = AnalysisDataService.retrieve("Data") self.assertEqual(dataws.getNumberHistograms(), 4) self.assertEqual(len(dataws.readX(0)), 36) # value self.assertEqual(dataws.readX(0)[13], 5026.3223) self.assertEqual(dataws.readY(1)[30], 0.3819) # 4. Clean os.remove(prffilename) AnalysisDataService.remove("Data") AnalysisDataService.remove("Info") return
def test_saveGSS(self): """ Test to Save a GSAS file to match V-drive """ # Create a test data file and workspace binfilename = "testbin.dat" self._createBinFile(binfilename) datawsname = "TestInputWorkspace" self._createDataWorkspace(datawsname) # Execute alg_test = run_algorithm("SaveVulcanGSS", InputWorkspace = datawsname, BinFilename = binfilename, OutputWorkspace = datawsname+"_rebinned", GSSFilename = "tempout.gda") self.assertTrue(alg_test.isExecuted()) # Verify .... outputws = AnalysisDataService.retrieve(datawsname+"_rebinned") #self.assertEqual(4, tablews.rowCount()) # Delete the test hkl file os.remove(binfilename) AnalysisDataService.remove("InputWorkspace") AnalysisDataService.remove(datawsname+"_rebinned") return
def get_weighted_peak_centres(self): """ Get the peak centers found in peak workspace. Guarantees: the peak centers and its weight (detector counts) are exported :return: 2-tuple: list of 3-tuple (Qx, Qy, Qz) list of double (Det_Counts) """ # get PeaksWorkspace if AnalysisDataService.doesExist(self._myPeakWorkspaceName) is False: raise RuntimeError('PeaksWorkspace %s does ot exit.' % self._myPeakWorkspaceName) peak_ws = AnalysisDataService.retrieve(self._myPeakWorkspaceName) # get peak center, peak intensity and etc. peak_center_list = list() peak_intensity_list = list() num_peaks = peak_ws.getNumberPeaks() for i_peak in xrange(num_peaks): peak_i = peak_ws.getPeak(i_peak) center_i = peak_i.getQSampleFrame() intensity_i = peak_i.getIntensity() peak_center_list.append((center_i.X(), center_i.Y(), center_i.Z())) peak_intensity_list.append(intensity_i) # END-FOR return peak_center_list, peak_intensity_list
def decode(self, obj_dic, project_path=None): """ Decode a InstrumentView Dictionary from project Save and return the object created :param obj_dic: Dict; A dictionary containing the information for an InstrumentView :param project_path: String; The location of the project save location :return: InstrumentView's View; The View object with correct state is returned. """ load_mask = True if obj_dic is None: return None if project_path is None: project_path = "" load_mask = False # Make the widget ws = ADS.retrieve(obj_dic["workspaceName"]) instrument_view = InstrumentViewPresenter(ws).container instrument_widget = instrument_view.widget # Then 'decode' set the values from the dictionary self.widget_decoder.decode(obj_dic, instrument_widget, project_path, load_mask) # Show the end result return instrument_view
def get_moving_motor_information(spice_table_name): """ :param spice_table_name: :return: """ table = AnalysisDataService.retrieve(spice_table_name) col_names = table.getColumnNames() pt_index = col_names.index('Pt.') omega_index = col_names.index('omega') chi_index = col_names.index('chi') phi_index = col_names.index('phi') col_tup_dict = {'omega': omega_index, 'phi': phi_index, 'chi': chi_index} std_list = list() motor_vector_dict = dict() for motor in col_tup_dict: motor_index = col_tup_dict[motor] motor_vector = numpy.array(table.column(motor_index)) motor_vector_dict[motor] = motor_vector std_list.append((motor_vector.std(), motor)) std_list.sort() moving_motor = std_list[-1][1] pt_list = table.column(pt_index) motor_pos_dict = dict() for i_m in range(len(pt_list)): motor_pos_dict[pt_list[i_m]] = motor_vector_dict[moving_motor][i_m] return moving_motor, motor_pos_dict
def test_updateDouble(self): """ Test for update a double value """ # tablews = self.create_TableWorkspace() alg_init = run_algorithm("CreateEmptyTableWorkspace", OutputWorkspace="TestTableWorkspace") self.assertTrue(alg_init.isExecuted()) tablews = AnalysisDataService.retrieve("TestTableWorkspace") tablews.addColumn("str", "Name") tablews.addColumn("double", "Value") tablews.addColumn("str", "FitOrTie") tablews.addRow(["A", 1.34, "Fit"]) tablews.addRow(["B", 2.34, "Tie"]) tablews.addRow(["S", 3.34, "Tie"]) alg_test = run_algorithm("UpdatePeakParameterTableValue", InputWorkspace=alg_init.getPropertyValue("OutputWorkspace"), Column="Value", ParameterNames=["A"], NewFloatValue=1.00) self.assertTrue(alg_test.isExecuted()) newvalue_A = tablews.cell(0, 1) self.assertEqual(newvalue_A, 1.00) return
def __init__(self, data_file, workspace_name=None): self.errors = [] if HAS_MANTID: try: if workspace_name is None: self.data_ws = "__raw_data_file" else: self.data_ws = str(workspace_name) api.HFIRLoad(Filename=str(data_file), OutputWorkspace=self.data_ws) ws = AnalysisDataService.retrieve(self.data_ws) x = ws.dataX(0) self.wavelength = (x[0]+x[1])/2.0 self.wavelength_spread = x[1]-x[0] self.sample_detector_distance = ws.getRun().getProperty("sample-detector-distance").value self.sample_detector_distance_offset = ws.getRun().getProperty("sample-detector-distance-offset").value self.sample_si_window_distance = ws.getRun().getProperty("sample-si-window-distance").value self.sample_detector_distance_moved = ws.getRun().getProperty("sample_detector_distance").value self.sample_thickness = ws.getRun().getProperty("sample-thickness").value self.beam_diameter = ws.getRun().getProperty("beam-diameter").value logger.notice("Loaded data file: %s" % data_file) except: logger.error("Error loading data file:\n%s" % sys.exc_value) self.errors.append("Error loading data file:\n%s" % sys.exc_value)
def test_LoadHKLFile(self): """ Test to load a .hkl file """ # 1. Create a test file hklfilename = "test.hkl" self._createHKLFile(hklfilename) # 2. alg_test = run_algorithm("LoadFullprofFile", Filename = hklfilename, OutputWorkspace = "Foo", PeakParameterWorkspace = "PeakParameterTable") self.assertTrue(alg_test.isExecuted()) # 3. Verify some values tablews = AnalysisDataService.retrieve("PeakParameterTable") self.assertEqual(4, tablews.rowCount()) # alpha of (11 5 1)/Row 0 self.assertEqual(0.34252, tablews.cell(0, 3)) # 4. Delete the test hkl file os.remove(hklfilename) AnalysisDataService.remove("PeakParameterTable") AnalysisDataService.remove("Foo") return
def test_calculation_fitsample(self): OutputWorkspaceName = "outputws" # generate EPP table table = FindEPP(self._input_ws) alg_test = run_algorithm("TOFTOFConvertTofToDeltaE", InputWorkspace=self._input_ws, EPPTable=table, OutputWorkspace=OutputWorkspaceName) self.assertTrue(alg_test.isExecuted()) wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName) # create reference data for X axis dataX = np.linspace(4005.75, 7995.75, 381) tel = 6005.25 factor = m_n*1e+15/eV newX = 0.5*factor*16.0*(1/tel**2 - 1/dataX**2) # compare self.assertTrue(np.allclose(newX, wsoutput.readX(0))) # sdd = 4.0 self.assertTrue(np.allclose(4.0*newX, wsoutput.readX(1))) # sdd = 8.0 # create reference data for Y axis and compare to the output tof = dataX[:-1] + 5.25 newY = self._input_ws.readY(0)*tof**3/(factor*10.5*16.0) self.assertTrue(np.allclose(newY, wsoutput.readY(0))) # sdd = 4.0 self.assertTrue(np.allclose(newY/4.0, wsoutput.readY(1))) # sdd = 8.0 DeleteWorkspace(wsoutput) DeleteWorkspace(table)
def test_LoadNormalizeToDuration(self): outputWorkspaceName = "LoadDNSLegacyTest_Test1" filename = "dn134011vana.d_dat" alg_test = run_algorithm("LoadDNSLegacy", Filename=filename, Normalization='duration', OutputWorkspace=outputWorkspaceName, CoilCurrentsTable=self.curtable) self.assertTrue(alg_test.isExecuted()) # Verify some values ws = AnalysisDataService.retrieve(outputWorkspaceName) # dimensions self.assertEqual(24, ws.getNumberHistograms()) self.assertEqual(2, ws.getNumDims()) # data array self.assertAlmostEqual(31461.0/600.0, ws.readY(1)) self.assertAlmostEqual(13340.0/600.0, ws.readY(23)) # sample logs run = ws.getRun() self.assertEqual(-8.54, run.getProperty('deterota').value) self.assertEqual(8332872, run.getProperty('mon_sum').value) self.assertEqual('duration', run.getProperty('normalized').value) # check whether detector bank is rotated det = ws.getDetector(0) self.assertAlmostEqual(8.54, ws.detectorSignedTwoTheta(det)*180/pi) run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName) return
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 display_workspace(self, name): from mantidqt.widgets.workspacedisplay.matrix.presenter import MatrixWorkspaceDisplay from mantidqt.widgets.workspacedisplay.table.presenter import TableWorkspaceDisplay if AnalysisDataService.doesExist(name): ws = AnalysisDataService.retrieve(name) if isinstance(ws, MatrixWorkspace): presenter = MatrixWorkspaceDisplay(ws, plot=plot) presenter.show_view() elif isinstance(ws, ITableWorkspace): presenter = TableWorkspaceDisplay(ws, plot=matplotlib.pyplot) presenter.show_view()
def test_input_run_is_loaded_if_not_in_ADS(self): args = self._default_options args['InputRunList'] = '13460' outputs = ['IvsQ_13460', 'IvsQ_binned_13460', 'TOF_13460', 'TOF'] self._assert_run_algorithm_succeeds(args, outputs) history = [ 'ReflectometryISISPreprocess', 'ReflectometryReductionOneAuto', 'GroupWorkspaces' ] self._check_history(AnalysisDataService.retrieve('IvsQ_binned_13460'), history)
def testTable(self): # tests that correct table is created OutputWorkspaceName = "outputws1" alg_test = run_algorithm("FindEPP", InputWorkspace=self._input_ws, OutputWorkspace=OutputWorkspaceName) self.assertTrue(alg_test.isExecuted()) wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName) self.assertEqual(2, wsoutput.rowCount()) self.assertEqual(9, wsoutput.columnCount()) columns = ['WorkspaceIndex', 'PeakCentre', 'PeakCentreError', 'Sigma', 'SigmaError', 'Height', 'HeightError', 'chiSq', 'FitStatus'] self.assertEqual(columns, wsoutput.getColumnNames()) DeleteWorkspace(wsoutput)
def runTest(self): enginx = EnginX(vanadium_run="ENGINX236516", focus_runs=["ENGINX299080"], save_dir=CWDIR, full_inst_calib_path=FULL_CALIB, ceria_run="ENGINX193749", group=GROUP.TEXTURE20) enginx.main(plot_cal=False, plot_foc=False) # store workspaces for validation self._ws_foc = ADS.retrieve( "299080_engggui_focusing_output_ws_Texture20")
def test_debug_option_outputs_extra_workspaces_with_overridden_names(self): self._create_workspace(13460, 'TOF_') args = self._default_options args['InputRunList'] = '13460' args['Debug'] = True args.update(self._all_output_names) outputs = ['testIvsQ', 'testIvsQBin', 'testIvsLam', 'TOF_13460', 'TOF'] self._assert_run_algorithm_succeeds(args, outputs) history = ['ReflectometryReductionOneAuto', 'GroupWorkspaces'] self._check_history(AnalysisDataService.retrieve('testIvsQBin'), history)
def update_fit(self, fit_props): for fit_prop in fit_props: wsname = fit_prop['properties']['InputWorkspace'] self._fit_results[wsname] = { 'model': fit_prop['properties']['Function'], 'status': fit_prop['status'] } self._fit_results[wsname]['results'] = defaultdict( list) # {function_param: [[Y1, E1], [Y2,E2],...] } fnames = [ x.split('=')[-1] for x in findall( 'name=[^,]*', fit_prop['properties']['Function']) ] # get num params for each function (first elem empty as str begins with 'name=') # need to remove ties and constraints which are enclosed in () nparams = [ s.count('=') for s in sub(r'=\([^)]*\)', '', fit_prop['properties'] ['Function']).split('name=')[1:] ] params_dict = ADS.retrieve(fit_prop['properties']['Output'] + '_Parameters').toDict() # loop over rows in output workspace to get value and error for each parameter istart = 0 for ifunc, fname in enumerate(fnames): for iparam in range(0, nparams[ifunc]): irow = istart + iparam key = '_'.join([ fname, params_dict['Name'][irow].split('.')[-1] ]) # funcname_param self._fit_results[wsname]['results'][key].append([ params_dict['Value'][irow], params_dict['Error'][irow] ]) if key in fit_prop['peak_centre_params']: # param corresponds to a peak centre in TOF which we also need in dspacing # add another entry into the results dictionary key_d = key + "_dSpacing" try: dcen = self._convert_TOF_to_d( params_dict['Value'][irow], wsname) dcen_er = self._convert_TOFerror_to_derror( params_dict['Error'][irow], dcen, wsname) self._fit_results[wsname]['results'][key_d].append( [dcen, dcen_er]) except (ValueError, RuntimeError) as e: logger.warning( f"Unable to output {key_d} parameters for TOF={params_dict['Value'][irow]}: " + str(e)) istart += nparams[ifunc] # append the cost function value (in this case always chisq/DOF) as don't let user change cost func # always last row in parameters table self._fit_results[wsname]['costFunction'] = params_dict['Value'][ -1] self.create_fit_tables()
def split_to_single_bank(self, gss_ws_name): """ Split a multiple-bank GSAS workspace to a set of single-spectrum MatrixWorkspace Parameters ---------- gss_ws_name Returns ------- Name of grouped workspace and list """ # check assert isinstance(gss_ws_name, str) assert AnalysisDataService.doesExist(gss_ws_name) # get workspace gss_ws = AnalysisDataService.retrieve(gss_ws_name) ws_list = list() angle_list = list() if gss_ws.getNumberHistograms() == 1: # input is already a single-spectrum workspace ws_list.append(gss_ws_name) else: num_spec = gss_ws.getNumberHistograms() for i_ws in range(num_spec): # split this one to a single workspace out_ws_name = '%s_bank%d' % (gss_ws_name, i_ws + 1) # also can use ExtractSpectra() simpleapi.CropWorkspace(InputWorkspace=gss_ws_name, OutputWorkspace=out_ws_name, StartWorkspaceIndex=i_ws, EndWorkspaceIndex=i_ws) assert AnalysisDataService.doesExist(out_ws_name) ws_list.append(out_ws_name) # END-FOR # END-IF # calculate bank angles for ws_name in ws_list: bank_angle = calculate_bank_angle(ws_name) angle_list.append(bank_angle) # group all the workspace ws_group_name = gss_ws_name + '_group' simpleapi.GroupWorkspaces(InputWorkspaces=ws_list, OutputWorkspace=ws_group_name) self._braggDataDict[ws_group_name] = (gss_ws_name, ws_list) return ws_group_name, ws_list, angle_list
def test_loading_run_with_instrument_prefix_in_name(self): args = self._default_options args['InputRunList'] = 'INTER13460' outputs = ['IvsQ_13460', 'IvsQ_binned_13460', 'TOF_13460', 'TOF'] self._assert_run_algorithm_succeeds(args, outputs) history = [ 'ReflectometryISISPreprocess', 'ReflectometryReductionOneAuto', 'GroupWorkspaces' ] self._check_history(AnalysisDataService.retrieve('IvsQ_binned_13460'), history)
def _add_workspace_to_group(group_name, workspace_name): if AnalysisDataService.doesExist(group_name): workspaces_to_group = AnalysisDataService.retrieve( group_name).getNames() else: workspaces_to_group = [] if workspace_name not in workspaces_to_group: workspaces_to_group.append(workspace_name) WorkspaceGroupDefinition().add_workspaces_to_group( group_name, workspaces_to_group) WorkspaceGroupDefinition().execute_grouping()
def _expand_groups(self): """expand workspace groups""" workspaces = self.getProperty("InputWorkspace").value input_workspaces = [] for wsname in workspaces: wks = AnalysisDataService.retrieve(wsname) if isinstance(wks, WorkspaceGroup): input_workspaces.extend(wks.getNames()) else: input_workspaces.append(wsname) return input_workspaces
def runTest(self): enginx = EnginX(vanadium_run="ENGINX236516", focus_runs=["ENGINX299080"], save_dir=CWDIR, full_inst_calib_path=FULL_CALIB, ceria_run="ENGINX193749", group=GROUP.CROPPED, spectrum_num="1-1200") # North enginx.main(plot_cal=False, plot_foc=False) # store workspaces for validation self._ws_foc = ADS.retrieve( "299080_engggui_focusing_output_ws_Cropped")
def process_vanadium(vanadium_path, calibration, full_calib): van_run = path_handling.get_run_number_from_path( vanadium_path, calibration.get_instrument()) van_foc_name = CURVES_PREFIX + calibration.get_group_suffix() if ADS.doesExist(van_foc_name): ws_van_foc = ADS.retrieve(van_foc_name) else: if ADS.doesExist(van_run): ws_van = ADS.retrieve( van_run) # will exist if have only changed the ROI else: ws_van = _load_run_and_convert_to_dSpacing( vanadium_path, calibration.get_instrument(), full_calib) if not ws_van: raise RuntimeError( f"vanadium run {van_run} has no proton_charge - " f"please supply a valid vanadium run to focus.") ws_van_foc = _focus_run_and_apply_roi_calibration( ws_van, calibration, ws_foc_name=van_foc_name) ws_van_foc = _smooth_vanadium(ws_van_foc) return ws_van_foc, van_run
def testFitOutputWorkspacesAreDeleted(self): OutputWorkspaceName = "outputws1" alg_test = run_algorithm("FindEPP", InputWorkspace=self._input_ws, OutputWorkspace=OutputWorkspaceName, Version=1) wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName) DeleteWorkspace(wsoutput) oldOption = mantid.config['MantidOptions.InvisibleWorkspaces'] mantid.config['MantidOptions.InvisibleWorkspaces'] = '1' self.assertEqual(mtd.size(), 1) # Only self._input_ws exists. mantid.config['MantidOptions.InvisibleWorkspaces'] = oldOption
def test_key_operator_does_same_as_retrieve(self): wsname = 'ADSTest_test_key_operator_does_same_as_retrieve' self._run_createws(wsname) ws_from_op = AnalysisDataService[wsname] ws_from_method = AnalysisDataService.retrieve(wsname) self.do_check_for_matrix_workspace_type(ws_from_op) self.do_check_for_matrix_workspace_type(ws_from_method) self.assertEquals(ws_from_op.name(), ws_from_method.name()) self.assertEquals(ws_from_op.getMemorySize(), ws_from_method.getMemorySize())
def test_update_plot_guess_will_use_tmp_workspace_with_data_range_if_plot_range_type_is_selected(self): guess_workspace_name = "__frequency_domain_analysis_fitting_guessName1" self.model.dataset_names = self.dataset_names self.model.single_fit_functions = self.single_fit_functions self.model.start_xs = [0.0, 1.0] self.model.end_xs = [10.0, 11.0] self.model.current_dataset_index = 0 self.model.plot_guess = True self.model.plot_guess_type = X_FROM_FIT_RANGE self.model.context = mock.Mock() self.model._double_pulse_enabled = mock.Mock(return_value=False) self.model._get_plot_guess_name = mock.Mock(return_value=guess_workspace_name) self.model._get_guess_parameters = mock.Mock(return_value=['func', 'ws']) self.model.update_plot_guess() guess_workspace = AnalysisDataService.retrieve(guess_workspace_name) data_workspace = AnalysisDataService.retrieve(self.dataset_names[0]) self.assertEqual(guess_workspace.dataX(0).min(), 0.0) self.assertEqual(guess_workspace.dataX(0).max(), 10.0) self.assertEqual(guess_workspace.dataX(0).size, data_workspace.blocksize())
def get_region_of_interest(mask_ws_name): """ get region of interest from mask workspace :param mask_ws_name: :return: """ # check input assert isinstance(mask_ws_name, str), 'Mask workspace name {0} must be an integer but not a {1}' \ ''.format(mask_ws_name, type(mask_ws_name)) mask_ws = ADS.retrieve(mask_ws_name) # construct a 2D matrix size_x = size_y = int(math.sqrt(mask_ws.getNumberHistograms())) mask_matrix = numpy.ndarray(shape=(size_x, size_y), dtype='int') # mask or unmask all the matrix element according to mask workspace for iws in range(mask_ws.getNumberHistograms()): det_id = mask_ws.getDetector(iws).getID() pixel_2d_id = det_id / size_y, det_id % size_y mask_matrix[pixel_2d_id] = int(mask_ws.isMasked(iws)) # END-FOR # find lower left corner lower_left_corner = None for ir in range(size_y): if mask_matrix[ir].min() == 0: ll_row = ir ret_value = numpy.where(mask_matrix[ir] == 0) ll_col = ret_value[0][0] lower_left_corner = ll_row, ll_col break # END-IF # END-FOR # find upper right corner upper_right_corner = None for ir in range(size_y - 1, -1, -1): if mask_matrix[ir].min() == 0: ur_row = ir ret_value = numpy.where(mask_matrix[ir] == 0) ur_col = ret_value[0][-1] upper_right_corner = ur_row, ur_col break # END-IF # END-FOR # check before return if lower_left_corner is None or upper_right_corner is None: raise RuntimeError( 'It is impossible not to find either lower left corner {0} or upper right corner {1}' ''.format(lower_left_corner, upper_right_corner)) return lower_left_corner, upper_right_corner
def test_sum(self): outputWorkspaceName = "output_ws" alg_test = run_algorithm("ComputeCalibrationCoefVan", VanadiumWorkspace=self._input_ws, EPPTable=self._table, OutputWorkspace=outputWorkspaceName) self.assertTrue(alg_test.isExecuted()) wsoutput = AnalysisDataService.retrieve(outputWorkspaceName) # check whether sum is calculated correctly, for theta=0, dwf=1 y_sum = sum(self._input_ws.readY(0)[27:75]) self.assertAlmostEqual(y_sum, wsoutput.readY(0)[0]) DeleteWorkspace(wsoutput)
def _getRunNumberAsString(workspace_name): """Get the run number for a workspace. If it's a workspace group, get the run number from the first child workspace.""" try: workspace = AnalysisDataService.retrieve(workspace_name) if not isinstance(workspace, WorkspaceGroup): return str(workspace.getRunNumber()) # Get first child in the group return str(workspace[0].getRunNumber()) except: raise RuntimeError('Could not find run number for workspace ' + workspace_name)
def test_overriding_output_names_includes_all_specified_outputs(self): self._create_workspace(13460, 'TOF_') args = self._default_options args['InputRunList'] = '13460' args.update(self._all_output_names) # Current behaviour is that the optional workspaces are output even if # Debug is not set outputs = ['testIvsQ', 'testIvsQBin', 'testIvsLam', 'TOF_13460', 'TOF'] self._assert_run_algorithm_succeeds(args, outputs) history = ['ReflectometryReductionOneAuto', 'GroupWorkspaces'] self._check_history(AnalysisDataService.retrieve('testIvsQBin'), history)
def test_setGetMonitorWS(self): run_algorithm('CreateWorkspace', OutputWorkspace='ws1', DataX=[ 1., 2., 3.], DataY=[2., 3.], DataE=[2., 3.], UnitX='TOF') run_algorithm('CreateWorkspace', OutputWorkspace='ws_mon', DataX=[ 1., 2., 3.], DataY=[2., 3.], DataE=[2., 3.], UnitX='TOF') ws1 = AnalysisDataService.retrieve('ws1') try: monWs = ws1.getMonitorWorkspace() GotIt = True except RuntimeError: GotIt = False self.assertFalse(GotIt) monWs = AnalysisDataService.retrieve('ws_mon') ws1.setMonitorWorkspace(monWs) monWs.setTitle("My Fake Monitor workspace") monWs1 = ws1.getMonitorWorkspace() self.assertEquals(monWs.getTitle(), monWs1.getTitle()) ws1.clearMonitorWorkspace() try: monWs1 = ws1.getMonitorWorkspace() GotIt = True except RuntimeError: GotIt = False self.assertFalse(GotIt) # Check weak pointer issues ws1.setMonitorWorkspace(monWs) wms = ws1.getMonitorWorkspace() allFine = False try: ws1.setMonitorWorkspace(wms) allFine = True except ValueError: pass self.assertTrue(allFine)
def test_DNSFRVanaCorrection(self): outputWorkspaceName = "DNSFlippingRatioCorrTest_Test6" # create fake vanadium data workspaces dataY = np.array([1811., 2407., 3558., 3658., 3352., 2321., 2240., 2617., 3245., 3340., 3338., 3310., 2744., 3212., 1998., 2754., 2791., 2509., 3045., 3429., 3231., 2668., 3373., 2227.]) __sf_vanaws = create_fake_dns_workspace('__sf_vanaws', dataY=dataY/58.0, flipper='ON') self.workspaces.append('__sf_vanaws') dataY = np.array([2050., 1910., 2295., 2236., 1965., 1393., 1402., 1589., 1902., 1972., 2091., 1957., 1593., 1952., 1232., 1720., 1689., 1568., 1906., 2001., 2051., 1687., 1975., 1456.]) __nsf_vanaws = create_fake_dns_workspace('__nsf_vanaws', dataY=dataY/58.0, flipper='OFF') self.workspaces.append('__nsf_vanaws') # consider normalization=1.0 as set in self._create_fake_workspace dataws_sf = __sf_vanaws - self.__sf_bkgrws dataws_nsf = __nsf_vanaws - self.__nsf_bkgrws alg_test = run_algorithm("DNSFlippingRatioCorr", SFDataWorkspace=dataws_sf, NSFDataWorkspace=dataws_nsf, SFNiCrWorkspace=self.__sf_nicrws.getName(), NSFNiCrWorkspace=self.__nsf_nicrws.getName(), SFBkgrWorkspace=self.__sf_bkgrws.getName(), NSFBkgrWorkspace=self.__nsf_bkgrws.getName(), SFOutputWorkspace=outputWorkspaceName+'SF', NSFOutputWorkspace=outputWorkspaceName+'NSF') self.assertTrue(alg_test.isExecuted()) # check whether the data are correct ws_sf = AnalysisDataService.retrieve(outputWorkspaceName + 'SF') ws_nsf = AnalysisDataService.retrieve(outputWorkspaceName + 'NSF') # dimensions self.assertEqual(24, ws_sf.getNumberHistograms()) self.assertEqual(24, ws_nsf.getNumberHistograms()) self.assertEqual(2, ws_sf.getNumDims()) self.assertEqual(2, ws_nsf.getNumDims()) # data array: for vanadium ratio sf/nsf must be around 2 ws = ws_sf/ws_nsf for i in range(24): self.assertAlmostEqual(2.0, np.around(ws.readY(i))) run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName + 'SF') run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName + 'NSF') run_algorithm("DeleteWorkspace", Workspace=dataws_sf) run_algorithm("DeleteWorkspace", Workspace=dataws_nsf) run_algorithm("DeleteWorkspace", Workspace=ws) return
def test_DNSFRSelfCorrection(self): outputWorkspaceName = "DNSFlippingRatioCorrTest_Test4" # consider normalization=1.0 as set in self._create_fake_workspace dataws_sf = self.__sf_nicrws - self.__sf_bkgrws dataws_nsf = self.__nsf_nicrws - self.__nsf_bkgrws alg_test = run_algorithm("DNSFlippingRatioCorr", SFDataWorkspace=dataws_sf, NSFDataWorkspace=dataws_nsf, SFNiCrWorkspace=self.__sf_nicrws.getName(), NSFNiCrWorkspace=self.__nsf_nicrws.getName(), SFBkgrWorkspace=self.__sf_bkgrws.getName(), NSFBkgrWorkspace=self.__nsf_bkgrws.getName(), SFOutputWorkspace=outputWorkspaceName + 'SF', NSFOutputWorkspace=outputWorkspaceName + 'NSF') self.assertTrue(alg_test.isExecuted()) # check whether the data are correct ws_sf = AnalysisDataService.retrieve(outputWorkspaceName + 'SF') ws_nsf = AnalysisDataService.retrieve(outputWorkspaceName + 'NSF') # dimensions self.assertEqual(24, ws_sf.getNumberHistograms()) self.assertEqual(24, ws_nsf.getNumberHistograms()) self.assertEqual(2, ws_sf.getNumDims()) self.assertEqual(2, ws_nsf.getNumDims()) # data array: spin-flip must be zero for i in range(24): self.assertAlmostEqual(0.0, ws_sf.readY(i)[0]) # data array: non spin-flip must be nsf - sf^2/nsf nsf = np.array(dataws_nsf.extractY()) sf = np.array(dataws_sf.extractY()) refdata = nsf + sf for i in range(24): self.assertAlmostEqual(refdata[i][0], ws_nsf.readY(i)[0]) run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName + 'SF') run_algorithm("DeleteWorkspace", Workspace=outputWorkspaceName + 'NSF') run_algorithm("DeleteWorkspace", Workspace=dataws_sf) run_algorithm("DeleteWorkspace", Workspace=dataws_nsf) return
def test_that_can_load_isis_nexus_file_with_event_data_and_multi_period( self): # Arrange state = SANSLoadTest._get_simple_state( sample_scatter="LARMOR00013065.nxs", calibration="80tubeCalibration_18-04-2016_r9330-9335.nxs") # Act output_workspace_names = { "SampleScatterWorkspace": "sample_scatter", "SampleScatterMonitorWorkspace": "sample_monitor_scatter" } load_alg = self._run_load( state, publish_to_cache=True, use_cached=True, move_workspace=False, output_workspace_names=output_workspace_names) # Assert expected_number_of_workspaces = [4, 0, 0, 0, 0, 0] expected_number_on_ads = 1 workspace_type = [EventWorkspace, None, None, None, None, None] self._do_test_output(load_alg, expected_number_of_workspaces, expected_number_on_ads, workspace_type) # Check that calibration is added self.assertTrue(SANSLoadTest._has_calibration_been_applied(load_alg)) # Confirm that the ADS workspace contains the calibration file try: AnalysisDataService.retrieve( "80tubeCalibration_18-04-2016_r9330-9335") on_ads = True except RuntimeError: on_ads = False self.assertTrue(on_ads) # Cleanup remove_all_workspaces_from_ads()
def test_slicing_loads_input_run_if_not_in_ADS(self): args = self._default_options args.update(self._default_slice_options_real_run) args['InputRunList'] = '38415' outputs = self._expected_real_time_sliced_outputs self._assert_run_algorithm_succeeds(args, outputs) history = [ 'ReflectometryReductionOneAuto', 'ReflectometryReductionOneAuto', 'ReflectometryReductionOneAuto', 'GroupWorkspaces' ] self._check_history( AnalysisDataService.retrieve('IvsQ_binned_38415_sliced_0_210'), history, False)
def test_debug_option_outputs_extra_workspaces(self): self._create_workspace(13460, 'TOF_') args = self._default_options args['InputRunList'] = '13460' args['Debug'] = True outputs = [ 'IvsQ_13460', 'IvsQ_binned_13460', 'IvsLam_13460', 'TOF_13460', 'TOF' ] self._assert_run_algorithm_succeeds(args, outputs) history = ['ReflectometryReductionOneAuto', 'GroupWorkspaces'] self._check_history(AnalysisDataService.retrieve('IvsQ_binned_13460'), history)
def test_input_run_is_reloaded_if_in_ADS_with_unknown_prefix(self): self._create_workspace(13460, 'TEST_') args = self._default_options args['InputRunList'] = '13460' outputs = [ 'IvsQ_13460', 'IvsQ_binned_13460', 'TEST_13460', 'TOF_13460', 'TOF' ] self._assert_run_algorithm_succeeds(args, outputs) history = [ 'LoadNexus', 'ReflectometryReductionOneAuto', 'GroupWorkspaces' ] self._check_history(AnalysisDataService.retrieve('IvsQ_binned_13460'), history)
def _create_flat_background_test_workspace(workspace_name): LoadNexusProcessed(Filename="LOQ48127", OutputWorkspace=workspace_name) workspace = AnalysisDataService.retrieve(workspace_name) # Rebin to only have four values at 11, 31, 51, 70.5 workspace = Rebin(workspace, "1,20,80") # For each spectrum we set the first two entries to 2 and the other two entries to 4. for index in range(workspace.getNumberHistograms()): data_y = workspace.dataY(index) data_y[0] = 2. data_y[1] = 2. data_y[2] = 4. data_y[3] = 4. return workspace
def _setUniformNumberOfSlices(self, alg, workspace_name): """If slicing by a specified number of slices is requested, find the time interval to use to give this number of even time slices and set the relevant property on the given slicing algorithm""" if self.getProperty(Prop.NUMBER_OF_SLICES).isDefault: return number_of_slices = self.getProperty(Prop.NUMBER_OF_SLICES).value run=AnalysisDataService.retrieve(workspace_name).run() total_duration = (run.endTime() - run.startTime()).total_seconds() slice_duration = total_duration / number_of_slices alg.setProperty("TimeInterval", slice_duration) self.log().information('Slicing ' + workspace_name + ' into ' + str(number_of_slices) + ' even slices of duration ' + str(slice_duration))
def _removeWorkspace(workspace_name): """Remove the workspace with the given name, including any child workspaces if it is a group. If a corresponding monitors workspace exists, remove that too.""" if AnalysisDataService.doesExist(workspace_name): workspace = AnalysisDataService.retrieve(workspace_name) if isinstance(workspace, WorkspaceGroup): # Remove child workspaces first while workspace.getNumberOfEntries(): _removeWorkspace(workspace[0].name()) AnalysisDataService.remove(workspace_name) # If a corresponding monitors workspace also exists, remove that too if AnalysisDataService.doesExist(_monitorWorkspace(workspace_name)): _removeWorkspace(_monitorWorkspace(workspace_name))
def clear_fit_result_lines(self): """ Delete the fit curves. """ for line in self.get_lines(): if line.get_label() == self.sequential_fit_line: line.remove() if self.fit_result_ws_name: ws = AnalysisDataService.retrieve(self.fit_result_ws_name) self.get_axes().remove_workspace_artists(ws) self.fit_result_ws_name = "" self.update_legend()