InductionGar2.h

Go to the documentation of this file.

#ifndef INDUCTIONGAR2_H
#define INDUCTIONGAR2_H
 
#include "CgemDigitizerSvc/ConvolveWithConst.h"
#include "CgemDigitizerSvc/IndexGar.h"
#include "CgemDigitizerSvc/Induction.h"
#include "CgemGeomSvc/ICgemGeomSvc.h"
 
#include <string>
#include <vector>
#include <set>
#include "TCanvas.h"
#include "TFile.h"
#include "TH1D.h"
 
class G4Svc;
 
//typedef std::map<Index, vector<int> > HitHistMap;
 
class CTF2 { // as Convolution_Tbranch_fft
public:
    ConvolveWithConst *conv;
    std::vector<double> TBranch;
 
public:
    CTF2();
    ~CTF2();
    TH1D Convolution_Tbranch_fft(const double *Input_Curr_plot_001);
};
 
class CEF2 { // 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:
    CEF2();
    ~CEF2();
    TH1D Convolution_Ebranch_fft(const double *Input_Curr_plot_001);
};
 
class InductionGar2 : public Induction {
public:
    InductionGar2();
    ~InductionGar2();
 
    void init(ICgemGeomSvc *geomSvc, double magConfig);
 
    void setDebugOutput(bool debugOutput) { m_debugOutput = debugOutput; }
 
    struct PVectorXYZT;
 
    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){};
    void setMultiElectrons(int layer, const HitHistMap &hitmap, const PVectorXYZT *debug_ref_electrons = 0);
 
    /* 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 setScaleSignalX(double ScaleSignalX) {m_ScaleSignalX = ScaleSignalX;}
    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] {index of ID, Q}
 
    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
 
    CTF2 ctf;
    CEF2 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) const;
    void conv1PerGrid_fft(int Save_Grid, double *hist_bin_Content,
                          const std::vector<int> &hitlist, int layer, int axis) const;
    void conv1PerGrid_legacy(int gridX, int gridV, int indexOID, double *hist_bin_Content,
                             const std::vector<int> &elecHitHist, int layer, int axis) const;
    void conv1PerGrid_fft(int gridX, int gridV, int indexOID, double *hist_bin_Content,
                          const std::vector<int> &elecHitHist, int layer, int axis) const;
 
    void calcMapQFromHitHistMap(const HitHistMap &histmap, int layer, std::map<int, double> mapQ[2][2]) const;
    void calcSaveSheetXVFromMapQ(vector<int> &Save_Sheetx, vector<int> &Save_Sheetv, std::map<int, double> const mapQ[2][2]) const;
    void calcStripCurrent(double *strip_current, double &timeFirstHit, const HitHistMap &histmap,
                          int layer, int req_sheetid, int req_stripid, int xvaxis) const;
    void calcStripCurrent(double *strip_current, double &timeFirstHit, const std::map<IndexGar,std::vector<double> > &histFFTmap,const HitHistMap &histmap, int layer, int req_sheetid, int req_stripid, int xvaxis) const ;
    void calcHitHistFftMap(std::map<IndexGar,std::vector<double> > &histFFTMap,const HitHistMap &histmap)const;
 
    double m_QinGausSigma[2];
    std::set<int> m_deadStrip[3][2][2];//layer sheet XVview
    double m_ScaleSignalX;
    bool isDeadStrip(int layer, int sheet, int XVview, int strip);
 
};
 
struct InductionGar2::PVectorXYZT {
    const std::vector<Float_t> *x, *y, *z, *t;
};
 
#endif