Geant4Particle.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_GEANT4PARTICLE_H
#define DDG4_GEANT4PARTICLE_H
 
// Framework include files
 
// ROOT includes
#include <Math/Vector4D.h>
 
// Geant4 forward declarations
class G4ParticleDefinition;
class G4VProcess;
 
// C/C++ include files
#include <set>
#include <map>
#include <vector>
#include <memory>
 
namespace dd4hep {
 
  namespace sim {
 
    // Forward declarations
    class Geant4Particle;
 
 
    class ParticleExtension  {
    public:
      ParticleExtension() {}
      virtual ~ParticleExtension();
    };
 
    enum Geant4ParticleProperties {
      G4PARTICLE_CREATED_HIT         = 1<<1,
      G4PARTICLE_PRIMARY             = 1<<2,
      G4PARTICLE_HAS_SECONDARIES     = 1<<3,
      G4PARTICLE_ABOVE_ENERGY_THRESHOLD = 1<<4,
      G4PARTICLE_KEEP_PROCESS        = 1<<5,
      G4PARTICLE_KEEP_PARENT         = 1<<6,
      G4PARTICLE_CREATED_CALORIMETER_HIT = 1<<7,
      G4PARTICLE_CREATED_TRACKER_HIT = 1<<8,
      G4PARTICLE_KEEP_USER           = 1<<9,
      G4PARTICLE_KEEP_ALWAYS         = 1<<10,
      G4PARTICLE_FORCE_KILL          = 1<<11,
 
      // Generator status for a given particles: bit 0...4, agreed by many formats (HepMC, LCIO, ....):
      G4PARTICLE_GEN_EMPTY           = 1<<0,  // Empty line
      G4PARTICLE_GEN_STABLE          = 1<<1,  // undecayed particle, stable in the generator
      G4PARTICLE_GEN_DECAYED         = 1<<2,  // particle decayed in the generator
      G4PARTICLE_GEN_DOCUMENTATION   = 1<<3,  // documentation line
      G4PARTICLE_GEN_BEAM            = 1<<4,  // beam particle
 
      G4PARTICLE_GEN_OTHER           = 1<<9,  // any other generator status
 
      G4PARTICLE_GEN_GENERATOR       =        // Particle comes from generator
      (  G4PARTICLE_GEN_EMPTY+G4PARTICLE_GEN_STABLE+
         G4PARTICLE_GEN_DECAYED+G4PARTICLE_GEN_DOCUMENTATION+
         G4PARTICLE_GEN_BEAM+G4PARTICLE_GEN_OTHER),
      G4PARTICLE_GEN_STATUS          = 0x3FF, // Mask for generator status (bit 0...9)
      G4PARTICLE_GEN_STATUS_MASK     = 0xFFFF,// Mask for the raw generator status (max 65k values)
      // Simulation status of a given particle
      G4PARTICLE_SIM_CREATED         = 1<<10, // True if the particle has been created by the simulation program (rather than the generator)
      G4PARTICLE_SIM_BACKSCATTER     = 1<<11, // True if the particle is the result of a backscatter from a calorimeter shower.
      G4PARTICLE_SIM_DECAY_CALO      = 1<<12, // True if the particle has interacted in a calorimeter region.
      G4PARTICLE_SIM_DECAY_TRACKER   = 1<<13, // True if the particle has interacted in a tracking region.
      G4PARTICLE_SIM_STOPPED         = 1<<14, // True if the particle has been stopped by the simulation program.
      G4PARTICLE_SIM_LEFT_DETECTOR   = 1<<15, // True if the particle has left the world volume undecayed.
      G4PARTICLE_SIM_PARENT_RADIATED = 1<<16, // True if the particle's vertex is not the endpoint of the  parent particle.
      G4PARTICLE_SIM_OVERLAY         = 1<<17, // True if the particle has been overlayed by the simulation (or digitization)  program.
 
      G4PARTICLE_LAST_NOTHING = 1<<31
    };
 
 
    class Geant4Particle {
    public:
      typedef std::set<int> Particles;
      int ref                      { 0 };           
      int id                       { 0 };
      int originalG4ID             { 0 };           
      int g4Parent                 { 0 };
      int reason                   { 0 };
      int mask                     { 0 };
      int steps                    { 0 };
      int secondaries              { 0 };
      int pdgID                    { 0 };
      int status                   { 0 };
      int colorFlow[2]             { 0, 0 };
      unsigned short genStatus     { 0 };
      char  charge                 { 0 };
      char  _spare[1]              { 0 };
      float spin[3]                { 0E0,0E0,0E0 };
      // 12 ints + 4 bytes + 3 floats should be aligned to 8 bytes....
      double vsx  = 0E0, vsy  = 0E0, vsz = 0E0;
      double vex  = 0E0, vey  = 0E0, vez = 0E0;
      double psx  = 0E0, psy  = 0E0, psz = 0E0;
      double pex  = 0E0, pey  = 0E0, pez = 0E0;
      double mass       { 0E0 };
      double time       { 0E0 };
      double properTime { 0E0 };
      Particles parents;
      Particles daughters;
 
      std::unique_ptr<ParticleExtension> extension  { };
      const G4VProcess *process = 0;             
 
