PoissonLogLikelihoodWithLinearModelForMeanAndProjData.h

Go to the documentation of this file.

/*
    Copyright (C) 2003 - 2011-02-23, Hammersmith Imanet Ltd
    Copyright (C) 2018, 2022, University College London
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0
 
    See STIR/LICENSE.txt for details
*/
 
#ifndef __stir_recon_buildblock_PoissonLogLikelihoodWithLinearModelForMeanAndProjData_H__
#define __stir_recon_buildblock_PoissonLogLikelihoodWithLinearModelForMeanAndProjData_H__
 
#include "stir/RegisteredParsingObject.h"
#include "stir/recon_buildblock/PoissonLogLikelihoodWithLinearModelForMean.h"
#include "stir/ParseAndCreateFrom.h"
//#include "stir/ProjData.h"
#include "stir/recon_buildblock/ProjectorByBinPair.h"
//#include "stir/recon_buildblock/BinNormalisation.h"
#include "stir/TimeFrameDefinitions.h"
#ifdef STIR_MPI
#  include "stir/recon_buildblock/distributable.h" // for  RPC_process_related_viewgrams_type
#endif
 
START_NAMESPACE_STIR
 
class DistributedCachingInformation;
 
//#ifdef STIR_MPI_CLASS_DEFINITION
//#define PoissonLogLikelihoodWithLinearModelForMeanAndProjData PoissonLogLikelihoodWithLinearModelForMeanAndProjData_MPI
//#endif

