def test_that_mask_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_builder.set_sample_scatter_period(3)
data_info = data_builder.build()
# Act
builder = get_mask_builder(data_info)
self.assertTrue(builder)
start_time = [0.1, 1.3]
end_time = [0.2, 1.6]
builder.set_bin_mask_general_start(start_time)
builder.set_bin_mask_general_stop(end_time)
builder.set_LAB_single_vertical_strip_mask([1, 2, 3])
# Assert
state = builder.build()
self.assertTrue(len(state.bin_mask_general_start) == 2)
self.assertTrue(state.bin_mask_general_start[0] == start_time[0])
self.assertTrue(state.bin_mask_general_start[1] == start_time[1])
self.assertTrue(len(state.bin_mask_general_stop) == 2)
self.assertTrue(state.bin_mask_general_stop[0] == end_time[0])
self.assertTrue(state.bin_mask_general_stop[1] == end_time[1])
strip_mask = state.detectors[DetectorType.to_string(DetectorType.LAB)].single_vertical_strip_mask
self.assertTrue(len(strip_mask) == 3)
self.assertTrue(strip_mask[2] == 3)
def test_that_divide_uses_settings_from_state_if_they_are_set(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("SANS2D00022024")
data_state = data_builder.build()
scale_builder = get_scale_builder(data_state)
width = 10.
height = 5.
thickness = 2.
scale_builder.set_shape(SampleShape.CylinderAxisAlong)
scale_builder.set_thickness(thickness)
scale_builder.set_width(width)
scale_builder.set_height(height)
scale_state = scale_builder.build()
test_director = TestDirector()
test_director.set_states(scale_state=scale_state, data_state=data_state)
state = test_director.construct()
divide_factory = DivideByVolumeFactory()
divider = divide_factory.create_divide_by_volume(state)
workspace = ScaleHelperTest._get_workspace()
# Act
output_workspace = divider.divide_by_volume(workspace, scale_state)
# Assert
expected_volume = thickness * math.pi * math.pow(width, 2) / 4.0
expected_value = 0.3 / expected_volume
data_y = output_workspace.dataY(0)
self.assertEqual(data_y[0], expected_value)
def _get_data_state(self):
# Get the data commands
data_commands = self._get_data_commands()
data_elements = self._get_elements_with_key(DataCommandId.sample_scatter, data_commands)
data_element = data_elements[-1]
file_name = data_element.file_name
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(file_name)
# Build the state data
data_builder = get_data_builder(self._facility, file_information)
self._set_data_element(data_builder.set_sample_scatter, data_builder.set_sample_scatter_period,
DataCommandId.sample_scatter, data_commands)
self._set_data_element(data_builder.set_sample_transmission, data_builder.set_sample_transmission_period,
DataCommandId.sample_transmission, data_commands)
self._set_data_element(data_builder.set_sample_direct, data_builder.set_sample_direct_period,
DataCommandId.sample_direct, data_commands)
self._set_data_element(data_builder.set_can_scatter, data_builder.set_can_scatter_period,
DataCommandId.can_scatter, data_commands)
self._set_data_element(data_builder.set_can_transmission, data_builder.set_can_transmission_period,
DataCommandId.can_transmission, data_commands)
self._set_data_element(data_builder.set_can_direct, data_builder.set_can_direct_period,
DataCommandId.can_direct, data_commands)
return data_builder.build()
def test_that_slice_event_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_slice_event_builder(data_info)
self.assertTrue(builder)
start_time = [0.1, 1.3]
end_time = [0.2, 1.6]
builder.set_start_time(start_time)
builder.set_end_time(end_time)
# Assert
state = builder.build()
self.assertTrue(len(state.start_time) == 2)
self.assertTrue(state.start_time[0] == start_time[0])
self.assertTrue(state.start_time[1] == start_time[1])
self.assertTrue(len(state.end_time) == 2)
self.assertTrue(state.end_time[0] == end_time[0])
self.assertTrue(state.end_time[1] == end_time[1])
def _get_sample_state(q_min=1., q_max=2., q_step=0.1, q_step_type=RangeStepType.Lin,
q_xy_max=None, q_xy_step=None, q_xy_step_type=None,
use_gravity=False, dim=ReductionDimensionality.OneDim):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_state = data_builder.build()
convert_to_q_builder = get_convert_to_q_builder(data_state)
convert_to_q_builder.set_reduction_dimensionality(dim)
convert_to_q_builder.set_use_gravity(use_gravity)
convert_to_q_builder.set_radius_cutoff(0.002)
convert_to_q_builder.set_wavelength_cutoff(2.)
convert_to_q_builder.set_q_min(q_min)
convert_to_q_builder.set_q_max(q_max)
prefix = 1. if q_step_type is RangeStepType.Lin else -1.
q_step *= prefix
rebin_string = str(q_min) + "," + str(q_step) + "," + str(q_max)
convert_to_q_builder.set_q_1d_rebin_string(rebin_string)
if q_xy_max is not None:
convert_to_q_builder.set_q_xy_max(q_xy_max)
if q_xy_step is not None:
convert_to_q_builder.set_q_xy_step(q_xy_step)
if q_xy_step_type is not None:
convert_to_q_builder.set_q_xy_step_type(q_xy_step_type)
convert_to_q_state = convert_to_q_builder.build()
test_director = TestDirector()
test_director.set_states(convert_to_q_state=convert_to_q_state, data_state=data_state)
return test_director.construct().property_manager
def test_that_wavelength_and_pixel_adjustment_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_wavelength_and_pixel_adjustment_builder(data_info)
self.assertTrue(builder)
builder.set_HAB_pixel_adjustment_file("test")
builder.set_HAB_wavelength_adjustment_file("test2")
builder.set_wavelength_low([1.5])
builder.set_wavelength_high([2.7])
builder.set_wavelength_step(0.5)
builder.set_wavelength_step_type(RangeStepType.Lin)
state = builder.build()
# Assert
self.assertTrue(state.adjustment_files[DetectorType.to_string(
DetectorType.HAB)].pixel_adjustment_file == "test")
self.assertTrue(state.adjustment_files[DetectorType.to_string(
DetectorType.HAB)].wavelength_adjustment_file == "test2")
self.assertTrue(state.wavelength_low == [1.5])
self.assertTrue(state.wavelength_high == [2.7])
self.assertTrue(state.wavelength_step == 0.5)
self.assertTrue(state.wavelength_step_type is RangeStepType.Lin)
def test_that_slice_event_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_slice_event_builder(data_info)
self.assertTrue(builder)
start_time = [0.1, 1.3]
end_time = [0.2, 1.6]
builder.set_start_time(start_time)
builder.set_end_time(end_time)
# Assert
state = builder.build()
self.assertTrue(len(state.start_time) == 2)
self.assertTrue(state.start_time[0] == start_time[0])
self.assertTrue(state.start_time[1] == start_time[1])
self.assertTrue(len(state.end_time) == 2)
self.assertTrue(state.end_time[0] == end_time[0])
self.assertTrue(state.end_time[1] == end_time[1])
def test_that_slice_event_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_wavelength_builder(data_info)
self.assertTrue(builder)
builder.set_wavelength_low([10.0])
builder.set_wavelength_high([20.0])
builder.set_wavelength_step(3.0)
builder.set_wavelength_step_type(RangeStepType.Lin)
builder.set_rebin_type(RebinType.Rebin)
# Assert
state = builder.build()
self.assertTrue(state.wavelength_low == [10.0])
self.assertTrue(state.wavelength_high == [20.0])
self.assertTrue(state.wavelength_step_type is RangeStepType.Lin)
self.assertTrue(state.rebin_type is RebinType.Rebin)
def test_that_cylinder_masking_is_applied(self):
# Arrange
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("SANS2D00028827")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
# Radius Mask
radius_min = 0.01
radius_max = 10.
expected_spectra = []
expected_spectra.extend([30469, 30470, 30471, 30472, 30473, 30474, 30475, 30476, 30477, 30980,
30981, 30982, 30983, 30984, 30985, 30986, 30987, 30988])
mask_builder.set_radius_min(radius_min)
mask_builder.set_radius_max(radius_max)
mask_info = mask_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info, mask_state=mask_info)
state = test_director.construct()
workspace = self._load_workspace(state, move_workspace=False)
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
self._do_assert(workspace, expected_spectra)
def test_that_correct_scale_strategy_is_selected_for_loq_2(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_state = data_builder.build()
scale_builder = get_scale_builder(data_state)
scale_builder.set_scale(2.4)
scale_state = scale_builder.build()
test_director = TestDirector()
test_director.set_states(scale_state=scale_state, data_state=data_state)
state_loq = test_director.construct()
absolute_multiply_factory = MultiplyByAbsoluteScaleFactory()
multiplier = absolute_multiply_factory.create_multiply_by_absolute(state_loq)
workspace = self._get_workspace()
# Act
output_workspace = multiplier.multiply_by_absolute_scale(workspace, state_loq.scale)
# Assert
expected_value = 0.3 * 2.4 / math.pi * 100.
data_y = output_workspace.dataY(0)
self.assertEqual(data_y[0], expected_value)
def test_that_state_for_loq_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_builder.set_sample_scatter_period(3)
data_info = data_builder.build()
# Act
builder = get_move_builder(data_info)
self.assertTrue(builder)
value = 324.2
builder.set_center_position(value)
builder.set_HAB_x_translation_correction(value)
builder.set_LAB_sample_centre_pos1(value)
# Assert
state = builder.build()
self.assertTrue(state.center_position == value)
self.assertTrue(state.detectors[DetectorType.to_string(DetectorType.HAB)].x_translation_correction == value)
self.assertTrue(state.detectors[DetectorType.to_string(DetectorType.HAB)].detector_name_short == "HAB")
self.assertTrue(state.detectors[DetectorType.to_string(DetectorType.LAB)].detector_name == "main-detector-bank")
self.assertTrue(state.monitor_names[str(2)] == "monitor2")
self.assertTrue(len(state.monitor_names) == 2)
self.assertTrue(state.detectors[DetectorType.to_string(DetectorType.LAB)].sample_centre_pos1 == value)
def test_that_reduction_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_save_builder(data_info)
self.assertTrue(builder)
user_specified_output_name = "test_file_name"
zero_free_correction = True
file_format = [SaveType.Nexus, SaveType.CanSAS]
builder.set_user_specified_output_name(user_specified_output_name)
builder.set_zero_free_correction(zero_free_correction)
builder.set_file_format(file_format)
state = builder.build()
# Assert
self.assertTrue(state.user_specified_output_name == user_specified_output_name)
self.assertTrue(state.zero_free_correction == zero_free_correction)
self.assertTrue(state.file_format == file_format)
def test_that_reduction_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_convert_to_q_builder(data_info)
self.assertTrue(builder)
builder.set_q_min(12.0)
builder.set_q_max(17.0)
builder.set_q_step(1.)
builder.set_q_step_type(RangeStepType.Lin)
builder.set_reduction_dimensionality(ReductionDimensionality.OneDim)
state = builder.build()
# Assert
self.assertTrue(state.q_min == 12.0)
self.assertTrue(state.q_max == 17.0)
self.assertTrue(state.q_step == 1.)
self.assertTrue(state.q_step_type is RangeStepType.Lin)
self.assertTrue(state.reduction_dimensionality is ReductionDimensionality.OneDim)
def test_that_wavelength_and_pixel_adjustment_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_wavelength_and_pixel_adjustment_builder(data_info)
self.assertTrue(builder)
builder.set_HAB_pixel_adjustment_file("test")
builder.set_HAB_wavelength_adjustment_file("test2")
builder.set_wavelength_low(1.5)
builder.set_wavelength_high(2.7)
builder.set_wavelength_step(0.5)
builder.set_wavelength_step_type(RangeStepType.Lin)
state = builder.build()
# Assert
self.assertTrue(state.adjustment_files[DetectorType.to_string(
DetectorType.HAB)].pixel_adjustment_file == "test")
self.assertTrue(state.adjustment_files[DetectorType.to_string(
DetectorType.HAB)].wavelength_adjustment_file == "test2")
self.assertTrue(state.wavelength_low == 1.5)
self.assertTrue(state.wavelength_high == 2.7)
self.assertTrue(state.wavelength_step == 0.5)
self.assertTrue(state.wavelength_step_type is RangeStepType.Lin)
def test_that_reduction_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_adjustment_builder(data_info)
self.assertTrue(builder)
builder.set_calculate_transmission(MockStateCalculateTransmission())
builder.set_normalize_to_monitor(MockStateNormalizeToMonitor())
builder.set_wavelength_and_pixel_adjustment(MockStateWavelengthAndPixelAdjustment())
builder.set_wide_angle_correction(False)
state = builder.build()
# # Assert
self.assertTrue(not state.wide_angle_correction)
try:
state.validate()
is_valid = True
except ValueError:
is_valid = False
self.assertTrue(is_valid)
def test_batch_reduction_on_multiperiod_file(self):
# Arrange
# Build the data information
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("SANS2D0005512")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info)
user_file_director.set_user_file("MASKSANS2Doptions.091A")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB)
state = user_file_director.construct()
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = ["5512p1rear_1D_2.0_14.0Phi-45.0_45.0", "5512p2rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p3rear_1D_2.0_14.0Phi-45.0_45.0", "5512p4rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p5rear_1D_2.0_14.0Phi-45.0_45.0", "5512p6rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p7rear_1D_2.0_14.0Phi-45.0_45.0", "5512p8rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p9rear_1D_2.0_14.0Phi-45.0_45.0", "5512p10rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p11rear_1D_2.0_14.0Phi-45.0_45.0", "5512p12rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p13rear_1D_2.0_14.0Phi-45.0_45.0"]
for element in expected_workspaces:
self.assertTrue(AnalysisDataService.doesExist(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def test_that_slice_event_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_scale_builder(data_info, file_information)
self.assertTrue(builder)
builder.set_scale(1.0)
builder.set_shape(SampleShape.FlatPlate)
builder.set_thickness(3.6)
builder.set_width(3.7)
builder.set_height(5.8)
# Assert
state = builder.build()
self.assertTrue(state.shape is SampleShape.FlatPlate)
self.assertTrue(state.scale == 1.0)
self.assertTrue(state.thickness == 3.6)
self.assertTrue(state.width == 3.7)
self.assertTrue(state.height == 5.8)
def test_state_can_be_created_from_valid_user_file_with_data_information(self):
# Arrange
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("SANS2D00022024")
data_builder.set_sample_scatter_period(3)
data_state = data_builder.build()
director = StateDirectorISIS(data_state)
user_file_path = create_user_file(sample_user_file)
director.set_user_file(user_file_path)
state = director.construct()
# Assert
self._assert_data(state)
self._assert_move(state)
self._assert_mask(state)
self._assert_reduction(state)
self._assert_wavelength(state)
self._assert_scale(state)
self._assert_adjustment(state)
self._assert_convert_to_q(state)
# clean up
if os.path.exists(user_file_path):
os.remove(user_file_path)
def test_that_reduction_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_reduction_mode_builder(data_info)
self.assertTrue(builder)
mode = ISISReductionMode.Merged
dim = ReductionDimensionality.OneDim
builder.set_reduction_mode(mode)
builder.set_reduction_dimensionality(dim)
merge_shift = 324.2
merge_scale = 3420.98
fit_mode = FitModeForMerge.Both
builder.set_merge_fit_mode(fit_mode)
builder.set_merge_shift(merge_shift)
builder.set_merge_scale(merge_scale)
state = builder.build()
# Assert
self.assertTrue(state.reduction_mode is mode)
self.assertTrue(state.reduction_dimensionality is dim)
self.assertTrue(state.merge_fit_mode == fit_mode)
self.assertTrue(state.merge_shift == merge_shift)
self.assertTrue(state.merge_scale == merge_scale)
detector_names = state.detector_names
self.assertTrue(detector_names[DetectorType.to_string(DetectorType.LAB)] == "main-detector-bank")
def test_stat_can_be_crated_from_valid_user_file_and_later_on_reset(self):
# Arrange
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("SANS2D00022024")
data_builder.set_sample_scatter_period(3)
data_state = data_builder.build()
director = StateDirectorISIS(data_state)
user_file_path = create_user_file(sample_user_file)
director.set_user_file(user_file_path)
# Set additional items
director.set_mask_builder_radius_min(0.001298)
director.set_mask_builder_radius_max(0.003298)
director.set_scale_builder_width(1.)
director.set_scale_builder_height(1.5)
director.set_scale_builder_thickness(12.)
director.set_scale_builder_shape(SampleShape.Cuboid)
# Act
state = director.construct()
# Assert
self.assertTrue(state.mask.radius_min == 0.001298)
self.assertTrue(state.mask.radius_max == 0.003298)
self.assertTrue(state.scale.width == 1.)
self.assertTrue(state.scale.height == 1.5)
self.assertTrue(state.scale.thickness == 12.)
self.assertTrue(state.scale.shape is SampleShape.Cuboid)
# clean up
if os.path.exists(user_file_path):
os.remove(user_file_path)
def test_that_divide_uses_settings_from_workspace(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("SANS2D00022024")
data_state = data_builder.build()
scale_builder = get_scale_builder(data_state)
scale_state = scale_builder.build()
test_director = TestDirector()
test_director.set_states(scale_state=scale_state, data_state=data_state)
state = test_director.construct()
divide_factory = DivideByVolumeFactory()
divider = divide_factory.create_divide_by_volume(state)
# Apply the settings from the SANS2D00022024 workspace
width = 8.
height = 8.
thickness = 1.
shape = 3
workspace = ScaleHelperTest._get_workspace(width, height, thickness, shape)
# Act
output_workspace = divider.divide_by_volume(workspace, scale_state)
# Assert
expected_volume = thickness * math.pi * math.pow(width, 2) / 4.0
expected_value = 0.3 / expected_volume
data_y = output_workspace.dataY(0)
self.assertEqual(data_y[0], expected_value)
def test_that_cross_block_masking_is_applied(self):
# Arrange
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("SANS2D00028827")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
# Expected_spectra
expected_spectra = []
# Block
# Detector-specific cross block
# The block will be evaluated for SANS2D on the LAB as:
block_cross_horizontal = [12, 17]
block_cross_vertical = [49, 67]
for h, v in zip(block_cross_horizontal, block_cross_vertical):
expected_spectra.extend([h*512 + 9 + v])
mask_builder.set_LAB_block_cross_horizontal(block_cross_horizontal)
mask_builder.set_LAB_block_cross_vertical(block_cross_vertical)
mask_info = mask_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info, mask_state=mask_info)
state = test_director.construct()
workspace = self._load_workspace(state)
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
self._do_assert(workspace, expected_spectra)
def test_that_beam_stop_masking_is_applied(self):
# Arrange
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("SANS2D00028827")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
beam_stop_arm_width = .01
beam_stop_arm_angle = 180.0
beam_stop_arm_pos1 = 0.0
beam_stop_arm_pos2 = 0.0
# Expected_spectra, again the tubes are shifted and that will produce the slightly strange masking
expected_spectra = []
expected_spectra.extend((512*59 + 9 + x for x in range(0, 257)))
expected_spectra.extend((512*60 + 9 + x for x in range(0, 255)))
mask_builder.set_beam_stop_arm_width(beam_stop_arm_width)
mask_builder.set_beam_stop_arm_angle(beam_stop_arm_angle)
mask_builder.set_beam_stop_arm_pos1(beam_stop_arm_pos1)
mask_builder.set_beam_stop_arm_pos2(beam_stop_arm_pos2)
mask_info = mask_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info, mask_state=mask_info)
state = test_director.construct()
workspace = self._load_workspace(state, move_workspace=False)
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
self._do_assert(workspace, expected_spectra)
def test_that_produces_correct_workspace_for_SANS2D(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information("SANS2D00034484")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00034484")
data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs")
data_state = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_state, file_information)
user_file_director.set_user_file("USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt")
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY BEGIN -- Remove when appropriate
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Since we are dealing with event based data but we want to compare it with histogram data from the
# old reduction system we need to enable the compatibility mode
user_file_director.set_compatibility_builder_use_compatibility_mode(True)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY END
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Construct the final state
state = user_file_director.construct()
# Act
output_workspaces = run_integral('', True, IntegralEnum.Horizontal, DetectorType.LAB, state)
self.assertEqual(len(output_workspaces), 1)
# Evaluate it up to a defined point
reference_file_name = "SANS2D_ws_centred_diagnostic_reference.nxs"
self._compare_workspace(output_workspaces[0], reference_file_name)
def test_that_reduction_core_evaluates_LAB(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D00034484")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00034484")
data_builder.set_sample_transmission("SANS2D00034505")
data_builder.set_sample_direct("SANS2D00034461")
data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs")
data_state = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_state, file_information)
user_file_director.set_user_file(
"USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt")
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY BEGIN -- Remove when appropriate
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Since we are dealing with event based data but we want to compare it with histogram data from the
# old reduction system we need to enable the compatibility mode
user_file_director.set_compatibility_builder_use_compatibility_mode(
True)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY END
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Construct the final state
state = user_file_director.construct()
# Load the sample workspaces
workspace, workspace_monitor, transmission_workspace, direct_workspace = self._load_workspace(
state)
# Act
reduction_core_alg = self._run_reduction_core(state, workspace,
workspace_monitor,
transmission_workspace,
direct_workspace)
output_workspace = reduction_core_alg.getProperty(
"OutputWorkspace").value
calculated_transmission = reduction_core_alg.getProperty(
"CalculatedTransmissionWorkspace").value
unfitted_transmission = reduction_core_alg.getProperty(
"UnfittedTransmissionWorkspace").value
# Evaluate it up to a defined point
reference_file_name = "SANS2D_ws_D20_reference.nxs"
self._compare_workspace(output_workspace, reference_file_name)
calculated_transmission_reference_file = "SANS2D_ws_D20_calculated_transmission_reference.nxs"
unfitted_transmission_reference_file = "SANS2D_ws_D20_unfitted_transmission_reference.nxs"
self._compare_workspace(calculated_transmission,
calculated_transmission_reference_file)
self._compare_workspace(unfitted_transmission,
unfitted_transmission_reference_file)
def test_that_single_reduction_evaluates_HAB(self):
# Arrange
# Build the data information
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("SANS2D00034484")
data_builder.set_sample_transmission("SANS2D00034505")
data_builder.set_sample_direct("SANS2D00034461")
data_builder.set_can_scatter("SANS2D00034481")
data_builder.set_can_transmission("SANS2D00034502")
data_builder.set_can_direct("SANS2D00034461")
data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info)
user_file_director.set_user_file(
"USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(
ISISReductionMode.HAB)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY BEGIN -- Remove when appropriate
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Since we are dealing with event based data but we want to compare it with histogram data from the
# old reduction system we need to enable the compatibility mode
user_file_director.set_compatibility_builder_use_compatibility_mode(
True)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY END
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
state = user_file_director.construct()
# Load the sample workspaces
sample, sample_monitor, transmission_workspace, direct_workspace, can, can_monitor,\
can_transmission, can_direct = self._load_workspace(state) # noqa
# Act
output_settings = {"OutputWorkspaceHAB": EMPTY_NAME}
single_reduction_alg = self._run_single_reduction(
state,
sample_scatter=sample,
sample_transmission=transmission_workspace,
sample_direct=direct_workspace,
sample_monitor=sample_monitor,
can_scatter=can,
can_monitor=can_monitor,
can_transmission=can_transmission,
can_direct=can_direct,
output_settings=output_settings)
output_workspace = single_reduction_alg.getProperty(
"OutputWorkspaceHAB").value
# # Compare the output of the reduction with the reference
reference_file_name = "SANS2D_ws_D20_reference_HAB_1D.nxs"
self._compare_workspace(output_workspace, reference_file_name)
def test_batch_reduction_on_period_time_sliced_wavelength_range_data(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D0005512")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D0005512")
data_builder.set_sample_scatter_period(1)
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file("MASKSANS2Doptions.091A")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(
ISISReductionMode.LAB)
user_file_director.set_slice_event_builder_start_time([1.0, 3.0])
user_file_director.set_slice_event_builder_end_time([3.0, 5.0])
state = user_file_director.construct()
start = [1.0, 1.0]
end = [3.0, 2.0]
state.wavelength.wavelength_low = start
state.wavelength.wavelength_high = end
state.adjustment.normalize_to_monitor.wavelength_low = start
state.adjustment.normalize_to_monitor.wavelength_high = end
state.adjustment.calculate_transmission.wavelength_low = start
state.adjustment.calculate_transmission.wavelength_high = end
state.adjustment.wavelength_and_pixel_adjustment.wavelength_low = start
state.adjustment.wavelength_and_pixel_adjustment.wavelength_high = end
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = [
"5512p1rear_1D_1.0_2.0Phi-45.0_45.0_t1.00_T3.00",
"5512p1rear_1D_1.0_2.0Phi-45.0_45.0_t3.00_T5.00",
"5512p1rear_1D_1.0_3.0Phi-45.0_45.0_t1.00_T3.00",
"5512p1rear_1D_1.0_3.0Phi-45.0_45.0_t3.00_T5.00"
]
for element in expected_workspaces:
self.assertTrue(AnalysisDataService.doesExist(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def _get_simple_state(sample_scatter, sample_trans=None, sample_direct=None,
can_scatter=None, can_trans=None, can_direct=None, calibration=None,
sample_scatter_period=None, sample_trans_period=None, sample_direct_period=None,
can_scatter_period=None, can_trans_period=None, can_direct_period=None):
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(sample_scatter)
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter(sample_scatter)
# Set the file names
if sample_trans is not None:
data_builder.set_sample_transmission(sample_trans)
if sample_direct is not None:
data_builder.set_sample_direct(sample_direct)
if can_scatter is not None:
data_builder.set_can_scatter(can_scatter)
if can_trans is not None:
data_builder.set_can_transmission(can_trans)
if can_direct is not None:
data_builder.set_can_direct(can_direct)
# Set the periods
if sample_scatter_period is not None:
data_builder.set_sample_scatter_period(sample_scatter_period)
if sample_trans_period is not None:
data_builder.set_sample_transmission_period(sample_trans_period)
if sample_direct_period is not None:
data_builder.set_sample_direct_period(sample_direct_period)
if can_scatter_period is not None:
data_builder.set_can_scatter_period(can_scatter_period)
if can_trans_period is not None:
data_builder.set_can_transmission_period(can_trans_period)
if can_direct_period is not None:
data_builder.set_can_direct_period(can_direct_period)
# Add the calibration
if calibration is not None:
data_builder.set_calibration(calibration)
data_info = data_builder.build()
# Get the sample state
test_director = TestDirector()
test_director.set_states(data_state=data_info)
return test_director.construct()
def _get_simple_state(sample_scatter, sample_trans=None, sample_direct=None,
can_scatter=None, can_trans=None, can_direct=None, calibration=None,
sample_scatter_period=None, sample_trans_period=None, sample_direct_period=None,
can_scatter_period=None, can_trans_period=None, can_direct_period=None):
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(sample_scatter)
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter(sample_scatter)
# Set the file names
if sample_trans is not None:
data_builder.set_sample_transmission(sample_trans)
if sample_direct is not None:
data_builder.set_sample_direct(sample_direct)
if can_scatter is not None:
data_builder.set_can_scatter(can_scatter)
if can_trans is not None:
data_builder.set_can_transmission(can_trans)
if can_direct is not None:
data_builder.set_can_direct(can_direct)
# Set the periods
if sample_scatter_period is not None:
data_builder.set_sample_scatter_period(sample_scatter_period)
if sample_trans_period is not None:
data_builder.set_sample_transmission_period(sample_trans_period)
if sample_direct_period is not None:
data_builder.set_sample_direct_period(sample_direct_period)
if can_scatter_period is not None:
data_builder.set_can_scatter_period(can_scatter_period)
if can_trans_period is not None:
data_builder.set_can_transmission_period(can_trans_period)
if can_direct_period is not None:
data_builder.set_can_direct_period(can_direct_period)
# Add the calibration
if calibration is not None:
data_builder.set_calibration(calibration)
data_info = data_builder.build()
# Get the sample state
test_director = TestDirector()
test_director.set_states(data_state=data_info)
return test_director.construct()
def get_example_state():
ws_name_sample = "SANS2D00022024"
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter(ws_name_sample)
data = data_builder.build()
# Get the sample state
test_director = TestDirector()
test_director.set_states(data_state=data)
return test_director.construct()
def get_example_state():
ws_name_sample = "SANS2D00022024"
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter(ws_name_sample)
data = data_builder.build()
# Get the sample state
test_director = TestDirector()
test_director.set_states(data_state=data)
return test_director.construct()
def get_example_state():
ws_name_sample = "SANS2D00022024"
file_information = SANSFileInformationMock(instrument=SANSInstrument.SANS2D, run_number=22024)
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter(ws_name_sample)
data = data_builder.build()
# Get the sample state
test_director = TestDirector()
test_director.set_states(data_state=data)
return test_director.construct()
def test_that_single_reduction_evaluates_LAB_for_2D_reduction(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information("SANS2D00034484")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00034484")
data_builder.set_sample_transmission("SANS2D00034505")
data_builder.set_sample_direct("SANS2D00034461")
data_builder.set_can_scatter("SANS2D00034481")
data_builder.set_can_transmission("SANS2D00034502")
data_builder.set_can_direct("SANS2D00034461")
data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file("USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB)
user_file_director.set_reduction_builder_reduction_dimensionality(ReductionDimensionality.TwoDim)
user_file_director.set_convert_to_q_builder_reduction_dimensionality(ReductionDimensionality.TwoDim)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY BEGIN -- Remove when appropriate
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Since we are dealing with event based data but we want to compare it with histogram data from the
# old reduction system we need to enable the compatibility mode
user_file_director.set_compatibility_builder_use_compatibility_mode(True)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY END
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
state = user_file_director.construct()
# Load the sample workspaces
sample, sample_monitor, transmission_workspace, direct_workspace, can, can_monitor, \
can_transmission, can_direct = self._load_workspace(state) # noqa
# Act
output_settings = {"OutputWorkspaceLAB": EMPTY_NAME}
single_reduction_alg = self._run_single_reduction(state, sample_scatter=sample,
sample_transmission=transmission_workspace,
sample_direct=direct_workspace,
sample_monitor=sample_monitor,
can_scatter=can,
can_monitor=can_monitor,
can_transmission=can_transmission,
can_direct=can_direct,
output_settings=output_settings)
output_workspace = single_reduction_alg.getProperty("OutputWorkspaceLAB").value
# Compare the output of the reduction with the reference
reference_file_name = "SANS2D_ws_D20_reference_LAB_2D.nxs"
self._compare_workspace(output_workspace, reference_file_name)
def get_example_state():
ws_name_sample = "SANS2D00022024"
file_information = SANSFileInformationMock(instrument=SANSInstrument.SANS2D, run_number=22024)
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter(ws_name_sample)
data = data_builder.build()
# Get the sample state
test_director = TestDirector()
test_director.set_states(data_state=data)
return test_director.construct()
def test_that_correct_values_are_set_for_LOQ(self):
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(run_number=74044, instrument=SANSInstrument.LOQ)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_state = data_builder.build()
self.beam_centre_model.reset_to_defaults_for_instrument(data_state)
self.assertEqual(self.beam_centre_model.r_max, 200)
def test_that_correct_values_are_set_for_LARMOR(self):
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(run_number=2260, instrument=SANSInstrument.LARMOR)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LARMOR00002260")
data_state = data_builder.build()
self.beam_centre_model.reset_to_defaults_for_instrument(data_state)
self.assertEqual(self.beam_centre_model.scale_1, 1.0)
def test_that_angle_masking_is_applied(self):
# Arrange
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D00028827")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00028827")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
# Expected_spectra
phi_mirror = False
phi_min = 0.
phi_max = 90.
# This should mask everything except for the upper right quadrant
# | 120 |-------------------|
# | |---------------------|
# | 60 |-------------------|
# | |----------------------|
# |
# |
# |-------------------|------------------|
# 512 256 0
expected_spectra = []
# The strange double pattern arises from the offset of the SANS2D tube geometry (see InstrumentView)
for y in range(60, 120):
if y % 2 == 0:
expected_spectra.extend(
((y * 512) + 9 + x for x in range(0, 255)))
else:
expected_spectra.extend(
((y * 512) + 9 + x for x in range(0, 257)))
expected_spectra.extend((x for x in range(92169, 122889))) # HAB
mask_builder.set_use_mask_phi_mirror(phi_mirror)
mask_builder.set_phi_min(phi_min)
mask_builder.set_phi_max(phi_max)
mask_info = mask_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info, mask_state=mask_info)
state = test_director.construct()
workspace = self._load_workspace(state)
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
self._do_assert_non_masked(workspace, expected_spectra)
def test_batch_reduction_on_period_time_sliced_wavelength_range_data(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information("SANS2D0005512")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D0005512")
data_builder.set_sample_scatter_period(1)
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file("MASKSANS2Doptions.091A")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB)
user_file_director.set_slice_event_builder_start_time([1.0, 3.0])
user_file_director.set_slice_event_builder_end_time([3.0, 5.0])
state = user_file_director.construct()
start = [1.0, 1.0]
end = [3.0, 2.0]
state.wavelength.wavelength_low = start
state.wavelength.wavelength_high = end
state.adjustment.normalize_to_monitor.wavelength_low = start
state.adjustment.normalize_to_monitor.wavelength_high = end
state.adjustment.calculate_transmission.wavelength_low = start
state.adjustment.calculate_transmission.wavelength_high = end
state.adjustment.wavelength_and_pixel_adjustment.wavelength_low = start
state.adjustment.wavelength_and_pixel_adjustment.wavelength_high = end
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = ["5512p1rear_1D_1.0_2.0Phi-45.0_45.0_t1.00_T3.00", "5512p1rear_1D_1.0_2.0Phi-45.0_45.0_t3.00_T5.00",
"5512p1rear_1D_1.0_3.0Phi-45.0_45.0_t1.00_T3.00", "5512p1rear_1D_1.0_3.0Phi-45.0_45.0_t3.00_T5.00"
]
for element in expected_workspaces:
self.assertTrue(AnalysisDataService.doesExist(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def test_that_mask_files_are_applied(self):
def create_shape_xml_file(xml_string):
f_name = os.path.join(
mantid.config.getString('defaultsave.directory'),
'sample_mask_file.xml')
if os.path.exists(f_name):
os.remove(f_name)
with open(f_name, 'w') as f:
f.write(xml_string)
return f_name
# Arrange
shape_xml = "<?xml version=\"1.0\"?>\n"\
"<detector-masking>\n" \
"<group>\n" \
"<detids>\n" \
"1313191-1313256\n" \
"</detids>\n" \
"</group>\n" \
"</detector-masking >"
file_name = create_shape_xml_file(shape_xml)
# Arrange
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D00028827")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00028827")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
# Mask file
# Got the spectra from the detector view
expected_spectra = [x for x in range(31432, 31498)]
mask_builder.set_mask_files([file_name])
mask_info = mask_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info, mask_state=mask_info)
state = test_director.construct()
workspace = self._load_workspace(state, move_workspace=False)
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
self._do_assert(workspace, expected_spectra)
# Remove
if os.path.exists(file_name):
os.remove(file_name)
def test_that_general_time_masking_is_applied(self):
# Arrange
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D00028827")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00028827")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
# Expected_spectra
bin_mask_general_start = [30000., 67000.]
bin_mask_general_stop = [35000., 75000.]
# bin_mask_start = [14000]
# bin_mask_stop = FloatListParameter()
mask_builder.set_bin_mask_general_start(bin_mask_general_start)
mask_builder.set_bin_mask_general_stop(bin_mask_general_stop)
mask_info = mask_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info, mask_state=mask_info)
state = test_director.construct()
workspace = self._load_workspace(state, move_workspace=False)
tof_spectra_10_original = workspace.getSpectrum(10).getTofs()
tof_spectra_11_original = workspace.getSpectrum(11).getTofs()
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
# Confirm that everything in the ranges 30000-35000 and 67000-75000 is removed from the event list
tof_spectra_10_masked = workspace.getSpectrum(10).getTofs()
tof_spectra_11_masked = workspace.getSpectrum(11).getTofs()
# Spectrum 10
# Three events should have been removed
self.assertTrue(
len(tof_spectra_10_masked) == len(tof_spectra_10_original) - 3)
# One event should have been removed
self.assertTrue(
len(tof_spectra_11_masked) == len(tof_spectra_11_original) - 1)
# Make sure that there are no elements
for start, stop in zip(bin_mask_general_start, bin_mask_general_stop):
self.assertFalse(
any(elements_in_range(start, stop, tof_spectra_10_masked)))
self.assertFalse(
any(elements_in_range(start, stop, tof_spectra_11_masked)))
def test_batch_reduction_on_time_sliced_file(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information("SANS2D00034484")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00034484")
data_builder.set_sample_transmission("SANS2D00034505")
data_builder.set_sample_direct("SANS2D00034461")
data_builder.set_can_scatter("SANS2D00034481")
data_builder.set_can_transmission("SANS2D00034502")
data_builder.set_can_direct("SANS2D00034461")
data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file("USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(ISISReductionMode.LAB)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY BEGIN -- Remove when appropriate
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Since we are dealing with event based data but we want to compare it with histogram data from the
# old reduction system we need to enable the compatibility mode
user_file_director.set_compatibility_builder_use_compatibility_mode(True)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY END
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
user_file_director.set_slice_event_builder_start_time([1.0,3.0])
user_file_director.set_slice_event_builder_end_time([3.0,5.0])
state = user_file_director.construct()
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
expected_workspaces = ["34484rear_1D_1.75_16.5_t1.00_T3.00", "34484rear_1D_1.75_16.5_t3.00_T5.00"]
reference_file_names = ["SANS2D_event_slice_referance_t1.00_T3.00.nxs", "SANS2D_event_slice_referance_t3.00_T5.00.nxs"]
for element, reference_file in zip(expected_workspaces, reference_file_names):
self.assertTrue(AnalysisDataService.doesExist(element))
# Evaluate it up to a defined point
self._compare_workspace(element, reference_file)
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def create_state(self, row, file_lookup=True, instrument=SANSInstrument.SANS2D,
user_file=""):
# 1. Get the data settings, such as sample_scatter, etc... and create the data state.
table_index_model = self._table_model.get_table_entry(row)
if file_lookup:
file_information = table_index_model.file_information
else:
file_information = SANSFileInformationMock(instrument=instrument, facility=self._facility)
data_builder = get_data_builder(self._facility, file_information, user_file)
self._set_data_entry(data_builder.set_sample_scatter, table_index_model.sample_scatter)
self._set_data_period_entry(data_builder.set_sample_scatter_period, table_index_model.sample_scatter_period)
self._set_data_entry(data_builder.set_sample_transmission, table_index_model.sample_transmission)
self._set_data_period_entry(data_builder.set_sample_transmission_period, table_index_model.sample_transmission_period) # noqa
self._set_data_entry(data_builder.set_sample_direct, table_index_model.sample_direct)
self._set_data_period_entry(data_builder.set_sample_direct_period, table_index_model.sample_direct_period)
self._set_data_entry(data_builder.set_can_scatter, table_index_model.can_scatter)
self._set_data_period_entry(data_builder.set_can_scatter_period, table_index_model.can_scatter_period)
self._set_data_entry(data_builder.set_can_transmission, table_index_model.can_transmission)
self._set_data_period_entry(data_builder.set_can_transmission_period, table_index_model.can_transmission_period)
self._set_data_entry(data_builder.set_can_direct, table_index_model.can_direct)
self._set_data_period_entry(data_builder.set_can_direct_period, table_index_model.can_direct_period)
data = data_builder.build()
# 2. Add elements from the options column
state_gui_model = copy.deepcopy(self._state_gui_model)
options_column_model = table_index_model.options_column_model
self._apply_column_options_to_state(options_column_model, state_gui_model)
# 3. Add other columns
output_name = table_index_model.output_name
if output_name:
state_gui_model.output_name = output_name
if table_index_model.sample_thickness:
state_gui_model.sample_thickness = float(table_index_model.sample_thickness)
if table_index_model.sample_height:
state_gui_model.sample_height = float(table_index_model.sample_height)
if table_index_model.sample_width:
state_gui_model.sample_width = float(table_index_model.sample_width)
if table_index_model.sample_shape:
state_gui_model.sample_shape = table_index_model.sample_shape
# 4. Create the rest of the state based on the builder.
user_file_state_director = StateDirectorISIS(data, file_information)
settings = copy.deepcopy(state_gui_model.settings)
user_file_state_director.add_state_settings(settings)
return user_file_state_director.construct()
def test_that_reduction_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(
instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_normalize_to_monitor_builder(data_info)
self.assertTrue(builder)
builder.set_prompt_peak_correction_min(12.0)
builder.set_prompt_peak_correction_max(17.0)
builder.set_rebin_type(RebinType.Rebin)
builder.set_wavelength_low([1.5])
builder.set_wavelength_high([2.7])
builder.set_wavelength_step(0.5)
builder.set_wavelength_step_type(RangeStepType.Lin)
builder.set_incident_monitor(1)
builder.set_background_TOF_general_start(1.4)
builder.set_background_TOF_general_stop(34.4)
builder.set_background_TOF_monitor_start({"1": 123, "2": 123})
builder.set_background_TOF_monitor_stop({"1": 234, "2": 2323})
state = builder.build()
# Assert
self.assertTrue(state.prompt_peak_correction_min == 12.0)
self.assertTrue(state.prompt_peak_correction_max == 17.0)
self.assertTrue(state.rebin_type is RebinType.Rebin)
self.assertTrue(state.wavelength_low == [1.5])
self.assertTrue(state.wavelength_high == [2.7])
self.assertTrue(state.wavelength_step == 0.5)
self.assertTrue(state.wavelength_step_type is RangeStepType.Lin)
self.assertTrue(state.background_TOF_general_start == 1.4)
self.assertTrue(state.background_TOF_general_stop == 34.4)
self.assertTrue(
len(
set(state.background_TOF_monitor_start.items()) & set({
"1": 123,
"2": 123
}.items())) == 2)
self.assertTrue(
len(
set(state.background_TOF_monitor_stop.items()) & set({
"1": 234,
"2": 2323
}.items())) == 2)
self.assertTrue(state.incident_monitor == 1)
def get_state_move_obj(monitor_4_dist):
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(
instrument=SANSInstrument.SANS2D, run_number=22048)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("SANS2D22048")
data_builder.set_sample_scatter_period(3)
data_info = data_builder.build()
state_builder = get_move_builder(data_info)
state = state_builder.build()
state.monitor_4_offset = monitor_4_dist
return state
def test_that_batch_reduction_evaluates_LAB(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D00034484")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00034484")
data_builder.set_sample_transmission("SANS2D00034505")
data_builder.set_sample_direct("SANS2D00034461")
data_builder.set_can_scatter("SANS2D00034481")
data_builder.set_can_transmission("SANS2D00034502")
data_builder.set_can_direct("SANS2D00034461")
data_builder.set_calibration("TUBE_SANS2D_BOTH_31681_25Sept15.nxs")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file(
"USER_SANS2D_154E_2p4_4m_M3_Xpress_8mm_SampleChanger.txt")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(
ISISReductionMode.LAB)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY BEGIN -- Remove when appropriate
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Since we are dealing with event based data but we want to compare it with histogram data from the
# old reduction system we need to enable the compatibility mode
user_file_director.set_compatibility_builder_use_compatibility_mode(
True)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# COMPATIBILITY END
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
state = user_file_director.construct()
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
workspace_name = "34484rear_1D_1.75_16.5"
output_workspace = AnalysisDataService.retrieve(workspace_name)
# Evaluate it up to a defined point
reference_file_name = "SANS2D_ws_D20_reference_LAB_1D.nxs"
self._compare_workspace(output_workspace, reference_file_name)
if AnalysisDataService.doesExist(workspace_name):
AnalysisDataService.remove(workspace_name)
def test_batch_reduction_on_multiperiod_file(self):
# Arrange
# Build the data information
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D0005512")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D0005512")
data_info = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_info, file_information)
user_file_director.set_user_file("MASKSANS2Doptions.091A")
# Set the reduction mode to LAB
user_file_director.set_reduction_builder_reduction_mode(
ISISReductionMode.LAB)
state = user_file_director.construct()
# Act
states = [state]
self._run_batch_reduction(states, use_optimizations=False)
# Assert
# We only assert that the expected workspaces exist on the ADS
expected_workspaces = [
"5512p1rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p2rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p3rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p4rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p5rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p6rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p7rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p8rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p9rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p10rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p11rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p12rear_1D_2.0_14.0Phi-45.0_45.0",
"5512p13rear_1D_2.0_14.0Phi-45.0_45.0"
]
for element in expected_workspaces:
self.assertTrue(AnalysisDataService.doesExist(element))
# Clean up
for element in expected_workspaces:
AnalysisDataService.remove(element)
def test_that_reduction_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(
instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_reduction_mode_builder(data_info)
self.assertTrue(builder)
mode = ISISReductionMode.Merged
dim = ReductionDimensionality.OneDim
builder.set_reduction_mode(mode)
builder.set_reduction_dimensionality(dim)
merge_shift = 324.2
merge_scale = 3420.98
fit_mode = FitModeForMerge.Both
builder.set_merge_fit_mode(fit_mode)
builder.set_merge_shift(merge_shift)
builder.set_merge_scale(merge_scale)
merge_mask = True
merge_min = 12.23
merge_max = 45.89
builder.set_merge_mask(merge_mask)
builder.set_merge_min(merge_min)
builder.set_merge_max(merge_max)
state = builder.build()
# Assert
self.assertEqual(state.reduction_mode, mode)
self.assertEqual(state.reduction_dimensionality, dim)
self.assertEqual(state.merge_fit_mode, fit_mode)
self.assertEqual(state.merge_shift, merge_shift)
self.assertEqual(state.merge_scale, merge_scale)
detector_names = state.detector_names
self.assertEqual(
detector_names[DetectorType.to_string(DetectorType.LAB)],
"main-detector-bank")
self.assertTrue(state.merge_mask)
self.assertEqual(state.merge_min, merge_min)
self.assertEqual(state.merge_max, merge_max)
def test_that_block_masking_is_applied(self):
# Arrange
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D00028827")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00028827")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
# Expected_spectra
expected_spectra = []
# Block
# Detector-specific block
# The block will be evaluated for SANS2D on the LAB as:
block_horizontal_start = [12, 17]
block_horizontal_stop = [14, 21]
block_vertical_start = [45, 87]
block_vertical_stop = [48, 91]
for h_start, h_stop, v_start, v_stop in zip(block_horizontal_start,
block_horizontal_stop,
block_vertical_start,
block_vertical_stop):
expected_spectra.extend(((h_start * 512 + 9) + y * 512 + x
for y in range(0, h_stop - h_start + 1)
for x in range(v_start, v_stop + 1)))
mask_builder.set_LAB_block_horizontal_start(block_horizontal_start)
mask_builder.set_LAB_block_horizontal_stop(block_horizontal_stop)
mask_builder.set_LAB_block_vertical_start(block_vertical_start)
mask_builder.set_LAB_block_vertical_stop(block_vertical_stop)
mask_info = mask_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info, mask_state=mask_info)
state = test_director.construct()
workspace = self._load_workspace(state)
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
self._do_assert(workspace, expected_spectra)
def test_that_data_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
# Act
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_builder.set_sample_scatter_period(3)
data_state = data_builder.build()
# # Assert
self.assertTrue(data_state.sample_scatter == "LOQ74044")
self.assertTrue(data_state.sample_scatter_period == 3)
self.assertTrue(data_state.sample_direct_period == 0)
self.assertTrue(data_state.instrument is SANSInstrument.LOQ)
self.assertTrue(data_state.sample_scatter_run_number == 74044)
def test_that_data_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(run_number=74044)
# Act
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_builder.set_sample_scatter_period(3)
data_state = data_builder.build()
# # Assert
self.assertEqual(data_state.sample_scatter, "LOQ74044")
self.assertEqual(data_state.sample_scatter_period, 3)
self.assertEqual(data_state.sample_direct_period, 0)
self.assertEqual(data_state.instrument, SANSInstrument.LOQ)
self.assertEqual(data_state.sample_scatter_run_number, 74044)
def test_that_detector_specific_time_masking_is_applied(self):
# Arrange
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"SANS2D00028827")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("SANS2D00028827")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
# Expected_spectra
bin_mask_start = [27000., 58000.]
bin_mask_stop = [45000., 61000.]
mask_builder.set_LAB_bin_mask_start(bin_mask_start)
mask_builder.set_LAB_bin_mask_stop(bin_mask_stop)
mask_info = mask_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info, mask_state=mask_info)
state = test_director.construct()
workspace = self._load_workspace(state, move_workspace=False)
# Is part of LAB
tof_spectra_23813_original = workspace.getSpectrum(23813).getTofs()
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
# Confirm that everything in the ranges 27000-45000 and 58000-61000 is removed from the event list
tof_spectra_23813_masked = workspace.getSpectrum(23813).getTofs()
# Spectrum 23813
# Five events should have been removed
self.assertTrue(
len(tof_spectra_23813_masked) == len(tof_spectra_23813_original) -
5)
# Make sure that there are no elements
for start, stop in zip(bin_mask_start, bin_mask_stop):
self.assertFalse(
any(elements_in_range(start, stop, tof_spectra_23813_masked)))
def get_state_move_obj(monitor_4_dist, monitor_5_dist):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(
instrument=SANSInstrument.ZOOM, run_number=6113)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("ZOOM00006113")
data_builder.set_sample_scatter_period(3)
data_info = data_builder.build()
# Act
state_builder = get_move_builder(data_info)
# Assert
state = state_builder.build()
state.monitor_4_offset = monitor_4_dist
state.monitor_5_offset = monitor_5_dist
return state
def _get_simple_state(sample_scatter, lab_x_translation_correction=None, lab_z_translation_correction=None):
# Set the data
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter(sample_scatter)
data_info = data_builder.build()
# Set the move parameters
builder = get_move_builder(data_info)
if lab_x_translation_correction is not None:
builder.set_LAB_x_translation_correction(lab_x_translation_correction)
if lab_z_translation_correction is not None:
builder.set_LAB_z_translation_correction(lab_z_translation_correction)
move_info = builder.build()
# Get the sample state
test_director = TestDirector()
test_director.set_states(data_state=data_info, move_state=move_info)
return test_director.construct()
def test_that_reduction_state_can_be_built(self):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
# Act
builder = get_reduction_mode_builder(data_info)
self.assertTrue(builder)
mode = ISISReductionMode.Merged
dim = ReductionDimensionality.OneDim
builder.set_reduction_mode(mode)
builder.set_reduction_dimensionality(dim)
merge_shift = 324.2
merge_scale = 3420.98
fit_mode = FitModeForMerge.Both
builder.set_merge_fit_mode(fit_mode)
builder.set_merge_shift(merge_shift)
builder.set_merge_scale(merge_scale)
merge_mask = True
merge_min = 12.23
merge_max = 45.89
builder.set_merge_mask(merge_mask)
builder.set_merge_min(merge_min)
builder.set_merge_max(merge_max)
state = builder.build()
# Assert
self.assertTrue(state.reduction_mode is mode)
self.assertTrue(state.reduction_dimensionality is dim)
self.assertTrue(state.merge_fit_mode == fit_mode)
self.assertTrue(state.merge_shift == merge_shift)
self.assertTrue(state.merge_scale == merge_scale)
detector_names = state.detector_names
self.assertTrue(detector_names[DetectorType.to_string(
DetectorType.LAB)] == "main-detector-bank")
self.assertTrue(state.merge_mask)
self.assertTrue(state.merge_min == merge_min)
self.assertTrue(state.merge_max == merge_max)
def test_that_beam_stop_masking_is_applied_for_LOQ(self):
# Arrange
file_information_factory = SANSFileInformationFactory()
file_information = file_information_factory.create_sans_file_information(
"LOQ74044")
data_builder = get_data_builder(SANSFacility.ISIS, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_info = data_builder.build()
mask_builder = get_mask_builder(data_info)
beam_stop_arm_width = .01
beam_stop_arm_angle = 180.0
beam_stop_arm_pos1 = 0.0
beam_stop_arm_pos2 = 0.0
# Expected_spectra, again the tubes are shifted and that will produce the slightly strange masking
expected_spectra = []
expected_spectra.extend((7811 + x for x in range(0, 63)))
expected_spectra.extend((7939 + x for x in range(0, 63)))
mask_builder.set_beam_stop_arm_width(beam_stop_arm_width)
mask_builder.set_beam_stop_arm_angle(beam_stop_arm_angle)
mask_builder.set_beam_stop_arm_pos1(beam_stop_arm_pos1)
mask_builder.set_beam_stop_arm_pos2(beam_stop_arm_pos2)
mask_info = mask_builder.build()
move_builder = get_move_builder(data_info)
move_builder.set_center_position(0.)
move_info = move_builder.build()
test_director = TestDirector()
test_director.set_states(data_state=data_info,
mask_state=mask_info,
move_state=move_info)
state = test_director.construct()
workspace = self._load_workspace(state)
# Act
workspace = self._run_mask(state, workspace, "LAB")
# Assert
self._do_assert(workspace, expected_spectra)
def _get_sample_state(width, height, thickness, shape, scale):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_state = data_builder.build()
scale_builder = get_scale_builder(data_state, file_information)
scale_builder.set_scale(scale)
scale_builder.set_thickness(thickness)
scale_builder.set_width(width)
scale_builder.set_height(height)
scale_builder.set_shape(shape)
scale_state = scale_builder.build()
test_director = TestDirector()
test_director.set_states(scale_state=scale_state, data_state=data_state)
return test_director.construct()
def _get_sample_state(width, height, thickness, shape, scale):
# Arrange
facility = SANSFacility.ISIS
data_builder = get_data_builder(facility)
data_builder.set_sample_scatter("LOQ74044")
data_state = data_builder.build()
scale_builder = get_scale_builder(data_state)
scale_builder.set_scale(scale)
scale_builder.set_thickness(thickness)
scale_builder.set_width(width)
scale_builder.set_height(height)
scale_builder.set_shape(shape)
scale_state = scale_builder.build()
test_director = TestDirector()
test_director.set_states(scale_state=scale_state,
data_state=data_state)
return test_director.construct()
def _get_sample_state(q_min=1.,
q_max=2.,
q_step=0.1,
q_step_type=RangeStepType.Lin,
q_xy_max=None,
q_xy_step=None,
q_xy_step_type=None,
use_gravity=False,
dim=ReductionDimensionality.OneDim):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(
instrument=SANSInstrument.LOQ, run_number=74044)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("LOQ74044")
data_state = data_builder.build()
convert_to_q_builder = get_convert_to_q_builder(data_state)
convert_to_q_builder.set_reduction_dimensionality(dim)
convert_to_q_builder.set_use_gravity(use_gravity)
convert_to_q_builder.set_radius_cutoff(0.002)
convert_to_q_builder.set_wavelength_cutoff(2.)
convert_to_q_builder.set_q_min(q_min)
convert_to_q_builder.set_q_max(q_max)
prefix = 1. if q_step_type is RangeStepType.Lin else -1.
q_step *= prefix
rebin_string = str(q_min) + "," + str(q_step) + "," + str(q_max)
convert_to_q_builder.set_q_1d_rebin_string(rebin_string)
if q_xy_max is not None:
convert_to_q_builder.set_q_xy_max(q_xy_max)
if q_xy_step is not None:
convert_to_q_builder.set_q_xy_step(q_xy_step)
if q_xy_step_type is not None:
convert_to_q_builder.set_q_xy_step_type(q_xy_step_type)
convert_to_q_state = convert_to_q_builder.build()
test_director = TestDirector()
test_director.set_states(convert_to_q_state=convert_to_q_state,
data_state=data_state)
return test_director.construct().property_manager
def test_that_divide_uses_settings_from_workspace(self):
# Arrange
facility = SANSFacility.ISIS
file_information = SANSFileInformationMock(
instrument=SANSInstrument.SANS2D,
run_number=22024,
height=8.0,
width=8.0,
thickness=1.0,
shape=SampleShape.CylinderAxisAlong)
data_builder = get_data_builder(facility, file_information)
data_builder.set_sample_scatter("SANS2D00022024")
data_state = data_builder.build()
scale_builder = get_scale_builder(data_state, file_information)
scale_state = scale_builder.build()
test_director = TestDirector()
test_director.set_states(scale_state=scale_state,
data_state=data_state)
state = test_director.construct()
divide_factory = DivideByVolumeFactory()
divider = divide_factory.create_divide_by_volume(state)
# Apply the settings from the SANS2D00022024 workspace
width = 8.
height = 8.
thickness = 1.
shape = 3
workspace = ScaleHelperTest._get_workspace(width, height, thickness,
shape)
# Act
output_workspace = divider.divide_by_volume(workspace, scale_state)
# Assert
expected_volume = thickness * math.pi * math.pow(width, 2) / 4.0
expected_value = 0.3 / expected_volume
data_y = output_workspace.dataY(0)
self.assertEqual(data_y[0], expected_value)
def test_that_produces_correct_workspace_multiperiod_LARMOR(self):
# Arrange
# Build the data information
data_builder = get_data_builder(SANSFacility.ISIS)
data_builder.set_sample_scatter("LARMOR00013065")
data_builder.set_calibration("80tubeCalibration_1-05-2015_r3157-3160.nxs")
data_state = data_builder.build()
# Get the rest of the state from the user file
user_file_director = StateDirectorISIS(data_state)
user_file_director.set_user_file("USER_LARMOR_151B_LarmorTeam_80tubes_BenchRot1p4_M4_r3699.txt")
# Construct the final state
state = user_file_director.construct()
# Act
output_workspaces = run_integral('', True, IntegralEnum.Horizontal, DetectorType.LAB, state)
# Evaluate it up to a defined point
reference_file_name = "LARMOR_ws_diagnostic_reference.nxs"
self._compare_workspace(output_workspaces[0], reference_file_name)