def test_algorithm_uses_right_fit_window(self):
x_val = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
y_val = [0, 0, 0, 0, 1, 7, 0, 0, 0, 0, 10, 7]
ws = CreateWorkspace(x_val * 2, y_val + [0] * len(y_val), NSpec=2)
table = CreateEmptyTableWorkspace()
table.addColumn("float", "Centre")
table.addRow([20])
with mock.patch(
'plugins.algorithms.WorkflowAlgorithms.FitGaussianPeaks.FitGaussianPeaks.'
'estimate_single_parameters') as mock_estimate_params:
mock_estimate_params.return_value = None
FitGaussianPeaks(InputWorkspace=ws,
PeakGuessTable=table,
EstimateFitWindow=False,
FitWindowSize=11)
centre_index = 10
# win_size is ( FitWindowSize -1)/2 as method estimate_single_parameters expects in this form
win_size = 5
arguements = mock_estimate_params.call_args_list[0][0]
self.assertSequenceEqual(list(arguements[0]), x_val)
self.assertSequenceEqual(list(arguements[1]), y_val)
self.assertEqual(arguements[2], centre_index)
self.assertEqual(arguements[3], win_size)
self.assertEqual(len(arguements), 4)
def test_algorithm_estimates_fit_window(self):
x_val = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
y_val = [0, 0, 0, 0, 1, 7, 0, 0, 0, 0, 10, 7]
ws = CreateWorkspace(x_val * 2, y_val + [0] * len(y_val), NSpec=2)
table = CreateEmptyTableWorkspace()
table.addColumn("float", "Centre")
table.addRow([20])
with mock.patch(
'plugins.algorithms.WorkflowAlgorithms.FitGaussianPeaks.FitGaussianPeaks.'
'estimate_single_parameters') as mock_estimate_params:
mock_estimate_params.return_value = None
FitGaussianPeaks(InputWorkspace=ws,
PeakGuessTable=table,
EstimateFitWindow=True,
FitWindowSize=11)
centre_index = 10
"""
win_size in this case is calculated from EstimatePeakSigma and is estimated to be 2 and FitWindowSize
is ignored
"""
win_size = 2
arguements = mock_estimate_params.call_args_list[0][0]
self.assertSequenceEqual(list(arguements[0]), x_val)
self.assertSequenceEqual(list(arguements[1]), y_val)
self.assertEqual(arguements[2], centre_index)
self.assertEqual(arguements[3], win_size)
self.assertEqual(len(arguements), 4)
def trim_calibration_table(input_workspace: InputTable, output_workspace: Optional[str] = None) -> TableWorkspace:
r"""
Discard trim the X and Z pixel coordinates, since we are only interested in the calibrated Y-coordinate
:param input_workspace:
:param output_workspace:
:return: handle to the trimmed table workspace
"""
if output_workspace is None:
output_workspace = str(input_workspace) # overwrite the input table
# Extract detector ID's and Y-coordinates from the input table
table = mtd[str(input_workspace)]
detector_ids = table.column(0)
y_coordinates = [v.Y() for v in table.column(1)]
# create the (empty) trimmed table
table_trimmed = CreateEmptyTableWorkspace(OutputWorkspace=output_workspace)
table_trimmed.addColumn(type='int', name='Detector ID')
table_trimmed.addColumn(type='double', name='Detector Y Coordinate')
# fill the rows of the trimmed table
for detector_id, y_coordinate in zip(detector_ids, y_coordinates):
table_trimmed.addRow([detector_id, y_coordinate])
return table_trimmed
def _create_indexed_workspace(self, fractional_peaks, ndim, hklm):
# Create table with the number of columns we need
indexed = CreateEmptyTableWorkspace()
names = fractional_peaks.getColumnNames()
types = fractional_peaks.columnTypes()
# Insert the extra columns for the addtional indicies
for i in range(ndim - 3):
names.insert(5 + i, 'm{}'.format(i + 1))
types.insert(5 + i, 'double')
names = np.array(names)
types = np.array(types)
# Create columns in the table workspace
for name, column_type in zip(names, types):
indexed.addColumn(column_type, name)
# Copy all columns from original workspace, ignoring HKLs
column_data = []
idx = np.arange(0, names.size)
hkl_mask = (idx < 5) | (idx > 4 + (ndim - 3))
for name in names[hkl_mask]:
column_data.append(fractional_peaks.column(name))
# Insert the addtional HKL columns into the data
for i, col in enumerate(hklm.T.tolist()):
column_data.insert(i + 2, col)
# Insert the columns into the table workspace
for i in range(fractional_peaks.rowCount()):
row = [column_data[j][i] for j in range(indexed.columnCount())]
indexed.addRow(row)
return indexed
def generate_peak_guess_table(self, xvals, peakids):
peak_table = CreateEmptyTableWorkspace(StoreInADS=False)
peak_table.addColumn(type='float', name='centre')
for peak_idx in sorted(peakids):
peak_table.addRow([xvals[peak_idx]])
return peak_table
def PyExec(self):
self.workspace = self.getProperty("InputWorkspace").value
outws_name = self.getPropertyValue("OutputWorkspace")
# create table and columns
outws = CreateEmptyTableWorkspace(OutputWorkspace=outws_name)
columns = ["PeakCentre", "PeakCentreError", "Sigma", "SigmaError", "Height", "HeightError", "chiSq"]
nextrow = dict.fromkeys(["WorkspaceIndex"] + columns + ["FitStatus"])
outws.addColumn(type="int", name="WorkspaceIndex", plottype=1) # x
for col in columns:
outws.addColumn(type="double", name=col)
outws.addColumn(type="str", name="FitStatus")
nb_hist = self.workspace.getNumberHistograms()
for idx in range(nb_hist):
nextrow["WorkspaceIndex"] = idx
result = self.do_fit_gaussian(idx)
if not result:
for col in columns:
nextrow[col] = 0
nextrow["FitStatus"] = "failed"
else:
nextrow["FitStatus"] = result[0]
nextrow["chiSq"] = result[1]
ptable = result[3]
for num in range(ptable.rowCount() - 1):
row = ptable.row(num)
name = row["Name"]
nextrow[name] = row["Value"]
nextrow[name+"Error"] = row["Error"]
DeleteWorkspace(result.OutputParameters)
DeleteWorkspace(result.OutputNormalisedCovarianceMatrix)
outws.addRow(nextrow)
self.setProperty("OutputWorkspace", outws)
return
def readCalibrationFile(table_name, in_path):
"""Read a calibration table from file
This loads a calibration TableWorkspace from a CSV file.
Example of usage:
.. code-block:: python
saveCalibration('CalibTable','/tmp/myCalibTable.txt')
:param table_name: name to call the TableWorkspace
:param in_path: the path to the calibration file
"""
DET = 'Detector ID'
POS = 'Detector Position'
re_float = re.compile(r"[+-]? *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?")
calibTable = CreateEmptyTableWorkspace(OutputWorkspace=table_name)
calibTable.addColumn(type='int', name=DET)
calibTable.addColumn(type='V3D', name=POS)
with open(in_path, 'r') as file_p:
for line in file_p:
values = re.findall(re_float, line)
if len(values) != 4:
continue
nextRow = {
DET: int(values[0]),
POS: V3D(float(values[1]), float(values[2]), float(values[3]))
}
calibTable.addRow(nextRow)
def test_sample_tof(self):
# creates table workspace with mock elastic peak positions and widths:
table_ws = CreateEmptyTableWorkspace()
table_ws.addColumn("float", "PeakCentre")
table_ws.addColumn("float", "Sigma")
for row in range(132):
table_ws.addRow([1645.2, 15.0])
sampleProperties = {
'SampleMass': 2.93,
'FormulaUnitMass': 50.94,
'EPWidth': 15
}
yig_calibration_file = "D7_YIG_calibration_TOF.xml"
PolDiffILLReduction(Run='395639',
ProcessAs='Sample',
OutputWorkspace='sample_tof',
SampleAndEnvironmentProperties=sampleProperties,
SampleGeometry='None',
OutputTreatment='Individual',
InstrumentCalibration=yig_calibration_file,
ElasticChannelsWorkspace='table_ws',
MeasurementTechnique='TOF')
self._check_output(mtd['sample_tof'], 339, 132, 2, 'Energy transfer',
'DeltaE', 'Spectrum', 'Label')
self._check_process_flag(mtd['sample_tof'], 'Sample')
def setUp(self):
# Creating two peaks on an exponential background with gaussian noise
self.x_values = np.linspace(0, 100, 1001)
self.centre = [25, 75]
self.height = [35, 20]
self.width = [10, 5]
self.y_values = self.gaussian(self.x_values, self.centre[0],
self.height[0], self.width[0])
self.y_values += self.gaussian(self.x_values, self.centre[1],
self.height[1], self.width[1])
self.background = 10 * np.ones(len(self.x_values))
# Generating a table with a guess of the position of the centre of the peaks
peak_table = CreateEmptyTableWorkspace()
peak_table.addColumn(type='float', name='Approximated Centre')
peak_table.addRow([self.centre[0] + 2])
peak_table.addRow([self.centre[1] - 3])
# Generating a workspace with the data and a flat background
data_ws = CreateWorkspace(
DataX=np.concatenate((self.x_values, self.x_values)),
DataY=np.concatenate((self.y_values, self.background)),
DataE=np.sqrt(np.concatenate((self.y_values, self.background))),
NSpec=2)
self.data_ws = data_ws
self.peak_guess_table = peak_table
self.alg_instance = _FitGaussianPeaks.FitGaussianPeaks()
self.alg_instance.initialize()
def readCalibrationFile(table_name, in_path):
"""Read a calibration table from file
This loads a calibration TableWorkspace from a CSV file.
Example of usage:
.. code-block:: python
saveCalibration('CalibTable','/tmp/myCalibTable.txt')
:param table_name: name to call the TableWorkspace
:param in_path: the path to the calibration file
"""
DET = 'Detector ID'
POS = 'Detector Position'
re_float = re.compile(r"[+-]? *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?")
calibTable = CreateEmptyTableWorkspace(OutputWorkspace=table_name)
calibTable.addColumn(type='int', name=DET)
calibTable.addColumn(type='V3D', name=POS)
with open(in_path, 'r') as file_p:
for line in file_p:
values = re.findall(re_float, line)
if len(values) != 4:
continue
nextRow = {
DET: int(values[0]),
POS: V3D(float(values[1]), float(values[2]), float(values[3]))
}
calibTable.addRow(nextRow)
def _createFakePeakPositionTable(self, peakPos):
"""Create a peak position TableWorkspace with a single column for peakPos."""
tableName = self._names.withSuffix('peak_position_table')
table = CreateEmptyTableWorkspace(OutputWorkspace=tableName,
EnableLogging=self._subalgLogging)
table.addColumn('double', 'PeakCentre')
table.addRow((peakPos, ))
return table
def _createFakePeakPositionTable(self, peakPos):
"""Create a peak position TableWorkspace with a single column for peakPos."""
tableName = self._names.withSuffix('peak_position_table')
table = CreateEmptyTableWorkspace(OutputWorkspace=tableName,
EnableLogging=self._subalgLogging)
table.addColumn('double', 'PeakCentre')
table.addRow((peakPos,))
return table
def test_gui_updated_when_row_added_from_sequence(self):
ws = CreateEmptyTableWorkspace()
ws.addColumn("double", "l")
presenter = TableWorkspaceDisplay(ws)
current_rows = presenter.view.rowCount()
ws.addRow([1.0])
self.assertEqual(current_rows + 1, presenter.view.rowCount())
def test_gui_updated_when_row_added_from_dictionary(self):
ws = CreateEmptyTableWorkspace()
ws.addColumn("double", "test_col")
presenter = TableWorkspaceDisplay(ws)
current_rows = presenter.view.rowCount()
ws.addRow({'test_col': 1.0})
self.assertEqual(current_rows + 1, presenter.view.rowCount())
def create_output_table(centre1, centre2):
Centre_position = CreateEmptyTableWorkspace()
Centre_position.addColumn(type="double", name="X Centre Position")
Centre_position.addColumn(type="double", name="Y Centre Position")
Centre_position.addRow({
"X Centre Position": centre1,
"Y Centre Position": centre2
})
def test_gui_updated_when_row_added_from_dictionary_batch(self):
ws = CreateEmptyTableWorkspace()
ws.addColumn("double", "test_col")
presenter = TableWorkspaceDisplay(ws, batch=True)
current_rows = presenter.view.rowCount()
ws.addRow({'test_col': 1.0})
self.assertEqual(current_rows + 1, presenter.view.model().max_rows())
presenter.close(ws.name())
def test_gui_updated_when_row_added_from_sequence_standard(self):
ws = CreateEmptyTableWorkspace()
ws.addColumn("double", "l")
presenter = TableWorkspaceDisplay(ws, batch=False)
current_rows = presenter.view.rowCount()
ws.addRow([1.0])
self.assertEqual(current_rows + 1, presenter.view.model().rowCount())
presenter.close(ws.name())
def correctMisalignedTubes(ws, calibrationTable, peaksTable, spec, idealTube,
fitPar, threshold=10):
""" Correct misaligned tubes due to poor fitting results
during the first round of calibration.
Misaligned tubes are first identified according to a tolerance
applied to the absolute difference between the fitted tube
positions and the mean across all tubes.
The FindPeaks algorithm is then used to find a better fit
with the ideal tube positions as starting parameters
for the peak centers.
From the refitted peaks the positions of the detectors in the
tube are recalculated.
@param ws: the workspace to get the tube geometry from
@param calibrationTable: the calibration table ouput from running
calibration
@param peaksTable: the table containing the fitted peak centers from
calibration
@param spec: the tube spec for the instrument
@param idealTube: the ideal tube for the instrument
@param fitPar: the fitting parameters for calibration
@param threshold: tolerance defining is a peak is outside of the acceptable
range
@return table of corrected detector positions
"""
table_name = calibrationTable.name() + 'Corrected'
corrections_table = CreateEmptyTableWorkspace(OutputWorkspace=table_name)
corrections_table.addColumn('int', "Detector ID")
corrections_table.addColumn('V3D', "Detector Position")
mean_peaks, bad_tubes = findBadPeakFits(peaksTable, threshold)
for index in bad_tubes:
print("Refitting tube %s" % spec.getTubeName(index))
tube_dets, _ = spec.getTube(index)
getPoints(ws, idealTube.getFunctionalForms(), fitPar, tube_dets)
tube_ws = mtd['TubePlot']
fit_ws = FindPeaks(InputWorkspace=tube_ws, WorkspaceIndex=0,
PeakPositions=fitPar.getPeaks(),
PeaksList='RefittedPeaks')
centers = [row['centre'] for row in fit_ws]
detIDList, detPosList = \
getCalibratedPixelPositions(ws, centers, idealTube.getArray(),
tube_dets)
for id, pos in zip(detIDList, detPosList):
corrections_table.addRow({'Detector ID': id,
'Detector Position': V3D(*pos)})
cleanUpFit()
return corrections_table
def test_gui_updated_when_row_added_from_dictionary_standard(self):
ws = CreateEmptyTableWorkspace()
ws.addColumn("double", "test_col")
presenter = TableWorkspaceDisplay(ws, batch=False)
presenter.model.block_model_replace = False
current_rows = presenter.view.rowCount()
ws.addRow({'test_col': 1.0})
self.assertEqual(current_rows + 1, presenter.view.model().rowCount())
presenter.close(ws.name())
def generateCropingTable(qmin, qmax):
mask_info = CreateEmptyTableWorkspace()
mask_info.addColumn("str", "SpectraList")
mask_info.addColumn("double", "XMin")
mask_info.addColumn("double", "XMax")
for (i, value) in enumerate(qmin):
mask_info.addRow([str(i), 0.0, value])
for (i, value) in enumerate(qmax):
mask_info.addRow([str(i), value, 100.0])
return mask_info
def test_ion_table(self):
ws = DensityOfStates(File=self._file_name, SpectrumType='IonTable')
# Build the expected output
expected = CreateEmptyTableWorkspace()
expected.addColumn('str', 'Ion')
expected.addColumn('int', 'Count')
expected.addRow(['H', 4])
expected.addRow(['C', 8])
expected.addRow(['O', 8])
self.assertEquals(CheckWorkspacesMatch(ws, expected), 'Success!')
def test_ion_table(self):
ws = SimulatedDensityOfStates(File=self._file_name, SpectrumType='IonTable')
# Build the expected output
expected = CreateEmptyTableWorkspace()
expected.addColumn('str', 'Ion')
expected.addColumn('int', 'Count')
expected.addRow(['H', 4])
expected.addRow(['C', 8])
expected.addRow(['O', 8])
self.assertEquals(CheckWorkspacesMatch(ws, expected), 'Success!')
def parameters_optimized_table(table_name, values=None, errors=None):
table = CreateEmptyTableWorkspace(OutputWorkspace=table_name)
for column_type, column_name in [('str', 'Name'),
('float', 'Value'),
('float', 'Error')]:
table.addColumn(type=column_type, name=column_name)
if values is not None and errors is not None:
assert len(values) == 4 and len(
errors) == 4 # A0, A1, A2, 'Cost function value'
for index, row_name in enumerate(
['A0', 'A1', 'A2', 'Cost function value']):
table.addRow([row_name, values[index], errors[index]])
return table
def _generate_props_table(self):
"""
Creates a table workspace with values calculated in algorithm.
"""
props_table = CreateEmptyTableWorkspace(OutputWorkspace=self._props_output_workspace)
props_table.addColumn('int', 'NegativeXMinIndex')
props_table.addColumn('int', 'PositiveXMinIndex')
props_table.addColumn('int', 'PositiveXMaxIndex')
props_table.addRow([int(self._negative_min_index), int(self._positive_min_index), int(self._positive_max_index)])
self.setProperty('OutputPropertiesTable', self._props_output_workspace)
def test_algorithm_does_not_throw_an_error_when_no_valid_peaks_fitted(
self):
x_val = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
y_val = [0, 0, 0, 0, 1, 7, 0, 0, 0, 0, 10, 7]
ws = CreateWorkspace(x_val * 2, y_val + [0] * len(y_val), NSpec=2)
table = CreateEmptyTableWorkspace()
table.addColumn("float", "Centre")
table.addRow([20])
FitGaussianPeaks(InputWorkspace=ws, PeakGuessTable=table)
self.assertEqual(mtd["peak_table"].rowCount(), 0)
self.assertEqual(mtd["refit_peak_table"].rowCount(), 0)
def _generate_props_table(self):
"""
Creates a table workspace with values calculated in algorithm.
"""
props_table = CreateEmptyTableWorkspace(OutputWorkspace=self._props_output_workspace)
props_table.addColumn('int', 'NegativeXMinIndex')
props_table.addColumn('int', 'PositiveXMinIndex')
props_table.addColumn('int', 'PositiveXMaxIndex')
props_table.addRow([int(self._negative_min_index), int(self._positive_min_index), int(self._positive_max_index)])
self.setProperty('OutputPropertiesTable', self._props_output_workspace)
def test_find_good_peaks_calls_fit_gaussian_peaks_twice_if_no_peaks_given(self):
with mock.patch('plugins.algorithms.WorkflowAlgorithms.FindPeaksAutomatic.FitGaussianPeaks'
) as mock_fit:
tmp_table = CreateEmptyTableWorkspace()
tmp_table.addColumn(type='float', name='chi2')
tmp_table.addColumn(type='float', name='poisson')
tmp_table.addRow([10, 20])
mock_fit.return_value = (mock.MagicMock(), mock.MagicMock(), tmp_table)
self.alg_instance.min_sigma = 1
self.alg_instance.max_sigma = 10
self.alg_instance.find_good_peaks(self.x_values, [], 0.1, 5, False, self.data_ws, 5)
self.assertEqual(2, mock_fit.call_count)
def PyExec(self):
d_spacing = self.getProperty("DSpacing").value
temp = self.getProperty("T").value
p_calc = calculate_pressure(d_spacing, temp)
self.log().notice("The calculated pressure is " + str(p_calc) + " GPa")
ws = CreateEmptyTableWorkspace()
ws.addColumn(type='double', name="Input dSpacing-111 (A)")
ws.addColumn(type='double', name="Temperature (K)")
ws.addColumn(type='double', name="Calculated Pressure (GPa)")
p_target = self.getProperty("TargetPressure").value
use_input_target = True
if p_target == 0.0:
use_input_target = False
p_target = p_calc
test_dspacing = np.arange(2, 2.95, 0.0001)
pressure = calculate_pressure(test_dspacing, temp)
diff = abs(pressure - p_target)
index = np.argmin(diff)
diff = diff[index]
if diff < TOL:
found_d = test_dspacing[index]
else:
diff, found_d = 0, 0
if found_d != 0:
if use_input_target:
self.log().notice("Temperature: " + str(temp) + " K")
self.log().notice("Target pressure: " + str(round(p_target, 6)) + " GPa")
self.log().notice("Pressure difference: " + str(round(diff, 6)) + " GPa")
self.log().notice("d(111): " + str(round(found_d, 6)) + " A")
else:
self.log().notice("Temperature: " + str(temp) + " K")
self.log().notice("Target pressure (calculated): " + str(round(p_target, 6)) + " GPa")
self.log().notice("Pressure difference: " + str(round(diff, 6)) + " GPa")
self.log().notice("d(111) : " + str(round(found_d, 6)) + " A")
ws.addColumn(type='double', name="Pressure Target (GPa)")
ws.addColumn(type='double', name="Pressure difference (GPa)")
ws.addColumn(type='double', name="dSpacing found (A)")
row = {"Input dSpacing-111 (A)": d_spacing, "Temperature (K)": temp, "Calculated Pressure (GPa)": p_calc,
"Pressure Target (GPa)": p_target, "Pressure difference (GPa)": diff,
"dSpacing found (A)": found_d}
else:
self.log().notice("dSpacing corresponding to the Target Pressure and Temperature given not found in range"
" 2-2.95. Please try different parameters.")
row = {"Input dSpacing-111 (A)": d_spacing, "Temperature (K)": temp, "Calculated Pressure (GPa)": p_calc}
ws.addRow(row)
self.setProperty("OutputWorkspace", ws)
DeleteWorkspace(ws)
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 peak_pixels_table(table_name,
peak_count,
tube_names=None,
pixel_positions=None):
table = CreateEmptyTableWorkspace(OutputWorkspace=table_name)
table.addColumn(type='str', name='TubeId')
for i in range(peak_count):
table.addColumn(type='float', name='Peak%d' % (i + 1))
if tube_names is not None and pixel_positions is not None:
assert len(tube_names) == len(
pixel_positions
), 'tube_names and pixel_positions have different length'
for tube_index in range(len(tube_names)):
# tube_names is a list of str values; pixel_positions is a list of lists of float values
table.addRow([tube_names[tube_index]] +
pixel_positions[tube_index])
return table
def test_update_match_table_when_table_has_less_than_3_rows(self):
correct_table_entries = ["9999", "Detector 3", "Al , C"]
# Create source tables
likelyhood_table = CreateEmptyTableWorkspace(OutputWorkspace="likelyhood")
likelyhood_table.addColumn("str", "Element")
likelyhood_table.addColumn("int", "Likelihood")
likelyhood_table.addRow(["Al", 20])
likelyhood_table.addRow(["C", 18])
# Run function
self.model.update_match_table("likelyhood", "9999; Detector 3")
# Assert statements
self.assertEqual(self.model.table_entries.get(), correct_table_entries)
# Delete tables from ADS
self.delete_if_present("likelyhood")
def update_calibration_params_table(params_table):
if len(params_table) == 0:
return
# Create blank, or clear rows from existing, params table.
if Ads.doesExist(CALIB_PARAMS_WORKSPACE_NAME):
workspace = Ads.retrieve(CALIB_PARAMS_WORKSPACE_NAME)
workspace.setRowCount(0)
else:
workspace = CreateEmptyTableWorkspace(OutputWorkspace=CALIB_PARAMS_WORKSPACE_NAME)
workspace.addColumn("int", "bankid")
workspace.addColumn("double", "difc")
workspace.addColumn("double", "difa")
workspace.addColumn("double", "tzero")
for row in params_table:
workspace.addRow(row)
def test_trim_calibration_table(self):
# create a table with detector id and detector XYZ positions
table = CreateEmptyTableWorkspace(OutputWorkspace='CalibTable')
table.addColumn(type='int', name='Detector ID')
table.addColumn(type='V3D', name='Detector Position')
table.addRow([0, V3D(0, 1, 2)]) # add two detectors with ID's 0 and 1
table.addRow([1, V3D(3, 4, 5)])
y_values = [1, 4]
# call trim_calibration_table and save to new table
table_calibrated = trim_calibration_table(
table, output_workspace='table_calibrated')
# assert the Y-coordinate hasn't changed
assert_allclose(table_calibrated.column(1), y_values, atol=0.0001)
# call trim_calibration_table and overwrite the table
table_calibrated = trim_calibration_table(table)
assert table_calibrated.name(
) == 'CalibTable' # table workspace has been overwritten with the calibrated one
assert_allclose(table_calibrated.column(1), y_values, atol=0.0001)
def simulate_fit_parameter_output(values, cost):
table = CreateEmptyTableWorkspace()
table.addColumn(type='str', name='Name')
table.addColumn(type='float', name='Value')
table.addColumn(type='float', name='Error')
for i, (val, err) in enumerate(values):
name = ''
if i % 3 == 0:
name = 'centre'
elif i % 3 == 1:
name = 'height'
elif i % 3 == 2:
name = 'sigma'
table.addRow([name, val, err])
return table
def _fixed_source_set_and_table(self, table_name):
r"""Create a table with appropriate column names for saving the location of the source"""
# collect info on the source
input_workspace = self.getPropertyValue(
'InputWorkspace') # name of the input workspace
source = mtd[self.getPropertyValue(
'InputWorkspace')].getInstrument().getSource()
source_name, source_full_name = source.getName(), source.getFullName()
# Update the position of the source
z_position = -abs(self.getProperty('SourceToSampleDistance').value)
MoveInstrumentComponent(input_workspace,
source_full_name,
X=0.0,
Y=0.0,
Z=z_position,
RelativePosition=False)
# Initialize the table of adjustments for the source
table = CreateEmptyTableWorkspace(OutputWorkspace=table_name)
item_types = [
'str', 'double', 'double', 'double', 'double', 'double', 'double',
'double'
]
item_names = [
'ComponentName', 'Xposition', 'Yposition', 'Zposition',
'XdirectionCosine', 'YdirectionCosine', 'ZdirectionCosine',
'RotationAngle'
]
for column_name, column_type in zip(item_names, item_types):
table.addColumn(name=column_name, type=column_type)
# Add the appropriate row in the table for the source
table.addRow([
source_name,
0.0,
0.0,
z_position, # new position for the source
0.0,
0.0,
0.0, # no rotation axis
0.0
]) # no rotation angle
return table
def get_he3_log(path):
"""
Load the ³He log data into Mantid Table named "helium_log"
Parameters
----------
path
A string with the path to the ³He as a tsv file
"""
hetemp = load_helium_file(path)
my_table = CreateEmptyTableWorkspace()
my_table.addColumn("int", "Number")
my_table.addColumn("str", "Cell")
my_table.addColumn("float", "scale")
my_table.addColumn("str", "Start time")
my_table.addColumn("float", "fid")
my_table.addColumn("float", "Time Constant")
for run in hetemp:
my_table.addRow([run.run, run.cell,
run.scale,
run.dt.isoformat(),
run.fid, run.t1])
RenameWorkspace(my_table, "helium_log")
def _create_indexed_workspace(self, fractional_peaks, ndim, hklm):
# Create table with the number of columns we need
types = ['int', 'long64', 'double', 'double', 'double', 'double', 'double', 'double',
'double', 'double', 'double', 'float', 'str', 'float', 'float', 'V3D', 'V3D']
indexed = CreateEmptyTableWorkspace()
names = fractional_peaks.getColumnNames()
# Insert the extra columns for the addtional indicies
for i in range(ndim - 3):
names.insert(5 + i, 'm{}'.format(i + 1))
types.insert(5 + i, 'double')
names = np.array(names)
types = np.array(types)
# Create columns in the table workspace
for name, column_type in zip(names, types):
indexed.addColumn(column_type, name)
# Copy all columns from original workspace, ignoring HKLs
column_data = []
idx = np.arange(0, names.size)
hkl_mask = (idx < 5) | (idx > 4 + (ndim - 3))
for name in names[hkl_mask]:
column_data.append(fractional_peaks.column(name))
# Insert the addtional HKL columns into the data
for i, col in enumerate(hklm.T.tolist()):
column_data.insert(i + 2, col)
# Insert the columns into the table workspace
for i in range(fractional_peaks.rowCount()):
row = [column_data[j][i] for j in range(indexed.columnCount())]
indexed.addRow(row)
return indexed
def PyExec(self):
""" Alg execution. """
instrument = self.getProperty(INSTRUMENT_PROP).value
run_number = self.getProperty(RUN_NUM_PROP).value
fit_deadtime = self.getProperty(FIT_DEADTIME_PROP).value
fix_phases = self.getProperty(FIX_PHASES_PROP).value
default_level = self.getProperty(DEFAULT_LEVEL).value
sigma_looseness = self.getProperty(SIGMA_LOOSENESS_PROP).value
groupings_file = self.getProperty(GROUPINGS_PROP).value
in_phases_file = self.getProperty(PHASES_PROP).value
in_deadtimes_file = self.getProperty(DEADTIMES_PROP).value
out_phases_file = self.getProperty(PHASES_RESULT_PROP).value
out_deadtimes_file = self.getProperty(DEADTIMES_RESULT_PROP).value
isis = config.getFacility('ISIS')
padding = isis.instrument(instrument).zeroPadding(0)
run_name = instrument + str(run_number).zfill(padding)
try:
run_number = int(run_number)
except:
raise RuntimeError("'%s' is not an integer run number." % run_number)
try:
run_file_path = FileFinder.findRuns(run_name)[0]
except:
raise RuntimeError("Unable to find file for run %i" % run_number)
if groupings_file == "":
groupings_file = DEFAULT_GROUPINGS_FILENAME % instrument
# Load data and other info from input files.
def temp_hidden_ws_name():
"""Generate a unique name for a temporary, hidden workspace."""
selection = string.ascii_lowercase + string.ascii_uppercase + string.digits
return '__temp_MaxEnt_' + ''.join(random.choice(selection) for _ in range(20))
input_data_ws_name = temp_hidden_ws_name()
LoadMuonNexus(Filename=run_file_path, OutputWorkspace=input_data_ws_name)
input_data_ws = mtd[input_data_ws_name]
if isinstance(input_data_ws, WorkspaceGroup):
Logger.get("MaxEnt").warning("Multi-period data is not currently supported. Just using first period.")
input_data_ws = input_data_ws[0]
groupings_ws_name = temp_hidden_ws_name()
LoadDetectorsGroupingFile(InputFile=groupings_file, OutputWorkspace=groupings_ws_name)
groupings_ws = mtd[groupings_ws_name]
def yield_floats_from_file(path):
"""Given a path to a file with a float on each line, will return
the floats one at a time. Throws otherwise. Strips whitespace
and ignores empty lines."""
with open(path, 'r') as f:
for i, line in enumerate(line.strip() for line in f):
if line == "":
continue
try:
yield float(line)
except:
raise RuntimeError("Parsing error in '%s': Line %d: '%s'." %
(path, i, line))
input_phases = np.array(list(yield_floats_from_file(in_phases_file)))
input_phases_size = len(input_phases)
input_deadtimes = np.array(list(yield_floats_from_file(in_deadtimes_file)))
input_deadtimes_size = len(input_deadtimes)
n_bins = input_data_ws.blocksize()
n_detectors = input_data_ws.getNumberHistograms()
def time_value_to_time_channel_index(value):
"""Given a time value, will return the index of the time channel in
which the value falls."""
bin_width = input_data_ws.readX(0)[1] - input_data_ws.readX(0)[0]
diff = value - input_data_ws.readX(0)[0]
return int(diff / bin_width)
# Mantid corrects for time zero on loading, so we want to find the actual channels
# where 0.0 occurs, and where we have values of 0.1 onwards.
time_zero_channel = time_value_to_time_channel_index(0.0)
first_good_channel = time_value_to_time_channel_index(0.1)
input_data = np.concatenate([input_data_ws.readY(i) for i in range(n_detectors)])
groupings = [groupings_ws.readY(row)[0] for row in range(groupings_ws.getNumberHistograms())]
groupings = map(int, groupings)
n_groups = len(set(groupings))
# Cleanup.
input_data_ws.delete()
groupings_ws.delete()
# We're faced with the problem of providing more than a dozen parameters to
# the Fortran, which can be a bit messy (especially on the Fortran side of
# things where we need to make "Cf2py" declarations). A cleaner way of
# doing this is to simply pass in a few callbacks -- one for each input
# type -- and have the Fortran provide the name of the variable it wants
# to the callback. The callback will then look up the corresponding value
# and feed it back to the Fortran.
#
# We also have a callback for printing to the results log.
self.int_vars = {
"RunNo" : run_number,
"frames" : FRAMES,
"res" : RES,
"Tzeroch" : time_zero_channel,
"firstgoodch" : first_good_channel,
"ptstofit" : POINTS_TO_FIT,
"histolen" : n_bins,
"nhisto" : n_detectors,
"n_groups" : n_groups,
}
self.float_vars = {
"deflevel" : default_level,
"sigloose" : sigma_looseness,
}
self.bool_vars = {
"fixphase" : fix_phases,
"fitdt" : fit_deadtime,
}
self._assert_map_values_are_of_expected_type()
def lookup(par_name, par_map, default):
"""The basis of the callbacks passed to the Fortran. Given a parameter
name it will consult the appropriate variable map, and return the
corresponding value of the parameter. Else return a default and log a
warning if a parameter with the name does not exist."""
par_name = par_name.strip()
if par_name in par_map:
return par_map[par_name]
msg = """WARNING: tried to find a value for parameter with name %s but
could not find one. Default of \"%s\" provided.""" % (par_name, default)
Logger.get("MaxEnt").warning(msg)
return default
def log(priority, message):
"""Log the given message with given priority."""
try:
logger = getattr(Logger.get("MaxEnt"), priority.lower())
except AttributeError:
# If we don't recognise the priority, use warning() as a default.
logger = getattr(Logger.get("MaxEnt"), "warning")
logger(message)
return True
# The Fortran expects arrays to be of a certain size, so any arrays that
# aren't big enough need to be padded.
input_phases = self._pad_to_length_with_zeros(input_phases, MAX_HISTOS)
input_deadtimes = self._pad_to_length_with_zeros(input_deadtimes, MAX_HISTOS)
input_data = self._pad_to_length_with_zeros(input_data, MAX_INPUT_DATA_SIZE)
groupings = self._pad_to_length_with_zeros(groupings, MAX_HISTOS)
# TODO: Return the contents of "NNNNN.max", instead of writing to file.
f_out, fchan_out, output_deadtimes, output_phases, chi_sq = maxent.mantid_maxent(
# Input data and other info:
input_data,
groupings,
input_deadtimes,
input_phases,
# Variable-lookup callbacks:
lambda par_name: lookup(par_name, self.int_vars, 0),
lambda par_name: lookup(par_name, self.float_vars, 0.0),
lambda par_name: lookup(par_name, self.bool_vars, False),
# Callback for logging:
log
)
def write_items_to_file(path, items):
"""Given a path to a file and a list of items, will write the items
to the file, one on each line."""
with open(path, 'w') as f:
for item in items:
f.write(str(item) + "\n")
# Chop the padded outputs back down to the correct size.
output_phases = output_phases[:input_phases_size]
output_deadtimes = output_deadtimes[:input_deadtimes_size]
input_phases = input_phases[:input_phases_size]
input_deadtimes = input_deadtimes[:input_deadtimes_size]
fchan_out = fchan_out[:n_bins]
f_out = f_out[:n_bins]
write_items_to_file(out_phases_file, output_phases)
write_items_to_file(out_deadtimes_file, output_deadtimes)
log_output = "\nDead times in:\n" + str(input_deadtimes) + "\n" +\
"\nDead times out:\n" + str(output_deadtimes) + "\n" +\
"\nPhases in:\n" + str(input_phases) + "\n" +\
"\nPhases out:\n" + str(output_phases) + "\n" + \
"\nGroupings:\n" + str(groupings) + "\n" +\
"\nChi Squared:\n" + str(chi_sq) + "\n" +\
"\nInput variables:\n"
for type_map in self.int_vars, self.float_vars, self.bool_vars:
for name, value in type_map.items():
log_output += str(name) + " = " + str(value) + "\n"
Logger.get("MaxEnt").notice(log_output)
# Generate our own output ws name if the user has not provided one.
out_ws_name = self.getPropertyValue(OUT_WS_PROP)
if out_ws_name == "":
out_ws_name = run_name + "; MaxEnt"
self.setPropertyValue(OUT_WS_PROP, out_ws_name)
out_ws = CreateWorkspace(OutputWorkspace=out_ws_name,
DataX=fchan_out[:n_bins],
DataY=f_out[:n_bins])
self.setProperty(OUT_WS_PROP, out_ws)
# MaxEnt inputs table.
input_table_name = run_name + "; MaxEnt Input"
input_table = CreateEmptyTableWorkspace(OutputWorkspace = input_table_name)
input_table.addColumn("str", "Name")
input_table.addColumn("str", "Value")
inputs = itertools.chain(self.int_vars.items(),
self.float_vars.items(),
self.bool_vars.items())
for name, value in inputs:
input_table.addRow([str(name), str(value)])
# Deadtimes and phases input/output table.
dead_phases_table_name = run_name + "; MaxEnt Deadtimes & Phases"
dead_phases_table = CreateEmptyTableWorkspace(OutputWorkspace = dead_phases_table_name)
for column_name in "Deadtimes In", "Deadtimes Out", "Phases In", "Phases Out":
dead_phases_table.addColumn("double", column_name)
for row in zip(input_deadtimes, output_deadtimes, input_phases, output_phases):
dead_phases_table.addRow(list(map(float, row)))
# Chi-squared output table.
chisq_table_name = run_name + "; MaxEnt Chi^2"
chisq_table = CreateEmptyTableWorkspace(OutputWorkspace = chisq_table_name)
chisq_table.addColumn("int", "Cycle")
for iteration in range(10):
chisq_table.addColumn("double", "Iter " + str(iteration + 1))
for cycle, data in enumerate(chi_sq):
chisq_table.addRow([cycle + 1] + list(map(float,data)))
all_output_ws = [input_table_name,
dead_phases_table_name,
chisq_table_name,
out_ws_name]
# The output workspaces of this algorithm belong in the same groups
# that are created by the muon interface. If the appropriate group
# doesn't exist already then it needs to be created.
if not run_name in mtd:
GroupWorkspaces(InputWorkspaces = all_output_ws,
OutputWorkspace = run_name)
else:
group = mtd[run_name]
for output_ws in all_output_ws:
if not group.contains(output_ws):
group.add(output_ws)
out_ws.getAxis(0).getUnit().setLabel("Field", "G")
out_ws.setYUnitLabel("P(B)")
if INSIDE_MANTIDPLOT:
mantidplot.plotSpectrum(out_ws, 0)
def testAlignComponentsPositionXY(self):
CreateSampleWorkspace(OutputWorkspace='testWS', NumBanks=1,BankPixelWidth=4)
component='bank1'
MoveInstrumentComponent(Workspace='testWS',ComponentName=component,X=0.06,Y=0.04,Z=4.98,RelativePosition=False)
### Detector should move to [0.05,0.03,4.98]
### Calibration table generated with:
# CreateSampleWorkspace(OutputWorkspace='sample', NumBanks=1,BankPixelWidth=4)
# MoveInstrumentComponent(Workspace='sample',ComponentName='bank1',X=0.05,Y=0.03,Z=4.98,RelativePosition=False)
# CalculateDIFC(InputWorkspace='sample', OutputWorkspace='sample')
# d=mtd['sample'].extractY()
# for i in range(len(d)):
# print "calTable.addRow(["+str(i+16)+", "+str(d[i][0])+"])"
calTable = CreateEmptyTableWorkspace()
calTable.addColumn("int", "detid")
calTable.addColumn("double", "difc")
calTable.addRow([16, 44.3352831346])
calTable.addRow([17, 47.7503426493])
calTable.addRow([18, 51.6581064544])
calTable.addRow([19, 55.9553976608])
calTable.addRow([20, 49.6495672525])
calTable.addRow([21, 52.7214213944])
calTable.addRow([22, 56.285004349])
calTable.addRow([23, 60.2530897937])
calTable.addRow([24, 55.1227558338])
calTable.addRow([25, 57.9048914599])
calTable.addRow([26, 61.1671229038])
calTable.addRow([27, 64.8369848035])
calTable.addRow([28, 60.7118272387])
calTable.addRow([29, 63.2484968666])
calTable.addRow([30, 66.2480051141])
calTable.addRow([31, 69.650545037])
ws = mtd["testWS"]
startPos = ws.getInstrument().getComponentByName(component).getPos()
startRot = ws.getInstrument().getComponentByName(component).getRotation().getEulerAngles()
AlignComponents(CalibrationTable="calTable",
Workspace="testWS",
ComponentList=component,
Xposition=True,
Yposition=True)
ws = mtd["testWS"]
endPos = ws.getInstrument().getComponentByName(component).getPos()
endRot = ws.getInstrument().getComponentByName(component).getRotation().getEulerAngles()
self.assertAlmostEqual(endPos.getX(), 0.05)
self.assertAlmostEqual(endPos.getY(), 0.03)
self.assertEqual(startPos.getZ(), endPos.getZ())
self.assertEqual(startRot[0], endRot[0])
self.assertEqual(startRot[1], endRot[1])
self.assertEqual(startRot[2], endRot[2])
def testAlignComponentsRotationY(self):
CreateSampleWorkspace(OutputWorkspace='testWS', NumBanks=1,BankPixelWidth=4)
component='bank1'
MoveInstrumentComponent(Workspace='testWS',ComponentName=component,X=2.00,Y=0,Z=2.00,RelativePosition=False)
RotateInstrumentComponent(Workspace='testWS',ComponentName='bank1',X=0,Y=1,Z=0,Angle=50,RelativeRotation=False)
### Detector should rotate to +45deg around Y
### Calibration table generated with:
# CreateSampleWorkspace(OutputWorkspace='sample2', NumBanks=1,BankPixelWidth=4)
# MoveInstrumentComponent(Workspace='sample2',ComponentName='bank1',X=2.0,Y=0.0,Z=2.0,RelativePosition=False)
# RotateInstrumentComponent(Workspace='sample2',ComponentName='bank1',X=0,Y=1,Z=0,Angle=45,RelativeRotation=False)
# CalculateDIFC(InputWorkspace='sample2', OutputWorkspace='sample2')
# d=mtd['sample2'].extractY()
# for i in range(len(d)):
# print "calTable.addRow(["+str(i+16)+", "+str(d[i][0])+"])"
calTable = CreateEmptyTableWorkspace()
calTable.addColumn("int", "detid")
calTable.addColumn("double", "difc")
calTable.addRow([16, 2481.89300158])
calTable.addRow([17, 2481.90717397])
calTable.addRow([18, 2481.94969])
calTable.addRow([19, 2482.02054626])
calTable.addRow([20, 2490.36640334])
calTable.addRow([21, 2490.38050851])
calTable.addRow([22, 2490.42282292])
calTable.addRow([23, 2490.49334316])
calTable.addRow([24, 2498.83911141])
calTable.addRow([25, 2498.85314962])
calTable.addRow([26, 2498.89526313])
calTable.addRow([27, 2498.96544859])
calTable.addRow([28, 2507.31101837])
calTable.addRow([29, 2507.32498986])
calTable.addRow([30, 2507.36690322])
calTable.addRow([31, 2507.43675513])
ws = mtd["testWS"]
startPos = ws.getInstrument().getComponentByName(component).getPos()
startRot = ws.getInstrument().getComponentByName(component).getRotation().getEulerAngles("YZX") #YZX
AlignComponents(CalibrationTable="calTable",
Workspace="testWS",
ComponentList=component,
AlphaRotation=True)
ws = mtd["testWS"]
endPos = ws.getInstrument().getComponentByName(component).getPos()
endRot = ws.getInstrument().getComponentByName(component).getRotation().getEulerAngles("YZX") #YZX
self.assertEqual(startPos, endPos)
self.assertAlmostEqual(endRot[0],45.0,places=0)
self.assertEqual(startRot[1], endRot[1])
self.assertEqual(startRot[2], endRot[2])
def create_output_table(centre1, centre2):
Centre_position = CreateEmptyTableWorkspace()
Centre_position.addColumn(type="double", name="X Centre Position")
Centre_position.addColumn(type="double", name="Y Centre Position")
Centre_position.addRow({"X Centre Position": centre1, "Y Centre Position": centre2})
class CorrectTOFTest(unittest.TestCase):
def setUp(self):
# create sample workspace
self.xmin = 2123.33867005 + 4005.75
self.xmax = 2123.33867005 + 7995.75
self._input_ws = CreateSampleWorkspace(Function="User Defined", UserDefinedFunction="name=LinearBackground, \
A0=0.3;name=Gaussian, PeakCentre=8190, Height=5, Sigma=75", NumBanks=2,
BankPixelWidth=1, XMin=self.xmin, XMax=self.xmax, BinWidth=10.5,
BankDistanceFromSample=4.0, SourceDistanceFromSample=1.4, OutputWorkspace="ws")
lognames = "wavelength,TOF1"
logvalues = "6.0,2123.33867005"
AddSampleLogMultiple(self._input_ws, lognames, logvalues)
# create EPP table
self._table = CreateEmptyTableWorkspace(OutputWorkspace="epptable")
self._table.addColumn(type="double", name="PeakCentre")
table_row = {'PeakCentre': 8189.5}
for i in range(2):
self._table.addRow(table_row)
def tearDown(self):
for wsname in ['ws', 'epptable']:
if AnalysisDataService.doesExist(wsname):
run_algorithm("DeleteWorkspace", Workspace=wsname)
def testCorrection(self):
# tests that correction is done properly
OutputWorkspaceName = "outputws1"
alg_test = run_algorithm("CorrectTOF", InputWorkspace=self._input_ws, EPPTable=self._table, OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName)
velocity = h/(m_n*6.0e-10)
t_el = 4.0e+6/velocity
t_corr = np.arange(self.xmin, self.xmax + 1.0, 10.5) + t_el - (8189.5 - 2123.33867005)
self.assertTrue(np.allclose(t_corr, wsoutput.readX(0))) #sdd = 4
self.assertTrue(np.allclose(t_corr + t_el, wsoutput.readX(1))) #sdd = 8
run_algorithm("DeleteWorkspace", Workspace=wsoutput)
def testGroup(self):
# tests whether the group of workspaces is accepted as an input
ws2 = CloneWorkspace(self._input_ws)
group = GroupWorkspaces([self._input_ws, ws2])
OutputWorkspaceName = "output_wsgroup"
alg_test = run_algorithm("CorrectTOF", InputWorkspace='group', EPPTable=self._table, OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName)
self.assertTrue(isinstance(wsoutput, WorkspaceGroup))
self.assertEqual(2, wsoutput.getNumberOfEntries())
run_algorithm("DeleteWorkspace", Workspace=group)
run_algorithm("DeleteWorkspace", Workspace=wsoutput)
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 get_log(runs):
"""
Uses the run journal to identify which run numbers are associated with
which samples and create a table for each sample, containing all the
information needed to analyse each run.
Parameters
----------
runs
A list of integer run numbers
"""
log_file = JPATH + "\\" + get_relevant_log(min(runs))
results = []
with open(log_file, "r") as infile:
journal = xml.etree.cElementTree.iterparse(infile)
for _, child in journal:
if "NXentry" in child.tag:
num = get_xml_run_number(child)
if num in runs:
for param in child:
if "title" in param.tag:
sample = param.text
elif "start_time" in param.tag:
start = datetime.datetime.strptime(
param.text,
"%Y-%m-%dT%H:%M:%S")
elif "end_time" in param.tag:
stop = datetime.datetime.strptime(
param.text,
"%Y-%m-%dT%H:%M:%S")
elif "duration" in param.tag:
duration = datetime.timedelta(
seconds=int(param.text))
elif "proton_charge" in param.tag:
proton_charge = float(param.text)
results.append(
QuickData(num, sample, start, stop, duration,
proton_charge))
child.clear()
if num > max(runs):
break
trans = [run for run in results
if re.match(RUN_IDENTIFIERS["trans"], run[1])]
csans = [run for run in results
if re.match(RUN_IDENTIFIERS["can_sans"], run[1])]
ctrans = [run for run in results
if re.match(RUN_IDENTIFIERS["can_trans"], run[1])]
dtrans = [run for run in results
if re.match(RUN_IDENTIFIERS["direct_trans"], run[1])]
temp = [convert_run(run, trans, csans, ctrans, dtrans)
for run in results
if (re.match(RUN_IDENTIFIERS["run"], run.sample) or
re.match(RUN_IDENTIFIERS["can_sans"], run.sample) or
re.match(RUN_IDENTIFIERS["direct_sans"], run.sample))
and run.charge/run.duration.seconds > 0.005]
d = {}
for run in temp:
if run.sample in d.keys():
d[run.sample].append(run)
else:
d[run.sample] = [run]
for k, v in d.items():
my_table = CreateEmptyTableWorkspace()
my_table.addColumn("int", "Run Number")
my_table.addColumn("str", "Sample")
my_table.addColumn("str", "Start time")
my_table.addColumn("str", "End time")
my_table.addColumn("int", "Trans run")
my_table.addColumn("int", "Can Sans run")
my_table.addColumn("int", "Can Trans run")
my_table.addColumn("int", "Direct Trans run")
for run in v:
my_table.addRow(
[run.number, run.sample,
run.start.isoformat(),
run.end.isoformat(),
run.trans, run.csans, run.ctrans,
run.direct])
RenameWorkspace(my_table, k+"_runs")
