ISF::SimKernelMT Class Reference

Core Athena algorithm for the Integrated Simulation Framework. More...

#include <SimKernelMT.h>

Inheritance diagram for ISF::SimKernelMT:

Public Member Functions
StatusCode	initialize () override
	Check user configuration and configure the algorithm state accordingly.
StatusCode	execute () override
	Check the validity of the MC truth event in the current Athena event.
StatusCode	finalize () override
	Implements empty finalize (implementation required by AthAlgorithm)
bool	isClonable () const override
	AthAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters:
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
ISimulatorTool &	identifySimulator (const ISF::ISFParticle &particle)
	Returns the simulator to use for the given particle.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< McEventCollection >	m_inputEvgenKey {this, "InputEvgenCollection", "", "Input EVGEN collection."}
	Input Generator Truth collection.
SG::WriteHandleKey< McEventCollection >	m_outputTruthKey {this, "OutputTruthCollection", "", "Output Truth collection."}
	Output Simulation Truth collection.
SG::WriteHandleKey< TrackRecordCollection >	m_caloEntryLayerKey {this, "CaloEntryLayerKey", "CaloEntryLayer", ""}
	Output TrackRecordCollections.
SG::WriteHandleKey< TrackRecordCollection >	m_muonEntryLayerKey {this, "MuonEntryLayerKey", "MuonEntryLayer", ""}
SG::WriteHandleKey< TrackRecordCollection >	m_muonExitLayerKey {this, "MuonExitLayerKey", "MuonExitLayer", ""}
BooleanProperty	m_useShadowEvent {this, "UseShadowEvent", false, "New approach to selecting particles for simulation" }
Gaudi::Property< bool >	m_forceGeoIDSvc {this, "AlwaysUseGeoIDSvc", false, "Force geoID recalculation for each particle" }
	Force geoID recalculation for each particle.
ToolHandle< IGenEventFilter >	m_truthPreselectionTool {this, "TruthPreselectionTool", "", "Tool for filtering out quasi-stable particle daughters"}
ServiceHandle< IInputConverter >	m_inputConverter {this, "InputConverter", "", "Input McEventCollection->ISFParticleContainer conversion service."}
	Input converter service (from Generator->ISF particle types)
ServiceHandle< ITruthSvc >	m_truthRecordSvc {this,"TruthRecordService", "ISF_MC15aPlusTruthService", ""}
	Central truth service.
