BaseSimulationSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ISF_BASESIMULATIONSVC_H
#define ISF_BASESIMULATIONSVC_H 1
 
// STL includes
#include <string>
 
// FrameWork includes
#include "AthenaKernel/IOVSvcDefs.h"
#include "GaudiKernel/ServiceHandle.h"
#include <GaudiKernel/StatusCode.h>
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IChronoStatSvc.h"
#include "AthenaBaseComps/AthService.h"
#include "StoreGate/StoreGateSvc.h"
 
#include "GeneratorObjects/McEventCollection.h"
 
// ISF includes
#include "ISF_Interfaces/ISimulationSvc.h"
#include "ISF_Event/ISFParticle.h"
#include "ISF_Event/SimSvcID.h"
 
namespace ISF {
 
  class IParticleBroker;
  class ITruthSvc;
 
  class BaseSimulationSvc : public extends<AthService, ISimulationSvc> {
  public:
 
    //** Constructor with parameters */
    BaseSimulationSvc( const std::string& name, ISvcLocator* pSvcLocator):
      base_class(name,pSvcLocator) {};
 
    virtual ~BaseSimulationSvc() {};
 
    virtual StatusCode sysInitialize() override
    {
      if ( AthService::sysInitialize().isFailure() ) {
        ATH_MSG_FATAL( m_screenOutputPrefix << " Cannot initialize AthService! Abort.");
        return StatusCode::FAILURE;
      }
      if ( m_chrono.retrieve().isFailure()){
        ATH_MSG_FATAL( m_screenOutputPrefix << " Cannot retrieve ChronoStatSvc! Abort.");
        return StatusCode::FAILURE;
      }
 
      return StatusCode::SUCCESS;
    }
 
    const std::string& simSvcDescriptor() override { return m_simDescr.value(); }
 
    virtual StatusCode setupEvent() override
    { return StatusCode::SUCCESS; }
 
   virtual  StatusCode releaseEvent() override
    { return StatusCode::SUCCESS; }
 
    virtual StatusCode setParticleBroker( IParticleBroker *broker) override {
      m_particleBroker = broker;
      return StatusCode::SUCCESS;
    }
 
    virtual StatusCode simulateVector(const ISFParticleVector& particles, McEventCollection* mcEventCollection, McEventCollection *) override {
      // this implementation is a wrapper in case the simulator does
      // implement particle-vector input
      StatusCode sc = StatusCode::SUCCESS;
      // simulate each particle individually
      for (ISF::ISFParticle* part : particles) {
        ATH_MSG_VERBOSE( m_screenOutputPrefix <<  "Starting simulation of particle: " << part );
        if ( this->simulate(*part, mcEventCollection).isFailure()) {
          ATH_MSG_WARNING("Simulation of particle failed!" << endmsg <<
                          "   -> simulator: " << this->simSvcDescriptor() <<
                          "   -> particle : " << *part );
          sc = StatusCode::FAILURE;
        }
      }
      return sc;
    }
 
    virtual StatusCode simulate(ISFParticle& isp, McEventCollection* mcEventCollection) override;
 
    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;
    }
 
    const ServiceHandle<StoreGateSvc>& evtStore() const {return m_evtStore;};
    ServiceHandle<StoreGateSvc>& evtStore() {return m_evtStore;};
 
    const ServiceHandle<StoreGateSvc>& detStore() const {return m_detStore;};
    ServiceHandle<StoreGateSvc>& detStore() {return m_detStore;};
 
    template <class T> StatusCode retrieveTool(ToolHandle<T>& thandle){
      if (!thandle.empty() && thandle.retrieve().isFailure()){
        ATH_MSG_FATAL( m_screenOutputPrefix << "Cannot retrieve " << thandle << ". Abort.");
        return StatusCode::FAILURE;
      } else
        ATH_MSG_DEBUG(m_screenOutputPrefix << "Successfully retrieved " << thandle);
      return StatusCode::SUCCESS;
    }
 
    template <class T>
    StatusCode retrieveTools(ToolHandleArray<T>& thandleArray){
      if (!thandleArray.empty() && thandleArray.retrieve().isFailure()){
        ATH_MSG_FATAL( m_screenOutputPrefix << "Cannot retrieve " << thandleArray << ". Abort.");
        return StatusCode::FAILURE;
      } else
        ATH_MSG_DEBUG(m_screenOutputPrefix << "Successfully retrieved " << thandleArray);
      return StatusCode::SUCCESS;
    }
 
    template<class T>
    StatusCode recordCollection( T*& coll, const std::string& collName) const{
      // create if necessary
      coll = coll ? coll : new T;
      // record
      if (evtStore()->record( coll, collName).isFailure()){
        ATH_MSG_FATAL( m_screenOutputPrefix << "Cannot record collection " <<  collName << ". Abort." );
        return StatusCode::FAILURE;
      } else
        ATH_MSG_DEBUG(m_screenOutputPrefix << "Successfully recorded collection " << collName);
      return StatusCode::SUCCESS;
    }
 
    template<class T>
    StatusCode retrieveCollection(T*& coll, const std::string& collName, bool forceBreak=true) const {
      // check for existence in the soft case
      if (!forceBreak && !evtStore()->contains<T>(collName)) {
        coll = 0;
        ATH_MSG_DEBUG(m_screenOutputPrefix << "Collection does not exists (not required). Ignore.");
        return StatusCode::SUCCESS;
      }
      if ( evtStore()->retrieve(coll, collName).isFailure()){
        ATH_MSG_FATAL( m_screenOutputPrefix << "Cannot retireve collection " <<  collName << ". Abort." );
        return StatusCode::FAILURE;
      } else
        ATH_MSG_DEBUG(m_screenOutputPrefix << "Successfully retrieved collection " << collName);
      return StatusCode::SUCCESS;
    }
 
  private:
    BaseSimulationSvc();
 
    ServiceHandle<StoreGateSvc> m_evtStore{this, "EvtStore", "StoreGateSvc/StoreGateSvc",
      "Handle to a StoreGateSvc instance: it will be used to retrieve data during the course of the job"};
 
    ServiceHandle<StoreGateSvc> m_detStore{this, "DetStore", "StoreGateSvc/DetectorStore",
      "Handle to a StoreGateSvc/DetectorStore instance: it will be used to retrieve data during the course of the job"};
 
 
  protected:
    Gaudi::Property<std::string> m_simDescr{this, "Identifier", {},
      "A unique string to identify the simulator."};
 
    Gaudi::Property<std::string> m_screenOutputPrefix{this, "ScreenOutputPrefix", "isf >> ",
      "Prefix for log output"};
 
    ServiceHandle<IChronoStatSvc>   m_chrono{this, "ChronoStatService", "ChronoStatSvc"};
 
    IParticleBroker*  m_particleBroker{};
 
  };
 
 
  inline StatusCode BaseSimulationSvc::simulate(ISFParticle& /*isp*/, McEventCollection*)
  {
    return StatusCode::SUCCESS;
  }
}
 
 
#endif //> !ISF_BASESIMULATIONSVC_H