Camera.h

Go to the documentation of this file.

#ifndef __Camera__
#define __Camera__
 
#include "CameraConfig.h"
#include "Rotation.h"
#include <TRandom3.h>
#include <TF1.h>
#include <TH2.h>
#include <TTree.h>
#include <TFile.h>
#include <TMath.h>
 
class Camera: public Rotation {
  
 public:
  
 
  Camera(const int aNbits=14, const int aNy=256, const int aNz=256);
 
 
  virtual ~Camera(void);  
 
  void WriteMap(const string aOutFileName="./mymaps.root");
 
 
  inline void SetSize(const double aXsize=1.0, const double aYsize=1.0, const double aZsize=1.0){
    cam_xsize=aXsize;
    cam_ysize=aYsize;
    cam_zsize=aZsize;
  };
 
 
  inline double GetXsize(void){ return cam_xsize; };
 
 
  inline double GetYsize(void){ return cam_ysize; };
 
 
  inline double GetZsize(void){ return cam_zsize; };
 
 
  inline void AddPixelAmplitudeValue(const int aPixIndexY, const int aPixIndexZ, const int aValue){
    cam_map[pixamplitude]->SetBinContent(aPixIndexY+1,aPixIndexZ+1,TMath::Min(cam_ampmax,(int)cam_map[pixamplitude]->GetBinContent(aPixIndexY+1,aPixIndexZ+1)+aValue));
  };
 
 
  inline void SetPixelValue(const CAMERA_MAPTYPE aMapType, const int aPixIndexY, const int aPixIndexZ, const int aValue, const double aValueErr=0.0){
    cam_map[aMapType]->SetBinError(aPixIndexY+1,aPixIndexZ+1,aValueErr);
    cam_map[aMapType]->SetBinContent(aPixIndexY+1,aPixIndexZ+1,aValue);
  };
 
 
  inline int GetPixelValue(const CAMERA_MAPTYPE aMapType, const int aPixIndexY, const int aPixIndexZ){
    return cam_map[aMapType]->GetBinContent(aPixIndexY+1,aPixIndexZ+1);
  };
 
 
  inline double GetPixelError(const CAMERA_MAPTYPE aMapType, const int aPixIndexY, const int aPixIndexZ){
    return cam_map[aMapType]->GetBinError(aPixIndexY+1,aPixIndexZ+1);
  };
 
 
  inline int GetMapNy(void){
    return cam_map[pixamplitude]->GetNbinsX();
  };
 
 
  inline int GetMapNz(void){
    return cam_map[pixamplitude]->GetNbinsY();
  };
 
 
  inline void ResetMap(const CAMERA_MAPTYPE aMapType){
    cam_map[aMapType]->Reset();
  };
 
 
  void GenAmplitudeNoiseMap(void);
 
 
  void SetFrozenBrightY(const int aPixIndexY);
   
 
  void SetFrozenBrightZ(const int aPixIndexZ);
   
 
  void SetRandomPixelBright(const int aN);
   
 
  void SetRandomPixelDead(const int aN);
   
 
  void SetName(const string aName);
  
 
  inline string GetName(void){ return cam_name; };
 
 
  inline void SetTimeResolution(const UInt_t aTimeResolution=100){
    cam_dt=aTimeResolution;
  };
  
 
  inline UInt_t GetTimeResolution(void){ return cam_dt; };
 
 
  inline void SetTime(const ULong64_t aTime=0){
    cam_time=aTime;
  };
  
 
  inline ULong64_t GetTime(void){ return cam_time; };
 
 
  inline void SetPhotonResolution(const double aPixelResY=1.0, const double aPixelResZ=1.0){
    cam_photon_gaus[0]->SetParameters(1.0/sqrt(2*TMath::Pi())/aPixelResY*(double)GetMapNy(),
                      0.0,
                      aPixelResY/(double)GetMapNy());
    cam_photon_gaus[1]->SetParameters(1.0/sqrt(2*TMath::Pi())/aPixelResZ*(double)GetMapNz(),
                      0.0,
                      aPixelResZ/(double)GetMapNz());
  };
 
 
  inline void SetCosmicRayEnergyLoss(const double aEnergyLoss=1.0){
    cam_cosmic_pixenergy = aEnergyLoss;
  };
 
 
  void AddPhoton(const double aEnergy, const double aY, const double aZ,
        const int aSourceIndex=0, const int aParticleIndex=0);
 
 
  void AddCosmicRay(const double aEnergy, const double aY, const double aZ,
            const double aCosTheta, const double aSinTheta,
            const double aCosPhi, const double aSinPhi,
            const int aSourceIndex=0, const int aParticleIndex=0);
 
 
  void SetMap(const CAMERA_MAPTYPE aMapType, TH2S *aMap);
 
 
  void SetPixelDistributions(const CAMERA_MAPTYPE aMapType,
                             double aPar1=-1.0, double aPar2=-1.0,
                             double aPar3=-1.0, double aPar4=-1.0);
 
 
  void SetGainUniform(const double aGain);
 
 
  void SetGain(TH2F* aGainMap);
  
 
  void TreeInit(void);
  
 
  int TreeFill(void);
  
 
  inline void TreeReset(void){
    if(cam_tree!=NULL) return cam_tree->Reset();
    return;
  };
  
 
  inline int TreeWrite(void){
    if(cam_tree!=NULL) return cam_tree->Write();
    return 0;
  };
  
 
  inline void TreeDelete(void){
    if(cam_tree!=NULL) delete cam_tree;
    cam_tree=NULL;
    return;
  };
 
 
  inline TH2S* GetMap(const CAMERA_MAPTYPE aMapType){ return cam_map[aMapType];  };
 
 protected:
  TTree *cam_tree;            
  TRandom3 *randgen;          
  
 private:
 
  string cam_name;            
  int cam_nbits;              
  int cam_ampmax;             
  double cam_xsize;           
  double cam_ysize;           
  double cam_zsize;           
  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[pixntype];    
  TH2F *cam_gain;             
 
  TF1 *cam_photon_gaus[2];    
  double cam_photon_resy;     
  double cam_photon_resz;     
  double cam_cosmic_pixenergy;
  
  ClassDef(Camera,0)
};
 
#endif