def test_purge_table(self): r"""We use either of two criterion functions""" with self.assertRaises(AssertionError) as exception_info: purge_table('I am not here', 'table', [True, False]) assert 'Input workspace I am not here does not exists' in str(exception_info.exception) with self.assertRaises(AssertionError) as exception_info: purge_table(self.cases['123455_bank20'], 'I am not here', [True, False]) assert 'Input table I am not here does not exists' in str(exception_info.exception) # control bank, it has no problems. Thus, no tubes to purge fit_bank(self.cases['123455_bank20'], 'bank20') tube_fit_success = criterion_peak_pixel_position('PeakTable', zscore_threshold=2.5, deviation_threshold=3) unpurged_row_count = mtd['CalibTable'].rowCount() purge_table(self.cases['123455_bank20'], 'CalibTable', tube_fit_success) assert mtd['CalibTable'].rowCount() == unpurged_row_count DeleteWorkspaces(['CalibTable', 'PeakTable', 'PeakYTable', 'ParametersTable']) # a bit of clean-up # tube11 is not working at all. Thus, purge only one tube fit_bank(self.cases['124018_bank45'], 'bank45') tube_fit_success = criterion_peak_vertical_position('PeakYTable', zscore_threshold=2.5, deviation_threshold=0.0035) unpurged_row_count = mtd['CalibTable'].rowCount() purge_table(self.cases['124018_bank45'], 'CalibTable', tube_fit_success) assert mtd['CalibTable'].rowCount() == unpurged_row_count - 256 self.assert_missing_tube('CalibTable', 11) DeleteWorkspaces(['CalibTable', 'PeakTable', 'PeakYTable', 'ParametersTable']) # a bit of clean-up
def test_fit_bank(self): control = self.cases['123455_bank20'] # a bank with a reasonable wire scan with self.assertRaises(AssertionError) as exception_info: fit_bank('I_am_not_here', 'bank42') with self.assertRaises(AssertionError) as exception_info: fit_bank(control, 'bank20', shadow_height=-1000) assert 'shadow height must be positive' in str(exception_info.exception) with self.assertRaises(AssertionError) as exception_info: fit_bank(control, 'tree/bank51') assert 'The bank name must be of the form' in str(exception_info.exception) with self.assertRaises(AssertionError) as exception_info: fit_bank(self.cases['123555_bank20'], 'bank20') assert 'Insufficient counts per pixel in workspace CORELLI_123555_bank20' in str(exception_info.exception) fit_bank(control, 'bank20', parameters_table_group='parameters_table') # Expect default name for calibration table assert AnalysisDataService.doesExist('CalibTable') # Expect default name for peak pixel position table assert AnalysisDataService.doesExist('PeakTable') # Expect default name for peak pixel position table assert AnalysisDataService.doesExist('PeakYTable') # assert the parameters tables are created assert AnalysisDataService.doesExist('parameters_table') for tube_number in range(TUBES_IN_BANK): assert AnalysisDataService.doesExist(f'parameters_table_{tube_number}') DeleteWorkspaces(['CalibTable', 'PeakTable', 'PeakYTable', 'parameters_table']) fit_bank(control, 'bank20', calibration_table='table_20', peak_pixel_positions_table='pixel_20') assert AnalysisDataService.doesExist('table_20') assert AnalysisDataService.doesExist('pixel_20') DeleteWorkspaces(['table_20', 'pixel_20', 'PeakYTable', 'ParametersTable']) # a bit of clean-up
def test_fit_bank(self): with self.assertRaises(AssertionError) as exception_info: fit_bank('I_am_not_here', 'bank42') assert 'Input workspace I_am_not_here does not exists' in str(exception_info.exception) control = self.cases['123455_bank20'] # a bank with a reasonable wire scan with self.assertRaises(AssertionError) as exception_info: fit_bank(control, 'bank20', shadow_height=-1000) assert 'shadow height must be positive' in str(exception_info.exception) with self.assertRaises(AssertionError) as exception_info: fit_bank(control, 'tree/bank51') assert 'The bank name must be of the form' in str(exception_info.exception) with self.assertRaises(AssertionError) as exception_info: fit_bank(self.cases['123555_bank20'], 'bank20') assert 'Insufficient counts per pixel in workspace CORELLI_123555_bank20' in str(exception_info.exception) fit_bank(control, 'bank20') # Expect default name for calibration table assert AnalysisDataService.doesExist('CalibTable') # Expect default name for peak pixel position table assert AnalysisDataService.doesExist('PeakTable') DeleteWorkspaces(['CalibTable', 'PeakTable']) fit_bank(control, 'bank20', calibration_table='table_20', peak_pixel_positions_table='pixel_20') assert AnalysisDataService.doesExist('table_20') assert AnalysisDataService.doesExist('pixel_20') DeleteWorkspaces(['CalibTable', 'PeakTable']) # a bit of clean-up
def test_calibrate_bank(self): # control bank, it has no problems. Thus, no mask to be created calibration, mask = calibrate_bank(self.cases['123455_bank20'], 'bank20', 'calibration_table') assert calibration.rowCount() == 256 * 16 assert calibration.columnCount() == 2 assert AnalysisDataService.doesExist('calibration_table') assert mask is None assert AnalysisDataService.doesExist('MaskTable') is False DeleteWorkspaces(['calibration_table']) # clean-up # beam center intensity spills over adjacent tubes, tube15 and tube16 calibration, mask = calibrate_bank(self.cases['123454_bank58'], 'bank58', 'calibration_table') assert calibration.rowCount() == 256 * (16 - 2) assert calibration.columnCount() == 2 # Detector ID, Position assert AnalysisDataService.doesExist('calibration_table') assert mask.rowCount() == 256 * 2 assert mask.columnCount() == 1 assert AnalysisDataService.doesExist('MaskTable') DeleteWorkspaces(['calibration_table', 'MaskTable']) # clean-up # check for the fits workspace calibrate_bank(self.cases['123455_bank20'], 'bank20', 'calibration_table', fit_results='fits') assert AnalysisDataService.doesExist('fits') workspace = mtd['fits'] axis = workspace.getAxis(1) labels = [axis.label(i) for i in range(workspace.getNumberHistograms())] assert labels == ['success', 'deviation', 'Z-score', 'A0', 'A1', 'A2'] assert_allclose(workspace.readY(0), [1.0] * TUBES_IN_BANK) # success status for first tube self.assertAlmostEqual(max(workspace.readY(2)), 2.73, delta=0.01) # maximum Z-score self.assertAlmostEqual(max(workspace.readY(3)), -0.445, delta=0.001) # maximum A0 value self.assertAlmostEqual(max(workspace.readE(3)), 1.251, delta=0.001) # maximum A0 error DeleteWorkspaces(['calibration_table', 'fits']) # a bit of clean-up
def test_calibrate(self): data = self.corelli calibrate(data['workspace'], data['bank_name'], data['wire_positions'], data['peaks_form'], fitPar=data['fit_parameters'], outputPeak=True, parameters_table_group='parameters_table_group') # Check the table workspaces containing the polynomial coefficients assert AnalysisDataService.doesExist('parameters_table_group') workspace = mtd['parameters_table_group'] for tube_number, name in enumerate(workspace.getNames()): assert name == f'parameters_table_group_{tube_number}' assert AnalysisDataService.doesExist(name) # Check the values of the coefficients for the first and last tube for tube_index, expected in [(0, { 'A0': -0.446804, 'A1': 0.003513, 'A2': 0.0 }), (15, { 'A0': -0.452107, 'A1': 0.003528, 'A2': 0.00 })]: workspace = mtd[f'parameters_table_group_{tube_index}'] for row in workspace: if row['Name'] in expected: self.assertAlmostEqual(expected[row['Name']], row['Value'], delta=1.e-6) DeleteWorkspaces(['CalibTable', 'parameters_table_group', 'PeakTable'])
def test_correct_tube_to_ideal_tube(self): # Verify the quadratic fit works data = self.y_quad_data # fit the Y-coordinates to the pixel positions with a default quadratic function fitted_coordinates = correct_tube_to_ideal_tube( data['tube_points'], data['ideal_tube_coordinates'], data['detector_count'], parameters_table='parameters') # Verify the fitted coordinates are the ideal_tube_coordinates assert_allclose( [fitted_coordinates[int(n)] for n in data['tube_points']], data['ideal_tube_coordinates'], atol=0.0001) # Compare fitting coefficients assert AnalysisDataService.doesExist('parameters') # here retrieve the fitting coefficients from the 'parameters' table and compare to the expected values expected = data['coefficients'] for row in mtd['parameters']: if row['Name'] in expected: self.assertAlmostEqual(row['Value'], expected[row['Name']], places=6) # a bit of clean-up DeleteWorkspaces([ 'PolyFittingWorkspace', 'QF_NormalisedCovarianceMatrix', 'QF_Parameters', 'QF_Workspace', 'parameters' ])
def mask_bank(bank_name: str, tubes_fit_success: np.ndarray, output_table: str) -> Optional[TableWorkspace]: r""" Creates a single-column `TableWorkspace` object containing the detector ID's of the unsuccessfully fitted tubes If all tubes were fit successfully, no `TableWorkspace` is created, and `None` is returned. :param bank_name: a string of the form 'bankI' where 'I' is a bank number :param tubes_fit_success: array of boolean containing a True/False entry for each tube, indicating wether the tube was successfully calibrated. :param output_table: name of the output TableWorkspace containing one column for detector ID from tubes not successfully calibrated. :raise AssertionError: the string bank_name does not follow the pattern 'bankI' where 'I' in an integer :return: name of the mask TableWorkspace. Returns `None` if no TableWorkspace is created. """ assert re.match(r'^bank\d+$', bank_name), 'The bank name must be of the form "bankI" where "I" in an integer' if False not in tubes_fit_success: return None # al tubes were fit successfully bank_number = bank_name[4:] # drop 'bank' from bank_name tube_numbers = 1 + np.where(tubes_fit_success == False)[0] # noqa E712 unsuccessfully fitted tube numbers tube_numbers = ','.join([str(n) for n in tube_numbers]) # failing tubes as a string detector_ids = MaskBTP(Instrument='CORELLI', Bank=bank_number, Tube=tube_numbers) table = CreateEmptyTableWorkspace(OutputWorkspace=output_table) table.addColumn('long64', 'Detector ID') [table.addRow([detector_id]) for detector_id in detector_ids.tolist()] if AnalysisDataService.doesExist('CORELLIMaskBTP'): DeleteWorkspaces(['CORELLIMaskBTP']) return mtd[output_table]
def spacings_recovered(self, input_workspace, calibrate=True): r"""Compare the input_workspace to the reference workspace 'test_workspace_dSpacing' after being converted to TOF units. If calibrate=True, calibrate first and then convert units""" if calibrate: CorelliPowderCalibrationCreate( InputWorkspace='perturbed', OutputWorkspacesPrefix='cal_', TofBinning=[300, 1.0, 16666.7], PeakPositions=self.spacings_reference, SourceToSampleDistance=10.0, ComponentList='bank1', FixY=False, ComponentMaxTranslation=0.03, FixYaw=False, ComponentMaxRotation=6, Minimizer='differential_evolution', MaxIterations=10) ConvertUnits(InputWorkspace='perturbed', Target='dSpacing', EMode='Elastic', OutputWorkspace='perturbed_dS') results = CompareWorkspaces(Workspace1='test_workspace_dSpacing', Workspace2='perturbed_dS', Tolerance=0.001, CheckInstrument=False) DeleteWorkspaces(['perturbed_dS']) return results.Result
def test_collect_peaks_diff(self): test_diff = diagnostics.collect_peaks('diag_dspacing', 'test_diff', infotype='difference') result = CompareWorkspaces(test_diff, "difference", Tolerance=1e-6) self.assertTrue(result) DeleteWorkspaces(test_diff, result)
def __testRaggedBoundaries(self, histogram): inwsname = 'MatchSpectraTest_raggedBoundaries' if histogram: inwsname += 'Histogram' else: inwsname += 'Frequency' outwsname = inwsname + '_out' self.__createRaggedWorkspace(inwsname, histogram) ##### offset only results = MatchSpectra(InputWorkspace=inwsname, OutputWorkspace=outwsname, ReferenceSpectrum=2, CalculateOffset=True, CalculateScale=False) self.__checkReference(results, 1) self.__checkValues(results, 0, 1., 10.) ##### scale only results = MatchSpectra(InputWorkspace=inwsname, OutputWorkspace=outwsname, ReferenceSpectrum=3, CalculateOffset=False, CalculateScale=True) self.__checkReference(results, 2) self.__checkValues(results, 0, 10., 0.) ##### both results = MatchSpectra(InputWorkspace=inwsname, OutputWorkspace=outwsname, ReferenceSpectrum=4, CalculateOffset=True, CalculateScale=True) self.__checkReference(results, 3) self.__checkValues(results, 0, 10., 10.) DeleteWorkspaces(WorkspaceList=[inwsname, outwsname])
def runTest(self): ws_name = 'SingleFilePredictPeaksUBFromFindPeaksIntegrate' HB3AAdjustSampleNorm(Filename="HB3A_exp0724_scan0183.nxs", OutputWorkspace=ws_name + '_data') HB3AFindPeaks(InputWorkspace=ws_name + '_data', CellType="Orthorhombic", Centering="F", OutputWorkspace=ws_name + '_found_peaks') HB3APredictPeaks(InputWorkspace=ws_name + "_data", UBWorkspace=ws_name + '_found_peaks', OutputWorkspace=ws_name + '_peaks') HB3AIntegratePeaks(InputWorkspace=ws_name + '_data', PeaksWorkspace=ws_name + '_peaks', PeakRadius=0.25, OutputWorkspace=ws_name + '_integrated') peaks = mtd[ws_name + '_integrated'] self.assertEqual(peaks.getNumberPeaks(), 114) ol = peaks.sample().getOrientedLattice() self.assertDelta(ol.a(), 5.231258554, 1.e-7) self.assertDelta(ol.b(), 5.257701834, 1.e-7) self.assertDelta(ol.c(), 19.67041036, 1.e-7) self.assertEqual(ol.alpha(), 90) self.assertEqual(ol.beta(), 90) self.assertEqual(ol.gamma(), 90) DeleteWorkspaces([ ws_name + '_data', ws_name + '_found_peaks', ws_name + '_peaks', ws_name + '_integrated' ])
def runTest(self): ws_name = 'SingleFilePredictPeaksIntegrate' HB3AAdjustSampleNorm(Filename="HB3A_exp0724_scan0183.nxs", OutputWorkspace=ws_name + '_data') HB3APredictPeaks(InputWorkspace=ws_name + "_data", OutputWorkspace=ws_name + "_peaks") HB3AIntegratePeaks(InputWorkspace=ws_name + '_data', PeaksWorkspace=ws_name + '_peaks', PeakRadius=0.25, OutputWorkspace=ws_name + '_integrated') peaks = mtd[ws_name + '_integrated'] self.assertEqual(peaks.getNumberPeaks(), 112) ol = peaks.sample().getOrientedLattice() self.assertDelta(ol.a(), 5.238389802, 1.e-7) self.assertDelta(ol.b(), 5.238415883, 1.e-7) self.assertDelta(ol.c(), 19.65194598, 1.e-7) self.assertDelta(ol.alpha(), 89.9997207, 1.e-7) self.assertDelta(ol.beta(), 89.9997934, 1.e-7) self.assertDelta(ol.gamma(), 89.9999396, 1.e-7) DeleteWorkspaces( [ws_name + '_data', ws_name + '_peaks', ws_name + '_integrated'])
def test_purge_table(self): with self.assertRaises(AssertionError) as exception_info: purge_table('I am not here', 'table', [True, False]) assert 'Input workspace I am not here does not exists' in str(exception_info.exception) with self.assertRaises(AssertionError) as exception_info: purge_table(self.cases['123455_bank20'], 'I am not here', [True, False]) assert 'Input table I am not here does not exists' in str(exception_info.exception) # control bank, it has no problems. Thus, no tubes to purge fit_bank(self.cases['123455_bank20'], 'bank20') tube_fit_success = criterium_peak_pixel_position('PeakTable', zscore_threshold=2.5, deviation_threshold=3) unpurged_row_count = mtd['CalibTable'].rowCount() purge_table(self.cases['123455_bank20'], 'CalibTable', tube_fit_success) assert mtd['CalibTable'].rowCount() == unpurged_row_count # tube11 is not working at all. Thus, purge only one tube fit_bank(self.cases['124018_bank45'], 'bank45') tube_fit_success = criterium_peak_pixel_position('PeakTable', zscore_threshold=2.5, deviation_threshold=3) unpurged_row_count = mtd['CalibTable'].rowCount() purge_table(self.cases['124018_bank45'], 'CalibTable', tube_fit_success) assert mtd['CalibTable'].rowCount() == unpurged_row_count - 256 self.assert_missing_tube('CalibTable', 11) # tubes 3, 8, and 13 have very faint wire shadows. Thus, purge three tubes fit_bank(self.cases['124023_bank14'], 'bank14') tube_fit_success = criterium_peak_pixel_position('PeakTable', zscore_threshold=2.5, deviation_threshold=3) unpurged_row_count = mtd['CalibTable'].rowCount() purge_table(self.cases['124023_bank14'], 'CalibTable', tube_fit_success) assert mtd['CalibTable'].rowCount() == unpurged_row_count - 256 * 3 for tube_number in (3, 8, 13): self.assert_missing_tube('CalibTable', tube_number) DeleteWorkspaces(['CalibTable', 'PeakTable']) # a bit of clean-up
def tearDown(self) -> None: to_delete = [ w for w in [self.workspace, self.table] if AnalysisDataService.doesExist(w) ] if len(to_delete) > 0: DeleteWorkspaces(to_delete)
def test_collect_peaks_strain(self): test_strain = diagnostics.collect_peaks('diag_dspacing', 'test_strain', infotype='strain') result = CompareWorkspaces(test_strain, "strain", Tolerance=1e-6) self.assertTrue(result) DeleteWorkspaces(test_strain, result)
def __testCommonBoundaries(self, histogram): inwsname = 'MatchSpectraTest_commonBoundaries' if histogram: inwsname += 'Histogram' else: inwsname += 'Frequency' outwsname = inwsname + '_out' self.__createWorkspace(inwsname, histogram, True) ##### offset only results = MatchSpectra(InputWorkspace=inwsname, OutputWorkspace=outwsname, ReferenceSpectrum=2, CalculateOffset=True, CalculateScale=False) self.__checkReference(results, 1) self.__checkValues(results, 0, 1., 10.) self.assertTrue(np.alltrue(mtd[outwsname].readY(0) == mtd[outwsname].readY(1))) ##### scale only results = MatchSpectra(InputWorkspace=inwsname, OutputWorkspace=outwsname, ReferenceSpectrum=3, CalculateOffset=False, CalculateScale=True) self.__checkReference(results, 2) self.__checkValues(results, 0, 10., 0.) self.assertTrue(np.alltrue(mtd[outwsname].readY(0) == mtd[outwsname].readY(2))) ##### both results = MatchSpectra(InputWorkspace=inwsname, OutputWorkspace=outwsname, ReferenceSpectrum=4, CalculateOffset=True, CalculateScale=True) self.__checkReference(results, 3) self.__checkValues(results, 0, 10., 10.) self.assertTrue(np.alltrue(mtd[outwsname].readY(0) == mtd[outwsname].readY(3))) DeleteWorkspaces(WorkspaceList=[inwsname, outwsname])
def test_calibrate_tube(self) -> None: # Check the validators are doing what they're supposed to do with self.assertRaises(AssertionError) as exception_info: calibrate_tube(None, 'bank42/sixteenpack/tube8') assert 'Cannot process workspace' in str(exception_info.exception) with self.assertRaises(AssertionError) as exception_info: calibrate_tube(self.workspace, 'tube42') assert 'tube42 does not uniquely specify one tube' in str( exception_info.exception) with self.assertRaises(AssertionError) as exception_info: calibrate_tube(self.workspace, 'bank42/sixteenpack/tube8', fit_domain=20) assert 'The fit domain cannot be larger than the distance between consecutive' in str( exception_info.exception) table = calibrate_tube(self.workspace, 'bank42/sixteenpack/tube8') calibrated_y = table.column(1) assert_allclose(calibrated_y, self.calibrated_y, atol=1e-3) # Check for existence of all table workspaces calibrate_tube(self.cases['124023_bank10'], 'bank10/sixteenpack/tube13') DeleteWorkspaces( ['CalibTable', 'PeakTable', 'ParametersTable', 'PeakYTable'])
def test_fix_y(self) -> None: CloneWorkspace(InputWorkspace='test_workspace_TOF', OutputWorkspace='perturbed') y = -0.0042 # desired fixed position MoveInstrumentComponent(Workspace='perturbed', ComponentName='bank1', X=0, y=y, z=0, RelativePosition=False) r"""Pass option FixY=True""" CorelliPowderCalibrationCreate(InputWorkspace='perturbed', OutputWorkspacesPrefix='cal_', TofBinning=[300, 1.0, 16666.7], PeakPositions=self.spacings_reference, SourceToSampleDistance=10.0, ComponentList='bank1', FixY=True, ComponentMaxTranslation=0.2, ComponentMaxRotation=10, Minimizer='L-BFGS-B') # Check Y-position of first bank hasn't changed row = mtd['cal_adjustments'].row(1) self.assertAlmostEquals(row['Yposition'], y, places=5) DeleteWorkspaces(['perturbed'])
def test_fix_yaw(self) -> None: CloneWorkspace(InputWorkspace='test_workspace_TOF', OutputWorkspace='perturbed') RotateInstrumentComponent(Workspace='perturbed', ComponentName='bank1', X=0, Y=0, z=1, Angle=5, RelativeRotation=True) r"""Pass option FixYaw=True""" CorelliPowderCalibrationCreate(InputWorkspace='perturbed', OutputWorkspacesPrefix='cal_', TofBinning=[300, 1.0, 16666.7], PeakPositions=self.spacings_reference, SourceToSampleDistance=10.0, ComponentList='bank1', ComponentMaxTranslation=0.2, FixYaw=True, ComponentMaxRotation=10, Minimizer='L-BFGS-B') # Check no change in the rotations around Z-axis of first bank row = mtd['cal_displacements'].row(0) self.assertAlmostEquals(row['DeltaGamma'], 0.0, places=5) DeleteWorkspaces(['perturbed'])
def test_calibrate_bank(self): # control bank, it has no problems. Thus, no mask to be created calibration, mask = calibrate_bank(self.cases['123455_bank20'], 'bank20', 'calibration_table') assert calibration.rowCount() == 256 * 16 assert calibration.columnCount() == 3 assert AnalysisDataService.doesExist('calibration_table') assert mask is None assert AnalysisDataService.doesExist('MaskTable') is False # tubes 3, 8, and 13 have very faint wire shadows. Thus, mask these tubes calibration, mask = calibrate_bank(self.cases['124023_bank14'], 'bank14', calibration_table='calibration_table') assert calibration.rowCount() == 256 * (16 - 3) assert calibration.columnCount() == 2 # Detector ID, Position assert AnalysisDataService.doesExist('calibration_table') assert mask.rowCount() == 256 * 3 assert mask.columnCount() == 1 assert AnalysisDataService.doesExist('MaskTable') # check for the summary workspace calibrate_bank(self.cases['123455_bank20'], 'bank20', 'calibration_table', criterium_kwargs=dict(summary='summary')) assert AnalysisDataService.doesExist('summary') workspace = mtd['summary'] axis = workspace.getAxis(1) assert [axis.label(workspace_index) for workspace_index in (0, 1, 2)] == ['success', 'deviation', 'Z-score'] self.assertEqual(min(workspace.readY(0)), 1.0) self.assertAlmostEqual(max(workspace.readY(2)), 1.728, delta=0.001) DeleteWorkspaces(['calibration_table', 'MaskTable', 'summary']) # a bit of clean-up
def norm(sample, blank, masks): """ Normalise the neutron polarisation on a tube by tube basis Parameters ---------- sample: string The name of the sample to be normalised. The individual tubes are assumed to be in workspaces with names like sample_2 blank: string The name of the blank to be normalised agains. The individual tubes are assumed to be in workspaces with names like blank_2 masks: list of string The file names for the masks used for the individual tubes. """ for t, _ in enumerate(masks): wtemp = mtd[sample + "_{}".format(t)] / \ mtd[blank + "_{}".format(t)] y = mtd[blank + "_{}".format(t)].extractY() e = wtemp.extractE() e[np.abs(y) < 0.2] *= 1e9 wtemp.setE(0, e[0]) RenameWorkspace("wtemp", sample + "_{}_norm".format(t)) wtemp = WeightedMean(sample + "_0_norm", sample + "_1_norm") for tube in range(2, len(masks)): wtemp = WeightedMean(wtemp, sample + "_{}_norm".format(tube)) RenameWorkspace(wtemp, OutputWorkspace=sample + "_Norm") DeleteWorkspaces( ["{}_{}_norm".format(sample, tube) for tube, _ in enumerate(masks)])
def test_extract_peak_info(self): test_single_strain = diagnostics.extract_peak_info( 'strain', 'test_single_strain', self.PEAK) result = CompareWorkspaces(test_single_strain, "single_strain", Tolerance=1e-6) self.assertTrue(result) DeleteWorkspaces(test_single_strain, result) test_single_diff = diagnostics.extract_peak_info( 'difference', 'test_single_diff', self.PEAK) result = CompareWorkspaces(test_single_diff, "single_diff", Tolerance=1e-6) self.assertTrue(result) DeleteWorkspaces(test_single_diff, result)
def test_collect_fit_result(self): test_center = diagnostics.collect_fit_result('diag_fitparam', 'test_center', [self.PEAK], infotype='centre') result = CompareWorkspaces(test_center, "center_tof", Tolerance=1e-6) self.assertTrue(result) DeleteWorkspaces(test_center, result)
def test_collect_bank_fit_results(self): def spectra_labels(workspace_name): workspace = mtd[str(workspace_name)] axis = workspace.getAxis(1) return [axis.label(spectrum_index) for spectrum_index in range(workspace.getNumberHistograms())] fit_bank(self.cases['123455_bank20'], 'bank20', parameters_table_group='parameters_tables') criterion_peak_vertical_position('PeakTable', summary='summary', zscore_threshold=2.5, deviation_threshold=0.0035) with self.assertRaises(AssertionError) as exception_info: collect_bank_fit_results('fit_results', acceptance_summary=None, parameters_table_group=None) assert 'fit results should be different than None' in str(exception_info.exception) # collect only the acceptance criteria results collect_bank_fit_results('fit_results', acceptance_summary='summary', parameters_table_group=None) assert spectra_labels('fit_results') == ['success', 'deviation', 'Z-score'] assert_allclose(mtd['fit_results'].readY(0), mtd['summary'].readY(0)) DeleteWorkspaces(['fit_results']) # collect only the polynomial coefficients collect_bank_fit_results('fit_results', acceptance_summary=None, parameters_table_group='parameters_tables') assert spectra_labels('fit_results') == ['A0', 'A1', 'A2'] for coefficient_idx in range(3): # we have three polynomial coefficients for tube_idx in range(TUBES_IN_BANK): self.assertAlmostEqual(mtd['fit_results'].readY(coefficient_idx)[tube_idx], mtd[f'parameters_tables_{tube_idx}'].row(coefficient_idx)['Value'], delta=1e-6) self.assertAlmostEqual(mtd['fit_results'].readE(coefficient_idx)[tube_idx], mtd[f'parameters_tables_{tube_idx}'].row(coefficient_idx)['Error'], delta=1e-6) DeleteWorkspaces(['fit_results']) # collect both acceptance criteria and polynomial coefficients collect_bank_fit_results('fit_results', acceptance_summary='summary', parameters_table_group='parameters_tables') assert spectra_labels('fit_results') == ['success', 'deviation', 'Z-score', 'A0', 'A1', 'A2'] for spectrum_idx in [0, 1, 2]: assert_allclose(mtd['fit_results'].readY(spectrum_idx), mtd['summary'].readY(spectrum_idx)) assert_allclose(mtd['fit_results'].readE(spectrum_idx), mtd['summary'].readE(spectrum_idx)) for coefficient_idx, spectrum_idx in [(0, 3), (1, 4), (2, 5)]: # we have three polynomial coefficients for tube_idx in range(TUBES_IN_BANK): self.assertAlmostEqual(mtd['fit_results'].readY(spectrum_idx)[tube_idx], mtd[f'parameters_tables_{tube_idx}'].row(coefficient_idx)['Value'], delta=1e-6) self.assertAlmostEqual(mtd['fit_results'].readE(spectrum_idx)[tube_idx], mtd[f'parameters_tables_{tube_idx}'].row(coefficient_idx)['Error'], delta=1e-6) DeleteWorkspaces(['CalibTable', 'fit_results', 'parameters_tables', 'PeakTable', 'PeakYTable', 'summary'])
def performOperation(self): lhs_valid, rhs_valid, err_msg = self.validateInputs() if err_msg != str(): return lhs_valid, rhs_valid, err_msg lhs_ws, rhs_ws = self._scale_input_workspaces() try: if self._operation == '+': if self._md_lhs or self._md_rhs: PlusMD(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) else: Plus(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) elif self._operation == '-': if self._md_lhs or self._md_rhs: MinusMD(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) else: Minus(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) elif self._operation == '*': if self._md_lhs or self._md_rhs: MultiplyMD(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) else: Multiply(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) elif self._operation == 'WM': if self._md_lhs or self._md_rhs: WeightedMeanMD(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) else: WeightedMean(InputWorkspace1=lhs_ws, InputWorkspace2=rhs_ws, OutputWorkspace=self._output_ws) else: if self._md_lhs or self._md_rhs: DivideMD(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) else: Divide(LHSWorkspace=lhs_ws, RHSWorkspace=rhs_ws, OutputWorkspace=self._output_ws) except (RuntimeError, ValueError) as err: return False, False, str(err) else: self._regularize_output_names(self._output_ws) finally: DeleteWorkspaces(WorkspaceList=[lhs_ws, rhs_ws]) return True, True, ""
def tearDownClass(cls): """ Remove workspaces from ADS. """ DeleteWorkspaces([ 'sample_ws', 'can_ws', 'corrections_ws', 'fws_corrections_ass', 'fws_corrections', 'fapi' ])
def test_new_corelli_calibration_and_load_calibration(self): r"""Creating a database is time consuming, thus we test both new_corelli_calibration and load_calibration""" # populate a calibration database with a few cases. There should be at least one bank with two calibrations database = tempfile.TemporaryDirectory() cases = [('124016_bank10', '10'), ('124023_bank10', '10'), ('124023_banks_14_15', '14-15')] for bank_case, bank_selection in cases: # Produce workspace groups 'calibrations', 'masks', 'fits' calibrate_banks(self.cases[bank_case], bank_selection) masks = 'masks' if AnalysisDataService.doesExist('masks') else None save_calibration_set(self.cases[bank_case], database.name, 'calibrations', masks, 'fits') DeleteWorkspaces(['calibrations', 'fits']) if AnalysisDataService.doesExist('masks'): DeleteWorkspaces(['masks']) # invoque creation of new corelli calibration without a date calibration_file, mask_file, manifest_file = new_corelli_calibration(database.name) for file_path in (calibration_file, mask_file, manifest_file): assert path.exists(file_path) assert open(manifest_file).read() == 'bankID, timestamp\n10, 20200109\n14, 20200109\n15, 20200109\n' # load latest calibration and mask (day-stamp of '124023_bank10' is 20200109) calibration, mask = load_calibration_set(self.cases['124023_bank10'], database.name, mask_format='TableWorkspace') calibration_expected = LoadNexusProcessed(Filename=calibration_file) mask_expected = LoadNexusProcessed(Filename=mask_file) assert_allclose(calibration.column(1), calibration_expected.column(1), atol=1e-4) assert mask.column(0) == mask_expected.column(0) # invoque a new corelli calibration with a date falling in between the bank (bank10) in # in our small dataset having two calibrations calibration_file, mask_file, manifest_file = new_corelli_calibration(database.name, date='20200108') for file_path in (calibration_file, mask_file, manifest_file): assert path.exists(file_path) assert open(manifest_file).read() == 'bankID, timestamp\n10, 20200106\n' # load oldest calibration and mask(day-stamp of '124023_bank10' is 20200106) calibration, mask = load_calibration_set(self.cases['124016_bank10'], database.name, mask_format='TableWorkspace') calibration_expected = LoadNexusProcessed(Filename=calibration_file) mask_expected = LoadNexusProcessed(Filename=mask_file) assert_allclose(calibration.column(1), calibration_expected.column(1), atol=1e-4) assert mask.column(0) == mask_expected.column(0) database.cleanup()
def runTest(self): ws_name = 'MultiFilePredictPeaksIntegrate' HB3AAdjustSampleNorm( Filename="HB3A_exp0724_scan0182.nxs, HB3A_exp0724_scan0183.nxs", NormaliseBy='None', OutputWorkspace=ws_name + '_data') HB3APredictPeaks(InputWorkspace=ws_name + "_data", OutputWorkspace=ws_name + "_peaks") peaks = mtd[ws_name + "_peaks"] self.assertEqual(peaks.getNumberOfEntries(), 2) HB3AIntegratePeaks(InputWorkspace=ws_name + '_data', PeaksWorkspace=ws_name + '_peaks', PeakRadius=0.25, OutputWorkspace=ws_name + '_integrated') integrated = mtd[ws_name + '_integrated'] self.assertEqual( peaks.getItem(0).getNumberPeaks() + peaks.getItem(1).getNumberPeaks(), integrated.getNumberPeaks()) # Should be the same as the UB from the data ol = integrated.sample().getOrientedLattice() self.assertDelta(ol.a(), 5.238389802, 1.e-7) self.assertDelta(ol.b(), 5.238415883, 1.e-7) self.assertDelta(ol.c(), 19.65194598, 1.e-7) self.assertDelta(ol.alpha(), 89.9997207, 1.e-7) self.assertDelta(ol.beta(), 89.9997934, 1.e-7) self.assertDelta(ol.gamma(), 89.9999396, 1.e-7) peak0 = integrated.getPeak(0) self.assertEqual(peak0.getH(), 0) self.assertEqual(peak0.getK(), 0) self.assertEqual(peak0.getL(), -11) self.assertEqual(peak0.getRunNumber(), 182) self.assertAlmostEqual(peak0.getWavelength(), 1.008, places=5) self.assertAlmostEqual(peak0.getIntensity(), 127.20005, places=5) self.assertEqual(peak0.getBinCount(), 0) peak1 = integrated.getPeak(integrated.getNumberPeaks() - 1) self.assertEqual(peak1.getH(), 5) self.assertEqual(peak1.getK(), 0) self.assertEqual(peak1.getL(), 1) self.assertEqual(peak1.getRunNumber(), 183) self.assertAlmostEqual(peak1.getWavelength(), 1.008, places=5) self.assertAlmostEqual(peak1.getIntensity(), 66.0945249, places=5) self.assertEqual(peak1.getBinCount(), 0) DeleteWorkspaces( [ws_name + '_data', ws_name + '_peaks', ws_name + '_integrated'])
def test_calibrate_banks(self): calibrations, masks = calibrate_banks(self.cases['124023_banks_14_15'], '14-15') assert list(calibrations.getNames()) == ['calib14', 'calib15'] assert list(masks.getNames()) == ['mask14'] assert mtd['calib14'].rowCount() == 256 * (16 - 3) assert mtd['mask14'].rowCount() == 256 * 3 assert mtd['calib15'].rowCount() == 256 * 16 self.assertEqual(mtd['acceptance14'].readY(0).tolist(), [1, 1, 0., 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1]) self.assertEqual(mtd['acceptance15'].readY(0).tolist(), [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) DeleteWorkspaces(['calibrations', 'masks', 'acceptances'])
def runTest(self): ws_name = 'MultiFileFindPeaksIntegrate' HB3AAdjustSampleNorm( Filename="HB3A_exp0724_scan0182.nxs, HB3A_exp0724_scan0183.nxs", NormaliseBy='None', OutputWorkspace=ws_name + '_data') HB3AFindPeaks(InputWorkspace=ws_name + '_data', CellType="Orthorhombic", Centering="F", OutputWorkspace=ws_name + '_peaks') peaks = mtd[ws_name + '_peaks'] self.assertEqual(peaks.getNumberOfEntries(), 2) HB3AIntegratePeaks(InputWorkspace=ws_name + '_data', PeaksWorkspace=ws_name + '_peaks', PeakRadius=0.25, OutputWorkspace=ws_name + '_integrated') integrated = mtd[ws_name + '_integrated'] self.assertEqual( peaks.getItem(0).getNumberPeaks() + peaks.getItem(1).getNumberPeaks(), integrated.getNumberPeaks()) ol = integrated.sample().getOrientedLattice() self.assertDelta(ol.a(), 5.261051697, 1.e-7) self.assertDelta(ol.b(), 5.224167511, 1.e-7) self.assertDelta(ol.c(), 19.689643636, 1.e-7) self.assertEqual(ol.alpha(), 90) self.assertEqual(ol.beta(), 90) self.assertEqual(ol.gamma(), 90) peak0 = integrated.getPeak(0) self.assertEqual(peak0.getH(), 0) self.assertEqual(peak0.getK(), 0) self.assertEqual(peak0.getL(), 10) self.assertEqual(peak0.getRunNumber(), 182) self.assertAlmostEqual(peak0.getWavelength(), 1.008, places=5) self.assertAlmostEqual(peak0.getIntensity(), 6581.5580392, places=5) self.assertEqual(peak0.getBinCount(), 827) peak1 = integrated.getPeak(integrated.getNumberPeaks() - 1) self.assertEqual(peak1.getH(), 0) self.assertEqual(peak1.getK(), 4) self.assertEqual(peak1.getL(), 0) self.assertEqual(peak1.getRunNumber(), 183) self.assertAlmostEqual(peak1.getWavelength(), 1.008, places=5) self.assertAlmostEqual(peak1.getIntensity(), 11853.7538139, places=5) self.assertEqual(peak1.getBinCount(), 134) DeleteWorkspaces( [ws_name + '_data', ws_name + '_peaks', ws_name + '_integrated'])