ServiceHandle< Simulation::IZeroLifetimePatcher >	m_qspatcher {this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"}
	Quasi-Stable Particle Simulation Patcher.
ToolHandleArray< ISimulatorTool >	m_simulationTools {this, "SimulationTools", {}, ""}
	Simulation Tools.
ISimulatorTool *	m_particleKillerTool {}
	When no appropriate simulator can be found for a given particle, the particle is sent to this "particle killer":
PublicToolHandle< IEntryLayerTool >	m_entryLayerTool {this, "EntryLayerTool", "ISF_EntryLayerToolMT", ""}
	AthenaTool responsible for writing Calo/Muon Entry/Exit Layer collection.
ServiceHandle< IGeoIDSvc >	m_geoIDSvc {this, "GeoIDSvc", "", "Service to set particle GeoIDs"}
	Service to set particle GeoIDs.
ToolHandle< IParticleOrderingTool >	m_orderingTool {this, "ParticleOrderingTool", "", "Tool to set order of particles"}
	Tool to set particle ordering.
std::array< PublicToolHandleArray< ISimulationSelector >, AtlasDetDescr::fNumAtlasRegions >	m_simSelectors
	The simulation selectors defining the "routing chain".
std::map< ISF::SimulationFlavor, ISimulatorTool * >	m_simToolMap
	Map of the simulation flavours used in this job to the corresponding Simulation Services.
Gaudi::Property< size_t >	m_maxParticleVectorSize {this, "MaximumParticleVectorSize", 10240}
	Number of particles simultaneously sent to simulator.
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

Friends
class	ISFTesting::SimKernelMT_test
	Allow the test class access to all methods.

Detailed Description

Core Athena algorithm for the Integrated Simulation Framework.

This Athena algorithm dispatches all selected particles from the input collection to the attached simulators.

Definition at line 61 of file SimKernelMT.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

AthAlgorithm()

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

Constructor with parameters:

Definition at line 51 of file AthAlgorithm.cxx.

                                                       :
  ::AthCommonDataStore<AthCommonMsg<Algorithm>>   ( name, pSvcLocator )
{
  // Set up to run AthAlgorithmDHUpdate in sysInitialize before
  // merging dependency lists.  This extends the output dependency
  // list with any symlinks implied by inheritance relations.
  m_updateDataHandles =
    std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
    (m_extendedExtraObjects,
     std::move (m_updateDataHandles));
}

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::SimKernelMT::execute ( )

override

Check the validity of the MC truth event in the current Athena event.

Return values

StatusCode::SUCCESS	all HepMC::GenEvents of the current Athena event are valid
StatusCode::FAILURE	the MC truth collection could not be read
StatusCode::FAILURE	the MC truth collection does not have a valid tree structure

Definition at line 115 of file SimKernelMT.cxx.

                                   {
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  auto hitCollections = std::make_shared<HitCollectionMap>();
  // Call setupEvent for all simulators (TODO: make the tools do this)
  for (auto& curSimTool: m_simulationTools) {
    if ( curSimTool ) {
      if (auto* g4sim =
              dynamic_cast<ISF::BaseSimulatorG4Tool*>(curSimTool.get())) {
        ATH_CHECK(g4sim->setupEvent(ctx, *hitCollections));
      } else {
        ATH_CHECK(curSimTool->setupEvent(ctx));
      }
      ATH_MSG_DEBUG( "Event setup done for " << curSimTool->name() );
    }
  }
 
  SG::ReadHandle<McEventCollection> inputEvgen(m_inputEvgenKey);
  if (!inputEvgen.isValid()) {
    ATH_MSG_FATAL("Unable to read input GenEvent collection '" << inputEvgen.key() << "'");
    return StatusCode::FAILURE;
  }
 
  // create output Truth collection
  SG::WriteHandle<McEventCollection> outputTruth(m_outputTruthKey, ctx);
  std::unique_ptr<McEventCollection> shadowTruth{};
  if (m_useShadowEvent) {
    outputTruth = std::make_unique<McEventCollection>();
    // copy input Evgen collection to shadow Truth collection
    shadowTruth = std::make_unique<McEventCollection>(*inputEvgen);
    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>(*inputEvgen);
    // Apply QS patch if required
    if ( not m_qspatcher.empty() ) {
      for (HepMC::GenEvent* currentGenEvent : *outputTruth ) {
        ATH_CHECK(m_qspatcher->applyWorkaround(*currentGenEvent));
      }
    }
  }
 
  const int largestGeneratedParticleBC = (outputTruth->empty()) ? HepMC::UNDEFINED_ID
    : HepMC::maxGeneratedParticleBarcode(outputTruth->at(0)); // TODO make this more robust
  const int largestGeneratedVertexBC =  (outputTruth->empty()) ? HepMC::UNDEFINED_ID
    : HepMC::maxGeneratedVertexBarcode(outputTruth->at(0)); // TODO make this more robust
  // tell TruthService we're starting a new event
  ATH_CHECK( m_truthRecordSvc->initializeTruthCollection(largestGeneratedParticleBC, largestGeneratedVertexBC) );
 
  // Create TrackRecordCollections and pass them to the entryLayerTool
  SG::WriteHandle<TrackRecordCollection> caloEntryLayer(m_caloEntryLayerKey, ctx);
  caloEntryLayer = std::make_unique<TrackRecordCollection>(caloEntryLayer.name());
  ATH_CHECK(m_entryLayerTool->registerTrackRecordCollection(caloEntryLayer.ptr(), fAtlasCaloEntry));
  SG::WriteHandle<TrackRecordCollection> muonEntryLayer(m_muonEntryLayerKey, ctx);
  muonEntryLayer = std::make_unique<TrackRecordCollection>(muonEntryLayer.name());
  ATH_CHECK(m_entryLayerTool->registerTrackRecordCollection(muonEntryLayer.ptr(), fAtlasMuonEntry));
  SG::WriteHandle<TrackRecordCollection> muonExitLayer(m_muonExitLayerKey, ctx);
  muonExitLayer = std::make_unique<TrackRecordCollection>(muonExitLayer.name());
  ATH_CHECK(m_entryLayerTool->registerTrackRecordCollection(muonExitLayer.ptr(), fAtlasMuonExit));
 
  // read and convert input
  ISFParticleContainer simParticles;
  ATH_CHECK( m_inputConverter->convert(*outputTruth, simParticles) );
 
  // create an ordered queue of particles
  ISFParticleOrderedQueue particleQueue;
  for ( auto& particle : simParticles ) {
 
    if ( m_orderingTool.empty() ) {
      // Without a defined ordering, preserve old FIFO behaviour
      particle->setOrder( -particleQueue.size() );
    } else {
      m_orderingTool->setOrder( *particle );
    }
 
    particleQueue.push( particle );
  }
 
  unsigned int loopCounter{0};
  // loop until there are no more particles to simulate
  ISF::ISFParticleVector particles{};
  ISimulatorTool* lastSimulator{};
  ISFParticleContainer newSecondaries{};
  while ( particleQueue.size() ) {
    ++loopCounter;
    ATH_MSG_VERBOSE("Main Loop pass no. " << loopCounter);
    ATH_MSG_VERBOSE("Queue starts with " << particleQueue.size() << " particles.");
    // Create a vector of particles with the same simulator
    ISFParticleOrderedQueue tempQueue;
    while ( particleQueue.size() ) {
      auto particlePtr = particleQueue.top();
      ISFParticle& curParticle( *particlePtr );
      particleQueue.pop();
 
      // Get the geo ID for the particle
      if ( m_forceGeoIDSvc || !validAtlasRegion( curParticle.nextGeoID() ) ) {
        m_geoIDSvc->identifyAndRegNextGeoID( curParticle );
      }
 
      // Get the simulator using the GeoID
      auto& simTool = identifySimulator(curParticle);
 
      // Fill the vector
      if ( particles.empty() ) {
        // First particle in the vector defines the simulator
        particles.push_back(particlePtr);
        lastSimulator=&simTool;
      }
      else if (&simTool!=lastSimulator || particles.size() >= m_maxParticleVectorSize.value() ) {
        // Change of simulator, end the current vector
        tempQueue.push(particlePtr);
      }
      else {
        particles.push_back(particlePtr);
      }
    }
    particleQueue = std::move(tempQueue);
    #ifdef ISFDEBUG
    if (loopCounter>100 && particles.size()<3) {
      ATH_MSG_INFO("Main Loop pass no. " << loopCounter);
      ATH_MSG_INFO("Selected " << particles.size() << " particles to be processed by " << lastSimulator->name());
      for ( const ISFParticle *particle : particles ) {
        ATH_MSG_INFO(*particle);
      }
    }
    #endif // ISFDEBUG
 
    ATH_MSG_VERBOSE("Selected " << particles.size() << " particles to be processed by " << lastSimulator->name());
    // Run the simulation
    if (auto* g4sim = dynamic_cast<ISF::BaseSimulatorG4Tool*>(lastSimulator)) {
      ATH_CHECK(g4sim->simulateVector(ctx, particles, newSecondaries,
                                      outputTruth.ptr(), hitCollections,
                                      shadowTruth.get()));
    } else {
      ATH_CHECK(lastSimulator->simulateVector(ctx, particles, newSecondaries,
                                              outputTruth.ptr(),
                                              shadowTruth.get()));
    }
 
    ATH_MSG_VERBOSE(lastSimulator->name() << " returned " << newSecondaries.size() << " new particles to be added to the queue." );
    // Register returned particles with the entry layer tool, set their order and enqueue them
    for ( auto* secondary : newSecondaries ) {
 
      // Set up particle in ISF
      m_entryLayerTool->registerParticle( *secondary );
      if ( m_forceGeoIDSvc || !validAtlasRegion( secondary->nextGeoID() ) ) {
        m_geoIDSvc->identifyAndRegNextGeoID( *secondary );
      }
 
      if ( m_orderingTool.empty() ) {
        // Without a defined ordering, preserve old FIFO behaviour
        secondary->setOrder( -particleQueue.size() );
      } else {
        m_orderingTool->setOrder( *secondary );
      }
 
      particleQueue.push( secondary );
    }
    newSecondaries.clear();
 
    // Delete simulated particles
    for ( auto usedParticle : particles ) {
      delete usedParticle;
    }
    particles.clear();
  }
  ATH_MSG_VERBOSE("Final status: queue contains " << particleQueue.size() << " particles.");
 
  // Release the event from all simulators (TODO: make the tools do this)
  for (auto& curSimTool: m_simulationTools) {
    if ( curSimTool ) {
      if (auto* g4sim =
              dynamic_cast<ISF::BaseSimulatorG4Tool*>(curSimTool.get())) {
        ATH_CHECK(g4sim->releaseEvent(ctx, *hitCollections));
      } else {
        ATH_CHECK(curSimTool->releaseEvent(ctx));
      }
      ATH_MSG_DEBUG( "releaseEvent() completed for " << curSimTool->name() );
    }
  }
 
  // Remove QS patch if required
  if(!m_qspatcher.empty()) {
    for (HepMC::GenEvent* currentGenEvent : *outputTruth ) {
      ATH_CHECK(m_qspatcher->removeWorkaround(*currentGenEvent));
    }
  }
 
  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::SimKernelMT::finalize ( )

override

Implements empty finalize (implementation required by AthAlgorithm)

Definition at line 316 of file SimKernelMT.cxx.

                                    {
  return StatusCode::SUCCESS;
}

identifySimulator()

ISF::ISimulatorTool & ISF::SimKernelMT::identifySimulator ( const ISF::ISFParticle & particle )

private

Returns the simulator to use for the given particle.

Definition at line 322 of file SimKernelMT.cxx.

                                                                                   {
  AtlasDetDescr::AtlasRegion geoID = particle.nextGeoID();
 
  auto& localSelectors = m_simSelectors[geoID];
  for (auto& selector: localSelectors) {
    bool selected = selector->selfSelect(particle);
    if (selected) {
      return *m_simToolMap.at(selector->simFlavor());
    }
  }
 
  ATH_MSG_WARNING("No simulator found for particle (" << particle << ")."
                  << " Will send it to " << m_particleKillerTool->name());
  return *m_particleKillerTool;
}

initialize()

StatusCode ISF::SimKernelMT::initialize ( )

override

Check user configuration and configure the algorithm state accordingly.

Core Athena algorithm for the Integrated Simulation Framework.

Author

Elmar Ritsch Elmar.nosp@m..Rit.nosp@m.sch@c.nosp@m.ern..nosp@m.ch

Date

October 2016

Definition at line 27 of file SimKernelMT.cxx.

                                      {
 
  ATH_CHECK( m_simulationTools.retrieve() );
  for ( auto& curSimTool : m_simulationTools )
  {
    if ( curSimTool )
    {
      const auto flavor = curSimTool->simFlavor();
      auto itr = m_simToolMap.find(flavor);
      if (itr != m_simToolMap.end() )
      {
        ATH_MSG_FATAL("Two ISimulatorTool instances (" << itr->second->name() << "," << curSimTool->name() << ") with the same flavor in this job!\n Check your configuration!");
        return StatusCode::FAILURE;
      }
      // New flavour add it to the map.
      m_simToolMap[flavor] = &*curSimTool;
      if (flavor == ISF::ParticleKiller) {
        m_particleKillerTool = &*curSimTool;
      }
    }
  }
  // Check that a particle killer simulator tool was provided
  if (!m_particleKillerTool) {
    ATH_MSG_FATAL("No fallback ParticleKiller Simulator Tool provided in SimulationTools, the job will bail out now.");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("The following Simulators will be used in this job: \t" << m_simulationTools);
  // retrieve simulation selectors (i.e. the "routing chain")
  for ( auto& selectorsToolHandleArray: m_simSelectors )
  {
    ATH_CHECK( selectorsToolHandleArray.retrieve() );
  }
 
  // info screen output
  ATH_MSG_INFO( "The following routing chains are defined:" );
  for ( short geoID=AtlasDetDescr::fFirstAtlasRegion; geoID<AtlasDetDescr::fNumAtlasRegions; ++geoID )
  {
    auto& localSelectors = m_simSelectors[geoID];
    ATH_MSG_INFO( AtlasDetDescr::AtlasRegionHelper::getName(geoID) << " (GeoID=" << geoID << "): \t" << localSelectors );
 
    for ( auto& selector : localSelectors )
    {
      const auto flavor = selector->simFlavor();
      auto itr = m_simToolMap.find(flavor);
      if (itr == m_simToolMap.end() )
      {
        ATH_MSG_WARNING( "Map from SimulationFlavor to SimulatorTool:" );
        for ( auto& entry : m_simToolMap )
        {
          ATH_MSG_WARNING( "SimulationFlavor: " << entry.first << ", SimulatorTool Name: " << entry.second->name() );
        }
        ATH_MSG_FATAL( "No SimulationTool with flavor " << flavor << " expected by " << selector->name() << " found in this job!\n Check your configuration!" );
        return StatusCode::FAILURE;
      }
    }
  }
 
  ATH_CHECK( m_entryLayerTool.retrieve() );
 
  if ( not m_orderingTool.empty() ) {
    ATH_CHECK( m_orderingTool.retrieve() );
  }
 
  ATH_CHECK( m_inputEvgenKey.initialize() );
  ATH_CHECK( m_outputTruthKey.initialize() );
 
  ATH_CHECK( m_caloEntryLayerKey.initialize() );
  ATH_CHECK( m_muonEntryLayerKey.initialize() );
  ATH_CHECK( m_muonExitLayerKey.initialize() );
 
  ATH_CHECK( m_inputConverter.retrieve() );
  if ( not m_truthPreselectionTool.empty() ) {
    ATH_CHECK(m_truthPreselectionTool.retrieve());
  }
 
  ATH_CHECK ( m_truthRecordSvc.retrieve() );
 
  if ( not m_qspatcher.empty() ) {
    ATH_CHECK( m_qspatcher.retrieve() );
  }
 
  ATH_CHECK( m_geoIDSvc.retrieve() );
 
  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.

isClonable()

bool ISF::SimKernelMT::isClonable ( ) const

inlineoverride

Definition at line 82 of file SimKernelMT.h.

{ return true; }

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.

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);
      }
    }
  }

