distributable.h

Go to the documentation of this file.

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000 - 2011, Hammersmith Imanet Ltd
    Copyright (C) 2013, University College London
    Copyright (C) 2022, University of Pennsylvania
    This file is part of STIR.

    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license

    See STIR/LICENSE.txt for details
*/

#ifndef __stir_recon_buildblock_DISTRIBUTABLE_H__
#define __stir_recon_buildblock_DISTRIBUTABLE_H__

#include "stir/shared_ptr.h"
#include "stir/Bin.h"
#include <vector>

START_NAMESPACE_STIR

template <typename elemT>
class RelatedViewgrams;
template <int num_dimensions, typename elemT>
class DiscretisedDensity;
class BinNormalisation;
class ProjData;
class ProjDataInfo;
class ExamInfo;
class DataSymmetriesForViewSegmentNumbers;
class ForwardProjectorByBin;
class BackProjectorByBin;
class ProjectorByBinPair;
class DistributedCachingInformation;
class ProjMatrixByBin;


const int task_stop_processing = 0;
const int task_setup_distributable_computation = 200;
const int task_do_distributable_gradient_computation = 42;
const int task_do_distributable_loglikelihood_computation = 43;
const int task_do_distributable_sensitivity_computation = 44;


void setup_distributable_computation(const shared_ptr<ProjectorByBinPair>& proj_pair_sptr,
                                     const shared_ptr<const ExamInfo>& exam_info_sptr,
                                     const shared_ptr<const ProjDataInfo> proj_data_info_sptr,
                                     const shared_ptr<const DiscretisedDensity<3, float>>& target_sptr,
                                     const bool zero_seg0_end_planes,
                                     const bool distributed_cache_enabled);


void end_distributable_computation();


typedef void RPC_process_related_viewgrams_type(const shared_ptr<ForwardProjectorByBin>& forward_projector_sptr,
                                                const shared_ptr<BackProjectorByBin>& back_projector_sptr,
                                                RelatedViewgrams<float>* measured_viewgrams_ptr,
                                                int& count,
                                                int& count2,
                                                double* log_likelihood_ptr,
                                                const RelatedViewgrams<float>* additive_binwise_correction_ptr,
                                                const RelatedViewgrams<float>* mult_viewgrams_ptr);

void distributable_computation(const shared_ptr<ForwardProjectorByBin>& forward_projector_sptr,
                               const shared_ptr<BackProjectorByBin>& back_projector_sptr,
                               const shared_ptr<DataSymmetriesForViewSegmentNumbers>& symmetries_sptr,
                               DiscretisedDensity<3, float>* output_image_ptr,
                               const DiscretisedDensity<3, float>* input_image_ptr,
                               const shared_ptr<ProjData>& proj_data_ptr,
                               const bool read_from_proj_data,
                               int subset_num,
                               int num_subsets,
                               int min_segment_num,
                               int max_segment_num,
                               bool zero_seg0_end_planes,
                               double* double_out_ptr,
                               const shared_ptr<ProjData>& additive_binwise_correction,
                               const shared_ptr<BinNormalisation> normalise_sptr,
                               const double start_time_of_frame,
                               const double end_time_of_frame,
                               RPC_process_related_viewgrams_type* RPC_process_related_viewgrams,
                               DistributedCachingInformation* caching_info_ptr,
                               int min_timing_pos_num,
                               int max_timing_pos_num);

template <typename CallBackT>
void LM_distributable_computation(const shared_ptr<ProjMatrixByBin> PM_sptr,
                                  const shared_ptr<ProjDataInfo>& proj_data_info_sptr,
                                  DiscretisedDensity<3, float>* output_image_ptr,
                                  const DiscretisedDensity<3, float>* input_image_ptr,
                                  const std::vector<BinAndCorr>& record_cache,
                                  const int subset_num,
                                  const int num_subsets,
                                  const bool has_add,
                                  const bool accumulate,
                                  double* double_out_ptr,
                                  CallBackT&& call_back);

const int AVAILABLE_NOTIFICATION_TAG = 2;
const int END_ITERATION_TAG = 3;
const int END_RECONSTRUCTION_TAG = 4;
const int END_NOTIFICATION_TAG = 5;
const int BINWISE_CORRECTION_TAG = 6;
const int BINWISE_MULT_TAG = 66;
const int REUSE_VIEWGRAM_TAG = 10;
const int NEW_VIEWGRAM_TAG = 11;
const int USE_DOUBLE_ARG_TAG = 70;
const int USE_OUTPUT_IMAGE_ARG_TAG = 71;


END_NAMESPACE_STIR

#endif // __stir_recon_buildblock_DISTRIBUTABLE_H__