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 spline_workspaces(focused_vanadium_spectra, num_splines):
"""
Splines a list of workspaces in TOF and returns the splines in new workspaces in a
list of said splined workspaces. The input workspaces should have any Bragg peaks
masked before performing this step.
:param focused_vanadium_spectra: The workspaces to spline as a list
:param num_splines: The coefficient to use within SplineBackground
:return: A list of splined workspaces
"""
tof_ws_list = []
for bank_index, ws in enumerate(focused_vanadium_spectra):
out_name = "spline_bank_" + str(bank_index + 1)
tof_ws_list.append(
mantid.ConvertUnits(InputWorkspace=ws,
Target="TOF",
OutputWorkspace=out_name))
splined_ws_list = []
for ws in tof_ws_list:
splined_ws_list.append(
mantid.SplineBackground(InputWorkspace=ws,
OutputWorkspace=ws,
NCoeff=num_splines))
return splined_ws_list
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 _perform_spline_range(instrument_version, num_splines, stripped_ws):
ws_range, unused = _get_instrument_ranges(instrument_version)
splined_ws_list = []
for i in range(0, ws_range):
out_ws_name = "spline" + str(i + 1)
splined_ws_list.append(mantid.SplineBackground(InputWorkspace=stripped_ws, OutputWorkspace=out_ws_name,
WorkspaceIndex=i, NCoeff=num_splines))
return splined_ws_list
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 _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 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
def process_vanadium(self,
vanadium,
empty,
panel,
height,
radius,
cycle_van="09_3",
cycle_empty="09_3"):
user_data_directory = self.use_folder + cycle_van + '/'
self.set_data_directory(user_data_directory)
self.datafile = self.get_file_name(vanadium, "raw")
vanadium_ws = self.read(vanadium, panel, "raw")
user_data_directory = self.use_folder + cycle_empty + '/'
self.set_data_directory(user_data_directory)
self.datafile = self.get_file_name(empty, "raw")
empty_ws = self.read(empty, panel, "raw")
simple.Minus(LHSWorkspace=vanadium_ws,
RHSWorkspace=empty_ws,
OutputWorkspace=vanadium_ws)
simple.DeleteWorkspace(empty_ws)
absorption_corrections(4.8756, height, 0.07118, radius, 5.16,
vanadium_ws)
vanfoc = self.focus(vanadium_ws, panel)
panel_crop = {
1: (0.95, 53.3),
2: (0.58, 13.1),
3: (0.44, 7.77),
4: (0.38, 5.86),
5: (0.35, 4.99),
6: (0.35, 4.99),
7: (0.38, 5.86),
8: (0.44, 7.77),
9: (0.58, 13.1),
10: (0.95, 53.3)
}
d_min, d_max = panel_crop.get(panel)
simple.CropWorkspace(InputWorkspace=vanfoc,
OutputWorkspace=vanfoc,
XMin=d_min,
XMax=d_max)
spline_coefficient = {
1: 120,
2: 120,
3: 120,
4: 130,
5: 140,
6: 140,
7: 130,
8: 120,
9: 120,
10: 120
}
simple.SplineBackground(InputWorkspace=vanfoc,
OutputWorkspace=vanfoc,
NCoeff=spline_coefficient.get(panel))
smoothing_coefficient = "30" if panel == 3 else "40"
simple.SmoothData(InputWorkspace=vanfoc,
OutputWorkspace=vanfoc,
NPoints=smoothing_coefficient)
return
