CP::CalcPartonHistory Class Reference

#include <CalcPartonHistory.h>

Inheritance diagram for CP::CalcPartonHistory:

Collaboration diagram for CP::CalcPartonHistory:

Classes
struct	ZTauTauProduct
	One Z->tautau decay product: kinematics, PDG ID and whether it was found. More...
struct	ZTauTauDecay
	Z->tautau decay chain: taus[0] = tau- (Zdecay1), taus[1] = tau+ (Zdecay2); tauDecays[i][j] = decay product j+1 of taus[i]. More...

Public Member Functions
	CalcPartonHistory (const std::string &name, const std::vector< std::string > &truthCollections={"TruthTop"})
virtual	~CalcPartonHistory ()=default
	CalcPartonHistory (const CalcPartonHistory &rhs)=delete
	CalcPartonHistory (CalcPartonHistory &&rhs)=delete
CalcPartonHistory &	operator= (const CalcPartonHistory &rhs)=delete
CalcPartonHistory &	operator= (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, std::size_t 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, std::size_t 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, std::size_t 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 (bool fcnc=false)
void	InitializeAntiTopDecorators (bool fcnc=false)
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)
void	handleFSR (const xAOD::TruthParticle *particle, const std::string &newKey, std::string &key)
bool	handleDecay (const xAOD::TruthParticle *particle, std::string &key, int decayID)
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 ()
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	FillXPartonHistory (const std::string &parent, const std::string &symbolX)
void	FillTopPartonHistory (bool fcnc=false)
void	FillAntiTopPartonHistory (bool fcnc=false)
void	FillHiggsPartonHistory (const std::string &mode)
void	FillTtbarPartonHistory (bool fcnc=false)
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)
ZTauTauDecay	getZFromTaus (const std::string &fsr)
void	configure (const PartonSchemeConfig &config)
virtual StatusCode	initialize () override
	Dummy implementation of the initialisation function.
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
Gaudi::Property< std::string >	m_prefix
Gaudi::Property< std::string >	m_symbolFCNC
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 28 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 40 of file CalcPartonHistory.cxx.

    : asg::AsgTool(name), m_truthCollections(truthCollection) {}

~CalcPartonHistory()

virtual CP::CalcPartonHistory::~CalcPartonHistory ( )

virtualdefault

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 246 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 372 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.
  auto out_cont =
      std::make_unique<ConstDataVector<DataVector<xAOD::TruthParticle_v1>>>(
          SG::VIEW_ELEMENTS);
  std::vector<const xAOD::TruthParticle*> p_candidates;
  std::vector<const xAOD::TruthParticle*> p_parents;
  std::unordered_set<int> candidateUids;
 
  for (const std::string& collection : collections) {
    const xAOD::TruthParticleContainer* cont = nullptr;
    ANA_CHECK(evtStore()->retrieve(cont, collection));
    for (const xAOD::TruthParticle* p : *cont) {
      if (p) {
        p_candidates.push_back(p);
        candidateUids.insert(p->uid());
      }
    }
  }
  // Collect the uids of all candidates that descend from another (non-PDF)
  // candidate, walking the decay tree of each candidate once. All copies of
  // duplicated particles are walked, as their navigation links may differ.
  std::unordered_set<int> descendantUids;
  std::vector<const xAOD::TruthParticle*> stack;
  for (const xAOD::TruthParticle* ancestor : p_candidates) {
    if (PartonHistoryUtils::isQuarkFromPDF(ancestor))
      continue;
    stack.assign(1, ancestor);
    while (!stack.empty()) {
      const xAOD::TruthParticle* p = stack.back();
      stack.pop_back();
      for (std::size_t i = 0; i < p->nChildren(); ++i) {
        const xAOD::TruthParticle* child = p->child(i);
        if (!child)
          continue;
        if (candidateUids.count(child->uid()))
          descendantUids.insert(child->uid());
        stack.push_back(child);
      }
    }
  }
  // Retain only particles that have no ancestor among the other candidates.
  // Particles present in several collections (same uid) are kept only once,
  // using the copy from the first collection that contains them.
  std::unordered_set<int> rootUids;
  for (const xAOD::TruthParticle* potential_parent : p_candidates) {
    if (!PartonHistoryUtils::isQuarkFromPDF(potential_parent) &&
        !descendantUids.count(potential_parent->uid()) &&
        rootUids.insert(potential_parent->uid()).second)
      p_parents.push_back(potential_parent);
  }
  out_cont->insert(out_cont->end(), p_parents.begin(), p_parents.end());
  StatusCode save = TDS()->record(std::move(out_cont), out_contName);
  if (!save)
    return StatusCode::FAILURE;
  return StatusCode::SUCCESS;
}

