ISF::SimKernel Class Reference

This is the purely sequential simulation kernel, executed once per event. More...

#include <SimKernel.h>

Inheritance diagram for ISF::SimKernel:

Public Member Functions
	SimKernel (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters.
virtual	~SimKernel ()
	Destructor.
StatusCode	initialize ()
	Athena algorithm's interface method initialize()
StatusCode	execute ()
	Athena algorithm's interface method execute()
StatusCode	finalize ()
	Athena algorithm's interface method finalize()
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	initSimSvcs (SimSelectorToolArray &simSelectorTools)
StatusCode	prepareInput (SG::ReadHandle< McEventCollection > &inputTruth, SG::WriteHandle< McEventCollection > &outputTruth, std::unique_ptr< McEventCollection > &shadowTruth, ISFParticleContainer &simParticles) const
	Convert input generator particles to ISFParticles and copy input generator truth collection into output simulation truth collection.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandle< McEventCollection >	m_inputHardScatterEvgen
	Input/output truth collections and input conversion.
SG::ReadHandle< McEventCollection >	m_inputPileupEvgen
	input pileup collection
SG::WriteHandle< McEventCollection >	m_outputHardScatterTruth
	output hard scatter truth collection
SG::WriteHandle< McEventCollection >	m_outputPileupTruth
	output pileup truth collection
ServiceHandle< IInputConverter >	m_inputConverter
	input->ISFParticle converter
ToolHandle< IGenEventFilter >	m_truthPreselectionTool {this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"}
BooleanProperty	m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation" }
ServiceHandle< IParticleBroker >	m_particleBroker
	Central particle broker service.
ServiceHandle< ITruthSvc >	m_truthRecordSvc
	Central truth service.
std::array< PublicToolHandleArray< ISimulationSelector >, AtlasDetDescr::fNumAtlasRegions >	m_simSelectors
	The Simulation Selector Chains.
ServiceHandle< Simulation::IZeroLifetimePatcher >	m_qspatcher
	Quasi-Stable Particle Simulation Patcher.
ToolHandleArray< IEventFilterTool >	m_eventFilters
	The Event Filters.
bool	m_doMemMon
	The Memory Info Tool.
ToolHandle< IMonitoringTool >	m_memMon
unsigned int	m_memUsageEvts
std::vector< ISimulationSvc * >	m_simSvcs
	Simulators to be used.
std::vector< std::string >	m_simSvcNames
	SimSvc names.
ISF::SimSvcID	m_numSimSvcs
	total number of SimSvcs used
unsigned int	m_numISFEvents
	keep track of the number of events processed
bool	m_doCPUMon
	CPU Benchmarking.
PMonUtils::CustomBenchmark *	m_benchSimID
long int	m_numParticles
	Statistics.
size_t	m_maxParticleVectorSize
	tuning
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

This is the purely sequential simulation kernel, executed once per event.

The ISF::SimKernel is configured by providing:

• one particle stack service (ISF::IParticleMgr )
• one truth record service (ISF::ITruthSvc)
• n simulation services for the subdetector geometries ( ISF::ISimulationSvc )

The AthAlgorithm::initialize() framework call triggers:

• retrieval of the given components, and subsequent inialize() calls on them
• translation of the ServiceHandleArray<ISF::ISimulationSvc> into a std::vector<ISF::ISimulationSvc*> for fast access of the geometry service

The AthAlgorithm::execute() framework call triggers the following sequence of calls :

• (1) the stack filling call to the ParticleMgr
• (2) the setupEvent() calls to the provided components
• (3) the loop over the particle stack
• (4) the releaseEvent() calls to the provided components

Author

Andreas.Salzburger -at- cern.ch , Elmar.Ritsch -at- cern.ch

Definition at line 68 of file SimKernel.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

SimKernel()

ISF::SimKernel::SimKernel	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Constructor with parameters.

Definition at line 39 of file SimKernel.cxx.

                                                                         :
  ::AthAlgorithm( name, pSvcLocator ),
  m_inputHardScatterEvgen(),
  m_inputPileupEvgen(),
  m_outputHardScatterTruth(),
  m_outputPileupTruth(),
  m_inputConverter("",name),
  m_particleBroker("ISF_ParticleBroker", name),
  m_truthRecordSvc("ISF_TruthRecordSvc", name),
  m_qspatcher("", name),
  m_doMemMon(true),
  m_memMon("MemMonitoringTool"),
  m_memUsageEvts(1000),
  m_simSvcs(ISF::fMaxNumAtlasSimIDs),
  m_simSvcNames(ISF::fMaxNumAtlasSimIDs),
  m_numSimSvcs(ISF::fFirstAtlasSimID), // ==1 since UndefinedSimID is always there
  m_numISFEvents(0),
  m_doCPUMon(true),
  //m_benchPDGCode(0), TODO: implement this if feasible
  //m_benchGeoID(0), TODO: implement this if feasible
  m_benchSimID(0),
  m_numParticles(0),
  m_maxParticleVectorSize(10240)
{
    declareProperty("InputHardScatterCollection",
                    m_inputHardScatterEvgen,
                    "Input Hard Scatter EVGEN collection.");
    declareProperty("InputPileupCollection",
                     m_inputPileupEvgen,
                    "Input Pileup EVGEN collection.");
    declareProperty("OutputHardScatterTruthCollection",
                    m_outputHardScatterTruth,
                    "Output Hard Scatter Truth collection.");
    declareProperty("OutputPileupTruthCollection",
                     m_outputPileupTruth,
                    "Output Pileup Truth collection.");
    declareProperty("InputConverter",
                    m_inputConverter,
                    "Input McEventCollection->ISFParticleContainer conversion service.");
 
    // the general services and tools needed
    declareProperty("ParticleBroker"             , m_particleBroker                  );
    declareProperty("TruthRecordService"         , m_truthRecordSvc                  );
    declareProperty("DoCPUMonitoring"            , m_doCPUMon                        );
    declareProperty("DoMemoryMonitoring"         , m_doMemMon                        );
    declareProperty("MemoryMonitoringTool"       , m_memMon                          );
    declareProperty("SummarizeMemUsageEveryNEvts", m_memUsageEvts                    );
    // Quasi-stable particle sim
    declareProperty("QuasiStablePatcher", m_qspatcher);
    // event filter
    declareProperty("EventFilterTools"           , m_eventFilters                      );
    // tuning parameters
    declareProperty("MaximumParticleVectorSize"  , m_maxParticleVectorSize             );
}

~SimKernel()

ISF::SimKernel::~SimKernel ( )

virtual

Destructor.

Definition at line 96 of file SimKernel.cxx.

{}

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode ISF::SimKernel::execute

(

)

Athena algorithm's interface method execute()

Definition at line 323 of file SimKernel.cxx.

{
 
  ATH_MSG_DEBUG ("Executing ...");
 
  // dump and record current memory stats
  if ( m_doMemMon && (m_numISFEvents==0) ) {
    m_memMon->dumpCurrent( "before 1st event", false );
    m_memMon->recordCurrent("before 1st event");
  }
 
  auto hitCollections = std::make_shared<HitCollectionMap>();
 
  // read and convert input
  //  a. hard-scatter
  ISFParticleContainer simParticles{}; // particles for ISF simulation
  std::unique_ptr<McEventCollection> shadowTruth{};
  std::unique_ptr<McEventCollection> shadowPileUpTruth{};
  ATH_CHECK( prepareInput(m_inputHardScatterEvgen, m_outputHardScatterTruth, shadowTruth, simParticles) );
  //  b. pileup
  if (!m_inputPileupEvgen.key().empty()) {
    ATH_CHECK( prepareInput(m_inputPileupEvgen, m_outputPileupTruth, shadowPileUpTruth, simParticles) );
  }
 
  // -----------------------------------------------------------------------------------------------
  // Step 1: Initialize the particle stack and the TruthManager, ABORT if failure
  ATH_CHECK ( m_particleBroker->initializeEvent( std::move(simParticles) ) );
 
  const int largestGeneratedParticleBC =  (m_outputHardScatterTruth->empty()) ? HepMC::UNDEFINED_ID
    : HepMC::maxGeneratedParticleBarcode(m_outputHardScatterTruth->at(0)); // TODO make this more robust
  const int largestGeneratedVertexBC =  (m_outputHardScatterTruth->empty()) ? HepMC::UNDEFINED_ID
    : HepMC::maxGeneratedVertexBarcode(m_outputHardScatterTruth->at(0)); // TODO make this more robust
  // tell TruthService we're starting a new event
  ATH_CHECK( m_truthRecordSvc->initializeTruthCollection(largestGeneratedParticleBC, largestGeneratedVertexBC) );
  // -----------------------------------------------------------------------------------------------
 
 
  // -----------------------------------------------------------------------------------------------
  // Step 2: Initialize the Event
  {
    std::vector<ISimulationSvc*>::iterator fSimSvcIter     = m_simSvcs.begin();
    std::vector<ISimulationSvc*>::iterator fSimSvcIterEnd  = m_simSvcs.end();
    for ( ; fSimSvcIter != fSimSvcIterEnd; ++fSimSvcIter ){
      ISimulationSvc *curSimSvc = (*fSimSvcIter);
      // if simulation with current flavour is registered
      //  -> setupEvent
      if ( curSimSvc){
        auto status = [&] ATLAS_NOT_THREAD_SAFE {
          if (auto* curSimSvcG4 =
                  dynamic_cast<ISF::BaseSimulationG4Svc*>(curSimSvc)) {
            // if the simulator is a Geant4 one, we need to pass the event info
            return curSimSvcG4->setupEvent(*hitCollections);
          } else {
            return curSimSvc->setupEvent();
          }
        }();
 
        if (status.isFailure()) {
          ATH_MSG_WARNING("Event setup failed for "
                          << curSimSvc->simSvcDescriptor());
        } else {
          ATH_MSG_DEBUG("Event setup done for "
                        << curSimSvc->simSvcDescriptor());
        }
      }
    }
  }
  // -----------------------------------------------------------------------------------------------
 
 
 
  // -----------------------------------------------------------------------------------------------
  // Step 3: ISimulation KERNEL : loop over particle stack, until empty
  unsigned int loopCounter{0};
  ATH_MSG_DEBUG( "Starting simulation loop, initial particle stack size: " << m_particleBroker->numParticles());
  while ( m_particleBroker->numParticles() ) {
    ++loopCounter;
    ATH_MSG_VERBOSE("Main Loop pass no. " << loopCounter);
    ATH_MSG_VERBOSE("Queue starts with " << m_particleBroker->numParticles() << " particles.");
    // get next vector of particles for simulation
    const ISF::ISFParticleVector &particles = m_particleBroker->popVector(m_maxParticleVectorSize);
    const unsigned int numParticlesLeftInBroker = m_particleBroker->numParticles();
    int numParticles = particles.size();
 
    // particle vector empty -> end simulation
    if (numParticles==0) break;
 
    // for job statistics
    m_numParticles += numParticles;
 
    // retrieve the particle destination simulator (and geoID)
    const ISFParticle *firstP = particles.front();
    ISF::SimSvcID simID = firstP->nextSimID();
    //AtlasDetDescr::AtlasRegion geoID = firstP->nextGeoID();
 
    ATH_MSG_DEBUG  ( "Took " << numParticles << " particles from queue (remaining: " << m_particleBroker->numParticles() << ")" );
    ATH_MSG_VERBOSE( " -> All particles will be sent to '" << m_simSvcNames[simID] << "' simulator (SimSvcID=" << simID << ")"  );
 
    #ifdef ISFDEBUG
    if (loopCounter>100 && numParticles<3) {
      ATH_MSG_INFO("Main Loop pass no. " << loopCounter);
      ATH_MSG_INFO("Selected " << numParticles << " particles to be processed by " << m_simSvcNames[simID]);
      for ( const ISFParticle *particle : particles ) {
        ATH_MSG_INFO(*particle);
      }
    }
    #endif // ISFDEBUG
 
    // ensure that all particles in the vector have the same SimID
    for ( const ISFParticle *particle : particles ) {
      if ( particle->nextSimID() != simID ) {
        ATH_MSG_WARNING( "Particle with SimID " << particle->nextSimID() << " found in vector with expected ID " << simID );
      }
    }
 
    // block defines scope for Benchmarks
    //  -> benchmarks will be stared/stopped automatically via the CustomBenchmarkGuard
    //     constructor and destructor, respectively
    {
      // setup sim svc benchmarks
      PMonUtils::CustomBenchmarkGuard benchSimID( m_benchSimID  , simID , numParticles );
 
      // ===> simulate particle
      // NB Passing only the hard-scatter McEventCollection is not
      // correct if Geant4 simulation were to be used for pile-up Hits
      // in Fast Chain.
      ATH_MSG_VERBOSE("Selected " << particles.size() << " particles to be processed by " <<  m_simSvcNames[simID]);
      if (auto* curSimSvcG4 =
              dynamic_cast<ISF::BaseSimulationG4Svc*>(m_simSvcs[simID])) {
        // if the simulator is a Geant4 one, we need to pass the event info
        if (curSimSvcG4
                ->simulateVector(particles, m_outputHardScatterTruth.ptr(),
                                 hitCollections, shadowTruth.get())
                .isFailure()) {
          ATH_MSG_WARNING("Simulation of particles failed in Simulator: "
                          << m_simSvcNames[simID]);
        }
      } else if (m_simSvcs[simID]
                     ->simulateVector(particles, m_outputHardScatterTruth.ptr(),
                                      shadowTruth.get())
                     .isFailure()) {
        ATH_MSG_WARNING( "Simulation of particles failed in Simulator: " << m_simSvcNames[simID]);
      }
      ATH_MSG_VERBOSE(m_simSvcNames[simID] << " returned " << m_particleBroker->numParticles()-numParticlesLeftInBroker << " new particles to be added to the queue." );
    }
 
  }
  ATH_MSG_VERBOSE("Final status: queue contains " << m_particleBroker->numParticles() << " particles.");
  // -----------------------------------------------------------------------------------------------
 
 
 
  // Step 4: Finalize the Event
  //  -> stack service
  if ( m_particleBroker->finalizeEvent().isFailure()) {
    ATH_MSG_WARNING( "ParticleBroker returned with an error in event finalization." );
  }
  //  -> simulator services
  {
    std::vector<ISimulationSvc*>::iterator fSimSvcIter     = m_simSvcs.begin();
    std::vector<ISimulationSvc*>::iterator fSimSvcIterEnd  = m_simSvcs.end();
    for ( ; fSimSvcIter != fSimSvcIterEnd; ++fSimSvcIter ){
      ISimulationSvc *curSimSvc = (*fSimSvcIter);
      // if simulation with current flavour is registered
      //  -> releaseEvent()
      if ( curSimSvc){
        auto status = [&] ATLAS_NOT_THREAD_SAFE {
          if (auto* curSimSvcG4 =
                  dynamic_cast<ISF::BaseSimulationG4Svc*>(curSimSvc)) {
            // if the simulator is a Geant4 one, we need to pass the event info
            return curSimSvcG4->releaseEvent(*hitCollections);
          } else {
            return curSimSvc->releaseEvent();
          }
        }();
 
        if (status.isFailure()) {
          ATH_MSG_WARNING("Event release failed for "
                          << curSimSvc->simSvcDescriptor());
        } else {
          ATH_MSG_DEBUG("Event release done for "
                        << curSimSvc->simSvcDescriptor());
        }
      }
    } // -> loop over SimSvcs
  }
 
  if ( m_truthRecordSvc->releaseEvent().isFailure() ){
      ATH_MSG_FATAL( "Event finalize failed for TruthService. Abort." );
      return StatusCode::FAILURE;
  }
 
  // Step 4a: Remove QS patch if required
  if(!m_qspatcher.empty()) {
    for (HepMC::GenEvent* currentGenEvent : *m_outputHardScatterTruth ) {
      ATH_CHECK(m_qspatcher->removeWorkaround(*currentGenEvent));
    }
  }
 
  // Step 5: Check Any Filters
  ToolHandleArray<IEventFilterTool>::iterator eventFilter(m_eventFilters.begin());
  const ToolHandleArray<IEventFilterTool>::iterator endOfEventFilters(m_eventFilters.end());
  while (eventFilter != endOfEventFilters) {
    if (!((**eventFilter).eventPassesFilter())) {
      setFilterPassed(false);
      ATH_MSG_INFO("This event failed the " << (**eventFilter).name() << " Filter. Therefore it will not be recorded.");
      break;
    }
    ++eventFilter;
  }
 
 
  // -----------------------------------------------------------------------------------------------
 
  // dump current memory monitoring information
  if (m_doMemMon) {
    std::string evtStr = std::to_string( m_numISFEvents );
    std::string descr("after event " + evtStr);
    m_memMon->dumpCurrent( descr.c_str(), true);
 
    // ISF internal event counting
    m_numISFEvents++;
 
    // memory monitoring records for the final summary
    if ( !(m_numISFEvents%m_memUsageEvts) ) m_memMon->recordCurrent( descr.c_str() );
    else if ( m_numISFEvents==1)   m_memMon->recordCurrent("after   1st event");
    else if ( m_numISFEvents==2)   m_memMon->recordCurrent("after   2nd event");
    else if ( m_numISFEvents==10)  m_memMon->recordCurrent("after  10th event");
    else if ( m_numISFEvents==100) m_memMon->recordCurrent("after 100th event");
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode ISF::SimKernel::finalize

(

)

Athena algorithm's interface method finalize()

Definition at line 189 of file SimKernel.cxx.

{
  ATH_MSG_INFO ( "Finalizing ..." );
 
  // record current memory usage
  if (m_doMemMon) m_memMon->recordCurrent("at beginning of ISF SimKernel finalize()");
 
  // statistics: number of particles handled
  ATH_MSG_INFO(" Number of particles handled by the ISF SimKernel: " << m_numParticles );
 
  ATH_MSG_INFO(" ========================= ISF Timing Stats  =========================");
  // Benchmarking: by SimID
  if (m_benchSimID) {
    ATH_MSG_INFO("Breakdown of simulation loop by SimulatorID:");
    //TODO: for (unsigned simID=0;simID<m_benchSimID->size();++simID) {
    for (unsigned simID=0;simID<ISF::fMaxNumAtlasSimIDs;++simID) {
      uint64_t count;
      double time_ms;
      m_benchSimID->getData(simID, count, time_ms);
      if (count>0)
       ATH_MSG_INFO("  "<<std::setprecision(4)
                        <<m_simSvcNames[simID]<<" (id="<<simID<<")"
                        <<"\t\tn="<<count<<"\t\tt=" <<time_ms<<" ms\t\tt/n="<<time_ms/count<<" ms"
                        <<std::setprecision(-1) );
    }
 
    delete m_benchSimID;
    m_benchSimID=0;
  }
 
  //TODO: implement this if feasible
  // Benchmarking: by GeoID
  //if (m_benchGeoID) {
  //  ATH_MSG_INFO("Breakdown of simulation loop by GeoID:");
  //  //TODO: for (unsigned geoID=0;geoID<m_benchGeoID->size();++simID) {
  //  for (unsigned geoID=AtlasDetDescr::fFirstAtlasRegion;geoID<AtlasDetDescr::fNumAtlasRegions;++geoID) {
  //    uint64_t count;
  //    double time_ms;
  //    m_benchGeoID->getData(geoID, count, time_ms);
  //    if (count>0)
  //     ATH_MSG_INFO("  "<<std::setprecision(4)
  //                      <<AtlasDetDescr::AtlasRegionHelper::getName(geoID)<<" (id="<<geoID<<")"
  //                      <<"\t\tn="<<count<<"\t\tt=" <<time_ms<<" ms\t\tt/n="<<time_ms/count<<" ms"
  //                      <<std::setprecision(-1) );
  //  }
 
  //  delete m_benchGeoID;
  //  m_benchGeoID=0;
  //}
 
  //TODO: implement this if feasible
  // Benchmarking: by PDGCode
  //if (m_benchPDGCode) {
  //  ATH_MSG_INFO("Breakdown of simulation loop by PDG Particle Code:");
  //  //TODO: for (unsigned geoID=0;geoID<m_benchGeoID->size();++simID) {
  //  for (int pdgCode=ISF::fUndefinedPDGCode;pdgCode<ISF::fMaxBenchmarkPDGCode;++pdgCode) {
  //    uint64_t count;
  //    double time_ms;
  //    m_benchPDGCode->getData(pdgCode, count, time_ms);
  //    if (count>0)
  //     ATH_MSG_INFO( std::setprecision(4)
  //                   << "  |PDGCode|="<<pdgCode<<", n="
  //                   <<count<<", t="<<time_ms<<" ms, t/n="<<time_ms/count<<" ms"
  //                   <<std::setprecision(-1) );
  //  }
 
  //  delete m_benchPDGCode;
  //  m_benchPDGCode=0;
  //}
 
  // call the memory monitoring tool to print some memory stats
  if (m_doMemMon) {
    ATH_MSG_INFO(" ====================== ISF Memory Usage Stats =======================");
    m_memMon->dumpSummary("end of ISF event");
  }
 
  ATH_MSG_INFO(" =====================================================================");
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ISF::SimKernel::initialize

(

)

Athena algorithm's interface method initialize()

Definition at line 101 of file SimKernel.cxx.

{
 
  ATH_MSG_VERBOSE ( "--------------------------------------------------------" );
  ATH_MSG_INFO( "Initializing the ISF KERNEL " );
 
  // setup memory monitoring Tool
  if ( m_doMemMon) {
    // memory monitoring tool given -> do memory monitoring
    ATH_CHECK( m_memMon.retrieve() );
    ATH_MSG_INFO( "- MemoryMonitoring  : " << m_memMon.typeAndName() );
    // record current memory usage
    m_memMon->recordCurrent("at beginning of SimKernel initialize()");
  }
 
 
  // setup CPU Benchmarks
  if (m_doCPUMon) {
    //if (!m_benchPDGCode)
    //  m_benchPDGCode = new PMonUtils::CustomBenchmark(ISF::fMaxBenchmarkPDGCode);
    //if (!m_benchGeoID)
    //  m_benchGeoID   = new PMonUtils::CustomBenchmark(AtlasDetDescr::fNumAtlasRegions     );
    if (!m_benchSimID)
      m_benchSimID   = new PMonUtils::CustomBenchmark(ISF::fMaxNumAtlasSimIDs  );
  }
 
  // retrieve the stack service
  ATH_CHECK ( m_particleBroker.retrieve() );
  ATH_MSG_INFO( "- ParticleBroker   : " << m_particleBroker.typeAndName() );
 
  // the truth service
  ATH_CHECK ( m_truthRecordSvc.retrieve() );
  ATH_MSG_INFO( "- TruthRecordSvc   : " << m_truthRecordSvc.typeAndName() );
 
  // initialize all SimulationServices
  //
  for ( short geoID=AtlasDetDescr::fFirstAtlasRegion; geoID<AtlasDetDescr::fNumAtlasRegions ; ++geoID) {
    ATH_CHECK ( initSimSvcs(m_simSelectors[geoID]) );
  }
 
  ATH_CHECK( m_inputConverter.retrieve() );
  if ( not m_truthPreselectionTool.empty() ) {
    ATH_CHECK(m_truthPreselectionTool.retrieve());
  }
 
  if(!m_qspatcher.empty()) {
    ATH_CHECK(m_qspatcher.retrieve());
  }
 
  // initialize all the EventFilterTools
  ATH_CHECK ( m_eventFilters.retrieve() );
  ATH_MSG_INFO( "The following Event Filters are defined:");
  ATH_MSG_INFO( m_eventFilters );
 
  // free unused space
  m_simSvcs.resize( m_numSimSvcs);
  m_simSvcNames.resize( m_numSimSvcs);
  // some screen output
  ATH_MSG_INFO ( "The following SimulationSvc are registered to ISF:");
  for (SimSvcID id=ISF::fFirstAtlasSimID; id<m_numSimSvcs; id++)
    ATH_MSG_INFO ( "ID: " << id << "\t  Name: '" << m_simSvcNames[id]
                   << "'");
 
  // setup the simulation selectors
  //
  for ( short geoID=AtlasDetDescr::fFirstAtlasRegion; geoID<AtlasDetDescr::fNumAtlasRegions ; ++geoID) {
    ATH_CHECK ( m_particleBroker->registerSimSelector( m_simSelectors[geoID], (AtlasDetDescr::AtlasRegion)geoID) );
  }
  // screen output
  ATH_MSG_INFO( "The following routing chains are defined:");
  for ( short geoID = 0; geoID<AtlasDetDescr::fNumAtlasRegions ; ++geoID) {
    ATH_MSG_INFO( AtlasDetDescr::AtlasRegionHelper::getName(geoID)
                  << " (GeoID=" << geoID << "): \t" << m_simSelectors[geoID]);
  }
 
  // record current memory usage
  if (m_doMemMon) m_memMon->recordCurrent("at end of ISF SimKernel initialize()");
 
  ATH_CHECK ( m_inputHardScatterEvgen.initialize() );
  ATH_CHECK ( m_inputPileupEvgen.initialize( !m_inputPileupEvgen.key().empty() ) );
  ATH_CHECK ( m_outputHardScatterTruth.initialize() );
  ATH_CHECK ( m_outputPileupTruth.initialize( !m_outputPileupTruth.key().empty() ) );
 
  // intialziation successful
  return StatusCode::SUCCESS;
}

initSimSvcs()

StatusCode ISF::SimKernel::initSimSvcs ( SimSelectorToolArray & simSelectorTools )

private

Definition at line 271 of file SimKernel.cxx.

{
  // (1.) retrieve all SimulationSelector tools in the array
  if ( simSelectorTools.retrieve().isFailure() ) {
      ATH_MSG_FATAL( "Could not retrieve SimulatorSelector Tool Array. Abort." );
      return StatusCode::FAILURE;
  }
 
  // (2.) loop over SimulationSelector tool array and retrieve simulators
  SimSelectorToolArray::iterator fSimSelectorIter    = simSelectorTools.begin();
  SimSelectorToolArray::iterator fSimSelectorIterEnd = simSelectorTools.end();
  for ( ; fSimSelectorIter != fSimSelectorIterEnd; ++fSimSelectorIter ) {
 
    // take the simulator from the current SimulationSelector
    ServiceHandle<ISimulationSvc> *curSimulator = (*fSimSelectorIter)->simulator();
 
    if ( (*curSimulator).retrieve().isFailure() ){
        ATH_MSG_FATAL( "Could not retrieve SimulatorSelector Tool. Abort." );
        return StatusCode::FAILURE;
    } else
        ATH_MSG_INFO( "- SimulationSelector   : " << fSimSelectorIter->typeAndName() );
 
    // hand over particle broker to simulator
    if ( (*curSimulator)->setParticleBroker( &*m_particleBroker).isFailure() ){
      ATH_MSG_FATAL( "Unable to register ParticleService to SimulationService "
                                          << *curSimulator );
      return StatusCode::FAILURE;
    }
 
    // get the unique ID assigned to the Simulation Service
    SimSvcID curID = (*curSimulator)->simSvcID();
    // if no ID assigned yet -> new simulator
    if ( curID == ISF::fUndefinedSimID) {
      // assign a new new ID to the simulator
      (*curSimulator)->assignSimSvcID( m_numSimSvcs);
      // register current simulator to the simulatorArray
      m_simSvcs[m_numSimSvcs]     = (&**curSimulator);
      m_simSvcNames[m_numSimSvcs] = (*curSimulator)->simSvcDescriptor();
      ATH_MSG_DEBUG( "Assigned SimSvcID=" << m_numSimSvcs
                    << " to simulator '" << m_simSvcNames[m_numSimSvcs]
                    << "'");
      // increment the total number of simulators registered (=used as IDs)
      ++m_numSimSvcs;
    }
 
  } // loop over simulation Selectors
 
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

prepareInput()

StatusCode ISF::SimKernel::prepareInput ( SG::ReadHandle< McEventCollection > & inputTruth, SG::WriteHandle< McEventCollection > & outputTruth, std::unique_ptr< McEventCollection > & shadowTruth, ISFParticleContainer & simParticles ) const

private

Convert input generator particles to ISFParticles and copy input generator truth collection into output simulation truth collection.

Definition at line 560 of file SimKernel.cxx.

                                                                                  {
 
  if (!inputTruth.isValid()) {
    ATH_MSG_FATAL("Unable to read input GenEvent collection '" << inputTruth.key() << "'");
    return StatusCode::FAILURE;
  }
 
  if (m_useShadowEvent) {
    outputTruth = std::make_unique<McEventCollection>();
    // copy input Evgen collection to shadow Truth collection
    shadowTruth = std::make_unique<McEventCollection>(*inputTruth);
    for (HepMC::GenEvent* currentGenEvent : *shadowTruth ) {
      // Apply QS patch if required
      if ( not m_qspatcher.empty() ) {
        ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
      }
      // Copy GenEvent and remove daughters of quasi-stable particles to be simulated
      std::unique_ptr<HepMC::GenEvent> outputEvent = m_truthPreselectionTool->filterGenEvent(*currentGenEvent);
      outputTruth->push_back(outputEvent.release());
    }
  }
  else {
    // copy input Evgen collection to output Truth collection
    outputTruth = std::make_unique<McEventCollection>(*inputTruth);
 
    // Apply QS patch if required
    if(!m_qspatcher.empty()) {
      for (HepMC::GenEvent* currentGenEvent : *outputTruth ) {
        ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
      }
    }
  }
  ATH_CHECK( m_inputConverter->convert(*outputTruth, simParticles) );
 
  return StatusCode::SUCCESS;
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_benchSimID

PMonUtils::CustomBenchmark* ISF::SimKernel::m_benchSimID

private

Definition at line 144 of file SimKernel.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doCPUMon

bool ISF::SimKernel::m_doCPUMon

private

CPU Benchmarking.

whether we use PMonUtils or not

Definition at line 141 of file SimKernel.h.

m_doMemMon

bool ISF::SimKernel::m_doMemMon

private

The Memory Info Tool.

Definition at line 128 of file SimKernel.h.

m_eventFilters

ToolHandleArray<IEventFilterTool> ISF::SimKernel::m_eventFilters

private

The Event Filters.

Definition at line 125 of file SimKernel.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_inputConverter

ServiceHandle<IInputConverter> ISF::SimKernel::m_inputConverter

private

input->ISFParticle converter

Definition at line 100 of file SimKernel.h.

m_inputHardScatterEvgen

SG::ReadHandle<McEventCollection> ISF::SimKernel::m_inputHardScatterEvgen

private

Input/output truth collections and input conversion.

input hard scatter collection

Definition at line 96 of file SimKernel.h.

m_inputPileupEvgen

SG::ReadHandle<McEventCollection> ISF::SimKernel::m_inputPileupEvgen

private

input pileup collection

Definition at line 97 of file SimKernel.h.

m_maxParticleVectorSize

size_t ISF::SimKernel::m_maxParticleVectorSize

private

tuning

number of particles simultaneously sent to simulator

Definition at line 150 of file SimKernel.h.

m_memMon

ToolHandle<IMonitoringTool> ISF::SimKernel::m_memMon

private

Definition at line 129 of file SimKernel.h.

m_memUsageEvts

unsigned int ISF::SimKernel::m_memUsageEvts

private

Definition at line 130 of file SimKernel.h.

m_numISFEvents

unsigned int ISF::SimKernel::m_numISFEvents

private

keep track of the number of events processed

Definition at line 138 of file SimKernel.h.

m_numParticles

long int ISF::SimKernel::m_numParticles

private

Statistics.

total number of particles handled by ISF

Definition at line 147 of file SimKernel.h.

m_numSimSvcs

ISF::SimSvcID ISF::SimKernel::m_numSimSvcs

private

total number of SimSvcs used

Definition at line 135 of file SimKernel.h.

m_outputHardScatterTruth

SG::WriteHandle<McEventCollection> ISF::SimKernel::m_outputHardScatterTruth

private

output hard scatter truth collection

Definition at line 98 of file SimKernel.h.

m_outputPileupTruth

SG::WriteHandle<McEventCollection> ISF::SimKernel::m_outputPileupTruth

private

output pileup truth collection

Definition at line 99 of file SimKernel.h.

m_particleBroker

ServiceHandle<IParticleBroker> ISF::SimKernel::m_particleBroker

private

Central particle broker service.

Definition at line 107 of file SimKernel.h.

m_qspatcher

ServiceHandle<Simulation::IZeroLifetimePatcher> ISF::SimKernel::m_qspatcher

private

Quasi-Stable Particle Simulation Patcher.

Definition at line 122 of file SimKernel.h.

m_simSelectors

std::array<PublicToolHandleArray<ISimulationSelector>, AtlasDetDescr::fNumAtlasRegions> ISF::SimKernel::m_simSelectors

private

Initial value:

{{ 
      {}, 
      {this, "IDSimulationSelectors", {} }, 
      {this, "BeamPipeSimulationSelectors", {} }, 
      {this, "CaloSimulationSelectors", {} }, 
      {this, "MSSimulationSelectors", {} }, 
      {this, "CavernSimulationSelectors", {} } 
      }}

The Simulation Selector Chains.

Definition at line 112 of file SimKernel.h.

                                                                                                      {{ // TODO make private
      {}, // fUndefinedAtlasRegion
      {this, "IDSimulationSelectors", {} }, // fAtlasID
      {this, "BeamPipeSimulationSelectors", {} }, // fAtlasFoward
      {this, "CaloSimulationSelectors", {} }, // fAtlasCalo
      {this, "MSSimulationSelectors", {} }, // fAtlasMS
      {this, "CavernSimulationSelectors", {} } // fAtlasCavern
      }};

m_simSvcNames

std::vector<std::string> ISF::SimKernel::m_simSvcNames

private

SimSvc names.

Definition at line 134 of file SimKernel.h.

m_simSvcs

std::vector<ISimulationSvc*> ISF::SimKernel::m_simSvcs

private

Simulators to be used.

SimSvc handles

Definition at line 133 of file SimKernel.h.

m_truthPreselectionTool

ToolHandle<IGenEventFilter> ISF::SimKernel::m_truthPreselectionTool {this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"}

private

Definition at line 102 of file SimKernel.h.

{this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"};

m_truthRecordSvc

ServiceHandle<ITruthSvc> ISF::SimKernel::m_truthRecordSvc

private

Central truth service.

Definition at line 109 of file SimKernel.h.

m_useShadowEvent

BooleanProperty ISF::SimKernel::m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation" }

private

Definition at line 104 of file SimKernel.h.

{this, "UseShadowEvent", false, "New approach to selecting particles for simulation" };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• SimKernel.h
• SimKernel.cxx