Geant4FastSimSpot.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_GEANT4FASTSIMSPOT_H
#define DDG4_GEANT4FASTSIMSPOT_H
 
// Framework include files
#include <DDG4/Defs.h>
 
// Geant4 include files
#include <G4Version.hh>
 
#if G4VERSION_NUMBER < 1070
 
#include <G4ThreeVector.hh>
 
class G4FastHit
{
 public:
  G4FastHit() = default;
  G4FastHit(const G4ThreeVector& aPosition, G4double aEnergy)
    : fEnergy(aEnergy), fPosition(aPosition) {}
  G4FastHit(const G4ThreeVector& aPosition, G4double aEnergy, G4bool /* aDebug */)
    : fEnergy(aEnergy), fPosition(aPosition) {}
  virtual ~G4FastHit() = default;
 
  inline void SetEnergy(const G4double& aEnergy) { fEnergy = aEnergy; }
  inline G4double GetEnergy() const { return fEnergy; }
  inline void SetPosition(const G4ThreeVector& aPosition) { fPosition = aPosition; }
  inline G4ThreeVector GetPosition() const { return fPosition; }
 private:
  G4double fEnergy  {0e0};
  G4ThreeVector fPosition  { };
};
#else
#include <G4FastHit.hh>
#endif
 
#include <G4Track.hh>
#include <G4FastTrack.hh>
#include <G4ThreeVector.hh>
#include <G4TouchableHandle.hh>
 
namespace dd4hep {
 
  namespace sim {
 
 
    class Geant4FastSimSpot   {
    public:
      Geant4FastSimSpot() = delete;
      Geant4FastSimSpot(const G4FastHit* h, const G4FastTrack* trk);
      Geant4FastSimSpot(const G4FastHit* h, const G4FastTrack* trk, G4VTouchable* t);
      ~Geant4FastSimSpot() = default;
 
      G4ThreeVector hitPosition() const    { return hit->GetPosition();          }
      double        energy() const         { return hit->GetEnergy();            }
      G4VPhysicalVolume* volume() const    { return touchable->GetVolume();      }
 
      G4ThreeVector trackPosition() const  { return primary->GetPosition();      }
      G4ThreeVector trackMomentum() const  { return primary->GetMomentum();      }
      double kineticEnergy() const         { return primary->GetKineticEnergy(); }
      const G4ParticleDefinition* trackDefinition() const 
      { return primary->GetParticleDefinition();                                 }
      G4ThreeVector particleLocalDirection()  const
      { return track->GetPrimaryTrackLocalDirection();                           }
      G4ThreeVector particleLocalMomentum()  const
      { return track->GetPrimaryTrackLocalMomentum();                            }
      G4ThreeVector particleLocalPosition()  const
      { return track->GetPrimaryTrackLocalPosition();                            }
 
      double distanceToOut()   const;
      G4ThreeVector particleDirection()  const;
      G4ThreeVector particleMomentum()  const;
      G4ThreeVector particlePosition()  const;
      
  public:
      const G4FastHit*   hit        { nullptr };
      const G4FastTrack* track      { nullptr };
      const G4Track*     primary    { nullptr };
      G4VTouchable*      touchable  { nullptr };
    };
 
    inline Geant4FastSimSpot::Geant4FastSimSpot(const G4FastHit* h,
                        const G4FastTrack* trk,
                        G4VTouchable* t)
      : hit(h), track(trk), primary(trk->GetPrimaryTrack()), touchable(t)
    {
    }
 
    inline Geant4FastSimSpot::Geant4FastSimSpot(const G4FastHit* h,
                        const G4FastTrack* trk)
      : hit(h), track(trk), primary(trk->GetPrimaryTrack())
    {
    }
 
    inline G4ThreeVector Geant4FastSimSpot::particleMomentum()  const    {
      auto mom = track->GetPrimaryTrackLocalMomentum();
      return track->GetInverseAffineTransformation()->TransformPoint(mom);
    }
 
    inline G4ThreeVector Geant4FastSimSpot::particleDirection()  const    {
      auto dir = track->GetPrimaryTrackLocalDirection();
      return track->GetInverseAffineTransformation()->TransformPoint(dir);
    }
 
    inline G4ThreeVector Geant4FastSimSpot::particlePosition()  const    {
      auto pos = track->GetPrimaryTrackLocalPosition();
      return track->GetInverseAffineTransformation()->TransformPoint(pos);
    }
 
    inline double Geant4FastSimSpot::distanceToOut()   const     {
      auto pos = track->GetPrimaryTrackLocalPosition();
      auto dir = track->GetPrimaryTrackLocalDirection();
      return track->GetEnvelopeSolid()->DistanceToOut(pos, dir);
    }
 
 
  }    // End namespace sim
}      // End namespace dd4hep
#endif // DDG4_GEANT4FASTSIMSPOT_H