CP::CalcPartonHistory Class Reference

#include <CalcPartonHistory.h>

Inheritance diagram for CP::CalcPartonHistory:

Collaboration diagram for CP::CalcPartonHistory:

Public Member Functions
	CalcPartonHistory (const std::string &name, const std::vector< std::string > &truthCollections={"TruthTop"})
virtual	~CalcPartonHistory ()
	CalcPartonHistory (const CalcPartonHistory &rhs)=delete
	CalcPartonHistory (CalcPartonHistory &&rhs)=delete
CalcPartonHistory &	operator= (const CalcPartonHistory &rhs)=delete
void	AddToParticleMap (const xAOD::TruthParticle *particle, const std::string &key)
bool	ExistsInMap (const std::string &key) const
bool	ExistsInKey (const std::string &key, const xAOD::TruthParticle *particle) const
bool	Retrievep4 (const std::string &key, PtEtaPhiMVector &p4)
bool	Retrievep4 (const std::string &key, PtEtaPhiMVector &p4, const int &idx)
bool	Retrievep4Gamma (PtEtaPhiMVector &p4, int &parentpdgId)
bool	RetrievepdgId (const std::string &key, std::vector< int > &pdgIds)
bool	RetrievepdgId (const std::string &key, int &pdgId)
bool	RetrievepdgId (const std::string &key, int &pdgId, const int &idx)
bool	RetrieveParticleInfo (const std::string &prefix, std::vector< const xAOD::TruthParticle * > &particles)
bool	RetrieveParticleInfo (const std::string &prefix, PtEtaPhiMVector &particle, int &pdgId)
bool	RetrieveParticleInfo (const std::string &prefix, PtEtaPhiMVector &particle, int &pdgId, const int &idx)
bool	RetrieveParticleInfo (const std::string &prefix, const std::string &alt_prefix, PtEtaPhiMVector &particle, int &pdgId)
bool	RetrieveParticleInfo (const std::string &prefix, std::vector< PtEtaPhiMVector > &particles, std::vector< int > &pdgIds)
void	Initialize4TopDecorators ()
void	InitializeTopDecorators ()
void	InitializeAntiTopDecorators ()
void	InitializeBottomDecorators ()
void	InitializeVectorBottomDecorators ()
void	InitializeAntiBottomDecorators ()
void	InitializeVectorAntiBottomDecorators ()
void	InitializeCharmDecorators ()
void	InitializeVectorCharmDecorators ()
void	InitializeAntiCharmDecorators ()
void	InitializeVectorAntiCharmDecorators ()
void	InitializeTtbarDecorators ()
void	InitializeHiggsDecorators ()
void	InitializePhotonDecorators ()
void	InitializeZDecorators (int nZs=1, bool extend=false)
void	InitializeWDecorators (int nWs=1)
std::string	GetParticleType (const xAOD::TruthParticle *particle)
void	TraceParticle (const xAOD::TruthParticle *particle, std::vector< const xAOD::TruthParticle * > &currentPath, std::vector< std::vector< const xAOD::TruthParticle * > > &allPaths)
void	TraceParticles (const xAOD::TruthParticleContainer *truthParticles)
bool	handleFSR (const xAOD::TruthParticle *particle, const std::string &newKey, std::string &key)
bool	handleDecay (const xAOD::TruthParticle *particle, std::string &key, int decayID)
void	handleSameAsParent (const xAOD::TruthParticle *particle, std::string &key)
void	handleDefault (const xAOD::TruthParticle *particle, const std::string &newKey, std::string &key)
void	FillParticleMap (std::vector< std::vector< const xAOD::TruthParticle * > > &allPaths)
void	FillGenericPartonHistory (const std::string &retrievalstring, const std::string &decorationstring, const int idx)
void	FillGenericPartonHistory (const std::vector< std::string > &retrievalStrings, const std::string &decorationstring, const int idx)
void	FillGenericPartonHistory (const std::vector< std::string > &retrievalStrings, const std::string &decorationstring)
void	FillGenericVectorPartonHistory (const std::string &retrievalstring, const std::string &decorationstring)
void	FillGammaPartonHistory (const std::string &parent)
void	FillZPartonHistory (const std::string &parent, int nZs=1, const std::string &mode="resonant")
void	FillZtautauPartonHistory (const std::string &parent, int nZs=1, const std::string &mode="resonant")
void	FillWPartonHistory (const std::string &parent, int nWs=1, const std::string &mode="resonant")
void	FillTopPartonHistory ()
void	FillAntiTopPartonHistory ()
void	FillHiggsPartonHistory (const std::string &mode)
void	FillTtbarPartonHistory ()
void	setHiggs (const std::string &fsr)
void	setW (const std::string &fsr, int nWs)
bool	getW (const std::string &str_lep, const std::string &str_nu, PtEtaPhiMVector &p1, int &pdgId1, PtEtaPhiMVector &p2, int &pdgId2)
void	setZ (const std::string &fsr, int nZs)
void	setZtautau (const std::string &fsr, int nZs)
bool	getZ (const std::string &str_lep1, const std::string &str_lep2, PtEtaPhiMVector &p1, int &pdgId1, PtEtaPhiMVector &p2, int &pdgId2)
bool	getZFromTaus (const std::string &fsr, PtEtaPhiMVector &Zdecay1, int &Zdecay1_pdgId, PtEtaPhiMVector &Zdecay2, int &Zdecay2_pdgId, PtEtaPhiMVector &Zdecay1_decay1, int &Zdecay1_decay1_pdgId, PtEtaPhiMVector &Zdecay1_decay2, int &Zdecay1_decay2_pdgId, PtEtaPhiMVector &Zdecay1_decay3, int &Zdecay1_decay3_pdgId, PtEtaPhiMVector &Zdecay2_decay1, int &Zdecay2_decay1_pdgId, PtEtaPhiMVector &Zdecay2_decay2, int &Zdecay2_decay2_pdgId, PtEtaPhiMVector &Zdecay2_decay3, int &Zdecay2_decay3_pdgId)
void	configure (const PartonSchemeConfig &config)
virtual StatusCode	initialize () override
	Dummy implementation of the initialisation function.
virtual StatusCode	execute ()
virtual void	print () const
	Print the state of the tool.
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	sysInitialize () override
	Perform system initialization for an algorithm.
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
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
virtual StatusCode	linkTruthContainers (const xAOD::TruthParticleContainer *&tp)
virtual StatusCode	runHistorySaver (const xAOD::TruthParticleContainer *truthParticles, const xAOD::EventInfo *ttbarPartonHistory)
virtual void	initializeDecorators ()
StatusCode	buildContainerFromMultipleCollections (const std::vector< std::string > &collections, const std::string &out_contName)
	used to build container from multiple collections in DAOD_PHYS we don't have the TruthParticles collection, so we have to build a TruthParticleContainer (named out_contName) by merging several collections; this is stored in the evtStore this method has to use some tricks, like the helper m_tempParticles ConstDataVector, due to the desing of DataVector, see https://twiki.cern.ch/twiki/bin/view/AtlasComputing/DataVector
StatusCode	linkBosonCollections ()
	currently in DAOD_PHYS TruthTop have links to Ws from the TruthBoson collection, which have no link to their decay products; we have therefore to associate the W from the TruthBoson collections to those in the TruthBosonsWithDecayParticles collection.
const xAOD::TruthParticle *	getTruthParticleLinkedFromDecoration (const xAOD::TruthParticle *part, const std::string &decorationName)
	helper method to handle retriveing the truth particle linked in the decoration of another particle
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.

Protected Attributes
std::map< std::string, std::vector< const xAOD::TruthParticle * > >	m_particleMap
PartonDecorator	m_dec
const std::vector< std::string >	m_truthCollections
std::string	m_prefix
	prefix applied to all decorator and m_particleMap names
PartonSchemeConfig	m_config
	scheme configuration set via configure()
bool	m_configured = false
	true after configure() has been called

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	decorateCollectionWithLinksToAnotherCollection (const std::string &collectionToDecorate, const std::string &collectionToLink, const std::string &nameOfDecoration)
	helper method currently used in DAOD_PHYS to link particles from a given collection to the same particles included in another collection; needed because particles may be duplicated in different collections, but their navigation links may only be there in some of them...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 26 of file CalcPartonHistory.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

CalcPartonHistory() [1/3]

CP::CalcPartonHistory::CalcPartonHistory ( const std::string & name, const std::vector< std::string > & truthCollections = {"TruthTop"} )

explicit

Definition at line 36 of file CalcPartonHistory.cxx.

    : asg::AsgTool(name), m_truthCollections(truthCollection) {
  declareProperty("prefix", m_prefix = "",
                  "Prefix to apply to all names to avoid overwriting");
}

~CalcPartonHistory()

virtual CP::CalcPartonHistory::~CalcPartonHistory ( )

inlinevirtual

Definition at line 32 of file CalcPartonHistory.h.

{};

CalcPartonHistory() [2/3]

CP::CalcPartonHistory::CalcPartonHistory ( const CalcPartonHistory & rhs )

delete

CalcPartonHistory() [3/3]

CP::CalcPartonHistory::CalcPartonHistory ( CalcPartonHistory && rhs )

delete

Member Function Documentation

AddToParticleMap()

void CP::CalcPartonHistory::AddToParticleMap	(	const xAOD::TruthParticle *	particle,
		const std::string &	key )

Definition at line 248 of file CalcPartonHistory.cxx.

                                                               {
  if (!ExistsInKey(key, p))
    m_particleMap[key].push_back(p);
}

buildContainerFromMultipleCollections()

StatusCode CP::CalcPartonHistory::buildContainerFromMultipleCollections ( const std::vector< std::string > & collections, const std::string & out_contName )

protected

used to build container from multiple collections in DAOD_PHYS we don't have the TruthParticles collection, so we have to build a TruthParticleContainer (named out_contName) by merging several collections; this is stored in the evtStore this method has to use some tricks, like the helper m_tempParticles ConstDataVector, due to the desing of DataVector, see https://twiki.cern.ch/twiki/bin/view/AtlasComputing/DataVector

Definition at line 409 of file CalcPartonHistory.cxx.

                                   {
  // In DAOD_PHYS there is no single TruthParticles collection, so we merge
  // several dedicated collections (e.g. TruthTop,
  // TruthBosonsWithDecayParticles) into one working container stored in the
  // event store.
  //
  // The merge must avoid double-counting: the same particle can appear in
  // multiple collections (e.g. the b from a top appears in both TruthTop and
  // TruthBottom). We therefore keep only "root" particles — those that are not
  // a descendant of any other candidate in the merged pool. TraceParticles then
  // walks down from these roots, naturally visiting all descendants regardless
  // of which original collection they came from.
  ConstDataVector<DataVector<xAOD::TruthParticle_v1>>* out_cont =
      new ConstDataVector<DataVector<xAOD::TruthParticle_v1>>(
          SG::VIEW_ELEMENTS);
  std::vector<const xAOD::TruthParticle*> p_candidates;
  std::vector<const xAOD::TruthParticle*> p_parents;
 
  for (const std::string& collection : collections) {
    const xAOD::TruthParticleContainer* cont = nullptr;
    ANA_CHECK(evtStore()->retrieve(cont, collection));
    p_candidates.insert(p_candidates.end(), cont->begin(), cont->end());
  }
  // Retain only particles that have no ancestor among the other candidates.
  for (const xAOD::TruthParticle* potential_parent : p_candidates) {
    if (PartonHistoryUtils::isQuarkFromPDF(potential_parent)) {
      continue;
    }
 
    if (std::none_of(p_candidates.begin(), p_candidates.end(),
                     [&](const xAOD::TruthParticle* other_candidate) {
                       return other_candidate != potential_parent &&
                              !PartonHistoryUtils::isQuarkFromPDF(
                                  other_candidate) &&
                              PartonHistoryUtils::isChildOf(other_candidate,
 
                                                            potential_parent);
                     }))
      p_parents.push_back(potential_parent);
  }
  out_cont->insert(out_cont->end(), p_parents.begin(), p_parents.end());
  StatusCode save = TDS()->record(out_cont, out_contName);
  if (!save)
    return StatusCode::FAILURE;
  return StatusCode::SUCCESS;
}

configure()

void CP::CalcPartonHistory::configure

(

const PartonSchemeConfig &

config

)

Definition at line 510 of file CalcPartonHistory.cxx.

                                                                  {
  m_config = config;
  m_configured = true;
}

declareGaudiProperty()

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

decorateCollectionWithLinksToAnotherCollection()

StatusCode CP::CalcPartonHistory::decorateCollectionWithLinksToAnotherCollection ( const std::string & collectionToDecorate, const std::string & collectionToLink, const std::string & nameOfDecoration )

private

helper method currently used in DAOD_PHYS to link particles from a given collection to the same particles included in another collection; needed because particles may be duplicated in different collections, but their navigation links may only be there in some of them...

