top::ParticleLevelLoader Class Reference

Loading tool which creates a particle level event object. More...

#include <ParticleLevelLoader.h>

Inheritance diagram for top::ParticleLevelLoader:

Collaboration diagram for top::ParticleLevelLoader:

Public Member Functions
	ParticleLevelLoader (const std::shared_ptr< top::TopConfig > &cfg)
	Constructor of the loader tool. More...
virtual	~ParticleLevelLoader ()
	Destructor of the loader tool. More...
ParticleLevelEvent	load ()
	Loading function. More...
bool	active () const
	Function that can be used to test whether the ParticleLevelLoader is active. More...
virtual StatusCode	initialize ()
	Dummy implementation of the initialisation function. More...
virtual void	print () const
	Print the state of the tool. More...
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	sysInitialize () override
	Perform system initialization for an algorithm. 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
bool	loadDressedLeptons (const xAOD::TruthParticleContainer &input, std::unique_ptr< xAOD::TruthParticleContainer > &store, std::unique_ptr< xAOD::ShallowAuxContainer > &storeAux) const
bool	isDressingPhoton (const xAOD::TruthParticle &photon, const xAOD::TruthParticleContainer &dressedParticles, const float dressingCone=0.1) const
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 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...

Private Attributes
const std::shared_ptr< top::TopConfig > &	m_config
std::unique_ptr< ObjectSelectorBase< xAOD::TruthParticle > >	m_objectSelector_Electron
std::unique_ptr< ObjectSelectorBase< xAOD::TruthParticle > >	m_objectSelector_Muon
std::unique_ptr< ObjectSelectorBase< xAOD::TruthParticle > >	m_objectSelector_Photon
std::unique_ptr< ObjectSelectorBase< xAOD::Jet > >	m_objectSelector_Jet
std::unique_ptr< ObjectSelectorBase< xAOD::Jet > >	m_objectSelector_LargeRJet
std::unique_ptr< ObjectSelectorBase< xAOD::TruthParticle > >	m_objectSelector_Tau
std::unique_ptr< ParticleLevelRCJetObjectLoader >	m_particleLevelRCJetObjectLoader
std::map< std::string, std::unique_ptr< ParticleLevelRCJetObjectLoader > >	m_particleLevelVarRCJetObjectLoader
std::vector< std::string >	m_VarRCJetRho
std::vector< std::string >	m_VarRCJetMassScale
std::unique_ptr< xAOD::TruthParticleContainer >	m_electronsDressed
std::unique_ptr< xAOD::ShallowAuxContainer >	m_electronsDressedAux
std::unique_ptr< xAOD::TruthParticleContainer >	m_muonsDressed
std::unique_ptr< xAOD::ShallowAuxContainer >	m_muonsDressedAux
std::unique_ptr< xAOD::TruthParticleContainer >	m_goodElectrons
std::unique_ptr< xAOD::TruthParticleAuxContainer >	m_goodElectronsAux
std::unique_ptr< xAOD::TruthParticleContainer >	m_goodMuons
std::unique_ptr< xAOD::TruthParticleAuxContainer >	m_goodMuonsAux
std::unique_ptr< xAOD::TruthParticleContainer >	m_goodSoftMuons
std::unique_ptr< xAOD::TruthParticleAuxContainer >	m_goodSoftMuonsAux
std::unique_ptr< xAOD::TruthParticleContainer >	m_goodPhotons
std::unique_ptr< xAOD::TruthParticleAuxContainer >	m_goodPhotonsAux
std::unique_ptr< xAOD::JetContainer >	m_goodJets
std::unique_ptr< xAOD::JetAuxContainer >	m_goodJetsAux
std::unique_ptr< xAOD::JetContainer >	m_goodLargeRJets
std::unique_ptr< xAOD::JetAuxContainer >	m_goodLargeRJetsAux
std::unique_ptr< xAOD::TruthParticleContainer >	m_goodTaus
std::unique_ptr< xAOD::TruthParticleAuxContainer >	m_goodTausAux
const bool	m_active
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

Loading tool which creates a particle level event object.

After creation of the loader tool, it will be in of of two states: either it is "active" or not (can be tested using the active() member function). If the tool is not active, then the load function is a no-op, it will return an "empty" ParticleLevelEvent object. The active() member function allows for the enclosing (i.e. calling) program to conditionally branch into computing intensive parts depending on whether particle level data is available or not. The loader tool is configured to be non-"active" if the input data is not monte carlo or any of the required collection names are empty respectively None

Definition at line 53 of file ParticleLevelLoader.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

ParticleLevelLoader()

top::ParticleLevelLoader::ParticleLevelLoader

(

const std::shared_ptr< top::TopConfig > &

cfg

)

Constructor of the loader tool.

