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:


   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

VTXDigitizer::_numberOfLayers
int _numberOfLayers
layer thickness
Definition: VTXDigitizer.h:188

SignalPoint
Definition: VTXDigitizer.h:27

VTXDigitizer::_nEvt
int _nEvt
Event number.
Definition: VTXDigitizer.h:169

MyG4UniversalFluctuationForSi
Definition: MyG4UniversalFluctuationForSi.h:52

VTXDigitizer::_tanLorentzAngle
double _tanLorentzAngle
tangent of Lorentz angle
Definition: VTXDigitizer.h:172

VTXDigitizer::_cutOnDeltaRays
double _cutOnDeltaRays
cut in MeV on delta electrons used in simulation of charge for each ionisation point ...
Definition: VTXDigitizer.h:176

VTXDigitizer::_colName
std::string _colName
Input collection name.
Definition: VTXDigitizer.h:159

VTXDigitizer::_diffusionCoefficient
double _diffusionCoefficient
Diffusion coefficient in mm for nominla layer thickness.
Definition: VTXDigitizer.h:179

VTXDigitizer::_nRun
int _nRun
Run number.
Definition: VTXDigitizer.h:165

IonisationPoint
Definition: CCDDigitizer.h:52