template <typename TargetT>
class PoissonLogLikelihoodWithLinearModelForMeanAndProjData
    : public RegisteredParsingObject<PoissonLogLikelihoodWithLinearModelForMeanAndProjData<TargetT>,
                                     GeneralisedObjectiveFunction<TargetT>,
                                     PoissonLogLikelihoodWithLinearModelForMean<TargetT>>
{
private:
  typedef RegisteredParsingObject<PoissonLogLikelihoodWithLinearModelForMeanAndProjData<TargetT>,
                                  GeneralisedObjectiveFunction<TargetT>,
                                  PoissonLogLikelihoodWithLinearModelForMean<TargetT>>
      base_type;
 
public:
  static const char* const registered_name;
 
  //

  DistributedCachingInformation* caching_info_ptr;
  //#ifdef STIR_MPI
  bool distributed_cache_enabled;
  bool distributed_tests_enabled;
  bool message_timings_enabled;
  double message_timings_threshold;
  bool rpc_timings_enabled;
  //#endif

  PoissonLogLikelihoodWithLinearModelForMeanAndProjData();


  ~PoissonLogLikelihoodWithLinearModelForMeanAndProjData() override;


  TargetT* construct_target_ptr() const override;

  const ProjData& get_proj_data() const;
  const shared_ptr<ProjData>& get_proj_data_sptr() const;
  const int get_max_segment_num_to_process() const;
  const int get_max_timing_pos_num_to_process() const;
  const bool get_zero_seg0_end_planes() const;
  const ProjData& get_additive_proj_data() const;
  const shared_ptr<ProjData>& get_additive_proj_data_sptr() const;
  const ProjectorByBinPair& get_projector_pair() const;
  const shared_ptr<ProjectorByBinPair>& get_projector_pair_sptr() const;
  const int get_time_frame_num() const;
  const TimeFrameDefinitions& get_time_frame_definitions() const;
  const BinNormalisation& get_normalisation() const;
  const shared_ptr<BinNormalisation>& get_normalisation_sptr() const;

  int set_num_subsets(const int num_subsets) override;
  void set_proj_data_sptr(const shared_ptr<ProjData>&);
  void set_max_segment_num_to_process(const int);
  void set_max_timing_pos_num_to_process(const int);
  void set_zero_seg0_end_planes(const bool);
  // N.E. Changed to ExamData
  void set_additive_proj_data_sptr(const shared_ptr<ExamData>&) override;
  void set_projector_pair_sptr(const shared_ptr<ProjectorByBinPair>&);
  void set_frame_num(const int);
  void set_frame_definitions(const TimeFrameDefinitions&);
  void set_normalisation_sptr(const shared_ptr<BinNormalisation>&) override;
 
  void set_input_data(const shared_ptr<ExamData>&) override;
  const ProjData& get_input_data() const override;
 
  void actual_compute_subset_gradient_without_penalty(TargetT& gradient,
                                                      const TargetT& current_estimate,
                                                      const int subset_num,
                                                      const bool add_sensitivity) override;
 
  std::unique_ptr<ExamInfo> get_exam_info_uptr_for_target() const override;
#if 0
  // currently not used
  float sum_projection_data() const;
#endif
  void add_subset_sensitivity(TargetT& sensitivity, const int subset_num) const override;
 
protected:
  Succeeded set_up_before_sensitivity(shared_ptr<const TargetT> const& target_sptr) override;
 
  double actual_compute_objective_function_without_penalty(const TargetT& current_estimate, const int subset_num) override;

  Succeeded actual_add_multiplication_with_approximate_sub_Hessian_without_penalty(TargetT& output,
                                                                                   const TargetT& input,
                                                                                   const int subset_num) const override;

  Succeeded actual_accumulate_sub_Hessian_times_input_without_penalty(TargetT& output,
                                                                      const TargetT& current_image_estimate,
                                                                      const TargetT& input,
                                                                      const int subset_num) const override;
 
protected:
  std::string input_filename;

  shared_ptr<ProjData> proj_data_sptr;


  int max_segment_num_to_process;


  int max_timing_pos_num_to_process;
 
  /**********************/
  ParseAndCreateFrom<TargetT, ProjData> target_parameter_parser;
  /********************************/

  shared_ptr<ProjectorByBinPair> projector_pair_ptr;

  bool zero_seg0_end_planes;

  bool use_tofsens;

  std::string additive_projection_data_filename;
 
  shared_ptr<ProjData> additive_proj_data_sptr;
 
  shared_ptr<BinNormalisation> normalisation_sptr;
 
  // TODO doc
  int frame_num;
  std::string frame_definition_filename;
  TimeFrameDefinitions frame_defs;
 
  // Loglikelihood computation parameters
  //  TODO rename and move higher up in the hierarchy
  int loglikelihood_computation_interval;

  bool compute_total_loglikelihood;

  std::string loglikelihood_data_filename;


  void set_defaults() override;

  void initialise_keymap() override;

  bool post_processing() override;


  bool actual_subsets_are_approximately_balanced(std::string& warning_message) const override;
 
private:
  shared_ptr<DataSymmetriesForViewSegmentNumbers> symmetries_sptr;

  shared_ptr<BackProjectorByBin> sens_backprojector_sptr;
 
  shared_ptr<DataSymmetriesForViewSegmentNumbers> sens_symmetries_sptr;
  mutable bool latest_setup_distributable_computation_was_with_orig_projectors;
  mutable bool distributable_computation_already_setup;

  bool sensitivity_uses_same_projector() const;

  shared_ptr<const ProjDataInfo> sens_proj_data_info_sptr;
  mutable bool latest_setup_norm_was_with_orig_data;
  mutable bool norm_already_setup = false;

  void ensure_norm_is_set_up(bool for_original_data = true) const;
  void ensure_norm_is_set_up_for_sensitivity() const;
#if 0
  void
    add_view_seg_to_sensitivity(TargetT& sensitivity, const ViewSegmentNumbers& view_seg_nums) const;
#endif
};
 
#ifdef STIR_MPI
// made available to be called from DistributedWorker object
RPC_process_related_viewgrams_type RPC_process_related_viewgrams_gradient;
RPC_process_related_viewgrams_type RPC_process_related_viewgrams_accumulate_loglikelihood;
RPC_process_related_viewgrams_type RPC_process_related_viewgrams_sensitivity_computation;
#endif
 
END_NAMESPACE_STIR
 
//#include "stir/recon_buildblock/PoissonLogLikelihoodWithLinearModelForMean.inl"
 
#endif