Algorithm creating xAOD truth from HepMC. More...

#include <xAODTruthCnvAlg.h>

Inheritance diagram for xAODMaker::xAODTruthCnvAlg:

Collaboration diagram for xAODMaker::xAODTruthCnvAlg:

Classes
struct	MetadataFields

class	MetaDataWriter
	Factor out the pieces dealing with writing to meta data. More...

struct	VertexParticles
	Type for tracking particles connected to a single vertex. More...

Public Member Functions
	xAODTruthCnvAlg (const std::string &name, ISvcLocator *svcLoc)
	Regular algorithm constructor. More...

virtual StatusCode	initialize () override
	Function initialising the algorithm. More...

virtual StatusCode	execute (const EventContext &ctx) const override
	Function executing the algorithm. More...

virtual void	handle (const Incident &incident) override
	Incident handler. More...

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

virtual bool	filterPassed (const EventContext &ctx) const

virtual void	setFilterPassed (bool state, const EventContext &ctx) const

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
typedef std::map< HepMC::ConstGenVertexPtr, VertexParticles >	VertexMap
	Convenience handle for a map of vtx ptrs -> connected particles. More...

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static void	fillVertex (xAOD::TruthVertex *tv, const HepMC::ConstGenVertexPtr &gv)
	These functions do not set up ELs, just the other variables. More...

static void	fillParticle (xAOD::TruthParticle *tp, const HepMC::ConstGenParticlePtr &gp)

Private Attributes
SG::ReadHandleKey< McEventCollection >	m_aodContainerKey
	The key of the input AOD truth container. More...

SG::WriteHandleKey< xAOD::TruthEventContainer >	m_xaodTruthEventContainerKey
	The key for the output xAOD truth containers. More...

SG::WriteHandleKey< xAOD::TruthPileupEventContainer >	m_xaodTruthPUEventContainerKey

SG::WriteHandleKey< xAOD::TruthParticleContainer >	m_xaodTruthParticleContainerKey

SG::WriteHandleKey< xAOD::TruthVertexContainer >	m_xaodTruthVertexContainerKey

SG::WriteHandleKey< xAODTruthParticleLinkVector >	m_truthLinkContainerKey

SG::WriteHandleKey< xAOD::TruthParticleContainer >	m_lheTruthParticleContainerKey

Gaudi::Property< bool >	m_doAllPileUp {this, "WriteAllPileUpTruth", false}
	Pile-up options. More...

Gaudi::Property< bool >	m_doInTimePileUp {this, "WriteInTimePileUpTruth", false}

MetaDataWriter m_meta	ATLAS_THREAD_SAFE
	Helper for writing to the meta data store. More...

ServiceHandle< StoreGateSvc >	m_metaStore
	Connection to the metadata store. More...

std::string	m_metaName
	SG key and name for meta data. More...

Gaudi::Property< bool >	m_writeMetaData {this, "WriteTruthMetaData", true}
	option to disable writing of metadata (e.g. if running a filter on xAOD in generators) More...

SG::ReadHandleKey< xAOD::EventInfo >	m_evtInfo {this, "EventInfo", "EventInfo", "" }
	Event Info. More...

bool	m_firstBeginRun
	Tag Info. More...

MetadataFields	m_metaFields

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

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Algorithm creating xAOD truth from HepMC.

This algorithm can be used to translate the HepMC coming from an AOD, and create xAOD truth objects out of them for an output xAOD.

Author: James Catmore James.nosp@m..Cat.nosp@m.more@.nosp@m.cern.nosp@m..ch; Jovan Mitreski Jovan.nosp@m..Mit.nosp@m.reski.nosp@m.@cer.nosp@m.n.ch; Andy Buckley Andy..nosp@m.Buck.nosp@m.ley@c.nosp@m.ern..nosp@m.ch

Definition at line 64 of file xAODTruthCnvAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ VertexMap

typedef std::map<HepMC::ConstGenVertexPtr, VertexParticles> xAODMaker::xAODTruthCnvAlg::VertexMap

private

Convenience handle for a map of vtx ptrs -> connected particles.

Definition at line 123 of file xAODTruthCnvAlg.h.

Constructor & Destructor Documentation

◆ xAODTruthCnvAlg()

xAODMaker::xAODTruthCnvAlg::xAODTruthCnvAlg	(	const std::string &	name,
		ISvcLocator *	svcLoc
	)

Regular algorithm constructor.

Definition at line 54 of file xAODTruthCnvAlg.cxx.

       : AthReentrantAlgorithm( name, svcLoc )
       , m_metaStore( "MetaDataStore", name )
       , m_firstBeginRun(true)
     {
       // leaving metadata alone for now--to be updated
         declareProperty( "MetaObjectName", m_metaName = "TruthMetaData" );
         declareProperty( "MetaDataStore", m_metaStore );
     }

Member Function Documentation

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

 {
   return 0;
 }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > & 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< 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode xAODMaker::xAODTruthCnvAlg::execute ( const EventContext & ctx ) const

overridevirtual

Function executing the algorithm.