Friends And Related Symbol Documentation

ISFTesting::SimKernelMT_test

friend class ISFTesting::SimKernelMT_test

friend

Allow the test class access to all methods.

Definition at line 64 of file SimKernelMT.h.

Member Data Documentation

m_caloEntryLayerKey

SG::WriteHandleKey<TrackRecordCollection> ISF::SimKernelMT::m_caloEntryLayerKey {this, "CaloEntryLayerKey", "CaloEntryLayer", ""}

private

Output TrackRecordCollections.

Definition at line 93 of file SimKernelMT.h.

{this, "CaloEntryLayerKey", "CaloEntryLayer", ""};

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_entryLayerTool

PublicToolHandle<IEntryLayerTool> ISF::SimKernelMT::m_entryLayerTool {this, "EntryLayerTool", "ISF_EntryLayerToolMT", ""}

private

AthenaTool responsible for writing Calo/Muon Entry/Exit Layer collection.

Definition at line 119 of file SimKernelMT.h.

{this, "EntryLayerTool", "ISF_EntryLayerToolMT", ""};

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_forceGeoIDSvc

Gaudi::Property<bool> ISF::SimKernelMT::m_forceGeoIDSvc {this, "AlwaysUseGeoIDSvc", false, "Force geoID recalculation for each particle" }

