def _prepare_workspaces(number_of_workspaces,
tagged_workspace_names=None,
state=None,
reduction_mode=None):
create_name = "CreateSampleWorkspace"
create_options = {
"OutputWorkspace": "test",
"NumBanks": 1,
"BankPixelWidth": 2,
"XMin": 1,
"XMax": 10,
"BinWidth": 2
}
create_alg = create_unmanaged_algorithm(create_name, **create_options)
for index in range(number_of_workspaces):
create_alg.execute()
workspace = create_alg.getProperty("OutputWorkspace").value
workspace_name = "test" + "_" + str(index)
AnalysisDataService.addOrReplace(workspace_name, workspace)
if tagged_workspace_names is not None:
for key, value in list(tagged_workspace_names.items()):
create_alg.execute()
workspace = create_alg.getProperty("OutputWorkspace").value
AnalysisDataService.addOrReplace(value, workspace)
write_hash_into_reduced_can_workspace(state, workspace,
reduction_mode, key)
def _prepare_workspaces(number_of_workspaces, tagged_workspace_names=None, state=None, reduction_mode=None):
create_name = "CreateSampleWorkspace"
create_options = {"OutputWorkspace": "test",
"NumBanks": 1,
"BankPixelWidth": 2,
"XMin": 1,
"XMax": 10,
"BinWidth": 2}
create_alg = create_unmanaged_algorithm(create_name, **create_options)
for index in range(number_of_workspaces):
create_alg.execute()
workspace = create_alg.getProperty("OutputWorkspace").value
workspace_name = "test" + "_" + str(index)
AnalysisDataService.addOrReplace(workspace_name, workspace)
if tagged_workspace_names is not None:
for key, value in list(tagged_workspace_names.items()):
create_alg.execute()
workspace = create_alg.getProperty("OutputWorkspace").value
AnalysisDataService.addOrReplace(value, workspace)
write_hash_into_reduced_can_workspace(state, workspace, reduction_mode, key)
def run_optimized_for_can(reduction_alg, reduction_setting_bundle):
"""
Check if the state can reduction already exists, and if so, use it else reduce it and add it to the ADS.
@param reduction_alg: a handle to the SANSReductionCore algorithm
@param reduction_setting_bundle: a ReductionSettingBundle tuple.
@return: a reduced workspace, a partial output workspace for the counts, a partial workspace for the normalization.
"""
state = reduction_setting_bundle.state
output_parts = reduction_setting_bundle.output_parts
reduction_mode = reduction_setting_bundle.reduction_mode
data_type = reduction_setting_bundle.data_type
reduced_can_workspace, reduced_can_workspace_count, reduced_can_workspace_norm = \
get_reduced_can_workspace_from_ads(state, output_parts, reduction_mode)
output_calculated_transmission_workspace, output_unfitted_transmission_workspace = \
get_transmission_workspaces_from_ads(state, reduction_mode)
# Set the results on the output bundle
output_bundle = OutputBundle(state=state, data_type=data_type, reduction_mode=reduction_mode,
output_workspace=reduced_can_workspace)
output_parts_bundle = OutputPartsBundle(state=state, data_type=data_type, reduction_mode=reduction_mode,
output_workspace_count=reduced_can_workspace_count,
output_workspace_norm=reduced_can_workspace_norm)
output_transmission_bundle = OutputTransmissionBundle(state=reduction_setting_bundle.state, data_type=data_type,
calculated_transmission_workspace=output_calculated_transmission_workspace,
unfitted_transmission_workspace=output_unfitted_transmission_workspace
)
# The logic table for the recalculation of the partial outputs is:
# | output_parts | reduced_can_workspace_count is None | reduced_can_workspace_norm is None | Recalculate |
# ----------------------------------------------------------------------------------------------------------
# | False | True | True | False |
# | False | True | False | False |
# | False | False | True | False |
# | False | False | False | False |
# | True | True | True | False |
# | True | True | False | True |
# | True | False | True | True |
# | True | False | False | False |
is_invalid_partial_workspaces = ((output_parts_bundle.output_workspace_count is None and
output_parts_bundle.output_workspace_norm is not None) or
(output_parts_bundle.output_workspace_count is not None and
output_parts_bundle.output_workspace_norm is None))
is_invalid_transmission_workspaces = (output_transmission_bundle.calculated_transmission_workspace is None
or output_transmission_bundle.unfitted_transmission_workspace is None) \
and state.adjustment.show_transmission
partial_output_require_reload = output_parts and is_invalid_partial_workspaces
must_reload = output_bundle.output_workspace is None or partial_output_require_reload or is_invalid_transmission_workspaces
if 'boost.mpi' in sys.modules:
# In MPI runs the result is only present on rank 0 (result of Q1D2 integration),
# so the reload flag must be broadcasted from rank 0.
must_reload = mpisetup.boost.mpi.broadcast(mpisetup.boost.mpi.world, must_reload, 0)
if must_reload:
# if output_bundle.output_workspace is None or partial_output_require_reload:
output_bundle, output_parts_bundle, output_transmission_bundle = run_core_reduction(reduction_alg,
reduction_setting_bundle)
# Now we need to tag the workspaces and add it to the ADS
if output_bundle.output_workspace is not None:
write_hash_into_reduced_can_workspace(state=output_bundle.state,
workspace=output_bundle.output_workspace,
partial_type=None,
reduction_mode=reduction_mode)
if output_transmission_bundle.calculated_transmission_workspace is not None and \
output_transmission_bundle.unfitted_transmission_workspace is not None:
write_hash_into_reduced_can_workspace(state=output_transmission_bundle.state,
workspace=output_transmission_bundle.calculated_transmission_workspace,
partial_type=TransmissionType.Calculated,
reduction_mode=reduction_mode)
write_hash_into_reduced_can_workspace(state=output_transmission_bundle.state,
workspace=output_transmission_bundle.unfitted_transmission_workspace,
partial_type=TransmissionType.Unfitted,
reduction_mode=reduction_mode)
if (output_parts_bundle.output_workspace_count is not None and
output_parts_bundle.output_workspace_norm is not None):
write_hash_into_reduced_can_workspace(state=output_parts_bundle.state,
workspace=output_parts_bundle.output_workspace_count,
partial_type=OutputParts.Count,
reduction_mode=reduction_mode)
write_hash_into_reduced_can_workspace(state=output_parts_bundle.state,
workspace=output_parts_bundle.output_workspace_norm,
partial_type=OutputParts.Norm,
reduction_mode=reduction_mode)
return output_bundle, output_parts_bundle, output_transmission_bundle
def run_optimized_for_can(reduction_alg,
reduction_setting_bundle,
event_slice_optimisation=False):
"""
Check if the state can reduction already exists, and if so, use it else reduce it and add it to the ADS.
:param reduction_alg: a handle to the SANSReductionCore algorithm
:param reduction_setting_bundle: a ReductionSettingBundle tuple.
:param event_slice_optimisation: An optional bool. If true then run run_core_event_slice_reduction, else run_core_reduction.
:return: a reduced workspace, a partial output workspace for the counts, a partial workspace for the normalization.
"""
state = reduction_setting_bundle.state
output_parts = reduction_setting_bundle.output_parts
reduction_mode = reduction_setting_bundle.reduction_mode
data_type = reduction_setting_bundle.data_type
reduced_can_workspace, reduced_can_workspace_count, reduced_can_workspace_norm = \
get_reduced_can_workspace_from_ads(state, output_parts, reduction_mode)
output_calculated_transmission_workspace, output_unfitted_transmission_workspace = \
get_transmission_workspaces_from_ads(state, reduction_mode)
# Set the results on the output bundle
output_bundle = OutputBundle(state=state,
data_type=data_type,
reduction_mode=reduction_mode,
output_workspace=reduced_can_workspace)
output_parts_bundle = OutputPartsBundle(
state=state,
data_type=data_type,
reduction_mode=reduction_mode,
output_workspace_count=reduced_can_workspace_count,
output_workspace_norm=reduced_can_workspace_norm)
output_transmission_bundle = OutputTransmissionBundle(
state=reduction_setting_bundle.state,
data_type=data_type,
calculated_transmission_workspace=
output_calculated_transmission_workspace,
unfitted_transmission_workspace=output_unfitted_transmission_workspace)
# The logic table for the recalculation of the partial outputs is:
# | output_parts | reduced_can_workspace_count is None | reduced_can_workspace_norm is None | Recalculate |
# ----------------------------------------------------------------------------------------------------------
# | False | True | True | False |
# | False | True | False | False |
# | False | False | True | False |
# | False | False | False | False |
# | True | True | True | False |
# | True | True | False | True |
# | True | False | True | True |
# | True | False | False | False |
is_invalid_partial_workspaces = (
(output_parts_bundle.output_workspace_count is None
and output_parts_bundle.output_workspace_norm is not None)
or (output_parts_bundle.output_workspace_count is not None
and output_parts_bundle.output_workspace_norm is None))
is_invalid_transmission_workspaces = (
output_transmission_bundle.calculated_transmission_workspace is None
or output_transmission_bundle.unfitted_transmission_workspace is None)
partial_output_require_reload = output_parts and is_invalid_partial_workspaces
must_reload = output_bundle.output_workspace is None or partial_output_require_reload or is_invalid_transmission_workspaces
if 'boost.mpi' in sys.modules:
# In MPI runs the result is only present on rank 0 (result of Q1D2 integration),
# so the reload flag must be broadcasted from rank 0.
must_reload = mpisetup.boost.mpi.broadcast(mpisetup.boost.mpi.world,
must_reload, 0)
if must_reload:
# if output_bundle.output_workspace is None or partial_output_require_reload:
if not event_slice_optimisation:
output_bundle, output_parts_bundle, \
output_transmission_bundle = run_core_reduction(reduction_alg, reduction_setting_bundle)
else:
output_bundle, output_parts_bundle, \
output_transmission_bundle = run_core_event_slice_reduction(reduction_alg, reduction_setting_bundle)
# Now we need to tag the workspaces and add it to the ADS
if output_bundle.output_workspace is not None:
write_hash_into_reduced_can_workspace(
state=output_bundle.state,
workspace=output_bundle.output_workspace,
partial_type=None,
reduction_mode=reduction_mode)
if output_transmission_bundle.calculated_transmission_workspace is not None and \
output_transmission_bundle.unfitted_transmission_workspace is not None:
write_hash_into_reduced_can_workspace(
state=output_transmission_bundle.state,
workspace=output_transmission_bundle.
calculated_transmission_workspace,
partial_type=TransmissionType.CALCULATED,
reduction_mode=reduction_mode)
write_hash_into_reduced_can_workspace(
state=output_transmission_bundle.state,
workspace=output_transmission_bundle.
unfitted_transmission_workspace,
partial_type=TransmissionType.UNFITTED,
reduction_mode=reduction_mode)
if (output_parts_bundle.output_workspace_count is not None
and output_parts_bundle.output_workspace_norm is not None):
write_hash_into_reduced_can_workspace(
state=output_parts_bundle.state,
workspace=output_parts_bundle.output_workspace_count,
partial_type=OutputParts.COUNT,
reduction_mode=reduction_mode)
write_hash_into_reduced_can_workspace(
state=output_parts_bundle.state,
workspace=output_parts_bundle.output_workspace_norm,
partial_type=OutputParts.NORM,
reduction_mode=reduction_mode)
return output_bundle, output_parts_bundle, output_transmission_bundle
def run_optimized_for_can(reduction_alg, reduction_setting_bundle):
"""
Check if the state can reduction already exists, and if so, use it else reduce it and add it to the ADS.
@param reduction_alg: a handle to the SANSReductionCore algorithm
@param reduction_setting_bundle: a ReductionSettingBundle tuple.
@return: a reduced workspace, a partial output workspace for the counts, a partial workspace for the normalization.
"""
state = reduction_setting_bundle.state
output_parts = reduction_setting_bundle.output_parts
reduction_mode = reduction_setting_bundle.reduction_mode
data_type = reduction_setting_bundle.data_type
reduced_can_workspace, reduced_can_workspace_count, reduced_can_workspace_norm = \
get_reduced_can_workspace_from_ads(state, output_parts, reduction_mode)
# Set the results on the output bundle
output_bundle = OutputBundle(state=state, data_type=data_type, reduction_mode=reduction_mode,
output_workspace=reduced_can_workspace)
output_parts_bundle = OutputPartsBundle(state=state, data_type=data_type, reduction_mode=reduction_mode,
output_workspace_count=reduced_can_workspace_count,
output_workspace_norm=reduced_can_workspace_norm)
# The logic table for the recalculation of the partial outputs is:
# | output_parts | reduced_can_workspace_count is None | reduced_can_workspace_norm is None | Recalculate |
# ----------------------------------------------------------------------------------------------------------
# | False | True | True | False |
# | False | True | False | False |
# | False | False | True | False |
# | False | False | False | False |
# | True | True | True | False |
# | True | True | False | True |
# | True | False | True | True |
# | True | False | False | False |
is_invalid_partial_workspaces = ((output_parts_bundle.output_workspace_count is None and
output_parts_bundle.output_workspace_norm is not None) or
(output_parts_bundle.output_workspace_count is not None and
output_parts_bundle.output_workspace_norm is None))
partial_output_require_reload = output_parts and is_invalid_partial_workspaces
if output_bundle.output_workspace is None or partial_output_require_reload:
output_bundle, output_parts_bundle = run_core_reduction(reduction_alg, reduction_setting_bundle)
# Now we need to tag the workspaces and add it to the ADS
if output_bundle.output_workspace is not None:
write_hash_into_reduced_can_workspace(state=output_bundle.state,
workspace=output_bundle.output_workspace,
partial_type=None,
reduction_mode=reduction_mode)
if (output_parts_bundle.output_workspace_count is not None and
output_parts_bundle.output_workspace_norm is not None):
write_hash_into_reduced_can_workspace(state=output_parts_bundle.state,
workspace=output_parts_bundle.output_workspace_count,
partial_type=OutputParts.Count,
reduction_mode=reduction_mode)
write_hash_into_reduced_can_workspace(state=output_parts_bundle.state,
workspace=output_parts_bundle.output_workspace_norm,
partial_type=OutputParts.Norm,
reduction_mode=reduction_mode)
return output_bundle, output_parts_bundle
def run_optimized_for_can(reduction_alg,
reduction_setting_bundle,
event_slice_optimisation=False):
"""
Check if the state can reduction already exists, and if so, use it else reduce it and add it to the ADS.
:param reduction_alg: a handle to the SANSReductionCore algorithm
:param reduction_setting_bundle: a ReductionSettingBundle tuple.
:param event_slice_optimisation: An optional bool. If true then run run_core_event_slice_reduction, else run_core_reduction.
:return: a reduced workspace, a partial output workspace for the counts, a partial workspace for the normalization.
"""
state = reduction_setting_bundle.state
output_parts = reduction_setting_bundle.output_parts
reduction_mode = reduction_setting_bundle.reduction_mode
reduced_slices = _get_existing_cans(reduction_setting_bundle, state)
# The logic table for the recalculation of the partial outputs is:
# | output_parts | reduced_can_workspace_count is None | reduced_can_workspace_norm is None | Recalculate |
# ----------------------------------------------------------------------------------------------------------
# | False | True | True | False |
# | False | True | False | False |
# | False | False | True | False |
# | False | False | False | False |
# | True | True | True | False |
# | True | True | False | True |
# | True | False | True | True |
# | True | False | False | False |
def needs_reload(slice: ReducedSlice):
output_parts_bundle = slice.parts_bundle
# Invalid partial when one is set to none, but not the other
is_invalid_partial_workspaces = \
(output_parts_bundle.output_workspace_count is None) ^ (output_parts_bundle.output_workspace_norm is None)
output_transmission_bundle = slice.transmission_bundle
is_invalid_transmission_workspaces = (
output_transmission_bundle.calculated_transmission_workspace is
None or
output_transmission_bundle.unfitted_transmission_workspace is None)
partial_output_require_reload = output_parts and is_invalid_partial_workspaces
return slice.output_bundle.output_workspace is None\
or partial_output_require_reload or is_invalid_transmission_workspaces
must_reload = any(
needs_reload(i)
for i in reduced_slices) # If any slice requires a reload
if 'boost.mpi' in sys.modules:
# In MPI runs the result is only present on rank 0 (result of Q1D2 integration),
# so the reload flag must be broadcasted from rank 0.
must_reload = mpisetup.boost.mpi.broadcast(mpisetup.boost.mpi.world,
must_reload, 0)
if not must_reload:
# Return the cached can without doing anything else
logger.information(
"SANS single_execution: Using cached can workspaces")
return reduced_slices
logger.information(
"SANS single_execution: Processing new/changed can workspaces")
# We can't used a cached can, lets re-process
if not event_slice_optimisation:
reduced_slices = run_core_reduction(reduction_alg,
reduction_setting_bundle)
else:
reduced_slices = run_core_event_slice_reduction(
reduction_alg, reduction_setting_bundle)
# Now we need to tag the workspaces and add it to the ADS
for completed_slice in reduced_slices:
out_bundle = completed_slice.output_bundle
wav_range = completed_slice.wav_range
write_hash_into_reduced_can_workspace(
state=out_bundle.state,
workspace=out_bundle.output_workspace,
partial_type=None,
wav_range=wav_range,
reduction_mode=reduction_mode)
trans_bundle = completed_slice.transmission_bundle
if trans_bundle.calculated_transmission_workspace and trans_bundle.unfitted_transmission_workspace:
write_hash_into_reduced_can_workspace(
state=trans_bundle.state,
workspace=trans_bundle.calculated_transmission_workspace,
partial_type=TransmissionType.CALCULATED,
reduction_mode=reduction_mode,
wav_range=wav_range)
write_hash_into_reduced_can_workspace(
state=trans_bundle.state,
workspace=trans_bundle.unfitted_transmission_workspace,
partial_type=TransmissionType.UNFITTED,
reduction_mode=reduction_mode,
wav_range=None)
parts_bundle = completed_slice.parts_bundle
if parts_bundle.output_workspace_count and parts_bundle.output_workspace_norm:
write_hash_into_reduced_can_workspace(
state=parts_bundle.state,
workspace=parts_bundle.output_workspace_count,
partial_type=OutputParts.COUNT,
reduction_mode=reduction_mode,
wav_range=wav_range)
write_hash_into_reduced_can_workspace(
state=parts_bundle.state,
workspace=parts_bundle.output_workspace_norm,
partial_type=OutputParts.NORM,
reduction_mode=reduction_mode,
wav_range=wav_range)
return reduced_slices
