Geant4PhysicsList.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_GEANT4PHYSICSLIST_H
#define DDG4_GEANT4PHYSICSLIST_H
 
// Framework include files
#include <DDG4/Geant4Action.h>
 
// C/C++ include files
#include <map>
#include <vector>
 
// Forward declarations
class G4VPhysicsConstructor;
class G4VModularPhysicsList;
class G4VUserPhysicsList;
 
namespace dd4hep {
 
  namespace sim {
 
 
    class Geant4PhysicsList: public Geant4Action {
    public:
 
 
      class Process {
      public:
        std::string name;
        int ordAtRestDoIt=-1, ordAlongSteptDoIt=-1, ordPostStepDoIt=-1;
        Process();
        Process(const Process& p);
        Process& operator=(const Process& p);
      };
      typedef std::vector<Process> ParticleProcesses;
      typedef std::map<std::string, ParticleProcesses> PhysicsProcesses;
 
 
      class ParticleConstructor : public std::string {
      public:
        ParticleConstructor() = default;
        ParticleConstructor(const ParticleConstructor& copy) = default;
        ParticleConstructor(const std::string& s) : std::string(s) { }
        ParticleConstructor& operator=(const ParticleConstructor& c) = default;
      };
      typedef std::vector<ParticleConstructor> ParticleConstructors;
 
 
      class PhysicsConstructor: public std::string {
      public:
        G4VPhysicsConstructor* pointer      { nullptr };
        G4VModularPhysicsList* physics_list { nullptr };
      public:
        PhysicsConstructor() = default;
        PhysicsConstructor(const PhysicsConstructor& c) = default;
        PhysicsConstructor(const std::string& s) : std::string(s), pointer(0)  {}
        PhysicsConstructor& operator=(const PhysicsConstructor& c) = default;
      };
      typedef std::vector<PhysicsConstructor> PhysicsConstructors;
 
      PhysicsProcesses     m_processes;
      PhysicsProcesses     m_discreteProcesses;
      PhysicsConstructors  m_physics;
      ParticleConstructors m_particles;
      ParticleConstructors m_particlegroups;
 
    public:
      Geant4PhysicsList(Geant4Context* context, const std::string& nam);
      virtual ~Geant4PhysicsList();
 
      void dump();
 
      virtual void installCommandMessenger()  override;
      PhysicsProcesses& processes() {
        return m_processes;
      }
      const PhysicsProcesses& processes() const {
        return m_processes;
      }
      ParticleProcesses& processes(const std::string& part_name);
      const ParticleProcesses& processes(const std::string& part_name) const;
 
      PhysicsProcesses& discreteProcesses() {
        return m_discreteProcesses;
      }
      const PhysicsProcesses& discreteProcesses() const {
        return m_discreteProcesses;
      }
      ParticleProcesses& discreteProcesses(const std::string& part_name);
      const ParticleProcesses& discreteProcesses(const std::string& part_name) const;
 
      PhysicsConstructor physics(const std::string& name)  const;
      
      ParticleConstructors& particles() {
        return m_particles;
      }
      const ParticleConstructors& particles() const {
        return m_particles;
      }
      ParticleConstructors& particlegroups() {
        return m_particlegroups;
      }
      const ParticleConstructors& particlegroups() const {
        return m_particlegroups;
      }
      PhysicsConstructors& physics() {
        return m_physics;
      }
      const PhysicsConstructors& physics() const {
        return m_physics;
      }
 
      void addParticleConstructor(const std::string& part_name);
      void addParticleGroup(const std::string& part_name);
      void addParticleProcess(const std::string& part_name, const std::string& proc_name,
                              int ordAtRestDoIt,int ordAlongSteptDoIt,int ordPostStepDoIt);
      void addDiscreteParticleProcess(const std::string& part_name, const std::string& proc_name);
 
      void addPhysicsConstructor(const std::string& physics_name);
 
      void adoptPhysicsConstructor(Geant4Action* action);
      G4VPhysicsConstructor* addPhysicsConstructorType(const std::string& physics_name);
 
      virtual void constructPhysics(G4VModularPhysicsList* physics);
      virtual void constructParticles(G4VUserPhysicsList* physics);
      virtual void constructProcesses(G4VUserPhysicsList* physics);
      virtual void enable(G4VUserPhysicsList* physics);
    };
 
 
    class Geant4PhysicsListActionSequence: public Geant4Action {
    public:
 
    protected:
      CallbackSequence m_physics          { };
      CallbackSequence m_process          { };
      CallbackSequence m_particle         { };
      Actors<Geant4PhysicsList> m_actors  { };
 
      virtual void constructDecays(G4VUserPhysicsList* physics);
    public:
      bool m_transportation         { false };
      bool m_decays                 { false };
      int m_verbosity               {     1 };
      int m_physics_verbosity       {    -1 };
      double m_rangecut;
      std::string m_extends;
 
    public:
      Geant4PhysicsListActionSequence(Geant4Context* context, const std::string& nam);
      virtual ~Geant4PhysicsListActionSequence();
      void dump();
      virtual void installCommandMessenger()  override;
      void setTransportation(bool value) {
        m_transportation = value;
      }
      bool transportation() const {
        return m_transportation;
      }
      template <typename Q, typename T>
      void constructPhysics(Q* p, void (T::*f)(G4VModularPhysicsList*)) {
        m_physics.add(p, f);
      }
      template <typename Q, typename T>
      void constructProcess(Q* p, void (T::*f)(G4VUserPhysicsList*)) {
        m_process.add(p, f);
      }
      template <typename Q, typename T>
      void constructParticle(Q* p, void (T::*f)(G4VUserPhysicsList*)) {
        m_particle.add(p, f);
      }
      void adopt(Geant4PhysicsList* action);
 
      virtual void constructProcesses(G4VUserPhysicsList* physics);
      virtual void constructParticles(G4VUserPhysicsList* physics);
      virtual void constructPhysics(G4VModularPhysicsList* physics);
      virtual void enable(G4VUserPhysicsList* physics);
      G4VUserPhysicsList* extensionList();
    };
 
  }    // End namespace sim
}      // End namespace dd4hep
 
#endif // DDG4_GEANT4PHYSICSLIST_H