Definition at line 111 of file xAODTruthCnvAlg.cxx.

                                                                       {
  
         SG::WriteHandle<xAODTruthParticleLinkVector> truthLinkVec(m_truthLinkContainerKey, ctx);
         ATH_CHECK(truthLinkVec.record(std::make_unique<xAODTruthParticleLinkVector>()));
  
         // Retrieve the HepMC truth:
         SG::ReadHandle<McEventCollection> mcColl(m_aodContainerKey, ctx);
         // validity check is only really needed for serial running. Remove when MT is only way.
         if (!mcColl.isValid()) {
           ATH_MSG_ERROR("Could not retrieve HepMC with key:" << m_aodContainerKey.key());
           return StatusCode::FAILURE;
         } else {
           ATH_MSG_DEBUG( "Retrieved HepMC with key: " << m_aodContainerKey.key() );
         }
  
         // **************************************************************
         // Create the xAOD containers and their auxiliary stores:
         // **************************************************************
         // Signal event
         SG::WriteHandle<xAOD::TruthEventContainer> xTruthEventContainer(m_xaodTruthEventContainerKey, ctx);
         ATH_CHECK(xTruthEventContainer.record(std::make_unique<xAOD::TruthEventContainer>(),
                                               std::make_unique<xAOD::TruthEventAuxContainer>()));
         ATH_MSG_DEBUG( "Recorded TruthEventContainer with key: " << m_xaodTruthEventContainerKey.key() );
  
         // Pile-up events
         SG::WriteHandle<xAOD::TruthPileupEventContainer> xTruthPileupEventContainer;
         if (m_doAllPileUp || m_doInTimePileUp) {
           xTruthPileupEventContainer = SG::WriteHandle<xAOD::TruthPileupEventContainer>(m_xaodTruthPUEventContainerKey, ctx);
           ATH_CHECK(xTruthPileupEventContainer.record(std::make_unique<xAOD::TruthPileupEventContainer>(),
                                                       std::make_unique<xAOD::TruthPileupEventAuxContainer>()));
           ATH_MSG_DEBUG( "Recorded TruthPileupEventContainer with key: " << m_xaodTruthPUEventContainerKey.key() );
         }
  
         // Particles
         SG::WriteHandle<xAOD::TruthParticleContainer> xTruthParticleContainer(m_xaodTruthParticleContainerKey, ctx);
         ATH_CHECK(xTruthParticleContainer.record(std::make_unique<xAOD::TruthParticleContainer>(),
                                                  std::make_unique<xAOD::TruthParticleAuxContainer>()));
         ATH_MSG_DEBUG( "Recorded TruthParticleContainer with key: " << m_xaodTruthParticleContainerKey.key() );
         // Vertices
         SG::WriteHandle<xAOD::TruthVertexContainer> xTruthVertexContainer(m_xaodTruthVertexContainerKey, ctx);
         ATH_CHECK(xTruthVertexContainer.record(std::make_unique<xAOD::TruthVertexContainer>(),
                                                std::make_unique<xAOD::TruthVertexAuxContainer>()));
         ATH_MSG_DEBUG( "Recorded TruthVertexContainer with key: " << m_xaodTruthVertexContainerKey.key() );
  
         // To keep track of whether we wrote an LHE event already or not
 #ifdef HEPMC3
         bool hadLHERecord = false;
 #endif
  
         // ***********************************************************************************
         // Create the xAOD objects
         // This consists of three parts:
         // (1)  For each Athena event, loop over the GenEvents and build TruthEvent collections
         //      In principle there can be more than one GenEvent per event
         // (2)  For each GenEvent, loop over the GenParticles. For each GenParticle:
         //      (a) Create a TruthParticle.
         //      (b) Call fillParticle
         //      (c) Add the TruthParticle to the TruthParticle container, and add
         //          an EL to this TruthParticle to the truthParticles in TruthEvent
         //          (call this EL eltp)
         //      (d) For the GenVertex * that's this particle's production vertex,
         //          (i) see if it is in tempMap. If not, add it.
         //          (ii) add a copy of eltp (the EL to this truth particle) to map[gv].second
         //      (e) For the GenVertex * that's this particle's decay vertex,
         //          (i) see if it is in tempMap. If not, add it.
         //          (ii) add a copy of eltp (the EL to this truth particle) to map[gv].first
         // (3) Iterate over tempMap. For each GenVertex *:
         //      (a) Create a TruthVertex
         //      (b) Call fillVertex
         //      (c) Add the TruthVertex to the TruthTruth container, and add an EL to this TruthVertex
         //          to the truthVertices in TruthEvent. (call this EL eltv)
         //      (d) call tv->setIncomingParticles(mapiter.second.first)  <- I think mapiter.second.first is the first of the pair
         //      (e) call tv->setOutgoingParticles(mapiter.second.second)
         //      (f) Iterate through the incomingParticles, and set the decay vertex EL as eltv.
         //      (g) Iterate through the outgoingParticles, and set the incoming vertex EL as eltv.
         //
         // Comment lines below follow this recipe
         // ************************************************************************************
  
         // (1) Build TruthEvents
         ATH_MSG_DEBUG("Number of GenEvents in this Athena event = " << mcColl->size());
 #ifdef HEPMC3
         bool newAttributesPresent(false);
 #endif
         for (unsigned int cntr = 0; cntr < mcColl->size(); ++cntr) {
           const HepMC::GenEvent* genEvt = (*mcColl)[cntr];
           bool isSignalProcess(false);
           if (cntr==0) {
             isSignalProcess=true;
 #ifdef HEPMC3
             auto bunchCrossingTime = genEvt->attribute<HepMC3::IntAttribute>("BunchCrossingTime");
             if (bunchCrossingTime) {
               newAttributesPresent = true;
               ATH_MSG_VERBOSE("New attributes present.");
             }
             else {
               ATH_MSG_VERBOSE("New attributes missing.");
             }
 #else
               ATH_MSG_VERBOSE("New attributes missing.");
 #endif
           }
           if (cntr>0) {
             // Handle pile-up events
             if (!m_doInTimePileUp && !m_doAllPileUp) break;
             isSignalProcess=false;
 #ifdef HEPMC3
             auto bunchCrossingTime = genEvt->attribute<HepMC3::IntAttribute>("BunchCrossingTime");
             if (bunchCrossingTime) {
               // New approach based on checking the bunch crossing
               // time directly.
               if (m_doInTimePileUp && std::abs(bunchCrossingTime->value()) > 0) {
                 // Skip out-of-time pile-up events
                 continue;
               }
             }
             else {
               // Old approach based on McEventCollection structure. If
               // in-time pileup only is requested, loop stops when the
               // separator GenEvent between out-of-time and in-time is
               // reached
               if (m_doInTimePileUp && isSeparatorGenEvent(genEvt)) {
                 if (newAttributesPresent) {
                   // Old structure with new Attributes?! Check all
                   // GenEvents just in case.
                   ATH_MSG_VERBOSE("New-style, but seeing separator GenEvents");
                   continue;
                 }
                 // Old structure - stop at the first separator
                 // GenEvent.
                 break;
               }
             }
 #else
               // Old approach based on McEventCollection structure. If
               // in-time pileup only is requested, loop stops when the
               // separator GenEvent between out-of-time and in-time is
               // reached
               if (m_doInTimePileUp && isSeparatorGenEvent(genEvt)) {
                 // Old structure - stop at the first separator
                 // GenEvent.
                 break;
               }
 #endif
           }
  
           xAOD::TruthEvent* xTruthEvent = new xAOD::TruthEvent();
           xAOD::TruthPileupEvent* xTruthPileupEvent = new xAOD::TruthPileupEvent();
  
  
           if (isSignalProcess) {
             xTruthEventContainer->push_back( xTruthEvent );
             // Cross-section
             auto crossSection = genEvt->cross_section();
 #ifdef HEPMC3
             xTruthEvent->setCrossSection(crossSection ? (float)crossSection->xsec() : -1);
             xTruthEvent->setCrossSectionError(crossSection ? (float)crossSection->xsec_err() : -1);
 #else
             xTruthEvent->setCrossSection(crossSection ? (float)crossSection->cross_section() : -1);
             xTruthEvent->setCrossSectionError(crossSection ? (float)crossSection->cross_section_error() : -1);
 #endif
  
             if (m_writeMetaData) {
               //The mcChannelNumber is used as a unique identifier for which truth meta data belongs to
               uint32_t mcChannelNumber = 0;
               SG::ReadHandle<xAOD::EventInfo> evtInfo (m_evtInfo,ctx);
               if (evtInfo.isValid()) {
                 mcChannelNumber = evtInfo->mcChannelNumber();
                 if (mcChannelNumber==0) mcChannelNumber = evtInfo->runNumber();
               }
               else {
                 ATH_MSG_FATAL("Faied to retrieve EventInfo");
                 return StatusCode::FAILURE;
               }
  
               ATH_CHECK( m_meta.maybeWrite (mcChannelNumber, *genEvt, m_metaFields) );
             }
             // Event weights
             vector<float> weights;
             for (const double& w : genEvt->weights()) weights.push_back((float)(w));
             //AV This to be decided. It is always a good idea to have a default weight 1.0.
             //if (weights.empty()) weights.push_back(1.0);
             xTruthEvent->setWeights(weights);
  
             // Heavy ion info
             auto const hiInfo = genEvt->heavy_ion();
             if (hiInfo) {
 #ifdef HEPMC3
               /* Please note HepMC3 as well as more recent HePMC2 versions   have more Hi parameters */
               xTruthEvent->setHeavyIonParameter(hiInfo->Ncoll_hard, xAOD::TruthEvent::NCOLLHARD);
               xTruthEvent->setHeavyIonParameter(hiInfo->Npart_proj, xAOD::TruthEvent::NPARTPROJ);
               xTruthEvent->setHeavyIonParameter(hiInfo->Npart_targ, xAOD::TruthEvent::NPARTTARG);
               xTruthEvent->setHeavyIonParameter(hiInfo->Ncoll, xAOD::TruthEvent::NCOLL);
               xTruthEvent->setHeavyIonParameter(hiInfo->spectator_neutrons, xAOD::TruthEvent::SPECTATORNEUTRONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->spectator_protons, xAOD::TruthEvent::SPECTATORPROTONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->N_Nwounded_collisions, xAOD::TruthEvent::NNWOUNDEDCOLLISIONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->Nwounded_N_collisions, xAOD::TruthEvent::NWOUNDEDNCOLLISIONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->Nwounded_Nwounded_collisions, xAOD::TruthEvent::NWOUNDEDNWOUNDEDCOLLISIONS);
               xTruthEvent->setHeavyIonParameter((float)hiInfo->impact_parameter, xAOD::TruthEvent::IMPACTPARAMETER);
               xTruthEvent->setHeavyIonParameter((float)hiInfo->event_plane_angle, xAOD::TruthEvent::EVENTPLANEANGLE);
               xTruthEvent->setHeavyIonParameter((float)hiInfo->eccentricity, xAOD::TruthEvent::ECCENTRICITY);
               xTruthEvent->setHeavyIonParameter((float)hiInfo->sigma_inel_NN, xAOD::TruthEvent::SIGMAINELNN);
 #else
               xTruthEvent->setHeavyIonParameter(hiInfo->Ncoll_hard(), xAOD::TruthEvent::NCOLLHARD);
               xTruthEvent->setHeavyIonParameter(hiInfo->Npart_proj(), xAOD::TruthEvent::NPARTPROJ);
               xTruthEvent->setHeavyIonParameter(hiInfo->Npart_targ(), xAOD::TruthEvent::NPARTTARG);
               xTruthEvent->setHeavyIonParameter(hiInfo->Ncoll(), xAOD::TruthEvent::NCOLL);
               xTruthEvent->setHeavyIonParameter(hiInfo->spectator_neutrons(), xAOD::TruthEvent::SPECTATORNEUTRONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->spectator_protons(), xAOD::TruthEvent::SPECTATORPROTONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->N_Nwounded_collisions(), xAOD::TruthEvent::NNWOUNDEDCOLLISIONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->Nwounded_N_collisions(), xAOD::TruthEvent::NWOUNDEDNCOLLISIONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->Nwounded_Nwounded_collisions(), xAOD::TruthEvent::NWOUNDEDNWOUNDEDCOLLISIONS);
               xTruthEvent->setHeavyIonParameter(hiInfo->impact_parameter(), xAOD::TruthEvent::IMPACTPARAMETER);
               xTruthEvent->setHeavyIonParameter(hiInfo->event_plane_angle(), xAOD::TruthEvent::EVENTPLANEANGLE);
               xTruthEvent->setHeavyIonParameter(hiInfo->eccentricity(), xAOD::TruthEvent::ECCENTRICITY);
               xTruthEvent->setHeavyIonParameter(hiInfo->sigma_inel_NN(), xAOD::TruthEvent::SIGMAINELNN);
 #endif
               // This doesn't yet exist in our version of HepMC
               // xTruthEvent->setHeavyIonParameter(hiInfo->centrality(),xAOD::TruthEvent::CENTRALITY);
             }
  
             // Parton density info
             // This will exist 99% of the time, except for e.g. cosmic or particle gun simulation
             auto const pdfInfo = genEvt->pdf_info();
             if (pdfInfo) {
 #ifdef HEPMC3
               xTruthEvent->setPdfInfoParameter(pdfInfo->parton_id[0], xAOD::TruthEvent::PDGID1);
               xTruthEvent->setPdfInfoParameter(pdfInfo->parton_id[1], xAOD::TruthEvent::PDGID2);
               xTruthEvent->setPdfInfoParameter(pdfInfo->pdf_id[1], xAOD::TruthEvent::PDFID1);
               xTruthEvent->setPdfInfoParameter(pdfInfo->pdf_id[1], xAOD::TruthEvent::PDFID2);
  
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->x[0], xAOD::TruthEvent::X1);
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->x[1], xAOD::TruthEvent::X2);
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->scale, xAOD::TruthEvent::Q);
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->xf[0], xAOD::TruthEvent::XF1);
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->xf[1], xAOD::TruthEvent::XF2);
 #else
               xTruthEvent->setPdfInfoParameter(pdfInfo->id1(), xAOD::TruthEvent::PDGID1);
               xTruthEvent->setPdfInfoParameter(pdfInfo->id2(), xAOD::TruthEvent::PDGID2);
               xTruthEvent->setPdfInfoParameter(pdfInfo->pdf_id1(), xAOD::TruthEvent::PDFID1);
               xTruthEvent->setPdfInfoParameter(pdfInfo->pdf_id2(), xAOD::TruthEvent::PDFID2);
  
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->x1(), xAOD::TruthEvent::X1);
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->x2(), xAOD::TruthEvent::X2);
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->scalePDF(), xAOD::TruthEvent::Q);
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->pdf1(), xAOD::TruthEvent::XF1);
               xTruthEvent->setPdfInfoParameter((float)pdfInfo->pdf2(), xAOD::TruthEvent::XF2);
 #endif
             }
  
             // Handle LHE particles, only supported for HEPMC3
 #ifdef HEPMC3
             auto lhe_record_attribute = genEvt->attribute<HepMC::ShortEventAttribute>("LHERecord");
  
             if (lhe_record_attribute && !hadLHERecord && !m_lheTruthParticleContainerKey.empty()){
               hadLHERecord=true;
               // The event had an LHE record, so let's record it. This will only happen once per event.
               SG::WriteHandle<xAOD::TruthParticleContainer> xTruthLHEParticleContainer(m_lheTruthParticleContainerKey, ctx);
               ATH_CHECK(xTruthLHEParticleContainer.record(std::make_unique<xAOD::TruthParticleContainer>(),
                                                           std::make_unique<xAOD::TruthParticleAuxContainer>()));
               ATH_MSG_DEBUG( "Recorded TruthLHEParticleContainer with key: " << m_lheTruthParticleContainerKey.key() );
               // The LHE record is stored in a struct with old-style LHE format, so we have to re-encode it
               for (int nPart=0;nPart<lhe_record_attribute->NUP;++nPart) {
                 // Create TruthParticle
                 xAOD::TruthParticle* xTruthParticle = new xAOD::TruthParticle();
                 // Put particle into container;
                 xTruthLHEParticleContainer->push_back( xTruthParticle );
                 // Copy LHE info into the new particle; good description is in https://arxiv.org/abs/hep-ph/0609017
                 xTruthParticle->setPdgId( lhe_record_attribute->IDUP[nPart] );
                 xTruthParticle->setBarcode( nPart+1 );
                 xTruthParticle->setStatus( lhe_record_attribute->ISTUP[nPart] );
                 xTruthParticle->setPx( lhe_record_attribute->PUP[nPart][0] );
                 xTruthParticle->setPy( lhe_record_attribute->PUP[nPart][1] );
                 xTruthParticle->setPz( lhe_record_attribute->PUP[nPart][2] );
                 xTruthParticle->setE( lhe_record_attribute->PUP[nPart][3] );
                 xTruthParticle->setM( lhe_record_attribute->PUP[nPart][4] );
               } // End of loop over particles
             } // End of if we found the LHE record attribute
             else if (hadLHERecord){
               ATH_MSG_WARNING("Truth record appeared to have two LHE records; this should not be possible");
             }
 #else
             if (!m_lheTruthParticleContainerKey.empty()){
               ATH_MSG_WARNING("HEPMC2 does not support LHE truth record storage. Skipping.");
             }
 #endif
           }else{//not isSignalProcess
       xTruthPileupEventContainer->push_back( xTruthPileupEvent );
     }
  
           // (2) Build particles and vertices
           // Map for building associations between particles and vertices
           // The pair in the map is the (incomingParticles . outgoingParticles) of the given vertex
           // If signal process vertex is a disconnected vertex (no incoming/outgoing particles), add it manually
           VertexMap vertexMap;
           VertexMap::iterator mapItr;
           vector<HepMC::ConstGenVertexPtr> vertices;
  
           // Check signal process vertex
           // If this is a disconnected vertex, add it manually or won't be added from the loop over particles below.
            auto disconnectedSignalProcessVtx = HepMC::signal_process_vertex(genEvt); // Get the signal process vertex
           if (disconnectedSignalProcessVtx) {
             if (disconnectedSignalProcessVtx->particles_in_size() == 0 && disconnectedSignalProcessVtx->particles_out_size() == 0 ) {
               //This is a disconnected vertex, add it manually
               vertices.push_back (disconnectedSignalProcessVtx);
             }
           } else {
             ATH_MSG_WARNING("Signal process vertex pointer not valid in HepMC Collection for GenEvent #" << cntr << " / " << mcColl->size());
           }
  
           // Get the beam particles
           pair<HepMC::ConstGenParticlePtr,HepMC::ConstGenParticlePtr> beamParticles;
           bool genEvt_valid_beam_particles=false;
 #ifdef HEPMC3
         auto beamParticles_vec = genEvt->beams();
         genEvt_valid_beam_particles=(beamParticles_vec.size()>1);
         if (genEvt_valid_beam_particles){beamParticles.first=beamParticles_vec[0]; beamParticles.second=beamParticles_vec[1]; }
         // We want to process particles in barcode order.
         auto bcmapatt = genEvt->attribute<HepMC::GenEventBarcodes>("barcodes"); // FIXME barcode-based
         if (!bcmapatt) ATH_MSG_ERROR("TruthParticleCnvTool.cxx: Event does not contain barcodes attribute");
         std::map<int, HepMC3::ConstGenParticlePtr> bcmap = bcmapatt->barcode_to_particle_map();
         xTruthParticleContainer->reserve(bcmap.size());
         for (const auto &[genPartBarcode,part]: bcmap) {
 #else
         genEvt_valid_beam_particles=genEvt->valid_beam_particles();
         if ( genEvt_valid_beam_particles ) beamParticles = genEvt->beam_particles();
         xTruthParticleContainer->reserve(genEvt->particles_size());
         for (auto part: *genEvt) {
           int genPartBarcode = HepMC::barcode(part); // FIXME barcode-based
 #endif
           // (a) create TruthParticle
           xAOD::TruthParticle* xTruthParticle = new xAOD::TruthParticle();
           // (b) Put particle into container;
           xTruthParticleContainer->push_back( xTruthParticle );
           fillParticle(xTruthParticle, part); // (c) Copy HepMC info into the new particle
           // (d) Build Event<->Particle element link
           const ElementLink<xAOD::TruthParticleContainer> eltp(*xTruthParticleContainer, xTruthParticleContainer->size()-1);
           if (isSignalProcess) xTruthEvent->addTruthParticleLink(eltp);
           if (!isSignalProcess) xTruthPileupEvent->addTruthParticleLink(eltp);
  
           // Create link between HepMC and xAOD truth
           if (isSignalProcess) truthLinkVec->push_back(new xAODTruthParticleLink(HepMcParticleLink(genPartBarcode,0,HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_BARCODE), eltp)); // FIXME barcode-based
           if (!isSignalProcess) truthLinkVec->push_back(new xAODTruthParticleLink(HepMcParticleLink(genPartBarcode,genEvt->event_number(), HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_BARCODE), eltp)); // FIXME barcode-based
  
           // Is this one of the beam particles?
           if (genEvt_valid_beam_particles) {
             if (isSignalProcess) {
               if (part == beamParticles.first) xTruthEvent->setBeamParticle1Link(eltp);
               if (part == beamParticles.second) xTruthEvent->setBeamParticle2Link(eltp);
             }
           }
             // (e) Particle's production vertex
             auto productionVertex = part->production_vertex();
             // Skip the dummy vertex that HepMC3 adds
             // Can distinguish it from real vertices because it has
             // a null event pointer.
             if (productionVertex && productionVertex->parent_event() != nullptr) {
               VertexParticles& parts = vertexMap[productionVertex];
               if (parts.incoming.empty() && parts.outgoing.empty())
                 vertices.push_back (productionVertex);
               parts.outgoingEL.push_back(eltp);
               parts.outgoing.push_back(xTruthParticle);
             }
             //
             // else maybe want to keep track that this is the production vertex
             //
             // (f) Particle's decay vertex
             auto decayVertex = part->end_vertex();
             if (decayVertex) {
               VertexParticles& parts = vertexMap[decayVertex];
               if (parts.incoming.empty() && parts.outgoing.empty())
                 vertices.push_back (decayVertex);
               parts.incomingEL.push_back(eltp);
               parts.incoming.push_back(xTruthParticle);
             }
  
           } // end of loop over particles
  
           // (3) Loop over the map
           auto signalProcessVtx = HepMC::signal_process_vertex(genEvt); // Get the signal process vertex
           xTruthVertexContainer->reserve(vertices.size());
           for (const auto&  vertex : vertices) {
             const auto& parts = vertexMap[vertex];
             // (a) create TruthVertex
             xAOD::TruthVertex* xTruthVertex = new xAOD::TruthVertex();
             // (b) Put particle into container (so has store)
             xTruthVertexContainer->push_back( xTruthVertex );
             fillVertex(xTruthVertex, vertex); // (c) Copy HepMC info into the new vertex
             // (d) Build Event<->Vertex element link
             ElementLink<xAOD::TruthVertexContainer> eltv(*xTruthVertexContainer, xTruthVertexContainer->size()-1);
             // Mark if this is the signal process vertex
             if (vertex == signalProcessVtx && isSignalProcess) xTruthEvent->setSignalProcessVertexLink(eltv);
             if (isSignalProcess) xTruthEvent->addTruthVertexLink(eltv);
             if (!isSignalProcess) xTruthPileupEvent->addTruthVertexLink(eltv);
             // (e) Assign incoming particles to the vertex, from the map
             xTruthVertex->setIncomingParticleLinks( parts.incomingEL );
             // (f) Assign outgoing particles to the vertex, from the map
             xTruthVertex->setOutgoingParticleLinks( parts.outgoingEL );
             // (g) Set Particle<->Vertex links for incoming particles
             for (xAOD::TruthParticle* p : parts.incoming) p->setDecayVtxLink(eltv);
             // (h) Set Particle<->Vertex links for incoming particles
             for (xAOD::TruthParticle* p : parts.outgoing) p->setProdVtxLink(eltv);
           } //end of loop over vertices
  
           // Delete the event that wasn't used
           if (isSignalProcess) delete xTruthPileupEvent;
           if (!isSignalProcess) delete xTruthEvent;
  
         } // end of loop over McEventCollection
  
  
         std::stable_sort(truthLinkVec->begin(), truthLinkVec->end(), SortTruthParticleLink());
         ATH_MSG_VERBOSE("Summarizing truth link size: " << truthLinkVec->size() );
  
         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 & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.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();
 }

