def PyInit(self):
# Workspace which is to be masked
self.declareProperty(MatrixWorkspaceProperty("InputWorkspace", '',
optional=PropertyMode.Mandatory, direction=Direction.Input),
doc='The workspace which is to be converted to wavelength')
self.declareProperty('WavelengthLow', defaultValue=Property.EMPTY_DBL, direction=Direction.Input,
doc='The low value of the wavelength binning.')
self.declareProperty('WavelengthHigh', defaultValue=Property.EMPTY_DBL, direction=Direction.Input,
doc='The high value of the wavelength binning.')
self.declareProperty('WavelengthStep', defaultValue=Property.EMPTY_DBL, direction=Direction.Input,
doc='The step size of the wavelength binning.')
# Step type
allowed_step_types = StringListValidator([RangeStepType.to_string(RangeStepType.Log),
RangeStepType.to_string(RangeStepType.Lin)])
self.declareProperty('WavelengthStepType', RangeStepType.to_string(RangeStepType.Lin),
validator=allowed_step_types, direction=Direction.Input,
doc='The step type for rebinning.')
# Rebin type
allowed_rebin_methods = StringListValidator([RebinType.to_string(RebinType.Rebin),
RebinType.to_string(RebinType.InterpolatingRebin)])
self.declareProperty("RebinMode", RebinType.to_string(RebinType.Rebin),
validator=allowed_rebin_methods, direction=Direction.Input,
doc="The method which is to be applied to the rebinning.")
self.declareProperty(MatrixWorkspaceProperty('OutputWorkspace', '',
optional=PropertyMode.Mandatory, direction=Direction.Output),
doc='The output workspace.')
def PyInit(self):
# Workspace which is to be masked
self.declareProperty(
MatrixWorkspaceProperty("InputWorkspace",
'',
optional=PropertyMode.Mandatory,
direction=Direction.Input),
doc='The workspace which is to be converted to wavelength')
self.declareProperty('WavelengthLow',
defaultValue=Property.EMPTY_DBL,
direction=Direction.Input,
doc='The low value of the wavelength binning.')
self.declareProperty('WavelengthHigh',
defaultValue=Property.EMPTY_DBL,
direction=Direction.Input,
doc='The high value of the wavelength binning.')
self.declareProperty('WavelengthStep',
defaultValue=Property.EMPTY_DBL,
direction=Direction.Input,
doc='The step size of the wavelength binning.')
# Step type
allowed_step_types = StringListValidator([
RangeStepType.to_string(RangeStepType.Log),
RangeStepType.to_string(RangeStepType.Lin)
])
self.declareProperty('WavelengthStepType',
RangeStepType.to_string(RangeStepType.Lin),
validator=allowed_step_types,
direction=Direction.Input,
doc='The step type for rebinning.')
# Rebin type
allowed_rebin_methods = StringListValidator([
RebinType.to_string(RebinType.Rebin),
RebinType.to_string(RebinType.InterpolatingRebin)
])
self.declareProperty(
"RebinMode",
RebinType.to_string(RebinType.Rebin),
validator=allowed_rebin_methods,
direction=Direction.Input,
doc="The method which is to be applied to the rebinning.")
self.declareProperty(MatrixWorkspaceProperty(
'OutputWorkspace',
'',
optional=PropertyMode.Mandatory,
direction=Direction.Output),
doc='The output workspace.')
def _convert_to_wavelength(self, workspace, normalize_to_monitor_state):
"""
Converts the workspace from time-of-flight units to wavelength units
:param workspace: a time-of-flight workspace.
:param normalize_to_monitor_state: a SANSStateNormalizeToMonitor object.
:return: a wavelength workspace.
"""
wavelength_low = normalize_to_monitor_state.wavelength_low
wavelength_high = normalize_to_monitor_state.wavelength_high
wavelength_step = normalize_to_monitor_state.wavelength_step
wavelength_step_type = normalize_to_monitor_state.wavelength_step_type
wavelength_rebin_mode = normalize_to_monitor_state.rebin_type
convert_name = "SANSConvertToWavelengthAndRebin"
convert_options = {
"InputWorkspace": workspace,
"WavelengthLow": wavelength_low,
"WavelengthHigh": wavelength_high,
"WavelengthStep": wavelength_step,
"WavelengthStepType":
RangeStepType.to_string(wavelength_step_type),
"RebinMode": RebinType.to_string(wavelength_rebin_mode)
}
convert_alg = create_unmanaged_algorithm(convert_name,
**convert_options)
convert_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
convert_alg.setProperty("OutputWorkspace", workspace)
convert_alg.execute()
return convert_alg.getProperty("OutputWorkspace").value
def _convert_to_wavelength(self, workspace, normalize_to_monitor_state):
"""
Converts the workspace from time-of-flight units to wavelength units
:param workspace: a time-of-flight workspace.
:param normalize_to_monitor_state: a SANSStateNormalizeToMonitor object.
:return: a wavelength workspace.
"""
wavelength_low = normalize_to_monitor_state.wavelength_low
wavelength_high = normalize_to_monitor_state.wavelength_high
wavelength_step = normalize_to_monitor_state.wavelength_step
wavelength_step_type = normalize_to_monitor_state.wavelength_step_type
wavelength_rebin_mode = normalize_to_monitor_state.rebin_type
convert_name = "SANSConvertToWavelengthAndRebin"
convert_options = {"InputWorkspace": workspace,
"WavelengthLow": wavelength_low,
"WavelengthHigh": wavelength_high,
"WavelengthStep": wavelength_step,
"WavelengthStepType": RangeStepType.to_string(wavelength_step_type),
"RebinMode": RebinType.to_string(wavelength_rebin_mode)}
convert_alg = create_unmanaged_algorithm(convert_name, **convert_options)
convert_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
convert_alg.setProperty("OutputWorkspace", workspace)
convert_alg.execute()
return convert_alg.getProperty("OutputWorkspace").value
def test_that_event_workspace_with_conversion_is_still_event_workspace(
self):
workspace = provide_workspace(is_event=True)
convert_options = {
"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"RebinMode": "Rebin",
"WavelengthLow": 1.0,
"WavelengthHigh": 10.0,
"WavelengthStep": 1.0,
"WavelengthStepType": RangeStepType.to_string(RangeStepType.Lin)
}
convert_alg = create_unmanaged_algorithm(
"SANSConvertToWavelengthAndRebin", **convert_options)
convert_alg.execute()
self.assertTrue(convert_alg.isExecuted())
output_workspace = convert_alg.getProperty("OutputWorkspace").value
self.assertTrue(isinstance(output_workspace, EventWorkspace))
# Check the rebinning part
data_x0 = output_workspace.dataX(0)
self.assertTrue(len(data_x0) == 10)
self.assertTrue(data_x0[0] == 1.0)
self.assertTrue(data_x0[-1] == 10.0)
# Check the units part
axis0 = output_workspace.getAxis(0)
unit = axis0.getUnit()
self.assertTrue(unit.unitID() == "Wavelength")
def test_that_not_setting_upper_bound_takes_it_from_original_value(self):
workspace = provide_workspace(is_event=True)
convert_options = {
"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"RebinMode": "Rebin",
"WavelengthLow": 1.0,
"WavelengthStep": 1.0,
"WavelengthStepType": RangeStepType.to_string(RangeStepType.Lin)
}
convert_alg = create_unmanaged_algorithm(
"SANSConvertToWavelengthAndRebin", **convert_options)
convert_alg.execute()
self.assertTrue(convert_alg.isExecuted())
output_workspace = convert_alg.getProperty("OutputWorkspace").value
self.assertTrue(isinstance(output_workspace, EventWorkspace))
# Check the rebinning part
data_x0 = output_workspace.dataX(0)
self.assertTrue(data_x0[0] == 1.0)
expected_upper_bound = 5.27471197274
self.assertEqual(round(data_x0[-1], 11), expected_upper_bound)
# Check the units part
axis0 = output_workspace.getAxis(0)
unit = axis0.getUnit()
self.assertTrue(unit.unitID() == "Wavelength")
def PyExec(self):
# State
state_property_manager = self.getProperty("SANSState").value
state = create_deserialized_sans_state_from_property_manager(
state_property_manager)
wavelength_state = state.wavelength
# Input workspace
workspace = get_input_workspace_as_copy_if_not_same_as_output_workspace(
self)
wavelength_name = "SANSConvertToWavelengthAndRebin"
wavelength_options = {
"InputWorkspace":
workspace,
"WavelengthLow":
wavelength_state.wavelength_low,
"WavelengthHigh":
wavelength_state.wavelength_high,
"WavelengthStep":
wavelength_state.wavelength_step,
"WavelengthStepType":
RangeStepType.to_string(wavelength_state.wavelength_step_type),
"RebinMode":
RebinType.to_string(wavelength_state.rebin_type)
}
wavelength_alg = create_unmanaged_algorithm(wavelength_name,
**wavelength_options)
wavelength_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
wavelength_alg.setProperty("OutputWorkspace", workspace)
wavelength_alg.execute()
converted_workspace = wavelength_alg.getProperty(
"OutputWorkspace").value
append_to_sans_file_tag(converted_workspace, "_wavelength")
self.setProperty("OutputWorkspace", converted_workspace)
def _default_gui_setup(self):
"""
Provides a default setup of the GUI. This is important for the initial start up, when the view is being set.
"""
# Set the possible reduction modes
reduction_mode_list = get_reduction_mode_strings_for_gui()
self._view.set_reduction_modes(reduction_mode_list)
# Set the step type options for wavelength
range_step_types = [
RangeStepType.to_string(RangeStepType.Lin),
RangeStepType.to_string(RangeStepType.Log)
]
self._view.wavelength_step_type = range_step_types
# Set the geometry options. This needs to include the option to read the sample shape from file.
sample_shape = [
"Read from file",
SampleShape.to_string(SampleShape.CylinderAxisUp),
SampleShape.to_string(SampleShape.Cuboid),
SampleShape.to_string(SampleShape.CylinderAxisAlong)
]
self._view.sample_shape = sample_shape
# Set the q range
self._view.q_1d_step_type = range_step_types
self._view.q_xy_step_type = range_step_types
# Set the fit options
fit_types = [
FitType.to_string(FitType.Linear),
FitType.to_string(FitType.Logarithmic),
FitType.to_string(FitType.Polynomial)
]
self._view.transmission_sample_fit_type = fit_types
self._view.transmission_can_fit_type = fit_types
def test_that_lower_wavelength_larger_than_higher_wavelength_raises(self):
workspace = provide_workspace(is_event=True)
convert_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"RebinMode": "Rebin",
"WavelengthLow": 4.0,
"WavelengthHigh": 3.0,
"WavelengthStep": 1.5,
"WavelengthStepType": RangeStepType.to_string(RangeStepType.Log)}
convert_alg = create_unmanaged_algorithm("SANSConvertToWavelengthAndRebin", **convert_options)
had_run_time_error = False
try:
convert_alg.execute()
except RuntimeError:
had_run_time_error = True
self.assertTrue(had_run_time_error)
def test_that_lower_wavelength_larger_than_higher_wavelength_raises(self):
workspace = provide_workspace(is_event=True)
convert_options = {
"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"RebinMode": "Rebin",
"WavelengthLow": 4.0,
"WavelengthHigh": 3.0,
"WavelengthStep": 1.5,
"WavelengthStepType": RangeStepType.to_string(RangeStepType.Log)
}
convert_alg = create_unmanaged_algorithm(
"SANSConvertToWavelengthAndRebin", **convert_options)
had_run_time_error = False
try:
convert_alg.execute()
except RuntimeError:
had_run_time_error = True
self.assertTrue(had_run_time_error)
def test_that_event_workspace_with_conversion_is_still_event_workspace(self):
workspace = provide_workspace(is_event=True)
convert_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"RebinMode": "Rebin",
"WavelengthLow": 1.0,
"WavelengthHigh": 10.0,
"WavelengthStep": 1.0,
"WavelengthStepType": RangeStepType.to_string(RangeStepType.Lin)}
convert_alg = create_unmanaged_algorithm("SANSConvertToWavelengthAndRebin", **convert_options)
convert_alg.execute()
self.assertTrue(convert_alg.isExecuted())
output_workspace = convert_alg.getProperty("OutputWorkspace").value
self.assertTrue(isinstance(output_workspace, EventWorkspace))
# Check the rebinning part
data_x0 = output_workspace.dataX(0)
self.assertTrue(len(data_x0) == 10)
self.assertTrue(data_x0[0] == 1.0)
self.assertTrue(data_x0[-1] == 10.0)
# Check the units part
axis0 = output_workspace.getAxis(0)
unit = axis0.getUnit()
self.assertTrue(unit.unitID() == "Wavelength")
def PyExec(self):
# State
state_property_manager = self.getProperty("SANSState").value
state = create_deserialized_sans_state_from_property_manager(state_property_manager)
wavelength_state = state.wavelength
# Input workspace
workspace = get_input_workspace_as_copy_if_not_same_as_output_workspace(self)
wavelength_name = "SANSConvertToWavelengthAndRebin"
wavelength_options = {"InputWorkspace": workspace,
"WavelengthLow": wavelength_state.wavelength_low[0],
"WavelengthHigh": wavelength_state.wavelength_high[0],
"WavelengthStep": wavelength_state.wavelength_step,
"WavelengthStepType": RangeStepType.to_string(
wavelength_state.wavelength_step_type),
"RebinMode": RebinType.to_string(wavelength_state.rebin_type)}
wavelength_alg = create_unmanaged_algorithm(wavelength_name, **wavelength_options)
wavelength_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
wavelength_alg.setProperty("OutputWorkspace", workspace)
wavelength_alg.execute()
converted_workspace = wavelength_alg.getProperty("OutputWorkspace").value
append_to_sans_file_tag(converted_workspace, "_wavelength")
self.setProperty("OutputWorkspace", converted_workspace)
def test_that_not_setting_upper_bound_takes_it_from_original_value(self):
workspace = provide_workspace(is_event=True)
convert_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"RebinMode": "Rebin",
"WavelengthLow": 1.0,
"WavelengthStep": 1.0,
"WavelengthStepType": RangeStepType.to_string(RangeStepType.Lin)}
convert_alg = create_unmanaged_algorithm("SANSConvertToWavelengthAndRebin", **convert_options)
convert_alg.execute()
self.assertTrue(convert_alg.isExecuted())
output_workspace = convert_alg.getProperty("OutputWorkspace").value
self.assertTrue(isinstance(output_workspace, EventWorkspace))
# Check the rebinning part
data_x0 = output_workspace.dataX(0)
self.assertTrue(data_x0[0] == 1.0)
expected_upper_bound = 5.27471197274
self.assertEqual(round(data_x0[-1],11), expected_upper_bound)
# Check the units part
axis0 = output_workspace.getAxis(0)
unit = axis0.getUnit()
self.assertTrue(unit.unitID() == "Wavelength")
def _get_corrected_wavelength_workspace(self, workspace, detector_ids, calculate_transmission_state):
"""
Performs a prompt peak correction, a background correction, converts to wavelength and rebins.
:param workspace: the workspace which is being corrected.
:param detector_ids: a list of relevant detector ids
:param calculate_transmission_state: a SANSStateCalculateTransmission state
:return: a corrected workspace.
"""
# Extract the relevant spectra. These include
# 1. The incident monitor spectrum
# 2. The transmission spectra, be it monitor or ROI based.
# A previous implementation of this code had a comment which suggested
# that we have to exclude unused spectra as the interpolation runs into
# problems if we don't.
extract_name = "ExtractSpectra"
extract_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"DetectorList": detector_ids}
extract_alg = create_unmanaged_algorithm(extract_name, **extract_options)
extract_alg.execute()
workspace = extract_alg.getProperty("OutputWorkspace").value
# Make sure that we still have spectra in the workspace
if workspace.getNumberHistograms() == 0:
raise RuntimeError("SANSCalculateTransmissionCorrection: The transmission workspace does "
"not seem to have any spectra.")
# ----------------------------------
# Perform the prompt peak correction
# ----------------------------------
prompt_peak_correction_min = calculate_transmission_state.prompt_peak_correction_min
prompt_peak_correction_max = calculate_transmission_state.prompt_peak_correction_max
prompt_peak_correction_enabled = calculate_transmission_state.prompt_peak_correction_enabled
workspace = self._perform_prompt_peak_correction(workspace, prompt_peak_correction_min,
prompt_peak_correction_max, prompt_peak_correction_enabled)
# ---------------------------------------
# Perform the flat background correction
# ---------------------------------------
# The flat background correction has two parts:
# 1. Corrections on monitors
# 2. Corrections on regular detectors
# Monitor flat background correction
workspace_indices_of_monitors = list(get_workspace_indices_for_monitors(workspace))
background_tof_monitor_start = calculate_transmission_state.background_TOF_monitor_start
background_tof_monitor_stop = calculate_transmission_state.background_TOF_monitor_stop
background_tof_general_start = calculate_transmission_state.background_TOF_general_start
background_tof_general_stop = calculate_transmission_state.background_TOF_general_stop
workspace = apply_flat_background_correction_to_monitors(workspace,
workspace_indices_of_monitors,
background_tof_monitor_start,
background_tof_monitor_stop,
background_tof_general_start,
background_tof_general_stop)
# Detector flat background correction
flat_background_correction_start = calculate_transmission_state.background_TOF_roi_start
flat_background_correction_stop = calculate_transmission_state.background_TOF_roi_stop
workspace = apply_flat_background_correction_to_detectors(workspace, flat_background_correction_start,
flat_background_correction_stop)
# ---------------------------------------
# Convert to wavelength and rebin
# ---------------------------------------
# The wavelength setting is reasonably complex.
# 1. Use full wavelength range
# 2. Use standard settings
if calculate_transmission_state.use_full_wavelength_range:
wavelength_low = calculate_transmission_state.wavelength_full_range_low
wavelength_high = calculate_transmission_state.wavelength_full_range_high
else:
wavelength_low = calculate_transmission_state.wavelength_low[0]
wavelength_high = calculate_transmission_state.wavelength_high[0]
wavelength_step = calculate_transmission_state.wavelength_step
rebin_type = calculate_transmission_state.rebin_type
wavelength_step_type = calculate_transmission_state.wavelength_step_type
convert_name = "SANSConvertToWavelengthAndRebin"
convert_options = {"InputWorkspace": workspace,
"WavelengthLow": wavelength_low,
"WavelengthHigh": wavelength_high,
"WavelengthStep": wavelength_step,
"WavelengthStepType": RangeStepType.to_string(wavelength_step_type),
"RebinMode": RebinType.to_string(rebin_type)}
convert_alg = create_unmanaged_algorithm(convert_name, **convert_options)
convert_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
convert_alg.setProperty("OutputWorkspace", workspace)
convert_alg.execute()
return convert_alg.getProperty("OutputWorkspace").value
def _get_corrected_wavelength_workspace(self, workspace, detector_ids, calculate_transmission_state):
"""
Performs a prompt peak correction, a background correction, converts to wavelength and rebins.
:param workspace: the workspace which is being corrected.
:param detector_ids: a list of relevant detector ids
:param calculate_transmission_state: a SANSStateCalculateTransmission state
:return: a corrected workspace.
"""
# Extract the relevant spectra. These include
# 1. The incident monitor spectrum
# 2. The transmission spectra, be it monitor or ROI based.
# A previous implementation of this code had a comment which suggested
# that we have to exclude unused spectra as the interpolation runs into
# problems if we don't.
extract_name = "ExtractSpectra"
extract_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"DetectorList": detector_ids}
extract_alg = create_unmanaged_algorithm(extract_name, **extract_options)
extract_alg.execute()
workspace = extract_alg.getProperty("OutputWorkspace").value
# Make sure that we still have spectra in the workspace
if workspace.getNumberHistograms() == 0:
raise RuntimeError("SANSCalculateTransmissionCorrection: The transmission workspace does "
"not seem to have any spectra.")
# ----------------------------------
# Perform the prompt peak correction
# ----------------------------------
prompt_peak_correction_min = calculate_transmission_state.prompt_peak_correction_min
prompt_peak_correction_max = calculate_transmission_state.prompt_peak_correction_max
prompt_peak_correction_enabled = calculate_transmission_state.prompt_peak_correction_enabled
workspace = self._perform_prompt_peak_correction(workspace, prompt_peak_correction_min,
prompt_peak_correction_max, prompt_peak_correction_enabled)
# ---------------------------------------
# Perform the flat background correction
# ---------------------------------------
# The flat background correction has two parts:
# 1. Corrections on monitors
# 2. Corrections on regular detectors
# Monitor flat background correction
workspace_indices_of_monitors = list(get_workspace_indices_for_monitors(workspace))
background_tof_monitor_start = calculate_transmission_state.background_TOF_monitor_start
background_tof_monitor_stop = calculate_transmission_state.background_TOF_monitor_stop
background_tof_general_start = calculate_transmission_state.background_TOF_general_start
background_tof_general_stop = calculate_transmission_state.background_TOF_general_stop
workspace = apply_flat_background_correction_to_monitors(workspace,
workspace_indices_of_monitors,
background_tof_monitor_start,
background_tof_monitor_stop,
background_tof_general_start,
background_tof_general_stop)
# Detector flat background correction
flat_background_correction_start = calculate_transmission_state.background_TOF_roi_start
flat_background_correction_stop = calculate_transmission_state.background_TOF_roi_stop
workspace = apply_flat_background_correction_to_detectors(workspace, flat_background_correction_start,
flat_background_correction_stop)
# ---------------------------------------
# Convert to wavelength and rebin
# ---------------------------------------
# The wavelength setting is reasonably complex.
# 1. Use full wavelength range
# 2. Use standard settings
if calculate_transmission_state.use_full_wavelength_range:
wavelength_low = calculate_transmission_state.wavelength_full_range_low
wavelength_high = calculate_transmission_state.wavelength_full_range_high
else:
data_type_string = self.getProperty("DataType").value
fit_state = calculate_transmission_state.fit[data_type_string]
wavelength_low = fit_state.wavelength_low if fit_state.wavelength_low\
else calculate_transmission_state.wavelength_low[0]
wavelength_high = fit_state.wavelength_high if fit_state.wavelength_high\
else calculate_transmission_state.wavelength_high[0]
wavelength_step = calculate_transmission_state.wavelength_step
rebin_type = calculate_transmission_state.rebin_type
wavelength_step_type = calculate_transmission_state.wavelength_step_type
convert_name = "SANSConvertToWavelengthAndRebin"
convert_options = {"InputWorkspace": workspace,
"WavelengthLow": wavelength_low,
"WavelengthHigh": wavelength_high,
"WavelengthStep": wavelength_step,
"WavelengthStepType": RangeStepType.to_string(wavelength_step_type),
"RebinMode": RebinType.to_string(rebin_type)}
convert_alg = create_unmanaged_algorithm(convert_name, **convert_options)
convert_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
convert_alg.setProperty("OutputWorkspace", workspace)
convert_alg.execute()
return convert_alg.getProperty("OutputWorkspace").value