Definition at line 464 of file CalcPartonHistory.cxx.

                                                                          {
  const SG::Decorator<const xAOD::TruthParticle*> dec(nameOfDecoration);
  const xAOD::TruthParticleContainer* cont1 = nullptr;
  const xAOD::TruthParticleContainer* cont2 = nullptr;
  ANA_CHECK(evtStore()->retrieve(cont1, collectionToDecorate));
  ANA_CHECK(evtStore()->retrieve(cont2, collectionToLink));
  for (const auto* p : *cont1) {
    const xAOD::TruthParticle* link = nullptr;
    for (const auto* q : *cont2) {
      if (p->pdgId() == q->pdgId() && p->uid() == q->uid()) {
        link = q;
        break;
      }
    }
    dec(*p) = link;
  }
  return StatusCode::SUCCESS;
}

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

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

execute()

StatusCode CP::CalcPartonHistory::execute ( )

virtual

Definition at line 398 of file CalcPartonHistory.cxx.

                                      {
  const xAOD::TruthParticleContainer* truthParticles{nullptr};
  ANA_CHECK(linkTruthContainers(truthParticles));
 
  const xAOD::EventInfo* partonHistory = nullptr;
  ANA_CHECK(evtStore()->retrieve(partonHistory, "EventInfo"));
 
  ANA_CHECK(runHistorySaver(truthParticles, partonHistory));
  return StatusCode::SUCCESS;
}

ExistsInKey()

bool CP::CalcPartonHistory::ExistsInKey	(	const std::string &	key,
		const xAOD::TruthParticle *	particle ) const

Definition at line 48 of file CalcPartonHistory.cxx.

                                                                      {
  // Checks whether a given particle exists in the vector for the given key.
  if (const auto* v = findVector(m_particleMap, key)) {
    return std::find(v->begin(), v->end(), p) != v->end();
  }
  return false;
}

ExistsInMap()

bool CP::CalcPartonHistory::ExistsInMap

(

const std::string &

key

)

const

Definition at line 43 of file CalcPartonHistory.cxx.

                                                              {
  // Checks whether a given key exists in the particle map.
  return m_particleMap.find(key) != m_particleMap.end();
}

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

FillAntiTopPartonHistory()

void CP::CalcPartonHistory::FillAntiTopPartonHistory

(

)

Definition at line 22 of file CalcTopPartonHistory.cxx.

                                                 {
  FillGenericPartonHistory("MC_tbar_beforeFSR", "MC_tbar_beforeFSR", 0);
  FillGenericPartonHistory("MC_tbar_bbar_beforeFSR",
                           "MC_bbar_beforeFSR_from_tbar", 0);
  FillGenericPartonHistory("MC_tbar_afterFSR", "MC_tbar_afterFSR", 0);
  FillGenericPartonHistory("MC_tbar_bbar_afterFSR",
                           "MC_bbar_afterFSR_from_tbar", 0);
  FillWPartonHistory("tbar");
}

FillGammaPartonHistory()

void CP::CalcPartonHistory::FillGammaPartonHistory

(

const std::string &

parent

)

Definition at line 14 of file CalcPhotonPartonHistory.cxx.

                                                                      {
  std::string parentstring = parent.empty() ? "" : "_from_" + parent;
  PtEtaPhiMVector gamma;
  int gamma_origin = -1;
 
  m_dec.decorateDefault("MC_gamma" + parentstring);
  m_dec.decorateCustom("MC_gamma_origin", 0);
 
  if (Retrievep4Gamma(gamma, gamma_origin))
    m_dec.decorateParticle("MC_gamma" + parentstring, gamma);
 
  m_dec.decorateCustom("MC_gamma_origin", gamma_origin);
}

FillGenericPartonHistory() [1/3]

void CP::CalcPartonHistory::FillGenericPartonHistory	(	const std::string &	retrievalstring,
		const std::string &	decorationstring,
		const int	idx )

Definition at line 14 of file CalcGenericPartonHistory.cxx.

                   {
  PtEtaPhiMVector v;
  int pdgId = 0;
  m_dec.decorateDefault(decorationstring);
  if (RetrieveParticleInfo(m_prefix + "_" + retrievalstring, v, pdgId, idx))
    m_dec.decorateParticle(decorationstring, v, pdgId);
}

FillGenericPartonHistory() [2/3]

void CP::CalcPartonHistory::FillGenericPartonHistory	(	const std::vector< std::string > &	retrievalStrings,
		const std::string &	decorationstring )

Definition at line 38 of file CalcGenericPartonHistory.cxx.

                                       {
  FillGenericPartonHistory(retrievalStrings, decorationstring, 0);
}

FillGenericPartonHistory() [3/3]

void CP::CalcPartonHistory::FillGenericPartonHistory	(	const std::vector< std::string > &	retrievalStrings,
		const std::string &	decorationstring,
		const int	idx )

Definition at line 24 of file CalcGenericPartonHistory.cxx.

                                                      {
  PtEtaPhiMVector v;
  int pdgId = 0;
  m_dec.decorateDefault(decorationstring);
  for (const auto& retrievalString : retrievalStrings) {
    if (RetrieveParticleInfo(m_prefix + "_" + retrievalString, v, pdgId, idx)) {
      m_dec.decorateParticle(decorationstring, v, pdgId);
      break;
    }
  }
}

FillGenericVectorPartonHistory()

void CP::CalcPartonHistory::FillGenericVectorPartonHistory	(	const std::string &	retrievalstring,
		const std::string &	decorationstring )

Definition at line 44 of file CalcGenericPartonHistory.cxx.

                                                                         {
  std::vector<PtEtaPhiMVector> v;
  std::vector<int> pdgId;
  m_dec.decorateVectorDefault(decorationstring);
  if (RetrieveParticleInfo(m_prefix + "_" + retrievalstring, v, pdgId))
    m_dec.decorateVectorParticle(decorationstring, v, pdgId);
}

FillHiggsPartonHistory()

void CP::CalcPartonHistory::FillHiggsPartonHistory

(

const std::string &

mode

)

Definition at line 53 of file CalcHiggsPartonHistory.cxx.

                                                                    {
  PtEtaPhiMVector v;
  int pdgId = 0;
 
  // Defaults for all branches regardless of mode.
  m_dec.decorateDefault("MC_H_beforeFSR");
  m_dec.decorateDefault("MC_Hdecay1_beforeFSR");
  m_dec.decorateDefault("MC_Hdecay2_beforeFSR");
  m_dec.decorateDefault("MC_Hdecay1_decay1_beforeFSR");
  m_dec.decorateDefault("MC_Hdecay1_decay2_beforeFSR");
  m_dec.decorateDefault("MC_Hdecay2_decay1_beforeFSR");
  m_dec.decorateDefault("MC_Hdecay2_decay2_beforeFSR");
  m_dec.decorateDefault("MC_H_afterFSR");
  m_dec.decorateDefault("MC_Hdecay1_afterFSR");
  m_dec.decorateDefault("MC_Hdecay2_afterFSR");
  m_dec.decorateDefault("MC_Hdecay1_decay1_afterFSR");
  m_dec.decorateDefault("MC_Hdecay1_decay2_afterFSR");
  m_dec.decorateDefault("MC_Hdecay2_decay1_afterFSR");
  m_dec.decorateDefault("MC_Hdecay2_decay2_afterFSR");
 
  if (mode == "resonant") {
    // RetrieveParticleInfo uses full m_particleMap keys (with m_prefix).
    // m_dec.decorateParticle uses bare names.
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_H_beforeFSR", v, pdgId))
      m_dec.decorateParticle("MC_H_beforeFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay1_beforeFSR", v, pdgId))
      m_dec.decorateParticle("MC_Hdecay1_beforeFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay2_beforeFSR", v, pdgId))
      m_dec.decorateParticle("MC_Hdecay2_beforeFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay1Decay1_beforeFSR", v,
                             pdgId))
      m_dec.decorateParticle("MC_Hdecay1_decay1_beforeFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay1Decay2_beforeFSR", v,
                             pdgId))
      m_dec.decorateParticle("MC_Hdecay1_decay2_beforeFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay2Decay1_beforeFSR", v,
                             pdgId))
      m_dec.decorateParticle("MC_Hdecay2_decay1_beforeFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay2Decay2_beforeFSR", v,
                             pdgId))
      m_dec.decorateParticle("MC_Hdecay2_decay2_beforeFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_H_afterFSR", v, pdgId))
      m_dec.decorateParticle("MC_H_afterFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay1_afterFSR", v, pdgId))
      m_dec.decorateParticle("MC_Hdecay1_afterFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay2_afterFSR", v, pdgId))
      m_dec.decorateParticle("MC_Hdecay2_afterFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay1Decay1_afterFSR", v,
                             pdgId))
      m_dec.decorateParticle("MC_Hdecay1_decay1_afterFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay1Decay2_afterFSR", v,
                             pdgId))
      m_dec.decorateParticle("MC_Hdecay1_decay2_afterFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay2Decay1_afterFSR", v,
                             pdgId))
      m_dec.decorateParticle("MC_Hdecay2_decay1_afterFSR", v, pdgId);
    if (RetrieveParticleInfo(m_prefix + "_" + "MC_HDecay2Decay2_afterFSR", v,
                             pdgId))
      m_dec.decorateParticle("MC_Hdecay2_decay2_afterFSR", v, pdgId);
  } else if (mode == "single_top") {
    // FillGenericPartonHistory retrieval strings are bare suffixes.
    FillGenericPartonHistory(
        {"MC_H_beforeFSR", "MC_b_H_beforeFSR", "MC_bbar_H_beforeFSR"},
        "MC_H_beforeFSR", 0);
    FillGenericPartonHistory({"MC_HDecay1_beforeFSR", "MC_b_HDecay1_beforeFSR",
                              "MC_bbar_HDecay1_beforeFSR"},
                             "MC_Hdecay1_beforeFSR", 0);
    FillGenericPartonHistory({"MC_HDecay2_beforeFSR", "MC_b_HDecay2_beforeFSR",
                              "MC_bbar_HDecay2_beforeFSR"},
                             "MC_Hdecay2_beforeFSR", 0);
    FillGenericPartonHistory(
        {"MC_HDecay1Decay1_beforeFSR", "MC_b_HDecay1Decay1_beforeFSR",
         "MC_bbar_HDecay1Decay1_beforeFSR"},
        "MC_Hdecay1_decay1_beforeFSR", 0);
    FillGenericPartonHistory(
        {"MC_HDecay1Decay2_beforeFSR", "MC_b_HDecay1Decay2_beforeFSR",
         "MC_bbar_HDecay1Decay2_beforeFSR"},
        "MC_Hdecay1_decay2_beforeFSR", 0);
    FillGenericPartonHistory(
        {"MC_HDecay2Decay1_beforeFSR", "MC_b_HDecay2Decay1_beforeFSR",
         "MC_bbar_HDecay2Decay1_beforeFSR"},
        "MC_Hdecay2_decay1_beforeFSR", 0);
    FillGenericPartonHistory(
        {"MC_HDecay2Decay2_beforeFSR", "MC_b_HDecay2Decay2_beforeFSR",
         "MC_bbar_HDecay2Decay2_beforeFSR"},
        "MC_Hdecay2_decay2_beforeFSR", 0);
    FillGenericPartonHistory(
        {"MC_H_afterFSR", "MC_b_H_afterFSR", "MC_bbar_H_afterFSR"},
        "MC_H_afterFSR", 0);
    FillGenericPartonHistory({"MC_HDecay1_afterFSR", "MC_b_HDecay1_afterFSR",
                              "MC_bbar_HDecay1_afterFSR"},
                             "MC_Hdecay1_afterFSR", 0);
    FillGenericPartonHistory({"MC_HDecay2_afterFSR", "MC_b_HDecay2_afterFSR",
                              "MC_bbar_HDecay2_afterFSR"},
                             "MC_Hdecay2_afterFSR", 0);
    FillGenericPartonHistory(
        {"MC_HDecay1Decay1_afterFSR", "MC_b_HDecay1Decay1_afterFSR",
         "MC_bbar_HDecay1Decay1_afterFSR"},
        "MC_Hdecay1_decay1_afterFSR", 0);
    FillGenericPartonHistory(
        {"MC_HDecay1Decay2_afterFSR", "MC_b_HDecay1Decay2_afterFSR",
         "MC_bbar_HDecay1Decay2_afterFSR"},
        "MC_Hdecay1_decay2_afterFSR", 0);
    FillGenericPartonHistory(
        {"MC_HDecay2Decay1_afterFSR", "MC_b_HDecay2Decay1_afterFSR",
         "MC_bbar_HDecay2Decay1_afterFSR"},
        "MC_Hdecay2_decay1_afterFSR", 0);
    FillGenericPartonHistory(
        {"MC_HDecay2Decay2_afterFSR", "MC_b_HDecay2Decay2_afterFSR",
         "MC_bbar_HDecay2Decay2_afterFSR"},
        "MC_Hdecay2_decay2_afterFSR", 0);
  } else if (mode == "non_resonant_WW") {
    setHiggs("beforeFSR");
    setHiggs("afterFSR");
  }
}