private

Force geoID recalculation for each particle.

Definition at line 99 of file SimKernelMT.h.

{this, "AlwaysUseGeoIDSvc", false, "Force geoID recalculation for each particle" };

m_geoIDSvc

ServiceHandle<IGeoIDSvc> ISF::SimKernelMT::m_geoIDSvc {this, "GeoIDSvc", "", "Service to set particle GeoIDs"}

private

Service to set particle GeoIDs.

Definition at line 122 of file SimKernelMT.h.

{this, "GeoIDSvc", "", "Service to set particle GeoIDs"};

m_inputConverter

ServiceHandle<IInputConverter> ISF::SimKernelMT::m_inputConverter {this, "InputConverter", "", "Input McEventCollection->ISFParticleContainer conversion service."}

private

Input converter service (from Generator->ISF particle types)

Definition at line 104 of file SimKernelMT.h.

{this, "InputConverter", "", "Input McEventCollection->ISFParticleContainer conversion service."};

m_inputEvgenKey

SG::ReadHandleKey<McEventCollection> ISF::SimKernelMT::m_inputEvgenKey {this, "InputEvgenCollection", "", "Input EVGEN collection."}

private

Input Generator Truth collection.

Definition at line 89 of file SimKernelMT.h.

{this, "InputEvgenCollection", "", "Input EVGEN collection."};

