def _spline_old_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 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 _mask_prompt_pulse(workspace, middle, left_crop, right_crop):
min_crop = middle - left_crop
max_crop = middle + right_crop
mantid.MaskBins(InputWorkspace=workspace,
OutputWorkspace=workspace,
XMin=min_crop,
XMax=max_crop)
def _apply_bragg_peaks_masking(workspaces_to_mask, mask_list):
output_workspaces = list(workspaces_to_mask)
for ws_index, (bank_mask_list, workspace) in enumerate(zip(mask_list, output_workspaces)):
output_name = "masked_vanadium-" + str(ws_index + 1)
for mask_params in bank_mask_list:
output_workspaces[ws_index] = mantid.MaskBins(InputWorkspace=output_workspaces[ws_index],
OutputWorkspace=output_name,
XMin=mask_params[0], XMax=mask_params[1])
return output_workspaces
def _mask_prompt_pulses(self, ws):
left_crop = 30
right_crop = 140
for i in range(6):
middle = 100000 + 20000 * i
min_crop = middle - left_crop
max_crop = middle + right_crop
mantid.MaskBins(InputWorkspace=ws,
OutputWorkspace=ws,
XMin=min_crop,
XMax=max_crop)
def _mask_bins_and_spectra(ws, xmin, xmax, num_spectra, indices=None):
import mantid.simpleapi as mantid
masked_ws = mantid.MaskBins(ws,
XMin=xmin,
XMax=xmax,
InputWorkspaceIndexSet=indices)
# mask the first 3 spectra
for i in range(num_spectra):
masked_ws.spectrumInfo().setMasked(i, True)
return masked_ws
def _mask_prompt_pulses(self, ws):
left_crop = 30
right_crop = 140
pulse_interval = 20000
for i in range(1, 6):
middle = i * pulse_interval
min_crop = middle - left_crop
max_crop = middle + right_crop
mantid.MaskBins(InputWorkspace=ws,
OutputWorkspace=ws,
XMin=min_crop,
XMax=max_crop)
def read_event_nexus(self, number, output, panel):
simple.RenameWorkspace("{}_monitors".format(output),
"w{}_monitors".format(number))
simple.Rebin(InputWorkspace=output,
OutputWorkspace=output,
Params='6000,-0.00063,110000')
simple.ConvertToMatrixWorkspace(output, output)
spectra_min, spectra_max = self.return_panel.get(panel)
simple.CropWorkspace(InputWorkspace=output,
OutputWorkspace=output,
StartWorkspaceIndex=spectra_min - 6,
EndWorkspaceIndex=spectra_max - 6)
simple.MaskBins(InputWorkspace=output,
OutputWorkspace=output,
XMin=99900,
XMax=106000)
def apply_bragg_peaks_masking(workspaces_to_mask, mask_list):
"""
Mask a series of peaks defined by the lower/upper bounds
:param workspaces_to_mask: Mask these workspaces
:param mask_list: A list of pairs of peak X min/max for masking
:return: A list of masked workspaces
"""
output_workspaces = list(workspaces_to_mask)
for ws_index, (bank_mask_list, workspace) in enumerate(zip(mask_list, output_workspaces)):
output_name = "masked_vanadium-" + str(ws_index + 1)
for mask_params in bank_mask_list:
output_workspaces[ws_index] = mantid.MaskBins(InputWorkspace=output_workspaces[ws_index],
OutputWorkspace=output_name,
XMin=mask_params[0], XMax=mask_params[1])
return output_workspaces
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 _mask_prompt_pulses(self, ws):
"""
HRPD has a long flight path from the moderator resulting
in sharp peaks from the proton pulse that maintain their
sharp resolution. Here we mask these pulses out that occur
at 20ms intervals.
:param ws: The workspace containing the pulses. It is
masked in place.
"""
# The number of pulse can vary depending on the data range
# Compute number of pulses that occur at each 20ms interval.
x_data = ws.readX(0)
pulse_min = int(round(x_data[0]) / PROMPT_PULSE_INTERVAL) + 1
pulse_max = int(round(x_data[-1]) / PROMPT_PULSE_INTERVAL) + 1
for i in range(pulse_min, pulse_max):
centre = PROMPT_PULSE_INTERVAL * float(i)
mantid.MaskBins(InputWorkspace=ws, OutputWorkspace=ws,
XMin=centre - PROMPT_PULSE_LEFT_WIDTH,
XMax=centre + PROMPT_PULSE_RIGHT_WIDTH)
def _run_get_monitor(self, run_number, input_dir, spline_terms):
load_monitor_ws = common._load_monitor(run_number, input_dir=input_dir, instrument=self)
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]
# ConvertToDistribution(works)
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)
common.remove_intermediate_workspace(get_monitor_ws)
return monitor_ws
def shared_load_files(extension, filename, ws, spectrum_max, spectrum_min,
is_monitor):
if not (extension == "nxs" or extension == "raw" or extension[0] == "s"):
return False
if extension == "nxs":
simple.Load(Filename=filename,
OutputWorkspace=ws,
SpectrumMin=spectrum_min,
SpectrumMax=spectrum_min)
else:
simple.LoadRaw(Filename=filename,
OutputWorkspace=ws,
SpectrumMin=spectrum_min,
SpectrumMax=spectrum_max,
LoadLogFiles="0")
simple.Rebin(InputWorkspace=ws,
OutputWorkspace=ws,
Params='6000,-0.00063,110000')
if not is_monitor:
simple.MaskBins(InputWorkspace=ws,
OutputWorkspace=ws,
XMin=99900,
XMax=106000)
return True
def process_incidentmon(self, number, extension, spline_terms=20):
if type(number) is int:
filename = self.get_file_name(number, extension)
works = "monitor{}".format(number)
shared_load_files(extension, filename, works, 4, 4, True)
if extension[:9] == "nxs_event":
temp = "w{}_monitors".format(number)
works = "w{}_monitor4".format(number)
simple.Rebin(InputWorkspace=temp,
OutputWorkspace=temp,
Params='6000,-0.00063,110000',
PreserveEvents=False)
simple.ExtractSingleSpectrum(InputWorkspace=temp,
OutputWorkspace=works,
WorkspaceIndex=3)
else:
num_1, num_2 = split_run_string(number)
works = "monitor{0}_{1}".format(num_1, num_2)
filename = self.get_file_name(num_1, extension)
works1 = "monitor{}".format(num_1)
simple.LoadRaw(Filename=filename,
OutputWorkspace=works1,
SpectrumMin=4,
SpectrumMax=4,
LoadLogFiles="0")
filename = self.get_file_name(num_2, extension)
works2 = "monitor{}".format(num_2)
simple.LoadRaw(Filename=filename,
OutputWorkspace=works2,
SpectrumMin=4,
SpectrumMax=4,
LoadLogFiles="0")
simple.MergeRuns(InputWorkspaces=works1 + "," + works2,
OutputWorkspace=works)
simple.DeleteWorkspace(works1)
simple.DeleteWorkspace(works2)
simple.ConvertUnits(InputWorkspace=works,
OutputWorkspace=works,
Target="Wavelength",
Emode="Elastic")
lambda_min, lambda_max = Wish.LAMBDA_RANGE
simple.CropWorkspace(InputWorkspace=works,
OutputWorkspace=works,
XMin=lambda_min,
XMax=lambda_max)
ex_regions = np.array([[4.57, 4.76], [3.87, 4.12], [2.75, 2.91],
[2.24, 2.50]])
simple.ConvertToDistribution(works)
for reg in range(0, 4):
simple.MaskBins(InputWorkspace=works,
OutputWorkspace=works,
XMin=ex_regions[reg, 0],
XMax=ex_regions[reg, 1])
simple.SplineBackground(InputWorkspace=works,
OutputWorkspace=works,
WorkspaceIndex=0,
NCoeff=spline_terms)
simple.SmoothData(InputWorkspace=works,
OutputWorkspace=works,
NPoints=40)
simple.ConvertFromDistribution(works)
return works