configure()

void CP::CalcPartonHistory::configure

(

const PartonSchemeConfig &

config

)

Definition at line 495 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 448 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));
  std::unordered_map<int, const xAOD::TruthParticle*> byUid;
  byUid.reserve(cont2->size());
  for (const auto* q : *cont2)
    byUid.emplace(q->uid(), q);
  for (const auto* p : *cont1) {
    const xAOD::TruthParticle* link = nullptr;
    auto it = byUid.find(p->uid());
    if (it != byUid.end() && it->second->pdgId() == p->pdgId())
      link = it->second;
    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

(

)

Definition at line 361 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 49 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 44 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

(

bool

fcnc = false

)

Definition at line 73 of file CalcTopPartonHistory.cxx.

                                                          {
  FillGenericPartonHistory("MC_tbar_beforeFSR", "MC_tbar_beforeFSR", 0);
  FillGenericPartonHistory("MC_tbar_afterFSR", "MC_tbar_afterFSR", 0);
  if (fcnc) {
    PtEtaPhiMVector v;
    int pdgId = 0;
    const std::array<std::string, 2> fsrStates{ "beforeFSR", "afterFSR" };
    const std::array<std::string, 3> flavors{ "bbar", "cbar", "ubar" }; // "ubar" kept for future-proofing
 
    for (const auto& fsrState : fsrStates) {
      const auto outputTag = "MC_qbar_" + fsrState + "_from_tbar";
      bool found = false;
      for (const auto& flavor : flavors) {
        const auto key = m_prefix + "_" + ("MC_tbar_" + flavor + "_" + fsrState);
        if (RetrieveParticleInfo(key, v, pdgId)) {
          m_dec.decorateParticle(outputTag, v, pdgId);
          found = true;
          break;
        }
      }
      if (!found) m_dec.decorateDefault(outputTag);
    }
    FillXPartonHistory("tbar", m_symbolFCNC);
  } else {
    FillGenericPartonHistory("MC_tbar_bbar_beforeFSR",
                             "MC_bbar_beforeFSR_from_tbar", 0);
    FillGenericPartonHistory("MC_tbar_bbar_afterFSR",
                             "MC_bbar_afterFSR_from_tbar", 0);
    FillWPartonHistory("tbar");
  }
}

FillGammaPartonHistory()

void CP::CalcPartonHistory::FillGammaPartonHistory

(

)

Definition at line 14 of file CalcPhotonPartonHistory.cxx.

                                               {
  PtEtaPhiMVector gamma;
  int gamma_origin = 0;
 
  m_dec.decorateDefault("MC_gamma");
 
  if (Retrievep4Gamma(gamma, gamma_origin))
    m_dec.decorateParticle("MC_gamma", 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 56 of file CalcHiggsPartonHistory.cxx.

                                                                    {
  // {particle map key, decoration name}, both without the "MC_" prefix and
  // the FSR-stage suffix.
  static constexpr std::array<std::pair<const char*, const char*>, 7>
      higgsParticles{{{"H", "H"},
                      {"HDecay1", "Hdecay1"},
                      {"HDecay2", "Hdecay2"},
                      {"HDecay1Decay1", "Hdecay1_decay1"},
                      {"HDecay1Decay2", "Hdecay1_decay2"},
                      {"HDecay2Decay1", "Hdecay2_decay1"},
                      {"HDecay2Decay2", "Hdecay2_decay2"}}};
  static constexpr std::array<const char*, 2> fsrStages{
      {"_beforeFSR", "_afterFSR"}};
 
  // Defaults for all branches regardless of mode.
  for (const char* fsr : fsrStages)
    for (const auto& [key, decoration] : higgsParticles)
      m_dec.decorateDefault("MC_" + std::string(decoration) + fsr);
 
  if (mode == "resonant" || mode == "single_top") {
    // FillGenericPartonHistory retrieval strings are bare suffixes.
    for (const char* fsr : fsrStages) {
      for (const auto& [key, decoration] : higgsParticles) {
        const std::string decorationName =
            "MC_" + std::string(decoration) + fsr;
        if (mode == "resonant") {
          FillGenericPartonHistory("MC_" + std::string(key) + fsr,
                                   decorationName, 0);
        } else {
          FillGenericPartonHistory({"MC_" + std::string(key) + fsr,
                                    "MC_b_" + std::string(key) + fsr,
                                    "MC_bbar_" + std::string(key) + fsr},
                                   decorationName, 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 282 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".
  //
  // Handlers (first match wins for each particle in the path):
  //   handleDecay — daughters of W/Z/H: appends "Decay<N>" and records
  //                 beforeFSR/afterFSR
  //   handleFSR   — all other particles: the first copy of an FSR chain
  //                 appends the type suffix and records beforeFSR (and
  //                 afterFSR if it does not radiate); the last copy (same PDG
  //                 as parent) records afterFSR under the current key
  m_particleMap.clear();
 
  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;
      handleFSR(p, new_key, key);
    }
  }
}

FillTopPartonHistory()

void CP::CalcPartonHistory::FillTopPartonHistory

(

bool

fcnc = false

)

Definition at line 43 of file CalcTopPartonHistory.cxx.

                                                      {
  FillGenericPartonHistory("MC_t_beforeFSR", "MC_t_beforeFSR", 0);
  FillGenericPartonHistory("MC_t_afterFSR", "MC_t_afterFSR", 0);
  if (fcnc) {
    PtEtaPhiMVector v;
    int pdgId = 0;
    const std::array<std::string, 2> fsrStates{ "beforeFSR", "afterFSR" };
    const std::array<std::string, 3> flavors{ "b", "c", "u" }; // The u-quark is currently not stored in the DAOD_PHYS
                                                                           // truth record, but it's kept here for future-proofing.
    for (const auto& fsrState : fsrStates) {
      const auto outputTag = "MC_q_" + fsrState + "_from_t";
      bool found = false;
      for (const auto& flavor : flavors) {
        const auto key = m_prefix + "_" + ("MC_t_" + flavor + "_" + fsrState);
        if (RetrieveParticleInfo(key, v, pdgId)) {
          m_dec.decorateParticle(outputTag, v, pdgId);
          found = true;
          break;
        }
      }
      if (!found) m_dec.decorateDefault(outputTag);
    }
    FillXPartonHistory("t", m_symbolFCNC);
  } else {
    FillGenericPartonHistory("MC_t_b_beforeFSR", "MC_b_beforeFSR_from_t", 0);
    FillGenericPartonHistory("MC_t_b_afterFSR", "MC_b_afterFSR_from_t", 0);
    FillWPartonHistory("t");
  }
}

FillTtbarPartonHistory()

void CP::CalcPartonHistory::FillTtbarPartonHistory

(

bool

fcnc = false

)

Definition at line 105 of file CalcTopPartonHistory.cxx.

                                                        {
  std:: string qSymbol = fcnc ? "q" : "b";
  std:: string qbarSymbol = fcnc ? "qbar" : "bbar";
  std::string bosonSymbol = fcnc ? "X" : "W";
  // 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_" + bosonSymbol + "Decay1_beforeFSR", WpDecay1) &&
      Retrievep4(m_prefix + "_" + "MC_t_" + bosonSymbol + "Decay2_beforeFSR", WpDecay2) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_" + bosonSymbol + "Decay1_beforeFSR", WmDecay1) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_" + bosonSymbol + "Decay2_beforeFSR", WmDecay2) &&
      Retrievep4(m_prefix + "_" + "MC_t_" + qSymbol + "_beforeFSR", b) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_" + qbarSymbol + "_beforeFSR", bbar)) {
    ttbar = WpDecay1 + WpDecay2 + WmDecay1 + WmDecay2 + b + bbar;
    m_dec.decorateParticle("MC_ttbar_fromDecay_beforeFSR", ttbar);
  }
 
  if (Retrievep4(m_prefix + "_" + "MC_t_" + bosonSymbol + "Decay1_afterFSR", WpDecay1) &&
      Retrievep4(m_prefix + "_" + "MC_t_" + bosonSymbol + "Decay2_afterFSR", WpDecay2) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_" + bosonSymbol + "Decay1_afterFSR", WmDecay1) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_" + bosonSymbol + "Decay2_afterFSR", WmDecay2) &&
      Retrievep4(m_prefix + "_" + "MC_t_" + qSymbol + "_afterFSR", b) &&
      Retrievep4(m_prefix + "_" + "MC_tbar_" + qbarSymbol + "_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 114 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) {
      if (parent.empty())
        m_dec.decorateCustom(
            "MC_W_IsOnShell",
            ExistsInMap(m_prefix + "_" + prefix + "_beforeFSR") ? 1 : 0);
      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);
        if (parent.empty())
          m_dec.decorateCustom("MC_W" + idxStr + "_IsOnShell", 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") {
    if (parent.empty()) {
      if (nWs == 1) {
        m_dec.decorateCustom("MC_W_IsOnShell", 0);
      } else {
        for (int idx = 0; idx < nWs; idx++)
          m_dec.decorateCustom("MC_W" + std::to_string(idx + 1) + "_IsOnShell",
                               0);
      }
    }
    setW("beforeFSR", nWs);
    setW("afterFSR", nWs);
  }
}

FillXPartonHistory()

void CP::CalcPartonHistory::FillXPartonHistory	(	const std::string &	parent,
		const std::string &	symbolX )

Definition at line 17 of file CalcTopPartonHistory.cxx.

                                                                     {
  PtEtaPhiMVector v;
  int pdgId = 0;
  const std::array<std::string, 2> fsrStates{ "beforeFSR", "afterFSR" };
  const std::array<std::pair<std::string, std::string>, 3> particleTags{{
    {"", "X"},
    {"Decay1", "Xdecay1"},
    {"Decay2", "Xdecay2"},
  }};
 
  for (const auto& fsrState : fsrStates) {
    for (const auto& [sourceSuffix, outputSuffix] : particleTags) {
      const auto outputTag = "MC_" + outputSuffix + "_" + fsrState + "_from_" + parent;
      const auto sourcePrefix = "MC_" + parent + "_";
 
      if (RetrieveParticleInfo(m_prefix + "_" + sourcePrefix + "W" + sourceSuffix + "_" + fsrState, v, pdgId))
        m_dec.decorateParticle(outputTag, v, pdgId);
      else if (RetrieveParticleInfo(m_prefix + "_" + sourcePrefix + symbolX + sourceSuffix + "_" + fsrState, v, pdgId))
        m_dec.decorateParticle(outputTag, v, pdgId);
      else
        m_dec.decorateDefault(outputTag);
    }
  }
}

FillZPartonHistory()

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

Definition at line 175 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 237 of file CalcZPartonHistory.cxx.

                                                                        {
  std::string parentstring = parent.empty() ? "" : "_from_" + parent;
  // 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 167 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 471 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 the neutrino must
        // be that of the lepton plus 1 (11 & 12, 13 & 14, 15 & 16); a
        // symmetric difference would also accept e.g. (mu, nu_e).
        if (particle_2->absPdgId() - particle_1->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 20 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. Returns the first pair that passes all
  // conditions (same convention as getW).
  static const SG::ConstAccessor<unsigned int> acc_classifierParticleOrigin(
      "classifierParticleOrigin");
  static const SG::ConstAccessor<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) {
    for (const auto* pDecay1 : Z_offshell_decay1_candidates) {
      for (const auto* pDecay2 : Z_offshell_decay2_candidates) {
        // 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;
        // Leptons without MCTruthClassifier decorations cannot be classified
        // and are skipped.
        if (!acc_classifierParticleOrigin.isAvailable(*pDecay1) ||
            !acc_classifierParticleOrigin.isAvailable(*pDecay2) ||
            !acc_classifierParticleType.isAvailable(*pDecay1) ||
            !acc_classifierParticleType.isAvailable(*pDecay2))
          continue;
        const unsigned int o1 = acc_classifierParticleOrigin(*pDecay1);
        const unsigned int o2 = acc_classifierParticleOrigin(*pDecay2);
        const unsigned int t1 = acc_classifierParticleType(*pDecay1);
        const unsigned int t2 = acc_classifierParticleType(*pDecay2);
        // Condition 3: Origin ZBoson from MCTruthClassifier. 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 == MCTruthPartClassifier::ZBoson &&
              o2 == MCTruthPartClassifier::ZBoson))
          continue;
        // Condition 4: Type IsoElectron or IsoMuon from MCTruthClassifier.
        // Selects prompt isolated leptons, rejecting non-isolated or
        // non-prompt contributions.
        if (!((t1 == MCTruthPartClassifier::IsoElectron &&
               t2 == MCTruthPartClassifier::IsoElectron) ||
              (t1 == MCTruthPartClassifier::IsoMuon &&
               t2 == MCTruthPartClassifier::IsoMuon)))
          continue;
 
        p1 = GetPtEtaPhiMfromTruth(pDecay1);
        pdgId1 = pDecay1->pdgId();
        p2 = GetPtEtaPhiMfromTruth(pDecay2);
        pdgId2 = pDecay2->pdgId();
        return true;
      }
    }
  }
  return false;
}

getZFromTaus()

CalcPartonHistory::ZTauTauDecay CP::CalcPartonHistory::getZFromTaus

(

const std::string &

fsr

)

Definition at line 88 of file CalcZPartonHistory.cxx.

                          {
  // taus[0] is the tau- ("l"), taus[1] the tau+ ("lbar"). Their decay
  // products decay1..3 are the charged lepton followed by the two neutrinos.
  // All keys are full m_particleMap keys once the prefix is prepended.
  static constexpr std::array<const char*, 2> tauKeys{{"MC_l_", "MC_lbar_"}};
  static constexpr std::array<std::array<const char*, 3>, 2> tauDecayKeys{
      {{{"MC_l_l_", "MC_l_nubar_", "MC_l_nu_"}},
       {{"MC_lbar_lbar_", "MC_lbar_nu_", "MC_lbar_nubar_"}}}};
 
  ZTauTauDecay result;
  for (std::size_t i = 0; i < tauKeys.size(); ++i) {
    std::vector<const xAOD::TruthParticle*> tau_candidates;
    if (RetrieveParticleInfo(m_prefix + "_" + tauKeys[i] + fsr,
                             tau_candidates)) {
      result.taus[i] = {GetPtEtaPhiMfromTruth(tau_candidates.at(0)),
                        tau_candidates.at(0)->pdgId(), true};
    }
    // The tau decay products are only used if all three are found.
    std::array<std::vector<const xAOD::TruthParticle*>, 3> decay_candidates;
    bool has_decay_candidates = true;
    for (std::size_t j = 0; j < decay_candidates.size(); ++j) {
      has_decay_candidates =
          has_decay_candidates &&
          RetrieveParticleInfo(m_prefix + "_" + tauDecayKeys[i][j] + fsr,
                               decay_candidates[j]);
    }
    if (has_decay_candidates) {
      for (std::size_t j = 0; j < decay_candidates.size(); ++j) {
        result.tauDecays[i][j] = {
            GetPtEtaPhiMfromTruth(decay_candidates[j].at(0)),
            decay_candidates[j].at(0)->pdgId(), true};
      }
    }
  }
  return result;
}

handleDecay()

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

Definition at line 265 of file CalcPartonHistory.cxx.

                                                                 {
  // Only daughters of a W/Z/H (not FSR copies of the boson itself).
  if (PartonHistoryUtils::hasParentPdgId(p) ||
      !(PartonHistoryUtils::hasParentAbsPdgId(p, 23) ||
        PartonHistoryUtils::hasParentAbsPdgId(p, 24) ||
        PartonHistoryUtils::hasParentAbsPdgId(p, 25)))
    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;
}

handleFSR()

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

Definition at line 252 of file CalcPartonHistory.cxx.

                                                                           {
  // Last copy of an FSR chain: stored under the key of its first copy.
  if (PartonHistoryUtils::hasParentPdgId(p)) {
    AddToParticleMap(p, key + kAfterFSR);
    return;
  }
  key += newKey;
  AddToParticleMap(p, key + kBeforeFSR);
  if (!PartonHistoryUtils::hasIdenticalChild(p))
    AddToParticleMap(p, key + kAfterFSR);
}

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 355 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 175 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 207 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

(

bool

fcnc = false

)

Definition at line 131 of file PartonHistoryDecorators.cxx.

                                                             {
  std:: string quarkSymbol = fcnc ? "qbar" : "bbar";
  std::string bosonSymbol = fcnc ? "X" : "W";
  m_dec.initializePtEtaPhiMDecorator("MC_tbar_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_" + quarkSymbol + "_beforeFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "_beforeFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "decay1_beforeFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "decay2_beforeFSR_from_tbar");
 
  m_dec.initializePtEtaPhiMDecorator("MC_tbar_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_" + quarkSymbol + "_afterFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "_afterFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "decay1_afterFSR_from_tbar");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "decay2_afterFSR_from_tbar");
 
  m_dec.initializeIntDecorator("MC_tbar_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_" + quarkSymbol + "_beforeFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "_beforeFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "decay1_beforeFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "decay2_beforeFSR_from_tbar_pdgId");
 
  m_dec.initializeIntDecorator("MC_tbar_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_" + quarkSymbol + "_afterFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "_afterFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "decay1_afterFSR_from_tbar_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "decay2_afterFSR_from_tbar_pdgId");
}

InitializeBottomDecorators()

void CP::CalcPartonHistory::InitializeBottomDecorators

(

)

Definition at line 159 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 191 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 500 of file CalcPartonHistory.cxx.

                                             {
  if (!m_configured)
    return;
 
  for (const auto& group : m_config.decoratorGroups) {
    switch (group) {
      case DecoratorGroup::Top:
        InitializeTopDecorators();
        break;
      case DecoratorGroup::TopFCNC:
        InitializeTopDecorators(true);
        break;
      case DecoratorGroup::AntiTop:
        InitializeAntiTopDecorators();
        break;
      case DecoratorGroup::AntiTopFCNC:
        InitializeAntiTopDecorators(true);
        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");
    }
  }
 
  for (const auto& fill : m_config.isOnShellFills)
    m_dec.initializeIntDecorator(fill.decorationKey);
}

InitializeHiggsDecorators()

void CP::CalcPartonHistory::InitializeHiggsDecorators

(

)

Definition at line 245 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 239 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

(

bool

fcnc = false

)

Definition at line 103 of file PartonHistoryDecorators.cxx.

                                                         {
  std:: string quarkSymbol = fcnc ? "q" : "b";
  std::string bosonSymbol = fcnc ? "X" : "W";
  m_dec.initializePtEtaPhiMDecorator("MC_t_beforeFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_" + quarkSymbol + "_beforeFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "_beforeFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "decay1_beforeFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "decay2_beforeFSR_from_t");
 
  m_dec.initializePtEtaPhiMDecorator("MC_t_afterFSR");
  m_dec.initializePtEtaPhiMDecorator("MC_" + quarkSymbol + "_afterFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "_afterFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "decay1_afterFSR_from_t");
  m_dec.initializePtEtaPhiMDecorator("MC_" + bosonSymbol + "decay2_afterFSR_from_t");
 
  m_dec.initializeIntDecorator("MC_t_beforeFSR_pdgId");
  m_dec.initializeIntDecorator("MC_" + quarkSymbol + "_beforeFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "_beforeFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "decay1_beforeFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "decay2_beforeFSR_from_t_pdgId");
 
  m_dec.initializeIntDecorator("MC_t_afterFSR_pdgId");
  m_dec.initializeIntDecorator("MC_" + quarkSymbol + "_afterFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "_afterFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "decay1_afterFSR_from_t_pdgId");
  m_dec.initializeIntDecorator("MC_" + bosonSymbol + "decay2_afterFSR_from_t_pdgId");
}

InitializeTtbarDecorators()

void CP::CalcPartonHistory::InitializeTtbarDecorators

(

)

Definition at line 223 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 183 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 215 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 167 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 199 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 338 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 279 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 442 of file CalcPartonHistory.cxx.

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

linkTruthContainers()

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

protectedvirtual

Definition at line 480 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=() [1/2]

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

delete

operator=() [2/2]

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 58 of file CalcPartonHistory.cxx.

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

Retrievep4() [2/2]

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

Definition at line 63 of file CalcPartonHistory.cxx.

                                                  {
  const auto* v = findVector(m_particleMap, key);
  if (!v || idx >= v->size())
    return false;
  p4 = GetPtEtaPhiMfromTruth(v->at(idx));
  return true;
}

Retrievep4Gamma()

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

Definition at line 72 of file CalcPartonHistory.cxx.

                                                                             {
  // Finds the highest-pT photon among all m_particleMap entries. Photons are
  // stored either under "..._gamma_<beforeFSR|afterFSR>" keys or, when they
  // come from a W/Z/H decay vertex, under "...Decay<N>_<beforeFSR|afterFSR>".
  const xAOD::TruthParticle* bestPhoton = nullptr;
  for (const auto& entry : m_particleMap) {
    for (const auto* p : entry.second) {
      if (p && p->pdgId() == 22 && (!bestPhoton || p->pt() > bestPhoton->pt()))
        bestPhoton = p;
    }
  }
  if (!bestPhoton) {
    parentpdgId = 0;
    return false;
  }
  p4 = GetPtEtaPhiMfromTruth(bestPhoton);
  // Skip identical-photon copies to find the particle that emitted it.
  const xAOD::TruthParticle* parent =
      bestPhoton->nParents() > 0 ? bestPhoton->parent(0) : nullptr;
  while (parent && parent->pdgId() == 22)
    parent = parent->nParents() > 0 ? parent->parent(0) : nullptr;
  parentpdgId = parent ? parent->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 158 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 146 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,
		std::size_t	idx )

Definition at line 152 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 122 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 131 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 97 of file CalcPartonHistory.cxx.

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

RetrievepdgId() [2/3]

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

Definition at line 113 of file CalcPartonHistory.cxx.

                                                     {
  const auto* v = findVector(m_particleMap, key);
  if (!v || idx >= v->size())
    return false;
  pdgId = v->at(idx)->pdgId();
  return true;
}

RetrievepdgId() [3/3]

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

Definition at line 101 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 578 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::TopFCNC:
        FillTopPartonHistory(true);
        break;
      case SpecialFillType::AntiTop:
        FillAntiTopPartonHistory();
        break;
      case SpecialFillType::AntiTopFCNC:
        FillAntiTopPartonHistory(true);
        break;
      case SpecialFillType::Ttbar:
        FillTtbarPartonHistory();
        break;
      case SpecialFillType::TtbarFCNC:
        FillTtbarPartonHistory(true);
        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();
        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);
    }
  }
 
  for (const auto& fill : m_config.isOnShellFills) {
    bool onShell = false;
    for (const auto& key : fill.retrievalKeys) {
      if (ExistsInMap(m_prefix + "_" + key)) {
        onShell = true;
        break;
      }
    }
    m_dec.decorateCustom(fill.decorationKey, onShell ? 1 : 0);
  }
 
  return StatusCode::SUCCESS;
}

setHiggs()

void CP::CalcPartonHistory::setHiggs

(

const std::string &

fsr

)

Definition at line 19 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 62 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 127 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 147 of file CalcZPartonHistory.cxx.

                                                                {
  const ZTauTauDecay decay = getZFromTaus(fsr);
  const bool has_Z = decay.taus[0].found && decay.taus[1].found;
  if (nZs == 1) {
    if (has_Z) {
      m_dec.decorateParticle("MC_Z_" + fsr,
                             decay.taus[0].p4 + decay.taus[1].p4, 23);
      for (std::size_t i = 0; i < decay.taus.size(); ++i) {
        const std::string zDecay = "MC_Zdecay" + std::to_string(i + 1);
        m_dec.decorateParticle(zDecay + "_" + fsr, decay.taus[i].p4,
                               decay.taus[i].pdgId);
        for (std::size_t j = 0; j < decay.tauDecays[i].size(); ++j) {
          const std::string name =
              zDecay + "_decay" + std::to_string(j + 1) + "_" + fsr;
          const ZTauTauProduct& product = decay.tauDecays[i][j];
          // Tau decay products that were not found (e.g. hadronic tau
          // decays) get the sentinel defaults rather than a zero vector.
          if (product.found)
            m_dec.decorateParticle(name, product.p4, product.pdgId);
          else
            m_dec.decorateDefault(name);
        }
      }
    }
  } 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 >, and AthCheckedComponent<::AthAlgTool >.

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 189 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 341 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 183 of file CalcPartonHistory.h.

m_configured

bool CP::CalcPartonHistory::m_configured = false

protected

true after configure() has been called

Definition at line 184 of file CalcPartonHistory.h.

m_dec

PartonDecorator CP::CalcPartonHistory::m_dec

protected

Definition at line 162 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 161 of file CalcPartonHistory.h.

m_prefix

Gaudi::Property<std::string> CP::CalcPartonHistory::m_prefix

protected

Initial value:

{
      this, "prefix", "", "Prefix to apply to all names to avoid overwriting"}

Definition at line 165 of file CalcPartonHistory.h.

                                   {
      this, "prefix", "", "Prefix to apply to all names to avoid overwriting"};

m_symbolFCNC

Gaudi::Property<std::string> CP::CalcPartonHistory::m_symbolFCNC

protected

Initial value:

{
      this, "symbolFCNC", "",
      "Symbol for FCNC, valid only for 'TtbarFCNC' history"}

Definition at line 167 of file CalcPartonHistory.h.

                                       {
      this, "symbolFCNC", "",
      "Symbol for FCNC, valid only for 'TtbarFCNC' history"};

m_truthCollections

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

protected

Definition at line 164 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