FillParticleMap()

void CP::CalcPartonHistory::FillParticleMap

(

std::vector< std::vector< const xAOD::TruthParticle * > > &

allPaths

)

Definition at line 307 of file CalcPartonHistory.cxx.

                                                              {
  // Converts the raw decay paths produced by TraceParticles into the
  // m_particleMap used by all Retrieve* and Fill* methods.
  //
  // Key construction: each path is walked particle by particle, accumulating
  // a string key of the form
  // "<prefix>_MC_<type1>_<type2>_..._<beforeFSR|afterFSR>". For example, a b
  // quark from a top gives "MySch_MC_t_b_beforeFSR". Decay products of W/Z/H
  // get an additional "Decay<N>" segment to distinguish the two daughters, e.g.
  // "MySch_MC_t_WDecay1_beforeFSR".
  //
  // Handler priority (first match wins for each particle in the path):
  //   handleDecay      — daughters of W/Z/H: appends "Decay<N>" and records
  //   beforeFSR/afterFSR handleFSR        — the radiating particle itself:
  //   records both before and after FSR copies handleSameAsParent —
  //   intermediate FSR copies (same PDG as parent): stored under current key
  //   handleDefault    — all other particles: appends the type suffix and
  //   advances the key
  m_particleMap.clear();
  static const SG::Accessor<unsigned int> acc_classification("Classification");
  static const SG::Accessor<unsigned int> acc_classifierParticleOrigin(
      "classifierParticleOrigin");
  static const SG::Accessor<unsigned int> acc_classifierParticleType(
      "classifierParticleType");
 
  for (const auto& path : allPaths) {
    // m_particleMap keys always include the prefix, built once here.
    std::string key = m_prefix + "_" + "MC";
 
    for (const auto* p : path) {
      // beforeFSR: this node has an identical child (it will radiate).
      // afterFSR:  this node's parent has the same PDG ID (it was radiated
      // from).
      const bool beforeFSR = PartonHistoryUtils::hasIdenticalChild(p);
      const bool afterFSR = PartonHistoryUtils::hasParentPdgId(p);
 
      // Determine which child index this particle is under its parent; used to
      // label W/Z/H decay daughters as Decay1, Decay2. Falls back to sign of
      // pdgId (negative → 2) if parent navigation is unavailable.
      int decayID = (p->pdgId() < 0) ? 2 : 1;
      if (p->nParents() != 0 && p->parent(0)) {
        const auto* par = p->parent(0);
        for (std::size_t i = 0; i < par->nChildren(); ++i) {
          if (par->child(i) == p) {
            decayID = static_cast<int>(i) + 1;
            break;
          }
        }
      }
 
      const std::string new_key = GetParticleType(p);
 
      // Skip pure intermediate FSR nodes that are neither the first nor last
      // in the FSR chain — they carry no additional physics information.
      if (beforeFSR && afterFSR)
        continue;
      if (handleDecay(p, key, decayID))
        continue;
      if (handleFSR(p, new_key, key))
        continue;
      if (PartonHistoryUtils::hasParentPdgId(p)) {
        handleSameAsParent(p, key);
        continue;
      }
      if (!new_key.empty())
        handleDefault(p, new_key, key);
    }
  }
}

FillTopPartonHistory()

void CP::CalcPartonHistory::FillTopPartonHistory

(

)

Definition at line 14 of file CalcTopPartonHistory.cxx.

                                             {
  FillGenericPartonHistory("MC_t_beforeFSR", "MC_t_beforeFSR", 0);
  FillGenericPartonHistory("MC_t_b_beforeFSR", "MC_b_beforeFSR_from_t", 0);
  FillGenericPartonHistory("MC_t_afterFSR", "MC_t_afterFSR", 0);
  FillGenericPartonHistory("MC_t_b_afterFSR", "MC_b_afterFSR_from_t", 0);
  FillWPartonHistory("t");
}

FillTtbarPartonHistory()

void CP::CalcPartonHistory::FillTtbarPartonHistory

(

)

Definition at line 32 of file CalcTopPartonHistory.cxx.

                                               {
  // Assumes FillTopPartonHistory and FillAntiTopPartonHistory have already run.
  PtEtaPhiMVector ttbar;
  PtEtaPhiMVector t_beforeFSR, tbar_beforeFSR, t_afterFSR, tbar_afterFSR;
  PtEtaPhiMVector WpDecay1, WpDecay2, WmDecay1, WmDecay2, b, bbar;
 
  // m_dec.decorate* takes bare names; Retrievep4 takes full m_particleMap keys.
  m_dec.decorateDefaultNoPdgId("MC_ttbar_beforeFSR");
  m_dec.decorateDefaultNoPdgId("MC_ttbar_afterFSR");
  m_dec.decorateDefaultNoPdgId("MC_ttbar_fromDecay_beforeFSR");
  m_dec.decorateDefaultNoPdgId("MC_ttbar_fromDecay_afterFSR");
 
  if (Retrievep4(m_prefix + "_" + "MC_t_beforeFSR", t_beforeFSR) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_beforeFSR", tbar_beforeFSR)) {
    ttbar = t_beforeFSR + tbar_beforeFSR;
    m_dec.decorateParticle("MC_ttbar_beforeFSR", ttbar);
  }
 
  if (Retrievep4(m_prefix + "_" + "MC_t_afterFSR", t_afterFSR) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_afterFSR", tbar_afterFSR)) {
    ttbar = t_afterFSR + tbar_afterFSR;
    m_dec.decorateParticle("MC_ttbar_afterFSR", ttbar);
  }
 
  if (Retrievep4(m_prefix + "_" + "MC_t_WDecay1_beforeFSR", WpDecay1) &&
      Retrievep4(m_prefix + "_" + "MC_t_WDecay2_beforeFSR", WpDecay2) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_WDecay1_beforeFSR", WmDecay1) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_WDecay2_beforeFSR", WmDecay2) &&
      Retrievep4(m_prefix + "_" + "MC_t_b_beforeFSR", b) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_bbar_beforeFSR", bbar)) {
    ttbar = WpDecay1 + WpDecay2 + WmDecay1 + WmDecay2 + b + bbar;
    m_dec.decorateParticle("MC_ttbar_fromDecay_beforeFSR", ttbar);
  }
 
  if (Retrievep4(m_prefix + "_" + "MC_t_WDecay1_afterFSR", WpDecay1) &&
      Retrievep4(m_prefix + "_" + "MC_t_WDecay2_afterFSR", WpDecay2) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_WDecay1_afterFSR", WmDecay1) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_WDecay2_afterFSR", WmDecay2) &&
      Retrievep4(m_prefix + "_" + "MC_t_b_afterFSR", b) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_bbar_afterFSR", bbar)) {
    ttbar = WpDecay1 + WpDecay2 + WmDecay1 + WmDecay2 + b + bbar;
    m_dec.decorateParticle("MC_ttbar_fromDecay_afterFSR", ttbar);
  }
}

FillWPartonHistory()

void CP::CalcPartonHistory::FillWPartonHistory	(	const std::string &	parent,
		int	nWs = 1,
		const std::string &	mode = "resonant" )

Definition at line 113 of file CalcWPartonHistory.cxx.

                                                                  {
  std::string parentstring = parent.empty() ? "" : "_from_" + parent;
  // Bare suffix for FillGenericPartonHistory (it prepends m_prefix + "_"
  // internally).
  std::string prefix = "MC_" + (parent.empty() ? "W" : parent + "_W");
 
  if (mode == "resonant") {
    if (nWs == 1) {
      FillGenericPartonHistory(prefix + "_beforeFSR",
                               "MC_W_beforeFSR" + parentstring, 0);
      FillGenericPartonHistory(prefix + "Decay1_beforeFSR",
                               "MC_Wdecay1_beforeFSR" + parentstring, 0);
      FillGenericPartonHistory(prefix + "Decay2_beforeFSR",
                               "MC_Wdecay2_beforeFSR" + parentstring, 0);
      FillGenericPartonHistory(prefix + "_afterFSR",
                               "MC_W_afterFSR" + parentstring, 0);
      FillGenericPartonHistory(prefix + "Decay1_afterFSR",
                               "MC_Wdecay1_afterFSR" + parentstring, 0);
      FillGenericPartonHistory(prefix + "Decay2_afterFSR",
                               "MC_Wdecay2_afterFSR" + parentstring, 0);
    } else {
      for (int idx = 0; idx < nWs; idx++) {
        const std::string idxStr = std::to_string(idx + 1);
        FillGenericPartonHistory(prefix + "_beforeFSR",
                                 "MC_W" + idxStr + "_beforeFSR" + parentstring,
                                 0);
        FillGenericPartonHistory(
            prefix + "Decay1_beforeFSR",
            "MC_W" + idxStr + "decay1_beforeFSR" + parentstring, 0);
        FillGenericPartonHistory(
            prefix + "Decay2_beforeFSR",
            "MC_W" + idxStr + "decay2_beforeFSR" + parentstring, 0);
        FillGenericPartonHistory(prefix + "_afterFSR",
                                 "MC_W" + idxStr + "_afterFSR" + parentstring,
                                 0);
        FillGenericPartonHistory(
            prefix + "Decay1_afterFSR",
            "MC_W" + idxStr + "decay1_afterFSR" + parentstring, 0);
        FillGenericPartonHistory(
            prefix + "Decay2_afterFSR",
            "MC_W" + idxStr + "decay2_afterFSR" + parentstring, 0);
      }
    }
  } else if (mode == "non_resonant") {
    setW("beforeFSR", nWs);
    setW("afterFSR", nWs);
  }
}

FillZPartonHistory()

void CP::CalcPartonHistory::FillZPartonHistory	(	const std::string &	parent,
		int	nZs = 1,
		const std::string &	mode = "resonant" )

Definition at line 211 of file CalcZPartonHistory.cxx.

                                                                  {
  std::string parentstring = parent.empty() ? "" : "_from_" + parent;
  // mapPrefix: full m_particleMap key base (with m_prefix) — used only for
  // ExistsInMap.
  std::string mapPrefix =
      m_prefix + "_" + "MC_" + (parent.empty() ? "Z" : parent + "_Z");
  // decPrefix: bare suffix passed to FillGenericPartonHistory as
  // retrievalstring; FillGenericPartonHistory prepends m_prefix + "_"
  // internally.
  std::string decPrefix = "MC_" + (parent.empty() ? "Z" : parent + "_Z");
 
  if (mode == "resonant") {
    if (nZs == 1) {
      if (ExistsInMap(mapPrefix + "_beforeFSR")) {
        m_dec.decorateCustom("MC_Z_IsOnShell", 1);
        FillGenericPartonHistory(decPrefix + "_beforeFSR",
                                 "MC_Z" + parentstring + "_beforeFSR", 0);
        FillGenericPartonHistory(decPrefix + "Decay1_beforeFSR",
                                 "MC_Zdecay1" + parentstring + "_beforeFSR", 0);
        FillGenericPartonHistory(decPrefix + "Decay2_beforeFSR",
                                 "MC_Zdecay2" + parentstring + "_beforeFSR", 0);
        FillGenericPartonHistory(decPrefix + "_afterFSR",
                                 "MC_Z" + parentstring + "_afterFSR", 0);
        FillGenericPartonHistory(decPrefix + "Decay1_afterFSR",
                                 "MC_Zdecay1" + parentstring + "_afterFSR", 0);
        FillGenericPartonHistory(decPrefix + "Decay2_afterFSR",
                                 "MC_Zdecay2" + parentstring + "_afterFSR", 0);
      } else {
        setZ("beforeFSR", nZs);
        setZ("afterFSR", nZs);
      }
    } else {
      for (int idx = 0; idx < nZs; idx++) {
        const std::string idxStr = std::to_string(idx + 1);
        m_dec.decorateCustom("MC_Z" + idxStr + "_IsOnShell", 1);
        FillGenericPartonHistory(decPrefix + "_beforeFSR",
                                 "MC_Z" + idxStr + parentstring + "_beforeFSR",
                                 idx);
        FillGenericPartonHistory(
            decPrefix + "Decay1_beforeFSR",
            "MC_Z" + idxStr + "decay1" + parentstring + "_beforeFSR", idx);
        FillGenericPartonHistory(
            decPrefix + "Decay2_beforeFSR",
            "MC_Z" + idxStr + "decay2" + parentstring + "_beforeFSR", idx);
        FillGenericPartonHistory(decPrefix + "_afterFSR",
                                 "MC_Z" + idxStr + parentstring + "_afterFSR",
                                 idx);
        FillGenericPartonHistory(
            decPrefix + "Decay1_afterFSR",
            "MC_Z" + idxStr + "decay1" + parentstring + "_afterFSR", idx);
        FillGenericPartonHistory(
            decPrefix + "Decay2_afterFSR",
            "MC_Z" + idxStr + "decay2" + parentstring + "_afterFSR", idx);
      }
    }
  } else if (mode == "non_resonant") {
    setZ("beforeFSR", nZs);
    setZ("afterFSR", nZs);
  }
}

