InductionGar.h

Go to the documentation of this file.

#ifndef INDUCTIONGAR_H
#define INDUCTIONGAR_H
 
#include "CgemGeomSvc/ICgemGeomSvc.h"
#include "CgemDigitizerSvc/Induction.h"
#include "CgemDigitizerSvc/ConvolveWithConst.h"
 
#include <vector>
#include <set>
#include <string>
#include "TH1D.h"
#include "TFile.h"
 
class G4Svc;
 
class CTF{ // as Convolution_Tbranch_fft
public:
     ConvolveWithConst *conv;
     std::vector<double> TBranch;
public:
     CTF();
     ~CTF();
     TH1D Convolution_Tbranch_fft(const double *Input_Curr_plot_001);
 
};
 
class CEF{ // as Convolution_Ebranch_fft ; 
     //didnot wished to play with this, yet too lazy to switch to a ConvFuncFft(double (* func)(double*), min=0,max=1000) version
public:
     ConvolveWithConst *conv;
     std::vector<double> EBranch;
public:
     CEF();
     ~CEF();
     TH1D Convolution_Ebranch_fft(const double *Input_Curr_plot_001);
};
 
class InductionGar: public Induction {
public:
     InductionGar();
     ~InductionGar();
 
     void init(ICgemGeomSvc* geomSvc, double magConfig);
 
     void setDebugOutput(bool debugOutput){m_debugOutput = debugOutput;}
 
     void setMultiElectrons(int layer, int nElectrons, const std::vector<Float_t>&  x, const std::vector<Float_t>& y, const std::vector<Float_t> &z, const std::vector<Float_t> &t);
 
     /* output info of fired strips */
     int    getNXstrips() const {return m_nXstrips;}
     int    getNVstrips() const {return m_nVstrips;}
     int    getXstripSheet(int n) const {return m_xstripSheet[n];}
     int    getXstripID(int n) const {return m_xstripID[n];}
     int    getVstripSheet(int n) const {return m_vstripSheet[n];}
     int    getVstripID(int n) const {return m_vstripID[n];}
     double getXstripQ(int n) const {return m_xstripQ[n];}
     double getVstripQ(int n) const {return m_vstripQ[n];}
     double getXstripT(int n) const {return m_xstripT_Branch[n];}
     double getVstripT(int n) const {return m_vstripT_Branch[n];}
     double getXstripT_Branch(int n) const {return m_xstripT_Branch[n];}
     double getVstripT_Branch(int n) const {return m_vstripT_Branch[n];}
     double getXstripQ_Branch(int n) const {return m_xstripQ_Branch[n];}
     double getVstripQ_Branch(int n) const {return m_vstripQ_Branch[n];}
     double getXfirstT(int n) const {return m_xTfirst[n];}
     double getVfirstT(int n) const {return m_vTfirst[n];}
 
     void setLUTFilePath(std::string path){m_LUTFilePath = path;}
     void setV2EfineFile(std::string path){m_V2EfineFile = path;}
     void setVsampleDelay(double delay){sample_delay = delay;}
     void setStoreFlag(bool flag){storeFlag = flag;}
     void setSaturation(bool flag) {m_saturation=flag;}
 
     void setNgapsSect(int n) {m_Ngaps_microSector=n;}
     void setGapSizeSect(double size) {m_gap_microSector=size;}
     void setScaleSignalX(double ScaleSignalX) {m_ScaleSignalX = ScaleSignalX;}
     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];
 
     }
     void setQinGausSigma(vector<double> sigma)
     {
         m_QinGausSigma[0]=sigma[0];
         m_QinGausSigma[1]=sigma[1];
     }
private:
     ICgemGeomSvc* m_geomSvc;
     double m_magConfig;        /* magnetic field */
     bool m_debugOutput;
     bool m_saturation;
 
     std::string m_LUTFilePath;
     std::string m_V2EfineFile;
     /* fired strips */
     int m_nXstrips;
     int m_nVstrips;
     std::vector<int> m_xstripSheet;
     std::vector<int> m_xstripID;
     std::vector<int> m_vstripSheet;
     std::vector<int> m_vstripID;
     std::vector<double> m_xstripQ;
     std::vector<double> m_vstripQ;
     std::vector<double> m_xstripT_Branch;
     std::vector<double> m_vstripT_Branch;
     std::vector<double> m_xstripQ_Branch;
     std::vector<double> m_vstripQ_Branch;
     std::vector<double> m_xTfirst;//time when first electron leave 3rd gem
     std::vector<double> m_vTfirst;
 
     std::map<int, double>  m_mapQ[2][2];//[nSheet][XV-view]
 
     double RatioX[3][5][5][4]; // [layer][bin-x][bin-y][Index of IDx]
     double RatioV[3][5][5][4]; // [layer][bin-x][bin-y][Index of IDv]
 
     //TH1D * SignalX[3][5][5][4]; // [layer][bin-x][bin-y][Index of IDx]
     //TH1D * SignalV[3][5][5][4]; // [layer][bin-x][bin-y][Index of IDv]
 
     double SignalX[3][5][5][4][100]; // [layer][bin-x][bin-y][Index of IDx]
     double SignalV[3][5][5][4][100]; // [layer][bin-x][bin-y][Index of IDv]
 
     double T_thr_V[3][2][2][1395];//[layer][sheet][XV-view][ID]
     double E_thr_V[3][2][2][1395];//[layer][sheet][XV-view][ID]
     double QDC_slope[3][2][2][1395];//[layer][sheet][XV-view][ID]
     double QDC_const[3][2][2][1395];//[layer][sheet][XV-view][ID]
     double Qsaturation[3][2][2][1395];
 
     double Vref[3][2][2][1395];//[layer][sheet][XV-view][ID]
     double toE_slope[3][2][2][1395];//[layer][sheet][XV-view][ID]
     double toE_const[3][2][2][1395];//[layer][sheet][XV-view][ID]
 
     double sample_delay;//ns
     bool   storeFlag;
     double VQ_slope;
     double VQ_const;//V-Q curve
 
     CTF ctf;
     CEF cef;
 
     ConvolveWithConst Signal_ConvolverX[3][5][5][4];//[layer][bin-x][bin-y][Index of IDx]
     ConvolveWithConst Signal_ConvolverV[3][5][5][4];//fft convolver version of signals
 
     void conv1PerGrid_legacy(int Save_Grid, double *hist_bin_Content,
                              const std::vector<int> &hitlist, int layer, int axis);
     void conv1PerGrid_fft(int Save_Grid, double *hist_bin_Content,
                           const std::vector<int> &hitlist, int layer, int axis);
 
     int    m_Ngaps_microSector;
     double m_gapShift_microSector[3][2];
     double m_microSector_width[3][2];
     double m_QinGausSigma[2];
     std::set<int> m_deadStrip[3][2][2];//layer sheet XVview
     double m_gap_microSector;
     double m_ScaleSignalX;
     bool inMicroSectorGap(double phi, int layer);
     bool isDeadStrip(int layer, int sheet, int XVview, int strip);
};
 
#endif