Geant4Data.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_GEANT4DATA_H
#define DDG4_GEANT4DATA_H
 
// Framework include files
#include <Math/Vector3D.h>
 
// C/C++ include files
#include <set>
#include <vector>
#include <memory>
 
// Forward declarations
class G4Step;
class G4StepPoint;
 
namespace dd4hep {
 
  // Forward type definitions
  typedef ROOT::Math::XYZVector Position;
  typedef ROOT::Math::XYZVector Direction;
  
  namespace sim {
 
    // Forward declarations
    class Geant4FastSimSpot;
 
 
    class SimpleRun {
    public:
      int runID     { -1 };
      int numEvents {  0 };
      SimpleRun();
      virtual ~SimpleRun();
    };
 
 
    class SimpleEvent {
    public:
      typedef std::vector<long> Seeds;
      int    runID   { -1 };
      int    eventID { -1 };
      Seeds  seeds { };
      SimpleEvent();
      virtual ~SimpleEvent();
    };
 
 
    class DataExtension  {
    public:
      DataExtension() {}
      virtual ~DataExtension();
    };
 
    /*
     *  Base class for geant4 hit structures created by the
     *  example sensitive detectors. This is a generic class
     *  only dealing with the cellID. Users may add an extension
     *  object, which normally should not be necessary.
     *
     *  \author  M.Frank
     *  \version 1.0
     *  \ingroup DD4HEP_SIMULATION
     */
    class Geant4HitData {
    public:
      enum HitFlags {
        HIT_KILLED_TRACK    = 1<<0,
        HIT_SECONDARY_TRACK = 1<<1,
        HIT_NEW_TRACK       = 1<<2,
        HIT_STARTED_INSIDE  = 1<<10,
        HIT_STARTED_SURFACE = 1<<11,
        HIT_STARTED_OUTSIDE = 1<<12,
        HIT_ENDED_INSIDE    = 1<<13,
        HIT_ENDED_SURFACE   = 1<<14,
        HIT_ENDED_OUTSIDE   = 1<<15
      };
      long long int cellID = 0;
      long flag = 0;
      long g4ID = -1;
      std::unique_ptr<DataExtension> extension;
 
 
      class MonteCarloContrib {
      public:
        int trackID = -1;
        int pdgID = -1;
        double deposit = 0.0;
        double time;
        double length = 0.0;
        float  x = 0.0, y = 0.0, z = 0.0;
        float  px = 0.0, py = 0.0, pz = 0.0;
 
        MonteCarloContrib() = default;
        MonteCarloContrib(const MonteCarloContrib& c) = default;
        MonteCarloContrib(MonteCarloContrib&& c) = default;
#if 0
        MonteCarloContrib(int track_id, int pdg, double dep, double time_stamp, double len)
          : trackID(track_id), pdgID(pdg), deposit(dep), time(time_stamp), length(len) {
        }
#endif
        MonteCarloContrib(int track_id, int pdg, double dep, double time_stamp, double len, float* pos, float* mom)
          : trackID(track_id), pdgID(pdg), deposit(dep), time(time_stamp), length(len),
            x(pos[0]), y(pos[1]), z(pos[2]), px(mom[0]), py(mom[1]), pz(mom[2])
        {
        }
        MonteCarloContrib(int track_id, int pdg, double dep, double time_stamp, double len, double* pos, double* mom)
          : trackID(track_id), pdgID(pdg), deposit(dep), time(time_stamp), length(len),
            x(float(pos[0])), y(float(pos[1])), z(float(pos[2])),
        px(float(mom[0])), py(float(mom[1])), pz(float(mom[2]))
        {
        }
        MonteCarloContrib(int track_id, int pdg, double dep, double time_stamp, double len, const Position& pos, const Direction& mom)
          : trackID(track_id), pdgID(pdg), deposit(dep), time(time_stamp), length(len),
            x(float(pos.x())), y(float(pos.y())), z(float(pos.z())),
        px(float(mom.x())), py(float(mom.y())), pz(float(mom.z()))
        {
        }
        MonteCarloContrib& operator=(MonteCarloContrib&& c) = default;
        MonteCarloContrib& operator=(const MonteCarloContrib& c) = default;
        void clear() {
          x = y = z = 0.0;
          px = py = pz = 0.0;
          time  = deposit = length = 0.0;
          pdgID = trackID = -1;
        }
    Position position() const   {
      return Position(x, y, z);
    }
    void setPosition(const Position& pos)   {
      x = pos.x();
      y = pos.y();
      z = pos.z();
    }
    void setPosition(double pos_x, double pos_y, double pos_z)   {
      x = float(pos_x);
      y = float(pos_y);
      z = float(pos_z);
    }
    Direction momentum() const   {
      return Direction(px, py, pz);
    }
    void setMomentum(const Direction& dir)   {
      px = dir.x();
      py = dir.y();
      pz = dir.z();
    }
    void setMomentum(double mom_x, double mom_y, double mom_z)   {
      px = float(mom_x);
      py = float(mom_y);
      pz = float(mom_z);
    }
      };
      typedef MonteCarloContrib Contribution;
      typedef std::vector<MonteCarloContrib> Contributions;
    public:
      Geant4HitData();
      virtual ~Geant4HitData();
      static Contribution extractContribution(const G4Step* step);
      static Contribution extractContribution(const G4Step* step, bool ApplyBirksLaw);
      static Contribution extractContribution(const Geant4FastSimSpot* spot);
    };
 
 
    class Geant4Tracker {
    public:
 
      class Hit : public Geant4HitData {
      public:
        typedef Geant4HitData base_t;
 
        Position      position;
        Direction     momentum;
        double        length  { 0e0 };
        double        energyDeposit { 0e0 };
        Contribution  truth;
      public:
        Hit();
        Hit(Hit&& c) = delete;
        Hit(const Hit& c) = delete;
        Hit(int track_id, int pdg_id, double deposit, double time_stamp, double len=0.0, const Position& p={0.0, 0.0, 0.0}, const Direction& d={0.0, 0.0, 0.0});
    Hit(const Geant4HitData::Contribution& contrib, const Direction& mom, double deposit);
        virtual ~Hit();
        Hit& operator=(Hit&& c) = delete;
        Hit& operator=(const Hit& c) = delete;
    void copyFrom(const Hit& c);
        Hit& clear();
        Hit& storePoint(const G4Step* step, const G4StepPoint* point);
    Hit& storePoint(const Geant4FastSimSpot* spot);
      };
    };
 
 
    class Geant4Calorimeter {
    public:
 
 
      class Hit : public Geant4HitData {
      public:
        typedef Geant4HitData base_t;
 
        Position      position      {     };
        Contributions truth         {     };
        double        energyDeposit { 0e0 };
      public:
        Hit();
        Hit(Hit&& c) = delete;
        Hit(const Hit& c) = delete;
        Hit(const Position& cell_pos);
        virtual ~Hit();
        Hit& operator=(Hit&& c) = delete;
        Hit& operator=(const Hit& c) = delete;
      };
    };
 
    typedef Geant4HitData SimpleHit;
    typedef Geant4Tracker SimpleTracker;
    typedef Geant4Calorimeter SimpleCalorimeter;
 
  }    // End namespace sim
}      // End namespace dd4hep
#endif // DDG4_GEANT4DATA_H