doc/html/VTXDigitizer_8h_source.html

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 #ifndef VTXDigitizer_h

 #define VTXDigitizer_h 1


 #include "marlin/Processor.h"

 #include "lcio.h"

 #include "EVENT/SimTrackerHit.h"

 #include "IMPL/TrackerHitImpl.h"

 #include "IMPL/SimTrackerHitImpl.h"

 #include <string>

 #include <vector>

 #include "MyG4UniversalFluctuationForSi.h"

 #include "EVENT/LCIO.h"

 #include <IMPL/LCCollectionVec.h>


 using namespace lcio ;

 using namespace marlin ;


 struct IonisationPoint {

   double x{};

   double y{};

   double z{};

   double eloss{};

 };


 struct SignalPoint {

   double x{};

   double y{};

   double sigmaX{};

   double sigmaY{};

   double charge{};


 };


 typedef std::vector<IonisationPoint> IonisationPointVec;

 typedef std::vector<SignalPoint> SignalPointVec;

 typedef std::vector<TrackerHitImpl*> TrackerHitImplVec;

 typedef std::vector<SimTrackerHitImpl*> SimTrackerHitImplVec;


 class VTXDigitizer : public Processor {


  public:

   VTXDigitizer(const VTXDigitizer&) = delete;

   VTXDigitizer& operator=(const VTXDigitizer&) = delete;


   virtual Processor*  newProcessor() { return new VTXDigitizer ; }


   VTXDigitizer() ;


   virtual void init() ;


   virtual void processRunHeader( LCRunHeader* run ) ;


   virtual void processEvent( LCEvent * evt ) ;


   virtual void check( LCEvent * evt ) ;


   virtual void end() ;


  protected:


   std::string _colName{};

   std::string _outputCollectionName{};

   std::string _colVTXRelation{};


   int _nRun{};


   int _nEvt{};

   double _tanLorentzAngle{};

   double _cutOnDeltaRays{};

   double _diffusionCoefficient{};

  //  double _layerThickness;

 //   /** layer half-thickness

 //    */

 //   double _layerHalfThickness;


   int _numberOfLayers{};

   double _pixelSizeX{};

   double _pixelSizeY{};

   double _electronsPerKeV{};

   double _segmentDepth{};

   double _currentTotalCharge{};


   std::vector<int> _laddersInLayer{};

   std::vector<float> _layerRadius{};

   std::vector<float> _layerThickness{};

   std::vector<float> _layerHalfThickness{};

   std::vector<float> _layerLadderLength{};

   std::vector<float> _layerLadderHalfWidth{};

   std::vector<float> _layerPhiOffset{};

   std::vector<float> _layerActiveSiOffset{};

   std::vector<float> _layerHalfPhi{};

   std::vector<float> _layerLadderGap{};

   std::vector<float> _bkgdHitsInLayer{};

   std::vector<float> _layerLadderWidth{};


   int _currentLayer{};

   int _currentModule{};

   int _generateBackground{};

   double _currentParticleMomentum{};

   double _currentParticleEnergy{};

   double _currentParticleMass{};

   double _currentPhi{};

   double _widthOfCluster{};


   double PI{},TWOPI{},PI2{};

   double SCALING{};


   int _produceFullPattern{};

   int _numberOfSegments{};

   int _debug{};

   int _PoissonSmearing{};

   int _electronicEffects{};

   int _useMCPMomentum{};

   int _removeDrays{};


   double _threshold{};

   double _currentLocalPosition[3]{};

   double _currentEntryPoint[3]{};

   double _currentExitPoint[3]{};

   double _electronicNoise{};

   double _segmentLength{};


   IonisationPointVec _ionisationPoints{};

   SignalPointVec _signalPoints{};


   MyG4UniversalFluctuationForSi * _fluctuate{};


   void FindLocalPosition(SimTrackerHit * hit,

                          double * localPosition,

                          double * localDirection);


   void TransformToLab(double * xLoc, double * xLab);

   void ProduceIonisationPoints( SimTrackerHit * hit);

   void ProduceSignalPoints( );

   void ProduceHits(SimTrackerHitImplVec & simTrkVec);

   void TransformXYToCellID(double x, double y,

                            int & ix,

                            int & iy);

   void TransformCellIDToXY(int ix, int iy,

                            double & x, double & y);

   void PoissonSmearer( SimTrackerHitImplVec & simTrkVec );

   void GainSmearer( SimTrackerHitImplVec & simTrkVec );

   void PrintInfo( SimTrackerHit * simTrkHit, TrackerHitImpl * recoHit);

   TrackerHitImpl * ReconstructTrackerHit(SimTrackerHitImplVec & simTrkVec );

   void TrackerHitToLab( TrackerHitImpl * recoHit );

   void PositionWithinCell(double x, double y,

                           int & ix, int & iy,

                           double & xCell, double & yCell);

   void generateBackground(LCCollectionVec * col);


   double _xLayerReco{},_yLayerReco{},_zLayerReco{};

   double _xLayerSim{},_yLayerSim{},_zLayerSim{};

   int _iLayer{};


   int _nCoveredX{},_nCoveredY{},_nCells{};


   int _totEntries{};

   double _totMomentum{};

   double _momX{},_momY{},_momZ{};

   double _eDep{};


   double _amplX[20]{};

   double _amplY[20]{};

   double _amplC[100]{};

   double _ampl{};

   double _amplMax{};

   double _eSum{};

   double _energyLoss{};

   double _clusterWidthX{},_clusterWidthY{};

   double _ampl33{},_ampl55{},_ampl77{};

   int _ncell33{},_ncell55{},_ncell77{};

   int _storeNtuple{};

   double _xLocalRecoCOG{},_yLocalRecoCOG{};

   double _xLocalRecoEdge{},_yLocalRecoEdge{};

   double _xLocalSim{},_yLocalSim{};


   std::vector <SimTrackerHitImplVec> _hitsInLayer{};


 } ;


 #endif

VTXDigitizer
Digitizer for Simulated Hits in the Vertex Detector.
Definition: VTXDigitizer.h:123

SignalPoint
Definition: VTXDigitizer.h:27

MyG4UniversalFluctuationForSi
Definition: MyG4UniversalFluctuationForSi.h:52

IonisationPoint
Definition: CCDDigitizer.h:52