def test_binning_commands_parsed(self):
# Wavelength
for bin_type in ["Lin", "Log"]:
wavelength_dict = {"binning": {"wavelength": {"start": 1.1, "step": 0.1, "stop": 2.2, "type": bin_type}}}
wavelength = self._setup_parser(wavelength_dict).get_state_wavelength()
self.assertEqual((1.1, 2.2), wavelength.wavelength_interval.wavelength_full_range)
self.assertEqual(0.1, wavelength.wavelength_interval.wavelength_step)
self.assertEqual(RangeStepType(bin_type), wavelength.wavelength_step_type)
one_d_reduction_q_dict = {"binning": {"1d_reduction": {"binning": "1.0, 0.1, 2.0, -0.2, 3.0",
"radius_cut": 12.3,
"wavelength_cut": 23.4}}}
one_d_convert_to_q = self._setup_parser(one_d_reduction_q_dict).get_state_convert_to_q()
self.assertEqual(1.0, one_d_convert_to_q.q_min)
self.assertEqual(3.0, one_d_convert_to_q.q_max)
self.assertEqual("1.0, 0.1, 2.0, -0.2, 3.0", one_d_convert_to_q.q_1d_rebin_string.strip())
self.assertEqual(12.3, one_d_convert_to_q.radius_cutoff)
self.assertEqual(23.4, one_d_convert_to_q.wavelength_cutoff)
two_d_reduction_q_dict = {"binning": {"2d_reduction": {"step": 1.0, "stop": 5.0,
"type": "Lin", "interpolate": True}}}
results = self._setup_parser(two_d_reduction_q_dict)
two_d_convert_to_q = results.get_state_convert_to_q()
self.assertEqual(5.0, two_d_convert_to_q.q_xy_max)
self.assertEqual(1.0, two_d_convert_to_q.q_xy_step)
self.assertTrue(two_d_convert_to_q.q_xy_step_type is RangeStepType.LIN)
self.assertTrue(results.get_state_calculate_transmission().rebin_type is RebinType.INTERPOLATING_REBIN)
def _parse_binning(self):
binning_dict = self._get_val(["binning"])
def set_wavelength(state_obj):
wavelength_start = self._get_val(["wavelength", "start"],
binning_dict)
# Weirdly start and stop in user file parser are lists whilst
# step is a float val?
if wavelength_start:
state_obj.wavelength_low = [wavelength_start]
wavelength_stop = self._get_val(["wavelength", "stop"],
binning_dict)
if wavelength_stop:
state_obj.wavelength_high = [wavelength_stop]
state_obj.wavelength_step = self._get_val(["wavelength", "step"],
binning_dict, 0.0)
step_str = self._get_val(["wavelength", "type"], binning_dict)
if step_str:
state_obj.wavelength_step_type = RangeStepType(step_str)
# For legacy reasons where information is duplicated across our
# state objects we set the same thing in 4 different locations.
set_wavelength(self.calculate_transmission)
set_wavelength(self.normalize_to_monitor)
set_wavelength(self.wavelength)
set_wavelength(self.wavelength_and_pixel)
one_d_dict = self._get_val("1d_reduction", binning_dict)
if one_d_dict:
one_d_binning = self._get_val(["1d_reduction", "binning"],
binning_dict)
q_min, q_max = self._get_1d_min_max(one_d_binning)
self.convert_to_q.q_min = q_min
self.convert_to_q.q_1d_rebin_string = one_d_binning
self.convert_to_q.q_max = q_max
self.convert_to_q.radius_cutoff = self._get_val("radius_cut",
one_d_dict,
default=0.0)
self.convert_to_q.wavelength_cutoff = self._get_val(
"wavelength_cut", one_d_dict, default=0.0)
self.convert_to_q.q_xy_max = self._get_val(["2d_reduction", "stop"],
binning_dict)
self.convert_to_q.q_xy_step = self._get_val(["2d_reduction", "step"],
binning_dict)
two_d_step_type = self._get_val(["2d_reduction", "type"], binning_dict)
if two_d_step_type:
self.convert_to_q.q_xy_step_type = RangeStepType(two_d_step_type)
rebin_type = self._get_val(["2d_reduction", "interpolate"],
binning_dict,
default=False)
rebin_type = RebinType.INTERPOLATING_REBIN if rebin_type else RebinType.REBIN
self.calculate_transmission.rebin_type = rebin_type
self.normalize_to_monitor.rebin_type = rebin_type
def set_wavelength(state_obj):
wavelength_start = self._get_val(["wavelength", "start"],
binning_dict)
# Weirdly start and stop in user file parser are lists whilst
# step is a float val?
if wavelength_start:
state_obj.wavelength_low = [wavelength_start]
wavelength_stop = self._get_val(["wavelength", "stop"],
binning_dict)
if wavelength_stop:
state_obj.wavelength_high = [wavelength_stop]
state_obj.wavelength_step = self._get_val(["wavelength", "step"],
binning_dict, 0.0)
step_str = self._get_val(["wavelength", "type"], binning_dict)
if step_str:
state_obj.wavelength_step_type = RangeStepType(step_str)
def set_wavelength_details(self, state_objs: DuplicateWavelengthStates):
binning_dict = self.get_val(["binning"])
if not self.get_val("wavelength", binning_dict):
return
step_type = RangeStepType(self.get_mandatory_val(["binning", "wavelength", "type"]))
wavelength_step = float(self.get_mandatory_val(["binning", "wavelength", "step"]))
for i in state_objs.iterate_fields():
i.wavelength_interval.wavelength_step = wavelength_step
i.wavelength_step_type = step_type
if step_type in (RangeStepType.RANGE_LIN, RangeStepType.RANGE_LOG):
self._parse_range_wavelength(state_objs)
else:
assert step_type in (RangeStepType.LIN, RangeStepType.LOG)
self._parse_linear_wavelength(state_objs)
def _get_rebin_string(self, workspace, wavelength_low, wavelength_high):
# If the wavelength has not been specified, then get it from the workspace. Only the first spectrum is checked
# The lowest wavelength value is to be found in the spectrum located at workspaces index 0 is a very
# strong assumption, but it existed in the previous implementation.
if wavelength_low is None or wavelength_low == Property.EMPTY_DBL:
wavelength_low = min(workspace.readX(0))
if wavelength_high is None or wavelength_high == Property.EMPTY_DBL:
wavelength_high = max(workspace.readX(0))
wavelength_step = self.getProperty("WavelengthStep").value
step_type = RangeStepType(self.getProperty("WavelengthStepType").value)
pre_factor = -1 if step_type in [
RangeStepType.LOG, RangeStepType.RANGE_LOG
] else 1
wavelength_step *= pre_factor
return str(wavelength_low) + "," + str(wavelength_step) + "," + str(
wavelength_high)
def _parse_binning(self):
binning_dict = self.get_val(["binning"])
to_set = DuplicateWavelengthStates(
transmission=self.calculate_transmission,
normalize=self.normalize_to_monitor,
wavelength=self.wavelength,
pixel=self.wavelength_and_pixel)
WavelengthTomlParser(toml_dict=self._input).set_wavelength_details(
state_objs=to_set)
one_d_dict = self.get_val("1d_reduction", binning_dict)
if one_d_dict:
one_d_binning = self.get_val(["1d_reduction", "binning"],
binning_dict)
q_min, q_max = self._get_1d_min_max(one_d_binning)
self.convert_to_q.q_min = q_min
self.convert_to_q.q_1d_rebin_string = one_d_binning
self.convert_to_q.q_max = q_max
self.convert_to_q.radius_cutoff = self.get_val("radius_cut",
one_d_dict,
default=0.0)
self.convert_to_q.wavelength_cutoff = self.get_val(
"wavelength_cut", one_d_dict, default=0.0)
self.convert_to_q.q_xy_max = self.get_val(["2d_reduction", "stop"],
binning_dict)
self.convert_to_q.q_xy_step = self.get_val(["2d_reduction", "step"],
binning_dict)
two_d_step_type = self.get_val(["2d_reduction", "type"], binning_dict)
if two_d_step_type:
self.convert_to_q.q_xy_step_type = RangeStepType(two_d_step_type)
rebin_type = self.get_val(["2d_reduction", "interpolate"],
binning_dict,
default=False)
rebin_type = RebinType.INTERPOLATING_REBIN if rebin_type else RebinType.REBIN
self.calculate_transmission.rebin_type = rebin_type
self.normalize_to_monitor.rebin_type = rebin_type
