def provide_workspace_with_proton_charge(is_event=True):
sample_name = "CreateSampleWorkspace"
sample_options = {"OutputWorkspace": "dummy",
"NumBanks": 1,
"BankPixelWidth": 2}
if is_event:
sample_options.update({"WorkspaceType": "Event"})
else:
sample_options.update({"WorkspaceType": "Histogram"})
sample_alg = create_unmanaged_algorithm(sample_name, **sample_options)
sample_alg.execute()
workspace = sample_alg.getProperty("OutputWorkspace").value
# Provide a proton charge
log_name = "AddTimeSeriesLog"
log_options = {"Workspace": workspace,
"Name": "proton_charge",
"Type": "double"}
log_alg = create_unmanaged_algorithm(log_name, **log_options)
time = DateAndTime("2010-01-01T00:10:00")
for index in range(0, 10):
time += 1000000000
value = 1.0
log_alg.setProperty("Time", str(time))
log_alg.setProperty("Value", value)
log_alg.execute()
return workspace
def _get_sample_workspace(with_zero_errors, convert_to_numeric_axis=False):
create_name = "CreateSimulationWorkspace"
create_options = {"Instrument": "LARMOR",
"BinParams": '1,10,1000',
"UnitX": 'MomentumTransfer',
"OutputWorkspace": EMPTY_NAME}
create_alg = create_unmanaged_algorithm(create_name, **create_options)
create_alg.execute()
workspace = create_alg.getProperty("OutputWorkspace").value
crop_name = "CropWorkspace"
crop_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"EndWorkspaceIndex": 0}
crop_alg = create_unmanaged_algorithm(crop_name, **crop_options)
crop_alg.execute()
workspace = crop_alg.getProperty("OutputWorkspace").value
if convert_to_numeric_axis:
convert_name = "ConvertSpectrumAxis"
convert_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"Target": 'ElasticQ',
"EFixed": 1}
convert_alg = create_unmanaged_algorithm(convert_name, **convert_options)
convert_alg.execute()
workspace = convert_alg.getProperty("OutputWorkspace").value
if with_zero_errors:
errors = workspace.dataE(0)
errors[0] = 0.0
errors[14] = 0.0
errors[45] = 0.0
return workspace
def _compare_workspace(self, workspace, reference_file_name, check_spectra_map=True):
# Load the reference file
load_name = "LoadNexusProcessed"
load_options = {"Filename": reference_file_name,
"OutputWorkspace": EMPTY_NAME}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
load_alg.execute()
reference_workspace = load_alg.getProperty("OutputWorkspace").value
# Compare reference file with the output_workspace
# We need to disable the instrument comparison, it takes way too long
# We need to disable the sample -- Not clear why yet
# operation how many entries can be found in the sample logs
compare_name = "CompareWorkspaces"
compare_options = {"Workspace1": workspace,
"Workspace2": reference_workspace,
"Tolerance": 1e-6,
"CheckInstrument": False,
"CheckSample": False,
"ToleranceRelErr": True,
"CheckAllData": True,
"CheckMasking": True,
"CheckType": True,
"CheckAxes": True,
"CheckSpectraMap": check_spectra_map}
compare_alg = create_unmanaged_algorithm(compare_name, **compare_options)
compare_alg.setChild(False)
compare_alg.execute()
result = compare_alg.getProperty("Result").value
self.assertTrue(result)
def mask_with_mask_files(mask_info, workspace):
"""
Apply mask files to the workspace
Rolling our own MaskDetectors wrapper since masking is broken in a couple
of places that affect us here.
Calling MaskDetectors(Workspace=ws_name, MaskedWorkspace=mask_ws_name) is
not something we can do because the algorithm masks by ws index rather than
detector id, and unfortunately for SANS the detector table is not the same
for MaskingWorkspaces as it is for the workspaces containing the data to be
masked. Basically, we get a mirror image of what we expect. Instead, we
have to extract the det IDs and use those via the DetectorList property.
:param mask_info: a SANSStateMask object.
:param workspace: the workspace to be masked.
:return: the masked workspace.
"""
mask_files = mask_info.mask_files
if mask_files:
idf_path = mask_info.idf_path
# Mask loader
load_name = "LoadMask"
load_options = {"Instrument": idf_path,
"OutputWorkspace": EMPTY_NAME}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
dummy_params = {"OutputWorkspace": EMPTY_NAME}
mask_alg = create_unmanaged_algorithm("MaskInstrument", **dummy_params)
clear_alg = create_unmanaged_algorithm("ClearMaskedSpectra", **dummy_params)
# Masker
for mask_file in mask_files:
mask_file = find_full_file_path(mask_file)
# Get the detector ids which need to be masked
load_alg.setProperty("InputFile", mask_file)
load_alg.execute()
masking_workspace = load_alg.getProperty("OutputWorkspace").value
# Could use MaskDetectors directly with masking_workspace but it does not
# support MPI. Use a three step approach via a, b, and c instead.
# a) Extract detectors to mask from MaskWorkspace
det_ids = masking_workspace.getMaskedDetectors()
# b) Mask the detector ids on the instrument
mask_alg.setProperty("InputWorkspace", workspace)
mask_alg.setProperty("OutputWorkspace", workspace)
mask_alg.setProperty("DetectorIDs", det_ids)
mask_alg.execute()
workspace = mask_alg.getProperty("OutputWorkspace").value
# c) Clear data in all spectra associated with masked detectors
clear_alg.setProperty("InputWorkspace", workspace)
clear_alg.setProperty("OutputWorkspace", workspace)
clear_alg.execute()
workspace = clear_alg.getProperty("OutputWorkspace").value
return workspace
def _get_wavelength_adjustment_workspace(self, wavelength_adjustment_file, transmission_workspace,
monitor_normalization_workspace, rebin_string):
"""
This creates a workspace with wavelength adjustments, ie this will be a correction for the bins, but it will
be the same for all pixels. This is essentially the product of several workspaces.
The participating workspaces are:
1. A workspace loaded from a calibration file
2.. The workspace resulting from the monitor normalization
3. The workspace resulting from the transmission calculation (using SANSCalculateTransmission) if applicable
:param wavelength_adjustment_file: the file path to the wavelength adjustment file
:param transmission_workspace: the calculated transmission workspace (which can be None)
:param monitor_normalization_workspace: the monitor normalization workspace
:param rebin_string: the parameters for rebinning
:return: a general wavelength adjustment workspace
"""
# 1. Get the wavelength correction workspace from the file
wavelength_adjustment_workspaces = []
if wavelength_adjustment_file:
wavelength_correction_workspace_from_file = \
self._load_wavelength_correction_file(wavelength_adjustment_file)
wavelength_adjustment_workspaces.append(wavelength_correction_workspace_from_file)
# 2. Normalization
wavelength_adjustment_workspaces.append(monitor_normalization_workspace)
# 3. Transmission Calculation
if transmission_workspace:
wavelength_adjustment_workspaces.append(transmission_workspace)
# Multiply all workspaces
wavelength_adjustment_workspace = None
for workspace in wavelength_adjustment_workspaces:
# First we need to change the binning such that is matches the binning of the main data workspace
rebin_name = "Rebin"
rebin_options = {"InputWorkspace": workspace,
"Params": rebin_string,
"OutputWorkspace": EMPTY_NAME}
rebin_alg = create_unmanaged_algorithm(rebin_name, **rebin_options)
rebin_alg.execute()
rebinned_workspace = rebin_alg.getProperty("OutputWorkspace").value
if wavelength_adjustment_workspace is None:
wavelength_adjustment_workspace = rebinned_workspace
else:
multiply_name = "Multiply"
multiply_options = {"LHSWorkspace": rebinned_workspace,
"RHSWorkspace": wavelength_adjustment_workspace,
"OutputWorkspace": EMPTY_NAME}
multiply_alg = create_unmanaged_algorithm(multiply_name, **multiply_options)
multiply_alg.execute()
wavelength_adjustment_workspace = multiply_alg.getProperty("OutputWorkspace").value
return wavelength_adjustment_workspace
def _compare_workspace(self, workspace, reference_file_name):
# Load the reference file
load_name = "LoadNexusProcessed"
load_options = {"Filename": reference_file_name,
"OutputWorkspace": EMPTY_NAME}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
load_alg.execute()
reference_workspace = load_alg.getProperty("OutputWorkspace").value
# Save the workspace out and reload it again. This equalizes it with the reference workspace
f_name = os.path.join(mantid.config.getString('defaultsave.directory'),
'SANS_temp_single_core_reduction_testout.nxs')
save_name = "SaveNexus"
save_options = {"Filename": f_name,
"InputWorkspace": workspace}
save_alg = create_unmanaged_algorithm(save_name, **save_options)
save_alg.execute()
load_alg.setProperty("Filename", f_name)
load_alg.setProperty("OutputWorkspace", EMPTY_NAME)
load_alg.execute()
ws = load_alg.getProperty("OutputWorkspace").value
# Compare reference file with the output_workspace
# We need to disable the instrument comparison, it takes way too long
# We need to disable the sample -- since the sample has been modified (more logs are being written)
# operation how many entries can be found in the sample logs
compare_name = "CompareWorkspaces"
compare_options = {"Workspace1": ws,
"Workspace2": reference_workspace,
"Tolerance": 1e-6,
"CheckInstrument": False,
"CheckSample": False,
"ToleranceRelErr": True,
"CheckAllData": True,
"CheckMasking": True,
"CheckType": True,
"CheckAxes": True,
"CheckSpectraMap": True}
compare_alg = create_unmanaged_algorithm(compare_name, **compare_options)
compare_alg.setChild(False)
compare_alg.execute()
result = compare_alg.getProperty("Result").value
message = compare_alg.getProperty("Messages").value
self.assertTrue(result, message)
# Remove file
if os.path.exists(f_name):
os.remove(f_name)
def _apply_user_mask_ranges(self, cF, cR, nR, nF, merge_min, merge_max):
merge_max = self._check_bins(merge_min, merge_max, cF, cR)
mask_name = "MaskBins"
mask_options = {"InputWorkspace": cF}
mask_alg = create_unmanaged_algorithm(mask_name, **mask_options)
mask_alg.setProperty("InputWorkspace", cF)
mask_alg.setProperty("OutputWorkspace", EMPTY_NAME)
mask_alg.setProperty("XMin", min(cF.dataX(0)))
mask_alg.setProperty("XMax", merge_min)
mask_alg.execute()
cF = mask_alg.getProperty("OutputWorkspace").value
mask_alg.setProperty("InputWorkspace", nF)
mask_alg.setProperty("OutputWorkspace", EMPTY_NAME)
mask_alg.setProperty("XMin", min(nF.dataX(0)))
mask_alg.setProperty("XMax", merge_min)
mask_alg.execute()
nF = mask_alg.getProperty("OutputWorkspace").value
mask_alg.setProperty("InputWorkspace", cR)
mask_alg.setProperty("OutputWorkspace", EMPTY_NAME)
mask_alg.setProperty("XMin", merge_max)
mask_alg.setProperty("XMax", max(cR.dataX(0)))
mask_alg.execute()
cR = mask_alg.getProperty("OutputWorkspace").value
mask_alg.setProperty("InputWorkspace", nR)
mask_alg.setProperty("OutputWorkspace", EMPTY_NAME)
mask_alg.setProperty("XMin", merge_max)
mask_alg.setProperty("XMax", max(nR.dataX(0)))
mask_alg.execute()
nR = mask_alg.getProperty("OutputWorkspace").value
return cR, cF, nR, nF
def mask_cylinder(mask_info, workspace):
"""
Masks a (hollow) cylinder around (0,0)
Two radii can be specified for the cylinder mask. An inner radius (radius_min) and an outer radius(radius_max)
which specify a hollow cylinder mask.
:param mask_info: a SANSStateMask object.
:param workspace: the workspace which is about to be masked
:return: the masked workspace.
"""
radius_min = mask_info.radius_min
radius_max = mask_info.radius_max
xml = []
# Set up the inner radius of the cylinder
if radius_min is not None and radius_min > 0.0:
add_cylinder(xml, radius_min, 0, 0, 'beam_stop')
# Set up the outer radius of the cylinder
if radius_max is not None and radius_max > 0.0:
add_outside_cylinder(xml, radius_max, 0, 0, 'beam_area')
# Mask the cylinder shape if there is anything to mask, else don't do anything
if xml:
mask_name = "MaskDetectorsInShape"
mask_options = {"Workspace": workspace}
mask_alg = create_unmanaged_algorithm(mask_name, **mask_options)
for shape in xml:
mask_alg.setProperty("Workspace", workspace)
mask_alg.setProperty("ShapeXML", shape)
mask_alg.execute()
workspace = mask_alg.getProperty("Workspace").value
return workspace
def _perform_prompt_peak_correction(self, workspace, prompt_peak_correction_min, prompt_peak_correction_max,
prompt_peak_correction_enabled):
"""
Prompt peak correction is performed if it is explicitly set by the user.
:param workspace: the workspace to correct.
:param prompt_peak_correction_min: the start time for the prompt peak correction.
:param prompt_peak_correction_max: the stop time for the prompt peak correction.
:prompt_peak_correction_enabled: flag if prompt peak correction should be enabled
:return: a corrected workspace.
"""
# We perform only a prompt peak correction if the start and stop values of the bins we want to remove,
# were explicitly set. Some instruments require it, others don't.
if prompt_peak_correction_enabled and prompt_peak_correction_min is not None and \
prompt_peak_correction_max is not None: # noqa
remove_name = "RemoveBins"
remove_options = {"InputWorkspace": workspace,
"XMin": prompt_peak_correction_min,
"XMax": prompt_peak_correction_max,
"Interpolation": "Linear"}
remove_alg = create_unmanaged_algorithm(remove_name, **remove_options)
remove_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
remove_alg.setProperty("OutputWorkspace", workspace)
remove_alg.execute()
workspace = remove_alg.getProperty("OutputWorkspace").value
return workspace
def mask_beam_stop(mask_info, workspace, instrument, detector_names):
"""
The beam stop is being masked here.
:param mask_info: a SANSStateMask object.
:param workspace: the workspace which is to be masked.
:param instrument: the instrument associated with the current workspace.
:return: a masked workspace
"""
beam_stop_arm_width = mask_info.beam_stop_arm_width
beam_stop_arm_angle = mask_info.beam_stop_arm_angle
beam_stop_arm_pos1 = mask_info.beam_stop_arm_pos1
beam_stop_arm_pos2 = mask_info.beam_stop_arm_pos2
if beam_stop_arm_width is not None and beam_stop_arm_angle is not None:
detector = workspace.getInstrument().getComponentByName(detector_names['LAB'])
z_position = detector.getPos().getZ()
start_point = [beam_stop_arm_pos1, beam_stop_arm_pos2, z_position]
line_mask = create_line_mask(start_point, 100., beam_stop_arm_width, beam_stop_arm_angle)
mask_name = "MaskDetectorsInShape"
mask_options = {"Workspace": workspace,
"ShapeXML": line_mask}
mask_alg = create_unmanaged_algorithm(mask_name, **mask_options)
mask_alg.execute()
workspace = mask_alg.getProperty("Workspace").value
return workspace
def test_that_workspace_can_be_saved_without_zero_error_free_option(self):
# Arrange
workspace = SANSSaveTest._get_sample_workspace(with_zero_errors=False, convert_to_numeric_axis=True)
file_name = os.path.join(mantid.config.getString('defaultsave.directory'), 'sample_sans_save_file')
use_zero_errors_free = False
save_name = "SANSSave"
save_options = {"InputWorkspace": workspace,
"Filename": file_name,
"UseZeroErrorFree": use_zero_errors_free,
"Nexus": True,
"CanSAS": True,
"NXCanSAS": True,
"NistQxy": True,
"RKH": True,
"CSV": True}
save_alg = create_unmanaged_algorithm(save_name, **save_options)
# Act
save_alg.execute()
self.assertTrue(save_alg.isExecuted())
# Assert
expected_files = ["sample_sans_save_file.xml", "sample_sans_save_file.txt", "sample_sans_save_file_nistqxy.dat",
"sample_sans_save_file.h5", "sample_sans_save_file.nxs",
"sample_sans_save_file.csv"]
expected_full_file_names = [os.path.join(mantid.config.getString('defaultsave.directory'), elem)
for elem in expected_files]
for file_name in expected_full_file_names:
self._assert_that_file_exists(file_name)
# Clean up
for file_name in expected_full_file_names:
self._remove_file(file_name)
def _load_workspace(file_name):
load_name = "Load"
load_options = {"OutputWorkspace": EMPTY_NAME,
"Filename": file_name}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
load_alg.execute()
return load_alg.getProperty("OutputWorkspace").value
def rotate_component(workspace, angle, direction, component_to_rotate):
"""
Rotate a component on a workspace.
:param workspace: the workspace which contains the component which is to be rotated.
:param angle: the angle by which it is to be rotated in degrees.
:param direction: the rotation direction. This is a unit vector encoded as a Coordinate vs Value map.
:param component_to_rotate: name of the component which is to be rotated
:return:
"""
rotate_name = "RotateInstrumentComponent"
rotate_options = {"Workspace": workspace,
"ComponentName": component_to_rotate,
"RelativeRotation": "1"}
for key, value in list(direction.items()):
if key is CanonicalCoordinates.X:
rotate_options.update({"X": value})
elif key is CanonicalCoordinates.Y:
rotate_options.update({"Y": value})
elif key is CanonicalCoordinates.Z:
rotate_options.update({"Z": value})
else:
raise RuntimeError("SANSMove: Trying to rotate the components along an unknown direction. "
"See here: {0}".format(str(component_to_rotate)))
rotate_options.update({"Angle": angle})
alg = create_unmanaged_algorithm(rotate_name, **rotate_options)
alg.execute()
def _get_calculated_transmission_workspace(self, state):
"""
Creates the fitted transmission workspace.
Note that this step is not mandatory. If no transmission and direct workspaces are provided, then we
don't have to do anything here.
:param state: a SANSState object.
:return: a fitted transmission workspace and the unfitted data.
"""
transmission_workspace = self.getProperty("TransmissionWorkspace").value
direct_workspace = self.getProperty("DirectWorkspace").value
if transmission_workspace and direct_workspace:
data_type = self.getProperty("DataType").value
transmission_name = "SANSCalculateTransmission"
serialized_state = state.property_manager
transmission_options = {"TransmissionWorkspace": transmission_workspace,
"DirectWorkspace": direct_workspace,
"SANSState": serialized_state,
"DataType": data_type,
"OutputWorkspace": EMPTY_NAME,
"UnfittedData": EMPTY_NAME}
transmission_alg = create_unmanaged_algorithm(transmission_name, **transmission_options)
transmission_alg.execute()
fitted_data = transmission_alg.getProperty("OutputWorkspace").value
unfitted_data = transmission_alg.getProperty("UnfittedData").value
else:
fitted_data = None
unfitted_data = None
return fitted_data, unfitted_data
def move_component(workspace, offsets, component_to_move, is_relative=True):
"""
Move an individual component on a workspace
:param workspace: the workspace which the component which is to be moved.
:param offsets: a Coordinate vs. Value map of offsets.
:param component_to_move: the name of a component on the instrument. This component must be name which exist.
on the instrument.
:param is_relative: if the move is relative of not.
:return:
"""
move_name = "MoveInstrumentComponent"
move_options = {"Workspace": workspace,
"ComponentName": component_to_move,
"RelativePosition": is_relative}
for key, value in list(offsets.items()):
if key is CanonicalCoordinates.X:
move_options.update({"X": value})
elif key is CanonicalCoordinates.Y:
move_options.update({"Y": value})
elif key is CanonicalCoordinates.Z:
move_options.update({"Z": value})
else:
raise RuntimeError("SANSMove: Trying to move the components along an unknown direction. "
"See here: {0}".format(str(component_to_move)))
alg = create_unmanaged_algorithm(move_name, **move_options)
alg.execute()
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 _run_test(state, sample_data, sample_monitor_data, transmission_data, direct_data, is_lab=True, is_sample=True):
adjustment_name = "SANSCreateAdjustmentWorkspaces"
adjustment_options = {"SANSState": state,
"SampleData": sample_data,
"MonitorWorkspace": sample_monitor_data,
"TransmissionWorkspace": transmission_data,
"DirectWorkspace": direct_data,
"OutputWorkspaceWavelengthAdjustment": EMPTY_NAME,
"OutputWorkspacePixelAdjustment": EMPTY_NAME,
"OutputWorkspaceWavelengthAndPixelAdjustment": EMPTY_NAME}
if is_sample:
adjustment_options.update({"DataType": DataType.to_string(DataType.Sample)})
else:
adjustment_options.update({"DataType": DataType.to_string(DataType.Can)})
if is_lab:
adjustment_options.update({"Component": DetectorType.to_string(DetectorType.LAB)})
else:
adjustment_options.update({"Component": DetectorType.to_string(DetectorType.HAB)})
adjustment_alg = create_unmanaged_algorithm(adjustment_name, **adjustment_options)
adjustment_alg.execute()
wavelength_adjustment = adjustment_alg.getProperty("OutputWorkspaceWavelengthAdjustment").value
pixel_adjustment = adjustment_alg.getProperty("OutputWorkspacePixelAdjustment").value
wavelength_and_pixel_adjustment = adjustment_alg.getProperty(
"OutputWorkspaceWavelengthAndPixelAdjustment").value
calculated_transmission = adjustment_alg.getProperty("CalculatedTransmissionWorkspace").value
unfitted_transmission = adjustment_alg.getProperty("UnfittedTransmissionWorkspace").value
return wavelength_adjustment, pixel_adjustment, wavelength_and_pixel_adjustment,\
calculated_transmission, unfitted_transmission
def _clone_workspace(workspace):
clone_name = "CloneWorkspace"
clone_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME}
clone_alg = create_unmanaged_algorithm(clone_name, **clone_options)
clone_alg.execute()
return clone_alg.getProperty("OutputWorkspace").value
def do_scale(workspace, scale_factor):
single_valued_name = "CreateSingleValuedWorkspace"
single_valued_options = {"OutputWorkspace": EMPTY_NAME,
"DataValue": scale_factor}
single_valued_alg = create_unmanaged_algorithm(single_valued_name, **single_valued_options)
single_valued_alg.execute()
single_valued_workspace = single_valued_alg.getProperty("OutputWorkspace").value
multiply_name = "Multiply"
multiply_options = {"LHSWorkspace": workspace,
"RHSWorkspace": single_valued_workspace}
multiply_alg = create_unmanaged_algorithm(multiply_name, **multiply_options)
multiply_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
multiply_alg.setProperty("OutputWorkspace", workspace)
multiply_alg.execute()
return multiply_alg.getProperty("OutputWorkspace").value
def mask_angle(mask_info, workspace):
"""
Creates a pizza slice mask on the detector around (0,0)
:param mask_info: a SANSStateMask object
:param workspace: the workspace which is to be masked.
:return: a masked workspace
"""
phi_mirror = mask_info.use_mask_phi_mirror
phi_min = mask_info.phi_min
phi_max = mask_info.phi_max
if phi_min is not None and phi_max is not None and phi_mirror is not None:
# Check for edge cases for the mirror
if phi_mirror:
if phi_min > phi_max:
phi_min, phi_max = phi_max, phi_min
if phi_max - phi_min == 180.0:
phi_min = -90.0
phi_max = 90.0
# Create the phi mask and apply it if anything was created
phi_mask = create_phi_mask('unique phi', [0, 0, 0], phi_min, phi_max, phi_mirror)
if phi_mask:
mask_name = "MaskDetectorsInShape"
mask_options = {"Workspace": workspace,
"ShapeXML": phi_mask}
mask_alg = create_unmanaged_algorithm(mask_name, **mask_options)
mask_alg.execute()
workspace = mask_alg.getProperty("Workspace").value
return workspace
def _perform_rebin(self, rebin_type, rebin_options, workspace):
rebin_name = "Rebin" if rebin_type is RebinType.Rebin else "InterpolatingRebin"
rebin_alg = create_unmanaged_algorithm(rebin_name, **rebin_options)
rebin_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
rebin_alg.setProperty("OutputWorkspace", workspace)
rebin_alg.execute()
return rebin_alg.getProperty("OutputWorkspace").value
def test_that_scales_the_workspace_correctly(self):
# Arrange
workspace = self._get_workspace()
width = 1.0
height = 2.0
scale = 7.2
state = self._get_sample_state(width=width, height=height, thickness=3.0, scale=scale,
shape=SampleShape.CylinderAxisUp)
serialized_state = state.property_manager
scale_name = "SANSScale"
scale_options = {"SANSState": serialized_state,
"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME}
scale_alg = create_unmanaged_algorithm(scale_name, **scale_options)
# Act
scale_alg.execute()
output_workspace = scale_alg.getProperty("OutputWorkspace").value
# Assert
# We have a LOQ data set, hence we need to divide by pi
expected_value = 0.3/(height * math.pi * math.pow(width, 2) / 4.0) * (scale / math.pi) * 100.
data_y = output_workspace.dataY(0)
tolerance = 1e-7
self.assertTrue(abs(data_y[0] - expected_value) < tolerance)
def _perform_prompt_peak_correction(self, workspace, normalize_to_monitor_state):
"""
Performs a prompt peak correction.
A prompt peak can occur when very fast neutrons shoot through the measurement. This can happen when working
with two time regimes. Prompt peaks are prominent peaks which stand out from usual data. They occur frequently
on LOQ, but are now also a possibility on other instruments. We deal with them, by removing the data and
interpolating between the edge data points. If the user does not specify a start and stop time for the
prompt peak, then this correction is not performed.
:param workspace: the workspace which is to be corrected.
:param normalize_to_monitor_state: a SANSStateNormalizeToMonitor object.
:return: the corrected workspace.
"""
prompt_peak_correction_start = normalize_to_monitor_state.prompt_peak_correction_min
prompt_peak_correction_stop = normalize_to_monitor_state.prompt_peak_correction_max
prompt_peak_correction_enabled = normalize_to_monitor_state.prompt_peak_correction_enabled
# We perform only a prompt peak correction if the start and stop values of the bins we want to remove,
# were explicitly set. Some instruments require it, others don't.
if prompt_peak_correction_enabled and prompt_peak_correction_start is not None and prompt_peak_correction_stop is not None:
remove_name = "RemoveBins"
remove_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"XMin": prompt_peak_correction_start,
"XMax": prompt_peak_correction_stop,
"Interpolation": "Linear"}
remove_alg = create_unmanaged_algorithm(remove_name, **remove_options)
remove_alg.execute()
workspace = remove_alg.getProperty("OutputWorkspace").value
return workspace
def perform_move(state, workspace):
serialized_state = state.property_manager
move_name = "SANSMove"
move_options = {"SANSState": serialized_state,
"Workspace": workspace,
"MoveType": "InitialMove"}
move_alg = create_unmanaged_algorithm(move_name, **move_options)
move_alg.execute()
def _save_output(self, workspace, mismatch_name):
# Save the workspace out
f_name = path.join(config.getString('defaultsave.directory'),
mismatch_name)
save_name = "SaveNexus"
save_options = {"Filename": f_name, "InputWorkspace": workspace}
save_alg = create_unmanaged_algorithm(save_name, **save_options)
save_alg.execute()
def perform_move(state, workspace):
serialized_state = state.property_manager
move_name = "SANSMove"
move_options = {"SANSState": serialized_state,
"Workspace": workspace,
"MoveType": "InitialMove"}
move_alg = create_unmanaged_algorithm(move_name, **move_options)
move_alg.execute()
def perform_move(state, workspace):
serialized_state = state.property_manager
move_name = "SANSMove"
zero_options = {"SANSState": serialized_state,
"Workspace": workspace,
"MoveType": "SetToZero",
"Component": ""}
zero_alg = create_unmanaged_algorithm(move_name, **zero_options)
zero_alg.execute()
workspace = zero_alg.getProperty("Workspace").value
move_options = {"SANSState": serialized_state,
"Workspace": workspace,
"MoveType": "InitialMove"}
move_alg = create_unmanaged_algorithm(move_name, **move_options)
move_alg.execute()
def _get_workspace(self, file_name):
full_file_name = FileFinder.findRuns(file_name)[0]
load_name = "Load"
load_options = {"Filename": full_file_name,
"OutputWorkspace": EMPTY_NAME}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
load_alg.execute()
return load_alg.getProperty("OutputWorkspace").value
def _run_test(workspace, state):
normalize_name = "SANSNormalizeToMonitor"
normalize_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"SANSState": state}
normalize_alg = create_unmanaged_algorithm(normalize_name, **normalize_options)
normalize_alg.execute()
return normalize_alg.getProperty("OutputWorkspace").value
def _run_q_2d(self, state):
"""
This method performs a 2D data reduction on our workspace.
Note that it does not perform any q resolution calculation, nor any wavelength-and-pixel adjustment. The
output workspace contains two numerical axes.
:param state: a SANSState object
:return: the reduced workspace, the sum of counts workspace, the sum of norms workspace or
the reduced workspace, None, None
"""
data_workspace = self.getProperty("InputWorkspace").value
wavelength_adjustment_workspace = self.getProperty(
"InputWorkspaceWavelengthAdjustment").value
pixel_adjustment_workspace = self.getProperty(
"InputWorkspacePixelAdjustment").value
output_parts = self.getProperty("OutputParts").value
# Extract relevant settings
convert_to_q = state.convert_to_q
max_q_xy = convert_to_q.q_xy_max
log_binning = True if convert_to_q.q_xy_step_type is RangeStepType.Log else False
delta_q = convert_to_q.q_xy_step
radius_cutoff = convert_to_q.radius_cutoff / 1000. # Qxy expects the radius cutoff to be in mm
wavelength_cutoff = convert_to_q.wavelength_cutoff
use_gravity = convert_to_q.use_gravity
gravity_extra_length = convert_to_q.gravity_extra_length
qxy_name = "Qxy"
qxy_options = {
"InputWorkspace": data_workspace,
"OutputWorkspace": EMPTY_NAME,
"MaxQxy": max_q_xy,
"DeltaQ": delta_q,
"IQxQyLogBinning": log_binning,
"AccountForGravity": use_gravity,
"RadiusCut": radius_cutoff,
"WaveCut": wavelength_cutoff,
"OutputParts": output_parts,
"ExtraLength": gravity_extra_length
}
if wavelength_adjustment_workspace:
qxy_options.update(
{"WavelengthAdj": wavelength_adjustment_workspace})
if pixel_adjustment_workspace:
qxy_options.update({"PixelAdj": pixel_adjustment_workspace})
qxy_alg = create_unmanaged_algorithm(qxy_name, **qxy_options)
qxy_alg.execute()
reduced_workspace = qxy_alg.getProperty("OutputWorkspace").value
reduced_workspace = self._replace_special_values(reduced_workspace)
# Get the partial workspaces
sum_of_counts_workspace, sum_of_norms_workspace = self._get_partial_output(
output_parts, qxy_alg, do_clean=True)
return reduced_workspace, sum_of_counts_workspace, sum_of_norms_workspace
def _run_single_reduction(self,
state,
sample_scatter,
sample_monitor,
sample_transmission=None,
sample_direct=None,
can_scatter=None,
can_monitor=None,
can_transmission=None,
can_direct=None,
output_settings=None,
event_slice_optimisation=False,
save_can=False,
use_optimizations=False):
single_reduction_name = "SANSSingleReduction"
ver = 1 if not event_slice_optimisation else 2
state_dict = Serializer.to_json(state)
single_reduction_options = {
"SANSState": state_dict,
"SampleScatterWorkspace": sample_scatter,
"SampleScatterMonitorWorkspace": sample_monitor,
"UseOptimizations": use_optimizations,
"SaveCan": save_can
}
if sample_transmission:
single_reduction_options.update(
{"SampleTransmissionWorkspace": sample_transmission})
if sample_direct:
single_reduction_options.update(
{"SampleDirectWorkspace": sample_direct})
if can_scatter:
single_reduction_options.update(
{"CanScatterWorkspace": can_scatter})
if can_monitor:
single_reduction_options.update(
{"CanScatterMonitorWorkspace": can_monitor})
if can_transmission:
single_reduction_options.update(
{"CanTransmissionWorkspace": can_transmission})
if can_direct:
single_reduction_options.update({"CanDirectWorkspace": can_direct})
if output_settings:
single_reduction_options.update(output_settings)
single_reduction_alg = create_unmanaged_algorithm(
single_reduction_name, version=ver, **single_reduction_options)
# Act
single_reduction_alg.execute()
self.assertTrue(single_reduction_alg.isExecuted())
return single_reduction_alg
def _clone_workspace(workspace):
clone_name = "CloneWorkspace"
clone_options = {
"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME
}
clone_alg = create_unmanaged_algorithm(clone_name, **clone_options)
clone_alg.execute()
return clone_alg.getProperty("OutputWorkspace").value
def _convert_units_to_wavelength(self, workspace):
convert_name = "ConvertUnits"
convert_options = {"InputWorkspace": workspace,
"Target": "Wavelength"}
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 _replace_special_values(self, workspace):
replace_name = "ReplaceSpecialValues"
replace_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"NaNValue": 0.,
"InfinityValue": 0.}
replace_alg = create_unmanaged_algorithm(replace_name, **replace_options)
replace_alg.execute()
return replace_alg.getProperty("OutputWorkspace").value
def _run_q_1d(self, state):
data_workspace = self.getProperty("InputWorkspace").value
wavelength_adjustment_workspace = self.getProperty(
"InputWorkspaceWavelengthAdjustment").value
pixel_adjustment_workspace = self.getProperty(
"InputWorkspacePixelAdjustment").value
wavelength_and_pixel_adjustment_workspace = self.getProperty(
"InputWorkspaceWavelengthAndPixelAdjustment").value
# Get QResolution
convert_to_q = state.convert_to_q
q_resolution_factory = QResolutionCalculatorFactory()
q_resolution_calculator = q_resolution_factory.create_q_resolution_calculator(
state)
q_resolution_workspace = q_resolution_calculator.get_q_resolution_workspace(
convert_to_q, data_workspace)
output_parts = self.getProperty("OutputParts").value
# Extract relevant settings
q_binning = convert_to_q.q_1d_rebin_string
use_gravity = convert_to_q.use_gravity
gravity_extra_length = convert_to_q.gravity_extra_length
radius_cutoff = convert_to_q.radius_cutoff * 1000. # Q1D2 expects the radius cutoff to be in mm
wavelength_cutoff = convert_to_q.wavelength_cutoff
q1d_name = "Q1D"
q1d_options = {
"DetBankWorkspace": data_workspace,
"OutputWorkspace": EMPTY_NAME,
"OutputBinning": q_binning,
"AccountForGravity": use_gravity,
"RadiusCut": radius_cutoff,
"WaveCut": wavelength_cutoff,
"OutputParts": output_parts,
"ExtraLength": gravity_extra_length
}
if wavelength_adjustment_workspace:
q1d_options.update(
{"WavelengthAdj": wavelength_adjustment_workspace})
if pixel_adjustment_workspace:
q1d_options.update({"PixelAdj": pixel_adjustment_workspace})
if wavelength_and_pixel_adjustment_workspace:
q1d_options.update(
{"WavePixelAdj": wavelength_and_pixel_adjustment_workspace})
if q_resolution_workspace:
q1d_options.update({"QResolution": q_resolution_workspace})
q1d_alg = create_unmanaged_algorithm(q1d_name, **q1d_options)
q1d_alg.execute()
reduced_workspace = q1d_alg.getProperty("OutputWorkspace").value
# Get the partial workspaces
sum_of_counts_workspace, sum_of_norms_workspace = self._get_partial_output(
output_parts, q1d_alg, do_clean=False)
return reduced_workspace, sum_of_counts_workspace, sum_of_norms_workspace
def _convert_units_to_wavelength(self, workspace):
convert_name = "ConvertUnits"
convert_options = {"InputWorkspace": workspace, "Target": "Wavelength"}
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 divide_by_volume(self, workspace, scale_info):
volume = self._get_volume(scale_info)
single_valued_name = "CreateSingleValuedWorkspace"
single_valued_options = {"OutputWorkspace": EMPTY_NAME,
"DataValue": volume}
single_valued_alg = create_unmanaged_algorithm(single_valued_name, **single_valued_options)
single_valued_alg.execute()
single_valued_workspace = single_valued_alg.getProperty("OutputWorkspace").value
divide_name = "Divide"
divide_options = {"LHSWorkspace": workspace,
"RHSWorkspace": single_valued_workspace}
divide_alg = create_unmanaged_algorithm(divide_name, **divide_options)
divide_alg.setPropertyValue("OutputWorkspace", EMPTY_NAME)
divide_alg.setProperty("OutputWorkspace", workspace)
divide_alg.execute()
return divide_alg.getProperty("OutputWorkspace").value
def _replace_special_values(self, workspace):
replace_name = "ReplaceSpecialValues"
replace_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"NaNValue": 0.,
"InfinityValue": 0.}
replace_alg = create_unmanaged_algorithm(replace_name, **replace_options)
replace_alg.execute()
return replace_alg.getProperty("OutputWorkspace").value
def mask_with_mask_files(mask_info, workspace):
"""
Apply mask files to the workspace
Rolling our own MaskDetectors wrapper since masking is broken in a couple
of places that affect us here.
Calling MaskDetectors(Workspace=ws_name, MaskedWorkspace=mask_ws_name) is
not something we can do because the algorithm masks by ws index rather than
detector id, and unfortunately for SANS the detector table is not the same
for MaskingWorkspaces as it is for the workspaces containing the data to be
masked. Basically, we get a mirror image of what we expect. Instead, we
have to extract the det IDs and use those via the DetectorList property.
:param mask_info: a SANSStateMask object.
:param workspace: the workspace to be masked.
:return: the masked workspace.
"""
mask_files = mask_info.mask_files
if mask_files:
idf_path = mask_info.idf_path
# Mask loader
load_name = "LoadMask"
load_options = {"Instrument": idf_path, "OutputWorkspace": EMPTY_NAME}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
mask_alg = create_unmanaged_algorithm("MaskDetectors")
# Masker
for mask_file in mask_files:
mask_file = find_full_file_path(mask_file)
# Get the detector ids which need to be masked
load_alg.setProperty("InputFile", mask_file)
load_alg.execute()
masking_workspace = load_alg.getProperty("OutputWorkspace").value
# Could use MaskDetectors directly with masking_workspace but it does not
# support MPI. Use a two step approach via a and b instead.
# a) Extract detectors to mask from MaskWorkspace
det_ids = masking_workspace.getMaskedDetectors()
# b) Mask the detector ids on the instrument
mask_alg.setProperty("Workspace", workspace)
mask_alg.setProperty("DetectorList", det_ids)
mask_alg.execute()
workspace = mask_alg.getProperty("Workspace").value
return workspace
def _get_pixel_adjustment_workspace(pixel_adjustment_file, component, idf_path):
"""
This get the pixel-by-pixel adjustment of the workspace
:param pixel_adjustment_file: full file path to the pixel adjustment file
:param component: the component which is currently being investigated
:param idf_path: the idf path
:return: the pixel adjustment workspace
"""
if pixel_adjustment_file:
load_name = "LoadRKH"
load_options = {"Filename": pixel_adjustment_file,
"OutputWorkspace": EMPTY_NAME,
"FirstColumnValue": "SpectrumNumber"}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
load_alg.execute()
output_workspace = load_alg.getProperty("OutputWorkspace").value
if not idf_path:
raise ValueError("No IDF path was found in the provided state")
# Add an instrument to the workspace
instrument_name = "LoadInstrument"
instrument_options = {"Workspace": output_workspace,
"Filename": idf_path,
"RewriteSpectraMap": False}
instrument_alg = create_unmanaged_algorithm(instrument_name, **instrument_options)
instrument_alg.execute()
# Crop to the required detector
crop_name = "CropToComponent"
component_to_crop = DetectorType(component)
component_to_crop = get_component_name(output_workspace, component_to_crop)
crop_options = {"InputWorkspace": output_workspace,
"OutputWorkspace": EMPTY_NAME,
"ComponentNames": component_to_crop}
crop_alg = create_unmanaged_algorithm(crop_name, **crop_options)
crop_alg.execute()
pixel_adjustment_workspace = crop_alg.getProperty("OutputWorkspace").value
else:
pixel_adjustment_workspace = None
return pixel_adjustment_workspace
def _get_workspace():
sample_name = "CreateSampleWorkspace"
sample_options = {"WorkspaceType": "Histogram",
"NumBanks": 1,
"BankPixelWidth": 1,
"OutputWorkspace": "test"}
sample_alg = create_unmanaged_algorithm(sample_name, **sample_options)
sample_alg.execute()
workspace = sample_alg.getProperty("OutputWorkspace").value
return workspace
def _rebin_workspace(workspace):
rebin_name = "Rebin"
rebin_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"Params": "{0}, {1}, {2}".format(SANSCreateAdjustmentWorkspacesTest.test_tof_min,
SANSCreateAdjustmentWorkspacesTest.test_tof_width,
SANSCreateAdjustmentWorkspacesTest.test_tof_max)}
rebin_alg = create_unmanaged_algorithm(rebin_name, **rebin_options)
rebin_alg.execute()
return rebin_alg.getProperty("OutputWorkspace").value
def _get_workspace(self, file_name):
full_file_name = FileFinder.findRuns(file_name)[0]
load_name = "Load"
load_options = {
"Filename": full_file_name,
"OutputWorkspace": EMPTY_NAME
}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
load_alg.execute()
return load_alg.getProperty("OutputWorkspace").value
def create_1D_workspace(data_x, data_y):
create_name = "CreateWorkspace"
create_options = {'DataX': data_x,
'DataY': data_y,
'NSpec': 1,
'UnitX': 'MomentumTransfer',
"OutputWorkspace": EMPTY_NAME}
create_alg = create_unmanaged_algorithm(create_name, **create_options)
create_alg.execute()
return create_alg.getProperty('OutputWorkspace').value
def test_that_zero_error_is_removed(self):
# Arrange
workspace = SANSSaveTest._get_sample_workspace(
with_zero_errors=True, convert_to_numeric_axis=True)
file_name = os.path.join(
mantid.config.getString('defaultsave.directory'),
'sample_sans_save_file')
use_zero_errors_free = True
save_name = "SANSSave"
save_options = {
"InputWorkspace": workspace,
"Filename": file_name,
"UseZeroErrorFree": use_zero_errors_free,
"Nexus": True,
"CanSAS": False,
"NXCanSAS": False,
"NistQxy": False,
"RKH": False,
"CSV": False
}
save_alg = create_unmanaged_algorithm(save_name, **save_options)
# Act
save_alg.execute()
self.assertTrue(save_alg.isExecuted())
file_name = os.path.join(
mantid.config.getString('defaultsave.directory'),
"sample_sans_save_file.nxs")
load_name = "LoadNexusProcessed"
load_options = {"Filename": file_name, "OutputWorkspace": EMPTY_NAME}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
load_alg.execute()
reloaded_workspace = load_alg.getProperty("OutputWorkspace").value
errors = reloaded_workspace.dataE(0)
# Make sure that the errors are not zero
self.assertGreater(errors[0], 1.0)
self.assertGreater(errors[14], 1.0)
self.assertGreater(errors[45], 1.0)
# Clean up
self._remove_file(file_name)
def _compare_to_reference(self, workspace, reference_file_name, check_spectra_map=True):
# Load the reference file
load_name = "LoadNexusProcessed"
load_options = {"Filename": reference_file_name,
"OutputWorkspace": EMPTY_NAME}
load_alg = create_unmanaged_algorithm(load_name, **load_options)
load_alg.execute()
reference_workspace = load_alg.getProperty("OutputWorkspace").value
# Compare reference file with the output_workspace
self._compare_workspace(workspace, reference_workspace, check_spectra_map=check_spectra_map)
def _load_wavelength_correction_file(file_name):
correction_workspace = None
if file_name:
load_name = "LoadRKH"
load_option = {"Filename": file_name,
"OutputWorkspace": EMPTY_NAME,
"FirstColumnValue": "Wavelength"}
load_alg = create_unmanaged_algorithm(load_name, **load_option)
load_alg.execute()
output_workspace = load_alg.getProperty("OutputWorkspace").value
# We require HistogramData and not PointData
if not output_workspace.isHistogramData():
convert_name = "ConvertToHistogram"
convert_options = {"InputWorkspace": output_workspace,
"OutputWorkspace": EMPTY_NAME}
convert_alg = create_unmanaged_algorithm(convert_name, **convert_options)
convert_alg.execute()
output_workspace = convert_alg.getProperty("OutputWorkspace").value
correction_workspace = output_workspace
return correction_workspace
def _load_sigma_moderator_workspace(file_name):
"""
Gets the sigma moderator workspace.
:param file_name: the file name of the sigma moderator
:returns the sigma moderator workspace
"""
load_name = "LoadRKH"
load_option = {"Filename": file_name,
"OutputWorkspace": EMPTY_NAME,
"FirstColumnValue": "Wavelength"}
load_alg = create_unmanaged_algorithm(load_name, **load_option)
load_alg.execute()
moderator_workspace = load_alg.getProperty("OutputWorkspace").value
convert_name = "ConvertToHistogram"
convert_options = {"InputWorkspace": moderator_workspace,
"OutputWorkspace": EMPTY_NAME}
convert_alg = create_unmanaged_algorithm(convert_name, **convert_options)
convert_alg.execute()
return convert_alg.getProperty("OutputWorkspace").value
def _get_monitor_workspace(data=None):
create_name = "CreateSampleWorkspace"
name = "test_workspace"
create_options = {"OutputWorkspace": name,
"NumBanks": 0,
"NumMonitors": 8}
create_alg = create_unmanaged_algorithm(create_name, **create_options)
create_alg.execute()
ws = create_alg.getProperty("OutputWorkspace").value
ws = SANSNormalizeToMonitorTest._prepare_workspace(ws, data=data)
return ws
def _run_test(workspace, state):
normalize_name = "SANSNormalizeToMonitor"
normalize_options = {
"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"SANSState": state
}
normalize_alg = create_unmanaged_algorithm(normalize_name,
**normalize_options)
normalize_alg.execute()
return normalize_alg.getProperty("OutputWorkspace").value
def _get_sample_workspace(with_zero_errors, convert_to_numeric_axis=False):
create_name = "CreateSimulationWorkspace"
create_options = {
"Instrument": "LARMOR",
"BinParams": '1,10,1000',
"UnitX": 'MomentumTransfer',
"OutputWorkspace": EMPTY_NAME
}
create_alg = create_unmanaged_algorithm(create_name, **create_options)
create_alg.execute()
workspace = create_alg.getProperty("OutputWorkspace").value
crop_name = "CropWorkspace"
crop_options = {
"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"EndWorkspaceIndex": 0
}
crop_alg = create_unmanaged_algorithm(crop_name, **crop_options)
crop_alg.execute()
workspace = crop_alg.getProperty("OutputWorkspace").value
if convert_to_numeric_axis:
convert_name = "ConvertSpectrumAxis"
convert_options = {
"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"Target": 'ElasticQ',
"EFixed": 1
}
convert_alg = create_unmanaged_algorithm(convert_name,
**convert_options)
convert_alg.execute()
workspace = convert_alg.getProperty("OutputWorkspace").value
if with_zero_errors:
errors = workspace.dataE(0)
errors[0] = 0.0
errors[14] = 0.0
errors[45] = 0.0
return workspace
def perform_move(state, workspace):
serialized_state = state.property_manager
move_name = "SANSMove"
zero_options = {
"SANSState": serialized_state,
"Workspace": workspace,
"MoveType": "SetToZero",
"Component": ""
}
zero_alg = create_unmanaged_algorithm(move_name, **zero_options)
zero_alg.execute()
workspace = zero_alg.getProperty("Workspace").value
move_options = {
"SANSState": serialized_state,
"Workspace": workspace,
"MoveType": "InitialMove"
}
move_alg = create_unmanaged_algorithm(move_name, **move_options)
move_alg.execute()
def get_region_of_interest(workspace, radius=None, roi_files=None, mask_files=None):
"""
Calculate the various contributions to the "region of interest", used in the
transmission calculation.
The region of interest can be made up of a circle of detectors (with a given radius)
around the beam centre, and/or one or more mask files, and/or the main detector bank.
Note that the mask files wont actually be used for masking, we're just piggy-backing
on the functionality that they provide. Note that in the case of a radius, we have
to ensure that we do not use a workspace which already has masked detectors, since
they would contribute to the ROI.
:param workspace: the workspace which is used for the transmission calculation
:param radius: the radius of the region of interest
:param roi_files: a list of roi files. Spectra in the ROI contribute to the
transmission calculation.
:param mask_files: a list of mask files. Spectra in the Mask explicitly do not
contribute to the transmission calculation.
:return: a list of spectrum numbers
"""
trans_roi = []
if radius is not None:
# Mask out a cylinder with the given radius in a copy of the workspace.
# The centre position of the Cylinder does not require a shift, as all
# components have been shifted already, when the workspaces were loaded
clone_name = "CloneWorkspace"
clone_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME}
clone_alg = create_unmanaged_algorithm(clone_name, **clone_options)
clone_alg.execute()
cloned_workspace = clone_alg.getProperty("OutputWorkspace").value
# Mask the cylinder around a centre of (0, 0)
mask_with_cylinder(cloned_workspace, radius, 0.0, 0.0, "")
# Extract the masked detector ID's.
trans_roi += get_masked_det_ids(cloned_workspace)
idf_path = get_idf_path_from_workspace(workspace)
if roi_files is not None and idf_path is not None:
for roi_file in roi_files:
trans_roi += get_masked_det_ids_from_mask_file(roi_file, idf_path)
masked_ids = []
if mask_files is not None and idf_path is not None:
for mask_file in mask_files:
masked_ids += get_masked_det_ids_from_mask_file(mask_file, idf_path)
# Detector ids which are not allowed and specified by "masked_ids" need to
# be removed from the trans_roi list
# Remove duplicates and sort.
return sorted(set(trans_roi) - set(masked_ids))
def _run_single_reduction(self,
state,
sample_scatter,
sample_monitor,
sample_transmission=None,
sample_direct=None,
can_scatter=None,
can_monitor=None,
can_transmission=None,
can_direct=None,
output_settings=None):
single_reduction_name = "SANSSingleReduction"
state_dict = state.property_manager
single_reduction_options = {
"SANSState": state_dict,
"SampleScatterWorkspace": sample_scatter,
"SampleScatterMonitorWorkspace": sample_monitor,
"UseOptimizations": False
}
if sample_transmission:
single_reduction_options.update(
{"SampleTransmissionWorkspace": sample_transmission})
if sample_direct:
single_reduction_options.update(
{"SampleDirectWorkspace": sample_direct})
if can_scatter:
single_reduction_options.update(
{"CanScatterWorkspace": can_scatter})
if can_monitor:
single_reduction_options.update(
{"CanScatterMonitorWorkspace": can_monitor})
if can_transmission:
single_reduction_options.update(
{"CanTransmissionWorkspace": can_transmission})
if can_direct:
single_reduction_options.update({"CanDirectWorkspace": can_direct})
if output_settings:
single_reduction_options.update(output_settings)
single_reduction_alg = create_unmanaged_algorithm(
single_reduction_name, **single_reduction_options)
# Act
single_reduction_alg.execute()
self.assertTrue(single_reduction_alg.isExecuted())
return single_reduction_alg
def _get_sample_data():
create_name = "CreateSampleWorkspace"
name = "test_workspace"
create_options = {"OutputWorkspace": name,
"NumBanks": 1,
"NumMonitors": 1,
"XMin": SANSCreateAdjustmentWorkspacesTest.test_wav_min,
"XMax": SANSCreateAdjustmentWorkspacesTest.test_wav_max,
"BinWidth": SANSCreateAdjustmentWorkspacesTest.test_wav_width,
"XUnit": "Wavelength"}
create_alg = create_unmanaged_algorithm(create_name, **create_options)
create_alg.execute()
return create_alg.getProperty("OutputWorkspace").value
def _get_wide_angle_correction_workspace(self, sample_data, calculated_transmission_workspace):
wide_angle_correction = self._state.wide_angle_correction
workspace = None
if wide_angle_correction and sample_data and calculated_transmission_workspace:
wide_angle_name = "SANSWideAngleCorrection"
wide_angle_options = {"SampleData": sample_data,
"TransmissionData": calculated_transmission_workspace,
"OutputWorkspace": EMPTY_NAME}
wide_angle_alg = create_unmanaged_algorithm(wide_angle_name, **wide_angle_options)
wide_angle_alg.execute()
workspace = wide_angle_alg.getProperty("OutputWorkspace").value
return workspace
def _replace_special_values(workspace):
replace_name = "ReplaceSpecialValues"
replace_options = {"InputWorkspace": workspace,
"OutputWorkspace": EMPTY_NAME,
"NaNValue": 0.,
"InfinityValue": 0.,
"UseAbsolute": False,
"SmallNumberThreshold": 0.0,
"SmallNumberValue": 0.0,
"SmallNumberError": 0.0}
replace_alg = create_unmanaged_algorithm(replace_name, **replace_options)
replace_alg.execute()
return replace_alg.getProperty("OutputWorkspace").value
def test_that_run_number_properties_can_be_set(self):
# Arrange
workspace = SANSSaveTest._get_sample_workspace(with_zero_errors=False, convert_to_numeric_axis=True)
file_name = os.path.join(mantid.config.getString('defaultsave.directory'), 'sample_sans_save_file')
save_name = "SANSSave"
save_options = {"InputWorkspace": workspace,
"Filename": file_name,
"UseZeroErrorFree": False,
"Nexus": False,
"CanSAS": False,
"NXCanSAS": True,
"NistQxy": False,
"RKH": False,
"CSV": False,
"SampleTransmissionRunNumber": "5",
"SampleDirectRunNumber": "6",
"CanScatterRunNumber": "7",
"CanDirectRunNumber": "8"}
try:
create_unmanaged_algorithm(save_name, **save_options)
except RuntimeError:
self.fail("Unable to set properties for SANSSave.")
def test_single_nested_json_raises(self):
convert_options = {
"InputWorkspace": provide_workspace(),
"OutputWorkspace": EMPTY_NAME,
"RebinMode": "InterpolatingRebin",
self.WAV_PAIRS: json.dumps([1.0, 2.0]),
"WavelengthStep": 1.5,
"WavelengthStepType": RangeStepType.LIN.value
}
convert_alg = create_unmanaged_algorithm(
"SANSConvertToWavelengthAndRebin", **convert_options)
with self.assertRaisesRegex(RuntimeError, "WavelengthPairs"):
convert_alg.execute()
