PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2003- 2011, Hammersmith Imanet Ltd
    Copyright (C) 2015, Univ. of Leeds
    Copyright (C) 2016, 2022, 2024 UCL
    Copyright (C) 2021, University of Pennsylvania
    SPDX-License-Identifier: Apache-2.0

    See STIR/LICENSE.txt for details
*/
#ifndef __stir_recon_buildblock_PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin_H__
#define __stir_recon_buildblock_PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin_H__

#include "stir/RegisteredParsingObject.h"
#include "stir/recon_buildblock/PoissonLogLikelihoodWithLinearModelForMeanAndListModeData.h"
#include "stir/recon_buildblock/ProjMatrixByBin.h"
#include "stir/ProjDataFromStream.h"
#include "stir/ProjDataInMemory.h"
#include "stir/recon_buildblock/ProjectorByBinPairUsingProjMatrixByBin.h"
#include "stir/ExamInfo.h"
#include "stir/deprecated.h"
#include "stir/recon_buildblock/distributable.h"
#include "stir/error.h"
START_NAMESPACE_STIR

template <typename TargetT>
class PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin
    : public RegisteredParsingObject<PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin<TargetT>,
                                     GeneralisedObjectiveFunction<TargetT>,
                                     PoissonLogLikelihoodWithLinearModelForMeanAndListModeData<TargetT>>

{

private:
  typedef RegisteredParsingObject<PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin<TargetT>,
                                  GeneralisedObjectiveFunction<TargetT>,
                                  PoissonLogLikelihoodWithLinearModelForMeanAndListModeData<TargetT>>
      base_type;

public:
  static const char* const registered_name;

  PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin();


  double actual_compute_objective_function_without_penalty(const TargetT& current_estimate, const int subset_num) override;


  void actual_compute_subset_gradient_without_penalty(TargetT& gradient,
                                                      const TargetT& current_estimate,
                                                      const int subset_num,
                                                      const bool add_sensitivity) 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;

  TargetT* construct_target_ptr() const override;

  int set_num_subsets(const int new_num_subsets) override;

  const shared_ptr<BinNormalisation>& get_normalisation_sptr() const { return this->normalisation_sptr; }

  unique_ptr<ExamInfo> get_exam_info_uptr_for_target() const override;

  void set_proj_matrix(const shared_ptr<ProjMatrixByBin>&);

  void set_skip_balanced_subsets(const bool arg);

#if STIR_VERSION < 060000
  STIR_DEPRECATED
  void set_max_ring_difference(const int arg);
#endif

protected:
  Succeeded set_up_before_sensitivity(shared_ptr<const TargetT> const& target_sptr) override;

  void add_subset_sensitivity(TargetT& sensitivity, const int subset_num) const override;

#if STIR_VERSION < 060000

  int max_ring_difference_num_to_process;
#endif

  bool use_tofsens;

  shared_ptr<ProjMatrixByBin> PM_sptr;

  shared_ptr<ProjectorByBinPair> projector_pair_sptr;

  shared_ptr<BackProjectorByBin> sens_backprojector_sptr;

  shared_ptr<ProjDataInfo> sens_proj_data_info_sptr;

  void set_defaults() override;
  void initialise_keymap() override;
  bool post_processing() override;

  bool actual_subsets_are_approximately_balanced(std::string& warning_message) const override;

  bool skip_balanced_subsets;

private:

  mutable std::vector<BinAndCorr> record_cache;


  bool load_listmode_batch(unsigned int ibatch) const;


  bool read_listmode_batch(unsigned int ibatch) const;

  Succeeded cache_listmode_file();

  bool load_listmode_cache_file(unsigned int file_id) const;
  Succeeded write_listmode_cache_file(unsigned int file_id) const;

  unsigned int num_cache_files;
  mutable std::vector<double> end_time_per_batch;
};

END_NAMESPACE_STIR

//#include "stir/recon_buildblock/PoissonLogLikelihoodWithLinearModelForMean.inl"

#endif