BaseSimulatorTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ISF_INTERFACES_BASESIMULATORTOOL_H
#define ISF_INTERFACES_BASESIMULATORTOOL_H 1
 
// STL includes
#include <string>
 
// Gaudi
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IChronoStatSvc.h"
 
// Athena
#include "AthenaKernel/IOVSvcDefs.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
// DetectorDescription
#include "AtlasDetDescr/AtlasRegion.h"
#include "AtlasDetDescr/AtlasRegionHelper.h"
 
// ISF includes
#include "ISF_Interfaces/ISimulatorTool.h"
#include "ISF_Event/ISFParticle.h"
#include "ISF_Event/SimSvcID.h"
 
namespace ISF {
 
  class BaseSimulatorTool : public extends<AthAlgTool, ISimulatorTool> {
  public:
 
    //** Constructor with parameters */
    BaseSimulatorTool(const std::string& type, const std::string& name,  const IInterface* parent)
      : base_class(type, name, parent)
    {
      // Service handling
      declareProperty("ChronoStatService",    m_chronoSvcName     );
    }
 
    virtual ~BaseSimulatorTool() {}
 
    virtual StatusCode sysInitialize() override
    {
      ATH_CHECK( AthAlgTool::sysInitialize() );
      ATH_CHECK( serviceLocator()->service(m_chronoSvcName, m_chrono ) );
      return StatusCode::SUCCESS;
    }
 
    virtual StatusCode initialize() override
    {
      return StatusCode::SUCCESS;
    }
 
    virtual StatusCode setupEvent(const EventContext&) override
    { return StatusCode::FAILURE; }
 
    virtual StatusCode setupEventST() override
    { return setupEvent(Gaudi::Hive::currentContext()); }
 
    virtual StatusCode simulate( ISFParticle& , ISFParticleContainer&, McEventCollection*) override
    { return StatusCode::FAILURE; }
 
    virtual StatusCode simulateVector(const ISFParticleVector& particles, ISFParticleContainer& secondaries, McEventCollection* mcEventCollection, McEventCollection *) override
    {
      // this implementation is a wrapper in case the simulator does
      // implement particle-vector input
 
      // simulate each particle individually
      for (auto* cisp : particles) {
        ATH_MSG_VERBOSE( "Starting simulation of particle: " << (*cisp) );
        ATH_CHECK(this->simulate(*cisp, secondaries, mcEventCollection));
      }
      return StatusCode::SUCCESS;
 
    }
 
    virtual StatusCode releaseEvent(const EventContext&) override
    { return StatusCode::FAILURE; }
 
    virtual StatusCode releaseEventST() override
    { return releaseEvent(Gaudi::Hive::currentContext()); }
 
    const ChronoEntity* chronoStart(const IChronoSvc::ChronoTag& tag ) {
      if (m_chrono) return m_chrono->chronoStart( tag);
      return nullptr;
    }
 
    const ChronoEntity* chronoStop(const IChronoSvc::ChronoTag& tag ) {
      if (m_chrono) return m_chrono->chronoStop( tag);
      return nullptr;
    }
 
  private:
    BaseSimulatorTool();
 
  protected:
    std::string       m_chronoSvcName{"ChronoStatSvc"};
 
    IChronoStatSvc*   m_chrono{};
 
  };
 
}
 
 
#endif //> !ISF_INTERFACES_BASESIMULATORTOOL_H