def validate(self):
self.tolerance_is_rel_err = True
self.tolerance = 1e-2
# this is neccesary due to appendspectra creating spectrum numbers of 0
self.disableChecking.append('SpectraMap')
# fitted peaks table workspace is v sensitive to changes in input data so just validate X0 col
if systemtesting.using_gsl_v1():
reffile = simple.LoadNexus(
Filename="engggui_calibration_bank_cropped_gsl1.nxs")
self.validateSingleColumn(mtd["cropped"].column("X0"),
reffile.column("X0"), self.tolerance)
return ("engg_calibration_banks_parameters",
"engggui_calibration_cropped_parameters_gsl1.nxs",
"Engg difc Zero Peaks Bank cropped",
"engggui_difc_zero_peaks_bank_cropped_gsl1.nxs")
else:
reffile = simple.LoadNexus(
Filename="engggui_calibration_bank_cropped.nxs")
self.validateSingleColumn(mtd["cropped"].column("X0"),
reffile.column("X0"), self.tolerance)
return ("engg_calibration_banks_parameters",
"engggui_calibration_bank_cropped_parameters.nxs",
"Engg difc Zero Peaks Bank cropped",
"engggui_difc_zero_peaks_bank_cropped.nxs")
def runTest(self):
setup_mantid_paths()
# Load Focused ws
mantid.LoadNexus(Filename=total_scattering_input_file,
OutputWorkspace='98533-Results-TOF-Grp')
q_lims = np.array([2.5, 3, 4, 6, 7, 3.5, 5, 7, 11, 40]).reshape((2, 5))
self.pdf_output = run_total_scattering('98533', True, q_lims=q_lims)
def _obtain_focused_run(run_number, focus_file_path):
"""
Searches for the focused workspace to use (based on user specified run number) in the ADS and then the output
directory.
If unsuccessful, a ValueError exception is thrown.
:param run_number: The run number to search for.
:param focus_file_path: The expected file path for the focused file.
:return: The focused workspace.
"""
# Try the ADS first to avoid undesired loading
if mantid.mtd.doesExist('%s-ResultTOF' % run_number):
focused_ws = mantid.mtd['%s-ResultTOF' % run_number]
elif mantid.mtd.doesExist('%s-ResultD' % run_number):
focused_ws = mantid.mtd['%s-ResultD' % run_number]
else:
# Check output directory
print(
'No loaded focused files found. Searching in output directory...')
try:
focused_ws = mantid.LoadNexus(
Filename=focus_file_path,
OutputWorkspace='focused_ws').OutputWorkspace
except ValueError:
raise ValueError(
"Could not find focused file for run number:%s\n"
"Please ensure a focused file has been produced and is located in the output directory."
% run_number)
return focused_ws
def test_function_call_raises_ValueError_when_passed_args_with_invalid_values(self):
# lhs code bug means we can't do this "self.assertRaises(simpleapi.LoadNexus, 'DoesNotExist')" --> ticket #4186
try:
simpleapi.LoadNexus(Filename='DoesNotExist.nxs')
self.fail("A ValueError was not thrown")
except ValueError:
pass
def setUp(self):
"""
Set up dependencies for one or more of the tests below.
"""
if not self.__class__._data_ws:
self.__class__._data_ws = sapi.LoadNexus("ENGINX00228061.nxs", OutputWorkspace='ENGIN-X_test_ws')
if not self.__class__._van_curves_ws:
# Note the pre-calculated file instead of the too big vanadium run
# self.__class__._van_ws = LoadNexus("ENGINX00236516.nxs", OutputWorkspace='ENGIN-X_test_vanadium_ws')
self.__class__._van_curves_ws = sapi.LoadNexus(Filename=
'ENGINX_precalculated_vanadium_run000236516_bank_curves.nxs',
OutputWorkspace='ENGIN-X_vanadium_curves_test_ws')
self.__class__._van_integ_tbl = sapi.LoadNexus(Filename=
'ENGINX_precalculated_vanadium_run000236516_integration.nxs',
OutputWorkspace='ENGIN-X_vanadium_integ_test_ws')
def test_function_call_raises_RuntimeError_when_passed_incorrect_args(
self):
try:
simpleapi.LoadNexus(NotAProperty=1)
self.fail("A RuntimeError was not thrown")
except RuntimeError:
pass
def _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string,
absorb, sample_details):
read_ws_list = common.load_current_normalised_ws_list(
run_number_string=run_number_string, instrument=instrument)
run_details = instrument._get_run_details(
run_number_string=run_number_string)
vanadium_splines = None
van = "van_{}".format(run_details.vanadium_run_numbers)
if perform_vanadium_norm:
if van not in mantid.mtd:
vanadium_splines = mantid.LoadNexus(
Filename=run_details.splined_vanadium_file_path,
OutputWorkspace=van)
else:
vanadium_splines = mantid.mtd[van]
output = None
for ws in read_ws_list:
output = _focus_one_ws(input_workspace=ws,
run_number=run_number_string,
instrument=instrument,
perform_vanadium_norm=perform_vanadium_norm,
absorb=absorb,
sample_details=sample_details,
vanadium_path=vanadium_splines)
if instrument.get_instrument_prefix(
) == "PEARL" and vanadium_splines is not None:
mantid.DeleteWorkspace(vanadium_splines.OutputWorkspace)
return output
def _individual_run_focusing(instrument, perform_vanadium_norm, run_number,
absorb, sample_details):
# Load and process one by one
run_numbers = common.generate_run_numbers(run_number_string=run_number)
run_details = instrument._get_run_details(run_number_string=run_number)
vanadium_splines = None
van = "van_{}".format(run_details.vanadium_run_numbers)
if perform_vanadium_norm:
if van not in mantid.mtd:
vanadium_splines = mantid.LoadNexus(
Filename=run_details.splined_vanadium_file_path,
OutputWorkspace=van)
else:
vanadium_splines = mantid.mtd[van]
output = None
for run in run_numbers:
ws = common.load_current_normalised_ws_list(run_number_string=run,
instrument=instrument)
output = _focus_one_ws(input_workspace=ws[0],
run_number=run,
instrument=instrument,
absorb=absorb,
perform_vanadium_norm=perform_vanadium_norm,
sample_details=sample_details,
vanadium_path=vanadium_splines)
return output
def _validate_wrapper(cls, focus_mode):
cls.disableChecking.append('Instrument')
cls.disableChecking.append('Sample')
cls.disableChecking.append('SpectraMap')
out_name = "PEARL_routines_fmode_" + focus_mode
mantid.LoadNexus(Filename=DIRS[0] +
"PEARL/Focus_Test/DataOut/PEARL92476_92479.nxs",
OutputWorkspace=out_name)
reference_file_name = "PEARL92476_92479_" + focus_mode + ".nxs"
return out_name, reference_file_name
def _divide_by_vanadium_splines(spectra_list, spline_file_path):
vanadium_ws_list = mantid.LoadNexus(Filename=spline_file_path)
output_list = []
for data_ws, van_ws in zip(spectra_list, vanadium_ws_list[1:]):
vanadium_ws = mantid.RebinToWorkspace(WorkspaceToRebin=van_ws,
WorkspaceToMatch=data_ws)
output_ws = mantid.Divide(LHSWorkspace=data_ws,
RHSWorkspace=vanadium_ws,
OutputWorkspace=data_ws)
output_list.append(output_ws)
common.remove_intermediate_workspace(vanadium_ws)
return output_list
def _divide_by_vanadium_splines(spectra_list, spline_file_path):
vanadium_splines = mantid.LoadNexus(Filename=spline_file_path)
if hasattr(vanadium_splines, "OutputWorkspace"): # vanadium_splines is a group
vanadium_splines = vanadium_splines.OutputWorkspace
num_splines = len(vanadium_splines)
num_spectra = len(spectra_list)
if num_splines != num_spectra:
raise RuntimeError("Mismatch between number of banks in vanadium and number of banks in workspace to focus"
"\nThere are {} banks for vanadium but {} for the run".format(num_splines, num_spectra))
output_list = [_divide_one_spectrum_by_spline(data_ws, van_ws)
for data_ws, van_ws in zip(spectra_list, vanadium_splines)]
return output_list
output_list = [_divide_one_spectrum_by_spline(spectra_list[0], vanadium_splines)]
common.remove_intermediate_workspace(vanadium_splines)
return output_list
def parse_nxs(file_name):
name, ext = os.path.splitext(file_name)
if ext != '.nxs':
print('Wrong file!', ext)
return -1
ws = ms.LoadNexus(file_name)
xs = ws.readX(0)
ys = ws.readY(0)
es = ws.readE(0)
data_template = '{0} {1} {2}\n'
lines = ['# X Y E\n', '\n']
lines += [
data_template.format(x, y, e)
for x, y, e in itertools.izip(xs, ys, es)
]
with open(name + '.txt', 'w') as f:
f.writelines(lines)
def _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string,
absorb, sample_details):
read_ws_list = common.load_current_normalised_ws_list(
run_number_string=run_number_string, instrument=instrument)
run_details = instrument._get_run_details(
run_number_string=run_number_string)
vanadium_splines = None
if perform_vanadium_norm:
vanadium_splines = mantid.LoadNexus(
Filename=run_details.splined_vanadium_file_path)
output = None
for ws in read_ws_list:
output = _focus_one_ws(input_workspace=ws,
run_number=run_number_string,
instrument=instrument,
perform_vanadium_norm=perform_vanadium_norm,
absorb=absorb,
sample_details=sample_details,
vanadium_path=vanadium_splines)
return output
def _focus_load(alg_range, focused_ws, input_file_paths, instrument, van_norm):
processed_spectra = []
for index in range(0, alg_range):
if van_norm:
vanadium_ws = mantid.LoadNexus(
Filename=input_file_paths["vanadium"], EntryNumber=index + 1)
van_rebinned = mantid.Rebin(
InputWorkspace=vanadium_ws,
Params=instrument._get_focus_tof_binning())
processed_spectra.append(
calc_calibration_with_vanadium(focused_ws, index, van_rebinned,
instrument))
remove_intermediate_workspace(vanadium_ws)
remove_intermediate_workspace(van_rebinned)
else:
processed_spectra.append(
calc_calibration_without_vanadium(focused_ws, index,
instrument))
return processed_spectra
def runTest(self):
setup_mantid_paths()
# Load Focused ws
mantid.LoadNexus(Filename=total_scattering_input_file, OutputWorkspace='98533-ResultTOF')
self.pdf_output = run_total_scattering('98533', False)
def runTest(self):
# Load Focused ws
mantid.LoadNexus(Filename=total_scattering_input_file,
OutputWorkspace='98533-Results-TOF-Grp')
self.pdf_output = run_total_scattering('98533', False)
def _focus_one_ws(input_workspace,
run_number,
instrument,
perform_vanadium_norm,
absorb,
sample_details,
vanadium_path,
empty_can_subtraction_method,
paalman_pings_events_per_point=None):
run_details = instrument._get_run_details(run_number_string=run_number)
if perform_vanadium_norm:
_test_splined_vanadium_exists(instrument, run_details)
# Subtract empty instrument runs, as long as this run isn't an empty, user hasn't turned empty subtraction off, or
# The user has not supplied a sample empty
is_run_empty = common.runs_overlap(run_number, run_details.empty_inst_runs)
summed_empty = None
if not is_run_empty and instrument.should_subtract_empty_inst(
) and not run_details.sample_empty:
if os.path.isfile(run_details.summed_empty_inst_file_path):
logger.warning('Pre-summed empty instrument workspace found at ' +
run_details.summed_empty_inst_file_path)
summed_empty = mantid.LoadNexus(
Filename=run_details.summed_empty_inst_file_path)
else:
summed_empty = common.generate_summed_runs(
empty_sample_ws_string=run_details.empty_inst_runs,
instrument=instrument)
elif run_details.sample_empty:
scale_factor = 1.0
if empty_can_subtraction_method != 'PaalmanPings':
scale_factor = instrument._inst_settings.sample_empty_scale
# Subtract a sample empty if specified ie empty can
summed_empty = common.generate_summed_runs(
empty_sample_ws_string=run_details.sample_empty,
instrument=instrument,
scale_factor=scale_factor)
if absorb and empty_can_subtraction_method == 'PaalmanPings':
if run_details.sample_empty: # need summed_empty including container
input_workspace = instrument._apply_paalmanpings_absorb_and_subtract_empty(
workspace=input_workspace,
summed_empty=summed_empty,
sample_details=sample_details,
paalman_pings_events_per_point=paalman_pings_events_per_point)
# Crop to largest acceptable TOF range
input_workspace = instrument._crop_raw_to_expected_tof_range(
ws_to_crop=input_workspace)
else:
raise TypeError(
"The PaalmanPings absorption method requires 'sample_empty' to be supplied."
)
else:
if summed_empty:
input_workspace = common.subtract_summed_runs(
ws_to_correct=input_workspace, empty_sample=summed_empty)
# Crop to largest acceptable TOF range
input_workspace = instrument._crop_raw_to_expected_tof_range(
ws_to_crop=input_workspace)
if absorb:
input_workspace = instrument._apply_absorb_corrections(
run_details=run_details, ws_to_correct=input_workspace)
else:
# Set sample material if specified by the user
if sample_details is not None:
mantid.SetSample(
InputWorkspace=input_workspace,
Geometry=sample_details.generate_sample_geometry(),
Material=sample_details.generate_sample_material())
# Align
mantid.ApplyDiffCal(InstrumentWorkspace=input_workspace,
CalibrationFile=run_details.offset_file_path)
aligned_ws = mantid.ConvertUnits(InputWorkspace=input_workspace,
Target="dSpacing")
solid_angle = instrument.get_solid_angle_corrections(
run_details.vanadium_run_numbers, run_details)
if solid_angle:
aligned_ws = mantid.Divide(LHSWorkspace=aligned_ws,
RHSWorkspace=solid_angle)
mantid.DeleteWorkspace(solid_angle)
# Focus the spectra into banks
focused_ws = mantid.DiffractionFocussing(
InputWorkspace=aligned_ws,
GroupingFileName=run_details.grouping_file_path)
instrument.apply_calibration_to_focused_data(focused_ws)
calibrated_spectra = _apply_vanadium_corrections(
instrument=instrument,
input_workspace=focused_ws,
perform_vanadium_norm=perform_vanadium_norm,
vanadium_splines=vanadium_path)
output_spectra = instrument._crop_banks_to_user_tof(calibrated_spectra)
bin_widths = instrument._get_instrument_bin_widths()
if bin_widths:
# Reduce the bin width if required on this instrument
output_spectra = common.rebin_workspace_list(
workspace_list=output_spectra, bin_width_list=bin_widths)
# Output
d_spacing_group, tof_group = instrument._output_focused_ws(
output_spectra, run_details=run_details)
common.keep_single_ws_unit(d_spacing_group=d_spacing_group,
tof_group=tof_group,
unit_to_keep=instrument._get_unit_to_keep())
# Tidy workspaces from Mantid
common.remove_intermediate_workspace(input_workspace)
common.remove_intermediate_workspace(aligned_ws)
common.remove_intermediate_workspace(focused_ws)
common.remove_intermediate_workspace(output_spectra)
return d_spacing_group
def _create_van(instrument,
van,
empty,
output_van_file_name,
num_of_splines=60,
absorb=True,
gen_absorb=False):
cycle_information = instrument._get_cycle_information(van)
input_van_ws = _read_ws(number=van, instrument=instrument)
input_empty_ws = _read_ws(number=empty, instrument=instrument)
corrected_van_ws = mantid.Minus(LHSWorkspace=input_van_ws,
RHSWorkspace=input_empty_ws)
remove_intermediate_workspace(input_empty_ws)
remove_intermediate_workspace(input_van_ws)
calibration_full_paths = instrument._get_calibration_full_paths(
cycle=cycle_information["cycle"])
tof_binning = instrument._get_create_van_tof_binning()
if absorb:
corrected_van_ws = _apply_absorb_corrections(calibration_full_paths,
corrected_van_ws,
gen_absorb)
corrected_van_ws = mantid.ConvertUnits(InputWorkspace=corrected_van_ws,
Target="TOF")
corrected_van_ws = mantid.Rebin(InputWorkspace=corrected_van_ws,
Params=tof_binning["1"])
corrected_van_ws = mantid.AlignDetectors(
InputWorkspace=corrected_van_ws,
CalibrationFile=calibration_full_paths["calibration"])
focused_van_file = mantid.DiffractionFocussing(
InputWorkspace=corrected_van_ws,
GroupingFileName=calibration_full_paths["grouping"])
focused_van_file = mantid.ConvertUnits(InputWorkspace=focused_van_file,
Target="TOF")
focused_van_file = mantid.Rebin(InputWorkspace=focused_van_file,
Params=tof_binning["2"])
focused_van_file = mantid.ConvertUnits(InputWorkspace=focused_van_file,
Target="dSpacing")
remove_intermediate_workspace(corrected_van_ws)
splined_ws_list = instrument._spline_background(
focused_van_file, num_of_splines,
cycle_information["instrument_version"])
if instrument._PEARL_use_full_path():
out_van_file_path = output_van_file_name
else:
out_van_file_path = instrument.calibration_dir + output_van_file_name
append = False
for ws in splined_ws_list:
mantid.SaveNexus(Filename=out_van_file_path,
InputWorkspace=ws,
Append=append)
remove_intermediate_workspace(ws)
append = True
mantid.LoadNexus(Filename=out_van_file_path, OutputWorkspace="Van_data")
def _load_van_absorb_corr(calibration_full_paths):
absorption_ws = mantid.LoadNexus(
Filename=calibration_full_paths["vanadium_absorption"])
return absorption_ws
