TruthClassificationTool Class Reference

a tool to classify particles based on their type and origin More...

#include <TruthClassificationTool.h>

Inheritance diagram for TruthClassificationTool:

Collaboration diagram for TruthClassificationTool:

Public Member Functions
	TruthClassificationTool (const std::string &type)
virtual StatusCode	classify (const xAOD::IParticle &particle, unsigned int &classification) const override
	classify and return unsigned int
virtual StatusCode	classify (const xAOD::IParticle &particle, Truth::Type &classification) const override
	classify and return Truth::Type
virtual StatusCode	initialize ()
	Dummy implementation of the initialisation function.
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
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	classifyElectron (const xAOD::IParticle &electron, Truth::Type &classification) const
	electron classification helper
StatusCode	classifyMuon (const xAOD::IParticle &muon, Truth::Type &classification) const
	muon classification helper
bool	isPromptElectron (const xAOD::IParticle &electron, bool isTruthParticle, const xAOD::TruthParticle *truthParticle) const
	a helper to check if an electron is prompt
bool	isChargeFlipElectron (const xAOD::IParticle &electron, bool isTruthParticle, const xAOD::TruthParticle *truthParticle) const
	a helper to check if an electron has an incorrectly reconstructed charge
bool	isChargeFlipMuon (const xAOD::IParticle &muon, bool isTruthParticle, const xAOD::TruthParticle *truthParticle) const
	a helper to check if a muon has an incorrectly reconstructed charge
bool	hasBHadronOrigin (int origin) const
	a helper to check if the origin is a b-hadron
bool	hasCHadronOrigin (int origin) const
	a helper to check if the origin is a c-hadron
bool	hasLightHadronOrigin (int origin) const
	a helper to check if the origin is a light hadron
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_separateChargeFlipElectrons = false
	separately store charge-flip electrons/muons
bool	m_separateChargeFlipMuons = false
bool	m_useTruthParticleDecorations {false}
	use truth particle decorations
const SG::AuxElement::ConstAccessor< int >	m_truthType {"truthType"}
const SG::AuxElement::ConstAccessor< int >	m_truthOrigin {"truthOrigin"}
const SG::AuxElement::ConstAccessor< unsigned int >	m_truthClassification {"truthClassification"}
const SG::AuxElement::ConstAccessor< int >	m_truthPdgId {"truthPdgId"}
const SG::AuxElement::ConstAccessor< unsigned int >	m_classifierParticleType {"classifierParticleType"}
const SG::AuxElement::ConstAccessor< unsigned int >	m_classifierParticleOrigin {"classifierParticleOrigin"}
const SG::AuxElement::ConstAccessor< int >	m_firstMotherTruthType {"firstEgMotherTruthType"}
const SG::AuxElement::ConstAccessor< int >	m_firstMotherTruthOrigin {"firstEgMotherTruthOrigin"}
const SG::AuxElement::ConstAccessor< unsigned int >	m_firstMotherTruthClassification {"firstEgMotherTruthClassification"}
const SG::AuxElement::ConstAccessor< int >	m_firstMotherPdgId {"firstEgMotherPdgId"}
const SG::AuxElement::ConstAccessor< int >	m_lastMotherTruthType {"lastEgMotherTruthType"}
const SG::AuxElement::ConstAccessor< int >	m_lastMotherTruthOrigin {"lastEgMotherTruthOrigin"}
const SG::AuxElement::ConstAccessor< unsigned int >	m_lastMotherTruthClassification {"lastEgMotherTruthClassification"}
const SG::AuxElement::ConstAccessor< int >	m_lastMotherPdgId {"lastEgMotherPdgId"}
const SG::AuxElement::ConstAccessor< int >	m_fallbackTruthType {"TruthClassifierFallback_truthType"}
const SG::AuxElement::ConstAccessor< int >	m_fallbackTruthOrigin {"TruthClassifierFallback_truthOrigin"}
const SG::AuxElement::ConstAccessor< int >	m_fallbackTruthClassification {"TruthClassifierFallback_truthClassification"}
const SG::AuxElement::ConstAccessor< float >	m_fallbackDR {"TruthClassifierFallback_dR"}
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

a tool to classify particles based on their type and origin

Definition at line 18 of file TruthClassificationTool.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

TruthClassificationTool()

TruthClassificationTool::TruthClassificationTool ( const std::string & type )

explicit

Definition at line 25 of file TruthClassificationTool.cxx.

  : asg::AsgTool(type)
{
  declareProperty ("separateChargeFlipElectrons", m_separateChargeFlipElectrons, "separate prompt charge-flipped electrons");
  declareProperty ("separateChargeFlipMuons",     m_separateChargeFlipMuons,     "separate prompt charge-flipped muons");
  declareProperty ("useTruthParticleDecorations", m_useTruthParticleDecorations, "use truth particle decorations");
}

Member Function Documentation

classify() [1/2]

StatusCode TruthClassificationTool::classify ( const xAOD::IParticle & particle, Truth::Type & classification ) const

overridevirtual

classify and return Truth::Type

Implements ITruthClassificationTool.

Definition at line 44 of file TruthClassificationTool.cxx.

