ProjMatrixByBin.h

Go to the documentation of this file.

#ifndef __stir_recon_buildblock_ProjMatrixByBin_H__
#define __stir_recon_buildblock_ProjMatrixByBin_H__

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000-2009, Hammersmith Imanet Ltd
    Copyright (C) 2013, 2015, 2022 University College London
    Copyright (C) 2016, University of Hull
 
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/
 
#include "stir/RegisteredObject.h"
#include "stir/ParsingObject.h"
#include "stir/recon_buildblock/ProjMatrixElemsForOneBin.h"
#include "stir/recon_buildblock/DataSymmetriesForBins.h"
#include "stir/shared_ptr.h"
#include "stir/VectorWithOffset.h"
#include "stir/TimedObject.h"
#include "stir/VoxelsOnCartesianGrid.h"
#include "stir/numerics/FastErf.h"
#include <cstdint>
//#include <map>
#include <unordered_map>
#ifdef STIR_OPENMP
#  include <omp.h>
#endif
 
START_NAMESPACE_STIR
 
/* TODO
class ProjMatrixElemsForOneViewgram;
class SubsetInfo;
*/
 
class Bin;

class ProjMatrixByBin : public RegisteredObject<ProjMatrixByBin>, public TimedObject
{
public:
  ~ProjMatrixByBin() override {}


  virtual void set_up(const shared_ptr<const ProjDataInfo>& proj_data_info_ptr,
                      const shared_ptr<const DiscretisedDensity<3, float>>& density_info_ptr // TODO should be Info only
                      )
      = 0;
 
  virtual ProjMatrixByBin* clone() const = 0;

  inline const DataSymmetriesForBins* get_symmetries_ptr() const;
  inline const shared_ptr<DataSymmetriesForBins> get_symmetries_sptr() const;


  inline void get_proj_matrix_elems_for_one_bin(ProjMatrixElemsForOneBin&, const Bin&) const;
 
#if 0
  // TODO
  virtual void write_to_file_by_bin(
    const char * const file_name_without_extension) const;
#endif
  // TODO implement this one at some point ?
  /*
  virtual void write_to_file_by_voxel(
  const char * const file_name_without_extension);
  */
 
  // void set_maximum_cache_size(const unsigned long size){;}
  /* TODO
  void set_subset_usage(const SubsetInfo&, const int num_access_times);
  */
  void enable_cache(const bool v = true);
  void store_only_basic_bins_in_cache(const bool v = true);
 
  bool is_cache_enabled() const;
  bool does_cache_store_only_basic_bins() const;
 
  // void reserve_num_elements_in_cache(const std::size_t);
  void clear_cache() const;
 
protected:
  shared_ptr<DataSymmetriesForBins> symmetries_sptr;


  ProjMatrixByBin();

  virtual void calculate_proj_matrix_elems_for_one_bin(ProjMatrixElemsForOneBin&) const = 0;



  void set_defaults() override;

  void initialise_keymap() override;

  bool post_processing() override;

 
  bool cache_disabled;
  bool cache_stores_only_basic_bins;
  bool tof_enabled;

  Succeeded get_cached_proj_matrix_elems_for_one_bin(ProjMatrixElemsForOneBin&) const;

  shared_ptr<const VoxelsOnCartesianGrid<float>> image_info_sptr;

  shared_ptr<const ProjDataInfo> proj_data_info_sptr;

  void cache_proj_matrix_elems_for_one_bin(const ProjMatrixElemsForOneBin&) const;
 
private:
  typedef std::uint64_t CacheKey;
  // note: sum needs to be less than  64 - 3  (for the 3 sign bits)
  const CacheKey tang_pos_bits = 12;
  const CacheKey axial_pos_bits = 28;
  const CacheKey timing_pos_bits = 20;
  //  typedef std::map<CacheKey, ProjMatrixElemsForOneBin>   MapProjMatrixElemsForOneBin;
  typedef std::unordered_map<CacheKey, ProjMatrixElemsForOneBin> MapProjMatrixElemsForOneBin;
  typedef MapProjMatrixElemsForOneBin::iterator MapProjMatrixElemsForOneBinIterator;
  typedef MapProjMatrixElemsForOneBin::const_iterator const_MapProjMatrixElemsForOneBinIterator;

  mutable VectorWithOffset<VectorWithOffset<MapProjMatrixElemsForOneBin>> cache_collection;
#ifdef STIR_OPENMP
  mutable VectorWithOffset<VectorWithOffset<omp_lock_t>> cache_locks;
#endif

  // KT 15/05/2002 not static anymore as it uses cache_stores_only_basic_bins
  CacheKey cache_key(const Bin& bin) const;

  void enable_tof(const shared_ptr<const ProjDataInfo>& proj_data_info_sptr, const bool v = true);

  float gauss_sigma_in_mm;
  float r_sqrt2_gauss_sigma;

  inline void apply_tof_kernel(ProjMatrixElemsForOneBin& probabilities) const;

  inline float get_tof_value(const float d1, const float d2) const;

  FastErf erf_interpolation;
};
 
END_NAMESPACE_STIR
 
#include "stir/recon_buildblock/ProjMatrixByBin.inl"
 
#endif // __ProjMatrixByBin_H__