Geant4TrackHandler.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DDG4_GEANT4TRACKHANDLER_H
#define DDG4_GEANT4TRACKHANDLER_H
 
// Framework include files
#include <DDG4/Defs.h>
 
// Geant4 include files
#include <G4Track.hh>
#include <G4TrajectoryPoint.hh>
#include <G4VTouchable.hh>
#include <G4VSensitiveDetector.hh>
#include <G4ParticleDefinition.hh>
#include <G4DynamicParticle.hh>
#include <G4VProcess.hh>
 
// C/C++ include files
#include <stdexcept>
 
// Forward declarations
class G4VTouchableHandle;
class G4VUserTrackInformation;
 
namespace dd4hep {
 
  namespace sim {
 
    // Forward declarations;
    class Geant4TrackHandler;
 
 
    class Geant4TrackHandler {
    public:
      typedef G4VUserTrackInformation Info;
      typedef G4ReferenceCountedHandle<G4VTouchable> Touchable;
      const G4Track* track;
      Geant4TrackHandler() = delete;
      Geant4TrackHandler(const G4Track* t) : track(t) {
        if ( 0 == t )  {
          throw std::runtime_error("Geant4TrackHandler: NULL pointer passed to constructor!");
        }
      }
      const char* statusName() const    {
        switch( track->GetTrackStatus() )  {
        case fAlive:                    return "Alive";
        case fStopButAlive:             return "StopButAlive";
        case fStopAndKill:              return "StopAndKill";
        case fKillTrackAndSecondaries:  return "KillTrackAndSecondaries";
        case fSuspend:                  return "Suspend";
        case fPostponeToNextEvent:      return "PostponeToNextEvent";
        default:                        return "UNKNOWN";
        }
      }
 
      operator const G4Track*() const {
        return track;
      }
      int id() const  {
        return track->GetTrackID();
      }
      int parent()  const  {
        return track->GetParentID();
      }
      G4ParticleDefinition* trackDef() const {
        return track->GetDefinition();
      }
      const std::string& name()  const  {
        return trackDef()->GetParticleName();
      }
      const std::string& type()  const  {
        return trackDef()->GetParticleType();
      }
      const G4ThreeVector& position() const {
        return track->GetPosition();
      }
      const G4ThreeVector& vertex() const {
        return track->GetVertexPosition();
      }
      double globalTime() const  {
        return track->GetGlobalTime();
      }
      double properTime() const  {
        return track->GetProperTime();
      }
      double energy() const {
        return track->GetTotalEnergy();
      }
      double kineticEnergy() const {
        return track->GetKineticEnergy();
      }
      double velocity() const {
        return track->GetVelocity();
      }
      double length() const {
        return track->GetTrackLength();
      }
      double time() const {
        return track->GetGlobalTime();
      }
      double charge() const {
        G4ParticleDefinition* def = trackDef();
        return def ? def->GetPDGCharge() : 0;
      }
      double mass() const {
        G4ParticleDefinition* def = trackDef();
        return def ? def->GetPDGMass() : 0;
      }
      G4VPhysicalVolume* vol() const {
        return track->GetVolume();
      }
      G4ThreeVector momentum() const  {
        return track->GetMomentum();
      }
      G4VPhysicalVolume* nextVol() const {
        return track->GetNextVolume();
      }
      const G4LogicalVolume* vertexVol() const {
        return track->GetLogicalVolumeAtVertex();
      }
      const Touchable& touchable() const {
        return track->GetTouchableHandle();
      }
      const Touchable& nextTouchable() const {
        return track->GetNextTouchableHandle();
      }
      const G4VProcess* creatorProcess() const {
        return track->GetCreatorProcess();
      }
      const std::string creatorName() const {
        const G4VProcess* p = creatorProcess();
        if ( p ) return p->GetProcessName();
        return "";
      }
      Info* userInfo() const {
        return track->GetUserInformation();
      }
      template <typename T> T* info() const {
        return (T*) userInfo();
      }
      const G4Step* step() const {
        return track->GetStep();
      }
      G4int stepNumber() const {
        return track->GetCurrentStepNumber();
      }
      int pdgID() const {
        G4ParticleDefinition* def = trackDef();
        return def ? def->GetPDGEncoding() : 0;
      }
      const G4DynamicParticle* dynamic() const  {
        return track->GetDynamicParticle();
      }
      const G4PrimaryParticle* primary() const  {
        const G4DynamicParticle* d = track->GetDynamicParticle();
        if ( d ) return d->GetPrimaryParticle();
        return 0;
      }
    };
 
  }    // End namespace sim
}      // End namespace dd4hep
#endif // DDG4_GEANT4TRACKHANDLER_H