FillZtautauPartonHistory()

void CP::CalcPartonHistory::FillZtautauPartonHistory	(	const std::string &	parent,
		int	nZs = 1,
		const std::string &	mode = "resonant" )

Definition at line 273 of file CalcZPartonHistory.cxx.

                                                                        {
  std::string parentstring = parent.empty() ? "" : "_from_" + parent;
  // mapPrefix: full key for ExistsInMap (used indirectly via
  // FillZPartonHistory).
  std::string mapPrefix =
      m_prefix + "_" + "MC_" + (parent.empty() ? "Z" : parent + "_Z");
  // decPrefix: bare suffix for FillGenericPartonHistory retrieval strings.
  std::string decPrefix = "MC_" + (parent.empty() ? "Z" : parent + "_Z");
 
  FillZPartonHistory(parent, nZs, mode);
  m_dec.decorateCustom("MC_Z_IsOnShell",
                       0);  // default; overwritten to 1 below if resonant
  if (mode == "resonant") {
    if (nZs == 1) {
      m_dec.decorateCustom("MC_Z_IsOnShell", 1);
      FillGenericPartonHistory(
          decPrefix + "Decay1_Decay1_beforeFSR",
          "MC_Zdecay1_decay1" + parentstring + "_beforeFSR", 0);
      FillGenericPartonHistory(
          decPrefix + "Decay1_Decay2_beforeFSR",
          "MC_Zdecay1_decay2" + parentstring + "_beforeFSR", 0);
      FillGenericPartonHistory(
          decPrefix + "Decay1_Decay3_beforeFSR",
          "MC_Zdecay1_decay3" + parentstring + "_beforeFSR", 0);
      FillGenericPartonHistory(decPrefix + "Decay1_Decay1_afterFSR",
                               "MC_Zdecay1_decay1" + parentstring + "_afterFSR",
                               0);
      FillGenericPartonHistory(decPrefix + "Decay1_Decay2_afterFSR",
                               "MC_Zdecay1_decay2" + parentstring + "_afterFSR",
                               0);
      FillGenericPartonHistory(decPrefix + "Decay1_Decay3_afterFSR",
                               "MC_Zdecay1_decay3" + parentstring + "_afterFSR",
                               0);
    } else {
      for (int idx = 0; idx < nZs; idx++) {
        const std::string idxStr = std::to_string(idx + 1);
        m_dec.decorateCustom("MC_Z" + idxStr + "_IsOnShell", 1);
        FillGenericPartonHistory(
            decPrefix + "Decay1_Decay1_beforeFSR",
            "MC_Z" + idxStr + "decay1_decay1" + parentstring + "_beforeFSR",
            idx);
        FillGenericPartonHistory(
            decPrefix + "Decay1_Decay2_beforeFSR",
            "MC_Z" + idxStr + "decay1_decay2" + parentstring + "_beforeFSR",
            idx);
        FillGenericPartonHistory(
            decPrefix + "Decay1_Decay3_beforeFSR",
            "MC_Z" + idxStr + "decay1_decay3" + parentstring + "_beforeFSR",
            idx);
        FillGenericPartonHistory(
            decPrefix + "Decay1_Decay1_afterFSR",
            "MC_Z" + idxStr + "decay1_decay1" + parentstring + "_afterFSR",
            idx);
        FillGenericPartonHistory(
            decPrefix + "Decay1_Decay2_afterFSR",
            "MC_Z" + idxStr + "decay1_decay2" + parentstring + "_afterFSR",
            idx);
        FillGenericPartonHistory(
            decPrefix + "Decay1_Decay3_afterFSR",
            "MC_Z" + idxStr + "decay1_decay3" + parentstring + "_afterFSR",
            idx);
      }
    }
  } else if (mode == "non_resonant") {
    setZtautau("beforeFSR", nZs);
    setZtautau("afterFSR", nZs);
  }
}

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::Event 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::Event, 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::Event 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::Event, 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
   }

GetParticleType()

std::string CP::CalcPartonHistory::GetParticleType

(

const xAOD::TruthParticle *

particle

)

Definition at line 169 of file CalcPartonHistory.cxx.

                                       {
  static const std::unordered_map<int, std::string> pdgMap = {
      {1, "_q"},       {2, "_q"},       {3, "_q"},      {-1, "_qbar"},
      {-2, "_qbar"},   {-3, "_qbar"},   {6, "_t"},      {-6, "_tbar"},
      {5, "_b"},       {-5, "_bbar"},   {4, "_c"},      {-4, "_cbar"},
      {25, "_H"},      {24, "_W"},      {-24, "_W"},    {23, "_Z"},
      {22, "_gamma"},  {21, "_g"},      {11, "_l"},     {13, "_l"},
      {15, "_l"},      {-11, "_lbar"},  {-13, "_lbar"}, {-15, "_lbar"},
      {12, "_nu"},     {14, "_nu"},     {16, "_nu"},    {-12, "_nubar"},
      {-14, "_nubar"}, {-16, "_nubar"}, {2212, "_p"},   {1103, "_dd"},
      {2101, "_ud"},   {2103, "_ud"},   {2203, "_uu"},  {3101, "_sd"},
      {3103, "_sd"},   {3201, "_su"},   {3203, "_su"},  {3303, "_ss"},
      {4101, "_cd"},   {4103, "_cd"},   {4201, "_cu"},  {4203, "_cu"},
      {4301, "_cs"},   {4303, "_cs"},   {4403, "_cc"},  {5101, "_bd"},
      {5103, "_bd"},   {5201, "_bu"},   {5203, "_bu"},  {5301, "_bs"},
      {5303, "_bs"},   {5401, "_bc"},   {5403, "_bc"},  {5503, "_bb"}};
  int pdgId = particle->pdgId();
  auto it = pdgMap.find(pdgId);
  return it != pdgMap.end() ? it->second : "_" + std::to_string(pdgId);
}

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

getTruthParticleLinkedFromDecoration()

const xAOD::TruthParticle * CP::CalcPartonHistory::getTruthParticleLinkedFromDecoration ( const xAOD::TruthParticle * part, const std::string & decorationName )

protected

helper method to handle retriveing the truth particle linked in the decoration of another particle

Definition at line 486 of file CalcPartonHistory.cxx.

                                                                    {
  const SG::ConstAccessor<const xAOD::TruthParticle*> acc(decorationName);
  if (!acc.isAvailable(*part))
    return part;
  const xAOD::TruthParticle* link = acc(*part);
  return link ? link : part;
}

getW()

bool CP::CalcPartonHistory::getW	(	const std::string &	str_lep,
		const std::string &	str_nu,
		PtEtaPhiMVector &	p1,
		int &	pdgId1,
		PtEtaPhiMVector &	p2,
		int &	pdgId2 )

Definition at line 15 of file CalcWPartonHistory.cxx.

                                                                            {
  // Off-shell / non-resonant W reconstruction from lepton + neutrino
  // candidates. Loops over all (lepton, neutrino) pairs and returns the first
  // pair that passes the three conditions below. The caller is responsible for
  // passing the correct lepton/neutrino flavour keys (e.g. MC_lbar + MC_nu for
  // W+).
  std::vector<const xAOD::TruthParticle*> W_offshell_decay1_candidates;
  std::vector<const xAOD::TruthParticle*> W_offshell_decay2_candidates;
  // str_lep/str_nu are full m_particleMap keys (caller passes m_prefix + "_" +
  // ...)
  bool has_candidates =
      (RetrieveParticleInfo(str_lep, W_offshell_decay1_candidates) &&
       RetrieveParticleInfo(str_nu, W_offshell_decay2_candidates));
  if (has_candidates) {
    for (const auto* particle_1 : W_offshell_decay1_candidates) {
      for (const auto* particle_2 : W_offshell_decay2_candidates) {
        // Condition 1: Opposite charge — lepton and neutrino must have
        // opposite-sign pdgIds (e.g. e- has pdgId=11, νe has pdgId=12; product
        // is positive, so we require the product to be negative for a valid W
        // decay pair).
        if ((particle_1->pdgId() * particle_2->pdgId()) > 0)
          continue;
        // Condition 2: Same lepton generation — |pdgId| of lepton and neutrino
        // must differ by exactly 1 (e.g. 11 & 12, 13 & 14, 15 & 16).
        if (std::abs(particle_1->absPdgId() - particle_2->absPdgId()) != 1)
          continue;
        // Condition 3: Reject shower particles — particles produced during
        // parton showering are assigned UIDs above 10100 by the generator.
        // We require at least one of the pair to be a hard-scatter particle
        // (UID ≤ 10100) to avoid picking up shower leptons.
        if (particle_1->uid() > 10100 && particle_2->uid() > 10100)
          continue;
 
        p1 = GetPtEtaPhiMfromTruth(particle_1);
        pdgId1 = particle_1->pdgId();
        p2 = GetPtEtaPhiMfromTruth(particle_2);
        pdgId2 = particle_2->pdgId();
        return true;
      }
    }
  }
  return false;
}

getZ()

bool CP::CalcPartonHistory::getZ	(	const std::string &	str_lep1,
		const std::string &	str_lep2,
		PtEtaPhiMVector &	p1,
		int &	pdgId1,
		PtEtaPhiMVector &	p2,
		int &	pdgId2 )

Definition at line 15 of file CalcZPartonHistory.cxx.

                                                                            {
  // Off-shell / non-resonant Z reconstruction from two same-flavour
  // opposite-sign lepton candidates. Uses MCTruthClassifier decorations
  // (classifierParticleOrigin, classifierParticleType) to restrict to
  // prompt, isolated leptons from a Z decay, rejecting fakes and non-prompt
  // background. Only electrons and muons are considered (not taus); for
  // Z→ττ use getZFromTaus instead.
  static const SG::Accessor<unsigned int> acc_classifierParticleOrigin(
      "classifierParticleOrigin");
  static const SG::Accessor<unsigned int> acc_classifierParticleType(
      "classifierParticleType");
  std::vector<const xAOD::TruthParticle*> Z_offshell_decay1_candidates;
  std::vector<const xAOD::TruthParticle*> Z_offshell_decay2_candidates;
  // str_lep1/2 are full m_particleMap keys (caller passes m_prefix + "_" + ...)
  bool has_candidates =
      (RetrieveParticleInfo(str_lep1, Z_offshell_decay1_candidates) &&
       RetrieveParticleInfo(str_lep2, Z_offshell_decay2_candidates));
  if (has_candidates) {
    const xAOD::TruthParticle* bp1 = nullptr;
    const xAOD::TruthParticle* bp2 = nullptr;
    for (const auto* pDecay1 : Z_offshell_decay1_candidates) {
      for (const auto* pDecay2 : Z_offshell_decay2_candidates) {
        unsigned int o1 = acc_classifierParticleOrigin(*pDecay1);
        unsigned int o2 = acc_classifierParticleOrigin(*pDecay2);
        unsigned int t1 = acc_classifierParticleType(*pDecay1);
        unsigned int t2 = acc_classifierParticleType(*pDecay2);
        // Condition 1: Opposite charge — pdgId product must be negative
        // (e.g. e-=11, e+=−11 → product −121 < 0).
        if ((pDecay1->pdgId() * pDecay2->pdgId()) > 0)
          continue;
        // Condition 2: Same flavour — both leptons must have the same |pdgId|
        // (e.g. both electrons or both muons).
        if (pDecay1->absPdgId() != pDecay2->absPdgId())
          continue;
        // Condition 3: Origin == 13 (ZBoson) from MCTruthClassifier
        // (see TruthUtils/TruthClasses.h). Ensures both leptons are
        // truth-matched to a Z decay and not to backgrounds such as photon
        // conversions or heavy-flavour semileptonic decays.
        if (!(o1 == 13 && o2 == 13))
          continue;
        // Condition 4: Type == 2 (IsoElectron) or 4 (IsoMuon) from
        // MCTruthClassifier. Selects prompt isolated leptons, rejecting
        // non-isolated or non-prompt contributions.
        if (!((t1 == 2 && t2 == 2) || (t1 == 4 && t2 == 4)))
          continue;
        bp1 = pDecay1;
        bp2 = pDecay2;
      }
    }
    if (bp1 && bp2) {
      p1 = GetPtEtaPhiMfromTruth(bp1);
      pdgId1 = bp1->pdgId();
      p2 = GetPtEtaPhiMfromTruth(bp2);
      pdgId2 = bp2->pdgId();
      return true;
    }
  }
  return false;
}

getZFromTaus()

