def _crop_single_ws_in_tof(ws_to_rebin, x_max, x_min):
"""
Implementation of cropping the single workspace in TOF. First converts to TOF, crops then converts
back to the original unit.
:param ws_to_rebin: The workspace to crop
:param x_max: (Optional) The minimum TOF values to crop to
:param x_min: (Optional) The maximum TOF values to crop to
:return: The cropped workspace with the original units
"""
previous_units = ws_to_rebin.getAxis(0).getUnit().unitID()
if previous_units != "TOF":
ws_to_rebin = mantid.ConvertUnits(InputWorkspace=ws_to_rebin,
Target="TOF",
OutputWorkspace=ws_to_rebin)
if x_min > x_max:
raise ValueError("XMin is larger than XMax. (" + str(x_min) + " > " +
str(x_max) + ")")
if x_max <= 1 and x_min <= 1: # If <= 1, cropping by fractions, not absolutes
x_axis = ws_to_rebin.dataX(0)
x_min = x_axis[0] * (1 + x_min)
x_max = x_axis[-1] * x_max
cropped_ws = mantid.CropWorkspace(InputWorkspace=ws_to_rebin,
OutputWorkspace=ws_to_rebin,
XMin=x_min,
XMax=x_max)
if previous_units != "TOF":
cropped_ws = mantid.ConvertUnits(InputWorkspace=cropped_ws,
Target=previous_units,
OutputWorkspace=cropped_ws)
return cropped_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_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 _focus_mode_mods(output_file_paths, calibrated_spectra):
append = False
output_list = []
for index, ws in enumerate(calibrated_spectra):
output_name = output_file_paths["output_name"] + "_mod" + str(index +
1)
tof_ws = mantid.ConvertUnits(InputWorkspace=ws,
OutputWorkspace=output_name,
Target=WORKSPACE_UNITS.tof)
mantid.SaveFocusedXYE(InputWorkspace=tof_ws,
Filename=output_file_paths["tof_xye_filename"],
Append=False,
IncludeHeader=False)
mantid.SaveGSS(InputWorkspace=tof_ws,
Filename=output_file_paths["gss_filename"],
Append=append,
Bank=index + 1)
dspacing_ws = mantid.ConvertUnits(InputWorkspace=ws,
OutputWorkspace=output_name,
Target=WORKSPACE_UNITS.d_spacing)
output_list.append(dspacing_ws)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=dspacing_ws,
Append=append)
append = True
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 absorption_corrections(attenuation, height, number_density, radius,
scattering, input_ws):
simple.ConvertUnits(InputWorkspace=input_ws,
OutputWorkspace=input_ws,
Target="Wavelength",
EMode="Elastic")
simple.CylinderAbsorption(InputWorkspace=input_ws,
OutputWorkspace="absorptionWS",
CylinderSampleHeight=height,
CylinderSampleRadius=radius,
AttenuationXSection=attenuation,
ScatteringXSection=scattering,
SampleNumberDensity=number_density,
NumberOfSlices="10",
NumberOfAnnuli="10",
NumberOfWavelengthPoints="25",
ExpMethod="Normal")
simple.Divide(LHSWorkspace=input_ws,
RHSWorkspace="absorptionWS",
OutputWorkspace=input_ws)
simple.DeleteWorkspace("absorptionWS")
simple.ConvertUnits(InputWorkspace=input_ws,
OutputWorkspace=input_ws,
Target="TOF",
EMode="Elastic")
def _calibData(self, sam_ws, mon_ws):
sapi.MaskDetectors(Workspace=sam_ws,
DetectorList=self._dMask)
sapi.ModeratorTzeroLinear(InputWorkspace=sam_ws,
OutputWorkspace=sam_ws)
sapi.LoadParameterFile(Workspace=sam_ws,
Filename=pjoin(DEFAULT_CONFIG_DIR,
self._reflection["parameter_file"]))
sapi.ConvertUnits(InputWorkspace=sam_ws,
OutputWorkspace=sam_ws,
Target='Wavelength',
EMode='Indirect')
if self._MonNorm:
sapi.ModeratorTzeroLinear(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws)
sapi.Rebin(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws,
Params='10')
sapi.ConvertUnits(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws,
Target='Wavelength')
sapi.OneMinusExponentialCor(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws,
C='0.20749999999999999',
C1='0.001276')
sapi.Scale(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws,
Factor='1e-06')
sapi.RebinToWorkspace(WorkspaceToRebin=sam_ws,
WorkspaceToMatch=mon_ws,
OutputWorkspace=sam_ws)
sapi.Divide(LHSWorkspace=sam_ws,
RHSWorkspace=mon_ws,
OutputWorkspace=sam_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")
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 _read_ws(number, instrument):
cycle_information = instrument._get_cycle_information(run_number=number)
input_dir = instrument._generate_raw_data_cycle_dir(
cycle_information["cycle"])
read_in_ws = _load_raw_files(run_number=number,
instrument=instrument,
input_dir=input_dir)
# TODO move this into instrument specific
read_ws = mantid.ConvertUnits(InputWorkspace=read_in_ws,
Target="Wavelength")
remove_intermediate_workspace(read_in_ws)
_read_pearl_monitor = instrument._get_monitor(run_number=number,
input_dir=input_dir,
spline_terms=20)
read_ws = mantid.NormaliseToMonitor(InputWorkspace=read_ws,
MonitorWorkspace=_read_pearl_monitor,
IntegrationRangeMin=0.6,
IntegrationRangeMax=5.0)
output_name = "read_ws_output-" + str(g_ads_workaround["read_pearl_ws"])
g_ads_workaround["read_pearl_ws"] += 1
output_ws = mantid.ConvertUnits(InputWorkspace=read_ws,
OutputWorkspace=output_name,
Target="TOF")
remove_intermediate_workspace(_read_pearl_monitor)
remove_intermediate_workspace(read_ws)
return output_ws
def _calibData(self, sam_ws, mon_ws):
api.MaskDetectors(Workspace=sam_ws, DetectorList=self._dMask)
#MaskedWorkspace='BASIS_MASK')
api.ModeratorTzeroLinear(InputWorkspace=sam_ws,\
OutputWorkspace=sam_ws)
api.LoadParameterFile(Workspace=sam_ws,
Filename=config.getInstrumentDirectory() +
'BASIS_silicon_111_Parameters.xml')
api.ConvertUnits(InputWorkspace=sam_ws,
OutputWorkspace=sam_ws,
Target='Wavelength',
EMode='Indirect')
if not self._noMonNorm:
api.ModeratorTzeroLinear(InputWorkspace=mon_ws,\
OutputWorkspace=mon_ws)
api.Rebin(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws,
Params='10')
api.ConvertUnits(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws,
Target='Wavelength')
api.OneMinusExponentialCor(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws,
C='0.20749999999999999',
C1='0.001276')
api.Scale(InputWorkspace=mon_ws,
OutputWorkspace=mon_ws,
Factor='9.9999999999999995e-07')
api.RebinToWorkspace(WorkspaceToRebin=sam_ws,
WorkspaceToMatch=mon_ws,
OutputWorkspace=sam_ws)
api.Divide(LHSWorkspace=sam_ws,
RHSWorkspace=mon_ws,
OutputWorkspace=sam_ws)
def _run_focus(input_workspace,
tof_output_name,
vanadium_integration_ws,
vanadium_curves_ws,
df_kwarg,
full_calib,
region_calib):
simple.NormaliseByCurrent(InputWorkspace=input_workspace, OutputWorkspace=input_workspace)
input_workspace /= vanadium_integration_ws
simple.ReplaceSpecialValues(InputWorkspace=input_workspace, OutputWorkspace=input_workspace, NaNValue=0,
InfinityValue=0)
simple.ApplyDiffCal(InstrumentWorkspace=input_workspace, CalibrationWorkspace=full_calib)
ws_d = simple.ConvertUnits(InputWorkspace=input_workspace, Target='dSpacing')
focused_sample = simple.DiffractionFocussing(InputWorkspace=ws_d, **df_kwarg)
curves_rebinned = simple.RebinToWorkspace(WorkspaceToRebin=vanadium_curves_ws, WorkspaceToMatch=focused_sample)
normalised = simple.Divide(LHSWorkspace=focused_sample, RHSWorkspace=curves_rebinned,
AllowDifferentNumberSpectra=True)
simple.ApplyDiffCal(InstrumentWorkspace=normalised, CalibrationWorkspace=region_calib)
dspacing_output_name = tof_output_name + "_dSpacing"
simple.CloneWorkspace(InputWorkspace=normalised, OutputWorkspace=dspacing_output_name)
simple.ConvertUnits(InputWorkspace=normalised, OutputWorkspace=tof_output_name, Target='TOF')
simple.DeleteWorkspace(curves_rebinned)
simple.DeleteWorkspace(focused_sample)
simple.DeleteWorkspace(normalised)
simple.DeleteWorkspace(ws_d)
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 split_into_tof_d_spacing_groups(run_details, processed_spectra):
"""
Splits a processed list containing all focused banks into TOF and
d-spacing groups. It also sets the names of the output workspaces
to the run number(s) - Result<Unit>-<Bank Number> e.g.
123-130-ResultTOF-3
:param run_details: The run details associated with this run
:param processed_spectra: A list containing workspaces, one entry per focused bank.
:return: A workspace group for dSpacing and TOF in that order
"""
d_spacing_output = []
tof_output = []
run_number = str(run_details.output_run_string)
ext = run_details.file_extension if run_details.file_extension else ""
for name_index, ws in enumerate(processed_spectra, start=1):
d_spacing_out_name = run_number + ext + "-ResultD_" + str(name_index)
tof_out_name = run_number + ext + "-ResultTOF_" + str(name_index)
d_spacing_output.append(mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=d_spacing_out_name,
Target="dSpacing"))
tof_output.append(mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=tof_out_name, Target="TOF"))
# Group the outputs
d_spacing_group_name = run_number + ext + "-ResultD"
d_spacing_group = mantid.GroupWorkspaces(InputWorkspaces=d_spacing_output, OutputWorkspace=d_spacing_group_name)
tof_group_name = run_number + ext + "-ResultTOF"
tof_group = mantid.GroupWorkspaces(InputWorkspaces=tof_output, OutputWorkspace=tof_group_name)
return d_spacing_group, tof_group
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 _focus_mode_trans(output_file_paths, atten, instrument,
calibrated_spectra):
summed_ws = mantid.CloneWorkspace(InputWorkspace=calibrated_spectra[0])
for i in range(1, 9): # Add workspaces 2-9 to workspace 1
summed_ws = mantid.Plus(LHSWorkspace=summed_ws,
RHSWorkspace=calibrated_spectra[i])
summed_ws = mantid.Scale(InputWorkspace=summed_ws,
Factor=0.111111111111111)
if atten:
# Clone a workspace which is not attenuated
no_att = output_file_paths["output_name"] + "_noatten"
mantid.CloneWorkspace(InputWorkspace=summed_ws, OutputWorkspace=no_att)
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws,
Target="dSpacing")
summed_ws = instrument._attenuate_workspace(summed_ws)
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="TOF")
mantid.SaveGSS(InputWorkspace=summed_ws,
Filename=output_file_paths["gss_filename"],
Append=False,
Bank=1)
mantid.SaveFocusedXYE(InputWorkspace=summed_ws,
Filename=output_file_paths["tof_xye_filename"],
Append=False,
IncludeHeader=False)
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws,
Target="dSpacing")
# Rename to user friendly name:
summed_ws_name = output_file_paths["output_name"] + "_mods1-9"
summed_ws = mantid.RenameWorkspace(InputWorkspace=summed_ws,
OutputWorkspace=summed_ws_name)
mantid.SaveFocusedXYE(InputWorkspace=summed_ws,
Filename=output_file_paths["dspacing_xye_filename"],
Append=False,
IncludeHeader=False)
mantid.SaveNexus(InputWorkspace=summed_ws,
Filename=output_file_paths["nxs_filename"],
Append=False)
output_list = [summed_ws]
for i in range(0, 9):
workspace_name = output_file_paths["output_name"] + "_mod" + str(i + 1)
to_save = mantid.ConvertUnits(InputWorkspace=calibrated_spectra[i],
Target="dSpacing",
OutputWorkspace=workspace_name)
output_list.append(to_save)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=to_save,
Append=True)
return output_list
def _focus_mode_trans(output_file_paths, attenuation_filepath,
calibrated_spectra):
summed_ws = mantid.MergeRuns(InputWorkspaces=calibrated_spectra[:9])
xList = summed_ws.readX(0)
summed_ws = mantid.CropWorkspace(InputWorkspace=summed_ws,
XMin=xList[1],
Xmax=xList[-2])
summed_ws = mantid.Scale(InputWorkspace=summed_ws,
Factor=0.111111111111111)
if attenuation_filepath:
summed_ws = _attenuate_workspace(
output_file_paths=output_file_paths,
attenuated_ws=summed_ws,
attenuation_filepath=attenuation_filepath)
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="TOF")
mantid.SaveGSS(InputWorkspace=summed_ws,
Filename=output_file_paths["gss_filename"],
Append=False,
Bank=1)
mantid.SaveFocusedXYE(InputWorkspace=summed_ws,
Filename=output_file_paths["tof_xye_filename"],
Append=False,
IncludeHeader=False)
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws,
Target="dSpacing")
# Rename to user friendly name:
summed_ws_name = output_file_paths["output_name"] + "_mods1-9"
summed_ws = mantid.RenameWorkspace(InputWorkspace=summed_ws,
OutputWorkspace=summed_ws_name)
mantid.SaveFocusedXYE(InputWorkspace=summed_ws,
Filename=output_file_paths["dspacing_xye_filename"],
Append=False,
IncludeHeader=False)
mantid.SaveNexus(InputWorkspace=summed_ws,
Filename=output_file_paths["nxs_filename"],
Append=False)
output_list = [summed_ws]
for i in range(0, 9):
workspace_name = output_file_paths["output_name"] + "_mod" + str(i + 1)
to_save = mantid.ConvertUnits(InputWorkspace=calibrated_spectra[i],
Target="dSpacing",
OutputWorkspace=workspace_name)
output_list.append(to_save)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=to_save,
Append=True)
return output_list
def _focus_mode_all(output_file_paths, processed_spectra,
attenuation_filepath):
summed_spectra_name = output_file_paths["output_name"] + "_mods1-9"
summed_spectra = mantid.MergeRuns(InputWorkspaces=processed_spectra[:9],
OutputWorkspace=summed_spectra_name)
summed_spectra = mantid.Scale(InputWorkspace=summed_spectra,
Factor=0.111111111111111,
OutputWorkspace=summed_spectra_name)
if attenuation_filepath:
summed_spectra = _attenuate_workspace(
output_file_paths=output_file_paths,
attenuated_ws=summed_spectra,
attenuation_filepath=attenuation_filepath)
summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra,
Target="TOF",
OutputWorkspace=summed_spectra_name)
mantid.SaveGSS(InputWorkspace=summed_spectra,
Filename=output_file_paths["gss_filename"],
Append=False,
Bank=1)
summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra,
Target="dSpacing",
OutputWorkspace=summed_spectra_name)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=summed_spectra,
Append=False)
output_list = [summed_spectra]
for i in range(0, 5):
spectra_index = (i + 9) # Compensate for 0 based index
ws_to_save = processed_spectra[
spectra_index] # Save out workspaces 10/11/12
output_name = output_file_paths["output_name"] + "_mod" + str(
spectra_index + 1)
ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save,
OutputWorkspace=ws_to_save,
Target="TOF")
mantid.SaveGSS(InputWorkspace=ws_to_save,
Filename=output_file_paths["gss_filename"],
Append=True,
Bank=i + 2)
ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save,
OutputWorkspace=output_name,
Target="dSpacing")
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=ws_to_save,
Append=True)
output_list.append(ws_to_save)
return output_list
def _calculate__cylinder_absorb_corrections(ws_to_correct, multiple_scattering,
sample_details_obj):
"""
Calculates vanadium absorption corrections for the specified workspace. The workspace
should have any monitor spectra masked before being passed into this method. Additionally
it takes details of the sample container and sets the sample geometry to a cylinder with
the specified geometry. This function uses Mayers Sample Correction to perform the corrections.
:param ws_to_correct: The workspace to apply the sample corrections to
:param multiple_scattering: True if the effects of multiple scattering should be accounted for, else False
:param sample_details_obj: The SampleDetails object in a checked state which describes the sample
to ensure a none elemental formula has associated number density
:return: The workspace with corrections applied
"""
geometry_json = {
'Shape': 'Cylinder',
'Height': sample_details_obj.height,
'Radius': sample_details_obj.radius,
'Center': sample_details_obj.center
}
material = sample_details_obj.material_object
# See SetSampleMaterial for documentation on this dictionary
material_json = {'ChemicalFormula': material.chemical_formula}
if material.number_density:
material_json["SampleNumberDensity"] = material.number_density
if material.absorption_cross_section:
material_json[
"AttenuationXSection"] = material.absorption_cross_section
if material.scattering_cross_section:
material_json["ScatteringXSection"] = material.scattering_cross_section
mantid.SetSample(InputWorkspace=ws_to_correct,
Geometry=geometry_json,
Material=material_json)
previous_units = ws_to_correct.getAxis(0).getUnit().unitID()
ws_units = common_enums.WORKSPACE_UNITS
# Mayers Sample correction must be completed in TOF, convert if needed. Then back to original units afterwards
if previous_units != ws_units.tof:
ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct,
OutputWorkspace=ws_to_correct,
Target=ws_units.tof)
ws_to_correct = mantid.MayersSampleCorrection(
InputWorkspace=ws_to_correct,
OutputWorkspace=ws_to_correct,
MultipleScattering=multiple_scattering)
if previous_units != ws_units.tof:
ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct,
OutputWorkspace=ws_to_correct,
Target=previous_units)
return ws_to_correct
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 calculate_slab_absorb_corrections(ws_to_correct, sample_details_obj):
"""
Sets a slab sample from the user specified dictionary and performs HRPDSlabCanAbsorption on the workspace.
The SampleDetails object defines the sample, material and associated properties.
:param ws_to_correct: The workspace to do corrections on
:param sample_details_obj: The object containing the sample details
:return: The corrected workspace
"""
if not isinstance(sample_details_obj, sample_details.SampleDetails):
raise RuntimeError("A SampleDetails object was not set or a different object type was found when sample"
" absorption corrections were requested. If you want sample absorption corrections please "
"create a SampleDetails object and set the relevant properties it. "
"Then set the new sample by calling set_sample_details().")
if not sample_details_obj.is_material_set():
raise RuntimeError("The material for this sample has not been set yet. Please call"
" set_material on the SampleDetails object to set the material")
geometry_json = {"Shape": "FlatPlate", "Thick": sample_details_obj.thickness(), "Width": sample_details_obj.width(),
"Height": sample_details_obj.height(), "Center": sample_details_obj.center(),
"Angle": sample_details_obj.angle()}
material = sample_details_obj.material_object
# See SetSampleMaterial for documentation on this dictionary
material_json = {"ChemicalFormula": material.chemical_formula}
if material.number_density:
material_json["SampleNumberDensity"] = material.number_density
if material.absorption_cross_section:
material_json["AttenuationXSection"] = material.absorption_cross_section
if material.scattering_cross_section:
material_json["ScatteringXSection"] = material.scattering_cross_section
mantid.SetSample(InputWorkspace=ws_to_correct, Geometry=geometry_json, Material=material_json)
previous_units = ws_to_correct.getAxis(0).getUnit().unitID()
ws_units = common_enums.WORKSPACE_UNITS
# HRPDSlabCanAbsorption must be completed in units of wavelength - convert if needed, than convert back afterwards
if previous_units != ws_units.wavelength:
ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct, OutputWorkspace=ws_to_correct,
Target=ws_units.wavelength)
absorb_factors = mantid.HRPDSlabCanAbsorption(InputWorkspace=ws_to_correct)
ws_to_correct = mantid.Divide(LHSWorkspace=ws_to_correct, RHSWorkspace=absorb_factors,
OutputWorkspace=ws_to_correct)
mantid.DeleteWorkspace(Workspace=absorb_factors)
if previous_units != ws_units.wavelength:
ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct, OutputWorkspace=ws_to_correct,
Target=previous_units)
return ws_to_correct
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 load_bragg_by_filename(file_name):
"""
Load Bragg diffraction file (including 3-column data file, GSAS file) for Rietveld
"""
# load with different file type
base_file_name = os.path.basename(file_name).lower()
gss_ws_name = os.path.basename(file_name).split('.')[0]
if base_file_name.endswith('.gss') or base_file_name.endswith(
'.gsa') or base_file_name.endswith('.gda'):
simpleapi.LoadGSS(Filename=file_name, OutputWorkspace=gss_ws_name)
elif base_file_name.endswith('.nxs'):
simpleapi.LoadNexusProcessed(Filename=file_name,
OutputWorkspace=gss_ws_name)
simpleapi.ConvertUnits(InputWorkspace=gss_ws_name,
OutputWorkspace=gss_ws_name,
EMode='Elastic',
Target='TOF')
elif base_file_name.endswith('.dat'):
simpleapi.LoadAscii(Filename=file_name,
OutputWorkspace=gss_ws_name,
Unit='TOF')
else:
raise RuntimeError('File %s is not of a supported type.' % file_name)
# check
assert AnalysisDataService.doesExist(gss_ws_name)
angle_list = addie.utilities.workspaces.calculate_bank_angle(gss_ws_name)
return gss_ws_name, angle_list
def _group_and_SofQW(self, wsName, etRebins, isSample=True):
""" Transforms from wavelength and detector ID to S(Q,E)
@param wsName: workspace as a function of wavelength and detector id
@return: S(Q,E)
"""
api.ConvertUnits(InputWorkspace=wsName,
OutputWorkspace=wsName,
Target='DeltaE',
EMode='Indirect')
api.CorrectKiKf(InputWorkspace=wsName,
OutputWorkspace=wsName,
EMode='Indirect')
api.Rebin(InputWorkspace=wsName,
OutputWorkspace=wsName,
Params=etRebins)
if self._groupDetOpt != "None":
if self._groupDetOpt == "Low-Resolution":
grp_file = "BASIS_Grouping_LR.xml"
else:
grp_file = "BASIS_Grouping.xml"
# If mask override used, we need to add default grouping file
# location to search paths
if self._overrideMask:
config.appendDataSearchDir(DEFAULT_MASK_GROUP_DIR)
api.GroupDetectors(InputWorkspace=wsName,
OutputWorkspace=wsName,
MapFile=grp_file,
Behaviour="Sum")
wsSqwName = wsName + '_divided_sqw' if isSample and self._doNorm else wsName + '_sqw'
api.SofQW3(InputWorkspace=wsName,
OutputWorkspace=wsSqwName,
QAxisBinning=self._qBins,
EMode='Indirect',
EFixed='2.0826')
return wsSqwName
def ProcessVana(rnum, cycle):
# Preparation of the V/Nd sphere run for SX normalization
mantid.LoadRaw(Filename='/archive/NDXWISH/Instrument/data/cycle_' + cycle + '/WISH000' + str(rnum) + '.raw',
OutputWorkspace='Vana', LoadMonitors='Separate')
mantid.CropWorkspace(InputWorkspace='Vana', OutputWorkspace='Vana', XMin=6000, XMax=99000)
mantid.NormaliseByCurrent(InputWorkspace='Vana', OutputWorkspace='Vana')
mantid.ConvertUnits(InputWorkspace='Vana', OutputWorkspace='Vana', Target='Wavelength')
# create Abs Correction for V
shape = '''<sphere id="V-sphere">
<centre x="0.0" y="0.0" z="0.0" />
<radius val="0.0025"/>
</sphere>'''
mantid.CreateSampleShape('Vana', shape)
mantid.SetSampleMaterial('Vana', SampleNumberDensity=0.0719, ScatteringXSection=5.197, AttenuationXSection=4.739,
ChemicalFormula='V0.95 Nb0.05')
mantid.AbsorptionCorrection(InputWorkspace='Vana', OutputWorkspace='Abs_corr', ElementSize=0.5)
# SphericalAbsorption(InputWorkspace='WISH00038428', OutputWorkspace='Abs_corr_sphere', SphericalSampleRadius=0.25)
# correct Vanadium run for absorption
mantid.Divide(LHSWorkspace='Vana', RHSWorkspace='Abs_corr', OutputWorkspace='Vana_Abs')
mantid.DeleteWorkspace('Vana')
mantid.DeleteWorkspace('Abs_corr')
# Smoot data with redius 3
mantid.SmoothNeighbours(InputWorkspace='Vana_Abs', OutputWorkspace='Vana_smoot', Radius=3)
mantid.DeleteWorkspace('Vana_Abs')
# SmoothData38428
mantid.SmoothData(InputWorkspace='Vana_smoot', OutputWorkspace='Vana_smoot1', NPoints=300)
mantid.DeleteWorkspace('Vana_smoot')
def test_unit_conversion(self):
import mantid.simpleapi as mantid
eventWS = self.base_event_ws
ws = mantid.Rebin(eventWS, 10000, PreserveEvents=False)
tmp = scn.mantid.convert_Workspace2D_to_data_array(ws)
target_tof = tmp.coords['tof']
ws = mantid.ConvertUnits(InputWorkspace=ws,
Target="Wavelength",
EMode="Elastic")
converted_mantid = scn.mantid.convert_Workspace2D_to_data_array(ws)
da = scn.mantid.convert_EventWorkspace_to_data_array(
eventWS, load_pulse_times=False)
da = sc.histogram(da, bins=target_tof)
d = sc.Dataset(data={da.name: da})
converted = scn.convert(d, 'tof', 'wavelength', scatter=True)
self.assertTrue(
np.all(np.isclose(converted_mantid.values, converted[""].values)))
self.assertTrue(
np.all(
np.isclose(
converted_mantid.coords['wavelength'].values,
converted.coords['wavelength'].values,
)))
def save_combined_panel(self, run, panel):
panel_combination = {5: 6, 4: 7, 3: 8, 2: 9, 1: 10}
input_ws1 = "w{0}-{1}foc".format(run, panel)
input_ws2 = "w{0}-{1}foc".format(run, panel_combination.get(panel))
combined = "{0}{1}-{2}_{3}foc{4}".format("{0}", run, panel,
panel_combination.get(panel),
"{1}")
combined_save = combined.format("", "{}")
combined_ws = combined.format("w", "")
simple.RebinToWorkspace(WorkspaceToRebin=input_ws2,
WorkspaceToMatch=input_ws1,
OutputWorkspace=input_ws2,
PreserveEvents='0')
simple.Plus(LHSWorkspace=input_ws1,
RHSWorkspace=input_ws2,
OutputWorkspace=combined_ws)
simple.ConvertUnits(InputWorkspace=combined_ws,
OutputWorkspace=combined_ws + "-d",
Target="dSpacing",
EMode="Elastic")
simple.SaveGSS(combined_ws,
os.path.join(self.user_directory,
combined_save.format("raw.gss")),
Append=False,
Bank=1)
simple.SaveFocusedXYE(
combined_ws,
os.path.join(self.user_directory, combined_save.format("raw.dat")))
simple.SaveNexusProcessed(
combined_ws,
os.path.join(self.user_directory, combined_save.format("raw.nxs")))
def reduce(self, run_numbers, panels):
self.is_vanadium = False
for run in run_numbers:
self.startup(self.get_cycle(run))
self.datafile = self.get_file_name(run, "raw")
for panel in panels:
wout = self.process_run(run,
panel,
"raw",
"11_4",
absorb=self.absorb,
number_density=0.025,
scattering=5.463,
attenuation=2.595,
height=4.0,
radius=0.55)
simple.ConvertUnits(InputWorkspace=wout,
OutputWorkspace="{}-d".format(wout),
Target="dSpacing",
EMode="Elastic")
simple.DeleteWorkspace("WISH_diff_cal")
simple.DeleteWorkspace("WISH_diff_group")
simple.DeleteWorkspace("WISH_diff_mask")
simple.DeleteWorkspace("monitor{}".format(run))
if 0 in panels:
panels = [1, 2, 3, 4, 5]
for panel in [x for x in panels if x < 6]:
self.save_combined_panel(run, panel)
def test_Workspace2D_not_common_bins_masks(self):
import mantid.simpleapi as mantid
eventWS = self.base_event_ws
ws = mantid.Rebin(eventWS, 10000, PreserveEvents=False)
ws = mantid.ConvertUnits(ws,
"Wavelength",
EMode="Direct",
EFixed=0.1231)
# these X values will mask different number of bins
masked_ws = self._mask_bins_and_spectra(ws,
-214,
-192,
num_spectra=3,
indices='0-40')
self.assertFalse(masked_ws.isCommonBins())
ds = scn.mantid.convert_Workspace2D_to_data_array(masked_ws)
# bin with 3 masks
np.testing.assert_array_equal(ds.masks["bin"].values[0],
[True, True, False])
# bin with only 2
np.testing.assert_array_equal(ds.masks["bin"].values[31],
[True, True, False])
np.testing.assert_array_equal(ds.masks["spectrum"].values[0:3],
[True, True, True])
def _convert_units(self, workspace, target, emode, efixed):
return s_api.ConvertUnits(InputWorkspace=workspace,
OutputWorkspace="__units_converted",
Target=target,
EMode=emode,
EFixed=efixed,
StoreInADS=False)
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