◆ fillParticle()

void xAODMaker::xAODTruthCnvAlg::fillParticle	(	xAOD::TruthParticle *	tp,
		const HepMC::ConstGenParticlePtr &	gp
	)

staticprivate

Definition at line 590 of file xAODTruthCnvAlg.cxx.

                                                                                                 {
         tp->setPdgId(gp->pdg_id());
         tp->setBarcode(HepMC::barcode(gp)); // FIXME barcode-based
         tp->setStatus(HepMC::old_particle_status_from_new(HepMC::status(gp))); // For now convert the status back to the old scheme
  
         auto pol = HepMC::polarization(gp);
         if (pol.is_defined()) {
             tp->setPolarizationParameter(pol.theta(), xAOD::TruthParticle::polarizationTheta);
             tp->setPolarizationParameter(pol.phi(), xAOD::TruthParticle::polarizationPhi);
         }
  
         tp->setM(gp->generated_mass());
         tp->setPx(gp->momentum().px());
         tp->setPy(gp->momentum().py());
         tp->setPz(gp->momentum().pz());
         tp->setE(gp->momentum().e());
     }

◆ fillVertex()

void xAODMaker::xAODTruthCnvAlg::fillVertex	(	xAOD::TruthVertex *	tv,
		const HepMC::ConstGenVertexPtr &	gv
	)