bool CP::CalcPartonHistory::getZFromTaus	(	const std::string &	fsr,
		PtEtaPhiMVector &	Zdecay1,
		int &	Zdecay1_pdgId,
		PtEtaPhiMVector &	Zdecay2,
		int &	Zdecay2_pdgId,
		PtEtaPhiMVector &	Zdecay1_decay1,
		int &	Zdecay1_decay1_pdgId,
		PtEtaPhiMVector &	Zdecay1_decay2,
		int &	Zdecay1_decay2_pdgId,
		PtEtaPhiMVector &	Zdecay1_decay3,
		int &	Zdecay1_decay3_pdgId,
		PtEtaPhiMVector &	Zdecay2_decay1,
		int &	Zdecay2_decay1_pdgId,
		PtEtaPhiMVector &	Zdecay2_decay2,
		int &	Zdecay2_decay2_pdgId,
		PtEtaPhiMVector &	Zdecay2_decay3,
		int &	Zdecay2_decay3_pdgId )

Definition at line 77 of file CalcZPartonHistory.cxx.

                                                                {
 
  std::vector<const xAOD::TruthParticle*> Z_offshell_l_candidates;  // tau
  std::vector<const xAOD::TruthParticle*>
      Z_offshell_l_l_candidates;  // l from tau
  std::vector<const xAOD::TruthParticle*>
      Z_offshell_l_nubar_candidates;  // anti-nu from tau
  std::vector<const xAOD::TruthParticle*>
      Z_offshell_l_nu_candidates;  // nu from tau
  std::vector<const xAOD::TruthParticle*> Z_offshell_lbar_candidates;  // taubar
  std::vector<const xAOD::TruthParticle*>
      Z_offshell_lbar_lbar_candidates;  // lbar from taubar
  std::vector<const xAOD::TruthParticle*>
      Z_offshell_lbar_nu_candidates;  // nu from taubar
  std::vector<const xAOD::TruthParticle*>
      Z_offshell_lbar_nubar_candidates;  // anti-nu from taubar
 
  // All RetrieveParticleInfo calls use full m_particleMap keys (with prefix).
  bool has_taum_candidates = RetrieveParticleInfo(
      m_prefix + "_" + "MC_l_" + fsr, Z_offshell_l_candidates);
  bool has_taum_decay_candidates =
      (RetrieveParticleInfo(m_prefix + "_" + "MC_l_l_" + fsr,
                            Z_offshell_l_l_candidates) &&
       RetrieveParticleInfo(m_prefix + "_" + "MC_l_nubar_" + fsr,
                            Z_offshell_l_nubar_candidates) &&
       RetrieveParticleInfo(m_prefix + "_" + "MC_l_nu_" + fsr,
                            Z_offshell_l_nu_candidates));
  bool has_taup_candidates = RetrieveParticleInfo(
      m_prefix + "_" + "MC_lbar_" + fsr, Z_offshell_lbar_candidates);
  bool has_taup_decay_candidates =
      (RetrieveParticleInfo(m_prefix + "_" + "MC_lbar_lbar_" + fsr,
                            Z_offshell_lbar_lbar_candidates) &&
       RetrieveParticleInfo(m_prefix + "_" + "MC_lbar_nu_" + fsr,
                            Z_offshell_lbar_nu_candidates) &&
       RetrieveParticleInfo(m_prefix + "_" + "MC_lbar_nubar_" + fsr,
                            Z_offshell_lbar_nubar_candidates));
 
  if (has_taum_candidates) {
    Zdecay1 = GetPtEtaPhiMfromTruth(Z_offshell_l_candidates.at(0));
    Zdecay1_pdgId = Z_offshell_l_candidates.at(0)->pdgId();
  }
  if (has_taum_decay_candidates) {
    Zdecay1_decay1 = GetPtEtaPhiMfromTruth(Z_offshell_l_l_candidates.at(0));
    Zdecay1_decay1_pdgId = Z_offshell_l_l_candidates.at(0)->pdgId();
    Zdecay1_decay2 = GetPtEtaPhiMfromTruth(Z_offshell_l_nubar_candidates.at(0));
    Zdecay1_decay2_pdgId = Z_offshell_l_nubar_candidates.at(0)->pdgId();
    Zdecay1_decay3 = GetPtEtaPhiMfromTruth(Z_offshell_l_nu_candidates.at(0));
    Zdecay1_decay3_pdgId = Z_offshell_l_nu_candidates.at(0)->pdgId();
  }
  if (has_taup_candidates) {
    Zdecay2 = GetPtEtaPhiMfromTruth(Z_offshell_lbar_candidates.at(0));
    Zdecay2_pdgId = Z_offshell_lbar_candidates.at(0)->pdgId();
  }
  if (has_taup_decay_candidates) {
    Zdecay2_decay1 =
        GetPtEtaPhiMfromTruth(Z_offshell_lbar_lbar_candidates.at(0));
    Zdecay2_decay1_pdgId = Z_offshell_lbar_lbar_candidates.at(0)->pdgId();
    Zdecay2_decay2 = GetPtEtaPhiMfromTruth(Z_offshell_lbar_nu_candidates.at(0));
    Zdecay2_decay2_pdgId = Z_offshell_lbar_nu_candidates.at(0)->pdgId();
    Zdecay2_decay3 =
        GetPtEtaPhiMfromTruth(Z_offshell_lbar_nubar_candidates.at(0));
    Zdecay2_decay3_pdgId = Z_offshell_lbar_nubar_candidates.at(0)->pdgId();
  }
  return has_taum_candidates && has_taup_candidates;
}

handleDecay()

bool CP::CalcPartonHistory::handleDecay	(	const xAOD::TruthParticle *	particle,
		std::string &	key,
		int	decayID )

Definition at line 276 of file CalcPartonHistory.cxx.

                                                                 {
  const bool fromH = PartonHistoryUtils::hasParentAbsPdgId(p, 25) &&
                     !PartonHistoryUtils::hasParentPdgId(p);
  const bool fromW = PartonHistoryUtils::hasParentAbsPdgId(p, 24) &&
                     !PartonHistoryUtils::hasParentPdgId(p);
  const bool fromZ = PartonHistoryUtils::hasParentAbsPdgId(p, 23) &&
                     !PartonHistoryUtils::hasParentPdgId(p);
  if (!fromH && !fromW && !fromZ)
    return false;
 
  const std::string decayStr = "Decay" + std::to_string(decayID);
  key += decayStr;
  AddToParticleMap(p, key + kBeforeFSR);
  if (!PartonHistoryUtils::hasIdenticalChild(p))
    AddToParticleMap(p, key + kAfterFSR);
  return true;
}

handleDefault()

void CP::CalcPartonHistory::handleDefault	(	const xAOD::TruthParticle *	particle,
		const std::string &	newKey,
		std::string &	key )

Definition at line 300 of file CalcPartonHistory.cxx.

                                                      {
  AddToParticleMap(particle, key + newKey);
  key += newKey;
}

handleFSR()

bool CP::CalcPartonHistory::handleFSR	(	const xAOD::TruthParticle *	particle,
		const std::string &	newKey,
		std::string &	key )

Definition at line 254 of file CalcPartonHistory.cxx.

                                                                           {
  if (!PartonHistoryUtils::hasParentPdgId(p))
    key += newKey;
 
  if (p->nParents() == 0) {
    AddToParticleMap(p, key + kBeforeFSR);
    if (!PartonHistoryUtils::hasIdenticalChild(p))
      AddToParticleMap(p, key + kAfterFSR);
    return true;
  }
 
  if (PartonHistoryUtils::hasParentPdgId(p)) {
    AddToParticleMap(p, key + kAfterFSR);
  } else {
    AddToParticleMap(p, key + kBeforeFSR);
    if (!PartonHistoryUtils::hasIdenticalChild(p))
      AddToParticleMap(p, key + kAfterFSR);
  }
  return true;
}

handleSameAsParent()

void CP::CalcPartonHistory::handleSameAsParent	(	const xAOD::TruthParticle *	particle,
		std::string &	key )

Definition at line 295 of file CalcPartonHistory.cxx.

                                                           {
  AddToParticleMap(particle, key);
}

initialize()

StatusCode CP::CalcPartonHistory::initialize ( void )

overridevirtual

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 from asg::AsgTool.

Definition at line 392 of file CalcPartonHistory.cxx.

                                         {
  m_dec.setPrefix(m_prefix);
  initializeDecorators();
  return StatusCode::SUCCESS;
}

Initialize4TopDecorators()

void CP::CalcPartonHistory::Initialize4TopDecorators

(

)

Definition at line 11 of file PartonHistoryDecorators.cxx.

                                                 {
  for (int idx = 1; idx <= 2; idx++) {
    m_dec.initializePtEtaPhiMDecorator("MC_t" + std::to_string(idx) +
                                       "_beforeFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_b_beforeFSR_from_t" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_W_beforeFSR_from_t" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_Wdecay1_beforeFSR_from_t" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_Wdecay2_beforeFSR_from_t" +
                                       std::to_string(idx));
 
    m_dec.initializePtEtaPhiMDecorator("MC_t" + std::to_string(idx) +
                                       "_afterFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_b_afterFSR_from_t" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_W_afterFSR_from_t" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_Wdecay1_afterFSR_from_t" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_Wdecay2_afterFSR_from_t" +
                                       std::to_string(idx));
 
    m_dec.initializePtEtaPhiMDecorator("MC_tbar" + std::to_string(idx) +
                                       "_beforeFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_bbar_beforeFSR_from_tbar" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_W_beforeFSR_from_tbar" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_Wdecay1_beforeFSR_from_tbar" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_Wdecay2_beforeFSR_from_tbar" +
                                       std::to_string(idx));
 
    m_dec.initializePtEtaPhiMDecorator("MC_tbar" + std::to_string(idx) +
                                       "_afterFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_bbar_afterFSR_from_tbar" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_W_afterFSR_from_tbar" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_Wdecay1_afterFSR_from_tbar" +
                                       std::to_string(idx));
    m_dec.initializePtEtaPhiMDecorator("MC_Wdecay2_afterFSR_from_tbar" +
                                       std::to_string(idx));
 
    m_dec.initializeIntDecorator("MC_t" + std::to_string(idx) +
                                 "_beforeFSR_pdgId");
    m_dec.initializeIntDecorator("MC_b_beforeFSR_from_t" + std::to_string(idx) +
                                 "_pdgId");
    m_dec.initializeIntDecorator("MC_W_beforeFSR_from_t" + std::to_string(idx) +
                                 "_pdgId");
    m_dec.initializeIntDecorator("MC_Wdecay1_beforeFSR_from_t" +
                                 std::to_string(idx) + "_pdgId");
    m_dec.initializeIntDecorator("MC_Wdecay2_beforeFSR_from_t" +
                                 std::to_string(idx) + "_pdgId");
 
    m_dec.initializeIntDecorator("MC_t" + std::to_string(idx) +
                                 "_afterFSR_pdgId");
    m_dec.initializeIntDecorator("MC_b_afterFSR_from_t" + std::to_string(idx) +
                                 "_pdgId");
    m_dec.initializeIntDecorator("MC_W_afterFSR_from_t" + std::to_string(idx) +
                                 "_pdgId");
    m_dec.initializeIntDecorator("MC_Wdecay1_afterFSR_from_t" +
                                 std::to_string(idx) + "_pdgId");
    m_dec.initializeIntDecorator("MC_Wdecay2_afterFSR_from_t" +
                                 std::to_string(idx) + "_pdgId");
 
    m_dec.initializeIntDecorator("MC_tbar" + std::to_string(idx) +
                                 "_beforeFSR_pdgId");
    m_dec.initializeIntDecorator("MC_bbar_beforeFSR_from_tbar" +
                                 std::to_string(idx) + "_pdgId");
    m_dec.initializeIntDecorator("MC_W_beforeFSR_from_tbar" +
                                 std::to_string(idx) + "_pdgId");
    m_dec.initializeIntDecorator("MC_Wdecay1_beforeFSR_from_tbar" +
                                 std::to_string(idx) + "_pdgId");
    m_dec.initializeIntDecorator("MC_Wdecay2_beforeFSR_from_tbar" +
                                 std::to_string(idx) + "_pdgId");
 
    m_dec.initializeIntDecorator("MC_tbar" + std::to_string(idx) +
                                 "_afterFSR_pdgId");
    m_dec.initializeIntDecorator("MC_bbar_afterFSR_from_tbar" +
                                 std::to_string(idx) + "_pdgId");
    m_dec.initializeIntDecorator("MC_W_afterFSR_from_tbar" +
                                 std::to_string(idx) + "_pdgId");
    m_dec.initializeIntDecorator("MC_Wdecay1_afterFSR_from_tbar" +
                                 std::to_string(idx) + "_pdgId");
    m_dec.initializeIntDecorator("MC_Wdecay2_afterFSR_from_tbar" +
                                 std::to_string(idx) + "_pdgId");
  }
}

InitializeAntiBottomDecorators()

void CP::CalcPartonHistory::InitializeAntiBottomDecorators

(

)

