xAODMaker::xAODTruthCnvAlg Class Reference

Algorithm creating xAOD truth from HepMC. More...

#include <xAODTruthCnvAlg.h>

Inheritance 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.
virtual StatusCode	initialize () override
	Function initialising the algorithm.
virtual StatusCode	execute (const EventContext &ctx) const override
	Function executing the algorithm.
virtual void	handle (const Incident &incident) override
	Incident handler.
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 std::map< HepMC::ConstGenVertexPtr, VertexParticles >	VertexMap
	Convenience handle for a map of vtx ptrs -> connected particles.
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>

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.
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.
SG::WriteHandleKey< xAOD::TruthEventContainer >	m_xaodTruthEventContainerKey
	The key for the output xAOD truth containers.
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.
Gaudi::Property< bool >	m_doInTimePileUp {this, "WriteInTimePileUpTruth", false}
MetaDataWriter m_meta	ATLAS_THREAD_SAFE
	Helper for writing to the meta data store.
ServiceHandle< StoreGateSvc >	m_metaStore
	Connection to the metadata store.
std::string	m_metaName
	SG key and name for meta data.
Gaudi::Property< bool >	m_writeMetaData {this, "WriteTruthMetaData", true}
	option to disable writing of metadata (e.g. if running a filter on xAOD in generators)
SG::ReadHandleKey< xAOD::EventInfo >	m_evtInfo {this, "EventInfo", "EventInfo", "" }
	Event Info.
bool	m_firstBeginRun
	Tag Info.
MetadataFields	m_metaFields
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

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 45 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 104 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( "StoreGateSvc/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

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

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 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
        bool hadLHERecord = false;
 
        // ***********************************************************************************
        // 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());
        bool newAttributesPresent(false);
        for (unsigned int cntr = 0; cntr < mcColl->size(); ++cntr) {
          const HepMC::GenEvent* genEvt = (*mcColl)[cntr];
          bool isSignalProcess(false);
          if (cntr==0) {
            isSignalProcess=true;
            auto bunchCrossingTime = genEvt->attribute<HepMC3::IntAttribute>(HepMCStr::BunchCrossingTime);
            if (bunchCrossingTime) {
              newAttributesPresent = true;
              ATH_MSG_VERBOSE("New attributes present.");
            }
            else {
              ATH_MSG_VERBOSE("New attributes missing.");
            }
          }
          if (cntr>0) {
            // Handle pile-up events
            if (!m_doInTimePileUp && !m_doAllPileUp) break;
            isSignalProcess=false;
            auto bunchCrossingTime = genEvt->attribute<HepMC3::IntAttribute>(HepMCStr::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;
              }
            }
          }
 
          xAOD::TruthEvent* xTruthEvent = nullptr;
          xAOD::TruthPileupEvent* xTruthPileupEvent = nullptr;
 
 
          if (isSignalProcess) {
            xTruthEvent = xTruthEventContainer->push_back( std::make_unique<xAOD::TruthEvent>() );
            // Cross-section
            auto crossSection = genEvt->cross_section();
            xTruthEvent->setCrossSection(crossSection ? (float)crossSection->xsec() : -1);
            xTruthEvent->setCrossSectionError(crossSection ? (float)crossSection->xsec_err() : -1);
 
            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) {
              /* 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);
              // 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) {
              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);
            }
 
            // Handle LHE event record
            auto lhe_record_attribute = genEvt->attribute<HepMC::ShortEventAttribute>(HepMCStr::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->setUid( 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{//not isSignalProcess
            xTruthPileupEvent = xTruthPileupEventContainer->push_back( std::make_unique<xAOD::TruthPileupEvent>() );
          }
 
          // (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 (std::move(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;
        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>(HepMCStr::barcodes); // FIXME barcode-based
        if (!bcmapatt) {
          ATH_MSG_ERROR("TruthParticleCnvTool.cxx: Event does not contain barcodes attribute");
          return StatusCode::FAILURE;
        }
        std::map<int, HepMC3::ConstGenParticlePtr> bcmap = bcmapatt->barcode_to_particle_map();
        xTruthParticleContainer->reserve(bcmap.size());
        for (const auto &[genPartBarcode,part]: bcmap) {
          int genPartUniqueID = HepMC::uniqueID(part);
          // (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(genPartUniqueID,0,HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_ID), eltp));
          if (!isSignalProcess) truthLinkVec->push_back(new xAODTruthParticleLink(HepMcParticleLink(genPartUniqueID,genEvt->event_number(), HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_ID), eltp));
 
          // 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 (std::move(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 (std::move(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
 
        } // 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 & 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();
}

fillParticle()

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

staticprivate

Definition at line 522 of file xAODTruthCnvAlg.cxx.

                                                                                                {
        tp->setPdgId(gp->pdg_id());
        tp->setUid(HepMC::uniqueID(gp)); // FIXME set xAOD::TruthParticle function name appropriately
        tp->setStatus(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 510 of file xAODTruthCnvAlg.cxx.

                                                                                          {
      // id was renamed to status in HepMC3.
      tv->setStatus(HepMC::status(gv)); // For now convert the status back to the old scheme
      tv->setUid(HepMC::uniqueID(gv)); // FIXME set xAOD::TruthVertex function name appropriately
      tv->setX(gv->position().x());
      tv->setY(gv->position().y());
      tv->setZ(gv->position().z());
      tv->setT(gv->position().t());
    }

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

handle()

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

overridevirtual

Incident handler.

Definition at line 460 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()

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 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 AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

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, AthFilterAlgorithm, 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 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 135 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 111 of file xAODTruthCnvAlg.h.

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

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 129 of file xAODTruthCnvAlg.h.

{this, "WriteAllPileUpTruth", false};

m_doInTimePileUp

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

private

Definition at line 130 of file xAODTruthCnvAlg.h.

{this, "WriteInTimePileUpTruth", false};

m_evtInfo

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

private

Event Info.

Definition at line 146 of file xAODTruthCnvAlg.h.

{this, "EventInfo", "EventInfo", "" };

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 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_firstBeginRun

bool xAODMaker::xAODTruthCnvAlg::m_firstBeginRun

private

Tag Info.

Definition at line 149 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 125 of file xAODTruthCnvAlg.h.

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

m_metaFields

MetadataFields xAODMaker::xAODTruthCnvAlg::m_metaFields

private

Definition at line 150 of file xAODTruthCnvAlg.h.

m_metaName

std::string xAODMaker::xAODTruthCnvAlg::m_metaName

private

SG key and name for meta data.

Definition at line 140 of file xAODTruthCnvAlg.h.

m_metaStore

ServiceHandle< StoreGateSvc > xAODMaker::xAODTruthCnvAlg::m_metaStore

private

Connection to the metadata store.

Definition at line 138 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 123 of file xAODTruthCnvAlg.h.

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

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 143 of file xAODTruthCnvAlg.h.

{this, "WriteTruthMetaData", true};

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 115 of file xAODTruthCnvAlg.h.

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

m_xaodTruthParticleContainerKey

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

private

Initial value:

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

Definition at line 119 of file xAODTruthCnvAlg.h.

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

m_xaodTruthPUEventContainerKey

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

private

Initial value:

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

Definition at line 117 of file xAODTruthCnvAlg.h.

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

m_xaodTruthVertexContainerKey

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

private

Initial value:

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

Definition at line 121 of file xAODTruthCnvAlg.h.

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

---

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

• xAODTruthCnvAlg.h
• xAODTruthCnvAlg.cxx