Definition at line 36 of file ParticleLevelLoader.cxx.

    : asg::AsgTool("ParticleLevelLoader"),
    m_config(cfg),
    // Don't create them here because construction is a bit long-ish
    m_objectSelector_Electron(nullptr),
    m_objectSelector_Muon(nullptr),
    m_objectSelector_Photon(nullptr),
    m_objectSelector_Jet(nullptr),
    m_objectSelector_LargeRJet(nullptr),
    m_objectSelector_Tau(nullptr),
    // Tool is inactive on non-MC data and whenever particle level is not requested
    m_active(m_config->doTopParticleLevel() &&
             m_config->isMC() &&
             (m_config->useTruthElectrons() ||
              m_config->useTruthMuons() ||
              m_config->useTruthPhotons() ||
              m_config->useTruthJets() ||
              m_config->useTruthLargeRJets() ||
              m_config->useTruthTaus() ||
              m_config->useTruthMET())) {
    // Configure and create electron object selector
    auto optEl = ParticleLevelElectronObjectSelector::Options {
      m_config->truth_electron_PtCut(),
         m_config->truth_electron_EtaCut(),
         m_config->truth_electron_NotFromHadron(),
         m_config->truth_electron_TauIsHadron()
    };
 
    m_objectSelector_Electron.reset(new ParticleLevelElectronObjectSelector(optEl));
 
    // Configure and create muon object selector
    auto optMu = ParticleLevelMuonObjectSelector::Options {
      m_config->truth_muon_PtCut(),
         m_config->truth_muon_EtaCut(),
         m_config->truth_muon_NotFromHadron(),
         m_config->truth_muon_TauIsHadron()
    };
 
    m_objectSelector_Muon.reset(new ParticleLevelMuonObjectSelector(optMu));
 
    // Configure and create photon object selector
    auto optPhoton = ParticleLevelPhotonObjectSelector::Options {
      m_config->truth_photon_PtCut(),
         m_config->truth_photon_EtaCut(),
         m_config->truth_photon_Origin(),
         m_config->truth_photon_Isolation()
    };
 
    m_objectSelector_Photon.reset(new ParticleLevelPhotonObjectSelector(optPhoton));
 
 
    // Configure and create jet object selector
    auto optJet = ParticleLevelJetObjectSelector::Options {
      m_config->truth_jet_PtCut(),
         m_config->truth_jet_EtaCut()
    };
 
    m_objectSelector_Jet.reset(new ParticleLevelJetObjectSelector(optJet));
 
    // Configure and create jet object selector
    auto optLargeRJet = ParticleLevelJetObjectSelector::Options {
      m_config->truth_jet_largeR_PtCut(),
         m_config->truth_jet_largeR_EtaCut()
    };
 
    m_objectSelector_LargeRJet.reset(new ParticleLevelJetObjectSelector(optLargeRJet));
 
    // Configure and create muon object selector
    auto optTau = ParticleLevelTauObjectSelector::Options {
      m_config->truth_tau_PtCut(),
         m_config->truth_tau_EtaCut()
    };
 
    m_objectSelector_Tau.reset(new ParticleLevelTauObjectSelector(optTau));
 
 
    MsgStream &msgInfo = msg(MSG::Level::INFO);
    if (m_active) {
      msgInfo << "Particle level reconstruction is enabled; telling you how I am configured:" << '\n';
      msgInfo << "   " << std::setw(20) << "UseElectrons? " << std::setw(5) << std::boolalpha <<
        m_config->useTruthElectrons();
      if (m_config->useTruthElectrons()) {
        msgInfo << " [" << m_config->sgKeyTruthElectrons() << "]" << '\n'
                << "     --- Pt           > " << m_config->truth_electron_PtCut() << '\n'
                << "     --- |eta|        < " << m_config->truth_electron_EtaCut() << '\n'
                << "     --- notFromHadron? " << std::boolalpha << m_config->truth_electron_NotFromHadron() << '\n'
                << "     --- tauIsHadron?   " << std::boolalpha << m_config->truth_electron_TauIsHadron() << '\n';
      } else {
        msgInfo << '\n';
      }
      msgInfo << "   " << std::setw(20) << "UseMuons? " << std::setw(5) << std::boolalpha <<
        m_config->useTruthMuons();
      if (m_config->useTruthMuons()) {
        msgInfo << " [" << m_config->sgKeyTruthMuons() << "]" << '\n'
                << "     --- Pt           > " << m_config->truth_muon_PtCut() << '\n'
                << "     --- |eta|        < " << m_config->truth_muon_EtaCut() << '\n'
                << "     --- notFromHadron? " << std::boolalpha << m_config->truth_muon_NotFromHadron() << '\n'
                << "     --- tauIsHadron?   " << std::boolalpha << m_config->truth_muon_TauIsHadron() << '\n';
      } else {
        msgInfo << '\n';
      }
      msgInfo << "   " << std::setw(20) << "UsePhotons? " << std::setw(5) << std::boolalpha <<
        m_config->useTruthPhotons();
      if (m_config->useTruthPhotons()) {
        msgInfo << " [" << m_config->sgKeyTruthPhotons() << "]" << '\n'
                << "     --- Pt           > " << m_config->truth_photon_PtCut() << '\n'
                << "     --- |eta|        < " << m_config->truth_photon_EtaCut() << '\n'
                << "     --- Origin       = " << m_config->truth_photon_Origin() << '\n'
                << "     --- Isolation    = " << m_config->truth_photon_Isolation() << '\n';
      } else {
        msgInfo << '\n';
      }
      msgInfo << "   " << std::setw(20) << "UseJets? " << std::setw(5) << std::boolalpha << m_config->useTruthJets();
      if (m_config->useTruthJets()) {
        msgInfo << " [" << m_config->sgKeyTruthJets() << "]" << '\n'
                << "     --- Pt           > " << m_config->truth_jet_PtCut() << '\n'
                << "     --- |eta|        < " << m_config->truth_jet_EtaCut() << '\n';
      } else {
        msgInfo << '\n';
      }
      msgInfo << "   " << std::setw(20) << "UseLargeRJets? " << std::setw(5) << std::boolalpha <<
        m_config->useTruthLargeRJets();
      if (m_config->useTruthJets()) {
        msgInfo << " [" << m_config->sgKeyTruthLargeRJets() << "]" << '\n'
                << "     --- Pt           > " << m_config->truth_jet_largeR_PtCut() << '\n'
                << "     --- |eta|        < " << m_config->truth_jet_largeR_EtaCut() << '\n';
      } else {
        msgInfo << '\n';
      }
      msgInfo << "   " << std::setw(20) << "UseTaus? " << std::setw(5) << std::boolalpha << m_config->useTruthTaus();
      if (m_config->useTruthTaus()) {
        msgInfo << " [" << m_config->sgKeyTruthTaus() << "]" << '\n'
                << "     --- Pt           > " << m_config->truth_tau_PtCut() << '\n'
                << "     --- |eta|        < " << m_config->truth_tau_EtaCut() << '\n';
      } else {
        msgInfo << '\n';
      }
      msgInfo << "   " << std::setw(20) << "UseMET? " << std::setw(5) << std::boolalpha << m_config->useTruthMET();
      if (m_config->useTruthMET()) {
        msgInfo << " [" << m_config->sgKeyTruthMET() << "]" << '\n';
      } else {
        msgInfo << '\n';
      }
      msgInfo << "   " << std::setw(20) << "DoOverlapRemoval Mu-Jet? " << std::setw(5) << std::boolalpha <<
        m_config->doParticleLevelOverlapRemovalMuJet() << '\n';
      msgInfo << "   " << std::setw(20) << "DoOverlapRemoval El-Jet? " << std::setw(5) << std::boolalpha <<
        m_config->doParticleLevelOverlapRemovalElJet() << '\n';
      msgInfo << "   " << std::setw(20) << "DoOverlapRemoval Jet-Photon? " << std::setw(5) << std::boolalpha <<
        m_config->doParticleLevelOverlapRemovalJetPhoton() << '\n';
 
 
      if (m_config->useRCJets()) {
        m_particleLevelRCJetObjectLoader = std::unique_ptr<ParticleLevelRCJetObjectLoader> (new ParticleLevelRCJetObjectLoader(
                                                                                              m_config));
        top::check(m_particleLevelRCJetObjectLoader->initialize(),
                   "Failed to initialize ParticleLevelRCJetObjectLoader");
      }
 
      if (m_config->useVarRCJets() == true) {
        boost::split(m_VarRCJetRho, m_config->VarRCJetRho(), boost::is_any_of(","));
        boost::split(m_VarRCJetMassScale, m_config->VarRCJetMassScale(), boost::is_any_of(","));
 
        for (auto& rho : m_VarRCJetRho) {
          for (auto& mass_scale : m_VarRCJetMassScale) {
            std::replace(rho.begin(), rho.end(), '.', '_');
            std::string name = rho + mass_scale;
            m_particleLevelVarRCJetObjectLoader[name] = std::unique_ptr<ParticleLevelRCJetObjectLoader> (new ParticleLevelRCJetObjectLoader(
                                                                                                           m_config));
            top::check(m_particleLevelVarRCJetObjectLoader[name]->setProperty("VarRCjets",
                                                                              true),
                       "Failed to set VarRCjets property of VarRCJet");
            top::check(m_particleLevelVarRCJetObjectLoader[name]->setProperty("VarRCjets_rho",
                                                                              rho),
                       "Failed to set VarRCjets rho property of VarRCJet");
            top::check(m_particleLevelVarRCJetObjectLoader[name]->setProperty("VarRCjets_mass_scale",
                                                                              mass_scale),
                       "Failed to set VarRCjets mass scale property of VarRCJet");
            top::check(m_particleLevelVarRCJetObjectLoader[name]->initialize(), "Failed to initialize VarRCJet");
          } // end loop over mass scale parameters (e.g., top mass, w mass, etc.)
        } // end loop over mass scale multiplies (e.g., 1.,2.,etc.)
      }
    } else {
      msgInfo << "Particle level reconstruction is disabled." << '\n';
    }
    msgInfo.doOutput();
  }

~ParticleLevelLoader()

top::ParticleLevelLoader::~ParticleLevelLoader ( )

virtual

Destructor of the loader tool.

Definition at line 223 of file ParticleLevelLoader.cxx.

{ /* Deliberately Empty */}

Member Function Documentation

active()

bool top::ParticleLevelLoader::active ( ) const

inline

Function that can be used to test whether the ParticleLevelLoader is active.

The loader is set to inactive if the names of the truth collections are unavailable. This is determined at construction.

Definition at line 80 of file ParticleLevelLoader.h.

{return m_active;}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getName()