m_maxParticleVectorSize

Gaudi::Property<size_t> ISF::SimKernelMT::m_maxParticleVectorSize {this, "MaximumParticleVectorSize", 10240}

private

Number of particles simultaneously sent to simulator.

Definition at line 141 of file SimKernelMT.h.

{this, "MaximumParticleVectorSize", 10240};

m_muonEntryLayerKey

SG::WriteHandleKey<TrackRecordCollection> ISF::SimKernelMT::m_muonEntryLayerKey {this, "MuonEntryLayerKey", "MuonEntryLayer", ""}

private

Definition at line 94 of file SimKernelMT.h.

{this, "MuonEntryLayerKey", "MuonEntryLayer", ""};

m_muonExitLayerKey

SG::WriteHandleKey<TrackRecordCollection> ISF::SimKernelMT::m_muonExitLayerKey {this, "MuonExitLayerKey", "MuonExitLayer", ""}

private

Definition at line 95 of file SimKernelMT.h.

{this, "MuonExitLayerKey", "MuonExitLayer", ""};

m_orderingTool

ToolHandle<IParticleOrderingTool> ISF::SimKernelMT::m_orderingTool {this, "ParticleOrderingTool", "", "Tool to set order of particles"}

private

Tool to set particle ordering.

Definition at line 125 of file SimKernelMT.h.

