SamplingGar.h

Go to the documentation of this file.

#ifndef SAMPLINGGAR_H
#define SAMPLINGGAR_H
 
#include "CgemGeomSvc/ICgemGeomSvc.h"
#include "CgemDigitizerSvc/DriftAndAvalanche.h"
 
#include <vector>
#include <string>
 
#include "TF1.h"
 
class G4Svc;
 
class SamplingGar: public DriftAndAvalanche {
public:
     SamplingGar();
     ~SamplingGar();
 
     void init(ICgemGeomSvc* geomSvc, double magConfig);
 
     void setIonElectrons(int layer, int nElectrons, std::vector<double> x, std::vector<double> y, std::vector<double> z, std::vector<double> t);
 
     /* output info of multiplied eletrons */
     int    getNelectrons() const {return m_nMulElec;}
     Float_t getX(int n) const {return m_eX[n];}
     Float_t getY(int n) const {return m_eY[n];}
     Float_t getZ(int n) const {return m_eZ[n];}
     Float_t getT(int n) const {return m_eT[n];}
     const std::vector<Float_t> & getXContainer() const {return m_eX;}
     const std::vector<Float_t> & getYContainer() const {return m_eY;}
     const std::vector<Float_t> & getZContainer() const {return m_eZ;}
     const std::vector<Float_t> & getTContainer() const {return m_eT;}
     void setDebugging(bool debugging) {m_debugging = debugging;}
     
     void setGainMultiplier(vector<double> GainMultiplier) 
     {
         m_GainMultiplier[0] = GainMultiplier[0];
         m_GainMultiplier[1] = GainMultiplier[1];
         m_GainMultiplier[2] = GainMultiplier[2];
     }
     void setTransMultiplier(double TransMultiplier) {m_TransMultiplier = TransMultiplier;}
     void setDiffuMultiplier(double DiffuMultiplier) {m_DiffuMultiplier = DiffuMultiplier;}
 
private:
     void clear();
 
     /* /\* region = 0,1,2,3 (drift/transfer1/transfer2/induction) *\/ */
     /* void smearDrift(int layer, int region, double driftD, double& dphi, double& dz, double& dt) const; */
 
     bool readSmearPar();
     bool samplingDrift(int layer, double driftD, int idIon);
     bool samplingTransfer(int layer, int region, int idLastStep); /* region = 1,2 (Transfer1/Transfer2) */
     int  samplingGain(int layer, int region); /* region = 0,1,2 (Drift/Transfer1/Transfer2 */
     bool calMultiE(int layer);
     /* void getDriftPar(int layer, int region, double driftD, double& meanPhi, double& sigmaPhi, */
     /*               double& meanZ, double& sigmaZ, double& meanT, double& sigmaT) const; */
     
     bool m_debugging;
 
     TF1* m_funPolya[3][3];     /* Polya functions */
 
     ICgemGeomSvc* m_geomSvc;
     double m_magConfig;        /* magnetic field */
 
     /* electrons from ionization in drift region */
     int m_nIonE;       /* number of electrons from ionization in drift region */
     std::vector<Float_t> m_vecIonR;
     std::vector<Float_t> m_vecIonPhi;
     std::vector<Float_t> m_vecIonZ;
     std::vector<Float_t> m_vecIonT;
 
     /* electrons after gem foil1 */
     int m_nEgem1;
     std::vector<int>    m_idIon;
     std::vector<Float_t> m_vecGem1dX;
     std::vector<Float_t> m_vecGem1dZ;
     std::vector<Float_t> m_vecGem1dT;
 
     /* electrons after gem foil2 */
     int m_nEgem2;
     std::vector<int>    m_idGem1;
     std::vector<Float_t> m_vecGem2dX;
     std::vector<Float_t> m_vecGem2dZ;
     std::vector<Float_t> m_vecGem2dT;
 
     /* electrons after gem foil3 */
     int m_nEgem3;
     std::vector<int>    m_idGem2;
     std::vector<Float_t> m_vecGem3dX;
     std::vector<Float_t> m_vecGem3dZ;
     std::vector<Float_t> m_vecGem3dT;
 
     /* info of multiplied electrons */
     int m_nMulElec;
     std::vector<Float_t> m_eX;
     std::vector<Float_t> m_eY;
     std::vector<Float_t> m_eZ;
     std::vector<Float_t> m_eT;
 
     /* gain of each gem foil */
     double m_gain_gem[3][3];
     double m_GainMultiplier[3];
     double m_TransMultiplier;
     double m_DiffuMultiplier;
 
     /* smear parameters */
     /* drift region & Gem-1 */
     double m_meanXpar[2];
     double m_sigmaXpar[4];
     double m_meanZpar;
     double m_sigmaZpar[4];
     double m_meanTpar[2];
     double m_sigmaTpar[4];
     double m_transparency_gem1;
 
     /* Transfer1/Gem2 & Transfer2/Gem3 */
     double m_meanX_transf[2];
     double m_sigmaX_transf[2];
     double m_meanZ_transf[2];
     double m_sigmaZ_transf[2];
     double m_meanT_transf[2];
     double m_sigmaT_transf[2];
     double m_transparency_gem2;
     double m_transparency_gem3;
 
     /* Induction */
     double m_meanX_induc;
     double m_sigmaX_induc;
     double m_meanZ_induc;
     double m_sigmaZ_induc;
     double m_meanT_induc;
     double m_sigmaT_induc;
 
};
 
#endif