Definition at line 171 of file PartonHistoryDecorators.cxx.

                                                       {
  m_dec.initializePtEtaPhiMDecorator("MC_bbar_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_bbar_afterFSR");
 
  m_dec.initializeIntDecorator("MC_bbar_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_bbar_afterFSR_pdgId");
}

InitializeAntiCharmDecorators()

void CP::CalcPartonHistory::InitializeAntiCharmDecorators

(

)

Definition at line 203 of file PartonHistoryDecorators.cxx.

                                                      {
  m_dec.initializePtEtaPhiMDecorator("MC_cbar_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_cbar_afterFSR");
 
  m_dec.initializeIntDecorator("MC_cbar_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_cbar_afterFSR_pdgId");
}

InitializeAntiTopDecorators()

void CP::CalcPartonHistory::InitializeAntiTopDecorators

(

)

Definition at line 129 of file PartonHistoryDecorators.cxx.

                                                    {
  m_dec.initializePtEtaPhiMDecorator("MC_tbar_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_bbar_beforeFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_W_beforeFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_Wdecay1_beforeFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_Wdecay2_beforeFSR_from_tbar");
 
  m_dec.initializePtEtaPhiMDecorator("MC_tbar_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_bbar_afterFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_W_afterFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_Wdecay1_afterFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_Wdecay2_afterFSR_from_tbar");
 
  m_dec.initializeIntDecorator("MC_tbar_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_bbar_beforeFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_W_beforeFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_Wdecay1_beforeFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_Wdecay2_beforeFSR_from_tbar_pdgId");
 
  m_dec.initializeIntDecorator("MC_tbar_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_bbar_afterFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_W_afterFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_Wdecay1_afterFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_Wdecay2_afterFSR_from_tbar_pdgId");
}

InitializeBottomDecorators()

void CP::CalcPartonHistory::InitializeBottomDecorators

(

)

Definition at line 155 of file PartonHistoryDecorators.cxx.

                                                   {
  m_dec.initializePtEtaPhiMDecorator("MC_b_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_b_afterFSR");
 
  m_dec.initializeIntDecorator("MC_b_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_b_afterFSR_pdgId");
}

InitializeCharmDecorators()

void CP::CalcPartonHistory::InitializeCharmDecorators

(

)

Definition at line 187 of file PartonHistoryDecorators.cxx.

                                                  {
  m_dec.initializePtEtaPhiMDecorator("MC_c_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_c_afterFSR");
 
  m_dec.initializeIntDecorator("MC_c_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_c_afterFSR_pdgId");
}

initializeDecorators()

void CP::CalcPartonHistory::initializeDecorators ( )

protectedvirtual

Definition at line 515 of file CalcPartonHistory.cxx.

                                             {
  if (!m_configured)
    return;
 
  for (const auto& group : m_config.decoratorGroups) {
    switch (group) {
      case DecoratorGroup::Top:
        InitializeTopDecorators();
        break;
      case DecoratorGroup::AntiTop:
        InitializeAntiTopDecorators();
        break;
      case DecoratorGroup::FourTop:
        Initialize4TopDecorators();
        break;
      case DecoratorGroup::Ttbar:
        InitializeTtbarDecorators();
        break;
      case DecoratorGroup::Bottom:
        InitializeBottomDecorators();
        break;
      case DecoratorGroup::AntiBottom:
        InitializeAntiBottomDecorators();
        break;
      case DecoratorGroup::VectorBottom:
        InitializeVectorBottomDecorators();
        break;
      case DecoratorGroup::VectorAntiBottom:
        InitializeVectorAntiBottomDecorators();
        break;
      case DecoratorGroup::Charm:
        InitializeCharmDecorators();
        break;
      case DecoratorGroup::AntiCharm:
        InitializeAntiCharmDecorators();
        break;
      case DecoratorGroup::VectorCharm:
        InitializeVectorCharmDecorators();
        break;
      case DecoratorGroup::VectorAntiCharm:
        InitializeVectorAntiCharmDecorators();
        break;
      case DecoratorGroup::Photon:
        InitializePhotonDecorators();
        break;
      case DecoratorGroup::Higgs:
        InitializeHiggsDecorators();
        break;
    }
  }
 
  for (const auto& zw : m_config.decoratorZWs) {
    if (zw.type == DecoratorZW::Z)
      InitializeZDecorators(zw.count, zw.extended);
    else
      InitializeWDecorators(zw.count);
  }
 
  for (const auto& fill : m_config.genericFills) {
    if (fill.isVector) {
      m_dec.initializeVectorPtEtaPhiMDecorator(fill.decorationKey);
      m_dec.initializeVectorIntDecorator(fill.decorationKey + "_pdgId");
    } else {
      m_dec.initializePtEtaPhiMDecorator(fill.decorationKey);
      m_dec.initializeIntDecorator(fill.decorationKey + "_pdgId");
    }
  }
}

InitializeHiggsDecorators()

void CP::CalcPartonHistory::InitializeHiggsDecorators

(

)

Definition at line 241 of file PartonHistoryDecorators.cxx.

                                                  {
  m_dec.initializePtEtaPhiMDecorator("MC_H_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay1_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay2_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay1_decay1_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay2_decay1_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay1_decay2_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay2_decay2_beforeFSR");
 
  m_dec.initializePtEtaPhiMDecorator("MC_H_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay1_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay2_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay1_decay1_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay2_decay1_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay1_decay2_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_Hdecay2_decay2_afterFSR");
 
  m_dec.initializeIntDecorator("MC_H_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay1_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay2_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay1_decay1_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay2_decay1_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay1_decay2_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay2_decay2_beforeFSR_pdgId");
 
  m_dec.initializeIntDecorator("MC_H_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay1_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay2_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay1_decay1_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay2_decay1_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay1_decay2_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_Hdecay2_decay2_afterFSR_pdgId");
}

InitializePhotonDecorators()

void CP::CalcPartonHistory::InitializePhotonDecorators

(

)

Definition at line 235 of file PartonHistoryDecorators.cxx.

                                                   {
  m_dec.initializePtEtaPhiMDecorator("MC_gamma");
  m_dec.initializeIntDecorator("MC_gamma_origin");
  m_dec.initializeIntDecorator("MC_gamma_pdgId");
}

InitializeTopDecorators()

void CP::CalcPartonHistory::InitializeTopDecorators

(

)

Definition at line 103 of file PartonHistoryDecorators.cxx.

                                                {
  m_dec.initializePtEtaPhiMDecorator("MC_t_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_b_beforeFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_W_beforeFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_Wdecay1_beforeFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_Wdecay2_beforeFSR_from_t");
 
  m_dec.initializePtEtaPhiMDecorator("MC_t_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_b_afterFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_W_afterFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_Wdecay1_afterFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_Wdecay2_afterFSR_from_t");
 
  m_dec.initializeIntDecorator("MC_t_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_b_beforeFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_W_beforeFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_Wdecay1_beforeFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_Wdecay2_beforeFSR_from_t_pdgId");
 
  m_dec.initializeIntDecorator("MC_t_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_b_afterFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_W_afterFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_Wdecay1_afterFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_Wdecay2_afterFSR_from_t_pdgId");
}

InitializeTtbarDecorators()

void CP::CalcPartonHistory::InitializeTtbarDecorators

(

)

Definition at line 219 of file PartonHistoryDecorators.cxx.

                                                  {
  m_dec.initializeFloatDecorator(
      {"MC_ttbar_beforeFSR_m", "MC_ttbar_beforeFSR_pt",
       "MC_ttbar_beforeFSR_eta", "MC_ttbar_beforeFSR_phi"});
  m_dec.initializeFloatDecorator(
      {"MC_ttbar_fromDecay_beforeFSR_m", "MC_ttbar_fromDecay_beforeFSR_pt",
       "MC_ttbar_fromDecay_beforeFSR_eta", "MC_ttbar_fromDecay_beforeFSR_phi"});
 
  m_dec.initializeFloatDecorator({"MC_ttbar_afterFSR_m", "MC_ttbar_afterFSR_pt",
                                  "MC_ttbar_afterFSR_eta",
                                  "MC_ttbar_afterFSR_phi"});
  m_dec.initializeFloatDecorator(
      {"MC_ttbar_fromDecay_afterFSR_m", "MC_ttbar_fromDecay_afterFSR_pt",
       "MC_ttbar_fromDecay_afterFSR_eta", "MC_ttbar_fromDecay_afterFSR_phi"});
}

InitializeVectorAntiBottomDecorators()

void CP::CalcPartonHistory::InitializeVectorAntiBottomDecorators

(

)

Definition at line 179 of file PartonHistoryDecorators.cxx.

                                                             {
  m_dec.initializeVectorPtEtaPhiMDecorator("MC_bbar_beforeFSR");
  m_dec.initializeVectorPtEtaPhiMDecorator("MC_bbar_afterFSR");
 
  m_dec.initializeVectorIntDecorator("MC_bbar_beforeFSR_pdgId");
  m_dec.initializeVectorIntDecorator("MC_bbar_afterFSR_pdgId");
}

InitializeVectorAntiCharmDecorators()

void CP::CalcPartonHistory::InitializeVectorAntiCharmDecorators

(

)

Definition at line 211 of file PartonHistoryDecorators.cxx.

                                                            {
  m_dec.initializeVectorPtEtaPhiMDecorator("MC_cbar_beforeFSR");
  m_dec.initializeVectorPtEtaPhiMDecorator("MC_cbar_afterFSR");
 
  m_dec.initializeVectorIntDecorator("MC_cbar_beforeFSR_pdgId");
  m_dec.initializeVectorIntDecorator("MC_cbar_afterFSR_pdgId");
}

InitializeVectorBottomDecorators()

void CP::CalcPartonHistory::InitializeVectorBottomDecorators

(

)

Definition at line 163 of file PartonHistoryDecorators.cxx.

                                                         {
  m_dec.initializeVectorPtEtaPhiMDecorator("MC_b_beforeFSR");
  m_dec.initializeVectorPtEtaPhiMDecorator("MC_b_afterFSR");
 
  m_dec.initializeVectorIntDecorator("MC_b_beforeFSR_pdgId");
  m_dec.initializeVectorIntDecorator("MC_b_afterFSR_pdgId");
}

InitializeVectorCharmDecorators()

void CP::CalcPartonHistory::InitializeVectorCharmDecorators

(

)

Definition at line 195 of file PartonHistoryDecorators.cxx.

                                                        {
  m_dec.initializeVectorPtEtaPhiMDecorator("MC_c_beforeFSR");
  m_dec.initializeVectorPtEtaPhiMDecorator("MC_c_afterFSR");
 
  m_dec.initializeVectorIntDecorator("MC_c_beforeFSR_pdgId");
  m_dec.initializeVectorIntDecorator("MC_c_afterFSR_pdgId");
}

InitializeWDecorators()

void CP::CalcPartonHistory::InitializeWDecorators

(

int

nWs = 1

)

Definition at line 334 of file PartonHistoryDecorators.cxx.

                                                      {
  std::vector<std::string> Ws;
  if (n_Ws == 1)
    Ws.push_back("W");
  else {
    for (int i = 1; i <= n_Ws; i++) {
      Ws.push_back("W" + std::to_string(i));
    }
  }
  for (auto& W : Ws) {
    m_dec.initializePtEtaPhiMDecorator("MC_" + W + "_beforeFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_" + W + "decay1_beforeFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_" + W + "decay2_beforeFSR");
 
    m_dec.initializePtEtaPhiMDecorator("MC_" + W + "_afterFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_" + W + "decay1_afterFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_" + W + "decay2_afterFSR");
 
    m_dec.initializeIntDecorator("MC_" + W + "_beforeFSR_pdgId");
    m_dec.initializeIntDecorator("MC_" + W + "decay1_beforeFSR_pdgId");
    m_dec.initializeIntDecorator("MC_" + W + "decay2_beforeFSR_pdgId");
 
    m_dec.initializeIntDecorator("MC_" + W + "_afterFSR_pdgId");
    m_dec.initializeIntDecorator("MC_" + W + "decay1_afterFSR_pdgId");
    m_dec.initializeIntDecorator("MC_" + W + "decay2_afterFSR_pdgId");
 
    m_dec.initializeIntDecorator("MC_" + W + "_IsOnShell");
  }
}

InitializeZDecorators()

void CP::CalcPartonHistory::InitializeZDecorators	(	int	nZs = 1,
		bool	extend = false )

