ThinGeantTruthAlg Class Reference

#include <ThinGeantTruthAlg.h>

Inheritance diagram for ThinGeantTruthAlg:

Collaboration diagram for ThinGeantTruthAlg:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	execute (const EventContext &ctx) const override final
void	ancestors (const xAOD::TruthParticle *, std::vector< bool > &, std::unordered_set< int > &) const
	Inline method.
void	descendants (const xAOD::TruthParticle *, std::vector< bool > &, std::unordered_set< int > &) const
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
StringProperty	m_streamName
Gaudi::Property< float >	m_etaMaxEgTruth
Gaudi::Property< bool >	m_keepMuons { this, "keepMuons", true }
Gaudi::Property< bool >	m_keepEGamma { this, "keepEGamma", true }
Gaudi::Property< std::string >	m_truthLinkDecor {this, "TruthLinkDecor", "truthParticleLink"}
	Truth particle link decorations.
SG::ReadDecorHandleKeyArray< xAOD::IParticleContainer >	m_readDecorKeys {this, "DecorKeys", {}}
	Schedule the algorithm's dependency on the truth particle link.
Gaudi::Property< std::vector< int > >	m_longlived
SG::ThinningHandleKey< xAOD::TruthParticleContainer >	m_truthParticlesKey
SG::ThinningHandleKey< xAOD::TruthVertexContainer >	m_truthVerticesKey
SG::ReadHandleKey< xAOD::ElectronContainer >	m_electronsKey
SG::ReadHandleKey< xAOD::ElectronContainer >	m_fwdElectronsKey
SG::ReadHandleKey< xAOD::ElectronContainer >	m_lrtElectronsKey
SG::ReadHandleKey< xAOD::PhotonContainer >	m_photonsKey
SG::ReadHandleKey< xAOD::MuonContainer >	m_muonsKey { this, "MuonsKey", "Muons", "Name of the input muon container" }
SG::ReadHandleKey< xAOD::MuonContainer >	m_lrtMuonsKey
SG::ReadHandleKey< xAOD::TruthParticleContainer >	m_egammaTruthKey
std::atomic< unsigned long >	m_nEventsProcessed {}
	Counters.
std::atomic< unsigned long >	m_nParticlesProcessed {}
std::atomic< unsigned long >	m_nVerticesProcessed {}
std::atomic< unsigned long >	m_nParticlesThinned {}
std::atomic< unsigned long >	m_nVerticesThinned {}
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Definition at line 30 of file ThinGeantTruthAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Member Function Documentation

ancestors()

void ThinGeantTruthAlg::ancestors	(	const xAOD::TruthParticle *	pHead,
		std::vector< bool > &	particleMask,
		std::unordered_set< int > &	encounteredUniqueIDs ) const

Inline method.

Definition at line 365 of file ThinGeantTruthAlg.cxx.

{
 
  // Check that this uniqueID hasn't been seen before (e.g. we are in a loop)
  std::unordered_set<int>::const_iterator found =
    encounteredUniqueIDs.find(HepMC::uniqueID(pHead));
  if (found != encounteredUniqueIDs.end())
    return;
  encounteredUniqueIDs.insert(HepMC::uniqueID(pHead));
 
  // Save particle position in the mask
  int headIndex = pHead->index();
  particleMask[headIndex] = true;
 
  // Get the production vertex
  const xAOD::TruthVertex* prodVtx(nullptr);
  if (pHead->hasProdVtx()) {
    prodVtx = pHead->prodVtx();
  } else {
    return;
  }
 
  // Get children particles and self-call
  int nParents = prodVtx->nIncomingParticles();
  for (int i = 0; i < nParents; ++i)
    ancestors(prodVtx->incomingParticle(i), particleMask, encounteredUniqueIDs);
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::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());
  }

descendants()

void ThinGeantTruthAlg::descendants	(	const xAOD::TruthParticle *	pHead,
		std::vector< bool > &	particleMask,
		std::unordered_set< int > &	encounteredUniqueIDs ) const

Definition at line 400 of file ThinGeantTruthAlg.cxx.