staticprivate

These functions do not set up ELs, just the other variables.

Definition at line 578 of file xAODTruthCnvAlg.cxx.

                                                                                           {
       // id was renamed to status in HepMC3.
       tv->setId(HepMC::old_vertex_status_from_new(HepMC::status(gv))); // For now convert the status back to the old scheme
       tv->setBarcode(HepMC::barcode(gv)); // FIXME barcode-based
       tv->setX(gv->position().x());
       tv->setY(gv->position().y());
       tv->setZ(gv->position().z());
       tv->setT(gv->position().t());
     }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

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

◆ handle()

void xAODMaker::xAODTruthCnvAlg::handle ( const Incident & incident )

overridevirtual

Incident handler.

Definition at line 528 of file xAODTruthCnvAlg.cxx.

                                                              {
           if (m_firstBeginRun && incident.type()==IncidentType::BeginRun) {
             m_firstBeginRun = false;
             ServiceHandle<StoreGateSvc> inputStore("StoreGateSvc/InputMetaDataStore", name());
             if(inputStore.retrieve().isFailure()) {
               ATH_MSG_ERROR("Failed to retrieve Input Metadata Store");
               return;
             }
             const IOVMetaDataContainer* tagInfo{nullptr};
             if(inputStore->retrieve(tagInfo,"/TagInfo").isFailure()) {
               ATH_MSG_WARNING("Failed to retrieve /TagInfo metadata from the input store");
               return;
             }
             if(tagInfo->payloadContainer()->size()>0) {
               CondAttrListCollection* tagInfoPayload = tagInfo->payloadContainer()->at(0);
               if(tagInfoPayload->size()>0) {
                 const CondAttrListCollection::AttributeList& al = tagInfoPayload->attributeList(0);
                 if (al.exists("lhefGenerator")){
                   m_metaFields.lhefGenerator = al["lhefGenerator"].data<std::string>();
                 }
  
                 if (al.exists("generators")){
                   m_metaFields.generators = al["generators"].data<std::string>();
                 }
  
                 if (al.exists("evgenProcess")){
                   m_metaFields.evgenProcess = al["evgenProcess"].data<std::string>();
                 }
  
                 if (al.exists("evgenTune")){
                   m_metaFields.evgenTune = al["evgenTune"].data<std::string>();
                 }
  
                 if (al.exists("hardPDF")){
                   m_metaFields.hardPDF = al["hardPDF"].data<std::string>();
                 }
  
                 if (al.exists("softPDF")){
                   m_metaFields.softPDF = al["softPDF"].data<std::string>();
                 }
               }
             }
             else {
               ATH_MSG_WARNING("Empty Tag Info metadata!");
             }
           }
         }