Definition at line 275 of file PartonHistoryDecorators.cxx.

                                                                   {
  std::vector<std::string> Zs;
  if (n_Zs == 1)
    Zs.push_back("Z");
  else {
    for (int i = 1; i <= n_Zs; i++)
      Zs.push_back("Z" + std::to_string(i));
  }
  for (auto& Z : Zs) {
    m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "_beforeFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay1_beforeFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay2_beforeFSR");
 
    m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "_afterFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay1_afterFSR");
    m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay2_afterFSR");
 
    m_dec.initializeIntDecorator("MC_" + Z + "_beforeFSR_pdgId");
    m_dec.initializeIntDecorator("MC_" + Z + "decay1_beforeFSR_pdgId");
    m_dec.initializeIntDecorator("MC_" + Z + "decay2_beforeFSR_pdgId");
 
    m_dec.initializeIntDecorator("MC_" + Z + "_afterFSR_pdgId");
    m_dec.initializeIntDecorator("MC_" + Z + "decay1_afterFSR_pdgId");
    m_dec.initializeIntDecorator("MC_" + Z + "decay2_afterFSR_pdgId");
 
    if (extend) {
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay1_decay1_beforeFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay1_decay2_beforeFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay1_decay3_beforeFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay2_decay1_beforeFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay2_decay2_beforeFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay2_decay3_beforeFSR");
 
      m_dec.initializeIntDecorator("MC_" + Z + "decay1_decay1_beforeFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay1_decay2_beforeFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay1_decay3_beforeFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay2_decay1_beforeFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay2_decay2_beforeFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay2_decay3_beforeFSR_pdgId");
 
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay1_decay1_afterFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay1_decay2_afterFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay1_decay3_afterFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay2_decay1_afterFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay2_decay2_afterFSR");
      m_dec.initializePtEtaPhiMDecorator("MC_" + Z + "decay2_decay3_afterFSR");
 
      m_dec.initializeIntDecorator("MC_" + Z + "decay1_decay1_afterFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay1_decay2_afterFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay1_decay3_afterFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay2_decay1_afterFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay2_decay2_afterFSR_pdgId");
      m_dec.initializeIntDecorator("MC_" + Z + "decay2_decay3_afterFSR_pdgId");
    }
 
    m_dec.initializeIntDecorator("MC_" + Z + "_IsOnShell");
  }
}

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.

linkBosonCollections()

StatusCode CP::CalcPartonHistory::linkBosonCollections ( )

protected

currently in DAOD_PHYS TruthTop have links to Ws from the TruthBoson collection, which have no link to their decay products; we have therefore to associate the W from the TruthBoson collections to those in the TruthBosonsWithDecayParticles collection.

This method will use the helper method decorateCollectionWithLinksToAnotherCollection to decorate bosons in the TruthBoson collection with "CustomLinkedTruthBosonWithDecayParticles", which is a link to the same bosons in the TruthBosonsWithDecayParticles collection

Definition at line 458 of file CalcPartonHistory.cxx.

                                                   {
  return decorateCollectionWithLinksToAnotherCollection(
      "TruthBoson", "TruthBosonsWithDecayParticles",
      "CustomLinkedTruthBosonWithDecayParticles");
}

linkTruthContainers()

StatusCode CP::CalcPartonHistory::linkTruthContainers ( const xAOD::TruthParticleContainer *& tp )

protectedvirtual

Definition at line 495 of file CalcPartonHistory.cxx.

                                           {
  const std::string key = m_prefix + "_TruthParticles";
  if (!evtStore()->contains<xAOD::TruthParticleContainer>(key)) {
    const auto& collections =
        m_configured ? m_config.truthCollections : m_truthCollections;
    ANA_CHECK(buildContainerFromMultipleCollections(collections, key));
    ANA_CHECK(evtStore()->retrieve(tp, key));
    ANA_CHECK(linkBosonCollections());
    return StatusCode::SUCCESS;
  }
  ANA_CHECK(evtStore()->retrieve(tp, key));
  return StatusCode::SUCCESS;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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

operator=()

CalcPartonHistory & CP::CalcPartonHistory::operator= ( const CalcPartonHistory & rhs )

delete

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 AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, 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();
  }

Retrievep4() [1/2]

bool CP::CalcPartonHistory::Retrievep4	(	const std::string &	key,
		PtEtaPhiMVector &	p4 )

Definition at line 57 of file CalcPartonHistory.cxx.

                                                        {
  return Retrievep4(key, p4, 0);
}

Retrievep4() [2/2]

bool CP::CalcPartonHistory::Retrievep4	(	const std::string &	key,
		PtEtaPhiMVector &	p4,
		const int &	idx )

Definition at line 62 of file CalcPartonHistory.cxx.

                                                   {
  const auto* v = findVector(m_particleMap, key);
  if (!v || idx < 0)
    return false;
  const auto uidx = static_cast<std::size_t>(idx);
  if (uidx >= v->size())
    return false;
  p4 = GetPtEtaPhiMfromTruth(v->at(uidx));
  return true;
}

Retrievep4Gamma()

bool CP::CalcPartonHistory::Retrievep4Gamma	(	PtEtaPhiMVector &	p4,
		int &	parentpdgId )

Definition at line 74 of file CalcPartonHistory.cxx.

                                                                             {
  // Finds the highest-pT photon from any 'GammaRad' key in the m_particleMap.
  const xAOD::TruthParticle* bestPhoton = nullptr;
  for (const auto& [key, particles] : m_particleMap) {
    if (key.find("GammaRad") != std::string::npos) {
      auto it = std::max_element(
          particles.begin(), particles.end(),
          [](const auto* a, const auto* b) { return a->pt() < b->pt(); });
      if (it != particles.end() &&
          (!bestPhoton || (*it)->pt() > bestPhoton->pt()))
        bestPhoton = *it;
    }
  }
  if (!bestPhoton) {
    parentpdgId = 0;
    return false;
  }
  p4 = GetPtEtaPhiMfromTruth(bestPhoton);
  parentpdgId = bestPhoton->nParents() > 0 ? bestPhoton->parent(0)->pdgId() : 0;
  return true;
}

RetrieveParticleInfo() [1/5]

bool CP::CalcPartonHistory::RetrieveParticleInfo	(	const std::string &	prefix,
		const std::string &	alt_prefix,
		PtEtaPhiMVector &	particle,
		int &	pdgId )

Definition at line 160 of file CalcPartonHistory.cxx.

                                                         {
  if (Retrievep4(prefix, particle) && RetrievepdgId(prefix, pdgId))
    return true;
  return Retrievep4(alt_prefix, particle) && RetrievepdgId(alt_prefix, pdgId);
}

RetrieveParticleInfo() [2/5]

bool CP::CalcPartonHistory::RetrieveParticleInfo	(	const std::string &	prefix,
		PtEtaPhiMVector &	particle,
		int &	pdgId )

Definition at line 148 of file CalcPartonHistory.cxx.

                                                         {
  return RetrieveParticleInfo(prefix, particle, pdgId, 0);
}

RetrieveParticleInfo() [3/5]

bool CP::CalcPartonHistory::RetrieveParticleInfo	(	const std::string &	prefix,
		PtEtaPhiMVector &	particle,
		int &	pdgId,
		const int &	idx )

Definition at line 154 of file CalcPartonHistory.cxx.

                                                                         {
  return Retrievep4(prefix, particle, idx) && RetrievepdgId(prefix, pdgId, idx);
}

RetrieveParticleInfo() [4/5]

bool CP::CalcPartonHistory::RetrieveParticleInfo	(	const std::string &	prefix,
		std::vector< const xAOD::TruthParticle * > &	particles )

Definition at line 124 of file CalcPartonHistory.cxx.

                                                                       {
  const auto* v = findVector(m_particleMap, prefix);
  if (!v)
    return false;
  out.insert(out.end(), v->begin(), v->end());
  return true;
}

RetrieveParticleInfo() [5/5]

bool CP::CalcPartonHistory::RetrieveParticleInfo	(	const std::string &	prefix,
		std::vector< PtEtaPhiMVector > &	particles,
		std::vector< int > &	pdgIds )

Definition at line 133 of file CalcPartonHistory.cxx.

                            {
  const auto* v = findVector(m_particleMap, prefix);
  if (!v)
    return false;
  particles.reserve(particles.size() + v->size());
  pdgIds.reserve(pdgIds.size() + v->size());
  for (const auto* p : *v) {
    particles.push_back(GetPtEtaPhiMfromTruth(p));
    pdgIds.push_back(p->pdgId());
  }
  return true;
}

RetrievepdgId() [1/3]

bool CP::CalcPartonHistory::RetrievepdgId	(	const std::string &	key,
		int &	pdgId )

Definition at line 96 of file CalcPartonHistory.cxx.

                                                                      {
  return RetrievepdgId(key, pdgId, 0);
}

RetrievepdgId() [2/3]

bool CP::CalcPartonHistory::RetrievepdgId	(	const std::string &	key,
		int &	pdgId,
		const int &	idx )

Definition at line 112 of file CalcPartonHistory.cxx.

                                                      {
  const auto* v = findVector(m_particleMap, key);
  if (!v || idx < 0)
    return false;
  const auto uidx = static_cast<std::size_t>(idx);
  if (uidx >= v->size())
    return false;
  pdgId = v->at(uidx)->pdgId();
  return true;
}

RetrievepdgId() [3/3]

bool CP::CalcPartonHistory::RetrievepdgId	(	const std::string &	key,
		std::vector< int > &	pdgIds )

Definition at line 100 of file CalcPartonHistory.cxx.

                                                              {
  const auto* v = findVector(m_particleMap, key);
  if (!v)
    return false;
  pdgIds.reserve(pdgIds.size() + v->size());
  for (const auto* p : *v)
    if (p)
      pdgIds.push_back(p->pdgId());
  return true;
}

runHistorySaver()

StatusCode CP::CalcPartonHistory::runHistorySaver ( const xAOD::TruthParticleContainer * truthParticles, const xAOD::EventInfo * ttbarPartonHistory )

protectedvirtual

Definition at line 584 of file CalcPartonHistory.cxx.

                                        {
 
  // Register the EventInfo for this event; all m_dec.decorate*() calls
  // will write to it automatically.
  m_dec.setEventInfo(partonHistory);
 
  TraceParticles(truthParticles);
 
  for (const auto& op : m_config.specialFills) {
    switch (op.type) {
      case SpecialFillType::Top:
        FillTopPartonHistory();
        break;
      case SpecialFillType::AntiTop:
        FillAntiTopPartonHistory();
        break;
      case SpecialFillType::Ttbar:
        FillTtbarPartonHistory();
        break;
      case SpecialFillType::Z:
        FillZPartonHistory(op.parent, op.count, op.mode);
        break;
      case SpecialFillType::Ztautau:
        FillZtautauPartonHistory(op.parent, op.count, op.mode);
        break;
      case SpecialFillType::W:
        FillWPartonHistory(op.parent, op.count, op.mode);
        break;
      case SpecialFillType::Higgs:
        FillHiggsPartonHistory(op.mode);
        break;
      case SpecialFillType::Gamma:
        FillGammaPartonHistory(op.parent);
        break;
    }
  }
 
  for (const auto& fill : m_config.genericFills) {
    if (fill.isVector) {
      FillGenericVectorPartonHistory(fill.retrievalKeys.at(0),
                                     fill.decorationKey);
    } else if (fill.retrievalKeys.size() == 1) {
      FillGenericPartonHistory(fill.retrievalKeys.at(0), fill.decorationKey,
                               fill.idx);
    } else {
      FillGenericPartonHistory(fill.retrievalKeys, fill.decorationKey,
                               fill.idx);
    }
  }
 
  return StatusCode::SUCCESS;
}

setHiggs()

void CP::CalcPartonHistory::setHiggs

(

const std::string &

fsr

)

Definition at line 16 of file CalcHiggsPartonHistory.cxx.

                                                     {
  PtEtaPhiMVector H;
  PtEtaPhiMVector Wm, Wm_decay1, Wm_decay2;
  PtEtaPhiMVector Wp, Wp_decay1, Wp_decay2;
  int Wm_decay1_pdgId, Wm_decay2_pdgId;
  int Wp_decay1_pdgId, Wp_decay2_pdgId;
 
  // W+: pass full m_particleMap keys to getW; bare names to m_dec.*
  bool has_Wp =
      getW(m_prefix + "_" + "MC_lbar_" + fsr, m_prefix + "_" + "MC_nu_" + fsr,
           Wp_decay1, Wp_decay1_pdgId, Wp_decay2, Wp_decay2_pdgId);
  if (has_Wp) {
    Wp = Wp_decay1 + Wp_decay2;
    m_dec.decorateParticle("MC_Hdecay1_" + fsr, Wp, 24);
    m_dec.decorateParticle("MC_Hdecay1_decay1_" + fsr, Wp_decay1,
                           Wp_decay1_pdgId);
    m_dec.decorateParticle("MC_Hdecay1_decay2_" + fsr, Wp_decay2,
                           Wp_decay2_pdgId);
  }
  // W-
  bool has_Wm =
      getW(m_prefix + "_" + "MC_l_" + fsr, m_prefix + "_" + "MC_nubar_" + fsr,
           Wm_decay1, Wm_decay1_pdgId, Wm_decay2, Wm_decay2_pdgId);
  if (has_Wm) {
    Wm = Wm_decay1 + Wm_decay2;
    m_dec.decorateParticle("MC_Hdecay2_" + fsr, Wm, -24);
    m_dec.decorateParticle("MC_Hdecay2_decay1_" + fsr, Wm_decay1,
                           Wm_decay1_pdgId);
    m_dec.decorateParticle("MC_Hdecay2_decay2_" + fsr, Wm_decay2,
                           Wm_decay2_pdgId);
  }
  if (has_Wm && has_Wp) {
    H = Wp + Wm;
    m_dec.decorateParticle("MC_H_" + fsr, H, 25);
  }
}