    public:
      Geant4Particle();
      Geant4Particle(int part_id);
      Geant4Particle(const Geant4Particle& copy) = delete;
      virtual ~Geant4Particle();
      Geant4Particle& operator=(const Geant4Particle& copy) = delete;
      Geant4Particle* addRef()  {
        ++ref;
        return this;
      }
      void release();
      Geant4Particle& get_data(Geant4Particle& c);
      void removeDaughter(int id_daughter);
      int charge3() const  {  return charge; }
    };
 
#ifndef __DDG4_STANDALONE_DICTIONARIES__
 
 
    class Geant4ParticleHandle {
    public:
      typedef ROOT::Math::PxPyPzM4D<double> FourVector;
      typedef ROOT::Math::Cartesian3D<double> ThreeVector;
    protected:
      Geant4Particle* particle;
 
    public:
      Geant4ParticleHandle(Geant4Particle* part);
      Geant4ParticleHandle(const Geant4ParticleHandle& h);
      Geant4ParticleHandle& operator=(Geant4Particle* part);
      Geant4Particle* operator->() const;
      operator Geant4Particle*() const;
      size_t numParent() const;
      size_t numDaughter() const;
      double momentum2() const;
      double energy() const;
      double momentum() const   {  return std::sqrt(momentum2());  }
      double charge()  const    { return double(particle->charge); }
      double mass() const       { return particle->mass;           }
      double time() const       { return particle->time;           }
      std::string particleName() const;
      std::string particleType() const;
      std::string processName() const;
      std::string processTypeName() const;
      FourVector pxPyPzM() const;
      template <typename T> std::vector<T> pxPyPzM(T unit) const;
      ThreeVector startVertex() const;
      ThreeVector endVertex()  const;
      const G4ParticleDefinition *definition() const;
 
 
      void dump1(int level, const std::string& src, const char* tag) const;
      void dump2(int level, const std::string& src, const char* tag, int g4id, bool inrec) const;
      void dumpWithVertex(int level, const std::string& src, const char* tag) const;
      void dumpWithMomentum(int level, const std::string& src, const char* tag) const;
      void dumpWithMomentumAndVertex(int level, const std::string& src, const char* tag) const;
      static void header4(int level, const std::string& src, const char* tag);
      void dump4(int level, const std::string& src, const char* tag) const;
 
 
      void offset(int off)  const;
 
      static std::vector<G4ParticleDefinition*> g4DefinitionsRegEx(const std::string& expression);
      static G4ParticleDefinition* g4DefinitionsExact(const std::string& expression);
    };
 
    inline Geant4ParticleHandle::Geant4ParticleHandle(const Geant4ParticleHandle& c)
      : particle(c.particle) {
    }
 
    inline Geant4ParticleHandle::Geant4ParticleHandle(Geant4Particle* p)
      : particle(p)  {
    }
 
    inline Geant4Particle* Geant4ParticleHandle::operator->() const  {
      return particle;
    }
    inline Geant4ParticleHandle& Geant4ParticleHandle::operator=(Geant4Particle* part) {
      particle = part;
      return *this;
    }
    inline Geant4ParticleHandle::operator Geant4Particle*() const  {
      return particle;
    }
    inline size_t Geant4ParticleHandle::numParent() const   {
      return particle->parents.size();
    }
    inline size_t Geant4ParticleHandle::numDaughter() const   {
      return particle->daughters.size();
    }
    inline ROOT::Math::PxPyPzM4D<double> Geant4ParticleHandle::pxPyPzM() const {
      const Geant4Particle* p = particle;
      return ROOT::Math::PxPyPzM4D<double>(p->psx,p->psy,p->psz,p->mass);
    }
 
    inline ROOT::Math::Cartesian3D<double> Geant4ParticleHandle::startVertex() const {
      const Geant4Particle* p = particle;
      return ROOT::Math::Cartesian3D<double>(p->vsx,p->vsy,p->vsz);
    }
 
    inline ROOT::Math::Cartesian3D<double> Geant4ParticleHandle::endVertex()  const {
      const Geant4Particle* p = particle;
      return ROOT::Math::Cartesian3D<double>(p->vex,p->vey,p->vez);
    }
 
    inline double Geant4ParticleHandle::energy() const {
      const Geant4Particle* p = particle;
      ROOT::Math::PxPyPzM4D<double> v(p->psx,p->psy,p->psz,p->mass);
      return v.E();
    }
 
    inline double Geant4ParticleHandle::momentum2() const  {
      const Geant4Particle* p = particle;
      return (p->psx*p->psx + p->psy*p->psy + p->psz*p->psz);
    }
 
 
    class Geant4ParticleMap  {
    public:
      typedef Geant4Particle          Particle;
      typedef std::map<int,Particle*> ParticleMap;
      typedef std::map<int,int>       TrackEquivalents;
      ParticleMap particleMap; 
      TrackEquivalents equivalentTracks;
 
    public:
      Geant4ParticleMap() {}
      virtual ~Geant4ParticleMap();
      bool isValid() const;
      void dump()  const;
      void clear();
      void adopt(ParticleMap& pm, TrackEquivalents& equiv);
      const ParticleMap& particles() const  {  return particleMap; }
      const TrackEquivalents& equivalents() const  {  return equivalentTracks;  }
      int particleID(int track, bool throw_if_not_found=true) const;
    };
#endif
 
  }    // End namespace sim
}      // End namespace dd4hep
#endif // DDG4_GEANT4PARTICLE_H