SamplingGar2.h

Go to the documentation of this file.

#ifndef SAMPLINGGAR2_H
#define SAMPLINGGAR2_H
 
#include "CgemDigitizerSvc/DriftAndAvalanche.h"
#include "CgemGeomSvc/ICgemGeomSvc.h"
#include "CgemDigitizerSvc/IndexGar.h"
 
#include <string>
#include <vector>
 
#include "TF1.h"
 
class G4Svc;
//typedef std::map<Index, vector<int> > HitHistMap;
// maybe dont need to inherit from that? especially as the method to use this class has drastically changed
 
class SamplingGar2 : public DriftAndAvalanche {
public:
    
    SamplingGar2();
    ~SamplingGar2();
 
    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;}
 
    //const std::map<Index, vector<int> > & getMultiElectronMap() const {return m_multiElectronMap;}
    void setMultiElectronMapAddr(HitHistMap *address) { m_pMultiElectronMap = address; } // OK since Wangll said this type feels better.
                                                                                                           //it will be cleared everytime setIonElectrons() is called.
    
    //begin migrate from IndGar1
    void setNgapsSect(int n) {m_Ngaps_microSector=n;}
    void setGapSizeSect(double size) {m_gap_microSector=size;}
    void setGapShiftSect(vector<double> shift)
    {
    m_gapShift_microSector[0][0]=shift[0];
    m_gapShift_microSector[0][1]=shift[1];
    m_gapShift_microSector[1][0]=shift[2];
    m_gapShift_microSector[1][1]=shift[3];
    m_gapShift_microSector[2][0]=shift[4];
    m_gapShift_microSector[2][1]=shift[5];
    }
    void setMicroSectorWidthRad(vector<double> width)
    {
        m_microSector_width[0][0]=width[0];
        m_microSector_width[0][1]=width[1];
        m_microSector_width[1][0]=width[2];
        m_microSector_width[1][1]=width[3];
        m_microSector_width[2][0]=width[4];
        m_microSector_width[2][1]=width[5];
    }
    //end migrate from IndGar1 
 
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; */
    IndexGar pos2Index(double X, double Y, double Z);
    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);// not used
    void saveElectron(double phi, double z, double t); //post Sampling processing phase: SAVE and fill to hist.
    /* 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;
 
    HitHistMap *m_pMultiElectronMap;
    int m_layer;
 
    //begin migrate from indGar1
    int    m_Ngaps_microSector;
    double m_gapShift_microSector[3][2];
    double m_microSector_width[3][2];
    double m_gap_microSector;
    bool inMicroSectorGap(double phi, int layer);
    //end migrate from IndGar1
};
 
 
 
#endif