setW()

void CP::CalcPartonHistory::setW	(	const std::string &	fsr,
		int	nWs )

Definition at line 61 of file CalcWPartonHistory.cxx.

                                                          {
  PtEtaPhiMVector W;
  PtEtaPhiMVector Wm, Wm_decay1, Wm_decay2;
  PtEtaPhiMVector Wp, Wp_decay1, Wp_decay2;
  int Wm_decay1_pdgId, Wm_decay2_pdgId;
  int Wp_decay1_pdgId, Wp_decay2_pdgId;
 
  if (nWs == 1) {
    // W+: pass full m_particleMap keys to getW; bare names to m_dec.*
    bool has_Wp =
        getW(m_prefix + "_" + "MC_lbar_" + fsr, m_prefix + "_" + "MC_nu_" + fsr,
             Wp_decay1, Wp_decay1_pdgId, Wp_decay2, Wp_decay2_pdgId);
    if (has_Wp) {
      Wp = Wp_decay1 + Wp_decay2;
      m_dec.decorateParticle("MC_W_" + fsr, Wp, 24);
      m_dec.decorateParticle("MC_Wdecay1_" + fsr, Wp_decay1, Wp_decay1_pdgId);
      m_dec.decorateParticle("MC_Wdecay2_" + fsr, Wp_decay2, Wp_decay2_pdgId);
    }
    // W-
    bool has_Wm =
        getW(m_prefix + "_" + "MC_l_" + fsr, m_prefix + "_" + "MC_nubar_" + fsr,
             Wm_decay1, Wm_decay1_pdgId, Wm_decay2, Wm_decay2_pdgId);
    if (has_Wm) {
      Wm = Wm_decay1 + Wm_decay2;
      m_dec.decorateParticle("MC_W_" + fsr, Wm, -24);
      m_dec.decorateParticle("MC_Wdecay1_" + fsr, Wm_decay1, Wm_decay1_pdgId);
      m_dec.decorateParticle("MC_Wdecay2_" + fsr, Wm_decay2, Wm_decay2_pdgId);
    }
  } else if (nWs == 2) {
    // W+
    bool has_Wp =
        getW(m_prefix + "_" + "MC_lbar_" + fsr, m_prefix + "_" + "MC_nu_" + fsr,
             Wp_decay1, Wp_decay1_pdgId, Wp_decay2, Wp_decay2_pdgId);
    if (has_Wp) {
      Wp = Wp_decay1 + Wp_decay2;
      m_dec.decorateParticle("MC_W1_" + fsr, Wp, 24);
      m_dec.decorateParticle("MC_W1decay1_" + fsr, Wp_decay1, Wp_decay1_pdgId);
      m_dec.decorateParticle("MC_W1decay2_" + fsr, Wp_decay2, Wp_decay2_pdgId);
    }
    // W-
    bool has_Wm =
        getW(m_prefix + "_" + "MC_l_" + fsr, m_prefix + "_" + "MC_nubar_" + fsr,
             Wm_decay1, Wm_decay1_pdgId, Wm_decay2, Wm_decay2_pdgId);
    if (has_Wm) {
      Wm = Wm_decay1 + Wm_decay2;
      m_dec.decorateParticle("MC_W2_" + fsr, Wm, -24);
      m_dec.decorateParticle("MC_W2decay1_" + fsr, Wm_decay1, Wm_decay1_pdgId);
      m_dec.decorateParticle("MC_W2decay2_" + fsr, Wm_decay2, Wm_decay2_pdgId);
    }
  }
}

setZ()

void CP::CalcPartonHistory::setZ	(	const std::string &	fsr,
		int	nZs )

Definition at line 152 of file CalcZPartonHistory.cxx.

                                                          {
  PtEtaPhiMVector Z, Z_decay1, Z_decay2;
  int Z_decay1_pdgId, Z_decay2_pdgId;
  m_dec.decorateCustom("MC_Z_IsOnShell", 0);
  // getZ receives full m_particleMap keys; m_dec.decorate* receives bare names.
  bool has_Z =
      getZ(m_prefix + "_" + "MC_l_" + fsr, m_prefix + "_" + "MC_lbar_" + fsr,
           Z_decay1, Z_decay1_pdgId, Z_decay2, Z_decay2_pdgId);
  if (nZs == 1) {
    if (has_Z) {
      Z = Z_decay1 + Z_decay2;
      m_dec.decorateParticle("MC_Z_" + fsr, Z, 23);
      m_dec.decorateParticle("MC_Zdecay1_" + fsr, Z_decay1, Z_decay1_pdgId);
      m_dec.decorateParticle("MC_Zdecay2_" + fsr, Z_decay2, Z_decay2_pdgId);
    }
  } else
    ANA_MSG_ERROR("Reconstruction of multiple Zs is not supported yet!");
}

setZtautau()

void CP::CalcPartonHistory::setZtautau	(	const std::string &	fsr,
		int	nZs )

Definition at line 172 of file CalcZPartonHistory.cxx.

                                                                {
  PtEtaPhiMVector Z, Zdecay1, Zdecay2;
  PtEtaPhiMVector Zdecay1_decay1, Zdecay1_decay2, Zdecay1_decay3;
  PtEtaPhiMVector Zdecay2_decay1, Zdecay2_decay2, Zdecay2_decay3;
  int Zdecay1_pdgId = 0, Zdecay2_pdgId = 0;
  int Zdecay1_decay1_pdgId = 0, Zdecay1_decay2_pdgId = 0,
      Zdecay1_decay3_pdgId = 0;
  int Zdecay2_decay1_pdgId = 0, Zdecay2_decay2_pdgId = 0,
      Zdecay2_decay3_pdgId = 0;
 
  bool has_Z =
      getZFromTaus(fsr, Zdecay1, Zdecay1_pdgId, Zdecay2, Zdecay2_pdgId,
                   Zdecay1_decay1, Zdecay1_decay1_pdgId, Zdecay1_decay2,
                   Zdecay1_decay2_pdgId, Zdecay1_decay3, Zdecay1_decay3_pdgId,
                   Zdecay2_decay1, Zdecay2_decay1_pdgId, Zdecay2_decay2,
                   Zdecay2_decay2_pdgId, Zdecay2_decay3, Zdecay2_decay3_pdgId);
  if (nZs == 1) {
    if (has_Z) {
      Z = Zdecay1 + Zdecay2;
      m_dec.decorateParticle("MC_Z_" + fsr, Z, 23);
      m_dec.decorateParticle("MC_Zdecay1_" + fsr, Zdecay1, Zdecay1_pdgId);
      m_dec.decorateParticle("MC_Zdecay2_" + fsr, Zdecay2, Zdecay2_pdgId);
      m_dec.decorateParticle("MC_Zdecay1_decay1_" + fsr, Zdecay1_decay1,
                             Zdecay1_decay1_pdgId);
      m_dec.decorateParticle("MC_Zdecay2_decay1_" + fsr, Zdecay2_decay1,
                             Zdecay2_decay1_pdgId);
      m_dec.decorateParticle("MC_Zdecay1_decay2_" + fsr, Zdecay1_decay2,
                             Zdecay1_decay2_pdgId);
      m_dec.decorateParticle("MC_Zdecay2_decay2_" + fsr, Zdecay2_decay2,
                             Zdecay2_decay2_pdgId);
      m_dec.decorateParticle("MC_Zdecay1_decay3_" + fsr, Zdecay1_decay3,
                             Zdecay1_decay3_pdgId);
      m_dec.decorateParticle("MC_Zdecay2_decay3_" + fsr, Zdecay2_decay3,
                             Zdecay2_decay3_pdgId);
    }
  } else
    ANA_MSG_ERROR("Reconstruction of multiple Zs is not supported yet!");
}

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

TraceParticle()

void CP::CalcPartonHistory::TraceParticle	(	const xAOD::TruthParticle *	particle,
		std::vector< const xAOD::TruthParticle * > &	currentPath,
		std::vector< std::vector< const xAOD::TruthParticle * > > &	allPaths )

Definition at line 191 of file CalcPartonHistory.cxx.

                                                              {
  // Recursively builds decay paths from p down to stable particles.
  // Each completed root-to-leaf path is appended to allPaths and later
  // processed by FillParticleMap to assign m_particleMap keys.
  //
  // FSR handling: a particle that radiates before decaying appears as a chain
  // of identical PDG-ID nodes (e.g. t → t → t → W b). findAfterFSR() follows
  // that chain to the last node before the actual decay vertex, so the path
  // records the pre- and post-FSR instances rather than every intermediate.
  //
  // W linking (DAOD_PHYS only): TruthTop links to Ws in TruthBoson, which
  // carry no decay products. When we encounter such a W (isAfterFSR &&
  // |pdg|==24) we swap it for the corresponding entry in
  // TruthBosonsWithDecayParticles via the
  // "CustomLinkedTruthBosonWithDecayParticles" decoration so that the subsequent
  // child traversal finds the W decay products.
  if (!p || PartonHistoryUtils::isBrokenTop(p))
    return;
 
  // If this W node has no identical child (i.e. it is the after-FSR instance)
  // but lacks decay products, swap to the linked decay-product-bearing copy.
  if (PartonHistoryUtils::isAfterFSR(p) && std::abs(p->pdgId()) == 24) {
    p = getTruthParticleLinkedFromDecoration(
        p, "CustomLinkedTruthBosonWithDecayParticles");
  }
 
  path.push_back(p);
 
  // Leaf node: record the completed path.
  if (p->nChildren() == 0) {
    allPaths.push_back(path);
    path.pop_back();
    return;
  }
 
  const xAOD::TruthParticle* afterFSR = PartonHistoryUtils::findAfterFSR(p);
  // Same W-linking fix for the after-FSR node reached by findAfterFSR().
  if (std::abs(afterFSR->pdgId()) == 24) {
    afterFSR = getTruthParticleLinkedFromDecoration(
        afterFSR, "CustomLinkedTruthBosonWithDecayParticles");
  }
 
  if (afterFSR != p) {
    // There was FSR: continue the path from the post-FSR node.
    TraceParticle(afterFSR, path, allPaths);
  } else {
    // No FSR: branch into each child (e.g. W→lν gives two sub-paths).
    for (std::size_t i = 0; i < afterFSR->nChildren(); ++i) {
      if (const auto* c = afterFSR->child(i))
        TraceParticle(c, path, allPaths);
    }
  }
  path.pop_back();
}

TraceParticles()

void CP::CalcPartonHistory::TraceParticles

(

const xAOD::TruthParticleContainer *

truthParticles

)

Definition at line 378 of file CalcPartonHistory.cxx.

                                                      {
  std::vector<std::vector<const xAOD::TruthParticle*>> allPaths;
  allPaths.reserve(truthParticles->size());
  for (const xAOD::TruthParticle* p : *truthParticles) {
    if (PartonHistoryUtils::hasParticleIdenticalParent(p))
      continue;
    std::vector<const xAOD::TruthParticle*> path;
    path.reserve(16);
    TraceParticle(p, path, allPaths);
  }
  FillParticleMap(allPaths);
}

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_config

PartonSchemeConfig CP::CalcPartonHistory::m_config

protected

scheme configuration set via configure()

Definition at line 175 of file CalcPartonHistory.h.

m_configured

bool CP::CalcPartonHistory::m_configured = false

protected

true after configure() has been called

Definition at line 176 of file CalcPartonHistory.h.

m_dec

PartonDecorator CP::CalcPartonHistory::m_dec

protected

Definition at line 157 of file CalcPartonHistory.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_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_particleMap

std::map<std::string, std::vector<const xAOD::TruthParticle*> > CP::CalcPartonHistory::m_particleMap

protected

Definition at line 156 of file CalcPartonHistory.h.

m_prefix

std::string CP::CalcPartonHistory::m_prefix

protected

prefix applied to all decorator and m_particleMap names

Definition at line 161 of file CalcPartonHistory.h.

m_truthCollections

const std::vector<std::string> CP::CalcPartonHistory::m_truthCollections

protected

Definition at line 159 of file CalcPartonHistory.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.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:

• CalcPartonHistory.h
• CalcGenericPartonHistory.cxx
• CalcHiggsPartonHistory.cxx
• CalcPartonHistory.cxx
• CalcPhotonPartonHistory.cxx
• CalcTopPartonHistory.cxx
• CalcWPartonHistory.cxx
• CalcZPartonHistory.cxx
• PartonHistoryDecorators.cxx