sipmMC.h

Go to the documentation of this file.

#ifndef sipmMC_h
#define sipmMC_h

#include "HitMatrix.h"
#include "PhotonList.h"

#include <TROOT.h>
#include <TRandom3.h>
#include <TGraph.h>
#include <TH1.h>
#include <TH2.h>
#include <TF1.h>
#include <TGraphErrors.h>
#include <stdlib.h>
#include <vector>
#include <string>

using std::vector;
using std::cout;
using std::endl;
using std::string;

struct GCharge 
{
        double all;
        double pe;
        double dr;
        double ct;
        double ap;
        double enf;
        double en;
};

class sipmMC{

        public:

                sipmMC();
                ~sipmMC();

                int             NpixX;                                          
                int             NpixY;                                          
                double          xSipm;                                          
                double          ySipm;                                          
                double          tau_recovery;                                   
                double          PDE;                                            
                double          Pxt;                                            
                double          Pap_s;                                          
                double          Pap_f;                                          
                double          tau_ap_s;                                       
                double          tau_ap_f;                                       
                double          tau_dr;                                         
                double          gain;                                           
                double          ENF;                                            
                double          EN;                                             
                double          signalAmp;                                      
                double          noiseRMS;                                       
                double          jitter;                                         
                double          Generate( PhotonList photons );                 
                int             GetParaFile( const char* filename );            
                void            SetGeometry( string Geometry );                 
                void            SetGeometry( TH2I* hgeometry );                 
                void            SetPulseShape( double Tau1, double Tau2 );      
                void            SetPulseShape( TF1* pulse_shape );              
                void            UpdatePulseShape();                             
                void            SetSampling( double Sampling );                 
                void            SetCutoff( double Cutoff );                     
                void            SetGate( double Gate, bool gateCut=true );      
                void            SetPreGate( double preGate );                   
                void            SetSpectralSensitivity( TGraph* spect );        
                void            SetSpectralSensitivity( const char* file );     
                TGraph*         GetWaveform();                                  
                double          GetCharge(){ return charge.all; };
                GCharge         GetChargeDecomp(){ return charge; };
                double          GetGate(){ return gate; };
                TF1*            GetPulseShape(){ return f_pulse_shape; };
                HitMatrix*      GetHitMatrix(){ return hitMatrix; };
                int             GetNpix(){ return Npix; };
                double          GetSampling(){ return sampling; };

        private:

                TF1*            f_pulse_shape;
                TF1*            f_pulse_shape_intern;
                double          pulse_shape_func_max;
                double          pulse_shape_func_range;
                bool            update_pulse_shape;

                TGraph*         g_spectral;

                int             Npix;
                HitMatrix*      hitMatrix;
                TGraph*         g_waveform;
                TGraph          g_pulse_charge;
                double          pulseIntegral;
                int             n_pulse_samples;
                GCharge         charge;
                double          gate;
                double          pre_gate;

                TRandom3        r;
                vector<double>  hit;
                PhotonList      photonList;
                TH2I*           h_geometry;
                double          sampling;
                double          cutOff;
                double          tau1, tau2;

                void            Reset();
                void            ImportPhotons( PhotonList photons );
                void            InitHitMatrix();
};

#endif