Geant4InputAction.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_GEANT4INPUTACTION_H
#define DDG4_GEANT4INPUTACTION_H
 
// Framework include files
#include <DDG4/Geant4Vertex.h>
#include <DDG4/Geant4Particle.h>
#include <DDG4/Geant4GeneratorAction.h>
#include <Parsers/Parsers.h>
 
// C/C++ include files
#include <memory>
#include <set>
#include <vector>
 
// Forward declarations
class G4Event;
class G4Run;
 
namespace dd4hep  {
 
  namespace sim  {
    
    class Geant4InputAction;
 
 
    class Geant4EventReader  {
 
    public:
      typedef Geant4Vertex   Vertex;
      typedef Geant4Particle Particle;
      typedef std::vector<Particle*> Particles;
      typedef std::vector<Vertex*> Vertices;
      enum EventReaderStatus {
        EVENT_READER_ERROR=0,
        EVENT_READER_OK=1,
        EVENT_READER_NO_DIRECT=2,
        EVENT_READER_NO_PRIMARIES=4,
        EVENT_READER_NO_FACTORY=6,
        EVENT_READER_IO_ERROR=8,
        EVENT_READER_EOF=10
      };
    protected:
      std::string m_name;
      bool m_directAccess  { false };
      int  m_currEvent     { 0 };
      Geant4InputAction *m_inputAction   { nullptr };
 
 
      template <typename T>
      void _getParameterValue( std::map< std::string, std::string > & parameters,
                               std::string const& parameterName,
                               T& parameter, T defaultValue ) {
 
        if( parameters.find( parameterName ) != parameters.end() ) {
          dd4hep::Parsers::parse( parameter, parameters.at( parameterName ) );
          parameters.erase( parameterName );
        } else {
          parameter = std::move(defaultValue);
        }
      }
 
    public:
      Geant4EventReader(const std::string& nam);
      virtual ~Geant4EventReader();
      Geant4Context* context() const;
      void setInputAction(Geant4InputAction* action);
      const std::string& name()  const   {  return m_name;         }
      bool hasDirectAccess() const       {  return m_directAccess; }
      int currentEventNumber() const     {  return m_currEvent;    }
 
      virtual EventReaderStatus moveToEvent(int event_number);
      virtual EventReaderStatus skipEvent();
 
      virtual EventReaderStatus readParticles(int event_number, 
                                              Vertices&  vertices,
                                              Particles& particles) = 0;
 
      virtual EventReaderStatus setParameters( std::map< std::string, std::string > & ) {return EVENT_READER_OK; }
 
      virtual void checkParameters( std::map< std::string, std::string >& );
 
      virtual void registerRunParameters() {}
    };
 
 
    class Geant4InputAction : public Geant4GeneratorAction {
 
    public:
      typedef Geant4Vertex   Vertex;
      typedef Geant4Particle Particle;
      typedef std::vector<Particle*> Particles;
      typedef std::vector<Vertex*> Vertices;
    protected:
      std::string         m_input;
      int                 m_firstEvent;
      int                 m_mask;
      double              m_momScale;
      Geant4EventReader*  m_reader;
      int m_currentEventNumber;
      bool m_abort;
      std::map< std::string, std::string> m_parameters;
 
      std::set<int> m_alternativeDecayStatuses = {};
 
      void beginRun(const G4Run*);
 
      void createReader();
    public:
      int readParticles(int event_number,
                        Vertices&  vertices,
                        Particles& particles);
      using PropertyMask = dd4hep::detail::ReferenceBitMask<int>;
      void setGeneratorStatus(int generatorStatus, PropertyMask& status);
 
      std::string issue(int i) const;
 
      Geant4InputAction(Geant4Context* context, const std::string& name);
      virtual ~Geant4InputAction();
      Particles* new_particles() const { return new Particles; }
      virtual void operator()(G4Event* event)   override;
    };
  }     /* End namespace sim   */
}       /* End namespace dd4hep */
#endif // DDG4_GEANT4INPUTACTION_H