InputStreamFromROOTFile.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2015, 2016 University of Leeds
    Copyright (C) 2016, 2021, 2020, 2021 UCL
    Copyright (C) 2018 University of Hull
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0
 
    See STIR/LICENSE.txt for details
*/
 
#ifndef __stir_IO_InputStreamFromROOTFile_H__
#define __stir_IO_InputStreamFromROOTFile_H__
 
#include "stir/shared_ptr.h"
#include "stir/Succeeded.h"
#include "stir/listmode/CListRecordROOT.h"
#include "stir/RegisteredObject.h"
#include "stir/error.h"
 
// forward declaration of ROOT's TChain
class TChain;
class TBranch;
 
START_NAMESPACE_STIR


 
class InputStreamFromROOTFile : public RegisteredObject<InputStreamFromROOTFile>
{
public:
  typedef std::vector<long long int>::size_type SavedPosition;

  InputStreamFromROOTFile();
 
#if 0 // disabled as not used
    InputStreamFromROOTFile(std::string filename,
                            std::string chain_name,
                            bool exclude_scattered, bool exclude_randoms,
                            float low_energy_window, float up_energy_window,
                            int offset_dets);
#endif
 
  ~InputStreamFromROOTFile() override
  {}
  virtual Succeeded get_next_record(CListRecordROOT& record) = 0;
  inline Succeeded reset();
  virtual Succeeded set_up(const std::string& header_path);
  inline SavedPosition save_get_position();
  inline Succeeded set_get_position(const SavedPosition&);
  inline std::vector<unsigned long int> get_saved_get_positions() const;
  inline void set_saved_get_positions(const std::vector<unsigned long int>&);
  inline unsigned long int get_total_number_of_events() const;
 
  inline std::string get_ROOT_filename() const;

  virtual int get_num_rings() const = 0;
  virtual int get_num_dets_per_ring() const = 0;
  virtual int get_num_axial_blocks_per_bucket_v() const = 0;
  virtual int get_num_transaxial_blocks_per_bucket_v() const = 0;
  inline int get_num_axial_crystals_per_block_v() const;
  inline int get_num_transaxial_crystals_per_block_v() const;
  virtual int get_num_axial_crystals_per_singles_unit() const = 0;
  virtual int get_num_trans_crystals_per_singles_unit() const = 0;

  inline int get_num_virtual_axial_crystals_per_block() const;
  inline int get_num_virtual_transaxial_crystals_per_block() const;
  void set_num_virtual_axial_crystals_per_block(int);
  void set_num_virtual_transaxial_crystals_per_block(int);

  inline float get_low_energy_thres() const;
  inline float get_up_energy_thres() const;

  inline void set_singles_readout_depth(int);
 
  inline void set_input_filename(const std::string&);
 
  inline void set_chain_name(const std::string&);
 
  inline void set_exclude_true_events(bool);
 
  inline void set_exclude_scattered_events(bool);
 
  inline void set_exclude_unscattered_events(bool);
 
  inline void set_exclude_random_events(bool);
 
#ifdef STIR_ROOT_ROTATION_AS_V4
  inline void set_detectors_offset(int);
#endif
 
  inline void set_low_energy_window(float);
 
  inline void set_upper_energy_window(float);
  inline void set_optional_ROOT_fields(bool);
 
  void set_crystal_repeater_x(int);
  void set_crystal_repeater_y(int);
  void set_crystal_repeater_z(int);
 
protected:
  void set_defaults() override;
  void initialise_keymap() override;
  bool post_processing() override;

  std::string filename;
  unsigned long int starting_stream_position;
  unsigned long int nentries;
  unsigned long int current_position;
  std::vector<unsigned long int> saved_get_positions;
  std::string chain_name;
  bool read_optional_root_fields;


  int crystal_repeater_x;
  int crystal_repeater_y;
  int crystal_repeater_z;
  //}


  TChain* stream_ptr;
  // note: should be ROOT's Int_t, Double_t and Float_t types, but those
  // are only defined when including ROOT .h files, which we want to avoid
  // here, as it creates a public dependency on the ROOT .h files
  // checking https://github.com/root-project/root/blob/8695045aeff4b2e606a5febdcd58a0a7e7f6c7af/core/base/inc/RtypesCore.h
  // we can use int32_t, float and double instead
  std::int32_t eventID1, eventID2, runID, sourceID1, sourceID2;
  double time1, time2;
  float energy1, energy2, rotation_angle, sinogramS, sinogramTheta, axialPos;
  int32_t comptonphantom1, comptonphantom2;
  float globalPosX1, globalPosX2, globalPosY1, globalPosY2, globalPosZ1, globalPosZ2;
  float sourcePosX1, sourcePosX2, sourcePosY1, sourcePosY2, sourcePosZ1, sourcePosZ2;


  TBranch* br_time1 = nullptr;
  TBranch* br_time2 = nullptr;
  TBranch* br_eventID1 = nullptr;
  TBranch* br_eventID2 = nullptr;
  TBranch* br_energy1 = nullptr;
  TBranch* br_energy2 = nullptr;
  TBranch* br_comptonPhantom1 = nullptr;
  TBranch* br_comptonPhantom2 = nullptr;
  // Optional Branch variables. To be used if read_optional_root_fields is true.
  TBranch* br_axialPos = nullptr;
  TBranch* br_globalPosX1 = nullptr;
  TBranch* br_globalPosX2 = nullptr;
  TBranch* br_globalPosY1 = nullptr;
  TBranch* br_globalPosY2 = nullptr;
  TBranch* br_globalPosZ1 = nullptr;
  TBranch* br_globalPosZ2 = nullptr;
  TBranch* br_rotation_angle = nullptr;
  TBranch* br_runID = nullptr;
  TBranch* br_sinogramS = nullptr;
  TBranch* br_sinogramTheta = nullptr;
  TBranch* br_sourceID1 = nullptr;
  TBranch* br_sourceID2 = nullptr;
  TBranch* br_sourcePosX1 = nullptr;
  TBranch* br_sourcePosX2 = nullptr;
  TBranch* br_sourcePosY1 = nullptr;
  TBranch* br_sourcePosY2 = nullptr;
  TBranch* br_sourcePosZ1 = nullptr;
  TBranch* br_sourcePosZ2 = nullptr;


  int num_virtual_axial_crystals_per_block;
  int num_virtual_transaxial_crystals_per_block;

  bool exclude_nonrandom;
  bool exclude_scattered;
  bool exclude_unscattered;
  bool exclude_randoms;
  bool check_energy_window_information;
  float low_energy_window;
  float up_energy_window;
#ifdef STIR_ROOT_ROTATION_AS_V4
  int offset_dets;
#endif
  int singles_readout_depth;
 
  // This member will try to give to the continuous time register in GATE
  // data, a finite least significant bit.
  double least_significant_clock_bit;

  float get_energy1_in_keV() const
  {
    return energy1 * 1e3;
  };
  float get_energy2_in_keV() const
  {
    return energy2 * 1e3;
  };

  bool check_brentry_randoms_scatter_energy_conditions(long long int brentry);

  void GetEntryCheck(const int ret)
  {
    if (ret > 0)
      return;
    error(ret == 0 ? "Entry is null." : "ROOT I/O error.");
  };
};
 
END_NAMESPACE_STIR
 
#include "stir/IO/InputStreamFromROOTFile.inl"
 
#endif