Geant4Data.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_GEANT4DATA_H
#define DD4HEP_GEANT4DATA_H

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

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

// Forward declarations
class G4Step;
class G4StepPoint;

namespace DD4hep {

  namespace Simulation {

    // Forward type definitions
    typedef ROOT::Math::XYZVector Position;
    typedef ROOT::Math::XYZVector Direction;


    class SimpleRun {
    public:
      int runID;
      int numEvents;
      SimpleRun();
      virtual ~SimpleRun();
    };


    class SimpleEvent {
    public:
      typedef std::vector<long> Seeds;
      int runID;
      int eventID;
      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;
      long flag;
      long g4ID;
#ifdef DD4HEP_DD4HEP_PTR_AUTO
      dd4hep_ptr<DataExtension> extension;
#else
      dd4hep_ptr<DataExtension> extension;   
#endif


      class MonteCarloContrib {
      public:
        int trackID;
        int pdgID;
        double deposit;
        double time;
        float  x,y,z;

        MonteCarloContrib()
          : trackID(-1), pdgID(-1), deposit(0.0), time(0.0), x(0), y(0), z(0) {
        }
        MonteCarloContrib(int track_id, int pdg, double dep, double time_stamp)
          : trackID(track_id), pdgID(pdg), deposit(dep), time(time_stamp), x(0), y(0), z(0) {
        }
        MonteCarloContrib(int track_id, int pdg, double dep, double time_stamp, float* pos)
          : trackID(track_id), pdgID(pdg), deposit(dep), time(time_stamp),
            x(pos[0]), y(pos[1]), z(pos[2])
        {
        }
        MonteCarloContrib(int track_id, int pdg, double dep, double time_stamp, double* pos)
          : trackID(track_id), pdgID(pdg), deposit(dep), time(time_stamp),
            x(pos[0]), y(pos[1]), z(pos[2])
        {
        }
        MonteCarloContrib(const MonteCarloContrib& c)
          : trackID(c.trackID), pdgID(c.pdgID), deposit(c.deposit), time(c.time),
            x(c.x), y(c.y), z(c.z) {
        }
        MonteCarloContrib& operator=(const MonteCarloContrib& c)  {
          if ( this != &c )  {
            trackID = c.trackID;
            pdgID   = c.pdgID;
            deposit = c.deposit;
            time    = c.time;
            x       = c.x;
            y       = c.y;
            z       = c.z;
          }
          return *this;
        }
        void clear() {
          x = y = z = 0.0;
          time = deposit = 0.0;
          pdgID = trackID = -1;
        }
      };
      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);
    };


    class Geant4Tracker {
    public:

      class Hit : public Geant4HitData {
      public:
        Position position;
        Direction momentum;
        double length;
        Contribution truth;
        double energyDeposit;
        Hit();
        Hit(int track_id, int pdg_id, double deposit, double time_stamp);
        virtual ~Hit();
        Hit& operator=(const Hit& c);
        Hit& clear();
        Hit& storePoint(const G4Step* step, const G4StepPoint* point);
      };
    };


    class Geant4Calorimeter {
    public:


      class Hit : public Geant4HitData {
      public:
        Position position;
        Contributions truth;
        double energyDeposit;
      public:
        Hit();
        Hit(const Position& cell_pos);
        virtual ~Hit();
      };
    };

    typedef Geant4HitData SimpleHit;
    typedef Geant4Tracker SimpleTracker;
    typedef Geant4Calorimeter SimpleCalorimeter;

  }    // End namespace Simulation
}      // End namespace DD4hep
#endif // DD4HEP_GEANT4DATA_H