const std::string & asg::AsgTool::getName ( const void *  ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T >

const T* asg::AsgTool::getProperty ( const std::string &  name ) const

inherited

Get one of the tool's properties.

initialize()

virtual StatusCode asg::AsgTool::initialize ( )

inlinevirtualinherited

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented in SimpleMuonTriggerScaleFactors, Trig::TrigMuonMatching, CP::MuonTriggerScaleFactors, Trig::TrigTauMatchingTool, IHIEventShapeMapTool, ST::SUSYObjDef_xAOD, InDetSecVtxTruthMatchTool, JetGrooming::RecSoftDrop, met::METMaker, AsgForwardElectronIsEMSelector, JetGrooming::JetTrimming, ORUtils::BaseOverlapTool, PMGTools::PMGSherpa22VJetsWeightTool, AsgElectronEfficiencyCorrectionTool, CP::ElectronChargeEfficiencyCorrectionTool, AsgForwardElectronLikelihoodTool, CorrectPFOTool, CP::IsolationCorrectionTool, TauAnalysisTools::TauTruthMatchingTool, EGammaAmbiguityTool, InDetVertexTruthMatchTool, AthOnnx::OnnxRuntimeSessionToolCPU, AthOnnx::OnnxRuntimeSessionToolCUDA, PuppiWeightTool, JetIsolationTool, JetBalancePFlowJvtTool, CP::FFJetSmearingTool, JetForwardPFlowJvtTool, MCTruthClassifier, InDet::InDetHardScatterSelectionTool, dRMatchingTool, xAOD::BPhysBlindingTool, CP::EgammaCalibrationAndSmearingTool, JetVertexTaggerTool, tauRecTools::TrackRNN, LVL1::L1CaloOfflineTriggerTowerTools, TauAnalysisTools::TauSelectionTool, JetRecTool, met::METAssociationTool, CP::TrackVertexAssociationTool, met::METRebuilder, met::METAssociator, xAOD::TrackIsolationTool, InDet::InDetTrackSelectionTool, egammaMVACalibTool, TrigConf::xAODConfigTool, JetCleaningTool, met::METCaloRegionsTool, ZDC::ZdcLEDAnalysisTool, CP::MuonCalibTool, LVL1::L1CaloCells2TriggerTowers, JetVertexFractionTool, LVL1BS::PpmByteStreamReadV1V2Tool, JetClusterer, JetForwardJvtToolBDT, CP::AsgFlagSelectionTool, TauTrackFinder, TauAnalysisTools::DiTauSelectionTool, JetClustererByVertex, JetBadChanCorrTool, xAOD::BPhysTrackVertexMapTool, JetModifiedMassDrop, xAOD::CaloIsolationTool, EnhancedBiasWeighter, BookkeeperTool, ZDC::RpdSubtractCentroidTool, InDet::InDetUsedInFitTrackDecoratorTool, CP::AsgPtEtaSelectionTool, TauAnalysisTools::BuildTruthTaus, top::EventSaverFlatNtuple, tauRecTools::TauTrackRNNClassifier, InDet::InDetSecVtxTrackSelectionTool, JetForwardJvtTool, JetPileupTag::JetVertexNNTagger, CP::EgammaIsGoodOQSelectionTool, CP::IsolationCloseByCorrectionTool, CP::MuonCalibIntScaleSmearTool, DiTauRecTools::DiTauIDVarCalculator, JetFinder, AsgElectronIsEMSelector, CP::MuonCalibIntHighpTSmearTool, CP::MuonCalibIntSagittaTool, DiTauRecTools::DiTauDiscriminantTool, met::METBuilderTool, CP::AsgMaskSelectionTool, ElectronPhotonVariableCorrectionBase, ECUtils::EventCleaningTool, TauAnalysisTools::TauTruthTrackMatchingTool, met::METSoftTermsTool, LVL1::L1CaloLArTowerEnergy, HiggsTruthCategoryTool, IDTPM::TrackRoiSelectionTool, TauAnalysisTools::CommonDiTauEfficiencyTool, HIJetConstituentSubtractionTool, JetTrackSumMomentsTool, JetGrooming::SoftDrop, JetQGTaggerVariableTool, JetTrackMomentsTool, met::METTruthTool, CP::BaseLinearFakeBkgTool, PMGTools::PMGSherpaVjetsSysTool, ClusterMatching::CaloClusterMatchingTool, AsgPhotonEfficiencyCorrectionTool, InDet::JetTrackFilterTool, asg::DataHandleTestTool, xAODMaker::FileMetaDataTool, CP::BaseFakeBkgTool, InDet::InclusiveTrackFilterTool, InDet::InDetTrackTruthFilterTool, HIJetClusterSubtractorTool, CP::MVATrackVertexAssociationTool, IDTPM::RoiSelectionTool, ElectronPhotonVariableCorrectionTool, JetCalibrationTool, JetCaloQualityTool, JetOriginCorrectionTool, InDet::InDetTrackBiasingTool, HIJetClusterIndexAssociationTool, TauWPDecorator, TrigGlobalEfficiencyCorrectionTool, ZdcRecChannelToolV2, IDTPM::TrackObjectSelectionTool, CP::LhoodMM_tools, FlavorTagDiscriminants::GNNTool, FlavorTagDiscriminants::MultifoldGNNTool, CP::MuonSelectionTool, TauAnalysisTools::CommonDiTauSmearingTool, JSSTaggerBase, ZDC::ZdcAnalysisTool, IDTPM::TrackQualitySelectionTool, AsgElectronLikelihoodTool, CP::JetQGTagger, CP::JetJvtEfficiency, LVL1::L1CaloFcal23Cells2RxMappingTool, ORUtils::OverlapRemovalTool, Analysis::JetQuarkLabel, Ringer::AsgRingerSelectorTool, InDet::InDetTrackSmearingTool, JetCopier, JetGrooming::JetGroomer, met::METPhotonAssociator, JetECPSFractionTool, JetPtAssociationTool, met::METElectronAssociator, met::METTauAssociator, PMGTools::PMGDecayProductsSelectionTool, WeightToolBase, HIJetDRAssociationTool, JetClusterMomentsTool, met::METJetAssocTool, TauVertexFinder, IDTPM::JsonPlotsDefReadTool, TauAnalysisTools::DiTauSmearingTool, JetDRTrackAssocTool, JetReclusterer, TauDecayModeNNClassifier, BDTVertexWeightCalculator, asg::UnitTestTool1, IDTPM::DeltaRMatchingToolBase< T, R >, AsgElectronSelectorTool, JetReclusteringTool, met::METMuonAssociator, TauPi0CreateROI, TauShotFinder, IDTPM::DeltaRMatchingToolBase< xAOD::TrackParticle, xAOD::TruthParticle >, IDTPM::DeltaRMatchingToolBase< xAOD::TruthParticle, xAOD::TrackParticle >, IDTPM::DeltaRMatchingToolBase< xAOD::TrackParticle >, ZdcRecChannelToolLucrod, PMGTools::PMGTruthWeightTool, JetVoronoiMomentsTool, Trig::MatchFromCompositeTool, asg::UnitTestTool3, IDTPM::TruthTrackMatchingTool, CP::ApplyFakeFactor, AsgElectronChargeIDSelectorTool, HIJetMaxOverMeanTool, PanTau::Tool_FeatureExtractor, TauElectronVetoVariables, CP::IsolationSelectionTool, WeightsAgregator, EL::UnitTestTool, FlavorTagDiscriminants::TrackClassifier, JetLArHVTool, ZDC::ZdcTrigValidTool, IDTPM::TrackTruthMatchingTool, HI::HIPileupTool, InDet::InDetTrackTruthOriginTool, JetHelper::VarTool, FlavorTagDiscriminants::DL2Tool, BTaggingSelectionTool, EnergyCorrelatorGeneralizedRatiosTool, EnergyCorrelatorGeneralizedTool, EnergyCorrelatorRatiosTool, EnergyCorrelatorTool, TauEleOverlapChecker, TauJetRNNEvaluator, asg::UnitTestTool2, JetTruthLabelingTool, ZDC::ZdcRecTool, HIJetConstituentModifierTool, TauCalibrateLC, TauGNNEvaluator, TauPi0ScoreCalculator, TauRecToolBase, Trig::TrigEgammaEmulationPrecisionElectronHypoTool, asg::UnitTestTool1A, PDFWeight, HIEventShapeJetIteration, HIJetSignificanceTool, CP::JetQGTaggerBDT, JetWidthTool, TauVertexVariables, Trig::TrigEgammaEmulationPrecisionPhotonHypoTool, Trig::TrigEgammaMatchingTool, Trig::R3IParticleRetrievalTool, IDTPM::TruthTrackQualitySelectionTool, JetPileupLabelingTool, JetFromPseudojet, JetTruthParticleSelectorTool, Trig::TrigEgammaEmulationBaseHypoTool, CP::ApplyE2YFakeRate, ParticleScaleFactorTool, InDet::InDetTrackSystematicsTool, JetCaloQualityToolFE, Trig::MatchingTool, Trig::R3MatchingTool, IDTPM::OfflineTrackQualitySelectionTool, JetParticleAssociation, Trig::TrigEgammaEmulationChain, Trig::TrigEgammaEmulationFastCaloHypoTool, AthOnnx::OnnxRuntimeInferenceTool, xAODtoHepMCTool, HIEventShapeMapTool, HI::HIVertexSelectionTool, JetHelper::HistoInput2D, TauVertexedClusterDecorator, Trig::IParticleRetrievalTool, CP::AsymptMatrixTool, HI::HIEventSelectionTool, FlavorTagDiscriminants::HbbTagTool, JetConstituentFrac, JetGroomMRatio, JetHelper::HistoInput1D, JetHelper::TextInputMCJES, ExtendTrackToLayerTool, Trig::TypedScoringTool, TrackTruthSelectionTool, HIUEModulatorTool, JSSWTopTaggerANN, CP::JvtEfficiencyToolBase, JetEMScaleMomTool, MvaTESVariableDecorator, TauAODLeptonRemovalTool, TauCombinedTES, ParticleJetDeltaRLabelTool, HIEventShapeSummaryTool, FlavorTagDiscriminants::BTagAugmenterTool, FlavorTagDiscriminants::VRJetOverlapDecoratorTool, JetCaloEnergies, ParticleJetGhostLabelTool, FlavorTagDiscriminants::BTagMuonAugmenterTool, MBTSTimeFilterTool, JSSWTopTaggerDNN, SmoothedTopTagger, MvaTESEvaluator, CP::IsolationLowPtPLVTool, Trig::DRScoringTool, Trig::EgammaDRScoringTool, SmoothedWZTagger, CP::FJvtEfficiencyTool, CP::JvtSelectionToolBase, CP::NNJvtSelectionTool, AthAsgExUnittestTool, CP::JvtSelectionTool, BTaggingSelectionJsonTool, CP::FJvtSelectionTool, CP::JvtEfficiencyTool, CP::NNJvtEfficiencyTool, BookkeeperDumperTool, TrigFastCalibWithRings, top::ScaleFactorRetriever, BTaggingEfficiencyTool, BTaggingTruthTaggingTool, MissingCellListTool, JetVoronoiDiagramHelpers::Diagram, FastJetInterfaceTool, met::METSystematicsTool, Trig::TrigEgammaEmulationToolMT, JetAttributeRatioSelector, top::GhostTrackSystematicsMaker, top::TopObjectSelection, BTaggingEigenVectorRecompositionTool, LVL1::TrigT1CaloLWHistogramToolV1, LVL1::TrigT1CaloLWHistogramTool, Trig::TrigDecisionTool, CP::PhotonPointingTool, met::METRecoTool, CP::PhotonVertexSelectionTool, top::KLFitterTool, ZdcByteStreamReadV1V2Tool, CP::PileupReweightingTool, top::JetObjectCollectionMaker, LVL1::L1CaloxAODOfflineTriggerTowerTools, RCJet, LVL1::TrigT1CaloMonErrorToolV1, met::METTrackFilterTool, LVL1::TrigT1CaloMonErrorTool, SoftKillerWeightTool, EventDensityTool, met::METSignificance, ParticleLevelRCJetObjectLoader, JetUncertaintiesTool, top::TopToolStore, CP::JetTileCorrectionTool, xAODMaker::TriggerMenuMetaDataTool, D3PD::D3PDMCTruthClassifier, top::ElectronInJetSubtractionCollectionMaker, top::MuonObjectCollectionMaker, JetConstituentModSequence, top::EgammaObjectCollectionMaker, HistoGroupBase, AsgPhotonIsEMSelector, JetAttributeSelector, top::ObjectCollectionMaker, TrackVertexAssociationTool, met::METRefinerTool, TauAnalysisTools::CommonSmearingTool, top::GlobalLeptonTriggerCalculator, top::ScaleFactorCalculator, top::TrackSystematicsMaker, top::ElectronScaleFactorCalculator, top::JetScaleFactorCalculator, top::MuonScaleFactorCalculator, PanTau::Tool_DetailsArranger, LVL1::L1CaloMonitoringCaloTool, top::EventSaverxAOD, LVL1::L1CaloTTIdTools, top::SoftMuonObjectCollectionMaker, top::TauObjectCollectionMaker, JetInputElRemovalTool, TauAnalysisTools::CommonEfficiencyTool, top::BTagScaleFactorCalculator, top::MissingETObjectCollectionMaker, PanTau::PanTauProcessor, xAODMaker::TruthMetaDataTool, top::PDFScaleFactorCalculator, top::PhotonScaleFactorCalculator, top::PseudoTopReco, EventShapeCopier, met::METJetTool, GoodRunsListSelectionTool, top::EventSaverxAODNext, top::FwdElectronScaleFactorCalculator, FSR::FsrPhotonTool, Trig::StaticBunchCrossingTool, ZMassConstraint::ConstraintFit, TauAnalysisTools::TauEfficiencyCorrectionsTool, PanTau::Tool_DecayModeDeterminator, PanTau::Tool_ModeDiscriminator, CP::ElectronLRTOverlapRemovalTool, HIClusterSubtraction, JetAttributeHisto, JetPseudojetCopier, met::METEgammaAssociator, Trig::xAODBunchCrossingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, TauAnalysisTools::DiTauTruthMatchingTool, TauAnalysisTools::TauSmearingTool, top::JetMETCPTools, met::METTruthAssociator, PanTau::Tool_InformationStore, HistoDefinitionTool, PanTau::Tool_InputConverter, JetBottomUpSoftDrop, JetRecursiveSoftDrop, PMGTools::PMGCrossSectionTool, JetSoftDrop, TrigEgammaMatchingToolMT, DiTauMassTools::MissingMassToolV2, top::TauScaleFactorCalculator, top::TriggerCPTools, JetConstituentsRetriever, VoronoiWeightTool, top::GhostTrackCPTools, JetCaloCellQualityTool, JetContainerHistoFiller, ChargedHadronSubtractionTool, JetTrackSelectionTool, met::METRegionsTool, met::METSoftAssociator, PanTau::Tool_TauConstituentGetter, top::EventCleaningSelection, ConstituentSubtractorTool, top::EgammaCPTools, top::OtherCPTools, top::TopEventMaker, JetHistoBase, JetSelectorAttributeRunII, JetSplitter, CaloClusterConstituentsOrigin, JetTrackSelectionTool2, SimpleJetTrackSelectionTool, CP::MuonLRTOverlapRemovalTool, top::FlavorTaggingCPTools, top::TauCPTools, HistosForJetSelection, JetPruner, JetToolRunner, JetUsedInFitTrackDecoratorTool, top::TrackCPTools, JetTrimmer, NSubjettinessRatiosTool, CP::MuonEfficiencyScaleFactors, top::PileupScaleFactorCalculator, top::MuonCPTools, JetConstitFourMomTool, NSubjettinessTool, ZdcDataAccessV2, JetPseudojetRetriever, LVL1BS::TrigT1CaloDataAccessV2, PanTau::Tool_TauConstituentSelector, CopyTruthParticles, top::IsolationCPTools, top::OverlapRemovalCPTools, ClusterAtEMScaleTool, CP::IsolationHelper, top::BoostedTaggingCPTools, AsgDeadHVCellRemovalTool, ConstitTimeCutTool, Analysis::JetConeLabeling, JetSelectorAttribute, HIJetUEMonitoring, HIEfficiencyResponseHistos, JetSubStructureMomentToolsBase, AsgHelloTool, CopyTruthJetParticles, LeadingJetsRelations, EfficiencyResponseHistos, and JetEventSelector.

Definition at line 133 of file AsgTool.h.

{ return StatusCode::SUCCESS; }

inputHandles()

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

isDressingPhoton()

bool top::ParticleLevelLoader::isDressingPhoton ( const xAOD::TruthParticle &  photon, const xAOD::TruthParticleContainer &  dressedParticles, const float  dressingCone = 0.1  ) const

protected

Definition at line 826 of file ParticleLevelLoader.cxx.

                                                                               {
    // We do not check whether the original truth particle decoration exists
    // and / or is valid because at this point we assume that it was already
    // used by the lepton loading function.
    static const std::string decoName {
      "originalTruthParticle"
    };
 
    // Use rapidity instead of pseudo-rapidity in deltaR calculation for overlap removal
    bool useRapidityInDeltaRCalculation = m_config->useParticleLevelOverlapRemovalWithRapidity();
 
    for (const auto *particle : dressedParticles) {
      bool tp_isValid = false;
      ElementLink<xAOD::TruthParticleContainer> truthProxy;
      try {
        truthProxy = particle->auxdata<ElementLink<xAOD::TruthParticleContainer> >("originalTruthParticle");
        tp_isValid = truthProxy.isValid();
      } catch (const SG::ExcBadAuxVar&) {
        // ExcBadAuxVar can be thrown before checking if proxy is valid
        tp_isValid = false;
      }
 
      if (not tp_isValid) {
        if (xAOD::P4Helpers::deltaR(particle, &photon, useRapidityInDeltaRCalculation) <= dressingCone) {
          return true;
        }
      } else {
        if (xAOD::P4Helpers::deltaR((*truthProxy), &photon, useRapidityInDeltaRCalculation) <= dressingCone) {
          return true;
        }
      }
    }
 
    return false;
  }

load()

ParticleLevelEvent top::ParticleLevelLoader::load

(

)

Loading function.

Does the actual work. This function will load the truth information from the #xaodEvent and return this data transformed into a truth level event. The data stored in the ParticleLevel is owned by the truth event loader.

Parameters

xaodEvent

The input data event object.

Returns

ParticleLevelEvent object.

Definition at line 225 of file ParticleLevelLoader.cxx.

                                               {
    // If the ParticleLevelLoader is not active, return an empty object
    if (!m_active) {
      return {};
    }
 
    // Create the result object.
    ParticleLevelEvent plEvent;
 
    // Load event info object directly into the plEvent
    top::check(evtStore()->retrieve(plEvent.m_info, m_config->sgKeyEventInfo()),
               "xAOD::TEvent::retrieve failed for EventInfo");
 
    // Load the info for electrons, muons, jets, and MET into local objects:
    // They need to be selected / modified / etc
    const xAOD::TruthParticleContainer* electrons {
      nullptr
    };
    const xAOD::TruthParticleContainer* muons {
      nullptr
    };
    const xAOD::TruthParticleContainer* photons {
      nullptr
    };
    const xAOD::JetContainer* jets {
      nullptr
    };
    const xAOD::JetContainer* largeRJets {
      nullptr
    };
    const xAOD::TruthParticleContainer* taus {
      nullptr
    };
    const xAOD::MissingETContainer* mets {
      nullptr
    };
 
    if (m_config->useTruthElectrons()) {
      top::check(evtStore()->retrieve(electrons, m_config->sgKeyTruthElectrons()),
                 "xAOD::TEvent::retrieve failed for Truth Electrons");
    }
 
    if (m_config->useTruthMuons()) {
      top::check(evtStore()->retrieve(muons, m_config->sgKeyTruthMuons()),
                 "xAOD::TEvent::retrieve failed for Truth Muons");
    }
 
    if (m_config->useTruthPhotons()) {
      top::check(evtStore()->retrieve(photons, m_config->sgKeyTruthPhotons()),
                 "xAOD::TEvent::retrieve failed for Truth Photons");
    }
 
    if (m_config->useTruthJets()) {
      top::check(evtStore()->retrieve(jets, m_config->sgKeyTruthJets()),
                 "xAOD::TEvent::retrieve failed for Truth Jets");
    }
 
    if (m_config->useTruthLargeRJets()) {
      top::check(evtStore()->retrieve(largeRJets, m_config->sgKeyTruthLargeRJets()),
                 "xAOD::TEvent::retrieve failed for Truth Jets Large R");
    }
 
    if (m_config->useTruthTaus()) {
      top::check(evtStore()->retrieve(taus, m_config->sgKeyTruthTaus()),
                 "xAOD::TEvent::retrieve failed for Truth Taus");
    }
 
    if (m_config->useTruthMET()) {
      top::check(evtStore()->retrieve(mets, m_config->sgKeyTruthMET()),
                 "xAOD::TEvent::retrieve failed for Truth Missing ET");
    }
 
    // ======================================================================
    //                      DRESSING
    // We want to put the dressed leptons into the Event container, however,
    // after reading from the TOPQ file, their dressed kinematics are stored
    // as decorations. Lets (1) create a shallow copied container now, (2)
    // set the kinematics for the shallow copies to the dressed values, (3)
    // create decorations for the bare (non-dressed) kinematics, and (4)
    // deep-copy the selection electrons from that container later.
 
    // ELECTRONS
    if (m_config->useTruthElectrons()) {
      top::check(loadDressedLeptons(*electrons,
                                    m_electronsDressed,
                                    m_electronsDressedAux),
                 "Failure to load dressed electrons.");
    }
 
    // MUONS
    if (m_config->useTruthMuons()) {
      top::check(loadDressedLeptons(*muons,
                                    m_muonsDressed,
                                    m_muonsDressedAux),
                 "Failure to load dressed muons.");
    }
 
    // ======================================================================
    //                            OBJECT SELECTION
    // This yields index collections, one for each
    //    { electrons, muons, photons, jets, largeRJets }.
    std::list<std::size_t> idx_electrons;     // -> relative to `electrons`
    std::list<std::size_t> idx_muons;         // -> relative to `muons`
    std::list<std::size_t> idx_photons;       // -> relative to `photons`
    std::list<std::size_t> idx_jets;          // -> relative to `jets`
    std::list<std::size_t> idx_largeRJets;    // -> relative to `largeRJets`
    std::list<std::size_t> idx_taus;          // -> relative to `taus`
 
    // Electrons
    if (m_config->useTruthElectrons()) {
      for (std::size_t i = 0; i < electrons->size(); ++i) {
        const auto* electron = electrons->at(i);
 
        // Allow use of mixed-particle input container.
        if (electron->absPdgId() != 11) {
          continue;
        }
 
        // FIXME: Is this still needed?
        if (HepMC::is_simulation_particle(electron)) {
          continue;
        }
 
        if (m_objectSelector_Electron->apply(*electron)) {
          idx_electrons.push_back(i);
        }
      }
    }
 
    // Muons
    if (m_config->useTruthMuons()) {
      for (std::size_t i = 0; i < muons->size(); ++i) {
        const auto* muon = muons->at(i);
 
        // Allow use of mixed-particle input container.
        if (muon->absPdgId() != 13) {
          continue;
        }
 
        // FIXME: Is this still needed?
        if (HepMC::is_simulation_particle(muon)) {
          continue;
        }
 
        if (m_objectSelector_Muon->apply(*muon)) {
          idx_muons.push_back(i);
        }
      }
    }
 
    // Photons
    if (m_config->useTruthPhotons()) {
      for (std::size_t i = 0; i < photons->size(); ++i) {
        const auto* photon = photons->at(i);
 
        // Allow use of mixed-particle input container.
        if (photon->absPdgId() != 22) {
          continue;
        }
 
        // FIXME: Is this still needed?
        if (HepMC::is_simulation_particle(photon)) {
          continue;
        }
 
        if (not m_objectSelector_Photon->apply(*photon)) {
          continue;
        }
 
        // Reject photons used for electron dressing.
        if (m_config->useTruthElectrons()) {
          if (isDressingPhoton(*photon, *electrons)) {
            continue;
          }
        }
 
        // Reject photons used for muon dressing.
        if (m_config->useTruthMuons()) {
          if (isDressingPhoton(*photon, *muons)) {
            continue;
          }
        }
        idx_photons.push_back(i);
      }
    }
 
    // Jets
    if (m_config->useTruthJets()) {
      for (std::size_t i = 0; i < jets->size(); ++i) {
        if (m_objectSelector_Jet->apply(*jets->at(i))) {
          idx_jets.push_back(i);
        }
      }
    }
 
    // Large-R-Jets
    if (m_config->useTruthLargeRJets()) {
      for (std::size_t i = 0; i < largeRJets->size(); ++i) {
        if (m_objectSelector_LargeRJet->apply(*largeRJets->at(i))) {
          idx_largeRJets.push_back(i);
        }
      }
    }
 
    // Taus
    if (m_config->useTruthTaus()) {
      for (std::size_t i = 0; i < taus->size(); ++i) {
        if (m_objectSelector_Tau->apply(*taus->at(i))) {
          idx_taus.push_back(i);
        }
      }
    }
 
    // ======================================================================
    //                             OVERLAP REMOVAL
    // Removal Steps:
    //   1. Jets & Muons:
    //      Remove Muons with dR < 0.4
    //   2. Jets & Electrons:
    //      Remove Electrons with dR < 0.4
    //   3. Photons & Jets:
    //      Remove Jets with dR < 0.4
 
    // Use rapidity instead of pseudo-rapidity in deltaR calculation for overlap removal
    bool useRapidityInDeltaRCalculation = m_config->useParticleLevelOverlapRemovalWithRapidity();
 
    // Jets and Muons: Remove Muon with dR < 0.4
    if (m_config->useTruthMuons() && m_config->useTruthJets() && m_config->doParticleLevelOverlapRemovalMuJet()) {
#ifdef TOP_PARTICLE_LEVEL_DEBUG_OVERLAP_REMOVAL
      const std::size_t nMuonsPreOR {
        idx_muons.size()
      };
#endif
 
      idx_muons.remove_if([&idx_jets, &jets, &useRapidityInDeltaRCalculation, this](std::size_t m) {
        for (auto j : idx_jets) {
          if (xAOD::P4Helpers::deltaR(jets->at(j), m_muonsDressed->at(m), useRapidityInDeltaRCalculation) < 0.4) {
            return true;
          }
        }
        return false;
      });
 
#ifdef TOP_PARTICLE_LEVEL_DEBUG_OVERLAP_REMOVAL
      ATH_MSG_INFO("[top::ParticleLevelLoader] Muon-In-Jet OR: "
          << nMuonsPreOR << " -> " << idx_muons.size());
#endif
    }
 
    // Jets and Electrons: Remove Electron with dR < 0.4
    if (m_config->useTruthElectrons() && m_config->useTruthJets() && m_config->doParticleLevelOverlapRemovalElJet()) {
#ifdef TOP_PARTICLE_LEVEL_DEBUG_OVERLAP_REMOVAL
      const std::size_t nElectronsPreOR {
        idx_electrons.size()
      };
#endif
 
      idx_electrons.remove_if([&idx_jets, &jets, &useRapidityInDeltaRCalculation, this](std::size_t e) {
        for (auto j : idx_jets) {
          if (xAOD::P4Helpers::deltaR(jets->at(j),m_electronsDressed->at(e), useRapidityInDeltaRCalculation) < 0.4) {
            return true;
          }
        }
        return false;
      });
 
#ifdef TOP_PARTICLE_LEVEL_DEBUG_OVERLAP_REMOVAL
      ATH_MSG_INFO("[top::ParticleLevelLoader] Electron-In-Jet OR: "
          << nElectronsPreOR << " -> " << idx_electrons.size());
#endif
    }
 
    // Photons and Jets: Remove Jet with dR < 0.4
    if (m_config->useTruthPhotons() && m_config->useTruthJets() && m_config->doParticleLevelOverlapRemovalJetPhoton()) {
#ifdef TOP_PARTICLE_LEVEL_DEBUG_OVERLAP_REMOVAL
      const std::size_t nJetPreOR {
        idx_jets.size()
      };
#endif
 
      idx_jets.remove_if([&idx_photons, &photons, &useRapidityInDeltaRCalculation, &jets](std::size_t j) {
        for (auto ph : idx_photons) {
          if (xAOD::P4Helpers::deltaR(photons->at(ph), jets->at(j), useRapidityInDeltaRCalculation) < 0.4) {
            return true;
          }
        }
        return false;
      });
 
#ifdef TOP_PARTICLE_LEVEL_DEBUG_OVERLAP_REMOVAL
      ATH_MSG_INFO("[top::ParticleLevelLoader] Jet-In-Photon OR: "
          << nJetsPreOR << " -> " << idx_jets.size());
#endif
    }
 
 
    // ======================================================================
    //                             WRITE TO LOADER
    // 1. Loop index lists for electrons / muons / photons / jets
    // 2. Create a deep copy of the item and insert it into the
    //    appropriate container
    // 3. Create a shallow copy of the containers and apply corrections
    //    if needed (dressing, etc.)
 
    // Create New Containers holding the "Good" Electrons / Muons / Jets
    // and the MET
    if (m_config->useTruthElectrons()) {
      xAOD::TruthParticleContainer* goodElectrons = new xAOD::TruthParticleContainer();
      xAOD::TruthParticleAuxContainer* goodElectronsAux = new xAOD::TruthParticleAuxContainer();
      goodElectrons->setStore(goodElectronsAux); //< Connect the two
 
      m_goodElectrons.reset(goodElectrons);
      m_goodElectronsAux.reset(goodElectronsAux);
 
      for (auto e : idx_electrons) {
        const auto& elPtr = m_electronsDressed->at(e);
        xAOD::TruthParticle* electron = new xAOD::TruthParticle();
        electron->makePrivateStore(*elPtr);
        m_goodElectrons->push_back(electron);
      }
 
      // sort electrons based on dressed pT -- otherwise they remain sorted according to bare pT
      std::sort(m_goodElectrons->begin(), m_goodElectrons->end(), top::descendingPtSorter);
    }
 
    if (m_config->useTruthMuons()) {
      xAOD::TruthParticleContainer* goodMuons = new xAOD::TruthParticleContainer();
      xAOD::TruthParticleAuxContainer* goodMuonsAux = new xAOD::TruthParticleAuxContainer();
      goodMuons->setStore(goodMuonsAux); //< Connect the two
 
      m_goodMuons.reset(goodMuons);
      m_goodMuonsAux.reset(goodMuonsAux);
 
      for (auto m : idx_muons) {
        const auto& muPtr = m_muonsDressed->at(m);
        xAOD::TruthParticle* muon = new xAOD::TruthParticle();
        muon->makePrivateStore(*muPtr);
        m_goodMuons->push_back(muon);
      }
 
      // sort muons based on dressed pT -- otherwise they remain sorted according to bare pT
      std::sort(m_goodMuons->begin(), m_goodMuons->end(), top::descendingPtSorter);
    }
 
    if (m_config->useTruthPhotons()) {
      xAOD::TruthParticleContainer* goodPhotons = new xAOD::TruthParticleContainer();
      xAOD::TruthParticleAuxContainer* goodPhotonsAux = new xAOD::TruthParticleAuxContainer();
      goodPhotons->setStore(goodPhotonsAux); //< Connect the two
 
      m_goodPhotons.reset(goodPhotons);
      m_goodPhotonsAux.reset(goodPhotonsAux);
 
      for (auto ph : idx_photons) {
        const auto& phPtr = photons->at(ph);
        xAOD::TruthParticle* photon = new xAOD::TruthParticle();
        photon->makePrivateStore(*phPtr);
        m_goodPhotons->push_back(photon);
      }
    }
 
    if (m_config->useTruthJets()) {
      xAOD::JetContainer* goodJets = new xAOD::JetContainer();
      xAOD::JetAuxContainer* goodJetsAux = new xAOD::JetAuxContainer();
      goodJets->setStore(goodJetsAux); //< Connect the two
 
      m_goodJets.reset(goodJets);
      m_goodJetsAux.reset(goodJetsAux);
 
      for (auto j : idx_jets) {
        const auto& jetPtr = jets->at(j);
        xAOD::Jet* jet = new xAOD::Jet();
        jet->makePrivateStore(*jetPtr);
        m_goodJets->push_back(jet);
      }
    }
 
    if (m_config->useTruthLargeRJets()) {
      xAOD::JetContainer* goodLargeRJets = new xAOD::JetContainer();
      xAOD::JetAuxContainer* goodLargeRJetsAux = new xAOD::JetAuxContainer();
      goodLargeRJets->setStore(goodLargeRJetsAux); //< Connect the two
 
      m_goodLargeRJets.reset(goodLargeRJets);
      m_goodLargeRJetsAux.reset(goodLargeRJetsAux);
 
      for (auto j : idx_largeRJets) {
        const auto& jetPtr = largeRJets->at(j);
        xAOD::Jet* jet = new xAOD::Jet();
        jet->makePrivateStore(*jetPtr);
        m_goodLargeRJets->push_back(jet);
      }
    }
 
    if (m_config->useTruthTaus()) {
      xAOD::TruthParticleContainer* goodTaus = new xAOD::TruthParticleContainer();
      xAOD::TruthParticleAuxContainer* goodTausAux = new xAOD::TruthParticleAuxContainer();
      goodTaus->setStore(goodTausAux); //< Connect the two
 
      m_goodTaus.reset(goodTaus);
      m_goodTausAux.reset(goodTausAux);
 
      for (auto t : idx_taus) {
        const auto& tauPtr = taus->at(t);
        xAOD::TruthParticle* tau = new xAOD::TruthParticle();
        tau->makePrivateStore(*tauPtr);
        m_goodTaus->push_back(tau);
      }
    }
    
    if (m_config->useTruthMuons() && m_config->useSoftMuons() ) {
      xAOD::TruthParticleContainer* goodSoftMuons = new xAOD::TruthParticleContainer();
      xAOD::TruthParticleAuxContainer* goodSoftMuonsAux = new xAOD::TruthParticleAuxContainer();
      goodSoftMuons->setStore(goodSoftMuonsAux); //< Connect the two
 
      m_goodSoftMuons.reset(goodSoftMuons);
      m_goodSoftMuonsAux.reset(goodSoftMuonsAux);
      
      //if we want the soft muon truth history, the parent navigation for the TruthMuons collection is unfortunately working only in DAOD_PHYS, in other derivations 
      //we need a workaround, i.e. we need to use the muon from the TruthParticles container instead of the one from the TruthMuon container
      std::vector<const xAOD::TruthParticle*> truth_particles_vec; //this is an helper vector to speed up looking for the right muon...
      const xAOD::TruthParticleContainer* truth_particles = nullptr;
      if (m_config->useTruthParticles() && m_config->softmuonAdditionalTruthInfo()) {
        top::check(evtStore()->retrieve(truth_particles, m_config->sgKeyMCParticle()),
                   "xAOD::TEvent::retrieve failed for Truth Particles");
        if(truth_particles)
        {
          for(const xAOD::TruthParticle* p : *truth_particles)
          {
            if(p->isMuon() && MC::isStable(p)) truth_particles_vec.push_back(p);
          }
        }
      }
      
      for (std::size_t i = 0; i < muons->size(); ++i) { //note we don't use dressed muons in this case
        if(std::find(idx_muons.begin(), idx_muons.end(), i)!=idx_muons.end()) continue; //we don't want to store muons both as standard muons and as soft muons
        const auto& muPtr = muons->at(i);
        
        //here we apply the selection for soft muons
        if(muPtr->absPdgId()!=13) continue;
        if(muPtr->pt()<m_config->truth_softmuon_PtCut()) continue;
        if(fabs(muPtr->eta())>m_config->truth_softmuon_EtaCut()) continue;
        //now the association with the jets
        
        if(m_config->useTruthJets())
        {
          bool isInJet=false;
          for(xAOD::Jet* jetPtr : *m_goodJets)
          {
            float dR = xAOD::P4Helpers::deltaR(*muPtr,*jetPtr,m_config->softmuonDRJetcutUseRapidity());
            if(dR<m_config->softmuonDRJetcut())
            {
              isInJet=true;
              break;
            }
          }
          if(!isInJet) continue;
        }
        //end of selection
        
        if(m_config->softmuonAdditionalTruthInfo() && (!muPtr->isAvailable<bool>("hasTruthMuonHistoryInfo") || !muPtr->auxdecor<bool>("hasTruthMuonHistoryInfo"))) //if "hasTruthMuonPartonHistoryInfo" exists and is true, we already filled these info for this muon (since muon history filling can be done in several parts of the code for good reasons)
        {
          bool doPartonHistory=m_config->softmuonAdditionalTruthInfoCheckPartonOrigin();
          top::truth::initTruthMuonHistoryInfo(muPtr,doPartonHistory);
          
          //in DAOD_PHYS we can just navigate directly from the muon from TruthMuons
          if (m_config->getDerivationStream() == "PHYS")
          {
            top::truth::getTruthMuonHistory(muPtr,doPartonHistory,m_config->getShoweringAlgorithm(),m_config->softmuonAdditionalTruthInfoDoVerbose());
          }
          else //apparently in older derivation formats we have to navigate using the muon from the TruthParticles container, this is annoying
          {
            //first we find the associated truth muon from truth_particles
            const xAOD::TruthParticle* assMuon = 0;
            for(const xAOD::TruthParticle* p : truth_particles_vec)
            {
              if(!p) continue;
              if(HepMC::uniqueID(p) == HepMC::uniqueID(muPtr))
              {
                assMuon = p;
                break;
              }
            }
            if(assMuon) //then we use it
            {
              //if we don't have the info correctly filled already, let's initialize it to default values
              if(!assMuon->isAvailable<bool>("hasTruthMuonHistoryInfo") || ! assMuon->auxdecor<bool>("hasTruthMuonHistoryInfo")) top::truth::initTruthMuonHistoryInfo(assMuon,doPartonHistory);
              //we have to use the associated muon from the TruthParticles container in this case
              top::truth::getTruthMuonHistory(assMuon,doPartonHistory,m_config->getShoweringAlgorithm(),m_config->softmuonAdditionalTruthInfoDoVerbose());
              //then we copy the info to our muon
              top::truth::copyTruthMuonHistoryInfo(assMuon,muPtr);
              
             }
          }
        }//end of additional soft muon filling
        
        xAOD::TruthParticle* muon = new xAOD::TruthParticle();
        muon->makePrivateStore(*muPtr);
 
        m_goodSoftMuons->push_back(muon);
        
      }
      
      // sort muons based on dressed pT -- otherwise they remain sorted according to bare pT
      std::sort(m_goodSoftMuons->begin(), m_goodSoftMuons->end(), top::descendingPtSorter);
    }
 
 
    // ======================================================================
    //                         INSERTION INTO STORAGE
    // Put everything into storage, i.e. into the ParticleLevel.event object
    plEvent.m_electrons = m_config->useTruthElectrons() ? m_goodElectrons.get() : nullptr;
    plEvent.m_muons = m_config->useTruthMuons() ? m_goodMuons.get() : nullptr;
    plEvent.m_softmuons = (m_config->useTruthMuons() && m_config->useSoftMuons()) ? m_goodSoftMuons.get() : nullptr;
    plEvent.m_photons = m_config->useTruthPhotons() ? m_goodPhotons.get() : nullptr;
    plEvent.m_jets = m_config->useTruthJets() ? m_goodJets.get() : nullptr;
    plEvent.m_largeRJets = m_config->useTruthLargeRJets() ? m_goodLargeRJets.get() : nullptr;
    plEvent.m_taus = m_config->useTruthTaus() ? m_goodTaus.get() : nullptr;
    plEvent.m_met = m_config->useTruthMET() ? (*mets)[ "NonInt" ] : nullptr;
    
    // Reclustered jets
    if (m_config->useRCJets()) {
      top::check(m_particleLevelRCJetObjectLoader->execute(
                   plEvent), "Failed to execute ParticleLevelRCJetObjectLoader container");
      // Get the name of the container of re-clustered jets
      std::string RCJetContainerNane = m_particleLevelRCJetObjectLoader->rcjetContainerName();
 
      // -- Retrieve the re-clustered jets from TStore & save good re-clustered jets -- //
      const xAOD::JetContainer* rc_jets(nullptr);
      top::check(evtStore()->retrieve(rc_jets, RCJetContainerNane), "Failed to retrieve particle RC JetContainer");
 
      for (auto rcjet : *rc_jets) {
        top::check(rcjet->isAvailable<bool>(
                     "PassedSelection"),
                   " Can't find reclustered jet decoration \"PassedSelection\" - we need it to decide if we should keep the reclustered jet in the top::Event instance or not!");
        if (rcjet->auxdataConst<bool>("PassedSelection")) plEvent.m_RCJets.push_back((xAOD::Jet*) rcjet);
      }
    }
    // Variable-R reclustered jets
    if (m_config->useVarRCJets()) {
      for (auto& rho : m_VarRCJetRho) {
        for (auto& mass_scale : m_VarRCJetMassScale) {
          std::replace(rho.begin(), rho.end(), '.', '_');
          std::string name = rho + mass_scale;
          top::check(m_particleLevelVarRCJetObjectLoader[name]->execute(
                       plEvent), "Failed to execute RCJet container");
 
          // Get the name of the container of re-clustered jets in TStore
          std::string varRCJetContainerName = m_particleLevelVarRCJetObjectLoader[name]->rcjetContainerName();
 
          // -- Retrieve the re-clustered jets from TStore & save good re-clustered jets -- //
          const xAOD::JetContainer* vrc_jets(nullptr);
          top::check(evtStore()->retrieve(vrc_jets, varRCJetContainerName), "Failed to retrieve RC JetContainer");
 
          plEvent.m_VarRCJets[name] = std::make_shared<xAOD::JetContainer>(SG::VIEW_ELEMENTS);
          for (auto vrcjet : *vrc_jets) {
            top::check(vrcjet->isAvailable<bool>(
                         "PassedSelection"),
                       " Can't find jet decoration \"PassedSelection\" - we need it to decide if we should keep the variable-R reclustered jet in the top::Event instance or not!");
            if (vrcjet->auxdataConst<bool>("PassedSelection")) plEvent.m_VarRCJets[name]->push_back((xAOD::Jet*) vrcjet);
 
          }
        }
      }
    }
 
 
 
    return plEvent;
  }

loadDressedLeptons()

bool top::ParticleLevelLoader::loadDressedLeptons ( const xAOD::TruthParticleContainer &  input, std::unique_ptr< xAOD::TruthParticleContainer > &  store, std::unique_ptr< xAOD::ShallowAuxContainer > &  storeAux  ) const

protected

Definition at line 794 of file ParticleLevelLoader.cxx.

                                                                                                       {
    auto dressed = xAOD::shallowCopyContainer(input);
 
    store.reset(dressed.first);
    storeAux.reset(dressed.second);
 
    for (auto pl : *store.get()) {
      TLorentzVector fvDressed;
      fvDressed.SetPtEtaPhiE(pl->auxdata<float>("pt_dressed"),
                             pl->auxdata<float>("eta_dressed"),
                             pl->auxdata<float>("phi_dressed"),
                             pl->auxdata<float>("e_dressed"));
 
      // Store original kinematics as decoration
      // m->auxdata<int>( "nPhotons_dressed" ) = m->auxdata<int>( "nPhotons_dressed" );
 
      pl->auxdata<float>("pt_bare") = pl->pt();
      pl->auxdata<float>("eta_bare") = pl->eta();
      pl->auxdata<float>("phi_bare") = pl->phi();
      pl->auxdata<float>("e_bare") = pl->e();
 
      pl->setPx(fvDressed.Px());
      pl->setPy(fvDressed.Py());
      pl->setPz(fvDressed.Pz());
      pl->setE(fvDressed.E());
    }
 
    return true;
  }

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, top::TopObjectSelection, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

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< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_active

const bool top::ParticleLevelLoader::m_active

private

Definition at line 137 of file ParticleLevelLoader.h.

m_config

const std::shared_ptr<top::TopConfig>& top::ParticleLevelLoader::m_config

private

Definition at line 91 of file ParticleLevelLoader.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_electronsDressed

std::unique_ptr<xAOD::TruthParticleContainer> top::ParticleLevelLoader::m_electronsDressed

private

Definition at line 108 of file ParticleLevelLoader.h.

m_electronsDressedAux

std::unique_ptr<xAOD::ShallowAuxContainer> top::ParticleLevelLoader::m_electronsDressedAux

private

Definition at line 109 of file ParticleLevelLoader.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_goodElectrons

std::unique_ptr<xAOD::TruthParticleContainer> top::ParticleLevelLoader::m_goodElectrons

private

Definition at line 114 of file ParticleLevelLoader.h.

m_goodElectronsAux

std::unique_ptr<xAOD::TruthParticleAuxContainer> top::ParticleLevelLoader::m_goodElectronsAux

private

Definition at line 115 of file ParticleLevelLoader.h.

m_goodJets

std::unique_ptr<xAOD::JetContainer> top::ParticleLevelLoader::m_goodJets

private

Definition at line 126 of file ParticleLevelLoader.h.

m_goodJetsAux

std::unique_ptr<xAOD::JetAuxContainer> top::ParticleLevelLoader::m_goodJetsAux

private

Definition at line 127 of file ParticleLevelLoader.h.

m_goodLargeRJets

std::unique_ptr<xAOD::JetContainer> top::ParticleLevelLoader::m_goodLargeRJets

private

Definition at line 129 of file ParticleLevelLoader.h.

m_goodLargeRJetsAux

std::unique_ptr<xAOD::JetAuxContainer> top::ParticleLevelLoader::m_goodLargeRJetsAux

private

Definition at line 130 of file ParticleLevelLoader.h.

m_goodMuons

std::unique_ptr<xAOD::TruthParticleContainer> top::ParticleLevelLoader::m_goodMuons

private

Definition at line 117 of file ParticleLevelLoader.h.

m_goodMuonsAux

std::unique_ptr<xAOD::TruthParticleAuxContainer> top::ParticleLevelLoader::m_goodMuonsAux

private

Definition at line 118 of file ParticleLevelLoader.h.

m_goodPhotons

std::unique_ptr<xAOD::TruthParticleContainer> top::ParticleLevelLoader::m_goodPhotons

private

Definition at line 123 of file ParticleLevelLoader.h.

m_goodPhotonsAux

std::unique_ptr<xAOD::TruthParticleAuxContainer> top::ParticleLevelLoader::m_goodPhotonsAux

private

Definition at line 124 of file ParticleLevelLoader.h.

m_goodSoftMuons

std::unique_ptr<xAOD::TruthParticleContainer> top::ParticleLevelLoader::m_goodSoftMuons

private

Definition at line 120 of file ParticleLevelLoader.h.

m_goodSoftMuonsAux

std::unique_ptr<xAOD::TruthParticleAuxContainer> top::ParticleLevelLoader::m_goodSoftMuonsAux

private

Definition at line 121 of file ParticleLevelLoader.h.

m_goodTaus

std::unique_ptr<xAOD::TruthParticleContainer> top::ParticleLevelLoader::m_goodTaus

private

Definition at line 132 of file ParticleLevelLoader.h.

m_goodTausAux

std::unique_ptr<xAOD::TruthParticleAuxContainer> top::ParticleLevelLoader::m_goodTausAux

private

Definition at line 133 of file ParticleLevelLoader.h.

m_muonsDressed

std::unique_ptr<xAOD::TruthParticleContainer> top::ParticleLevelLoader::m_muonsDressed

private

Definition at line 111 of file ParticleLevelLoader.h.

m_muonsDressedAux

std::unique_ptr<xAOD::ShallowAuxContainer> top::ParticleLevelLoader::m_muonsDressedAux

private

Definition at line 112 of file ParticleLevelLoader.h.

m_objectSelector_Electron

std::unique_ptr<ObjectSelectorBase<xAOD::TruthParticle> > top::ParticleLevelLoader::m_objectSelector_Electron

private

Definition at line 96 of file ParticleLevelLoader.h.

m_objectSelector_Jet

std::unique_ptr<ObjectSelectorBase<xAOD::Jet> > top::ParticleLevelLoader::m_objectSelector_Jet

private

Definition at line 99 of file ParticleLevelLoader.h.

m_objectSelector_LargeRJet

std::unique_ptr<ObjectSelectorBase<xAOD::Jet> > top::ParticleLevelLoader::m_objectSelector_LargeRJet

private

Definition at line 100 of file ParticleLevelLoader.h.

m_objectSelector_Muon

std::unique_ptr<ObjectSelectorBase<xAOD::TruthParticle> > top::ParticleLevelLoader::m_objectSelector_Muon

private

Definition at line 97 of file ParticleLevelLoader.h.

m_objectSelector_Photon

std::unique_ptr<ObjectSelectorBase<xAOD::TruthParticle> > top::ParticleLevelLoader::m_objectSelector_Photon

private

Definition at line 98 of file ParticleLevelLoader.h.

m_objectSelector_Tau

std::unique_ptr<ObjectSelectorBase<xAOD::TruthParticle> > top::ParticleLevelLoader::m_objectSelector_Tau

private

Definition at line 101 of file ParticleLevelLoader.h.

m_particleLevelRCJetObjectLoader

std::unique_ptr<ParticleLevelRCJetObjectLoader> top::ParticleLevelLoader::m_particleLevelRCJetObjectLoader

private

Definition at line 102 of file ParticleLevelLoader.h.

m_particleLevelVarRCJetObjectLoader

std::map<std::string, std::unique_ptr<ParticleLevelRCJetObjectLoader> > top::ParticleLevelLoader::m_particleLevelVarRCJetObjectLoader

private

Definition at line 103 of file ParticleLevelLoader.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_VarRCJetMassScale

std::vector<std::string> top::ParticleLevelLoader::m_VarRCJetMassScale

private

Definition at line 105 of file ParticleLevelLoader.h.

m_VarRCJetRho

std::vector<std::string> top::ParticleLevelLoader::m_VarRCJetRho

private

Definition at line 104 of file ParticleLevelLoader.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• ParticleLevelLoader.h
• ParticleLevelLoader.cxx