CgemDigitizerSvc.h

Go to the documentation of this file.

#ifndef CGEMDIGITIZERSVC_H
#define CGEMDIGITIZERSVC_H 
 
#include <CLHEP/Units/PhysicalConstants.h>
#include <CLHEP/Geometry/Point3D.h>
#include <vector>
#include <map>
#include <iostream>
 
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/Property.h"
#include "GaudiKernel/MsgStream.h"
 
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/IInterface.h"
#include "CgemDigitizerSvc/ICgemDigitizerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IIncidentListener.h"
 
#include "GaudiKernel/NTuple.h"
#include "GaudiKernel/INTupleSvc.h"
 
#include "CLHEP/Vector/ThreeVector.h"
 
#include "CgemDigitizerSvc/Ionization.h"
#include "CgemDigitizerSvc/IonizationGar.h"
#include "CgemDigitizerSvc/IonizationGTS.h"
#include "CgemDigitizerSvc/DriftAndAvalanche.h"
#include "CgemDigitizerSvc/SamplingGar.h"
#include "CgemDigitizerSvc/SamplingGTS.h"
#include "CgemDigitizerSvc/SamplingGar2.h"
#include "CgemDigitizerSvc/Induction.h"
#include "CgemDigitizerSvc/InductionGar.h"
#include "CgemDigitizerSvc/InductionGTS.h"
#include "CgemDigitizerSvc/InductionGar2.h"
#include "CgemDigitizerSvc/IndexGar.h"
 
#include "TH1D.h"
#include "TRandom.h"
 
typedef  float Float_t;
 
class CgemDigitizerSvc : public Service, virtual public ICgemDigitizerSvc{
    
public:
     CgemDigitizerSvc(const std::string& name, ISvcLocator* svcloc);
     ~CgemDigitizerSvc();   
 
     virtual StatusCode queryInterface(const InterfaceID& riid, void** ppvUnknown);
     virtual StatusCode initialize();
     virtual StatusCode finalize();
 
     /* particle = 0,1,2,3,4 (e,mu,pi,K,p) */
     /* p: momentum (GeV/c) */
     /* trkPosIn & trkPosOut:  starting & exit positions (x,y,z) of the track segment in drift area */
     StatusCode setTrack(int layer, int particle, int charge, double p, double trkPosIn[], double trkPosOut[]);
     StatusCode setTrack(int layer, std::vector<int>particle, std::vector<int> charge, std::vector<double> p, std::vector<vector<double> > trkPosIn, std::vector<vector<double> > trkPosOut);
     /* 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];}
     // luxl modified code m_xstripQ2->m_xstripQ
     double getXstripQ2(int n) const {return m_xstripQ[n];}//measured Q
     double getVstripQ2(int n) const {return m_vstripQ[n];}
     double getXstripQ(int n) const {return m_xstripQ2[n];}//sum of induced charge simulated
     double getVstripQ(int n) const {return m_vstripQ2[n];}
     double getXstripT(int n) const {return m_xstripT[n];}
     double getVstripT(int n) const {return m_vstripT[n];}
     double getXfirstT(int n) const {return m_xfirstT[n];}
     double getVfirstT(int n) const {return m_vfirstT[n];}
     double getQsaturation(int layer, int sheet, int view, int id) { return Qsaturation[layer][sheet][view][id]; }
 
private:
     void clear();
     void positionToStrips();
 
     void checkMemorySize();
 
     int m_ionModel;
     int m_driftAvaModel;
     int m_inductionModel;
     bool m_garfDebugging;
     bool m_debugInduction;
     int m_magConfig;       /* 0 for without mag, 1 for 1 Tesla */
     std::string m_LUTFilePath;
     double sample_delay;//ns
     vector<double> m_GainMultiplier;
     double m_TransMultiplier;
     double m_DiffuMultiplier;
     double m_ScaleSignalX;
     
     double Qsaturation[3][2][2][1395];
 
     int    m_Ngaps_microSector;
     vector<double> m_gapShift_microSector;
     vector<double> m_microSector_width;
     vector<double> m_QinGausSigma;
     double m_gap_microSector;
     
     bool m_storeFlag;
     bool m_saturation;
     bool m_saveNt;
     bool m_samplingDebugging;
 
     ICgemGeomSvc* m_geomSvc;
     CgemGeoLayer* m_cgemLayer;
     CgemGeoReadoutPlane* m_cgemReadoutPlane;
     Ionization* m_pIon;
     DriftAndAvalanche* m_pDriftAndAva;
     Induction* m_pInduction;
 
     HitHistMap m_hitmap;
 
     /* position and time of multiplied electrons */
     int m_layer;
     int m_nSheet;
     int m_nMultiE;
     const std::vector<Float_t>* m_pmultiEx;
     const std::vector<Float_t>* m_pmultiEy;
     const std::vector<Float_t>* m_pmultiEz;
     const std::vector<Float_t>* m_pmultiEt;
 
     /* 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_xstripQ2;
     std::vector<double> m_vstripQ2;
     std::vector<double> m_xstripT;
     std::vector<double> m_vstripT;
     std::vector<double> m_xfirstT;
     std::vector<double> m_vfirstT;
     std::map<int, int>     m_mapQ[2][2];//[nSheet][XV-view]
     std::map<int, double>  m_mapT[2][2];
     std::map<int, TH1D*>   m_mapThis[2][2];
 
     /* ntuple */
     NTuple::Tuple*  m_tuple;
     NTuple::Item<int> m_ntNIonE;
     /* NTuple::Item<int> m_ntNGem1E; */
     /* NTuple::Item<int> m_ntNGem2E; */
     /* NTuple::Item<int> m_ntNGem3E; */
     NTuple::Item<int> m_ntNMultiE;
     NTuple::Item<int> m_ntNxstrips;
     NTuple::Item<int> m_ntNvstrips;
     NTuple::Array<double>    m_ntxstripQ;
     NTuple::Array<double>    m_ntxstripT;
     NTuple::Array<double>    m_ntvstripQ;
     NTuple::Array<double>    m_ntvstripT;
     NTuple::Array<double>    m_XstripID;
     NTuple::Array<double>    m_VstripID;
 
     
};
 
 
#endif  /* CGEMDIGITIZERSVC_H */