{this, "ParticleOrderingTool", "", "Tool to set order of particles"};

m_outputTruthKey

SG::WriteHandleKey<McEventCollection> ISF::SimKernelMT::m_outputTruthKey {this, "OutputTruthCollection", "", "Output Truth collection."}

private

Output Simulation Truth collection.

Definition at line 91 of file SimKernelMT.h.

{this, "OutputTruthCollection", "", "Output Truth collection."};

m_particleKillerTool

ISimulatorTool* ISF::SimKernelMT::m_particleKillerTool {}

private

When no appropriate simulator can be found for a given particle, the particle is sent to this "particle killer":

Definition at line 116 of file SimKernelMT.h.

{};

m_qspatcher

ServiceHandle<Simulation::IZeroLifetimePatcher> ISF::SimKernelMT::m_qspatcher {this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"}

private

Quasi-Stable Particle Simulation Patcher.

Definition at line 110 of file SimKernelMT.h.

{this, "QuasiStablePatcher", "", "Quasi-Stable Particle Simulation Patcher"};

m_simSelectors

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

private

Initial value:

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

The simulation selectors defining the "routing chain".

Definition at line 128 of file SimKernelMT.h.

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

m_simToolMap

std::map<ISF::SimulationFlavor, ISimulatorTool*> ISF::SimKernelMT::m_simToolMap

private

Map of the simulation flavours used in this job to the corresponding Simulation Services.

Definition at line 138 of file SimKernelMT.h.

m_simulationTools

ToolHandleArray<ISimulatorTool> ISF::SimKernelMT::m_simulationTools {this, "SimulationTools", {}, ""}

private

Simulation Tools.

Definition at line 113 of file SimKernelMT.h.

{this, "SimulationTools", {}, ""};

m_truthPreselectionTool

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

private

Definition at line 101 of file SimKernelMT.h.

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

m_truthRecordSvc

ServiceHandle<ITruthSvc> ISF::SimKernelMT::m_truthRecordSvc {this,"TruthRecordService", "ISF_MC15aPlusTruthService", ""}

private

Central truth service.

Definition at line 107 of file SimKernelMT.h.

{this,"TruthRecordService", "ISF_MC15aPlusTruthService", ""};

m_useShadowEvent

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

private

Definition at line 97 of file SimKernelMT.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:

• SimKernelMT.h
• SimKernelMT.cxx