FastTimerSD.h

Go to the documentation of this file.

#ifndef SimG4CMSForward_FastTimerSD_h
#define SimG4CMSForward_FastTimerSD_h

#include "DetectorDescription/Core/interface/DDsvalues.h"
#include "SimG4Core/Notification/interface/Observer.h"
#include "SimG4Core/SensitiveDetector/interface/SensitiveTkDetector.h"

#include "SimG4Core/Notification/interface/BeginOfJob.h"
#include "SimG4Core/Notification/interface/BeginOfRun.h"
#include "SimG4Core/Notification/interface/BeginOfEvent.h"
#include "SimG4Core/Notification/interface/EndOfEvent.h"

#include "SimG4CMS/Forward/interface/BscG4Hit.h"
#include "SimG4CMS/Forward/interface/BscG4HitCollection.h"
#include "Geometry/HGCalCommonData/interface/FastTimeDDDConstants.h"
  
#include "G4Step.hh"
#include "G4StepPoint.hh"
#include "G4Track.hh"
#include "G4VPhysicalVolume.hh"

#include <string>

class TrackingSlaveSD;
class TrackInformation;
class SimTrackManager;
class TrackingSlaveSD;
class UpdatablePSimHit;
class G4ProcessTypeEnumerator;
class G4TrackToParticleID;

//-------------------------------------------------------------------

class FastTimerSD : public SensitiveTkDetector,
                    public Observer<const BeginOfJob *>,
                    public Observer<const BeginOfRun *>,
                    public Observer<const BeginOfEvent*>,
                    public Observer<const EndOfEvent*> {

public:
  
  FastTimerSD(std::string, const DDCompactView &, const SensitiveDetectorCatalog &, 
          edm::ParameterSet const &, const SimTrackManager* );


  virtual ~FastTimerSD();
  
  virtual bool     ProcessHits(G4Step *,G4TouchableHistory *);
  virtual uint32_t setDetUnitId(G4Step*);

  virtual void     Initialize(G4HCofThisEvent * HCE);
  virtual void     EndOfEvent(G4HCofThisEvent * eventHC);
  virtual void     clear();
  virtual void     DrawAll();
  virtual void     PrintAll();

  virtual double   getEnergyDeposit(G4Step* step);
  void             fillHits(edm::PSimHitContainer&, std::string use);
  
  std::vector<std::string> getNames();
  
private:
  virtual void     update(const BeginOfJob *);
  virtual void     update(const BeginOfRun *);
  virtual void     update(const BeginOfEvent *);
  virtual void     update(const ::EndOfEvent *);
  virtual void     clearHits();

private:
  
  G4ThreeVector    SetToLocal(const G4ThreeVector& global);
  G4ThreeVector    SetToLocalExit(const G4ThreeVector& globalPoint);
  void             GetStepInfo(G4Step* aStep);
  G4bool           HitExists();
  void             CreateNewHit();
  void             UpdateHit();
  void             StoreHit(BscG4Hit*);
  void             ResetForNewPrimary();
  void             Summarize();
  std::vector<double> getDDDArray(const std::string &, const DDsvalues_type &);
  
private:
  
  TrackingSlaveSD             *slave;
  const FastTimeDDDConstants  *ftcons;
  int                          type_;

  G4ThreeVector                entrancePoint, exitPoint;
  G4ThreeVector                theEntryPoint, theExitPoint;
  
  float                        incidentEnergy;
  G4int                        primID  ; 
  
  std::string                  name;
  G4int                        hcID;
  BscG4HitCollection*          theHC; 
  const SimTrackManager*       theManager;
 
  G4int                        tsID; 
  BscG4Hit*                    currentHit;
  G4Track*                     theTrack;
  G4VPhysicalVolume*           currentPV;
  uint32_t                     unitID, previousUnitID;
  G4int                        primaryID, tSliceID;  
  G4double                     tSlice;
  
  G4StepPoint*                 preStepPoint; 
  G4StepPoint*                 postStepPoint; 
  float                        edeposit;
  
  G4ThreeVector                hitPoint;
  G4ThreeVector                hitPointExit;
  G4ThreeVector                hitPointLocal;
  G4ThreeVector                hitPointLocalExit;

  float                        Pabs, Tof, Eloss;    
  short                        ParticleType; 
  float                        ThetaAtEntry, PhiAtEntry;
  
  int                          ParentId;
  float                        Vx,Vy,Vz;
  float                        X,Y,Z;
  
  int                          eventno;
  
protected:
  
  float                        edepositEM, edepositHAD;
  G4int                        emPDG;
  G4int                        epPDG;
  G4int                        gammaPDG;
};

#endif