◆ initialize()

StatusCode xAODMaker::xAODTruthCnvAlg::initialize ( )

overridevirtual

Function initialising the algorithm.

Definition at line 65 of file xAODTruthCnvAlg.cxx.

                                            {
         if (m_doAllPileUp && m_doInTimePileUp) {
             ATH_MSG_FATAL( "Contradictory xAOD truth pile-up setting: all pile-up AND in-time alone requested simultaneously. Check settings." );
             return StatusCode::FAILURE;
         }
  
         if (m_writeMetaData) {
             ATH_CHECK( m_meta.initialize (m_metaStore, m_metaName) );
         }
  
         // initialize handles
         ATH_CHECK(m_truthLinkContainerKey.initialize());
  
         // only if doing full truth
         ATH_CHECK(m_aodContainerKey.initialize());
         ATH_CHECK(m_xaodTruthEventContainerKey.initialize());
         ATH_CHECK(m_xaodTruthPUEventContainerKey.initialize(m_doAllPileUp || m_doInTimePileUp));
         ATH_CHECK(m_xaodTruthParticleContainerKey.initialize());
         ATH_CHECK(m_xaodTruthVertexContainerKey.initialize());
         if (!m_lheTruthParticleContainerKey.empty()){
           ATH_CHECK(m_lheTruthParticleContainerKey.initialize());
         }
  
         ATH_CHECK(m_evtInfo.initialize());
  
         ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", name());
         ATH_CHECK(incSvc.retrieve());
         incSvc->addListener( this, "BeginRun", 10);
  
         ATH_MSG_DEBUG("AODContainerName = " << m_aodContainerKey.key() );
         ATH_MSG_DEBUG("xAOD TruthEventContainer name = " << m_xaodTruthEventContainerKey.key() );
         ATH_MSG_DEBUG("xAOD TruthPileupEventContainer name = " << m_xaodTruthPUEventContainerKey.key() );
         ATH_MSG_DEBUG("xAOD TruthParticleContainer name = " << m_xaodTruthParticleContainerKey.key() );
         ATH_MSG_DEBUG("xAOD TruthVertexContainer name = " << m_xaodTruthVertexContainerKey.key() );
         if (!m_lheTruthParticleContainerKey.empty()){
           ATH_MSG_DEBUG("xAOD TruthLHEParticleContainer name = " << m_lheTruthParticleContainerKey.key() );
         }
  
         if (m_doAllPileUp) ATH_MSG_INFO( "All pile-up truth (including out-of-time) will be written" );
         if (m_doInTimePileUp) ATH_MSG_INFO( "In-time pile-up truth (but not out-of-time) will be written" );
         if (!m_doAllPileUp && !m_doInTimePileUp) ATH_MSG_INFO( "No pile-up truth will be written" );
  
         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()

bool AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, InDet::SiSPGNNTrackMaker, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

 {
   // Reentrant algorithms are clonable.
   return true;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 380 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 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed	(	bool	state,
		const EventContext &	ctx
	)		const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthReentrantAlgorithm::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.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

 {
   return Gaudi::Algorithm::sysExecute (ctx);
 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::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 InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

                                                 {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::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< 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 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

◆ ATLAS_THREAD_SAFE

MetaDataWriter m_meta xAODMaker::xAODTruthCnvAlg::ATLAS_THREAD_SAFE

mutableprivate

Helper for writing to the meta data store.

This factors out the pieces that are non-const. It's declared mutable and protected with a mutex.

Definition at line 154 of file xAODTruthCnvAlg.h.

◆ m_aodContainerKey

SG::ReadHandleKey<McEventCollection> xAODMaker::xAODTruthCnvAlg::m_aodContainerKey

private

Initial value:

{

this, "AODContainerName", "GEN_AOD", "The input McEvenCollection"}

The key of the input AOD truth container.

Definition at line 130 of file xAODTruthCnvAlg.h.

◆ m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doAllPileUp

Gaudi::Property<bool> xAODMaker::xAODTruthCnvAlg::m_doAllPileUp {this, "WriteAllPileUpTruth", false}

private

Pile-up options.

Definition at line 148 of file xAODTruthCnvAlg.h.

◆ m_doInTimePileUp

Gaudi::Property<bool> xAODMaker::xAODTruthCnvAlg::m_doInTimePileUp {this, "WriteInTimePileUpTruth", false}

private

Definition at line 149 of file xAODTruthCnvAlg.h.

◆ m_evtInfo

SG::ReadHandleKey<xAOD::EventInfo> xAODMaker::xAODTruthCnvAlg::m_evtInfo {this, "EventInfo", "EventInfo", "" }

private

Event Info.

Definition at line 165 of file xAODTruthCnvAlg.h.

◆ m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_firstBeginRun

bool xAODMaker::xAODTruthCnvAlg::m_firstBeginRun

private

Tag Info.

Definition at line 168 of file xAODTruthCnvAlg.h.

◆ m_lheTruthParticleContainerKey

SG::WriteHandleKey<xAOD::TruthParticleContainer> xAODMaker::xAODTruthCnvAlg::m_lheTruthParticleContainerKey

private

Initial value:

{

this, "xAODTruthLHEParticleContainerName", "", "Output TruthLHEParticles container"}

Definition at line 144 of file xAODTruthCnvAlg.h.

◆ m_metaFields

MetadataFields xAODMaker::xAODTruthCnvAlg::m_metaFields

private

Definition at line 169 of file xAODTruthCnvAlg.h.

◆ m_metaName

std::string xAODMaker::xAODTruthCnvAlg::m_metaName

private

SG key and name for meta data.

Definition at line 159 of file xAODTruthCnvAlg.h.

◆ m_metaStore

ServiceHandle< StoreGateSvc > xAODMaker::xAODTruthCnvAlg::m_metaStore

private

Connection to the metadata store.

Definition at line 157 of file xAODTruthCnvAlg.h.

◆ m_truthLinkContainerKey

SG::WriteHandleKey<xAODTruthParticleLinkVector> xAODMaker::xAODTruthCnvAlg::m_truthLinkContainerKey

private

Initial value:

{

this, "TruthLinks", "xAODTruthLinks", "Output xAODTruthLinks container"}

Definition at line 142 of file xAODTruthCnvAlg.h.

◆ m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeMetaData

Gaudi::Property<bool> xAODMaker::xAODTruthCnvAlg::m_writeMetaData {this, "WriteTruthMetaData", true}

private

option to disable writing of metadata (e.g. if running a filter on xAOD in generators)

Definition at line 162 of file xAODTruthCnvAlg.h.

◆ m_xaodTruthEventContainerKey

SG::WriteHandleKey<xAOD::TruthEventContainer> xAODMaker::xAODTruthCnvAlg::m_xaodTruthEventContainerKey

private

Initial value:

{

this, "xAODTruthEventContainerName", "TruthEvents", "Output TruthEvents container"}

The key for the output xAOD truth containers.

Definition at line 134 of file xAODTruthCnvAlg.h.

◆ m_xaodTruthParticleContainerKey

SG::WriteHandleKey<xAOD::TruthParticleContainer> xAODMaker::xAODTruthCnvAlg::m_xaodTruthParticleContainerKey

private

Initial value:

{

this, "xAODTruthParticleContainerName", "TruthParticles", "Output TruthParticles container"}

Definition at line 138 of file xAODTruthCnvAlg.h.

◆ m_xaodTruthPUEventContainerKey

SG::WriteHandleKey<xAOD::TruthPileupEventContainer> xAODMaker::xAODTruthCnvAlg::m_xaodTruthPUEventContainerKey

private

Initial value:

{

this, "xAODTruthPileupEventContainerName", "TruthPileupEvents", "Output TruthPileupEvents container"}

Definition at line 136 of file xAODTruthCnvAlg.h.

◆ m_xaodTruthVertexContainerKey

SG::WriteHandleKey<xAOD::TruthVertexContainer> xAODMaker::xAODTruthCnvAlg::m_xaodTruthVertexContainerKey

private

Initial value:

{

this, "xAODTruthVertexContainerName", "TruthVertices", "Output TruthVertices container"}

Definition at line 140 of file xAODTruthCnvAlg.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ VertexMap

Constructor & Destructor Documentation

◆ xAODTruthCnvAlg()

Member Function Documentation

◆ cardinality()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ fillParticle()

◆ fillVertex()

◆ filterPassed()

◆ handle()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_aodContainerKey

◆ m_detStore

◆ m_doAllPileUp

◆ m_doInTimePileUp

◆ m_evtInfo

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_firstBeginRun

◆ m_lheTruthParticleContainerKey

◆ m_metaFields

◆ m_metaName

◆ m_metaStore

◆ m_truthLinkContainerKey

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_writeMetaData

◆ m_xaodTruthEventContainerKey

◆ m_xaodTruthParticleContainerKey

◆ m_xaodTruthPUEventContainerKey

◆ m_xaodTruthVertexContainerKey