{
  // Check that this unique ID hasn't been seen before (e.g. we are in a loop)
  std::unordered_set<int>::const_iterator found =
    encounteredUniqueIDs.find(HepMC::uniqueID(pHead));
  if (found != encounteredUniqueIDs.end())
    return;
  encounteredUniqueIDs.insert(HepMC::uniqueID(pHead));
 
  // Save the particle position in the mask
  int headIndex = pHead->index();
  particleMask[headIndex] = true;
 
  // Get the decay vertex
  const xAOD::TruthVertex* decayVtx(nullptr);
  if (pHead->hasDecayVtx()) {
    decayVtx = pHead->decayVtx();
  } else {
    return;
  }
 
  // Get children particles and self-call
  int nChildren = decayVtx->nOutgoingParticles();
  for (int i = 0; i < nChildren; ++i) {
    descendants(
      decayVtx->outgoingParticle(i), particleMask, encounteredUniqueIDs);
  }
 
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::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 ThinGeantTruthAlg::execute ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 91 of file ThinGeantTruthAlg.cxx.

{
  // Increase the event counter
  ++m_nEventsProcessed;
 
  // Retrieve truth and vertex containers
  SG::ThinningHandle truthParticles{m_truthParticlesKey, ctx};
  SG::ThinningHandle truthVertices{m_truthVerticesKey, ctx};
  if (!truthParticles.isValid()) {
    ATH_MSG_FATAL("No TruthParticleContainer with key " << m_truthParticlesKey.key() << " found.");
    return StatusCode::FAILURE;
  }
  if (!truthVertices.isValid()) {
    ATH_MSG_FATAL("No TruthVertexContainer with key " << m_truthVerticesKey.key() << " found.");
    return StatusCode::FAILURE;
  }
 
  // Loop over photons, electrons and muons and get the associated truth
  // particles Retain the associated index number
  std::vector<int> recoParticleTruthIndices;
  std::vector<int> egammaTruthIndices{};
 
  // Muons
  if (m_keepMuons) {
    const xAOD::MuonContainer* muons{nullptr};
    ATH_CHECK(SG::get(muons, m_muonsKey, ctx));
    for (const xAOD::Muon* muon : *muons) {
      const xAOD::TruthParticle* truthMuon = xAOD::TruthHelpers::getTruthParticle(*muon);
      if (truthMuon) {
        truthMuon = xAOD::TruthHelpers::getTruthParticle(*truthMuon);
        if (truthMuon) {
          recoParticleTruthIndices.push_back(truthMuon->index());
        }
      }
    }
 
    // LRT muons
    const xAOD::MuonContainer* lrtMuons{nullptr};
    ATH_CHECK(SG::get(lrtMuons, m_lrtMuonsKey, ctx));
    if (lrtMuons) {
      for (const xAOD::Muon* muon : *lrtMuons) {
        const xAOD::TruthParticle* truthMuon = xAOD::TruthHelpers::getTruthParticle(*muon);
        if (truthMuon) {
          truthMuon = xAOD::TruthHelpers::getTruthParticle(*truthMuon);
          if (truthMuon) {
            recoParticleTruthIndices.push_back(truthMuon->index());
          }
        }
      }
    }
  }
 
  // Electrons and photons
  if (m_keepEGamma) {
 
    // Electrons
    const xAOD::ElectronContainer* electrons{nullptr};
    ATH_CHECK(SG::get(electrons, m_electronsKey, ctx));
   
    for (const xAOD::Electron* electron : *electrons) {
      const xAOD::TruthParticle* truthElectron =
        xAOD::TruthHelpers::getTruthParticle(*electron);
      if (truthElectron) {
        recoParticleTruthIndices.push_back(truthElectron->index());
      }
    }
 
    // Forward Electrons
    const xAOD::ElectronContainer* fwdElectrons{nullptr};
    ATH_CHECK(SG::get(fwdElectrons, m_fwdElectronsKey, ctx));
    if (fwdElectrons) {
      
      for (const xAOD::Electron* electron : *fwdElectrons) {
        const xAOD::TruthParticle* truthElectron =
          xAOD::TruthHelpers::getTruthParticle(*electron);
        if (truthElectron) {
          recoParticleTruthIndices.push_back(truthElectron->index());
        }
      }
    }
 
    // LRT electrons
    const xAOD::ElectronContainer* lrtElectrons{nullptr};
    ATH_CHECK(SG::get(lrtElectrons, m_lrtElectronsKey, ctx));
    if (lrtElectrons) {
      for (const xAOD::Electron* electron : *lrtElectrons) {
        const xAOD::TruthParticle* truthElectron =
          xAOD::TruthHelpers::getTruthParticle(*electron);
        if (truthElectron) {
          recoParticleTruthIndices.push_back(truthElectron->index());
        }
      }
    }
 
    // Photons
    const xAOD::PhotonContainer* photons{nullptr};
    ATH_CHECK(SG::get(photons, m_photonsKey, ctx));
    for (const xAOD::Photon* photon : *photons) {
      const xAOD::TruthParticle* truthPhoton =
        xAOD::TruthHelpers::getTruthParticle(*photon);
      if (truthPhoton) {
        recoParticleTruthIndices.push_back(truthPhoton->index());
      }
    }
 
    // egamma Truth Particles
    const xAOD::TruthParticleContainer* egammaTruthParticles{nullptr};
    ATH_CHECK(SG::get(egammaTruthParticles, m_egammaTruthKey, ctx));
 
    for (const xAOD::TruthParticle* egTruthParticle : *egammaTruthParticles) {
      //coverity[UNNECESSARY_STRING_COPY:FALSE]
      static const SG::ConstAccessor<int> accType("truthType");
 
      if (!accType.isAvailable(*egTruthParticle) ||
          accType(*egTruthParticle) != MCTruthPartClassifier::IsoElectron ||
          std::abs(egTruthParticle->eta()) > m_etaMaxEgTruth) {
        continue;
      }
      // Only isolated true electrons
      using TruthLink_t = ElementLink<xAOD::TruthParticleContainer>;
      static const SG::ConstAccessor<TruthLink_t> linkToTruth(
        "truthParticleLink");
      if (!linkToTruth.isAvailable(*egTruthParticle)) {
        continue;
      }
 
      const TruthLink_t& truthegamma = linkToTruth(*egTruthParticle);
      if (!truthegamma.isValid()) {
        continue;
      }
      egammaTruthIndices.push_back((*truthegamma)->index());
    }
  }
 
  // Set up masks
  std::vector<bool> particleMask, vertexMask;
  int nTruthParticles = truthParticles->size();
  int nTruthVertices = truthVertices->size();
  m_nParticlesProcessed.fetch_add(nTruthParticles, std::memory_order_relaxed);
  m_nVerticesProcessed.fetch_add(nTruthVertices, std::memory_order_relaxed);
  particleMask.assign(nTruthParticles, false);
  vertexMask.assign(nTruthVertices, false);
 
  // Vector of pairs keeping track of how many incoming/outgoing particles each
  // vertex has
  std::vector<std::pair<int, int>> vertexLinksCounts;
  for (const auto *vertex : *truthVertices) {
    std::pair<int, int> tmpPair;
    tmpPair.first = vertex->nIncomingParticles();
    tmpPair.second = vertex->nOutgoingParticles();
    vertexLinksCounts.push_back(tmpPair);
  }
 
  // Loop over truth particles and update mask
  std::unordered_set<int> encounteredUniqueIDs; // for loop protection
  for (int i = 0; i < nTruthParticles; ++i) {
    encounteredUniqueIDs.clear();
    const xAOD::TruthParticle* particle = (*truthParticles)[i];
    // Retain status 1 BSM particles and descendants
    if (MC::isBSM(particle) && MC::isStable(particle)) {
      descendants(particle, particleMask, encounteredUniqueIDs);
      encounteredUniqueIDs.clear();
    }
 
    // Retain stable Tau particles produced by Geant4 and their descendants
    if (MC::isTau(particle) && MC::isStable(particle)) {
      descendants(particle, particleMask, encounteredUniqueIDs);
      encounteredUniqueIDs.clear();
    }
 
    // Retain children of longer-lived generator particles
    if (MC::isStable(particle)) {
      int pdgId = abs(particle->pdgId());
      if (std::find(m_longlived.begin(), m_longlived.end(), pdgId) !=
          m_longlived.end()) {
        const xAOD::TruthVertex* decayVtx(nullptr);
        if (particle->hasDecayVtx()) {
          decayVtx = particle->decayVtx();
        }
        int nChildren = 0;
        if (decayVtx)
          nChildren = decayVtx->nOutgoingParticles();
        for (int i = 0; i < nChildren; ++i) {
          particleMask[decayVtx->outgoingParticle(i)->index()] = true;
        }
      }
    }
 
    // Retain particles and their descendants/ancestors associated with the
    // reconstructed objects
    if (std::find(recoParticleTruthIndices.begin(),
                  recoParticleTruthIndices.end(),
                  i) != recoParticleTruthIndices.end()) {
      if (HepMC::is_simulation_particle(particle)) { // only need to do this for Geant particles since
                           // non-Geant are kept anyway
        ancestors(particle, particleMask, encounteredUniqueIDs);
        encounteredUniqueIDs.clear();
        descendants(particle, particleMask, encounteredUniqueIDs);
        encounteredUniqueIDs.clear();
      }
    }
 
    // Retain particles and their descendants  associated with the egamma Truth
    // Particles
    if (std::find(egammaTruthIndices.begin(), egammaTruthIndices.end(), i) !=
        egammaTruthIndices.end()) {
      descendants(particle, particleMask, encounteredUniqueIDs);
      encounteredUniqueIDs.clear();
    }
 
    if (!HepMC::is_simulation_particle(particle)) {
      particleMask[i] = true;
    }
    else {
      // deal with the products of interactions of quasi-stable
      // particles
      if (particle->hasProdVtx()) {
        const xAOD::TruthVertex* prodVtx = particle->prodVtx();
        const int nParents = prodVtx->nIncomingParticles();
        for (int parent = 0; parent < nParents; ++parent) {
          if (MC::isDecayed(prodVtx->incomingParticle(parent))) {
            // "simulation particle" with a parent with status==2 was
            // produced via the interaction of a quasi-stable particle
            // with the detector material. Such particles should be kept.
            particleMask[i] = true;
            break;
          }
        }
      }
    }
  }
 
  // Loop over the mask and update vertex association counters
  for (int i = 0; i < nTruthParticles; ++i) {
    if (!particleMask[i]) {
      ++m_nParticlesThinned;
      const xAOD::TruthParticle* particle = (*truthParticles)[i];
      if (particle->hasProdVtx()) {
        const auto *prodVertex = particle->prodVtx();
        --vertexLinksCounts[prodVertex->index()].second;
      }
      if (particle->hasDecayVtx()) {
        const auto *decayVertex = particle->decayVtx();
        --vertexLinksCounts[decayVertex->index()].first;
      }
    }
  }
 
  // Loop over truth vertices and update mask
  // Those for which all incoming and outgoing particles are to be thinned, will
  // be thinned as well
  unsigned int nVerticesThinned = 0;
  for (int i = 0; i < nTruthVertices; ++i) {
    if (vertexLinksCounts[i].first != 0 || vertexLinksCounts[i].second != 0) {
      vertexMask[i] = true;
    } else {
      ++nVerticesThinned;
    }
  }
  m_nVerticesThinned.fetch_add(nVerticesThinned, std::memory_order_relaxed);
  // Apply masks to thinning
  truthParticles.keep(particleMask);
  truthVertices.keep(vertexMask);
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.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 BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode ThinGeantTruthAlg::finalize ( )

overridevirtual

Definition at line 79 of file ThinGeantTruthAlg.cxx.

{
  ATH_MSG_INFO("Processed " << m_nEventsProcessed << " events containing "
                            << m_nParticlesProcessed << " truth particles and "
                            << m_nVerticesProcessed << " truth vertices ");
  ATH_MSG_INFO("Removed " << m_nParticlesThinned
                          << " Geant truth particles and " << m_nVerticesThinned
                          << " corresponding truth vertices ");
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ThinGeantTruthAlg::initialize ( )

overridevirtual

Definition at line 39 of file ThinGeantTruthAlg.cxx.

{
  if (m_streamName.empty()) {
    ATH_MSG_ERROR("StreamName property was not initialized.");
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_truthParticlesKey.initialize(m_streamName));
  ATH_CHECK(m_truthVerticesKey.initialize(m_streamName));
  ATH_CHECK(m_electronsKey.initialize(m_keepEGamma));
  ATH_CHECK(m_fwdElectronsKey.initialize(m_keepEGamma && !m_fwdElectronsKey.empty()));
  ATH_CHECK(m_lrtElectronsKey.initialize(m_keepEGamma && !m_lrtElectronsKey.empty()));
  ATH_CHECK(m_photonsKey.initialize(m_keepEGamma));
  ATH_CHECK(m_muonsKey.initialize(m_keepMuons));
  ATH_CHECK(m_lrtMuonsKey.initialize(m_keepMuons && !m_lrtMuonsKey.empty()));
  ATH_CHECK(m_egammaTruthKey.initialize(m_keepEGamma));
  if (m_keepEGamma) {
    m_readDecorKeys.emplace_back(m_electronsKey, m_truthLinkDecor);
    m_readDecorKeys.emplace_back(m_photonsKey, m_truthLinkDecor);
    if (!m_fwdElectronsKey.empty()){
      m_readDecorKeys.emplace_back(m_fwdElectronsKey, m_truthLinkDecor);
    }
    if (!m_lrtElectronsKey.empty()){
      m_readDecorKeys.emplace_back(m_lrtElectronsKey, m_truthLinkDecor);
    }
  }
  if (!m_muonsKey.empty()){
    m_readDecorKeys.emplace_back(m_muonsKey, m_truthLinkDecor);
  }
  if (!m_lrtMuonsKey.empty()){
    m_readDecorKeys.emplace_back(m_lrtMuonsKey, m_truthLinkDecor);
  }
  
  ATH_CHECK(m_readDecorKeys.initialize());
 
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::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< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::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< Gaudi::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< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_egammaTruthKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> ThinGeantTruthAlg::m_egammaTruthKey

private

Initial value:

{
    this,
    "EGammaTruthKey",
    "egammaTruthParticles",
    "Name of the input egammaTruth container"
  }

Definition at line 125 of file ThinGeantTruthAlg.h.

                                                              {
    this,
    "EGammaTruthKey",
    "egammaTruthParticles",
    "Name of the input egammaTruth container"
  };

m_electronsKey

SG::ReadHandleKey<xAOD::ElectronContainer> ThinGeantTruthAlg::m_electronsKey

private

Initial value:

{
    this,
    "ElectronsKey",
    "Electrons",
    "Name of the input electron container"
  }

Definition at line 87 of file ThinGeantTruthAlg.h.

                                                       {
    this,
    "ElectronsKey",
    "Electrons",
    "Name of the input electron container"
  };

m_etaMaxEgTruth

Gaudi::Property<float> ThinGeantTruthAlg::m_etaMaxEgTruth

private

Initial value:

{ this,
                                          "EtaMaxEGammaTruth",
                                          2.525,
                                          "Max eta value for e-gamma truth particles" }

Definition at line 52 of file ThinGeantTruthAlg.h.

                                      { this,
                                          "EtaMaxEGammaTruth",
                                          2.525,
                                          "Max eta value for e-gamma truth particles" };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_fwdElectronsKey

SG::ReadHandleKey<xAOD::ElectronContainer> ThinGeantTruthAlg::m_fwdElectronsKey

private

Initial value:

{
    this,
    "FwdElectronsKey",
    "",
    "Name of the input forward electron container"
  }

Definition at line 94 of file ThinGeantTruthAlg.h.

                                                          {
    this,
    "FwdElectronsKey",
    "",
    "Name of the input forward electron container"
  };

m_keepEGamma

Gaudi::Property<bool> ThinGeantTruthAlg::m_keepEGamma { this, "keepEGamma", true }

private

Definition at line 58 of file ThinGeantTruthAlg.h.

{ this, "keepEGamma", true };

m_keepMuons

Gaudi::Property<bool> ThinGeantTruthAlg::m_keepMuons { this, "keepMuons", true }

private

Definition at line 57 of file ThinGeantTruthAlg.h.

{ this, "keepMuons", true };

m_longlived

Gaudi::Property<std::vector<int> > ThinGeantTruthAlg::m_longlived

private

Initial value:

{
    this,
    "LongLivedParticleList",
    { 310, 3122, 3222, 3112, 3322, 3312 },
    "List of long lifetime particles which are likely to be decayed by "
    "Geant but whose children must be kept"
  }

Definition at line 65 of file ThinGeantTruthAlg.h.

                                           {
    this,
    "LongLivedParticleList",
    { 310, 3122, 3222, 3112, 3322, 3312 },
    "List of long lifetime particles which are likely to be decayed by "
    "Geant but whose children must be kept"
  };

m_lrtElectronsKey

SG::ReadHandleKey<xAOD::ElectronContainer> ThinGeantTruthAlg::m_lrtElectronsKey

private

Initial value:

{
    this,
    "LRTElectronsKey",
    "",
    "Name of the input LRT electron container"
  }

Definition at line 101 of file ThinGeantTruthAlg.h.

                                                          {
    this,
    "LRTElectronsKey",
    "",
    "Name of the input LRT electron container"
  };

m_lrtMuonsKey

SG::ReadHandleKey<xAOD::MuonContainer> ThinGeantTruthAlg::m_lrtMuonsKey

private

Initial value:

{
    this,
    "LRTMuonsKey",
    "",
    "Name of the input LRT muon container"
  }

Definition at line 118 of file ThinGeantTruthAlg.h.

                                                  {
    this,
    "LRTMuonsKey",
    "",
    "Name of the input LRT muon container"
  };

m_muonsKey

SG::ReadHandleKey<xAOD::MuonContainer> ThinGeantTruthAlg::m_muonsKey { this, "MuonsKey", "Muons", "Name of the input muon container" }

private

Definition at line 116 of file ThinGeantTruthAlg.h.

{ this, "MuonsKey", "Muons", "Name of the input muon container" };

m_nEventsProcessed

std::atomic<unsigned long> ThinGeantTruthAlg::m_nEventsProcessed {}

mutableprivate

Counters.

Definition at line 133 of file ThinGeantTruthAlg.h.

{};

m_nParticlesProcessed

std::atomic<unsigned long> ThinGeantTruthAlg::m_nParticlesProcessed {}

mutableprivate

Definition at line 134 of file ThinGeantTruthAlg.h.

{};

m_nParticlesThinned

std::atomic<unsigned long> ThinGeantTruthAlg::m_nParticlesThinned {}

mutableprivate

Definition at line 136 of file ThinGeantTruthAlg.h.

{};

m_nVerticesProcessed

std::atomic<unsigned long> ThinGeantTruthAlg::m_nVerticesProcessed {}

mutableprivate

Definition at line 135 of file ThinGeantTruthAlg.h.

{};

m_nVerticesThinned

std::atomic<unsigned long> ThinGeantTruthAlg::m_nVerticesThinned {}

mutableprivate

Definition at line 137 of file ThinGeantTruthAlg.h.

{};

m_photonsKey

SG::ReadHandleKey<xAOD::PhotonContainer> ThinGeantTruthAlg::m_photonsKey

private

Initial value:

{
    this,
    "PhotonsKey",
    "Photons",
    "Name of the input photon container"
  }

Definition at line 108 of file ThinGeantTruthAlg.h.

                                                   {
    this,
    "PhotonsKey",
    "Photons",
    "Name of the input photon container"
  };

m_readDecorKeys

SG::ReadDecorHandleKeyArray<xAOD::IParticleContainer> ThinGeantTruthAlg::m_readDecorKeys {this, "DecorKeys", {}}

private

Schedule the algorithm's dependency on the truth particle link.

Definition at line 63 of file ThinGeantTruthAlg.h.

{this, "DecorKeys", {}};

m_streamName

StringProperty ThinGeantTruthAlg::m_streamName

private

Initial value:

{ this,
                               "StreamName",
                               "",
                               "Stream for which thinning is to be done." }

Definition at line 47 of file ThinGeantTruthAlg.h.

                             { this,
                               "StreamName",
                               "",
                               "Stream for which thinning is to be done." };

m_truthLinkDecor

Gaudi::Property<std::string> ThinGeantTruthAlg::m_truthLinkDecor {this, "TruthLinkDecor", "truthParticleLink"}

private

Truth particle link decorations.

Definition at line 61 of file ThinGeantTruthAlg.h.

{this, "TruthLinkDecor", "truthParticleLink"};

m_truthParticlesKey

SG::ThinningHandleKey<xAOD::TruthParticleContainer> ThinGeantTruthAlg::m_truthParticlesKey

private

Initial value:

{
    this,
    "TruthParticlesKey",
    "TruthParticles",
    "Name of the input Truth Particle container"
  }

Definition at line 73 of file ThinGeantTruthAlg.h.

                                                                     {
    this,
    "TruthParticlesKey",
    "TruthParticles",
    "Name of the input Truth Particle container"
  };

m_truthVerticesKey

SG::ThinningHandleKey<xAOD::TruthVertexContainer> ThinGeantTruthAlg::m_truthVerticesKey

private

Initial value:

{
    this,
    "TruthVerticesKey",
    "TruthVertices",
    "Name of the input Truth Vertices container"
  }

Definition at line 80 of file ThinGeantTruthAlg.h.

                                                                  {
    this,
    "TruthVerticesKey",
    "TruthVertices",
    "Name of the input Truth Vertices container"
  };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

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

• ThinGeantTruthAlg.h
• ThinGeantTruthAlg.cxx