def normalise_ws_current(ws_to_correct, monitor_ws, spline_coeff, lambda_values, integration_range, ex_regions):
processed_monitor_ws = mantid.ConvertUnits(InputWorkspace=monitor_ws, Target="Wavelength")
processed_monitor_ws = mantid.CropWorkspace(InputWorkspace=processed_monitor_ws,
XMin=lambda_values[0], XMax=lambda_values[-1])
for reg in range(0, 4):
processed_monitor_ws = mantid.MaskBins(InputWorkspace=processed_monitor_ws, XMin=ex_regions[0, reg],
XMax=ex_regions[1, reg])
splined_monitor_ws = mantid.SplineBackground(InputWorkspace=processed_monitor_ws,
WorkspaceIndex=0, NCoeff=spline_coeff)
normalised_ws = mantid.ConvertUnits(InputWorkspace=ws_to_correct, Target="Wavelength",
OutputWorkspace=ws_to_correct)
normalised_ws = mantid.NormaliseToMonitor(InputWorkspace=normalised_ws, MonitorWorkspace=splined_monitor_ws,
IntegrationRangeMin=integration_range[0],
IntegrationRangeMax=integration_range[-1],
OutputWorkspace=normalised_ws)
normalised_ws = mantid.ConvertUnits(InputWorkspace=normalised_ws, Target="TOF", OutputWorkspace=normalised_ws)
common.remove_intermediate_workspace(processed_monitor_ws)
common.remove_intermediate_workspace(splined_monitor_ws)
return normalised_ws
def _sum_groups_of_three_ws(calibrated_spectra, output_file_names):
workspace_list = []
output_list = []
for outer_loop_count in range(0, 3):
# First clone workspaces 1/4/7
pass_multiplier = (outer_loop_count * 3)
workspace_names = "focus_mode_groups-" + str(pass_multiplier + 1)
workspace_list.append(
mantid.CloneWorkspace(
InputWorkspace=calibrated_spectra[pass_multiplier],
OutputWorkspace=workspace_names))
# Then add workspaces 1+2+3 / 4+5+6 / 7+8+9
for i in range(1, 3):
input_ws_index = i + pass_multiplier # Workspaces 2/3 * n
inner_workspace_names = "focus_mode_groups-" + str(input_ws_index)
workspace_list[outer_loop_count] = mantid.Plus(
LHSWorkspace=workspace_list[outer_loop_count],
RHSWorkspace=calibrated_spectra[input_ws_index],
OutputWorkspace=inner_workspace_names)
# Finally scale the output workspaces
mod_first_number = str((outer_loop_count * 3) + 1) # Generates 1/4/7
mod_last_number = str((outer_loop_count + 1) * 3) # Generates 3/6/9
workspace_names = output_file_names[
"output_name"] + "_mod" + mod_first_number + '-' + mod_last_number
output_list.append(
mantid.Scale(InputWorkspace=workspace_list[outer_loop_count],
OutputWorkspace=workspace_names,
Factor=0.333333333333))
common.remove_intermediate_workspace(workspace_list)
return output_list
def _spline_old_instrument_background(in_workspace):
van_stripped = mantid.ConvertUnits(InputWorkspace=in_workspace, Target="dSpacing")
# remove bragg peaks before spline
van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=15, Tolerance=6, WorkspaceIndex=0)
van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=15, Tolerance=6, WorkspaceIndex=2)
van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=15, Tolerance=6, WorkspaceIndex=3)
van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=40, Tolerance=12, WorkspaceIndex=1)
van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=60, Tolerance=12, WorkspaceIndex=1)
# Mask low d region that is zero before spline
for reg in range(0, 4):
if reg == 1:
van_stripped = mantid.MaskBins(InputWorkspace=van_stripped, XMin=0, XMax=0.14, SpectraList=reg)
else:
van_stripped = mantid.MaskBins(InputWorkspace=van_stripped, XMin=0, XMax=0.06, SpectraList=reg)
van_stripped = mantid.ConvertUnits(InputWorkspace=van_stripped, Target="TOF")
splined_ws_list = []
for i in range(0, 4):
out_ws_name = "spline" + str(i+1)
if i == 1:
coeff = 80
else:
coeff = 100
splined_ws_list.append(mantid.SplineBackground(InputWorkspace=van_stripped, OutputWorkspace=out_ws_name,
WorkspaceIndex=i, NCoeff=coeff))
common.remove_intermediate_workspace(van_stripped)
return splined_ws_list
def apply_vanadium_absorb_corrections(van_ws, run_details, absorb_ws=None):
if absorb_ws is None:
absorb_ws = mantid.Load(Filename=run_details.vanadium_absorption_path)
van_original_units = van_ws.getAxis(0).getUnit().unitID()
absorb_units = absorb_ws.getAxis(0).getUnit().unitID()
if van_original_units != absorb_units:
van_ws = mantid.ConvertUnits(InputWorkspace=van_ws,
Target=absorb_units,
OutputWorkspace=van_ws)
absorb_ws = mantid.RebinToWorkspace(WorkspaceToRebin=absorb_ws,
WorkspaceToMatch=van_ws,
OutputWorkspace=absorb_ws)
van_ws = mantid.Divide(LHSWorkspace=van_ws,
RHSWorkspace=absorb_ws,
OutputWorkspace=van_ws)
if van_original_units != absorb_units:
van_ws = mantid.ConvertUnits(InputWorkspace=van_ws,
Target=van_original_units,
OutputWorkspace=van_ws)
common.remove_intermediate_workspace(absorb_ws)
return van_ws
def _calibration_processing(calibration_dir, calibration_runs, cross_correlate_params, get_det_offset_params,
grouping_file_name, input_ws, instrument, offset_file, rebin_1_params, rebin_2_params):
calibration_ws = input_ws
if calibration_ws.getAxis(0).getUnit().unitID() != WORKSPACE_UNITS.d_spacing:
calibration_ws = mantid.Rebin(InputWorkspace=input_ws, Params=rebin_1_params)
calibration_ws = mantid.ConvertUnits(InputWorkspace=calibration_ws, Target="dSpacing")
spectrum_list = []
for i in range(0, calibration_ws.getNumberHistograms()):
try:
calibration_ws.getDetector(i)
except RuntimeError:
pass
else:
spectrum_list.append(i)
calibration_ws = mantid.ExtractSpectra(InputWorkspace=calibration_ws, WorkspaceIndexList=spectrum_list)
rebinned = mantid.Rebin(InputWorkspace=calibration_ws, Params=rebin_2_params)
cross_correlated = mantid.CrossCorrelate(InputWorkspace=rebinned, **cross_correlate_params)
# Offsets workspace must be referenced as string so it can be deleted, as simpleapi doesn't recognise it as a ws
offsets_ws_name = "offsets"
mantid.GetDetectorOffsets(InputWorkspace=cross_correlated, GroupingFileName=offset_file,
OutputWorkspace=offsets_ws_name, **get_det_offset_params)
rebinned_tof = mantid.ConvertUnits(InputWorkspace=rebinned, Target="TOF")
aligned = mantid.AlignDetectors(InputWorkspace=rebinned_tof, CalibrationFile=offset_file)
grouping_file = os.path.join(calibration_dir, grouping_file_name)
focused = mantid.DiffractionFocussing(InputWorkspace=aligned, GroupingFileName=grouping_file,
OutputWorkspace=instrument._generate_output_file_name(calibration_runs)
+ "_grouped")
print("Saved cal file to " + offset_file)
common.remove_intermediate_workspace([calibration_ws, rebinned, cross_correlated, rebinned_tof,
offsets_ws_name])
return focused
def process_vanadium_for_focusing(bank_spectra, mask_path, spline_number):
bragg_masking_list = _read_masking_file(mask_path)
masked_workspace_list = _apply_bragg_peaks_masking(bank_spectra, mask_list=bragg_masking_list)
output = common.spline_workspaces(focused_vanadium_spectra=masked_workspace_list,
num_splines=spline_number)
common.remove_intermediate_workspace(masked_workspace_list)
return output
def test_remove_intermediate_workspace(self):
ws_list = []
ws_names_list = []
ws_single_name = "remove_intermediate_ws-single"
ws_single = mantid.CreateSampleWorkspace(OutputWorkspace=ws_single_name, NumBanks=1, BankPixelWidth=1,
XMax=10, BinWidth=1)
for i in range(0, 3):
out_name = "remove_intermediate_ws_" + str(i)
ws_names_list.append(out_name)
ws_list.append(mantid.CreateSampleWorkspace(OutputWorkspace=out_name, NumBanks=1, BankPixelWidth=1,
XMax=10, BinWidth=1))
# Check single workspaces are removed
self.assertEqual(True, mantid.mtd.doesExist(ws_single_name))
common.remove_intermediate_workspace(ws_single)
self.assertEqual(False, mantid.mtd.doesExist(ws_single_name))
# Next check lists are handled
for ws_name in ws_names_list:
self.assertEqual(True, mantid.mtd.doesExist(ws_name))
common.remove_intermediate_workspace(ws_list)
for ws_name in ws_names_list:
self.assertEqual(False, mantid.mtd.doesExist(ws_name))
def process_vanadium_for_focusing(bank_spectra, mask_path, spline_number):
bragg_masking_list = _read_masking_file(mask_path)
masked_workspace_list = _apply_bragg_peaks_masking(bank_spectra, mask_list=bragg_masking_list)
output = common.spline_workspaces(focused_vanadium_spectra=masked_workspace_list,
num_splines=spline_number)
common.remove_intermediate_workspace(masked_workspace_list)
return output
def _adjust_cal_file(original_cal, generated_cal):
origin_ws = "origin{}"
gen_ws = "newCal{}"
out_ws = "adjusted_cal"
mantid.LoadCalFile(InstrumentName="Gem",
MakeGroupingWorkspace=False,
MakeMaskWorkspace=False,
MakeOffsetsWorkspace=True,
WorkspaceName=origin_ws.format(''),
CalFilename=original_cal)
mantid.LoadCalFile(InstrumentName="Gem",
MakeGroupingWorkspace=False,
MakeMaskWorkspace=False,
MakeOffsetsWorkspace=True,
WorkspaceName=gen_ws.format(''),
CalFilename=generated_cal)
mantid.Plus(LHSWorkspace=origin_ws.format("_offsets"),
RHSWorkspace=gen_ws.format("_offsets"),
OutputWorkspace=out_ws)
mantid.SaveCalFile(OffsetsWorkspace=out_ws, Filename=generated_cal)
common.remove_intermediate_workspace([
origin_ws.format("_offsets"),
gen_ws.format("_offsets"),
origin_ws.format("_cal"),
gen_ws.format("_cal")
])
def _divide_by_vanadium_splines(spectra_list, vanadium_splines):
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 create_solid_angle_corrections(self, vanadium, run_details):
"""
Creates the solid angle corrections from a vanadium run, only applicable on HRPD otherwise return None
:param vanadium: The vanadium used to create this
:param run_details: the run details of to use
"""
settings = self._inst_settings
if not settings.do_solid_angle:
return
solid_angle = mantid.SolidAngle(InputWorkspace=vanadium)
solid_angle = mantid.Scale(InputWorkspace=solid_angle, Factor=100, Operation='Multiply')
eff = mantid.Divide(LHSWorkspace=vanadium, RHSWorkspace=solid_angle)
eff = mantid.ConvertUnits(InputWorkspace=eff, Target='Wavelength')
integration_range = settings.eff_integration_range
# use full range if no range is supplied
integration_range = integration_range if integration_range is not None else (None, None)
eff = mantid.Integration(InputWorkspace=eff,
RangeLower=integration_range[0],
RangeUpper=integration_range[1])
correction = mantid.Multiply(LHSWorkspace=solid_angle, RHSWorkspace=eff)
correction = mantid.Scale(InputWorkspace=correction, Factor=1e-5,
Operation='Multiply')
name = "sac" + common.generate_splined_name(run_details.run_number, [])
path = run_details.van_paths
mantid.SaveNexus(InputWorkspace=correction, Filename=os.path.join(path, name))
common.remove_intermediate_workspace(eff)
common.remove_intermediate_workspace(correction)
def test_remove_intermediate_workspace(self):
ws_list = []
ws_names_list = []
ws_single_name = "remove_intermediate_ws-single"
ws_single = mantid.CreateSampleWorkspace(
OutputWorkspace=ws_single_name,
NumBanks=1,
BankPixelWidth=1,
XMax=10,
BinWidth=1)
for i in range(0, 3):
out_name = "remove_intermediate_ws_" + str(i)
ws_names_list.append(out_name)
ws_list.append(
mantid.CreateSampleWorkspace(OutputWorkspace=out_name,
NumBanks=1,
BankPixelWidth=1,
XMax=10,
BinWidth=1))
# Check single workspaces are removed
self.assertEqual(True, mantid.mtd.doesExist(ws_single_name))
common.remove_intermediate_workspace(ws_single)
self.assertEqual(False, mantid.mtd.doesExist(ws_single_name))
# Next check lists are handled
for ws_name in ws_names_list:
self.assertEqual(True, mantid.mtd.doesExist(ws_name))
common.remove_intermediate_workspace(ws_list)
for ws_name in ws_names_list:
self.assertEqual(False, mantid.mtd.doesExist(ws_name))
def _sum_groups_of_three_ws(calibrated_spectra, output_file_names):
workspace_list = []
output_list = []
for outer_loop_count in range(0, 3):
# First clone workspaces 1/4/7
pass_multiplier = (outer_loop_count * 3)
workspace_names = "focus_mode_groups-" + str(pass_multiplier + 1)
workspace_list.append(mantid.CloneWorkspace(InputWorkspace=calibrated_spectra[pass_multiplier],
OutputWorkspace=workspace_names))
# Then add workspaces 1+2+3 / 4+5+6 / 7+8+9
for i in range(1, 3):
input_ws_index = i + pass_multiplier # Workspaces 2/3 * n
inner_workspace_names = "focus_mode_groups-" + str(input_ws_index)
workspace_list[outer_loop_count] = mantid.Plus(LHSWorkspace=workspace_list[outer_loop_count],
RHSWorkspace=calibrated_spectra[input_ws_index],
OutputWorkspace=inner_workspace_names)
# Finally scale the output workspaces
mod_first_number = str((outer_loop_count * 3) + 1) # Generates 1/4/7
mod_last_number = str((outer_loop_count + 1) * 3) # Generates 3/6/9
workspace_names = output_file_names["output_name"] + "_mod" + mod_first_number + '-' + mod_last_number
output_list.append(mantid.Scale(InputWorkspace=workspace_list[outer_loop_count],
OutputWorkspace=workspace_names, Factor=0.333333333333))
for ws in workspace_list:
common.remove_intermediate_workspace(ws)
return output_list
def normalise_ws_current(ws_to_correct, monitor_ws, spline_coeff, lambda_values, integration_range, ex_regions):
processed_monitor_ws = mantid.ConvertUnits(InputWorkspace=monitor_ws, Target="Wavelength")
processed_monitor_ws = mantid.CropWorkspace(InputWorkspace=processed_monitor_ws,
XMin=lambda_values[0], XMax=lambda_values[-1])
for reg in range(0, 4):
processed_monitor_ws = mantid.MaskBins(InputWorkspace=processed_monitor_ws, XMin=ex_regions[0, reg],
XMax=ex_regions[1, reg])
splined_monitor_ws = mantid.SplineBackground(InputWorkspace=processed_monitor_ws,
WorkspaceIndex=0, NCoeff=spline_coeff)
normalised_ws = mantid.ConvertUnits(InputWorkspace=ws_to_correct, Target="Wavelength",
OutputWorkspace=ws_to_correct)
normalised_ws = mantid.NormaliseToMonitor(InputWorkspace=normalised_ws, MonitorWorkspace=splined_monitor_ws,
IntegrationRangeMin=integration_range[0],
IntegrationRangeMax=integration_range[-1],
OutputWorkspace=normalised_ws)
normalised_ws = mantid.ConvertUnits(InputWorkspace=normalised_ws, Target="TOF", OutputWorkspace=normalised_ws)
common.remove_intermediate_workspace(processed_monitor_ws)
common.remove_intermediate_workspace(splined_monitor_ws)
return normalised_ws
def generate_ts_pdf(run_number, focus_file_path, merge_banks=False, q_lims=None, cal_file_name=None,
sample_details=None, delta_r=None, delta_q=None, pdf_type="G(r)", lorch_filter=None,
freq_params=None, debug=False):
focused_ws = _obtain_focused_run(run_number, focus_file_path)
focused_ws = mantid.ConvertUnits(InputWorkspace=focused_ws, Target="MomentumTransfer", EMode='Elastic')
raw_ws = mantid.Load(Filename='POLARIS'+str(run_number)+'.nxs')
sample_geometry = common.generate_sample_geometry(sample_details)
sample_material = common.generate_sample_material(sample_details)
self_scattering_correction = mantid.TotScatCalculateSelfScattering(
InputWorkspace=raw_ws,
CalFileName=cal_file_name,
SampleGeometry=sample_geometry,
SampleMaterial=sample_material,
CrystalDensity=sample_details.material_object.crystal_density)
ws_group_list = []
for i in range(self_scattering_correction.getNumberHistograms()):
ws_name = 'correction_' + str(i)
mantid.ExtractSpectra(InputWorkspace=self_scattering_correction, OutputWorkspace=ws_name,
WorkspaceIndexList=[i])
ws_group_list.append(ws_name)
self_scattering_correction = mantid.GroupWorkspaces(InputWorkspaces=ws_group_list)
self_scattering_correction = mantid.RebinToWorkspace(WorkspaceToRebin=self_scattering_correction,
WorkspaceToMatch=focused_ws)
focused_ws = mantid.Subtract(LHSWorkspace=focused_ws, RHSWorkspace=self_scattering_correction)
if delta_q:
focused_ws = mantid.Rebin(InputWorkspace=focused_ws, Params=delta_q)
if merge_banks:
q_min, q_max = _load_qlims(q_lims)
merged_ws = mantid.MatchAndMergeWorkspaces(InputWorkspaces=focused_ws, XMin=q_min, XMax=q_max,
CalculateScale=False)
fast_fourier_filter(merged_ws, freq_params=freq_params)
pdf_output = mantid.PDFFourierTransform(Inputworkspace="merged_ws", InputSofQType="S(Q)-1", PDFType=pdf_type,
Filter=lorch_filter, DeltaR=delta_r,
rho0=sample_details.material_object.crystal_density)
else:
for ws in focused_ws:
fast_fourier_filter(ws, freq_params=freq_params)
pdf_output = mantid.PDFFourierTransform(Inputworkspace='focused_ws', InputSofQType="S(Q)-1", PDFType=pdf_type,
Filter=lorch_filter, DeltaR=delta_r,
rho0=sample_details.material_object.crystal_density)
pdf_output = mantid.RebinToWorkspace(WorkspaceToRebin=pdf_output, WorkspaceToMatch=pdf_output[4],
PreserveEvents=True)
if not debug:
common.remove_intermediate_workspace('self_scattering_correction')
# Rename output ws
if 'merged_ws' in locals():
mantid.RenameWorkspace(InputWorkspace='merged_ws', OutputWorkspace=run_number + '_merged_Q')
mantid.RenameWorkspace(InputWorkspace='focused_ws', OutputWorkspace=run_number+'_focused_Q')
if isinstance(focused_ws, WorkspaceGroup):
for i in range(len(focused_ws)):
mantid.RenameWorkspace(InputWorkspace=focused_ws[i], OutputWorkspace=run_number+'_focused_Q_'+str(i+1))
mantid.RenameWorkspace(InputWorkspace='pdf_output', OutputWorkspace=run_number+'_pdf_R')
if isinstance(pdf_output, WorkspaceGroup):
for i in range(len(pdf_output)):
mantid.RenameWorkspace(InputWorkspace=pdf_output[i], OutputWorkspace=run_number+'_pdf_R_'+str(i+1))
return pdf_output
def create_calibration(calibration_runs, instrument, offset_file_name,
grouping_file_name, calibration_dir, rebin_1_params,
rebin_2_params, cross_correlate_params,
get_det_offset_params):
"""
Create a calibration file from (usually) a ceria run
:param calibration_runs: Run number(s) for this run
:param instrument: The PEARL instrument object
:param offset_file_name: Name of the file to write detector offset information to
:param grouping_file_name: Name of grouping calibration file
:param calibration_dir: Path to directory containing calibration information
:param rebin_1_params: Parameters for the first rebin step (as a string in the usual format)
:param rebin_2_params: Parameters for the second rebin step (as a string in the usual format)
:param cross_correlate_params: Parameters for CrossCorrelate (as a dictionary PropertyName: PropertyValue)
:param get_det_offset_params: Parameters for GetDetectorOffsets (as a dictionary PropertyName: PropertyValue)
"""
input_ws_list = common.load_current_normalised_ws_list(
run_number_string=calibration_runs,
instrument=instrument,
input_batching=INPUT_BATCHING.Summed)
input_ws = input_ws_list[0]
calibration_ws = mantid.Rebin(InputWorkspace=input_ws,
Params=rebin_1_params)
if calibration_ws.getAxis(
0).getUnit().unitID() != WORKSPACE_UNITS.d_spacing:
calibration_ws = mantid.ConvertUnits(InputWorkspace=calibration_ws,
Target="dSpacing")
rebinned = mantid.Rebin(InputWorkspace=calibration_ws,
Params=rebin_2_params)
cross_correlated = mantid.CrossCorrelate(InputWorkspace=rebinned,
**cross_correlate_params)
offset_file = os.path.join(calibration_dir, offset_file_name)
# Offsets workspace must be referenced as string so it can be deleted, as simpleapi doesn't recognise it as a ws
offsets_ws_name = "offsets"
mantid.GetDetectorOffsets(InputWorkspace=cross_correlated,
GroupingFileName=offset_file,
OutputWorkspace=offsets_ws_name,
**get_det_offset_params)
rebinned_tof = mantid.ConvertUnits(InputWorkspace=rebinned, Target="TOF")
aligned = mantid.AlignDetectors(InputWorkspace=rebinned_tof,
CalibrationFile=offset_file)
grouping_file = os.path.join(calibration_dir, grouping_file_name)
focused = mantid.DiffractionFocussing(
InputWorkspace=aligned,
GroupingFileName=grouping_file,
OutputWorkspace=instrument._generate_output_file_name(calibration_runs)
+ "_grouped")
common.remove_intermediate_workspace([
calibration_ws, rebinned, cross_correlated, rebinned_tof, aligned,
offsets_ws_name
])
return focused
def generate_solid_angle_corrections(self, run_details):
solid_angle_vanadium_ws = common.load_current_normalised_ws(run_number_string=run_details.vanadium,
instrument=self)
corrections = _calculate_solid_angle_efficiency_corrections(solid_angle_vanadium_ws)
mantid.SaveNexusProcessed(InputWorkspace=corrections, Filename=run_details.solid_angle_corr)
common.remove_intermediate_workspace(solid_angle_vanadium_ws)
return corrections
def _spline_new_background(in_workspace, num_splines, instrument_version):
# Remove bragg peaks before spline
alg_range, unused = _get_instrument_ranges(instrument_version)
van_stripped = _strip_peaks_new_inst(in_workspace, alg_range)
van_stripped = mantid.ConvertUnits(InputWorkspace=van_stripped, Target="TOF")
splined_ws_list = _perform_spline_range(instrument_version, num_splines, van_stripped)
common.remove_intermediate_workspace(van_stripped)
return splined_ws_list
def correct_sample_vanadium(self, focused_ws, index, vanadium_ws=None):
spectra_name = "sample_ws-" + str(index + 1)
mantid.CropWorkspace(InputWorkspace=focused_ws, OutputWorkspace=spectra_name,
StartWorkspaceIndex=index, EndWorkspaceIndex=index)
if vanadium_ws:
van_rebinned = mantid.RebinToWorkspace(WorkspaceToRebin=vanadium_ws, WorkspaceToMatch=spectra_name)
mantid.Divide(LHSWorkspace=spectra_name, RHSWorkspace=van_rebinned, OutputWorkspace=spectra_name)
common.remove_intermediate_workspace(van_rebinned)
return spectra_name
def _apply_van_calibration_tof_rebinning(self, vanadium_ws, tof_rebin_pass, return_units):
tof_rebin_param_dict = self._get_create_van_tof_binning()
tof_rebin_param = tof_rebin_param_dict[str(tof_rebin_pass)]
rebinned_ws = mantid.ConvertUnits(InputWorkspace=vanadium_ws, Target="TOF")
rebinned_ws = mantid.Rebin(InputWorkspace=rebinned_ws, Params=tof_rebin_param)
rebinned_ws = mantid.ConvertUnits(InputWorkspace=rebinned_ws, Target=return_units)
common.remove_intermediate_workspace(vanadium_ws)
vanadium_ws = rebinned_ws
return vanadium_ws
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 _normalise_ws_current(self, ws_to_correct):
monitor_spectra = self._inst_settings.monitor_spec_no
monitor_ws = common.extract_single_spectrum(ws_to_process=ws_to_correct,
spectrum_number_to_extract=monitor_spectra)
normalised_ws = pearl_algs.normalise_ws_current(ws_to_correct=ws_to_correct, monitor_ws=monitor_ws,
spline_coeff=self._inst_settings.monitor_spline,
integration_range=self._inst_settings.monitor_integration_range,
lambda_values=self._inst_settings.monitor_lambda,
ex_regions=self._inst_settings.monitor_mask_regions)
common.remove_intermediate_workspace(monitor_ws)
return normalised_ws
def attenuate_workspace(attenuation_file_path, ws_to_correct):
original_units = ws_to_correct.getAxis(0).getUnit().unitID()
wc_attenuated = mantid.PearlMCAbsorption(attenuation_file_path)
wc_attenuated = mantid.ConvertToHistogram(InputWorkspace=wc_attenuated, OutputWorkspace=wc_attenuated)
ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct, OutputWorkspace=ws_to_correct,
Target=wc_attenuated.getAxis(0).getUnit().unitID())
wc_attenuated = mantid.RebinToWorkspace(WorkspaceToRebin=wc_attenuated, WorkspaceToMatch=ws_to_correct,
OutputWorkspace=wc_attenuated)
pearl_attenuated_ws = mantid.Divide(LHSWorkspace=ws_to_correct, RHSWorkspace=wc_attenuated)
common.remove_intermediate_workspace(workspaces=wc_attenuated)
pearl_attenuated_ws = mantid.ConvertUnits(InputWorkspace=pearl_attenuated_ws, OutputWorkspace=pearl_attenuated_ws,
Target=original_units)
return pearl_attenuated_ws
def _normalise_ws_current(self, ws_to_correct):
monitor_spectra = self._inst_settings.monitor_spec_no
monitor_ws = common.extract_single_spectrum(ws_to_process=ws_to_correct,
spectrum_number_to_extract=monitor_spectra)
normalised_ws = pearl_algs.normalise_ws_current(ws_to_correct=ws_to_correct, monitor_ws=monitor_ws,
spline_coeff=self._inst_settings.monitor_spline,
integration_range=self._inst_settings.monitor_integration_range,
lambda_values=self._inst_settings.monitor_lambda,
ex_regions=self._inst_settings.monitor_mask_regions)
common.remove_intermediate_workspace(monitor_ws)
return normalised_ws
def _run_attenuate_workspace(self, input_workspace):
if self._old_atten_file is None: # For old API support
attenuation_path = self._attenuation_full_path
else:
attenuation_path = self._old_atten_file
wc_attenuated = mantid.PearlMCAbsorption(attenuation_path)
wc_attenuated = mantid.ConvertToHistogram(InputWorkspace=wc_attenuated, OutputWorkspace=wc_attenuated)
wc_attenuated = mantid.RebinToWorkspace(WorkspaceToRebin=wc_attenuated, WorkspaceToMatch=input_workspace,
OutputWorkspace=wc_attenuated)
pearl_attenuated_ws = mantid.Divide(LHSWorkspace=input_workspace, RHSWorkspace=wc_attenuated)
common.remove_intermediate_workspace(workspace_name=wc_attenuated)
return pearl_attenuated_ws
def attenuate_workspace(attenuation_file_path, ws_to_correct):
original_units = ws_to_correct.getAxis(0).getUnit().unitID()
wc_attenuated = mantid.PearlMCAbsorption(attenuation_file_path)
wc_attenuated = mantid.ConvertToHistogram(InputWorkspace=wc_attenuated, OutputWorkspace=wc_attenuated)
ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct, OutputWorkspace=ws_to_correct,
Target=wc_attenuated.getAxis(0).getUnit().unitID())
wc_attenuated = mantid.RebinToWorkspace(WorkspaceToRebin=wc_attenuated, WorkspaceToMatch=ws_to_correct,
OutputWorkspace=wc_attenuated)
pearl_attenuated_ws = mantid.Divide(LHSWorkspace=ws_to_correct, RHSWorkspace=wc_attenuated)
common.remove_intermediate_workspace(workspaces=wc_attenuated)
pearl_attenuated_ws = mantid.ConvertUnits(InputWorkspace=pearl_attenuated_ws, OutputWorkspace=pearl_attenuated_ws,
Target=original_units)
return pearl_attenuated_ws
def generate_vanadium_absorb_corrections(van_ws, output_filename):
shape_ws = mantid.CloneWorkspace(InputWorkspace=van_ws)
shape_ws = mantid.ConvertUnits(InputWorkspace=shape_ws, OutputWorkspace=shape_ws, Target="Wavelength")
mantid.CreateSampleShape(InputWorkspace=shape_ws, ShapeXML='<sphere id="sphere_1"> <centre x="0" y="0" z= "0" />\
<radius val="0.005" /> </sphere>')
absorb_ws = \
mantid.AbsorptionCorrection(InputWorkspace=shape_ws, AttenuationXSection="5.08",
ScatteringXSection="5.1", SampleNumberDensity="0.072",
NumberOfWavelengthPoints="25", ElementSize="0.05")
mantid.SaveNexus(Filename=output_filename,
InputWorkspace=absorb_ws, Append=False)
common.remove_intermediate_workspace(shape_ws)
return absorb_ws
def create_solid_angle_corrections(self, vanadium, run_details):
"""
Creates the solid angle corrections from a vanadium run, only applicable on HRPD otherwise return None
:param vanadium: The vanadium used to create this
:param run_details: the run details of to use
"""
if not self._inst_settings.do_solid_angle:
return
solid_angle = mantid.SolidAngle(InputWorkspace=vanadium)
scale = mantid.CreateSingleValuedWorkspace(DataValue='100')
correction = mantid.Multiply(LHSWorkspace=solid_angle,
RHSWorkspace=scale)
eff = mantid.Divide(LHSWorkspace=vanadium, RHSWorkspace=correction)
eff = mantid.ConvertUnits(InputWorkspace=eff, Target='Wavelength')
eff = mantid.Integration(InputWorkspace=eff,
RangeLower='1.3999999999999999',
RangeUpper='3')
correction = mantid.Multiply(LHSWorkspace=correction, RHSWorkspace=eff)
scale = mantid.CreateSingleValuedWorkspace(DataValue='100000')
correction = mantid.Divide(LHSWorkspace=correction, RHSWorkspace=scale)
name = "sac" + common.generate_splined_name(run_details.run_number, [])
path = run_details.van_paths
mantid.SaveNexus(InputWorkspace=correction,
Filename=os.path.join(path, name))
common.remove_intermediate_workspace(solid_angle)
common.remove_intermediate_workspace(scale)
common.remove_intermediate_workspace(eff)
common.remove_intermediate_workspace(correction)
def apply_solid_angle_efficiency_corr(self, ws_to_correct, run_details):
if not self._apply_solid_angle:
return ws_to_correct
if not run_details or not os.path.isfile(run_details.solid_angle_corr):
corrections = self.generate_solid_angle_corrections(run_details)
else:
corrections = mantid.Load(Filename=run_details.solid_angle_corr)
corrected_ws = mantid.Divide(LHSWorkspace=ws_to_correct, RHSWorkspace=corrections)
common.remove_intermediate_workspace(corrections)
common.remove_intermediate_workspace(ws_to_correct)
ws_to_correct = corrected_ws
return ws_to_correct
def _apply_absorb_corrections(instrument, run_details, corrected_van_ws, gen_absorb):
corrected_van_ws = mantid.ConvertUnits(InputWorkspace=corrected_van_ws, Target="Wavelength")
if gen_absorb or not run_details.vanadium_absorption:
absorb_ws = instrument._generate_vanadium_absorb_corrections(run_details, corrected_van_ws)
else:
absorb_ws = mantid.LoadNexus(Filename=run_details.vanadium_absorption)
# PEARL rebins whilst POLARIS does not as some of the older absorption files have different number of bins
corrected_van_ws = instrument._calibration_rebin_to_workspace(ws_to_rebin=corrected_van_ws, ws_to_match=absorb_ws)
corrected_van_ws = mantid.Divide(LHSWorkspace=corrected_van_ws, RHSWorkspace=absorb_ws)
corrected_van_ws = mantid.ConvertUnits(InputWorkspace=corrected_van_ws, Target="dSpacing")
common.remove_intermediate_workspace(absorb_ws)
return corrected_van_ws
def generate_vanadium_absorb_corrections(van_ws, output_filename):
shape_ws = mantid.CloneWorkspace(InputWorkspace=van_ws)
shape_ws = mantid.ConvertUnits(InputWorkspace=shape_ws, OutputWorkspace=shape_ws, Target="Wavelength")
mantid.CreateSampleShape(InputWorkspace=shape_ws, ShapeXML='<sphere id="sphere_1"> <centre x="0" y="0" z= "0" />\
<radius val="0.005" /> </sphere>')
absorb_ws = \
mantid.AbsorptionCorrection(InputWorkspace=shape_ws, AttenuationXSection="5.08",
ScatteringXSection="5.1", SampleNumberDensity="0.072",
NumberOfWavelengthPoints="25", ElementSize="0.05")
mantid.SaveNexus(Filename=output_filename,
InputWorkspace=absorb_ws, Append=False)
common.remove_intermediate_workspace(shape_ws)
return absorb_ws
def create_van(instrument, run_details, absorb):
"""
Creates a splined vanadium run for the following instrument. Requires the run_details for the
vanadium workspace we will process and whether to apply absorption corrections.
:param instrument: The instrument object that will be used to supply various instrument specific methods
:param run_details: The run details associated with this vanadium run
:param absorb: Boolean flag whether to apply absorption corrections
:return: Processed workspace group in dSpacing (but not splined)
"""
van = run_details.vanadium_run_numbers
# Always sum a range of inputs as its a vanadium run over multiple captures
input_van_ws_list = common.load_current_normalised_ws_list(
run_number_string=van,
instrument=instrument,
input_batching=INPUT_BATCHING.Summed)
input_van_ws = input_van_ws_list[
0] # As we asked for a summed ws there should only be one returned
corrected_van_ws = common.subtract_summed_runs(
ws_to_correct=input_van_ws,
empty_sample_ws_string=run_details.empty_runs,
instrument=instrument)
# Crop the tail end of the data on PEARL if they are not capturing slow neutrons
corrected_van_ws = instrument._crop_raw_to_expected_tof_range(
ws_to_crop=corrected_van_ws)
if absorb:
corrected_van_ws = instrument._apply_absorb_corrections(
run_details=run_details, ws_to_correct=corrected_van_ws)
aligned_ws = mantid.AlignDetectors(
InputWorkspace=corrected_van_ws,
CalibrationFile=run_details.offset_file_path)
focused_vanadium = mantid.DiffractionFocussing(
InputWorkspace=aligned_ws,
GroupingFileName=run_details.grouping_file_path)
focused_spectra = common.extract_ws_spectra(focused_vanadium)
focused_spectra = instrument._crop_van_to_expected_tof_range(
focused_spectra)
d_spacing_group, tof_group = instrument._output_focused_ws(
processed_spectra=focused_spectra,
run_details=run_details,
output_mode="mods")
_create_vanadium_splines(focused_spectra, instrument, 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())
common.remove_intermediate_workspace(corrected_van_ws)
common.remove_intermediate_workspace(aligned_ws)
common.remove_intermediate_workspace(focused_vanadium)
common.remove_intermediate_workspace(focused_spectra)
return d_spacing_group
def _divide_by_vanadium_splines(spectra_list, vanadium_splines, instrument):
if hasattr(vanadium_splines, "OutputWorkspace"):
vanadium_splines = vanadium_splines.OutputWorkspace
if type(vanadium_splines) is WorkspaceGroup: # vanadium splines is a workspacegroup
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, instrument)
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, instrument)]
common.remove_intermediate_workspace(vanadium_splines)
return output_list
def apply_vanadium_absorb_corrections(van_ws, run_details, absorb_ws=None):
def generate_det_id_list(ws):
det_id_list = []
for i in range(0, ws.getNumberHistograms()):
try:
det_ids = ws.getSpectrum(i).getDetectorIDs()
except RuntimeError:
pass
else:
for det_id in det_ids:
det_id_list.append(det_id)
return det_id_list
if absorb_ws is None:
absorb_ws = mantid.Load(Filename=run_details.vanadium_absorption_path)
van_original_units = van_ws.getAxis(0).getUnit().unitID()
absorb_units = absorb_ws.getAxis(0).getUnit().unitID()
if van_original_units != absorb_units:
van_ws = mantid.ConvertUnits(InputWorkspace=van_ws, Target=absorb_units, OutputWorkspace=van_ws)
# PEARL sometimes do special runs with different detector cards so extract common spectra before doing
# RebinToWorkspace to ensure histogram by histogram by rebin
abs_det_id_list = generate_det_id_list(absorb_ws)
van_det_id_list = generate_det_id_list(van_ws)
common_det_ids = [det_id for det_id in abs_det_id_list if det_id in van_det_id_list]
if not common_det_ids:
raise RuntimeError("No common detectors in Vanadium and sample workspaces")
MSG_STEM = "Vanadium workspace and absorption workspaces have different spectra. "
if common_det_ids != van_det_id_list:
logger.warning(MSG_STEM + "Removing unmatched spectra from the Vanadium workspace")
van_ws = mantid.ExtractSpectra(InputWorkspace=van_ws, DetectorList=common_det_ids)
if common_det_ids != abs_det_id_list:
logger.warning(MSG_STEM + "Removing unmatched spectra from the absorption workspace")
absorb_ws = mantid.ExtractSpectra(InputWorkspace=absorb_ws, DetectorList=common_det_ids)
absorb_ws = mantid.RebinToWorkspace(WorkspaceToRebin=absorb_ws, WorkspaceToMatch=van_ws, OutputWorkspace=absorb_ws)
van_ws = mantid.Divide(LHSWorkspace=van_ws, RHSWorkspace=absorb_ws, OutputWorkspace=van_ws, AllowDifferentNumberSpectra=True)
if van_original_units != absorb_units:
van_ws = mantid.ConvertUnits(InputWorkspace=van_ws, Target=van_original_units, OutputWorkspace=van_ws)
common.remove_intermediate_workspace(absorb_ws)
return van_ws
def _generate_vanadium_absorb_corrections(self, calibration_full_paths, ws_to_match):
raise NotImplementedError("Generating absorption corrections needs to be implemented correctly")
# TODO are these values applicable to all instruments
shape_ws = mantid.CloneWorkspace(InputWorkspace=ws_to_match)
mantid.CreateSampleShape(InputWorkspace=shape_ws, ShapeXML='<sphere id="sphere_1"> <centre x="0" y="0" z= "0" />\
<radius val="0.005" /> </sphere>')
absorb_ws = \
mantid.AbsorptionCorrection(InputWorkspace=shape_ws, AttenuationXSection="5.08",
ScatteringXSection="5.1", SampleNumberDensity="0.072",
NumberOfWavelengthPoints="25", ElementSize="0.05")
mantid.SaveNexus(Filename=calibration_full_paths["vanadium_absorption"],
InputWorkspace=absorb_ws, Append=False)
common.remove_intermediate_workspace(shape_ws)
return absorb_ws
def generate_vanadium_absorb_corrections(van_ws):
raise NotImplementedError("Generating absorption corrections needs to be implemented correctly")
# TODO are these values applicable to all instruments
shape_ws = mantid.CloneWorkspace(InputWorkspace=van_ws)
mantid.CreateSampleShape(InputWorkspace=shape_ws, ShapeXML='<sphere id="sphere_1"> <centre x="0" y="0" z= "0" />\
<radius val="0.005" /> </sphere>')
calibration_full_paths = None
absorb_ws = \
mantid.AbsorptionCorrection(InputWorkspace=shape_ws, AttenuationXSection="5.08",
ScatteringXSection="5.1", SampleNumberDensity="0.072",
NumberOfWavelengthPoints="25", ElementSize="0.05")
mantid.SaveNexus(Filename=calibration_full_paths["vanadium_absorption"],
InputWorkspace=absorb_ws, Append=False)
common.remove_intermediate_workspace(shape_ws)
return absorb_ws
def apply_vanadium_absorb_corrections(van_ws, run_details, absorb_ws=None):
if absorb_ws is None:
absorb_ws = mantid.Load(Filename=run_details.vanadium_absorption_path)
van_original_units = van_ws.getAxis(0).getUnit().unitID()
absorb_units = absorb_ws.getAxis(0).getUnit().unitID()
if van_original_units != absorb_units:
van_ws = mantid.ConvertUnits(InputWorkspace=van_ws, Target=absorb_units, OutputWorkspace=van_ws)
absorb_ws = mantid.RebinToWorkspace(WorkspaceToRebin=absorb_ws, WorkspaceToMatch=van_ws, OutputWorkspace=absorb_ws)
van_ws = mantid.Divide(LHSWorkspace=van_ws, RHSWorkspace=absorb_ws, OutputWorkspace=van_ws)
if van_original_units != absorb_units:
van_ws = mantid.ConvertUnits(InputWorkspace=van_ws, Target=van_original_units, OutputWorkspace=van_ws)
common.remove_intermediate_workspace(absorb_ws)
return van_ws
def _spline_new2_background(in_workspace, num_splines, instrument_version):
# remove bragg peaks before spline
alg_range, unused = _get_instrument_ranges(instrument_version)
van_stripped_ws = _strip_peaks_new_inst(in_workspace, alg_range)
# run twice on low angle as peaks are very broad
for i in range(0, 2):
van_stripped_ws = mantid.StripPeaks(InputWorkspace=van_stripped_ws, FWHM=100, Tolerance=10,
WorkspaceIndex=12)
van_stripped_ws = mantid.StripPeaks(InputWorkspace=van_stripped_ws, FWHM=60, Tolerance=10,
WorkspaceIndex=13)
van_stripped_ws = mantid.ConvertUnits(InputWorkspace=van_stripped_ws, Target="TOF")
splined_ws_list = _perform_spline_range(instrument_version, num_splines, van_stripped_ws)
common.remove_intermediate_workspace(van_stripped_ws)
return splined_ws_list
def generate_ts_pdf(run_number, focus_file_path, merge_banks=False, q_lims=None, cal_file_name=None,
sample_details=None, output_binning=None, pdf_type="G(r)", freq_params=None):
focused_ws = _obtain_focused_run(run_number, focus_file_path)
focused_ws = mantid.ConvertUnits(InputWorkspace=focused_ws, Target="MomentumTransfer", EMode='Elastic')
raw_ws = mantid.Load(Filename='POLARIS'+str(run_number)+'.nxs')
sample_geometry = common.generate_sample_geometry(sample_details)
sample_material = common.generate_sample_material(sample_details)
self_scattering_correction = mantid.TotScatCalculateSelfScattering(InputWorkspace=raw_ws,
CalFileName=cal_file_name,
SampleGeometry=sample_geometry,
SampleMaterial=sample_material)
ws_group_list = []
for i in range(self_scattering_correction.getNumberHistograms()):
ws_name = 'correction_' + str(i)
mantid.ExtractSpectra(InputWorkspace=self_scattering_correction, OutputWorkspace=ws_name,
WorkspaceIndexList=[i])
ws_group_list.append(ws_name)
self_scattering_correction = mantid.GroupWorkspaces(InputWorkspaces=ws_group_list)
self_scattering_correction = mantid.RebinToWorkspace(WorkspaceToRebin=self_scattering_correction,
WorkspaceToMatch=focused_ws)
focused_ws = mantid.Subtract(LHSWorkspace=focused_ws, RHSWorkspace=self_scattering_correction)
if merge_banks:
q_min, q_max = _load_qlims(q_lims)
merged_ws = mantid.MatchAndMergeWorkspaces(InputWorkspaces=focused_ws, XMin=q_min, XMax=q_max,
CalculateScale=False)
fast_fourier_filter(merged_ws, freq_params)
pdf_output = mantid.PDFFourierTransform(Inputworkspace="merged_ws", InputSofQType="S(Q)-1", PDFType=pdf_type,
Filter=True)
else:
for ws in focused_ws:
fast_fourier_filter(ws, freq_params)
pdf_output = mantid.PDFFourierTransform(Inputworkspace='focused_ws', InputSofQType="S(Q)-1",
PDFType=pdf_type, Filter=True)
pdf_output = mantid.RebinToWorkspace(WorkspaceToRebin=pdf_output, WorkspaceToMatch=pdf_output[4],
PreserveEvents=True)
common.remove_intermediate_workspace('self_scattering_correction')
if output_binning is not None:
try:
pdf_output = mantid.Rebin(InputWorkspace=pdf_output, Params=output_binning)
except RuntimeError:
return pdf_output
return pdf_output
def _spline_background(self, focused_vanadium_ws, spline_number, instrument_version=''):
if spline_number is None:
spline_number = 100
mode = "spline" # TODO support spline modes for all instruments
extracted_spectra = _extract_bank_spectra(focused_vanadium_ws, self._number_of_banks)
if mode == "spline":
output = self._mask_spline_vanadium_ws(vanadium_spectra_list=extracted_spectra,
spline_coefficient=spline_number)
else:
raise NotImplementedError("Other vanadium processing methods not yet implemented")
for ws in extracted_spectra:
common.remove_intermediate_workspace(ws)
return output
def normalise_ws_current(ws_to_correct, monitor_ws, spline_coeff,
lambda_values, integration_range):
processed_monitor_ws = mantid.ConvertUnits(InputWorkspace=monitor_ws,
Target="Wavelength")
processed_monitor_ws = mantid.CropWorkspace(
InputWorkspace=processed_monitor_ws,
XMin=lambda_values[0],
XMax=lambda_values[-1])
# TODO move these masks to the adv. config file
ex_regions = numpy.zeros((2, 4))
ex_regions[:, 0] = [3.45, 3.7]
ex_regions[:, 1] = [2.96, 3.2]
ex_regions[:, 2] = [2.1, 2.26]
ex_regions[:, 3] = [1.73, 1.98]
for reg in range(0, 4):
processed_monitor_ws = mantid.MaskBins(
InputWorkspace=processed_monitor_ws,
XMin=ex_regions[0, reg],
XMax=ex_regions[1, reg])
splined_monitor_ws = mantid.SplineBackground(
InputWorkspace=processed_monitor_ws,
WorkspaceIndex=0,
NCoeff=spline_coeff)
normalised_ws = mantid.ConvertUnits(InputWorkspace=ws_to_correct,
Target="Wavelength",
OutputWorkspace=ws_to_correct)
normalised_ws = mantid.NormaliseToMonitor(
InputWorkspace=normalised_ws,
MonitorWorkspace=splined_monitor_ws,
IntegrationRangeMin=integration_range[0],
IntegrationRangeMax=integration_range[-1],
OutputWorkspace=normalised_ws)
normalised_ws = mantid.ConvertUnits(InputWorkspace=normalised_ws,
Target="TOF",
OutputWorkspace=normalised_ws)
common.remove_intermediate_workspace(processed_monitor_ws)
common.remove_intermediate_workspace(splined_monitor_ws)
return normalised_ws
def create_calibration(calibration_runs, instrument, offset_file_name, grouping_file_name, calibration_dir,
rebin_1_params, rebin_2_params, cross_correlate_params, get_det_offset_params):
"""
Create a calibration file from (usually) a ceria run
:param calibration_runs: Run number(s) for this run
:param instrument: The PEARL instrument object
:param offset_file_name: Name of the file to write detector offset information to
:param grouping_file_name: Name of grouping calibration file
:param calibration_dir: Path to directory containing calibration information
:param rebin_1_params: Parameters for the first rebin step (as a string in the usual format)
:param rebin_2_params: Parameters for the second rebin step (as a string in the usual format)
:param cross_correlate_params: Parameters for CrossCorrelate (as a dictionary PropertyName: PropertyValue)
:param get_det_offset_params: Parameters for GetDetectorOffsets (as a dictionary PropertyName: PropertyValue)
"""
input_ws_list = common.load_current_normalised_ws_list(run_number_string=calibration_runs, instrument=instrument,
input_batching=INPUT_BATCHING.Summed)
input_ws = input_ws_list[0]
calibration_ws = mantid.Rebin(InputWorkspace=input_ws, Params=rebin_1_params)
if calibration_ws.getAxis(0).getUnit().unitID() != WORKSPACE_UNITS.d_spacing:
calibration_ws = mantid.ConvertUnits(InputWorkspace=calibration_ws, Target="dSpacing")
rebinned = mantid.Rebin(InputWorkspace=calibration_ws, Params=rebin_2_params)
cross_correlated = mantid.CrossCorrelate(InputWorkspace=rebinned, **cross_correlate_params)
offset_file = os.path.join(calibration_dir, offset_file_name)
# Offsets workspace must be referenced as string so it can be deleted, as simpleapi doesn't recognise it as a ws
offsets_ws_name = "offsets"
mantid.GetDetectorOffsets(InputWorkspace=cross_correlated, GroupingFileName=offset_file,
OutputWorkspace=offsets_ws_name, **get_det_offset_params)
rebinned_tof = mantid.ConvertUnits(InputWorkspace=rebinned, Target="TOF")
aligned = mantid.AlignDetectors(InputWorkspace=rebinned_tof, CalibrationFile=offset_file)
grouping_file = os.path.join(calibration_dir, grouping_file_name)
focused = mantid.DiffractionFocussing(InputWorkspace=aligned, GroupingFileName=grouping_file,
OutputWorkspace=instrument._generate_output_file_name(calibration_runs)
+ "_grouped")
common.remove_intermediate_workspace([calibration_ws, rebinned, cross_correlated, rebinned_tof, aligned,
offsets_ws_name])
return focused
def _do_silicon_calibration(self, runs_to_process, cal_file_name, grouping_file_name):
# TODO fix all of this as the script is too limited to be useful
create_si_ws = common.load_current_normalised_ws(run_number_string=runs_to_process, instrument=self)
cycle_details = self._get_label_information(runs_to_process)
instrument_version = cycle_details["instrument_version"]
if instrument_version == "new" or instrument_version == "new2":
create_si_ws = mantid.Rebin(InputWorkspace=create_si_ws, Params="100,-0.0006,19950")
create_si_d_spacing_ws = mantid.ConvertUnits(InputWorkspace=create_si_ws, Target="dSpacing")
if instrument_version == "new2":
create_si_d_spacing_rebin_ws = mantid.Rebin(InputWorkspace=create_si_d_spacing_ws, Params="1.71,0.002,2.1")
create_si_cross_corr_ws = mantid.CrossCorrelate(InputWorkspace=create_si_d_spacing_rebin_ws,
ReferenceSpectra=20, WorkspaceIndexMin=9,
WorkspaceIndexMax=1063, XMin=1.71, XMax=2.1)
elif instrument_version == "new":
create_si_d_spacing_rebin_ws = mantid.Rebin(InputWorkspace=create_si_d_spacing_ws, Params="1.85,0.002,2.05")
create_si_cross_corr_ws = mantid.CrossCorrelate(InputWorkspace=create_si_d_spacing_rebin_ws,
ReferenceSpectra=20, WorkspaceIndexMin=9,
WorkspaceIndexMax=943, XMin=1.85, XMax=2.05)
elif instrument_version == "old":
create_si_d_spacing_rebin_ws = mantid.Rebin(InputWorkspace=create_si_d_spacing_ws, Params="3,0.002,3.2")
create_si_cross_corr_ws = mantid.CrossCorrelate(InputWorkspace=create_si_d_spacing_rebin_ws,
ReferenceSpectra=500, WorkspaceIndexMin=1,
WorkspaceIndexMax=1440, XMin=3, XMax=3.2)
else:
raise NotImplementedError("The instrument version is not supported for creating a silicon calibration")
common.remove_intermediate_workspace(create_si_d_spacing_ws)
common.remove_intermediate_workspace(create_si_d_spacing_rebin_ws)
calibration_output_path = self.calibration_dir + cal_file_name
create_si_offsets_ws = mantid.GetDetectorOffsets(InputWorkspace=create_si_cross_corr_ws,
Step=0.002, DReference=1.920127251, XMin=-200, XMax=200,
GroupingFileName=calibration_output_path)
create_si_aligned_ws = mantid.AlignDetectors(InputWorkspace=create_si_ws,
CalibrationFile=calibration_output_path)
grouping_output_path = self.calibration_dir + grouping_file_name
create_si_grouped_ws = mantid.DiffractionFocussing(InputWorkspace=create_si_aligned_ws,
GroupingFileName=grouping_output_path)
del create_si_offsets_ws, create_si_grouped_ws
def generate_ts_pdf(run_number,
focus_file_path,
merge_banks=False,
q_lims=None):
focused_ws = _obtain_focused_run(run_number, focus_file_path)
if merge_banks:
pdf_output = _generate_grouped_ts_pdf(focused_ws, q_lims)
else:
focused_ws = mantid.ConvertUnits(InputWorkspace=focused_ws.name(),
Target="MomentumTransfer")
pdf_output = mantid.PDFFourierTransform(Inputworkspace=focused_ws,
InputSofQType="S(Q)",
PDFType="G(r)",
Filter=True)
pdf_output = mantid.RebinToWorkspace(WorkspaceToRebin=pdf_output,
WorkspaceToMatch=pdf_output[4],
PreserveEvents=True)
common.remove_intermediate_workspace('focused_ws')
return pdf_output
def correct_sample_vanadium(self, focused_ws, index, vanadium_ws=None):
data_ws = mantid.ExtractSingleSpectrum(InputWorkspace=focused_ws, WorkspaceIndex=index)
data_ws = mantid.ConvertUnits(InputWorkspace=data_ws, Target="TOF")
data_ws = mantid.Rebin(InputWorkspace=data_ws, Params=self._focus_tof_binning)
if vanadium_ws:
data_processed = "van_processed" + str(index) # Workaround for Mantid overwriting the WS in a loop
vanadium_ws = mantid.Rebin(InputWorkspace=vanadium_ws, Params=self._focus_tof_binning)
data_ws = mantid.Divide(LHSWorkspace=data_ws, RHSWorkspace=vanadium_ws, OutputWorkspace=data_processed)
else:
data_processed = "processed-" + str(index)
mantid.CropWorkspace(InputWorkspace=data_ws, XMin=0.1, OutputWorkspace=data_processed)
if vanadium_ws:
mantid.Scale(InputWorkspace=data_processed, Factor=10, OutputWorkspace=data_processed)
common.remove_intermediate_workspace(data_ws)
return data_processed
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 _divide_sample_by_vanadium(instrument, run_number, input_workspace, perform_vanadium_norm):
processed_spectra = []
run_details = instrument._get_run_details(run_number=run_number)
alg_range, save_range = instrument._get_instrument_alg_save_ranges(run_details.instrument_version)
for index in range(0, alg_range):
if perform_vanadium_norm:
vanadium_ws = mantid.LoadNexus(Filename=run_details.splined_vanadium, EntryNumber=index + 1)
processed_spectra.append(
instrument.correct_sample_vanadium(focused_ws=input_workspace, index=index, vanadium_ws=vanadium_ws))
common.remove_intermediate_workspace(vanadium_ws)
else:
processed_spectra.append(
instrument.correct_sample_vanadium(focused_ws=input_workspace, index=index))
return processed_spectra
def create_van(instrument, run_details, absorb):
"""
Creates a splined vanadium run for the following instrument. Requires the run_details for the
vanadium workspace we will process and whether to apply absorption corrections.
:param instrument: The instrument object that will be used to supply various instrument specific methods
:param run_details: The run details associated with this vanadium run
:param absorb: Boolean flag whether to apply absorption corrections
:return: Processed workspace group in dSpacing (but not splined)
"""
van = run_details.vanadium_run_numbers
# Always sum a range of inputs as its a vanadium run over multiple captures
input_van_ws_list = common.load_current_normalised_ws_list(run_number_string=van, instrument=instrument,
input_batching=INPUT_BATCHING.Summed)
input_van_ws = input_van_ws_list[0] # As we asked for a summed ws there should only be one returned
corrected_van_ws = common.subtract_summed_runs(ws_to_correct=input_van_ws,
empty_sample_ws_string=run_details.empty_runs,
instrument=instrument)
# Crop the tail end of the data on PEARL if they are not capturing slow neutrons
corrected_van_ws = instrument._crop_raw_to_expected_tof_range(ws_to_crop=corrected_van_ws)
if absorb:
corrected_van_ws = instrument._apply_absorb_corrections(run_details=run_details,
ws_to_correct=corrected_van_ws)
else:
# Assume that create_van only uses Vanadium runs
mantid.SetSampleMaterial(InputWorkspace=corrected_van_ws, ChemicalFormula='V')
aligned_ws = mantid.AlignDetectors(InputWorkspace=corrected_van_ws,
CalibrationFile=run_details.offset_file_path)
focused_vanadium = mantid.DiffractionFocussing(InputWorkspace=aligned_ws,
GroupingFileName=run_details.grouping_file_path)
focused_spectra = common.extract_ws_spectra(focused_vanadium)
focused_spectra = instrument._crop_van_to_expected_tof_range(focused_spectra)
d_spacing_group, tof_group = instrument._output_focused_ws(processed_spectra=focused_spectra,
run_details=run_details)
_create_vanadium_splines(focused_spectra, instrument, 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())
common.remove_intermediate_workspace(corrected_van_ws)
common.remove_intermediate_workspace(aligned_ws)
common.remove_intermediate_workspace(focused_vanadium)
common.remove_intermediate_workspace(focused_spectra)
return d_spacing_group
def _normalise_current_ws(self, ws_to_correct, load_monitor_ws, spline_terms):
get_monitor_ws = mantid.ConvertUnits(InputWorkspace=load_monitor_ws, Target="Wavelength")
common.remove_intermediate_workspace(load_monitor_ws)
lmin, lmax = self._get_lambda_range()
get_monitor_ws = mantid.CropWorkspace(InputWorkspace=get_monitor_ws, XMin=lmin, XMax=lmax)
ex_regions = numpy.zeros((2, 4))
ex_regions[:, 0] = [3.45, 3.7]
ex_regions[:, 1] = [2.96, 3.2]
ex_regions[:, 2] = [2.1, 2.26]
ex_regions[:, 3] = [1.73, 1.98]
for reg in range(0, 4):
get_monitor_ws = mantid.MaskBins(InputWorkspace=get_monitor_ws, XMin=ex_regions[0, reg],
XMax=ex_regions[1, reg])
monitor_ws = mantid.SplineBackground(InputWorkspace=get_monitor_ws, WorkspaceIndex=0, NCoeff=spline_terms)
normalised_ws = mantid.ConvertUnits(InputWorkspace=ws_to_correct, Target="Wavelength")
normalised_ws = mantid.NormaliseToMonitor(InputWorkspace=normalised_ws, MonitorWorkspace=monitor_ws,
IntegrationRangeMin=0.6, IntegrationRangeMax=5.0)
normalised_ws = mantid.ConvertUnits(InputWorkspace=normalised_ws, Target="TOF")
common.remove_intermediate_workspace(get_monitor_ws)
common.remove_intermediate_workspace(monitor_ws)
return normalised_ws
def _focus_mode_groups(cycle_information, output_file_paths, save_range, calibrated_spectra):
output_list = []
to_save = _sum_groups_of_three_ws(calibrated_spectra, output_file_paths)
workspaces_4_to_9_name = output_file_paths["output_name"] + "_mods4-9"
workspaces_4_to_9 = mantid.Plus(LHSWorkspace=to_save[1], RHSWorkspace=to_save[2])
workspaces_4_to_9 = mantid.Scale(InputWorkspace=workspaces_4_to_9, Factor=0.5,
OutputWorkspace=workspaces_4_to_9_name)
to_save.append(workspaces_4_to_9)
append = False
index = 1
for ws in to_save:
if cycle_information["instrument_version"] == "new":
mantid.SaveGSS(InputWorkspace=ws, Filename=output_file_paths["gss_filename"], Append=append,
Bank=index)
elif cycle_information["instrument_version"] == "new2":
mantid.SaveGSS(InputWorkspace=ws, Filename=output_file_paths["gss_filename"], Append=False,
Bank=index)
workspace_names = ws.name()
dspacing_ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=workspace_names, Target="dSpacing")
common.remove_intermediate_workspace(ws)
output_list.append(dspacing_ws)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=dspacing_ws, Append=append)
append = True
index += 1
for i in range(0, save_range):
monitor_ws_name = output_file_paths["output_name"] + "_mod" + str(i + 10)
monitor_ws = calibrated_spectra[i + 9]
to_save = mantid.CloneWorkspace(InputWorkspace=monitor_ws, OutputWorkspace=monitor_ws_name)
mantid.SaveGSS(InputWorkspace=to_save, Filename=output_file_paths["gss_filename"], Append=True, Bank=i + 5)
to_save = mantid.ConvertUnits(InputWorkspace=to_save, OutputWorkspace=monitor_ws_name, Target="dSpacing")
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=to_save, Append=True)
output_list.append(to_save)
return output_list
def _run_focus(instrument, run_number, perform_attenuation, perform_vanadium_norm):
# Read
read_ws = common.load_current_normalised_ws(run_number_string=run_number, instrument=instrument)
input_workspace = instrument._do_tof_rebinning_focus(read_ws) # Rebins for PEARL
run_details = instrument._get_run_details(run_number=run_number)
# Check the necessary splined vanadium file has been created
if not os.path.isfile(run_details.splined_vanadium):
raise ValueError("Processed vanadium runs not found at this path: "
+ str(run_details.splined_vanadium) +
" \n\nHave you created a vanadium calibration with these settings yet?")
# Compensate for empty sample if specified
input_workspace = common.subtract_sample_empty(ws_to_correct=input_workspace, instrument=instrument,
empty_sample_ws_string=run_details.sample_empty)
# Align / Focus
input_workspace = mantid.AlignDetectors(InputWorkspace=input_workspace,
CalibrationFile=run_details.calibration)
input_workspace = instrument.apply_solid_angle_efficiency_corr(ws_to_correct=input_workspace,
run_details=run_details)
focused_ws = mantid.DiffractionFocussing(InputWorkspace=input_workspace,
GroupingFileName=run_details.grouping)
# Process
rebinning_params = instrument.calculate_focus_binning_params(sample=focused_ws)
calibrated_spectra = _divide_sample_by_vanadium(instrument=instrument, run_number=run_number,
input_workspace=focused_ws,
perform_vanadium_norm=perform_vanadium_norm)
_apply_binning_to_spectra(spectra_list=calibrated_spectra, binning_list=rebinning_params)
# Output
processed_nexus_files = instrument._process_focus_output(calibrated_spectra, run_details=run_details,
attenuate=perform_attenuation)
# Tidy
common.remove_intermediate_workspace(read_ws)
common.remove_intermediate_workspace(input_workspace)
common.remove_intermediate_workspace(focused_ws)
for ws in calibrated_spectra:
common.remove_intermediate_workspace(ws)
pass
return processed_nexus_files
def create_van(instrument, van, empty, output_van_file_name, num_of_splines, absorb, gen_absorb):
input_van_ws = common.load_current_normalised_ws(run_number_string=van, instrument=instrument)
corrected_van_ws = common.subtract_sample_empty(ws_to_correct=input_van_ws, empty_sample_ws_string=empty,
instrument=instrument)
common.remove_intermediate_workspace(input_van_ws)
run_details = instrument._get_run_details(run_number=van)
corrected_van_ws = instrument. _apply_van_calibration_tof_rebinning(vanadium_ws=corrected_van_ws,
tof_rebin_pass=1, return_units="TOF")
corrected_van_ws = mantid.AlignDetectors(InputWorkspace=corrected_van_ws,
CalibrationFile=run_details.calibration)
corrected_van_ws = instrument.apply_solid_angle_efficiency_corr(ws_to_correct=corrected_van_ws,
run_details=run_details)
if absorb:
corrected_van_ws = _apply_absorb_corrections(instrument=instrument,
run_details=run_details,
corrected_van_ws=corrected_van_ws, gen_absorb=gen_absorb)
focused_van_file = mantid.DiffractionFocussing(InputWorkspace=corrected_van_ws,
GroupingFileName=run_details.grouping)
# Optional
focused_van_file = instrument. _apply_van_calibration_tof_rebinning(vanadium_ws=focused_van_file,
tof_rebin_pass=2, return_units="dSpacing")
common.remove_intermediate_workspace(corrected_van_ws)
cycle_information = instrument._get_run_details(run_number=van)
splined_ws_list = instrument._spline_background(focused_van_file, num_of_splines,
cycle_information.instrument_version)
# Figure out who will provide the path name
if instrument._PEARL_filename_is_full_path():
out_van_file_path = output_van_file_name
elif output_van_file_name:
# The user has manually specified the output file
out_van_file_path = os.path.join(instrument.calibration_dir, output_van_file_name)
elif run_details.splined_vanadium:
out_van_file_path = run_details.splined_vanadium
else:
raise ValueError("The output name must be manually specified for this instrument/run")
append = False
for ws in splined_ws_list:
mantid.SaveNexus(Filename=out_van_file_path, InputWorkspace=ws, Append=append)
common.remove_intermediate_workspace(ws)
append = True
output_ws = mantid.LoadNexus(Filename=out_van_file_path, OutputWorkspace="Van_data")
return output_ws
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_calibration(self, calibration_runs, offset_file_name,
grouping_file_name):
input_ws_list = common.load_current_normalised_ws_list(
run_number_string=calibration_runs,
instrument=self,
input_batching=INPUT_BATCHING.Summed)
input_ws = input_ws_list[0]
run_details = self._get_run_details(calibration_runs)
if run_details.instrument_version == "new" or run_details.instrument_version == "new2":
input_ws = mantid.Rebin(InputWorkspace=input_ws,
Params="100,-0.0006,19950")
d_spacing_cal = mantid.ConvertUnits(InputWorkspace=input_ws,
Target="dSpacing")
d_spacing_cal = mantid.Rebin(InputWorkspace=d_spacing_cal,
Params="1.8,0.002,2.1")
if run_details.instrument_version == "new2":
cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal,
ReferenceSpectra=20,
WorkspaceIndexMin=9,
WorkspaceIndexMax=1063,
XMin=1.8,
XMax=2.1)
elif run_details.instrument_version == "new":
cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal,
ReferenceSpectra=20,
WorkspaceIndexMin=9,
WorkspaceIndexMax=943,
XMin=1.8,
XMax=2.1)
else:
cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal,
ReferenceSpectra=500,
WorkspaceIndexMin=1,
WorkspaceIndexMax=1440,
XMin=1.8,
XMax=2.1)
if self._old_api_uses_full_paths: # Workaround for old API setting full paths
grouping_file_path = grouping_file_name
offset_file_path = offset_file_name
else:
offset_file_path = os.path.join(self.calibration_dir, offset_file_name)
grouping_file_path = os.path.join(self.calibration_dir,
grouping_file_name)
# Ceo Cell refined to 5.4102(3) so 220 is 1.912795
offset_output_path = mantid.GetDetectorOffsets(
InputWorkspace=cross_cor_ws,
Step=0.002,
DReference=1.912795,
XMin=-200,
XMax=200,
GroupingFileName=offset_file_path)
del offset_output_path # This isn't used so delete it to keep linters happy
aligned_ws = mantid.AlignDetectors(InputWorkspace=input_ws,
CalibrationFile=offset_file_path)
cal_grouped_ws = mantid.DiffractionFocussing(
InputWorkspace=aligned_ws, GroupingFileName=grouping_file_path)
common.remove_intermediate_workspace(d_spacing_cal)
common.remove_intermediate_workspace(cross_cor_ws)
common.remove_intermediate_workspace(aligned_ws)
common.remove_intermediate_workspace(cal_grouped_ws)
def do_silicon_calibration(self, runs_to_process, cal_file_name,
grouping_file_name):
# TODO fix all of this as the script is too limited to be useful
create_si_ws = common.load_current_normalised_ws_list(
run_number_string=runs_to_process, instrument=self)
cycle_details = self._get_label_information(runs_to_process)
instrument_version = cycle_details["instrument_version"]
if instrument_version == "new" or instrument_version == "new2":
create_si_ws = mantid.Rebin(InputWorkspace=create_si_ws,
Params="100,-0.0006,19950")
create_si_d_spacing_ws = mantid.ConvertUnits(InputWorkspace=create_si_ws,
Target="dSpacing")
if instrument_version == "new2":
create_si_d_spacing_rebin_ws = mantid.Rebin(
InputWorkspace=create_si_d_spacing_ws, Params="1.71,0.002,2.1")
create_si_cross_corr_ws = mantid.CrossCorrelate(
InputWorkspace=create_si_d_spacing_rebin_ws,
ReferenceSpectra=20,
WorkspaceIndexMin=9,
WorkspaceIndexMax=1063,
XMin=1.71,
XMax=2.1)
elif instrument_version == "new":
create_si_d_spacing_rebin_ws = mantid.Rebin(
InputWorkspace=create_si_d_spacing_ws, Params="1.85,0.002,2.05")
create_si_cross_corr_ws = mantid.CrossCorrelate(
InputWorkspace=create_si_d_spacing_rebin_ws,
ReferenceSpectra=20,
WorkspaceIndexMin=9,
WorkspaceIndexMax=943,
XMin=1.85,
XMax=2.05)
elif instrument_version == "old":
create_si_d_spacing_rebin_ws = mantid.Rebin(
InputWorkspace=create_si_d_spacing_ws, Params="3,0.002,3.2")
create_si_cross_corr_ws = mantid.CrossCorrelate(
InputWorkspace=create_si_d_spacing_rebin_ws,
ReferenceSpectra=500,
WorkspaceIndexMin=1,
WorkspaceIndexMax=1440,
XMin=3,
XMax=3.2)
else:
raise NotImplementedError(
"The instrument version is not supported for creating a silicon calibration"
)
common.remove_intermediate_workspace(create_si_d_spacing_ws)
common.remove_intermediate_workspace(create_si_d_spacing_rebin_ws)
calibration_output_path = self.calibration_dir + cal_file_name
create_si_offsets_ws = mantid.GetDetectorOffsets(
InputWorkspace=create_si_cross_corr_ws,
Step=0.002,
DReference=1.920127251,
XMin=-200,
XMax=200,
GroupingFileName=calibration_output_path)
create_si_aligned_ws = mantid.AlignDetectors(
InputWorkspace=create_si_ws, CalibrationFile=calibration_output_path)
grouping_output_path = self.calibration_dir + grouping_file_name
create_si_grouped_ws = mantid.DiffractionFocussing(
InputWorkspace=create_si_aligned_ws,
GroupingFileName=grouping_output_path)
del create_si_offsets_ws, create_si_grouped_ws
def _focus_one_ws(ws, run_number, instrument, perform_vanadium_norm, absorb):
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
input_workspace = common.subtract_summed_runs(
ws_to_correct=ws,
instrument=instrument,
empty_sample_ws_string=run_details.empty_runs)
# Subtract a sample empty if specified
if run_details.sample_empty:
input_workspace = common.subtract_summed_runs(
ws_to_correct=input_workspace,
instrument=instrument,
empty_sample_ws_string=run_details.sample_empty,
scale_factor=instrument._inst_settings.sample_empty_scale)
# Crop to largest acceptable TOF range
input_workspace = instrument._crop_raw_to_expected_tof_range(
ws_to_crop=input_workspace)
# Correct for absorption / multiple scattering if required
if absorb:
input_workspace = instrument._apply_absorb_corrections(
run_details=run_details, ws_to_correct=input_workspace)
# Align
aligned_ws = mantid.AlignDetectors(
InputWorkspace=input_workspace,
CalibrationFile=run_details.offset_file_path)
# Focus the spectra into banks
focused_ws = mantid.DiffractionFocussing(
InputWorkspace=aligned_ws,
GroupingFileName=run_details.grouping_file_path)
calibrated_spectra = _apply_vanadium_corrections(
instrument=instrument,
run_number=run_number,
input_workspace=focused_ws,
perform_vanadium_norm=perform_vanadium_norm)
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, run_details, absorb):
"""
Creates a splined vanadium run for the following instrument. Requires the run_details for the
vanadium workspace we will process and whether to apply absorption corrections.
:param instrument: The instrument object that will be used to supply various instrument specific methods
:param run_details: The run details associated with this vanadium run
:param absorb: Boolean flag whether to apply absorption corrections
:return: Processed workspace group in dSpacing (but not splined)
"""
van = run_details.vanadium_run_numbers
# Always sum a range of inputs as its a vanadium run over multiple captures
input_van_ws_list = common.load_current_normalised_ws_list(
run_number_string=van,
instrument=instrument,
input_batching=INPUT_BATCHING.Summed)
input_van_ws = input_van_ws_list[
0] # As we asked for a summed ws there should only be one returned
instrument.create_solid_angle_corrections(input_van_ws, run_details)
if not (run_details.empty_runs is None):
summed_empty = common.generate_summed_runs(
empty_sample_ws_string=run_details.empty_runs,
instrument=instrument)
mantid.SaveNexus(Filename=run_details.summed_empty_file_path,
InputWorkspace=summed_empty)
corrected_van_ws = common.subtract_summed_runs(
ws_to_correct=input_van_ws, empty_sample=summed_empty)
# Crop the tail end of the data on PEARL if they are not capturing slow neutrons
corrected_van_ws = instrument._crop_raw_to_expected_tof_range(
ws_to_crop=corrected_van_ws)
if absorb:
corrected_van_ws = instrument._apply_absorb_corrections(
run_details=run_details, ws_to_correct=corrected_van_ws)
else:
# Assume that create_van only uses Vanadium runs
mantid.SetSampleMaterial(InputWorkspace=corrected_van_ws,
ChemicalFormula='V')
mantid.ApplyDiffCal(InstrumentWorkspace=corrected_van_ws,
CalibrationFile=run_details.offset_file_path)
aligned_ws = mantid.ConvertUnits(InputWorkspace=corrected_van_ws,
Target="dSpacing")
solid_angle = instrument.get_solid_angle_corrections(
run_details.run_number, run_details)
if solid_angle:
aligned_ws = mantid.Divide(LHSWorkspace=aligned_ws,
RHSWorkspace=solid_angle)
mantid.DeleteWorkspace(solid_angle)
focused_vanadium = mantid.DiffractionFocussing(
InputWorkspace=aligned_ws,
GroupingFileName=run_details.grouping_file_path)
# convert back to TOF based on engineered detector positions
mantid.ApplyDiffCal(InstrumentWorkspace=focused_vanadium,
ClearCalibration=True)
focused_spectra = common.extract_ws_spectra(focused_vanadium)
focused_spectra = instrument._crop_van_to_expected_tof_range(
focused_spectra)
d_spacing_group, tof_group = instrument._output_focused_ws(
processed_spectra=focused_spectra, run_details=run_details)
_create_vanadium_splines(focused_spectra, instrument, 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())
common.remove_intermediate_workspace(corrected_van_ws)
common.remove_intermediate_workspace(aligned_ws)
common.remove_intermediate_workspace(focused_vanadium)
common.remove_intermediate_workspace(focused_spectra)
return d_spacing_group
def _focus_one_ws(input_workspace, run_number, instrument,
perform_vanadium_norm, absorb, sample_details,
vanadium_path):
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 and user hasn't turned empty subtraction off
if not common.runs_overlap(run_number, run_details.empty_runs
) and instrument.should_subtract_empty_inst():
input_workspace = common.subtract_summed_runs(
ws_to_correct=input_workspace,
instrument=instrument,
empty_sample_ws_string=run_details.empty_runs)
# Subtract a sample empty if specified
if run_details.sample_empty:
input_workspace = common.subtract_summed_runs(
ws_to_correct=input_workspace,
instrument=instrument,
empty_sample_ws_string=run_details.sample_empty,
scale_factor=instrument._inst_settings.sample_empty_scale)
# Crop to largest acceptable TOF range
input_workspace = instrument._crop_raw_to_expected_tof_range(
ws_to_crop=input_workspace)
# Correct for absorption / multiple scattering if required
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=common.generate_sample_geometry(sample_details),
Material=common.generate_sample_material(sample_details))
# Align
aligned_ws = mantid.AlignDetectors(
InputWorkspace=input_workspace,
CalibrationFile=run_details.offset_file_path)
# Focus the spectra into banks
focused_ws = mantid.DiffractionFocussing(
InputWorkspace=aligned_ws,
GroupingFileName=run_details.grouping_file_path)
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 generate_ts_pdf(run_number,
focus_file_path,
sample_details,
merge_banks=False,
q_lims=None,
cal_file_name=None,
delta_r=None,
delta_q=None,
pdf_type="G(r)",
lorch_filter=None,
freq_params=None,
debug=False):
if sample_details is None:
raise RuntimeError(
"A SampleDetails object was not set. Please create a SampleDetails object and set the "
"relevant properties it. Then set the new sample by calling set_sample_details()"
)
focused_ws = _obtain_focused_run(run_number, focus_file_path)
focused_ws = mantid.ConvertUnits(InputWorkspace=focused_ws,
Target="MomentumTransfer",
EMode='Elastic')
raw_ws = mantid.Load(Filename='POLARIS' + str(run_number))
sample_geometry_json = sample_details.generate_sample_geometry()
sample_material_json = sample_details.generate_sample_material()
self_scattering_correction = mantid.TotScatCalculateSelfScattering(
InputWorkspace=raw_ws,
CalFileName=cal_file_name,
SampleGeometry=sample_geometry_json,
SampleMaterial=sample_material_json)
ws_group_list = []
for i in range(self_scattering_correction.getNumberHistograms()):
ws_name = 'correction_' + str(i)
mantid.ExtractSpectra(InputWorkspace=self_scattering_correction,
OutputWorkspace=ws_name,
WorkspaceIndexList=[i])
ws_group_list.append(ws_name)
self_scattering_correction = mantid.GroupWorkspaces(
InputWorkspaces=ws_group_list)
self_scattering_correction = mantid.RebinToWorkspace(
WorkspaceToRebin=self_scattering_correction,
WorkspaceToMatch=focused_ws)
if not compare_ws_compatibility(focused_ws, self_scattering_correction):
raise RuntimeError(
"To use create_total_scattering_pdf you need to run focus with "
"do_van_normalisation=true first.")
focused_ws = mantid.Subtract(LHSWorkspace=focused_ws,
RHSWorkspace=self_scattering_correction)
if debug:
dcs_corrected = mantid.CloneWorkspace(InputWorkspace=focused_ws)
# convert diff cross section to S(Q) - 1
material_builder = MaterialBuilder()
sample = material_builder.setFormula(
sample_details.material_object.chemical_formula).build()
sample_total_scatter_cross_section = sample.totalScatterXSection()
sample_coh_scatter_cross_section = sample.cohScatterXSection()
focused_ws = focused_ws - sample_total_scatter_cross_section / (4 *
math.pi)
focused_ws = focused_ws * 4 * math.pi / sample_coh_scatter_cross_section
if debug:
s_of_q_minus_one = mantid.CloneWorkspace(InputWorkspace=focused_ws)
if delta_q:
focused_ws = mantid.Rebin(InputWorkspace=focused_ws, Params=delta_q)
if merge_banks:
q_min, q_max = _load_qlims(q_lims)
merged_ws = mantid.MatchAndMergeWorkspaces(InputWorkspaces=focused_ws,
XMin=q_min,
XMax=q_max,
CalculateScale=False)
fast_fourier_filter(merged_ws,
rho0=sample_details.material_object.number_density,
freq_params=freq_params)
pdf_output = mantid.PDFFourierTransform(
Inputworkspace="merged_ws",
InputSofQType="S(Q)-1",
PDFType=pdf_type,
Filter=lorch_filter,
DeltaR=delta_r,
rho0=sample_details.material_object.number_density)
else:
for ws in focused_ws:
fast_fourier_filter(
ws,
rho0=sample_details.material_object.number_density,
freq_params=freq_params)
pdf_output = mantid.PDFFourierTransform(
Inputworkspace='focused_ws',
InputSofQType="S(Q)-1",
PDFType=pdf_type,
Filter=lorch_filter,
DeltaR=delta_r,
rho0=sample_details.material_object.number_density)
pdf_output = mantid.RebinToWorkspace(WorkspaceToRebin=pdf_output,
WorkspaceToMatch=pdf_output[4],
PreserveEvents=True)
if not debug:
common.remove_intermediate_workspace('self_scattering_correction')
# Rename output ws
if 'merged_ws' in locals():
mantid.RenameWorkspace(InputWorkspace='merged_ws',
OutputWorkspace=run_number + '_merged_Q')
mantid.RenameWorkspace(InputWorkspace='focused_ws',
OutputWorkspace=run_number + '_focused_Q')
target_focus_ws_name = run_number + '_focused_Q_'
target_pdf_ws_name = run_number + '_pdf_R_'
if isinstance(focused_ws, WorkspaceGroup):
for i in range(len(focused_ws)):
if str(focused_ws[i]) != (target_focus_ws_name + str(i + 1)):
mantid.RenameWorkspace(InputWorkspace=focused_ws[i],
OutputWorkspace=target_focus_ws_name +
str(i + 1))
mantid.RenameWorkspace(InputWorkspace='pdf_output',
OutputWorkspace=run_number + '_pdf_R')
if isinstance(pdf_output, WorkspaceGroup):
for i in range(len(pdf_output)):
if str(pdf_output[i]) != (target_pdf_ws_name + str(i + 1)):
mantid.RenameWorkspace(InputWorkspace=pdf_output[i],
OutputWorkspace=target_pdf_ws_name +
str(i + 1))
return pdf_output