{
  const xAOD::TruthParticle *truthParticle = dynamic_cast<const xAOD::TruthParticle *> (&particle);
  if (dynamic_cast<const xAOD::Electron *> (&particle) || (truthParticle != nullptr && MC::isElectron(truthParticle)))
  {
    ANA_CHECK(classifyElectron(particle, classification));
  }
  else if (dynamic_cast<const xAOD::Muon *> (&particle) || (truthParticle != nullptr && MC::isMuon(truthParticle)))
  {
    ANA_CHECK(classifyMuon(particle, classification));
  }
  else
  {
    ANA_MSG_ERROR("Only electrons and muons are supported.");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

classify() [2/2]

StatusCode TruthClassificationTool::classify ( const xAOD::IParticle & particle, unsigned int & classification ) const

overridevirtual

classify and return unsigned int

Implements ITruthClassificationTool.

Definition at line 34 of file TruthClassificationTool.cxx.

{
  Truth::Type type = Truth::Type::Unknown;
  ANA_CHECK(classify(particle, type));
  classification = static_cast<int>(type);
  return StatusCode::SUCCESS;
}

classifyElectron()

StatusCode TruthClassificationTool::classifyElectron ( const xAOD::IParticle & electron, Truth::Type & classification ) const

private

electron classification helper

Definition at line 66 of file TruthClassificationTool.cxx.

{
  
 
  // Check if xAOD::TruthParticle or if not if it has the TruthParticleLink
  const xAOD::TruthParticle *truthParticle = dynamic_cast<const xAOD::TruthParticle *> (&electron);
  bool isTruthParticle{};
  if (truthParticle == nullptr)
  {
    // need to find the truth particle
    truthParticle = xAOD::TruthHelpers::getTruthParticle(electron);
  }
  else
  {
    isTruthParticle = true;
  }
 
  if (!m_truthPdgId.isAvailable(electron) && !isTruthParticle)
  {
    ANA_MSG_ERROR("Electron does not have the 'truthPdgId' decoration.");
    return StatusCode::FAILURE;
  }
 
  if (!m_firstMotherTruthType.isAvailable(electron)
    || !m_firstMotherTruthOrigin.isAvailable(electron)
    || !m_firstMotherPdgId.isAvailable(electron))
  {
    ANA_MSG_ERROR("Electron does not have one or more 'firstEgMother' decorations.");
    return StatusCode::FAILURE;
  }
 
  int type = isTruthParticle ? m_classifierParticleType(electron) : m_truthType(electron);
  int origin = isTruthParticle ? m_classifierParticleOrigin(electron) : m_truthOrigin(electron);
  int pdgId = isTruthParticle ? truthParticle->pdgId() : m_truthPdgId(electron);
  if (m_useTruthParticleDecorations && !isTruthParticle)
  {
    type = m_classifierParticleType(*truthParticle);
    origin = m_classifierParticleOrigin(*truthParticle);
  }
 
  int firstMotherType = m_firstMotherTruthType(electron);
  int firstMotherOrigin = m_firstMotherTruthOrigin(electron);
  int firstMotherPdgId = m_firstMotherPdgId(electron);
  // not in the smart slimming list, thus only in few derivations
  int lastMotherType = m_lastMotherTruthType.isAvailable(electron) ? m_lastMotherTruthType(electron) : -1;
  int lastMotherOrigin = m_lastMotherTruthOrigin.isAvailable(electron) ? m_lastMotherTruthOrigin(electron) : -1;
  int lastMotherPdgId = m_lastMotherPdgId.isAvailable(electron) ? m_lastMotherPdgId(electron) : -1;
  // fallback recorations
  int fallbackType{-1};
  if (m_fallbackTruthType.isAvailable(electron) && m_fallbackDR.isAvailable(electron))
  {
    fallbackType = m_fallbackDR(electron) < 0.05 ? m_fallbackTruthType(electron) : -1;
  }
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Prompt Photon Conversions
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  // gamma -> e+ e-
  if (type == MCTruthPartClassifier::BkgElectron
    && (origin == MCTruthPartClassifier::PhotonConv || origin == MCTruthPartClassifier::ElMagProc)
    && firstMotherType == MCTruthPartClassifier::IsoPhoton && firstMotherOrigin == MCTruthPartClassifier::PromptPhot)
  {
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
 
  // H -> gamma gamma, gamma -> e+ e-
  if (type == MCTruthPartClassifier::BkgElectron && origin == MCTruthPartClassifier::PhotonConv
    && firstMotherType == MCTruthPartClassifier::IsoPhoton && firstMotherOrigin == MCTruthPartClassifier::Higgs)
  {
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
 
  // bkg electrons from bkg photons
  if (type == MCTruthPartClassifier::BkgElectron && origin == MCTruthPartClassifier::PhotonConv
    && firstMotherType == MCTruthPartClassifier::UnknownPhoton && firstMotherOrigin == MCTruthPartClassifier::NonDefined)
  {
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
 
  // bkg photon from UndrPhot; (Here there is a generator level photon (not gen electron ) that later converts)
  if (type == MCTruthPartClassifier::BkgElectron
    && (origin == MCTruthPartClassifier::PhotonConv || origin == MCTruthPartClassifier::ElMagProc )
    && firstMotherType == MCTruthPartClassifier::BkgPhoton && firstMotherOrigin == MCTruthPartClassifier::UndrPhot)
  {
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
 
  // type = 16 and origin = 38 (again, this is a photon)
  if (type == MCTruthPartClassifier::BkgPhoton && origin == MCTruthPartClassifier::UndrPhot)
  {
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
 
  // Is an isolated photon
  if (type == MCTruthPartClassifier::IsoPhoton && pdgId == 22)
  {
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
 
  // electrons from ElMagProc
  // when FSR, a better classification can be made with the fall back vars
  if (type == MCTruthPartClassifier::BkgElectron && origin == MCTruthPartClassifier::ElMagProc
    && firstMotherType == MCTruthPartClassifier::UnknownPhoton && firstMotherOrigin == MCTruthPartClassifier::NonDefined)
  {
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
  if (type == MCTruthPartClassifier::BkgElectron && origin == MCTruthPartClassifier::ElMagProc
    && firstMotherType == MCTruthPartClassifier::NonIsoPhoton && firstMotherOrigin == MCTruthPartClassifier::FSRPhot)
  {
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
 
  // TODO: Message from Otilia: """
  // but it's not clear if these electrons are really
  // "fakes" or they should go in the real category (we don't know from where
  // this photon is coming...). I would say more truth studies should be done.
  // """
  // Hence the warning message...
  if (type == MCTruthPartClassifier::BkgElectron && origin == MCTruthPartClassifier::PhotonConv
    && firstMotherType == MCTruthPartClassifier::Unknown && firstMotherOrigin == MCTruthPartClassifier::ZBoson)
  {
    ANA_MSG_WARNING("Electron identified as from a PromptPhotonConversion, "
                    "but this type of electron needs further study!");
    classification = Truth::Type::PromptPhotonConversion;
    return StatusCode::SUCCESS;
  }
 
  // when always a photon (last mum is a photon, even if the truth PDG is 11 and first mum PDG is 11 ):
  // very likely these are internal conversions;  last_mum_pdgId == 22 important as the cases with last_mum_pdgId == 11 were found to be quite often close to a true electron
  if (type == MCTruthPartClassifier::BkgElectron && firstMotherType == MCTruthPartClassifier::BkgElectron
    && origin == MCTruthPartClassifier::PhotonConv && firstMotherOrigin == MCTruthPartClassifier::PhotonConv
    && std::abs(firstMotherPdgId) == 11 && std::abs(pdgId) == 11)
  {  // electron
    if(lastMotherType == -1 || (lastMotherType == MCTruthPartClassifier::GenParticle && (lastMotherPdgId == 22 || std::abs(lastMotherPdgId) == 11)))
    {
      // lastMotherType == -1 ==>  when the last mother info is not stored in the derivations
      classification = Truth::Type::PromptPhotonConversion;
      return StatusCode::SUCCESS;
    }
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Is muon reco as electron or ele radiated by muons
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if ((type == MCTruthPartClassifier::NonIsoElectron || type == MCTruthPartClassifier::NonIsoPhoton)
    && (origin == MCTruthPartClassifier::Mu || firstMotherOrigin == MCTruthPartClassifier::Mu))
  {
    classification = Truth::Type::ElectronFromMuon;
    return StatusCode::SUCCESS;
  }
 
  if (type == MCTruthPartClassifier::BkgElectron && firstMotherOrigin == MCTruthPartClassifier::Mu)
  {
    classification = Truth::Type::ElectronFromMuon;
    return StatusCode::SUCCESS;
  }
 
  if (type == MCTruthPartClassifier::IsoMuon || type == MCTruthPartClassifier::NonIsoMuon || type == MCTruthPartClassifier::BkgMuon || type == MCTruthPartClassifier::UnknownMuon) {
    classification = Truth::Type::ElectronFromMuon;
    return StatusCode::SUCCESS;
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Tau decays
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  // Non-isolated electron/photon from tau decay
  if ((type == MCTruthPartClassifier::NonIsoElectron || type == MCTruthPartClassifier::NonIsoPhoton)
    && origin == MCTruthPartClassifier::TauLep)
  {
    classification = Truth::Type::TauDecay;
    return StatusCode::SUCCESS;
  }
 
  // tau -> tau gamma, gamma -> e+ e-, etc
  if ((firstMotherType == MCTruthPartClassifier::NonIsoElectron || firstMotherType == MCTruthPartClassifier::NonIsoPhoton)
    && firstMotherOrigin == MCTruthPartClassifier::TauLep)
  {
    classification = Truth::Type::TauDecay;
    return StatusCode::SUCCESS;
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Light hadron sources
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (type == MCTruthPartClassifier::Hadron || fallbackType == MCTruthPartClassifier::Hadron)
  {
    classification = Truth::Type::LightFlavorDecay;
    return StatusCode::SUCCESS;
  }
 
  if (firstMotherType == MCTruthPartClassifier::BkgElectron)
  {
    if ((origin == MCTruthPartClassifier::DalitzDec || origin == MCTruthPartClassifier::ElMagProc)
      && (hasLightHadronOrigin(origin) || hasLightHadronOrigin(firstMotherOrigin)))
    {
      classification = Truth::Type::LightFlavorDecay;
      return StatusCode::SUCCESS;
    }
  }
 
  if (type == MCTruthPartClassifier::BkgElectron)
  {
    if (origin == MCTruthPartClassifier::DalitzDec || firstMotherOrigin == MCTruthPartClassifier::DalitzDec) {
      classification = Truth::Type::LightFlavorDecay;
      return StatusCode::SUCCESS;
    }
    if (hasLightHadronOrigin(origin) || hasLightHadronOrigin(firstMotherOrigin)) {
      classification = Truth::Type::LightFlavorDecay;
      return StatusCode::SUCCESS;
    }
  }
 
  if (type == MCTruthPartClassifier::BkgPhoton
    && (hasLightHadronOrigin(origin) || hasLightHadronOrigin(firstMotherOrigin)))
  {
    classification = Truth::Type::LightFlavorDecay;
    return StatusCode::SUCCESS;
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // From B hadron
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (hasBHadronOrigin(origin) || hasBHadronOrigin(firstMotherOrigin))
  {
    classification = Truth::Type::BHadronDecay;
    return StatusCode::SUCCESS;
  }
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // From C hadron
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (type != MCTruthPartClassifier::IsoElectron && (hasCHadronOrigin(origin) || hasCHadronOrigin(firstMotherOrigin)))
  {
    classification = Truth::Type::CHadronDecay;
    return StatusCode::SUCCESS;
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Prompt / Isolated electrons
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (isPromptElectron(electron, isTruthParticle, truthParticle))
  {
    if (m_separateChargeFlipElectrons && isChargeFlipElectron(electron, isTruthParticle, truthParticle))
    {
      classification = Truth::Type::ChargeFlipIsoElectron;
      return StatusCode::SUCCESS;
    }
 
    classification = Truth::Type::IsoElectron;
    return StatusCode::SUCCESS;
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Unknown & known Unknown
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  // TODO: See if we want this or not. Now we check if this is something we are
  // able to classify or not. Note that this might be a bit dangerous because
  // the reasons for not having origin and status codes might be complex. The
  // main idea is to weed out things we don't have a hope of classifying due to
  // missing or unknown information.
  static const SG::ConstAccessor<int> statusAcc("status");
  bool stable = (truthParticle != nullptr && statusAcc.isAvailable(*truthParticle)) ? MC::isStable(truthParticle) : false;
 
 
  if (origin == MCTruthPartClassifier::NonDefined && firstMotherOrigin == MCTruthPartClassifier::NonDefined)
  {
    if (!stable)
    {
      if ((type == MCTruthPartClassifier::Unknown || type == MCTruthPartClassifier::UnknownPhoton) && firstMotherType == MCTruthPartClassifier::Unknown)
      {
        classification = Truth::Type::KnownUnknown;
        return StatusCode::SUCCESS;
      }
    } else {
      if ((type == MCTruthPartClassifier::Unknown && firstMotherType == MCTruthPartClassifier::Unknown)
        || (type == MCTruthPartClassifier::UnknownElectron && firstMotherType == MCTruthPartClassifier::UnknownElectron))
      {
        classification = Truth::Type::KnownUnknown;
        return StatusCode::SUCCESS;
      }
 
      if (type == MCTruthPartClassifier::UnknownPhoton)
      {
        classification = Truth::Type::KnownUnknown;
        return StatusCode::SUCCESS;
      }
    }
  }
 
  // non-iso photons with no info available to classify
  if (type == MCTruthPartClassifier::NonIsoPhoton && origin == MCTruthPartClassifier::FSRPhot && pdgId == 22
    && firstMotherType == 0 && firstMotherOrigin == 0 && firstMotherPdgId == 0)
  {
    if (lastMotherType == -1 || (lastMotherType == 0 && lastMotherOrigin == 0 && lastMotherPdgId == 0))
    { // last_firstMotherType == -1 ==>  when the last_mum info is not stored in the derivations
      classification = Truth::Type::KnownUnknown;
      return StatusCode::SUCCESS;
    }
  }
 
  ANA_MSG_WARNING("Electron type unknown: type = " << type << ", origin = " << origin);
 
  // debug printout
  if (truthParticle != nullptr)
  {
    const xAOD::TruthParticle *parent = truthParticle;
    ATH_MSG_DEBUG("Unknown particle decay chain (approximate):");
    std::string out = "\t";
    while (parent != nullptr)
    {
      out.append(std::to_string(parent->pdgId()));
      parent = parent->parent(0); //AV: Note the ambiguity: only the first particle is considered.
      if (parent) out.append(" -> ");
    }
    ATH_MSG_DEBUG(out);
  }
 
  classification = Truth::Type::Unknown;
  return StatusCode::SUCCESS;
}

classifyMuon()

StatusCode TruthClassificationTool::classifyMuon ( const xAOD::IParticle & muon, Truth::Type & classification ) const

private

muon classification helper

Definition at line 411 of file TruthClassificationTool.cxx.

{
  
 
  // Check if xAOD::TruthParticle or if not if it has the TruthParticleLink
  const xAOD::TruthParticle *truthParticle
    = dynamic_cast<const xAOD::TruthParticle *> (&muon);
  bool isTruthParticle{};
  if (truthParticle == nullptr)
  {
    // need to find the truth particle
    truthParticle = xAOD::TruthHelpers::getTruthParticle(muon);
  }
  else
  {
    isTruthParticle = true;
  }
 
  int type = isTruthParticle ? m_classifierParticleType(muon) : m_truthType(muon);
  int origin = isTruthParticle ? m_classifierParticleOrigin(muon) : m_truthOrigin(muon);
  if (m_useTruthParticleDecorations && !isTruthParticle && truthParticle != nullptr)
  {
    type = m_classifierParticleType(*truthParticle);
    origin = m_classifierParticleOrigin(*truthParticle);
  }
 
  // fallback recorations
  int fallbackType{-1};
  if (m_fallbackTruthType.isAvailable(muon) && m_fallbackDR.isAvailable(muon))
  {
    fallbackType = m_fallbackDR(muon) < 0.05 ? m_fallbackTruthType(muon) : -1;
  }
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // muons from taus
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (type == MCTruthPartClassifier::NonIsoMuon && origin == MCTruthPartClassifier::TauLep)
  {
    classification = Truth::Type::TauDecay;
    return StatusCode::SUCCESS;
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Light hadron sources
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (type == MCTruthPartClassifier::BkgMuon && hasLightHadronOrigin(origin))
  {
    classification = Truth::Type::LightFlavorDecay;
    return StatusCode::SUCCESS;
  }
 
  if (type == MCTruthPartClassifier::Hadron || fallbackType == MCTruthPartClassifier::Hadron )
  {
    classification = Truth::Type::LightFlavorDecay;
    return StatusCode::SUCCESS;
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // From B hadron
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (hasBHadronOrigin(origin))
  {
    classification = Truth::Type::BHadronDecay;
    return StatusCode::SUCCESS;
  }
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // From C hadron
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (type != MCTruthPartClassifier::IsoMuon && hasCHadronOrigin(origin))
  {
    classification = Truth::Type::CHadronDecay;
    return StatusCode::SUCCESS;
  }
  // TODO:: There is a comment in the example code about J/psi but there is a
  // separate origin code for that: `MCTruthPartClassifier::JPsi == 28.` --> this might not be in all samples/generators?
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // prompt muons
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Check if the type of muon is IsoMuon(6) and whether the origin
  // of the muon is from a prompt source
  static const std::set<int> promptOrigin({
      MCTruthPartClassifier::SingleMuon,  // Single muon (origin = 2) from muon twiki
      MCTruthPartClassifier::top,
      MCTruthPartClassifier::WBoson,
      MCTruthPartClassifier::ZBoson,
      MCTruthPartClassifier::Higgs,
      MCTruthPartClassifier::HiggsMSSM,
      MCTruthPartClassifier::SUSY,
      MCTruthPartClassifier::DiBoson,
      MCTruthPartClassifier::CCbarMeson, // PromptQuarkoniumDecay
      MCTruthPartClassifier::BBbarMeson,
      MCTruthPartClassifier::HeavyBoson,
      MCTruthPartClassifier::MultiBoson
  });
  if (type == MCTruthPartClassifier::IsoMuon && isInSet(origin, promptOrigin))
  {
    //separate charge-flip muons
    if (m_separateChargeFlipMuons && isChargeFlipMuon(muon, isTruthParticle, truthParticle))
    {
      classification = Truth::Type::ChargeFlipMuon;
      return StatusCode::SUCCESS;
    }
    classification = Truth::Type::PromptMuon;
    return StatusCode::SUCCESS;
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Known Unknown
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  if (type == MCTruthPartClassifier::UnknownMuon && origin == MCTruthPartClassifier::NonDefined)
  {
    classification = Truth::Type::KnownUnknown;
    return StatusCode::SUCCESS;
  }
  
  static const SG::ConstAccessor<int> statusAcc("status");
  bool stable = (truthParticle != nullptr && statusAcc.isAvailable(*truthParticle)) ? MC::isStable(truthParticle) : false;
 
  if (!stable) {
    if (type == MCTruthPartClassifier::Unknown && origin == MCTruthPartClassifier::NonDefined)
    { // Data
      classification = Truth::Type::KnownUnknown;
      return StatusCode::SUCCESS;
    }
    if (type == -99999 && origin == -99999)
    { // MC - no status = 1 truth particle associated with the primary track
      classification = Truth::Type::KnownUnknown;
      return StatusCode::SUCCESS;
    }
  }
  
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // NonMuonlike
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Check if the type of muon is related to electrons, ie IsoElectron (2) or NonIsoElectron (3) or BkgElectron (4)
  if (type == MCTruthPartClassifier::IsoElectron || type == MCTruthPartClassifier::BkgElectron || type == MCTruthPartClassifier::NonIsoElectron)
  {
    classification = Truth::Type::NonMuonlike;
    return StatusCode::SUCCESS;
  }
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // TauLike, BHadLike, CHadLike
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Check if the matched parent of truth muon fall into these 3 xxxLike
  // Only truth muon with one matched parent is considered
  // If parent is tau, the muons is TauLike
  // If parent is bhadron/b quark, the muons is BHadLike
  // If parent is chadron/c quark, the muons is CHadLike
  if (type == MCTruthPartClassifier::Unknown && origin == MCTruthPartClassifier::NonDefined){
    if( truthParticle != nullptr && truthParticle->nParents() == 1 && truthParticle->parent(0) != nullptr){
      const xAOD::TruthParticle *parent = truthParticle->parent(0);
      int parent_pdgid = parent->pdgId(); 
      if(parent->isTau()){
        classification = Truth::Type::TauDecayLike;
        ATH_MSG_WARNING("Muon type taudecaylike: type = " << type << ", origin = " << origin << ", parent = " << parent_pdgid) ; 
        return StatusCode::SUCCESS;
      }
      if(parent->isBottomHadron() || parent->hasBottom()){
        classification = Truth::Type::BHadronDecayLike;
        ATH_MSG_WARNING("Muon type bhadrondecaylike: type = " << type << ", origin = " << origin << ", parent = " << parent_pdgid) ; 
        return StatusCode::SUCCESS;
      }
      if(parent->isCharmHadron() || parent->hasCharm()){ 
        if( (parent_pdgid / 1000) % 10 != 0 || (parent_pdgid / 100) % 10 != 4 || (parent_pdgid / 10) % 10 != 4){ // to exclude ccbarmeson 
          classification = Truth::Type::CHadronDecayLike;
          ATH_MSG_WARNING("Muon type chadrondecaylike: type = " << type << ", origin = " << origin << ", parent = " << parent_pdgid) ; 
          return StatusCode::SUCCESS;
        } 
      }
    }
  }
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Unknown
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  classification = Truth::Type::Unknown;
  ATH_MSG_WARNING("Muon type unknown: type = " << type << ", origin = " << origin) ; 
 
  return StatusCode::SUCCESS;
}

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

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

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getKey()

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

inherited

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

This is a bit of a special one. StoreGateSvc and xAOD::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
   }

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

hasBHadronOrigin()

bool TruthClassificationTool::hasBHadronOrigin ( int origin ) const

private

a helper to check if the origin is a b-hadron

Definition at line 733 of file TruthClassificationTool.cxx.

{
  static const std::set<int> b_hadrons({
    MCTruthPartClassifier::BottomMeson,
    MCTruthPartClassifier::BBbarMeson,
    MCTruthPartClassifier::BottomBaryon,
  });
  return b_hadrons.contains(origin);
}

hasCHadronOrigin()

bool TruthClassificationTool::hasCHadronOrigin ( int origin ) const

private

a helper to check if the origin is a c-hadron

Definition at line 744 of file TruthClassificationTool.cxx.

                                                               {
  static const std::set<int> c_hadrons({
    MCTruthPartClassifier::CharmedMeson,
    MCTruthPartClassifier::CCbarMeson,
    MCTruthPartClassifier::CharmedBaryon,
  });
  return c_hadrons.contains(origin);
}

hasLightHadronOrigin()

bool TruthClassificationTool::hasLightHadronOrigin ( int origin ) const

private

a helper to check if the origin is a light hadron

Definition at line 754 of file TruthClassificationTool.cxx.

                                                                   {
  static const std::set<int> light_source({
    MCTruthPartClassifier::PiZero,
    MCTruthPartClassifier::LightMeson,
    MCTruthPartClassifier::StrangeMeson,
    MCTruthPartClassifier::LightBaryon,
    MCTruthPartClassifier::StrangeBaryon,
    MCTruthPartClassifier::PionDecay,
    MCTruthPartClassifier::KaonDecay,
  });
  return light_source.contains(origin);
}

initialize()

virtual StatusCode asg::AsgTool::initialize ( void )

inlinevirtualinherited

Dummy implementation of the initialisation function.

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

Reimplemented in asg::DataHandleTestTool, asg::EventStoreTestTool, asg::UnitTestTool1, asg::UnitTestTool1A, asg::UnitTestTool2, asg::UnitTestTool3, AsgDeadHVCellRemovalTool, AsgElectronChargeIDSelectorTool, AsgElectronEfficiencyCorrectionTool, AsgElectronIsEMSelector, AsgElectronLikelihoodTool, AsgElectronSelectorTool, AsgForwardElectronCalibrationTool, AsgForwardElectronIsEMSelector, AsgForwardElectronLikelihoodTool, AsgForwardElectronSelectorTool, AsgHelloTool, AsgPhotonEfficiencyCorrectionTool, AsgPhotonIsEMSelector, AthAsgExUnittestTool, AthONNX::JSSMLTool, AthOnnx::OnnxRuntimeInferenceTool, AthOnnx::OnnxRuntimeSessionToolCPU, AthOnnx::OnnxRuntimeSessionToolCUDA, BaseFakeBkgTool, BDTVertexWeightCalculator, BJetCorrectionTool, BJT::qgTagger, BJT::ScaleFactors, BookkeeperDumperTool, BookkeeperTool, BoostedJetTaggerTool, BTaggingEfficiencyJsonTool, BTaggingEfficiencyTool, BTaggingEigenVectorRecompositionTool, BTaggingSelectionJsonTool, BTaggingSelectionTool, BTaggingTruthTaggingTool, CaloClusterConstituentsOrigin, CenterOfMassShapesTool, ChargedHadronSubtractionTool, ClusterAtEMScaleTool, ClusterAtMLScaleTool, ClusterMatching::CaloClusterMatchingTool, columnar::ColumnarLinkTool, columnar::ConfigurableColumnExampleTool, columnar::LinkColumnExampleTool, columnar::ModularExampleTool, columnar::MomentumAccessorExampleTool, columnar::OptionalColumnExampleTool, columnar::SimpleSelectorExampleTool, columnar::StringExampleTool, columnar::VariantExampleTool, columnar::VectorExampleTool, ConstitTimeCutTool, ConstituentSubtractorTool, CopyTruthJetParticles, CopyTruthParticles, CorrectPFOTool, CP::ApplyE2YFakeRate, CP::ApplyFakeFactor, CP::AsgFlagSelectionTool, CP::AsgMaskSelectionTool, CP::AsgMassSelectionTool, CP::AsgNumDecorationSelectionTool< T >, CP::AsgNumDecorationSelectionTool< int >, CP::AsgNumDecorationSelectionTool< uint8_t >, CP::AsgPtEtaSelectionTool, CP::AsymptMatrixTool, CP::BaseFakeBkgTool, CP::BaseLinearFakeBkgTool, CP::CalcPartonHistory, CP::EgammaCalibrationAndSmearingTool, CP::EgammaIsGoodOQSelectionTool, CP::ElectronChargeEfficiencyCorrectionTool, CP::ElectronLRTOverlapRemovalTool, CP::FFJetSmearingTool, CP::FJvtEfficiencyTool, CP::FJvtSelectionTool, CP::IsolationCloseByCorrectionTool, CP::IsolationCorrectionTool, CP::IsolationHelper, CP::IsolationLowPtPLVTool, CP::IsolationSelectionTool, CP::JetQGTagger, CP::JetQGTaggerBDT, CP::JetTileCorrectionTool, CP::JvtEfficiencyTool, CP::JvtEfficiencyToolBase, CP::JvtSelectionTool, CP::JvtSelectionToolBase, CP::LhoodMM_tools, CP::MuonCalibIntHighpTSmearTool, CP::MuonCalibIntSagittaTool, CP::MuonCalibIntScaleSmearTool, CP::MuonCalibTool, CP::MuonEfficiencyScaleFactors, CP::MuonLRTOverlapRemovalTool, CP::MuonSelectionTool, CP::MuonTriggerScaleFactors, CP::MVATrackVertexAssociationTool, CP::NNJvtEfficiencyTool, CP::NNJvtSelectionTool, CP::PhotonPointingTool, CP::PhotonVertexSelectionTool, CP::PileupReweightingTool, CP::TrackVertexAssociationTool, D3PD::D3PDMCTruthClassifier, Diagram, DiTauMassTools::MissingMassTool, dRMatchingTool, ECUtils::EventCleaningTool, EfficiencyResponseHistos, EGammaAmbiguityTool, egammaMVACalibTool, egammaTransformerCalibTool, EL::UnitTestTool, ElectronPhotonVariableCorrectionBase, ElectronPhotonVariableCorrectionTool, ElectronPhotonVariableNFCorrectionTool, EnergyCorrelatorGeneralizedRatiosTool, EnergyCorrelatorGeneralizedTool, EnergyCorrelatorRatiosTool, EnergyCorrelatorTool, EnhancedBiasWeighter, EtaJESCalibStep, EventDensityTool, EventShapeCopier, ExtendTrackToLayerTool, FastJetInterfaceTool, FlavorTagDiscriminants::DL2Tool, FlavorTagDiscriminants::TrackClassifier, FlavorTagDiscriminants::VRJetOverlapDecoratorTool, FlavorTagInference::GNNTool, FlavorTagInference::MultifoldGNNTool, FSR::FsrPhotonTool, FtagLargeRJetTruthLabelTool, Generic4VecCorrectionStep, GoodRunsListSelectionTool, GSCCalibStep, HI::HIEventSelectionTool, HI::HIEventSelectionToolRun3, HI::HIPileupTool, HI::HIVertexSelectionTool, HIClusterSubtraction, HIEfficiencyResponseHistos, HIEventShapeFillerTool, HIEventShapeJetIteration, HIEventShapeMapTool, HIEventShapeSummaryTool, HiggsTruthCategoryTool, HIJetClusterIndexAssociationTool, HIJetClusterSubtractorTool, HIJetConstituentModifierTool, HIJetConstituentSubtractionTool, HIJetDRAssociationTool, HIJetMaxOverMeanTool, HIJetSignificanceTool, HIJetUEMonitoring, HistoDefinitionTool, HistoGroupBase, HistosForJetSelection, HIUEModulatorTool, IDTPM::DeltaRMatchingToolBase< T, R >, IDTPM::DeltaRMatchingToolBase< xAOD::TrackParticle >, IDTPM::DeltaRMatchingToolBase< xAOD::TrackParticle, xAOD::TruthParticle >, IDTPM::DeltaRMatchingToolBase< xAOD::TruthParticle, xAOD::TrackParticle >, IDTPM::EFTrackMatchingTool, IDTPM::JsonPlotsDefReadTool, IDTPM::OfflineTrackQualitySelectionTool, IDTPM::RoiSelectionTool, IDTPM::StableDeltaRMatchingTool< T, R >, IDTPM::StableDeltaRMatchingTool< xAOD::TrackParticle, xAOD::TrackParticle >, IDTPM::StableDeltaRMatchingTool< xAOD::TrackParticle, xAOD::TruthParticle >, IDTPM::StableDeltaRMatchingTool< xAOD::TruthParticle, xAOD::TrackParticle >, IDTPM::TrackAnalysisInfoWriteTool, IDTPM::TrackObjectSelectionTool, IDTPM::TrackQualitySelectionTool, IDTPM::TrackRoiSelectionTool, IDTPM::TrackTruthMatchingTool, IDTPM::TruthQualitySelectionTool, IDTPM::TruthTrackMatchingTool, IDTPM::VertexQualitySelectionTool, IDTPM::VertexRoiSelectionTool, IHIEventShapeMapTool, InDet::InclusiveTrackFilterTool, InDet::InDetHardScatterSelectionTool, InDet::InDetSecVtxTrackSelectionTool, InDet::InDetTrackBiasingTool, InDet::InDetTrackSelectionTool, InDet::InDetTrackSmearingTool, InDet::InDetTrackSystematicsTool, InDet::InDetTrackTruthFilterTool, InDet::InDetTrackTruthOriginTool, InDet::InDetUsedInFitTrackDecoratorTool, InDet::JetTrackFilterTool, InDetGNNHardScatterSelection::GNNTool, InDetSecVtxTruthMatchTool, InDetVertexTruthMatchTool, InSituCalibStep, InSituJMSCalibStep, JetAttributeHisto, JetAttributeRatioSelector, JetAttributeSelector, JetBadChanCorrTool, JetBalancePFlowJvtTool, JetBottomUpSoftDrop, JetCalibrationTool, JetCalibTool, JetCaloCellQualityTool, JetCaloEnergies, JetCaloQualityTool, JetCaloQualityToolFE, JetCleaningTool, JetClusterer, JetClustererByVertex, JetClusterMomentsTool, JetConstitFourMomTool, JetConstituentFrac, JetConstituentModSequence, JetConstituentsRetriever, JetContainerHistoFiller, JetCopier, JetDNNCalibStep, JetDRTrackAssocTool, JetECPSFractionTool, JetEMScaleMomTool, JetEventSelector, JetFinder, JetForwardJvtTool, JetForwardJvtToolBDT, JetForwardPFlowJvtTool, JetFromPseudojet, JetGrooming::JetGroomer, JetGrooming::JetTrimming, JetGrooming::RecSoftDrop, JetGrooming::SoftDrop, JetGroomMRatio, JetHelper::HistoInput1D, JetHelper::HistoInput2D, JetHelper::HistoInput3D, JetHelper::VarTool, JetHistoBase, JetInputElRemovalTool, JetIRCSafeLabelTool, JetIsolationTool, JetLArHVTool, JetModifiedMassDrop, JetNumConstitTool, JetOriginCorrectionTool, JetParticleAssociation, JetPileupLabelingTool, JetPileupTag::JetVertexNNTagger, JetPruner, JetPseudojetCopier, JetPseudojetRetriever, JetPtAssociationTool, JetQGTaggerVariableTool, JetQuarkChargeLabelingTool, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetResponseTool, JetSelectorAttribute, JetSelectorAttributeRunII, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrackMomentsTool, JetTrackSumMomentsTool, JetTrimmer, JetTruthLabelingTool, JetTruthParticleSelectorTool, JetUncertaintiesTool, JetUsedInFitTrackDecoratorTool, JetVertexFractionTool, JetVertexTaggerTool, JetVoronoiDiagramHelpers::Diagram, JetVoronoiMomentsTool, JetWidthTool, JMSCalibStep, JSSTaggerBase, JSSTaggerUtils, JSSWTopTaggerANN, JSSWTopTaggerDNN, KTSplittingScaleTool, LeadingJetsRelations, LundNetTagger, LVL1::L1CaloCells2TriggerTowers, LVL1::L1CaloFcal23Cells2RxMappingTool, LVL1::L1CaloLArTowerEnergy, LVL1::L1CaloMonitoringCaloTool, LVL1::L1CaloOfflineTriggerTowerTools, LVL1::L1CaloTTIdTools, LVL1::L1CaloxAODOfflineTriggerTowerTools, LVL1::TrigT1CaloMonErrorTool, LVL1::TrigT1CaloMonErrorToolV1, LVL1BS::PpmByteStreamReadV1V2Tool, LVL1BS::TrigT1CaloDataAccessV2, MBTSTimeFilterTool, MCTruthClassifier, met::ColumnarMETMaker, met::METAssociationTool, met::METAssociator, met::METBuilderTool, met::METCaloRegionsTool, met::METEgammaAssociator, met::METElectronAssociator, met::METJetAssocTool, met::METJetTool, met::METMaker, met::METMuonAssociator, met::METNet, met::METNetSig, met::METPhotonAssociator, met::METRecoTool, met::METRefinerTool, met::METRegionsTool, met::METSignificance, met::METSoftAssociator, met::METSoftTermsTool, met::METSystematicsTool, met::METTauAssociator, met::METTrackFilterTool, met::METTruthAssociator, met::METTruthTool, MissingCellListTool, MvaTESEvaluator, MvaTESVariableDecorator, NSubjettinessRatiosTool, NSubjettinessTool, ORUtils::BaseOverlapTool, ORUtils::FEAssociationTool, ORUtils::OverlapRemovalTool, PanTau::PanTauProcessor, PanTau::Tool_DecayModeDeterminator, PanTau::Tool_DetailsArranger, PanTau::Tool_FeatureExtractor, PanTau::Tool_InformationStore, PanTau::Tool_InputConverter, PanTau::Tool_ModeDiscriminator, PanTau::Tool_TauConstituentGetter, PanTau::Tool_TauConstituentSelector, ParticleJetDeltaRLabelTool, ParticleJetGhostLabelTool, ParticleScaleFactorTool, PDFWeight, PhotonIDBDT::AsgPhotonBDTSelector, PhotonIDBDT::PhotonBDTCalculator, PhotonIDBDT::PhotonSingleBDTCalculator, Pileup1DResidualCalibStep, PileupCalibStep, PMGTools::PMGCrossSectionTool, PMGTools::PMGDecayProductsSelectionTool, PMGTools::PMGHFProductionFractionTool, PMGTools::PMGSherpa22VJetsWeightTool, PMGTools::PMGSherpaVjetsSysTool, PMGTools::PMGTruthWeightTool, PuppiWeightTool, QwTool, Ringer::AsgRingerSelectorTool, SimpleMuonTriggerScaleFactors, SmearingCalibStep, SmoothedTopTagger, SmoothedWZTagger, SoftKillerWeightTool, ST::SUSYObjDef_xAOD, TauAnalysisTools::BuildTruthTaus, TauAnalysisTools::CommonDiTauEfficiencyTool, TauAnalysisTools::CommonDiTauSmearingTool, TauAnalysisTools::CommonEfficiencyTool, TauAnalysisTools::CommonSmearingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, TauAnalysisTools::DiTauSelectionTool, TauAnalysisTools::DiTauSmearingTool, TauAnalysisTools::DiTauTruthMatchingTool, TauAnalysisTools::TauEfficiencyCorrectionsTool, TauAnalysisTools::TauSelectionTool, TauAnalysisTools::TauSmearingTool, TauAnalysisTools::TauTruthMatchingTool, TauAnalysisTools::TauTruthTrackMatchingTool, TauAODMuonRemovalTool, TauCalibrateLC, TauCombinedTES, TauDecayModeNNClassifier, TauElectronVetoVariables, TauEleOverlapChecker, TauGNNEvaluator, TauJetRNNEvaluator, TauPi0CreateROI, TauPi0ScoreCalculator, TauRecToolBase, tauRecTools::TauTrackRNNClassifier, tauRecTools::TrackRNN, TauShotFinder, TauTrackFinder, TauVertexedClusterDecorator, TauVertexFinder, TauVertexVariables, TauWPDecorator, TrackTruthSelectionTool, TrackVertexAssociationTool, Trig::DRScoringTool, Trig::EgammaDRScoringTool, Trig::IParticleRetrievalTool, Trig::JetManagerTool, Trig::MatchFromCompositeTool, Trig::MatchingTool, Trig::R3IParticleRetrievalTool, Trig::R3MatchingTool, Trig::StaticBunchCrossingTool, Trig::TrigConfBunchCrossingTool, Trig::TrigDecisionTool, Trig::TrigDecisionToolLite, Trig::TrigEgammaEmulationBaseHypoTool, Trig::TrigEgammaEmulationChain, Trig::TrigEgammaEmulationFastCaloHypoTool, Trig::TrigEgammaEmulationPrecisionElectronHypoTool, Trig::TrigEgammaEmulationPrecisionPhotonHypoTool, Trig::TrigEgammaEmulationToolMT, Trig::TrigMuonMatching, Trig::TypedScoringTool, Trig::xAODBunchCrossingTool, TrigConf::xAODConfigTool, TrigEgammaMatchingToolMT, TrigFastCalibWithRings, TrigGlobalEfficiencyCorrectionTool, Validator, VoronoiWeightTool, WeightsAgregator, WeightToolBase, xAOD::BPhysBlindingTool, xAOD::BPhysTrackVertexMapTool, xAOD::CaloIsolationTool, xAOD::TrackIsolationTool, xAODMaker::TriggerMenuMetaDataTool, xAODMaker::TruthMetaDataTool, xAODtoHepMCTool, ZDC::LISAnalysisTool, ZDC::RPDAnalysisTool, ZDC::RpdSubtractCentroidTool, ZDC::ZdcAnalysisTool, ZDC::ZdcLEDAnalysisTool, ZDC::ZdcRecTool, ZDC::ZdcTrigValidTool, ZdcByteStreamReadV1V2Tool, ZdcDataAccessV2, ZdcRecChannelToolLucrod, ZdcRecChannelToolV2, and ZMassConstraint::ConstraintFit.

Definition at line 133 of file AsgTool.h.

{ return StatusCode::SUCCESS; }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isChargeFlipElectron()

bool TruthClassificationTool::isChargeFlipElectron ( const xAOD::IParticle & electron, bool isTruthParticle, const xAOD::TruthParticle * truthParticle ) const

private

a helper to check if an electron has an incorrectly reconstructed charge

Definition at line 654 of file TruthClassificationTool.cxx.

{
  
 
  int type = isTruthParticle ? m_classifierParticleType(electron) : m_truthType(electron);
  int origin = isTruthParticle ? m_classifierParticleOrigin(electron) : m_truthOrigin(electron);
  int pdgId = isTruthParticle && truthParticle ? truthParticle->pdgId() : m_truthPdgId(electron);
  if (m_useTruthParticleDecorations && !isTruthParticle && truthParticle != nullptr)
  {
    type = m_classifierParticleType(*truthParticle);
    origin = m_classifierParticleOrigin(*truthParticle);
  }
 
  int firstMotherType = m_firstMotherTruthType(electron);
  int firstMotherOrigin = m_firstMotherTruthOrigin(electron);
  int firstMotherPdgId = m_firstMotherPdgId(electron);
 
  // not consider FSR photons from electrons (the photon has no charge)
  if (origin == MCTruthPartClassifier::FSRPhot && type == MCTruthPartClassifier::NonIsoPhoton && std::abs(pdgId) == 11)
  {
    return false;
  }
  if (type == MCTruthPartClassifier::BkgElectron && origin == MCTruthPartClassifier::PhotonConv
    && firstMotherType == MCTruthPartClassifier::NonIsoPhoton && firstMotherOrigin == MCTruthPartClassifier::FSRPhot
    && std::abs(pdgId) == 11)
  {
    return false;
  }
 
  // bkg electrons with no additional info to help us classify them FSR -- not in the charge flip category
  if (type == MCTruthPartClassifier::BkgElectron && origin == MCTruthPartClassifier::PhotonConv
    && firstMotherType == MCTruthPartClassifier::BkgElectron && firstMotherOrigin == MCTruthPartClassifier::PhotonConv
    && std::abs(pdgId) == 11)
  {
    return false;
  }
 
  if (isTruthParticle)
  {
    if (truthParticle && truthParticle->charge() != 0)
    {
      return (firstMotherPdgId * truthParticle->charge()) > 0;
    }
  }
  else
  {
    const xAOD::Electron &xAODElectron = *static_cast<const xAOD::Electron *> (&electron);
    if (xAODElectron.charge() != 0)
    {
      return (firstMotherPdgId * xAODElectron.charge()) > 0;
    }
  }
 
  return (firstMotherPdgId * (-pdgId)) > 0;
}

isChargeFlipMuon()

bool TruthClassificationTool::isChargeFlipMuon ( const xAOD::IParticle & muon, bool isTruthParticle, const xAOD::TruthParticle * truthParticle ) const

private

a helper to check if a muon has an incorrectly reconstructed charge

Definition at line 713 of file TruthClassificationTool.cxx.

{
  if (isTruthParticle)
  {
    return false;
  }
 
  if (truthParticle != nullptr && xAOD::P4Helpers::isInDeltaR(*truthParticle, muon, 0.025))
  {
    const xAOD::Muon &xAODMuon = *static_cast<const xAOD::Muon *> (&muon);
    return (truthParticle->charge() * xAODMuon.charge()) < 0;
  }
 
  ANA_MSG_DEBUG("Cannot find associated truth-particle... assuming muon has correct charge");
  return false;
}

isPromptElectron()

bool TruthClassificationTool::isPromptElectron ( const xAOD::IParticle & electron, bool isTruthParticle, const xAOD::TruthParticle * truthParticle ) const

private

a helper to check if an electron is prompt

Definition at line 606 of file TruthClassificationTool.cxx.

{
  
 
  int type = isTruthParticle ? m_classifierParticleType(electron) : m_truthType(electron);
  int origin = isTruthParticle ? m_classifierParticleOrigin(electron) : m_truthOrigin(electron);
  if (m_useTruthParticleDecorations && !isTruthParticle && truthParticle != nullptr)
  {
    type = m_classifierParticleType(*truthParticle);
    origin = m_classifierParticleOrigin(*truthParticle);
  }
 
  // Electron is IsoElectron - return true
  if (type == MCTruthPartClassifier::IsoElectron)
  {
    return true;
  }
 
  int pdgId = isTruthParticle ? truthParticle->pdgId() : m_truthPdgId(electron);
  int firstMotherType = m_firstMotherTruthType(electron);
  int firstMotherOrigin = m_firstMotherTruthOrigin(electron);
 
  // Adding these cases from ElectronEfficiencyHelpers
  if (firstMotherType == MCTruthPartClassifier::IsoElectron && std::abs(m_firstMotherPdgId(electron)) == 11)
  {
    return true;
  }
 
  // FSR photons from electrons
  if (origin == MCTruthPartClassifier::FSRPhot && type == MCTruthPartClassifier::NonIsoPhoton && std::abs(pdgId) == 11)
  {
    return true;
  }
 
  if (type == MCTruthPartClassifier::BkgElectron && origin == MCTruthPartClassifier::PhotonConv
    && firstMotherType == MCTruthPartClassifier::NonIsoPhoton && firstMotherOrigin == MCTruthPartClassifier::FSRPhot
    && std::abs(pdgId) == 11)
  {
    return true;
  }
 
  // If we reach here then it is not a prompt electron
  return false;
}

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

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

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.

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_classifierParticleOrigin

const SG::AuxElement::ConstAccessor<unsigned int> TruthClassificationTool::m_classifierParticleOrigin {"classifierParticleOrigin"}

private

Definition at line 55 of file TruthClassificationTool.h.

{"classifierParticleOrigin"};

m_classifierParticleType

const SG::AuxElement::ConstAccessor<unsigned int> TruthClassificationTool::m_classifierParticleType {"classifierParticleType"}

private

Definition at line 54 of file TruthClassificationTool.h.

{"classifierParticleType"};

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_fallbackDR

const SG::AuxElement::ConstAccessor<float> TruthClassificationTool::m_fallbackDR {"TruthClassifierFallback_dR"}

private

Definition at line 67 of file TruthClassificationTool.h.

{"TruthClassifierFallback_dR"};

m_fallbackTruthClassification

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_fallbackTruthClassification {"TruthClassifierFallback_truthClassification"}

private

Definition at line 66 of file TruthClassificationTool.h.

{"TruthClassifierFallback_truthClassification"};

m_fallbackTruthOrigin

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_fallbackTruthOrigin {"TruthClassifierFallback_truthOrigin"}

private

Definition at line 65 of file TruthClassificationTool.h.

{"TruthClassifierFallback_truthOrigin"};

m_fallbackTruthType

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_fallbackTruthType {"TruthClassifierFallback_truthType"}

private

Definition at line 64 of file TruthClassificationTool.h.

{"TruthClassifierFallback_truthType"};

m_firstMotherPdgId

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_firstMotherPdgId {"firstEgMotherPdgId"}

private

Definition at line 59 of file TruthClassificationTool.h.

{"firstEgMotherPdgId"};

m_firstMotherTruthClassification

const SG::AuxElement::ConstAccessor<unsigned int> TruthClassificationTool::m_firstMotherTruthClassification {"firstEgMotherTruthClassification"}

private

Definition at line 58 of file TruthClassificationTool.h.

{"firstEgMotherTruthClassification"};

m_firstMotherTruthOrigin

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_firstMotherTruthOrigin {"firstEgMotherTruthOrigin"}

private

Definition at line 57 of file TruthClassificationTool.h.

{"firstEgMotherTruthOrigin"};

m_firstMotherTruthType

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_firstMotherTruthType {"firstEgMotherTruthType"}

private

Definition at line 56 of file TruthClassificationTool.h.

{"firstEgMotherTruthType"};

m_lastMotherPdgId

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_lastMotherPdgId {"lastEgMotherPdgId"}

private

Definition at line 63 of file TruthClassificationTool.h.

{"lastEgMotherPdgId"};

m_lastMotherTruthClassification

const SG::AuxElement::ConstAccessor<unsigned int> TruthClassificationTool::m_lastMotherTruthClassification {"lastEgMotherTruthClassification"}

private

Definition at line 62 of file TruthClassificationTool.h.

{"lastEgMotherTruthClassification"};

m_lastMotherTruthOrigin

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_lastMotherTruthOrigin {"lastEgMotherTruthOrigin"}

private

Definition at line 61 of file TruthClassificationTool.h.

{"lastEgMotherTruthOrigin"};

m_lastMotherTruthType

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_lastMotherTruthType {"lastEgMotherTruthType"}

private

Definition at line 60 of file TruthClassificationTool.h.

{"lastEgMotherTruthType"};

m_separateChargeFlipElectrons

bool TruthClassificationTool::m_separateChargeFlipElectrons = false

private

separately store charge-flip electrons/muons

Definition at line 43 of file TruthClassificationTool.h.

m_separateChargeFlipMuons

bool TruthClassificationTool::m_separateChargeFlipMuons = false

private

Definition at line 44 of file TruthClassificationTool.h.

m_truthClassification

const SG::AuxElement::ConstAccessor<unsigned int> TruthClassificationTool::m_truthClassification {"truthClassification"}

private

Definition at line 52 of file TruthClassificationTool.h.

{"truthClassification"};

m_truthOrigin

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_truthOrigin {"truthOrigin"}

private

Definition at line 51 of file TruthClassificationTool.h.

{"truthOrigin"};

m_truthPdgId

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_truthPdgId {"truthPdgId"}

private

Definition at line 53 of file TruthClassificationTool.h.

{"truthPdgId"};

m_truthType

const SG::AuxElement::ConstAccessor<int> TruthClassificationTool::m_truthType {"truthType"}

private

Definition at line 50 of file TruthClassificationTool.h.

{"truthType"};

m_useTruthParticleDecorations

bool TruthClassificationTool::m_useTruthParticleDecorations {false}

private

use truth particle decorations

Definition at line 47 of file TruthClassificationTool.h.

{false};

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:

• TruthClassificationTool.h
• TruthClassificationTool.cxx