CameraRead.h

Go to the documentation of this file.

#ifndef __CameraRead__
#define __CameraRead__
 
#include "CameraConfig.h"
#include "Rotation.h"
#include <TMath.h>
#include <TChain.h>
#include <TH2.h>
 
class CameraRead: public TChain, public Rotation{
  
 public:
  
 
  CameraRead(const string aFilePattern, const string aName);
 
 
  virtual ~CameraRead(void);  
 
  inline int GetEntry(Long64_t entry = 0, Int_t getall = 0){
    int ret = (int)TChain::GetEntry(entry, getall);
    Rotation::SetAlphaBetaGamma(rot_alpha, rot_beta, rot_gamma);
    return ret;
  };
 
 
  bool SetTime(const ULong64_t aTime);
 
  void GetSortedPixelIndex(int &aPixIndexY, int &aPixIndexZ, const int aPixIndex, const string aSortMethod="STANDARD");
 
 
  inline int GetPixelValue(const CAMERA_MAPTYPE aMapType, const int aPixIndexY, const int aPixIndexZ){
    return cam_map[aMapType]->GetBinContent(aPixIndexY+1,aPixIndexZ+1);
  };
 
 
  inline int GetPixelError(const CAMERA_MAPTYPE aMapType, const int aPixIndexY, const int aPixIndexZ){
    return cam_map[aMapType]->GetBinError(aPixIndexY+1,aPixIndexZ+1);
  };
 
 
  inline int GetAmplitudeNbits(void){ return cam_nbits; };
    
 
  inline int GetPixelAmplitudeMax(void){ return pow(2,cam_nbits); };
    
 
  inline double GetSizeX(void){ return cam_xsize; };
    
 
  inline double GetSizeY(void){ return cam_ysize; };
    
 
  inline double GetSizeZ(void){ return cam_zsize; };
    
 
  inline ULong64_t GetTime(void){ return cam_time; };
    
 
  inline ULong64_t GetTimeMinimum(void){ return TChain::GetMinimum("cam_time"); };
    
 
  inline ULong64_t GetTimeMaximum(void){ return TChain::GetMaximum("cam_time"); };
    
 
  inline UInt_t GetTimeResolution(void){ return cam_dt; };
    
 
  inline UInt_t GetTimeResolutionMinimum(void){ return TChain::GetMinimum("cam_dt"); };
    
 
  inline UInt_t GetTimeResolutionMaximum(void){ return TChain::GetMaximum("cam_dt"); };
    
 
  inline UInt_t GetNy(void){ return cam_map[pixamplitude]->GetNbinsX(); };
    
 
  inline UInt_t GetNz(void){ return cam_map[pixamplitude]->GetNbinsY(); };
    
 
  inline double GetPhotonResolutionY(void){ return cam_photon_resy; };
    
 
  inline double GetPhotonResolutionZ(void){ return cam_photon_resz; };
    
 
  inline TH2S* GetMap(const CAMERA_MAPTYPE aMapType=pixamplitude){ return cam_map[aMapType]; };
 
 
  inline TH2F* GetGainMap(void){ return cam_gain; };
 
 
  inline int GetHitN(void){ return cam_hitn; };
 
 
  inline int GetHitSourceIndex(const UInt_t aHitIndex){ return cam_hitsrc[aHitIndex]; };
 
 
  inline int GetHitParticleIndex(const UInt_t aHitIndex){ return cam_hitastro[aHitIndex]; };
 
 
  inline double GetHitY(const UInt_t aHitIndex){ return cam_hity[aHitIndex]; };
 
 
  inline double GetHitZ(const UInt_t aHitIndex){ return cam_hitz[aHitIndex]; };
 
 
  inline void SetThreshold(const double aThreshold){ cam_threshold = aThreshold; };
 
 
  inline double GetThreshold(void){ return cam_threshold; };
 
 
  TH2S* GetMapThreshold(TH2S *aAmplitudeThresholdMap);
 
 private:
 
  // file content
  int cam_nbits;              
  double cam_xsize;           
  double cam_ysize;           
  double cam_zsize;           
  double cam_photon_resy;     
  double cam_photon_resz;     
  ULong64_t cam_time;         
  UInt_t cam_dt;              
  int cam_hitn;               
  int cam_hitsrc[CAMERA_NHITMAX];
  int cam_hitastro[CAMERA_NHITMAX];
  double cam_hity[CAMERA_NHITMAX];
  double cam_hitz[CAMERA_NHITMAX];
  TH2S *cam_map_proc;         
  TH2S *cam_map[pixntype];    
  TH2F *cam_gain;             
  double cam_threshold;       
 
  void ApplyThreshold(TH2S *aAmplitudeThresholdMap);
 
 
  ClassDef(CameraRead,0)
};
 
#endif