Geant4Particle.h

Go to the documentation of this file.

// $Id: $
//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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 DD4HEP_GEANT4PARTICLE_H
#define DD4HEP_GEANT4PARTICLE_H

// Framework include files
#include "DD4hep/Memory.h"

// ROOT includes
#include "Math/Vector4D.h"

// Geant4 forward declarations
class G4ParticleDefinition;
class G4VProcess;

// C/C++ include files
#include <set>
#include <map>

namespace DD4hep {

  namespace Simulation {

    // 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...3 come from LCIO, rest is internal
      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_GENERATOR       =        // Particle comes from generator
      (  G4PARTICLE_GEN_EMPTY+G4PARTICLE_GEN_STABLE+
         G4PARTICLE_GEN_DECAYED+G4PARTICLE_GEN_DOCUMENTATION  ),
      G4PARTICLE_GEN_STATUS          = 0x3FF, // Mask for generator status (bit 0...9)

      // 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 {
    private:
      Geant4Particle(const Geant4Particle& c);
    public:
      typedef std::set<int> Particles;
      int ref;           
      int id, g4Parent, reason, mask;
      int steps, secondaries, pdgID;
      int status, colorFlow[2];
      char charge, _spare[3];
      float spin[3];
      // 12 ints + 4 floats should be aligned to 8 bytes....
      double vsx, vsy, vsz;
      double vex, vey, vez;
      double psx, psy, psz;
      double pex, pey, pez;
      double mass, time, properTime;
      Particles parents;
      Particles daughters;

#ifdef DD4HEP_DD4HEP_PTR_AUTO
      dd4hep_ptr<ParticleExtension> extension;
#else
      dd4hep_ptr<ParticleExtension> extension;   
#endif
      const G4VProcess *process;                 
      Geant4Particle();
      Geant4Particle(int part_id);
      virtual ~Geant4Particle();
      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;
      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;
      void dump4(int level, const std::string& src, const char* tag) const;


      void offset(int off)  const;

    };

    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;

      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 Simulation
}      // End namespace DD4hep
#endif // DD4HEP_GEANT4PARTICLE_H