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