ISF_Geant4/ISF_Geant4Tools/src/TransportTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ISF_GEANT4TOOLS_TRANSPORTTOOL_H
#define ISF_GEANT4TOOLS_TRANSPORTTOOL_H
 
 
 
// Gaudi headers
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
 
// DetectorDescription
#include "AtlasDetDescr/AtlasRegion.h"
 
// Athena headers
#include "AthenaKernel/IAthRNGSvc.h"
//#include "AthenaKernel/SlotSpecificObj.h"
#include "G4AtlasInterfaces/IUserActionSvc.h"
#include "G4AtlasInterfaces/IDetectorGeometrySvc.h"
#include "G4AtlasInterfaces/ISensitiveDetectorMasterTool.h"
#include "G4AtlasInterfaces/IFastSimulationMasterTool.h"
#include "G4AtlasInterfaces/IPhysicsListSvc.h"
#include "G4AtlasInterfaces/IUserLimitsSvc.h"
#include "CxxUtils/checker_macros.h"
 
// ISF includes
#include "ISF_Interfaces/BaseSimulatorTool.h"
//#include "ISF_Interfaces/ISimulationSelector.h"
#include "ISF_Interfaces/IInputConverter.h"
//#include "ISF_Geant4Tools/IG4RunManagerHelper.h"
 
#include "TrackProcessorUserActionBase.h"
#include "AtlasHepMC/GenEvent_fwd.h"
// TBB
#include "tbb/concurrent_unordered_map.h"
 
// STL headers
#include <string>
#include <thread>
 
 
 
class G4Event;
class G4Timer;
class G4AtlasRunManager;
 
namespace ISF {
  class ISFParticle;
}
 
 
 
namespace iGeant4
{
 
  class G4TransportTool : public ISF::BaseSimulatorTool {
 
  public:
    G4TransportTool(const std::string&,const std::string&,const IInterface*);
 
    virtual ~G4TransportTool () = default;
 
    virtual StatusCode initialize() override final;
 
    void initializeOnce ATLAS_NOT_THREAD_SAFE ();
 
    virtual StatusCode finalize() override final;
 
    void finalizeOnce();
 
    virtual StatusCode simulate( ISF::ISFParticle& isp, ISF::ISFParticleContainer& secondaries, McEventCollection* mcEventCollection ) override;
 
    virtual StatusCode simulateVector( const ISF::ISFParticleVector& particles, ISF::ISFParticleContainer& secondaries, McEventCollection* mcEventCollection, McEventCollection *shadowTruth=nullptr ) override;
 
    virtual StatusCode setupEvent(const EventContext&) override;
 
    virtual StatusCode releaseEvent(const EventContext&) override;
 
    virtual ISF::SimulationFlavor simFlavor() const override { return ISF::Geant4; };
 
  private:
 
    void commandLog(int returnCode, const std::string& commandString) const;
 
    HepMC::GenEvent* genEvent(McEventCollection* mcEventCollection) const;
 
 
    // timing checks
    Gaudi::Property<bool> m_doTiming{this, "PrintTimingInfo", true, ""};
    //float m_runTime;
    float m_accumulatedEventTime{0.};
    float m_accumulatedEventTimeSq{0.};
    unsigned int m_nrOfEntries{0};
 
    G4Timer* m_runTimer{nullptr};
    G4Timer* m_eventTimer{nullptr};
 
    // user actions that can return secondaries
    // Must be indexed by thread ID, and accessible from multiple threads
    using passbackAction_t = G4UA::iGeant4::TrackProcessorUserActionBase;
    using passbackActionMap_t = tbb::concurrent_unordered_map< std::thread::id, std::vector< passbackAction_t* >, std::hash<std::thread::id> >;
    mutable passbackActionMap_t m_secondaryActions ATLAS_THREAD_SAFE;
 
    Gaudi::Property<std::string> m_mcEventCollectionName{this, "McEventCollection", "TruthEvent", ""};
    // PublicToolHandle<ISF::IG4RunManagerHelper>  m_g4RunManagerHelper{this, "G4RunManagerHelper", "iGeant4::G4RunManagerHelper/G4RunManagerHelper", ""};
    // G4AtlasRunManager    *m_pRunMgr{};
 
    Gaudi::Property<std::string> m_libList{this, "Dll", "", ""};
    Gaudi::Property<std::string> m_physList{this, "Physics", "", ""};
    Gaudi::Property<std::string> m_fieldMap{this, "FieldMap", "", ""};
    Gaudi::Property<bool> m_releaseGeoModel{this, "ReleaseGeoModel", true, ""};
    Gaudi::Property<bool> m_recordFlux{this, "RecordFlux", false, ""};
    Gaudi::Property<std::vector<std::string> > m_g4commands{this, "G4Commands", {}, "Commands to send to the G4UI"};
    Gaudi::Property<bool> m_useMT{this,"MultiThreading",  false, "Multi-threading specific settings"};
    Gaudi::Property<bool> m_activateParallelGeometries{this, "ActivateParallelWorlds", false, "Toggle on/off the G4 parallel geometry system"};
    // Random number service
    ServiceHandle<IAthRNGSvc> m_rndmGenSvc{this, "RandomNumberService", "AthRNGSvc", ""};
    Gaudi::Property<std::string> m_randomStreamName{this, "RandomStreamName", "Geant4", ""};
    ServiceHandle<IUserLimitsSvc> m_userLimitsSvc{this, "UserLimitsSvc", "UserLimitsSvc", ""};
    ServiceHandle<G4UA::IUserActionSvc> m_userActionSvc{this, "UserActionSvc", "", ""};
    ServiceHandle<IDetectorGeometrySvc> m_detGeoSvc{this, "DetGeoSvc", "DetectorGeometrySvc", ""};
    ServiceHandle<ISF::IInputConverter> m_inputConverter{this, "InputConverter", "ISF_InputConverter", ""};
    ServiceHandle<IPhysicsListSvc> m_physListSvc{this, "PhysicsListSvc", "PhysicsListSvc", ""};
    PublicToolHandle<ISensitiveDetectorMasterTool> m_senDetTool{this, "SenDetMasterTool", "SensitiveDetectorMasterTool", ""};
    PublicToolHandle<IFastSimulationMasterTool> m_fastSimTool{this, "FastSimMasterTool", "FastSimulationMasterTool", ""};
 
  };
 
 
}
 
 
#endif // ISF_GEANT4TOOLS_TRANSPORTTOOL_H