Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
MCTruthClassifier Class Referenceabstract

#include <MCTruthClassifier.h>

Inheritance diagram for MCTruthClassifier:
Collaboration diagram for MCTruthClassifier:

Public Member Functions

 MCTruthClassifier (const std::string &type)
 
virtual ~MCTruthClassifier ()=default
 
virtual StatusCode initialize () override
 Dummy implementation of the initialisation function. More...
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (const xAOD::TruthParticle *, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (const HepMcParticleLink &theLink, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (HepMC::ConstGenParticlePtr, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual const xAOD::TruthParticle * getGenPart (const xAOD::TrackParticle *, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual const xAOD::TruthParticle * egammaClusMatch (const xAOD::CaloCluster *, bool, MCTruthPartClassifier::Info *info) const override final
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (const xAOD::TrackParticle *, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (const xAOD::Electron *, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (const xAOD::Photon *, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (const xAOD::Muon *, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (const xAOD::CaloCluster *, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier (const xAOD::Jet *, bool DR, MCTruthPartClassifier::Info *info=nullptr) const override final
 
virtual void print () const =0
 Print the state of the tool. More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

double detEta (double x, double y) const
 
double detPhi (double x, double y) const
 
MCTruthPartClassifier::ParticleOrigin defOrigOfElectron (const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, bool &isPrompt, MCTruthPartClassifier::Info &info) const
 
MCTruthPartClassifier::ParticleOrigin defOrigOfMuon (const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, bool &isPrompt, MCTruthPartClassifier::Info &info) const
 
MCTruthPartClassifier::ParticleOrigin defOrigOfTau (const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, int motherPDG, MCTruthPartClassifier::Info &info) const
 
MCTruthPartClassifier::ParticleOrigin defOrigOfPhoton (const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, bool &isPrompt, MCTruthPartClassifier::Info &info) const
 
MCTruthPartClassifier::ParticleOrigin defOrigOfNeutrino (const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, bool &isPrompt, MCTruthPartClassifier::Info &info) const
 
bool genPartToCalo (const EventContext &ctx, const xAOD::CaloCluster *clus, const xAOD::TruthParticle *thePart, bool isFwrdEle, double &dRmatch, bool &isNarrowCone, const CaloDetDescrManager &caloDDMgr) const
 
double fracParticleInJet (const xAOD::TruthParticle *, const xAOD::Jet *, bool DR, bool nparts) const
 
void findJetConstituents (const xAOD::Jet *, std::set< const xAOD::TruthParticle * > &constituents, bool DR) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadHandleKey< xAOD::TruthParticleContainer > m_truthParticleContainerKey {this,"xAODTruthParticleContainerName","TruthParticles","ReadHandleKey for xAOD::TruthParticleContainer"}
 
ToolHandle< Trk::IParticleCaloExtensionTool > m_caloExtensionTool {this,"ParticleCaloExtensionTool",""}
 
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey {this,"CaloDetDescrManager",""}
 
ToolHandle< xAOD::ITruthParticlesInConeTool > m_truthInConeTool {this,"TruthInConeTool","xAOD::TruthParticlesInConeTool/TruthParticlesInConeTool"}
 
bool m_FwdElectronUseG4Sel
 
float m_FwdElectronTruthExtrEtaCut
 
float m_FwdElectronTruthExtrEtaWindowCut
 
float m_partExtrConeEta
 
float m_partExtrConePhi
 
bool m_useCaching
 
float m_phtClasConePhi
 
float m_phtClasConeEta
 
float m_phtdRtoTrCut
 
float m_fwrdEledRtoTrCut
 
bool m_ROICone
 
float m_pTChargePartCut
 
float m_pTNeutralPartCut
 
bool m_inclG4part
 
SG::ReadHandleKey< xAODTruthParticleLinkVector > m_truthLinkVecReadHandleKey {this,"xAODTruthLinkVector","xAODTruthLinks", "ReadHandleKey for xAODTruthParticleLinkVector"}
 
float m_deltaRMatchCut
 
float m_deltaPhiMatchCut
 
int m_NumOfSiHitsCut
 
float m_jetPartDRMatch
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 55 of file MCTruthClassifier.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

◆ MCTruthClassifier()

MCTruthClassifier::MCTruthClassifier ( const std::string &  type)
inline

Definition at line 65 of file MCTruthClassifier.h.

96  {
97  ATH_MSG_INFO(" Initializing MCTruthClassifier");

◆ ~MCTruthClassifier()

virtual MCTruthClassifier::~MCTruthClassifier ( )
virtualdefault

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ defOrigOfElectron()

ParticleOrigin MCTruthClassifier::defOrigOfElectron ( const xAOD::TruthParticleContainer &  xTruthParticleContainer,
const xAOD::TruthParticle *  thePart,
bool &  isPrompt,
MCTruthPartClassifier::Info &  info 
) const
private

Definition at line 225 of file MCTruthClassifierGen.cxx.

229 {
230  ATH_MSG_DEBUG("Executing DefOrigOfElectron ");
231 
232  // Find the first copy of this particle stored in the xAOD::TruthParticleContainer (i.e. the particle prior to any interactions)
233  const xAOD::TruthParticle* thePriPart = MC::findMatching(xTruthParticleContainer, thePart);
234  if (!thePriPart) return NonDefined;
235  if (!MC::isElectron(thePriPart)) return NonDefined;
236 
237  const xAOD::TruthVertex* partOriVert = thePriPart->hasProdVtx() ? thePriPart->prodVtx() : nullptr;
238 
239  //-- to define electron outcome status
240  info.particleOutCome = defOutComeOfElectron(thePriPart);
241 
242  if (!partOriVert) return NonDefined;
243 
244  int numOfParents = partOriVert->nIncomingParticles();
245  if (numOfParents > 1) ATH_MSG_DEBUG("DefOrigOfElectron:: electron has more than one mother ");
246 
247  const xAOD::TruthParticle* mother = MC::findMother(thePriPart);
248  info.setMotherProperties(mother);
249  if (!mother) { return NonDefined; } // mother is not a nullptr beyond this point
250 
251  int motherPDG = mother->pdgId();
252  const xAOD::TruthVertex* mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
253 
254  bool samePart = false;
255  for (const auto& theDaug: partOriVert->particles_out()) {
256  if (!theDaug) continue;
257  if (motherPDG == theDaug->pdgId() && HepMC::is_same_generator_particle(theDaug, mother)) samePart = true;
258  }
259 
260  // to resolve Sherpa loop
261  if (mothOriVert && HepMC::is_same_vertex(mothOriVert,partOriVert)) samePart = true;
262  //
263 
264  if ((MC::isMuon(motherPDG) || MC::isTau(motherPDG) || MC::isW(motherPDG)) && mothOriVert && !samePart) {
265  int pPDG(0);
266  const xAOD::TruthParticle* MotherParent{};
267  do {
268  pPDG = 0;
269  MotherParent = MC::findMother(mother);
270  // to prevent Sherpa loop
271  const xAOD::TruthVertex* mother_prdVtx{};
272  const xAOD::TruthVertex* mother_endVtx{};
273  if (mother) {
274  mother_prdVtx = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
275  mother_endVtx = mother->decayVtx();
276  }
277  const xAOD::TruthVertex* parent_prdVtx{};
278  const xAOD::TruthVertex* parent_endVtx{};
279  if (MotherParent) {
280  parent_prdVtx = MotherParent->hasProdVtx() ? MotherParent->prodVtx() : nullptr;
281  parent_endVtx = MotherParent->decayVtx();
282  }
283  if (mother_endVtx == parent_prdVtx && mother_prdVtx == parent_endVtx) {
284  MotherParent = mother;
285  break;
286  }
287  //
288  if (MotherParent) pPDG = MotherParent->pdgId();
289  // to prevent Sherpa loop
290  if (mother == MotherParent) break;
291  if (MC::isMuon(pPDG) || MC::isTau(pPDG) || MC::isW(pPDG)) mother = MotherParent;
292 
293  } while ((MC::isMuon(pPDG) || MC::isTau(pPDG) || MC::isW(pPDG)));
294 
295  if (MC::isMuon(pPDG) || MC::isTau(pPDG) || MC::isW(pPDG) || MC::isZ(pPDG) || MC::isHiggs(pPDG) ||
296  MC::isMSSMHiggs(pPDG) || MC::isHeavyBoson(pPDG) || MC::isTop(pPDG) || // MSSM Higgs bosons, Heavy bosons( Z', Z'', W'+)
297  abs(pPDG) == MC::WBOSON_LRSM || MC::isNeutrinoRH(pPDG) || // Left-right symmetric model WBoson || Right-handed neutrino (Pythia-specific)
298  MC::isSUSY(pPDG))
299  mother = MotherParent; // FIXME difference in behaviour compared to MCTruthClassifier::defOrigOfMuon/Neutrino
300  }
301 
302  motherPDG = mother->pdgId();
303  partOriVert = mother->decayVtx();
304  mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
305  numOfParents = partOriVert->nIncomingParticles();
306  const int numOfDaug = partOriVert->nOutgoingParticles();
307 
308  info.setMotherProperties(mother);
309 
310  int NumOfPhot(0);
311  int NumOfEl(0);
312  int NumOfPos(0);
313  int NumOfNucFr(0);
314  int NumOfquark(0);
315  int NumOfgluon(0);
316  int NumOfElNeut(0);
317  int NumOfLQ(0);
318  int NumOfMuPl(0);
319  int NumOfMuMin(0);
320  int NumOfMuNeut(0);
321  int NumOfTau(0);
322  int NumOfTauNeut(0);
323  samePart = false;
324 
325  for (const auto& theDaug: partOriVert->particles_out()) {
326  if (!theDaug) continue;
327  int DaugType = theDaug->pdgId();
328  if (MC::isSMQuark(DaugType)) NumOfquark++;
329  else if (MC::isGluon(DaugType)) NumOfgluon++;
330  else if (abs(DaugType) == MC::NU_E) NumOfElNeut++;
331  else if (abs(DaugType) == MC::NU_MU) NumOfMuNeut++;
332  else if (MC::isPhoton(DaugType)) NumOfPhot++;
333  else if (DaugType == MC::ELECTRON) NumOfEl++;
334  else if (DaugType == MC::POSITRON) NumOfPos++;
335  else if (DaugType == MC::MUON) NumOfMuMin++;
336  else if (DaugType == -MC::MUON) NumOfMuPl++;
337  else if (MC::isTau(DaugType)) NumOfTau++;
338  else if (abs(DaugType) == MC::NU_TAU) NumOfTauNeut++;
339  else if (MC::isLeptoQuark(DaugType)) NumOfLQ++;
340  if (abs(DaugType) == abs(motherPDG) && theDaug && HepMC::is_same_generator_particle(theDaug, mother )) samePart = true;
341  if (numOfParents == 1 &&
342  (MC::isPhoton(motherPDG) || MC::isElectron(motherPDG) || MC::isMuon(motherPDG) || abs(motherPDG) == MC::PIPLUS) &&
343  (MC::isNucleus(DaugType) || DaugType == 0 || DaugType == MC::PROTON || DaugType == MC::NEUTRON ||
344  abs(DaugType) == MC::PIPLUS || abs(DaugType) == MC::PI0))
345  NumOfNucFr++;
346  }
347 
348  if (MC::isPhoton(motherPDG) && mothOriVert) {
349  if (mothOriVert->nIncomingParticles() > 1) { ATH_MSG_DEBUG("DefOrigOfElectron:: photon has more than one parent."); }
350  for (const auto& theMother: mothOriVert->particles_in()) {
351  if (!theMother) continue;
352  info.photonMother = theMother; // FIXME Just taking the first one...
353  }
354  }
355 
356  if ((MC::isPhoton(motherPDG) && numOfDaug == 2 && NumOfEl == 1 && NumOfPos == 1) || (MC::isPhoton(motherPDG) && numOfDaug == 1 && (NumOfEl == 1 || NumOfPos == 1))) return PhotonConv;
357 
358  // e,gamma,pi+Nuclear->NuclearFragments+nuclons+e
359  if ((numOfParents == 1 && (MC::isPhoton(motherPDG) || MC::isElectron(motherPDG) || MC::isTau(motherPDG))) && numOfDaug > 1 && NumOfNucFr != 0) return ElMagProc;
360 
361  if (numOfParents == 1 && abs(motherPDG) == MC::PIPLUS && numOfDaug > 2 && NumOfNucFr != 0) return ElMagProc;
362 
363  // nuclear photo fission
364  if (MC::isPhoton(motherPDG) && numOfDaug > 4 && NumOfNucFr != 0) return ElMagProc;
365 
366  // unknown process el(pos)->el+pos??
367  if (MC::isElectron(motherPDG) && numOfDaug == 2 && NumOfEl == 1 && NumOfPos == 1) return ElMagProc;
368 
369  // unknown process el->el+el??
370  if (motherPDG == MC::ELECTRON && numOfDaug == 2 && NumOfEl == 2 && NumOfPos == 0) return ElMagProc;
371 
372  // unknown process pos->pos+pos??
373  if (motherPDG == MC::POSITRON && numOfDaug == 2 && NumOfEl == 0 && NumOfPos == 2) return ElMagProc;
374 
375  // unknown process pos/el->pos/el??
376  if (MC::isElectron(motherPDG) && !MC::isDecayed(mother) && motherPDG == thePriPart->pdgId() && numOfDaug == 1 && !samePart) return ElMagProc;
377 
378  // pi->pi+e+/e-; mu->mu+e+/e- ;
379  // gamma+ atom->gamma(the same) + e (compton scattering)
380  if (numOfDaug == 2 && (NumOfEl == 1 || NumOfPos == 1) && !MC::isElectron(motherPDG) && samePart) return ElMagProc;
381 
382  if ((motherPDG == MC::PI0 && numOfDaug == 3 && NumOfPhot == 1 && NumOfEl == 1 && NumOfPos == 1) ||
383  (motherPDG == MC::PI0 && numOfDaug == 4 && NumOfPhot == 0 && NumOfEl == 2 && NumOfPos == 2))
384  return DalitzDec;
385 
386  // Quark weak decay
387  if (MC::isSMQuark(motherPDG) && numOfParents == 1 && numOfDaug == 3 && NumOfquark == 1 && NumOfElNeut == 1) return QuarkWeakDec;
388 
389  if (MC::isMuon(motherPDG) && NumOfNucFr != 0) return ElMagProc;
390 
391  if (MC::isTop(motherPDG)) return top;
392 
393  if (MC::isW(motherPDG) && mothOriVert && mothOriVert->nIncomingParticles() != 0) {
394 
395  const xAOD::TruthVertex* prodVert = mothOriVert;
396  const xAOD::TruthParticle* ptrPart;
397  do {
398  ptrPart = prodVert->incomingParticle(0); // FIXME just taking the first one
399  prodVert = ptrPart->hasProdVtx() ? ptrPart->prodVtx() : nullptr;
400  } while (MC::isW(ptrPart) && prodVert);
401 
402  if (prodVert && prodVert->nIncomingParticles() == 1) {
403  if (abs(ptrPart->pdgId()) == MC::RH_NU_E) return NuREle; // Right-handed NU_E (Pythia-specific)
404  if (abs(ptrPart->pdgId()) == MC::RH_NU_MU) return NuRMu; // Right-handed NU_MU (Pythia-specific)
405  if (abs(ptrPart->pdgId()) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
406  }
407  return WBoson;
408  }
409  if (MC::isW(motherPDG)) return WBoson;
410  if (MC::isZ(motherPDG)) return ZBoson;
411 
412  // MadGraphPythia ZWW*->lllnulnu
413  if (numOfParents == 1 && numOfDaug > 4 && (MC::isSMQuark(motherPDG) || MC::isGluon(motherPDG))) {
414 
415  const xAOD::TruthParticle* thePartToCheck = thePriPart;
416  const xAOD::TruthParticle* theMother = thePriPart->hasProdVtx() ? thePriPart->prodVtx()->incomingParticle(0) : nullptr; // FIXME just taking the first one
417  if (theMother && MC::isElectron(theMother) && MC::isDecayed(theMother)) thePartToCheck = theMother;
418 
419  bool isZboson = false;
420  bool isWboson = false;
421  bool skipnext = false;
422 
423  for (unsigned int ipOut = 0; ipOut + 1 < partOriVert->nOutgoingParticles(); ++ipOut) {
424  const xAOD::TruthParticle* theDaug = partOriVert->outgoingParticle(ipOut);
425  if (!theDaug) continue;
426  const xAOD::TruthParticle* theNextDaug = nullptr;
427  for (unsigned int ipOut1 = ipOut + 1; ipOut1 < partOriVert->nOutgoingParticles(); ipOut1++) {
428  theNextDaug = partOriVert->outgoingParticle(ipOut1);
429  if (theNextDaug) break;
430  }
431  if (!theNextDaug) continue;
432  if (skipnext) {
433  skipnext = false;
434  continue;
435  }
436 
437  if (MC::isElectron(theDaug) && MC::isElectron(theNextDaug)) {
438  // Zboson
439  if (thePartToCheck == theDaug || thePartToCheck == theNextDaug) {
440  isZboson = true;
441  break;
442  }
443  skipnext = true;
444  } else if (MC::isElectron(theDaug) && abs(theNextDaug->pdgId()) == MC::NU_E) {
445  // WBoson
446  if (thePartToCheck == theDaug || thePartToCheck == theNextDaug) {
447  isWboson = true;
448  break;
449  }
450  skipnext = true;
451  }
452  }
453  if (isWboson) return WBoson;
454  if (isZboson) return ZBoson;
455  }
456  if (numOfParents == 2) {
457  const int pdg1 = partOriVert->incomingParticle(0)->pdgId();
458  const int pdg2 = partOriVert->incomingParticle(1)->pdgId();
459  //--Sherpa Z->ee
460  if ((numOfDaug - NumOfquark - NumOfgluon) == 2 && NumOfEl == 1 && NumOfPos == 1) return ZBoson;
461 
462  //--Sherpa W->enu ??
463  if ((numOfDaug - NumOfquark - NumOfgluon) == 2 && (NumOfEl == 1 || NumOfPos == 1) && NumOfElNeut == 1) return WBoson;
464 
465  //--Sherpa ZZ,ZW
466  if ((numOfDaug - NumOfquark - NumOfgluon) == 4 && (NumOfEl + NumOfPos + NumOfMuPl + NumOfMuMin + NumOfTau + NumOfElNeut + NumOfMuNeut + NumOfTauNeut == 4) &&
467  (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return DiBoson;
468 
469  //--Sherpa VVV -- Note, have to allow for prompt photon radiation or these get lost
470  if ((numOfDaug - NumOfquark - NumOfgluon - NumOfPhot) == 6 && (NumOfEl + NumOfPos + NumOfMuPl + NumOfMuMin + NumOfTau + NumOfElNeut + NumOfMuNeut + NumOfTauNeut == 6) &&
471  (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return MultiBoson;
472  }
473 
474  // New Sherpa Z->ee
475  if (partOriVert == mothOriVert && partOriVert) {
476  int NumOfEleLoop = 0;
477  int NumOfLepLoop = 0;
478  int NumOfEleNeuLoop = 0;
479  for (const auto *const pout: partOriVert->particles_out()) {
480  if (!pout) continue;
481  for (const auto *const pin: partOriVert->particles_in()) {
482  if (!pin) continue;
483  if (!HepMC::is_same_particle(pout,pin)) continue;
484  if (MC::isElectron(pout)) NumOfEleLoop++;
485  if (std::abs(pin->pdgId()) == MC::NU_E) NumOfEleNeuLoop++; // FIXME pin vs pout difference in behaviour compared to MCTruthClassifier::defOrigOfMuon
486  if (MC::isSMLepton(pout)) NumOfLepLoop++;
487  }
488  }
489  if (NumOfEleLoop == 2 && NumOfEleNeuLoop == 0) return ZBoson;
490  if (NumOfEleLoop == 1 && NumOfEleNeuLoop == 1) return WBoson;
491  if ((NumOfEleLoop == 4 && NumOfEleNeuLoop == 0) || (NumOfEleLoop == 3 && NumOfEleNeuLoop == 1) ||
492  (NumOfEleLoop == 2 && NumOfEleNeuLoop == 2))
493  return DiBoson;
494  if (NumOfLepLoop == 4) return DiBoson;
495  }
496 
497  //-- McAtNLo
498 
499  if (MC::isHiggs(motherPDG)) return Higgs;
500 
501  if (MC::isMSSMHiggs(motherPDG)) return HiggsMSSM; // MSSM Higgs bosons
502 
503  if (MC::isHeavyBoson(motherPDG)) return HeavyBoson; // Heavy bosons( Z', Z'', W'+)
504 
505  if (MC::isMuon(motherPDG)) return Mu;
506  if (MC::isTau(motherPDG)) {
507  const ParticleOrigin tauOrig = defOrigOfTau(xTruthParticleContainer, mother, motherPDG, info);
508  const ParticleType tautype = defTypeOfTau(tauOrig);
509  return (tautype == IsoTau)?tauOrig:TauLep;
510  }
511 
512  if (abs(motherPDG) == MC::WBOSON_LRSM) return WBosonLRSM; // Left-right symmetric model WBoson (Pythia-specific)
513  if (abs(motherPDG) == MC::RH_NU_E) return NuREle; // Right-handed NU_E (Pythia-specific)
514  if (abs(motherPDG) == MC::RH_NU_MU) return NuRMu; // Right-handed NU_MU (Pythia-specific)
515  if (abs(motherPDG) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
516  if (MC::isLeptoQuark(motherPDG) || NumOfLQ != 0) return LQ;
517  if (MC::isSUSY(motherPDG)) return SUSY;
518  if (MC::isBSM(motherPDG)) return OtherBSM;
519  const ParticleType pType = defTypeOfHadron(motherPDG);
520  if ((pType == BBbarMesonPart || pType == CCbarMesonPart) && mothOriVert && MC::isHardScatteringVertex(mothOriVert)) isPrompt = true;
521  return convHadronTypeToOrig(pType, motherPDG);
522 }

◆ defOrigOfMuon()

ParticleOrigin MCTruthClassifier::defOrigOfMuon ( const xAOD::TruthParticleContainer &  xTruthParticleContainer,
const xAOD::TruthParticle *  thePart,
bool &  isPrompt,
MCTruthPartClassifier::Info &  info 
) const
private

Definition at line 525 of file MCTruthClassifierGen.cxx.

529 {
530  ATH_MSG_DEBUG("Executing DefOrigOfMuon ");
531 
532  // Find the first copy of this particle stored in the xAOD::TruthParticleContainer (i.e. the particle prior to any interactions)
533  const xAOD::TruthParticle* thePriPart = MC::findMatching(xTruthParticleContainer, thePart);
534  if (!thePriPart) return NonDefined;
535  if (!MC::isMuon(thePriPart)) return NonDefined;
536 
537  const xAOD::TruthVertex* partOriVert = thePriPart->hasProdVtx() ? thePriPart->prodVtx() : nullptr;
538 
539  //-- to define muon outcome status
540  info.particleOutCome = defOutComeOfMuon(thePriPart);
541 
542  if (!partOriVert) return NonDefined;
543 
544  int numOfParents = partOriVert->nIncomingParticles();
545  if (numOfParents > 1) ATH_MSG_DEBUG("DefOrigOfMuon:: muon has more than one mother ");
546 
547  const xAOD::TruthParticle* mother = MC::findMother(thePriPart);
548  info.setMotherProperties(mother);
549  if (!mother) { return NonDefined; } // mother is not a nullptr beyond this point
550 
551  const xAOD::TruthVertex* mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
552  int motherPDG = mother->pdgId();
553 
554  if ((MC::isTau(motherPDG)|| MC::isW(motherPDG)) && mothOriVert) {
555  int pPDG(0);
556  const xAOD::TruthParticle* MotherParent{};
557  do {
558  //
559  pPDG = 0;
560  //
561  const xAOD::TruthVertex* mother_prdVtx{};
562  const xAOD::TruthVertex* mother_endVtx{};
563  MotherParent = MC::findMother(mother);
564  // to prevent Sherpa loop
565  mother_prdVtx = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
566  mother_endVtx = mother->decayVtx();
567  //
568  const xAOD::TruthVertex* parent_prdVtx{};
569  const xAOD::TruthVertex* parent_endVtx{};
570  if (MotherParent) {
571  parent_prdVtx = MotherParent->hasProdVtx() ? MotherParent->prodVtx() : nullptr;
572  parent_endVtx = MotherParent->decayVtx();
573  }
574  //
575  if (mother_endVtx == parent_prdVtx && mother_prdVtx == parent_endVtx) {
576  MotherParent = mother;
577  break;
578  }
579  //
580  // to prevent Sherpa loop
581  if (mother == MotherParent) {
582  break;
583  }
584 
585  if (MotherParent) {
586  pPDG = MotherParent->pdgId();
587  if (MC::isMuon(pPDG) || MC::isTau(pPDG) || MC::isW(pPDG)) {
588  mother = MotherParent;
589  info.setMotherProperties(mother);
590  }
591  }
592  } while ((MC::isMuon(pPDG) || MC::isTau(pPDG) || MC::isW(pPDG))); // FIXME should this be (MC::isTau(pPDG) || MC::isW(pPDG)) ???
593 
594  if (MC::isTau(pPDG) || MC::isW(pPDG) || MC::isZ(pPDG) || MC::isHiggs(pPDG) ||
595  MC::isMSSMHiggs(pPDG) || MC::isHeavyBoson(pPDG) || MC::isTop(pPDG) || // MSSM Higgs bosons, Heavy bosons( Z', Z'', W'+)
596  abs(pPDG) == MC::WBOSON_LRSM || MC::isNeutrinoRH(pPDG) || // Left-right symmetric model WBoson || Right-handed neutrino (Pythia-specific)
597  MC::isSUSY(pPDG)) {
598  info.setMotherProperties(mother); // FIXME difference in behaviour compared to MCTruthClassifier::defOrigOfElectron
599  }
600  }
601 
602  motherPDG = mother->pdgId();
603  mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
604  partOriVert = mother->decayVtx();
605  numOfParents = partOriVert->nIncomingParticles();
606  const int numOfDaug = partOriVert->nOutgoingParticles();
607 
608  info.setMotherProperties(mother);
609  auto DP = DecayProducts(partOriVert);
610  const int NumOfPhot = DP.pd(MC::PHOTON);
611  const int NumOfEl = DP.pd(MC::ELECTRON);
612  const int NumOfPos = DP.pd(MC::POSITRON);
613  const int NumOfElNeut = DP.apd(MC::NU_E);
614  const int NumOfMuNeut = DP.apd(MC::NU_MU);
615  const int NumOfLQ = DP.apd(MC::LEPTOQUARK);
616  const int NumOfquark = DP.apd({MC::DQUARK,MC::UQUARK,MC::SQUARK,MC::CQUARK,MC::BQUARK,MC::TQUARK});
617  const int NumOfgluon = DP.apd(MC::GLUON);
618  const int NumOfMuPl = DP.pd(-MC::MUON);
619  const int NumOfMuMin = DP.pd(MC::MUON);
620  const int NumOfTau = DP.apd(MC::TAU);
621  const int NumOfTauNeut = DP.apd(MC::NU_TAU);
622  if (std::abs(motherPDG) == MC::PIPLUS && numOfDaug == 2 && NumOfMuNeut == 1) return PionDecay;
623  if (std::abs(motherPDG) == MC::KPLUS && numOfDaug == 2 && NumOfMuNeut == 1) return KaonDecay;
624  if (MC::isTau(motherPDG)) {
625  const ParticleOrigin tauOrig = defOrigOfTau(xTruthParticleContainer, mother, motherPDG, info);
626  const ParticleType tautype = defTypeOfTau(tauOrig);
627  return (tautype == IsoTau)?tauOrig:TauLep;
628  }
629 
630  if (MC::isTop(motherPDG)) return top;
631  // Quark weak decay
632  if (MC::isSMQuark(motherPDG) && numOfParents == 1 && numOfDaug == 3 && NumOfquark == 1 && NumOfMuNeut == 1) return QuarkWeakDec;
633 
634  if (MC::isW(motherPDG) && mothOriVert && mothOriVert->nIncomingParticles() != 0) {
635  const xAOD::TruthVertex* prodVert = mothOriVert;
636  const xAOD::TruthParticle* itrP;
637  do {
638  itrP = prodVert->incomingParticle(0); // FIXME just taking the first one
639  prodVert = itrP->hasProdVtx() ? itrP->prodVtx() : nullptr;
640  } while (MC::isW(itrP) && prodVert);
641 
642  if (prodVert && prodVert->nIncomingParticles() == 1) {
643  if (abs(itrP->pdgId()) == MC::RH_NU_E) return NuREle; // Right-handed NU_E (Pythia-specific)
644  if (abs(itrP->pdgId()) == MC::RH_NU_MU) return NuRMu; // Right-handed NU_MU (Pythia-specific)
645  if (abs(itrP->pdgId()) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
646  }
647  return WBoson;
648  }
649  if (MC::isW(motherPDG)) return WBoson;
650  if (MC::isZ(motherPDG)) return ZBoson;
651  if (MC::isPhoton(motherPDG) && numOfDaug == 2 && NumOfMuMin == 1 && NumOfMuPl == 1) return PhotonConv;
652  //-- Exotics
653 
654  // MadGraphPythia ZWW*->lllnulnu
655 
656  if (numOfParents == 1 && numOfDaug > 4 && (MC::isSMQuark(motherPDG) || MC::isGluon(motherPDG))) {
657  bool isZboson = false;
658  bool isWboson = false;
659  bool skipnext = false;
660  for (unsigned int ipOut = 0; ipOut + 1 < partOriVert->nOutgoingParticles(); ipOut++) {
661  if (skipnext) {
662  skipnext = false;
663  continue;
664  }
665  const xAOD::TruthParticle* theDaug = partOriVert->outgoingParticle(ipOut);
666  if (!theDaug) continue;
667  const xAOD::TruthParticle* theNextDaug{};
668  for (unsigned int ipOut1 = ipOut + 1; ipOut1 < partOriVert->nOutgoingParticles(); ipOut1++) {
669  theNextDaug = partOriVert->outgoingParticle(ipOut1);
670  if (theNextDaug) break;
671  }
672  if (!theNextDaug) continue;
673  if (MC::isMuon(theDaug) && MC::isMuon(theNextDaug)) {
674  // Zboson
675  if (thePriPart == theDaug || thePriPart == theNextDaug) {
676  isZboson = true;
677  break;
678  }
679  skipnext = true;
680  } else if (MC::isMuon(theDaug) && abs(theNextDaug->pdgId()) == MC::NU_MU) {
681  // WBoson
682  if (thePriPart == theDaug || thePriPart == theNextDaug) {
683  isWboson = true;
684  break;
685  }
686  skipnext = true;
687  }
688  }
689  if (isWboson) return WBoson;
690  if (isZboson) return ZBoson;
691  }
692  if (numOfParents == 2 ) {
693  const int pdg1 = partOriVert->incomingParticle(0)->pdgId();
694  const int pdg2 = partOriVert->incomingParticle(1)->pdgId();
695  //--Sherpa Z->mumu
696  if ((numOfDaug - NumOfquark - NumOfgluon) == 2 && NumOfMuPl == 1 && NumOfMuMin == 1) return ZBoson;
697 
698  //--Sherpa W->munu ??
699  // if(numOfParents==2&&(numOfDaug-NumOfquark-NumOfgluon)==2&&(NumOfEl==1||NumOfPos==1)&&NumOfElNeut==1) return WBoson;
700  if ((numOfDaug - NumOfquark - NumOfgluon) == 2 && (NumOfMuPl == 1 || NumOfMuMin == 1) && NumOfMuNeut == 1) return WBoson;
701 
702  //--Sherpa ZZ,ZW
703  if ((numOfDaug - NumOfquark - NumOfgluon) == 4 &&
704  (NumOfEl + NumOfPos + NumOfMuPl + NumOfMuMin + NumOfTau + NumOfElNeut + NumOfMuNeut + NumOfTauNeut == 4) &&
705  (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return DiBoson;
706 
707  //--Sherpa VVV -- Note, have to allow for prompt photon radiation or these get lost
708  if ((numOfDaug - NumOfquark - NumOfgluon - NumOfPhot) == 6 &&
709  (NumOfEl + NumOfPos + NumOfMuPl + NumOfMuMin + NumOfTau + NumOfElNeut + NumOfMuNeut + NumOfTauNeut == 6) &&
710  (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return MultiBoson;
711  }
712 
713  //--New Sherpa Z->mumu
714  if (partOriVert == mothOriVert) {
715  int NumOfMuLoop = 0;
716  int NumOfMuNeuLoop = 0;
717  int NumOfLepLoop = 0;
718  for (const auto & pout: partOriVert->particles_out()) {
719  for (const auto & pin: partOriVert->particles_in()) {
720  if (!pout) continue;
721  if (!pin) continue;
722  if (HepMC::is_same_particle(pout,pin)) {
723  if (MC::isMuon(pout)) NumOfMuLoop++;
724  if (std::abs(pout->pdg_id()) == MC::NU_MU) NumOfMuNeuLoop++; // FIXME pin vs pout difference in behaviour compared to MCTruthClassifier::defOrigOfElectron
725  if (MC::isSMLepton(pout)) NumOfLepLoop++;
726  }
727  }
728  }
729  if (NumOfMuLoop == 2 && NumOfMuNeuLoop == 0) return ZBoson;
730  if (NumOfMuLoop == 1 && NumOfMuNeuLoop == 1) return WBoson;
731  if ((NumOfMuLoop == 4 && NumOfMuNeuLoop == 0) || (NumOfMuLoop == 3 && NumOfMuNeuLoop == 1) || (NumOfMuLoop == 2 && NumOfMuNeuLoop == 2)) return DiBoson;
732  if (NumOfLepLoop == 4) return DiBoson;
733  }
734 
735  //-- McAtNLo
736 
737  if (MC::isHiggs(motherPDG)) return Higgs;
738 
739  if (MC::isMSSMHiggs(motherPDG)) return HiggsMSSM; // MSSM Higgs bosons
740 
741  if (MC::isHeavyBoson(motherPDG)) return HeavyBoson; // Heavy bosons( Z', Z'', W'+)
742 
743  if (abs(motherPDG) == MC::WBOSON_LRSM) return WBosonLRSM; // Left-right symmetric model WBoson (Pythia-specific)
744  if (abs(motherPDG) == MC::RH_NU_E) return NuREle; // Right-handed NU_E (Pythia-specific)
745  if (abs(motherPDG) == MC::RH_NU_MU) return NuRMu; // Right-handed NU_MU (Pythia-specific)
746  if (abs(motherPDG) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
747  if (MC::isLeptoQuark(motherPDG) || NumOfLQ != 0) return LQ;
748  if (MC::isSUSY(motherPDG)) return SUSY;
749  if (MC::isBSM(motherPDG)) return OtherBSM;
750 
751  const ParticleType pType = defTypeOfHadron(motherPDG);
752  if ((pType == BBbarMesonPart || pType == CCbarMesonPart) && mothOriVert && MC::isHardScatteringVertex(mothOriVert)) isPrompt = true;
753 
754  return convHadronTypeToOrig(pType, motherPDG);
755 }

◆ defOrigOfNeutrino()

ParticleOrigin MCTruthClassifier::defOrigOfNeutrino ( const xAOD::TruthParticleContainer &  xTruthParticleContainer,
const xAOD::TruthParticle *  thePart,
bool &  isPrompt,
MCTruthPartClassifier::Info &  info 
) const
private

Definition at line 1190 of file MCTruthClassifierGen.cxx.

1194 {
1195  ATH_MSG_DEBUG("Executing DefOrigOfNeutrino ");
1196 
1197  const int nuFlav = abs(thePart->pdgId());
1198  // Find the first copy of this particle stored in the xAOD::TruthParticleContainer (i.e. the particle prior to any interactions)
1199  const xAOD::TruthParticle* thePriPart = MC::findMatching(xTruthParticleContainer, thePart);
1200  if (!thePriPart) return NonDefined;
1201  if (abs(thePriPart->pdgId()) != nuFlav) return NonDefined;
1202 
1203  const xAOD::TruthVertex* partOriVert = thePriPart->hasProdVtx() ? thePriPart->prodVtx() : nullptr;
1204 
1205  //-- to define neutrino outcome status
1206  info.particleOutCome = NonInteract;
1207 
1208  if (!partOriVert) return NonDefined;
1209 
1210  int numOfParents = partOriVert->nIncomingParticles();
1211  if (numOfParents > 1) ATH_MSG_DEBUG("DefOrigOfNeutrino:: neutrino has more than one mother ");
1212 
1213  const xAOD::TruthParticle* mother = MC::findMother(thePriPart);
1214  info.setMotherProperties(mother);
1215  if (!mother) { return NonDefined; } // mother is not a nullptr beyond this point
1216 
1217  int motherPDG = mother->pdgId();
1218  const xAOD::TruthVertex* mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
1219 
1220  // to resolve Sherpa loop
1221  bool samePart = false;
1222  if (mothOriVert && HepMC::is_same_vertex(mothOriVert,partOriVert)) samePart = true;
1223  //
1224  if ((abs(motherPDG) == nuFlav || MC::isTau(motherPDG) || MC::isW(motherPDG)) && mothOriVert &&
1225  !samePart) {
1226  int pPDG(0);
1227  const xAOD::TruthParticle* MotherParent{};
1228  do {
1229  pPDG = 0;
1230  MotherParent = MC::findMother(mother);
1231  // to prevent Sherpa loop
1232  const xAOD::TruthVertex* mother_prdVtx{};
1233  const xAOD::TruthVertex* mother_endVtx{};
1234  if (mother) {
1235  mother_prdVtx = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
1236  mother_endVtx = mother->decayVtx();
1237  }
1238  const xAOD::TruthVertex* parent_prdVtx{};
1239  const xAOD::TruthVertex* parent_endVtx{};
1240  if (MotherParent) {
1241  parent_prdVtx = MotherParent->hasProdVtx() ? MotherParent->prodVtx() : nullptr;
1242  parent_endVtx = MotherParent->decayVtx();
1243  }
1244  if (mother_endVtx == parent_prdVtx && mother_prdVtx == parent_endVtx) {
1245  MotherParent = mother;
1246  break;
1247  }
1248  //
1249  if (MotherParent) {
1250  pPDG = MotherParent->pdgId();
1251  }
1252  // to prevent Sherpa loop
1253  if (mother == MotherParent) {
1254  break;
1255  }
1256  if (abs(pPDG) == nuFlav || MC::isTau(pPDG) || MC::isW(pPDG) ) {
1257  mother = MotherParent;
1258  info.setMotherProperties(mother);
1259  }
1260 
1261  } while ((std::abs(pPDG) == nuFlav || MC::isTau(pPDG) || MC::isW(pPDG)));
1262 
1263  if (std::abs(pPDG) == nuFlav || MC::isTau(pPDG) || MC::isW(pPDG) || MC::isZ(pPDG) || MC::isHiggs(pPDG) ||
1264  MC::isMSSMHiggs(pPDG) || MC::isHeavyBoson(pPDG) || MC::isTop(pPDG) || // MSSM Higgs bosons, Heavy bosons( Z', Z'', W'+)
1265  std::abs(pPDG) == MC::WBOSON_LRSM || MC::isNeutrinoRH(pPDG) || // Left-right symmetric model WBoson || Right-handed neutrino (Pythia-specific)
1266  MC::isSUSY(pPDG)) {
1267  mother = MotherParent;
1268  info.setMotherProperties(mother);
1269  }
1270  }
1271  //if mother is still nullptr, we have a problem
1272  if (!mother) return NonDefined; // FIXME it should not be possible for mother to be nullptr at this point???
1273 
1274  motherPDG = mother->pdgId();
1275  partOriVert = mother->decayVtx();
1276  mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
1277  numOfParents = partOriVert->nIncomingParticles();
1278  const int numOfDaug = partOriVert->nOutgoingParticles();
1279 
1280  info.setMotherProperties(mother);
1281 
1282  int NumOfPhot(0);
1283  int NumOfquark(0);
1284  int NumOfgluon(0);
1285  int NumOfLQ(0);
1286  int NumOfElNeut(0);
1287  int NumOfMuNeut(0);
1288  int NumOfTauNeut(0);
1289  int NumOfEl(0);
1290  int NumOfMu(0);
1291  int NumOfTau(0);
1292  samePart = false;
1293 
1294  for (const auto& theDaug: partOriVert->particles_out()) {
1295  if (!theDaug) continue;
1296  int DaugType = theDaug->pdgId();
1297  if (MC::isSMQuark(DaugType)) NumOfquark++;
1298  else if (MC::isGluon(DaugType)) NumOfgluon++;
1299  else if (abs(DaugType) == MC::NU_E) NumOfElNeut++;
1300  else if (std::abs(DaugType) == MC::NU_MU) NumOfMuNeut++;
1301  else if (std::abs(DaugType) == MC::NU_TAU) NumOfTauNeut++;
1302  else if (MC::isPhoton(DaugType)) NumOfPhot++;
1303  else if (MC::isElectron(DaugType)) NumOfEl++;
1304  else if (MC::isMuon(DaugType)) NumOfMu++;
1305  else if (MC::isTau(DaugType)) NumOfTau++;
1306  else if (MC::isLeptoQuark(DaugType)) NumOfLQ++;
1307  if (std::abs(DaugType) == std::abs(motherPDG) && theDaug && HepMC::is_same_generator_particle(theDaug,mother)) samePart = true;
1308  }
1309 
1310  // Quark weak decay
1311  if (MC::isQuark(motherPDG) && numOfParents == 1 && numOfDaug == 3 && NumOfquark == 1 && (NumOfEl == 1 || NumOfMu == 1 || NumOfTau == 1)) return QuarkWeakDec;
1312  if (MC::isTop(motherPDG)) return top;
1313 
1314  if (MC::isW(motherPDG) && mothOriVert && mothOriVert->nIncomingParticles() != 0) {
1315  const xAOD::TruthVertex* prodVert = mothOriVert;
1316  const xAOD::TruthParticle* ptrPart;
1317  do {
1318  ptrPart = prodVert->incomingParticle(0); // FIXME just taking the first one
1319  prodVert = ptrPart->hasProdVtx() ? ptrPart->prodVtx() : nullptr;
1320  } while (MC::isW(ptrPart) && prodVert);
1321 
1322  if (prodVert && prodVert->nIncomingParticles() == 1) {
1323  if (abs(ptrPart->pdgId()) == MC::RH_NU_E) return NuREle; // Right-handed NU_E (Pythia-specific)
1324  if (abs(ptrPart->pdgId()) == MC::RH_NU_MU) return NuRMu; // Right-handed NU_MU (Pythia-specific)
1325  if (abs(ptrPart->pdgId()) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
1326  }
1327  return WBoson;
1328  }
1329  if (MC::isW(motherPDG)) return WBoson;
1330  if (MC::isZ(motherPDG)) return ZBoson;
1331 
1332  //-- Exotics
1333 
1334  // MadGraphPythia ZWW*->lllnulnu or ZWW*->nunulnulnu (don't even know if the latter is generated)
1335  if (numOfParents == 1 && numOfDaug > 4 && (MC::isSMQuark(motherPDG) || MC::isGluon(motherPDG))) {
1336 
1337  const xAOD::TruthParticle* thePartToCheck = thePriPart;
1338  const xAOD::TruthParticle* theMother = thePriPart->hasProdVtx() ? thePriPart->prodVtx()->incomingParticle(0) : nullptr; // FIXME just taking the first one
1339 
1340  if (MC::isElectron(theMother) && MC::isDecayed(theMother)) thePartToCheck = theMother;
1341  bool isZboson = false;
1342  bool isWboson = false;
1343  bool skipnext = false;
1344 
1345  for (unsigned int ipOut = 0; ipOut + 1 < partOriVert->nOutgoingParticles(); ++ipOut) {
1346  const xAOD::TruthParticle* theDaug = partOriVert->outgoingParticle(ipOut);
1347  if (!theDaug) continue;
1348  const xAOD::TruthParticle* theNextDaug{};
1349  for (unsigned int ipOut1 = ipOut + 1; ipOut1 < partOriVert->nOutgoingParticles(); ipOut1++) {
1350  theNextDaug = partOriVert->outgoingParticle(ipOut1);
1351  if (theNextDaug) break;
1352  }
1353  if (!theNextDaug) continue;
1354 
1355  if (skipnext) {
1356  skipnext = false;
1357  continue;
1358  }
1359 
1360  const int apdgID1 = abs(theDaug->pdgId());
1361  const int apdgID2 = abs(theNextDaug->pdgId());
1362  if (apdgID1 == apdgID2 && MC::isSMNeutrino(apdgID1)) {
1363  // Zboson
1364  if (thePartToCheck == theDaug || thePartToCheck == theNextDaug) {
1365  isZboson = true;
1366  break;
1367  }
1368  skipnext = true;
1369  } else if ((apdgID1 == MC::ELECTRON && apdgID2 == MC::NU_E) ||
1370  (apdgID1 == MC::NU_E && apdgID2 == MC::ELECTRON) ||
1371  (apdgID1 == MC::MUON && apdgID2 == MC::NU_MU) ||
1372  (apdgID1 == MC::NU_MU && apdgID2 == MC::MUON) ||
1373  (apdgID1 == MC::TAU && apdgID2 == MC::NU_TAU) ||
1374  (apdgID1 == MC::NU_TAU && apdgID2 == MC::TAU)
1375  ) {
1376  // WBoson
1377  if (thePartToCheck == theDaug || thePartToCheck == theNextDaug) {
1378  isWboson = true;
1379  break;
1380  }
1381  skipnext = true;
1382  }
1383  }
1384  if (isWboson) return WBoson;
1385  if (isZboson) return ZBoson;
1386  }
1387 
1388  if (numOfParents == 2) {
1389  const int pdg1 = partOriVert->incomingParticle(0)->pdgId();
1390  const int pdg2 = partOriVert->incomingParticle(1)->pdgId();
1391  //--Sherpa Z->nunu
1392  if ( (numOfDaug - NumOfquark - NumOfgluon) == 2 && (NumOfElNeut == 2 || NumOfMuNeut == 2 || NumOfTauNeut == 2)) return ZBoson;
1393 
1394  //--Sherpa W->enu ??
1395  if ((numOfDaug - NumOfquark - NumOfgluon) == 2 && ((NumOfEl == 1 && NumOfElNeut == 1) || (NumOfMu == 1 && NumOfMuNeut == 1) || (NumOfTau == 1 && NumOfTauNeut == 1))) return WBoson;
1396 
1397  //--Sherpa ZZ,ZW
1398  if ( (numOfDaug - NumOfquark - NumOfgluon) == 4 && (NumOfEl + NumOfMu + NumOfTau + NumOfElNeut + NumOfMuNeut + NumOfTauNeut == 4) &&
1399  (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return DiBoson;
1400 
1401  //--Sherpa VVV -- Note, have to allow for prompt photon radiation or these get lost
1402  if ((numOfDaug - NumOfquark - NumOfgluon - NumOfPhot) == 6 && (NumOfEl + NumOfMu + NumOfTau + NumOfElNeut + NumOfMuNeut + NumOfTauNeut == 6) &&
1403  (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return MultiBoson;
1404  }
1405 
1406  // New Sherpa Z->nunu
1407  if (partOriVert == mothOriVert && partOriVert) {
1408  int NumOfLepLoop = 0;
1409  int NumOfNeuLoop = 0;
1410  for (const auto *const pout: partOriVert->particles_out()) {
1411  if (!pout) continue;
1412  for (const auto *const pin: partOriVert->particles_in()) {
1413  if (!pin) continue;
1414  if (HepMC::is_same_particle(pin,pout)) continue;
1415  const int apdgid = abs(pout->pdgId());
1416  if (MC::isSMLepton(apdgid)) {
1417  if (MC::isSMNeutrino(apdgid)) { NumOfNeuLoop++; }
1418  else { NumOfLepLoop++; }
1419  }
1420  }
1421  }
1422  if (NumOfNeuLoop == 2 && NumOfLepLoop == 0) return ZBoson;
1423  if (NumOfNeuLoop == 1 && NumOfLepLoop == 1) return WBoson;
1424  if (NumOfNeuLoop + NumOfLepLoop == 4) return DiBoson;
1425  }
1426 
1427  //-- McAtNLo
1428 
1429  if (MC::isHiggs(motherPDG)) return Higgs;
1430  if (MC::isMSSMHiggs(motherPDG)) return HiggsMSSM; // MSSM Higgs bosons
1431  if (MC::isHeavyBoson(motherPDG)) return HeavyBoson; // Heavy bosons( Z', Z'', W'+)
1432 
1433  if (MC::isTau(motherPDG)) {
1434  const ParticleOrigin tauOrig = defOrigOfTau(xTruthParticleContainer, mother, motherPDG, info);
1435  const ParticleType tautype = defTypeOfTau(tauOrig);
1436  return (tautype == IsoTau)?tauOrig:TauLep;
1437  }
1438 
1439  if (abs(motherPDG) == MC::WBOSON_LRSM) return WBosonLRSM; // Left-right symmetric model WBoson (Pythia-specific)
1440  if (abs(motherPDG) == MC::RH_NU_E) return NuREle; // Right-handed NU_E (Pythia-specific)
1441  if (abs(motherPDG) == MC::RH_NU_MU) return NuRMu; // Right-handed NU_MU (Pythia-specific)
1442  if (abs(motherPDG) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
1443  if (MC::isLeptoQuark(motherPDG) || NumOfLQ != 0) return LQ;
1444  if (MC::isSUSY(motherPDG)) return SUSY;
1445  if (MC::isBSM(motherPDG)) return OtherBSM;
1446 
1447  const ParticleType pType = defTypeOfHadron(motherPDG);
1448  if ((pType == BBbarMesonPart || pType == CCbarMesonPart) && mothOriVert && MC::isHardScatteringVertex(mothOriVert)) isPrompt = true;
1449 
1450  return convHadronTypeToOrig(pType, motherPDG);
1451 }

◆ defOrigOfPhoton()

ParticleOrigin MCTruthClassifier::defOrigOfPhoton ( const xAOD::TruthParticleContainer &  xTruthParticleContainer,
const xAOD::TruthParticle *  thePart,
bool &  isPrompt,
MCTruthPartClassifier::Info &  info 
) const
private

Definition at line 930 of file MCTruthClassifierGen.cxx.

934 {
935  if (!thePart) return NonDefined; // FIXME Why is this extra protection needed for this function and not the others?
936  ATH_MSG_DEBUG("Executing DefOrigOfPhoton ");
937 
938  info.resetMotherProperties();
939  info.photonMother = nullptr;
940 
941  // Find the first copy of this particle stored in the xAOD::TruthParticleContainer (i.e. the particle prior to any interactions)
942  const xAOD::TruthParticle* thePriPart = MC::findMatching(xTruthParticleContainer, thePart);
943  if (!thePriPart) return NonDefined;
944  if (!MC::isPhoton(thePriPart)) return NonDefined;
945 
946  const xAOD::TruthVertex* partOriVert = thePriPart->hasProdVtx() ? thePriPart->prodVtx() : nullptr;
947 
948  //-- to define photon outcome status
949  info.particleOutCome = defOutComeOfPhoton(thePriPart);
950  if (!partOriVert) return NonDefined;
951 
952  int numOfParents = partOriVert->nIncomingParticles();
953  if (partOriVert->nIncomingParticles() > 1) ATH_MSG_DEBUG("DefOrigOfPhoton:: photon has more than one mother ");
954 
955 
956  const xAOD::TruthParticle* mother = MC::findMother(thePriPart);
957  info.setMotherProperties(mother);
958  if (!mother) { return NonDefined; } // mother is not a nullptr beyond this point
959 
960  int motherPDG = mother->pdgId();
961  const xAOD::TruthVertex* mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
962  partOriVert = mother->decayVtx(); // FIXME how often does this line actually change the pointer???
963  numOfParents = partOriVert->nIncomingParticles();
964  const int numOfDaug = partOriVert->nOutgoingParticles();
965  int NumOfNucFr(0);
966  int NumOfEl(0);
967  int NumOfPos(0);
968  int NumOfMu(0);
969  int NumOfTau(0);
970  int NumOfPht(0);
971  int NumOfLQ(0);
972  int DaugType(0);
973  long NumOfLep(0); // FIXME does this really need to be a long???
974  long NumOfNeut(0); // FIXME does this really need to be a long???
975  long NumOfPartons(0); // FIXME does this really need to be a long???
976  const xAOD::TruthParticle* Daug{};
977  for (const auto& pout: partOriVert->particles_out()) {
978  if (!pout) continue;
979  DaugType = pout->pdg_id();
980  if (numOfParents == 1 && (MC::isPhoton(motherPDG) || MC::isElectron(motherPDG) || abs(motherPDG) == MC::PIPLUS) &&
981  (MC::isNucleus(DaugType) || DaugType == 0 || DaugType == MC::PROTON || DaugType == MC::NEUTRON))
982  NumOfNucFr++;
983  if (DaugType == MC::PHOTON) NumOfPht++;
984  else if (DaugType == MC::ELECTRON) NumOfEl++;
985  else if (DaugType == MC::POSITRON) NumOfPos++;
986  else if (MC::isMuon(DaugType)) NumOfMu++;
987  else if (MC::isTau(DaugType)) NumOfTau++;
988  else if (MC::isLeptoQuark(DaugType)) NumOfLQ++;
989  else if (MC::isElectron(DaugType) || MC::isMuon(DaugType) || MC::isTau(DaugType)) NumOfLep++;
990  else if (abs(DaugType) == MC::NU_E || abs(DaugType) == MC::NU_MU || abs(DaugType) == MC::NU_TAU) NumOfNeut++;
991  if (abs(DaugType) < MC::ELECTRON || (abs(DaugType) > MC::NU_TAU && abs(DaugType) < 43 && !MC::isPhoton(DaugType))) {
992  // FIXME Too loose? This definition picks up 4th generation quarks and leptons as well as all gauge bosons and leptoquarks.
993  // Suggest MC::isSMQuark(DaugType) || (MC::isBoson(DaugType) && !MC::isPhoton(DaugType))
994  // or maybe even MC::isSMQuark(DaugType) || MC::isGluon(DaugType)
995  // AKA const long NumOfPartons = DP.apd({MC::DQUARK,MC::UQUARK,MC::SQUARK,MC::CQUARK,MC::BQUARK,MC::TQUARK,MC::GLUON});
996  NumOfPartons++;
997  }
998  if (DaugType == motherPDG) {
999  Daug = pout;
1000  }
1001  }
1002 
1003  bool foundISR = false;
1004  bool foundFSR = false;
1005  if (numOfParents == 1 && numOfDaug == 2 && Daug && HepMC::is_same_generator_particle(Daug, mother)) return BremPhot;
1006  if (numOfParents == 1 && numOfDaug == 2 && MC::isElectron(motherPDG) && NumOfPht == 2) return ElMagProc;
1007 
1008  // decay of W,Z and Higgs to lepton with FSR generated by Pythia
1009  if (numOfParents == 1 && numOfDaug == 2 && (MC::isElectron(motherPDG) || MC::isMuon(motherPDG) || MC::isTau(motherPDG)) &&
1010  !(Daug && HepMC::is_same_generator_particle(Daug, mother)) && mothOriVert &&
1011  mothOriVert->nIncomingParticles() == 1) {
1012  int itr = 0;
1013  int PartPDG = 0;
1014  const xAOD::TruthVertex* prodVert = mothOriVert;
1015  const xAOD::TruthVertex* Vert{};
1016  do {
1017  Vert = prodVert;
1018  for (const auto & pin: Vert->particles_in()) {
1019  if (!pin) continue;
1020  PartPDG = abs(pin->pdgId());
1021  prodVert = pin->prodVtx();
1022  if (MC::isZ(PartPDG) || MC::isW(PartPDG) || MC::isHiggs(PartPDG)) foundFSR = true;
1023  }
1024  itr++;
1025  if (itr > 100) { // FIXME Improve loop detection here?
1026  ATH_MSG_WARNING("DefOrigOfPhoton:: infinite while");
1027  break;
1028  }
1029  } while (prodVert && abs(motherPDG) == PartPDG);
1030 
1031  if (foundFSR) return FSRPhot;
1032  }
1033 
1034  // Nucl reaction
1035  // gamma+Nuclear=>gamma+Nucl.Fr+Nuclons+pions
1036  // e+Nuclear=>e+gamma+Nucl.Fr+Nuclons+pions
1037  // pi+Nuclear=>gamma+Nucl.Fr+Nuclons+pions
1038 
1039  if ((numOfParents == 1 && (MC::isPhoton(motherPDG) || MC::isElectron(motherPDG)) && numOfDaug > 2 && NumOfNucFr != 0) ||
1040  (numOfParents == 1 && abs(motherPDG) == MC::PIPLUS && numOfDaug > 10 && NumOfNucFr != 0) ||
1041  (numOfParents == 1 && MC::isPhoton(motherPDG) && numOfDaug > 10 && MC::isStable(mother)) ||
1042  (numOfParents == 1 && MC::isNucleus(motherPDG) && std::abs(motherPDG) != MC::PROTON)) // FIXME vetoing protons here to preserve previous behaviour
1043  return NucReact;
1044 
1045  if (MC::isMuon(motherPDG) && NumOfMu == 0) return Mu;
1046  if (MC::isTau(motherPDG) && NumOfTau == 0) return TauLep;
1047 
1048  if (numOfParents == 1 && mother->status() == 3) return (foundISR)? ISRPhot:UndrPhot; // FIXME foundISR is always false at this point
1049 
1050  //-- to find initial and final state raiation and underline photons
1051  //-- SUSY
1052  if (numOfParents == 1 && (MC::isSMQuark(motherPDG) || MC::isGluon(motherPDG)) &&
1053  (numOfDaug != NumOfPht + NumOfPartons || !MC::Pythia8::isConditionA(mother))) {
1054  for (const auto& pout: partOriVert->particles_out()) {
1055  if (!pout) continue;
1056  if (motherPDG != pout->pdgId()) continue;
1057  const xAOD::TruthVertex* Vrtx = pout->decayVtx();
1058  if (!Vrtx) continue;
1059  if (Vrtx->nOutgoingParticles() != 1 && Vrtx->nIncomingParticles() == 1) continue;
1060  if (!Vrtx->outgoingParticle(0)) continue;
1061  if (Vrtx->outgoingParticle(0)->pdgId() == 91) foundISR = true; // Herwig "cluster"
1062  }
1063  return (foundISR)?ISRPhot:UndrPhot;
1064  }
1065 
1066  //-- to find final state radiation
1067  //-- Exotics
1068 
1069  // FSR from Photos
1070  //-- Exotics- CompHep
1071  if (numOfParents == 2 && ((MC::isElectron(motherPDG) && NumOfEl == 1 && NumOfPos == 1) || (MC::isMuon(motherPDG) && NumOfMu == 2) || (MC::isTau(motherPDG) && NumOfTau == 2))) {
1072  if (abs(partOriVert->incomingParticle(0)->pdgId()) == abs(partOriVert->incomingParticle(1)->pdgId())) return FSRPhot;
1073  }
1074 
1075  if (numOfParents == 2 && NumOfLep == 1 && NumOfNeut == 1 && (MC::isElectron(motherPDG) || abs(motherPDG) == MC::NU_E)) return FSRPhot;
1076 
1077  //-- Exotics - CompHep
1078  if (MC::isElectron(motherPDG) && numOfParents == 1 && numOfDaug == 2 && (NumOfEl == 1 || NumOfPos == 1) && NumOfPht == 1 &&
1079  !( Daug && HepMC::is_same_generator_particle(Daug, mother)) && !HepMC::is_simulation_particle(Daug) && !HepMC::is_simulation_particle(mother))
1080  return FSRPhot;
1081 
1082  // FSR from Photos
1083  if (MC::isZ(motherPDG) && ((NumOfEl + NumOfPos == 2 || NumOfEl + NumOfPos == 4) || (NumOfMu == 2 || NumOfMu == 4) || (NumOfTau == 2 || NumOfTau == 4)) && NumOfPht > 0) return FSRPhot;
1084 
1085  if (NumOfPht > 0 && (abs(motherPDG) == MC::WBOSON_LRSM || MC::isNeutrinoRH(motherPDG))) return FSRPhot; // Left-right symmetric model WBoson || Right-handed neutrinos (Pythia-specific)
1086 
1087  if (numOfParents == 2 && NumOfLQ == 1) return FSRPhot;
1088 
1089  //--- other process
1090 
1091  if (MC::isZ(motherPDG)) return ZBoson;
1092  if (MC::isW(motherPDG)) {
1093 
1094  if (NumOfLep == 1 && NumOfNeut == 1 && numOfDaug == NumOfLep + NumOfNeut + NumOfPht) return FSRPhot;
1095 
1096  if (mothOriVert && mothOriVert->nIncomingParticles() != 0) {
1097  const xAOD::TruthVertex* prodVert = mothOriVert;
1098  const xAOD::TruthParticle* itrP;
1099  do {
1100  itrP = prodVert->incomingParticle(0); // FIXME just taking the first one
1101  prodVert = itrP->hasProdVtx() ? itrP->prodVtx() : nullptr;
1102  } while (MC::isW(itrP) && prodVert);
1103 
1104  if (prodVert && prodVert->nIncomingParticles() == 1 ) {
1105  if ( MC::isTau(itrP)) return TauLep;
1106  if ( MC::isMuon(itrP)) return Mu;
1107  if ( abs(itrP->pdgId()) == MC::RH_NU_E) return NuREle; // Right-handed NU_E (Pythia-specific)
1108  if ( abs(itrP->pdgId()) == MC::RH_NU_MU) return NuRMu; // Right-handed NU_MU (Pythia-specific)
1109  if ( abs(itrP->pdgId()) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
1110  }
1111  } else
1112  return WBoson;
1113  }
1114 
1115  // MadGraphPythia ZWW*->lllnulnu
1116  if (numOfParents == 1 && numOfDaug > 4 && (MC::isSMQuark(motherPDG) || MC::isGluon(motherPDG))) {
1117  bool isZboson = false;
1118  bool isWboson = false;
1119  bool skipnext = false;
1120  for (unsigned int ipOut = 0; ipOut + 1 < partOriVert->nOutgoingParticles(); ipOut++) {
1121  if (skipnext) {
1122  skipnext = false;
1123  continue;
1124  }
1125  const xAOD::TruthParticle* theDaug = partOriVert->outgoingParticle(ipOut);
1126  if (!theDaug) continue;
1127  const xAOD::TruthParticle* theNextDaug{};
1128  for (unsigned int ipOut1 = ipOut + 1; ipOut1 < partOriVert->nOutgoingParticles(); ipOut1++) {
1129  theNextDaug = partOriVert->outgoingParticle(ipOut1);
1130  if (theNextDaug) break;
1131  }
1132  if (!theNextDaug) continue;
1133  if (MC::isTau(theDaug) && MC::isTau(theNextDaug)) {
1134  // Zboson
1135  if (thePriPart == theDaug || thePriPart == theNextDaug) {
1136  isZboson = true;
1137  break;
1138  }
1139  skipnext = true;
1140  } else if (MC::isTau(theDaug) && abs(theNextDaug->pdgId()) == MC::NU_TAU) {
1141  // WBoson
1142  if (thePriPart == theDaug || thePriPart == theNextDaug) {
1143  isWboson = true;
1144  break;
1145  }
1146  skipnext = true;
1147  }
1148  }
1149  if (isWboson) return WBoson;
1150  if (isZboson) return ZBoson;
1151  }
1152 
1153  //--Sherpa ZZ,ZW+FSR
1154  if (numOfParents == 4 && (numOfDaug - NumOfPht) == 4 && (NumOfLep + NumOfNeut == 4)) {
1155  if (MC::isSMLepton(partOriVert->incomingParticle(0))&&MC::isSMLepton(partOriVert->incomingParticle(1))
1156  && MC::isSMLepton(partOriVert->incomingParticle(2))&&MC::isSMLepton(partOriVert->incomingParticle(3)))
1157  return FSRPhot;
1158  }
1159 
1160  //--New Sherpa single photon
1161  if (partOriVert == mothOriVert && partOriVert) {
1162  int NumOfPhtLoop = 0;
1163  for (const auto *const pout: partOriVert->particles_out()) {
1164  if (!pout) continue;
1165  for (const auto *const pin: partOriVert->particles_in()) {
1166  if (!pin) continue;
1167  if (HepMC::is_same_particle(pout,pin) && MC::isPhoton(pout)) NumOfPhtLoop++;
1168  if (NumOfPhtLoop == 1) return SinglePhot;
1169  }
1170  }
1171  }
1172 
1173  if (MC::isHiggs(motherPDG)) return Higgs;
1174  if (abs(motherPDG) == MC::PI0) return PiZero;
1175  if (MC::isMSSMHiggs(motherPDG)) return HiggsMSSM; // MSSM Higgs bosons
1176  if (MC::isHeavyBoson(motherPDG) || std::abs(motherPDG) == 5100039 ) return HeavyBoson; // Heavy Bosons (Z' Z'' W'+) + KK excited graviton
1177 
1178  if (MC::isSUSY(motherPDG)) return SUSY;
1179  if (MC::isBSM(motherPDG)) return OtherBSM;
1180 
1181  // Pythia8 gamma+jet samples
1182  if (MC::Pythia8::isConditionA(mother) && MC::isStable(thePriPart) && NumOfPht == 1 && numOfDaug == (NumOfPht + NumOfPartons)) return PromptPhot;
1183 
1184  const ParticleType pType = defTypeOfHadron(motherPDG);
1185  if ((pType == BBbarMesonPart || pType == CCbarMesonPart) && mothOriVert && MC::isHardScatteringVertex(mothOriVert)) isPrompt = true;
1186  return convHadronTypeToOrig(pType, motherPDG);
1187 }

◆ defOrigOfTau()

ParticleOrigin MCTruthClassifier::defOrigOfTau ( const xAOD::TruthParticleContainer &  xTruthParticleContainer,
const xAOD::TruthParticle *  thePart,
int  motherPDG,
MCTruthPartClassifier::Info &  info 
) const
private

Definition at line 757 of file MCTruthClassifierGen.cxx.

761 {
762  ATH_MSG_DEBUG("Executing DefOrigOfTau ");
763  // Find the first copy of this particle stored in the xAOD::TruthParticleContainer (i.e. the particle prior to any interactions)
764  const xAOD::TruthParticle* thePriPart = MC::findMatching(xTruthParticleContainer, thePart);
765  if (!thePriPart) return NonDefined;
766  if (!MC::isTau(thePriPart)) return NonDefined;
767 
768  const xAOD::TruthVertex* partOriVert = thePriPart->hasProdVtx() ? thePriPart->prodVtx() : nullptr;
769 
770  //-- to define tau outcome status
771  if (MC::isPhysical(thePriPart)) info.particleOutCome = defOutComeOfTau(thePriPart); // FIXME why do we need the additional check on MC::isPhysical here c.f. defOrigOfElectron and defOrigOfMuon?
772 
773  if (!partOriVert) return NonDefined;
774 
775  int numOfParents = partOriVert->nIncomingParticles();
776  if (numOfParents > 1) ATH_MSG_DEBUG("DefOrigOfTau:: tau has more than one mother ");
777 
778  const xAOD::TruthParticle* mother = MC::findMother(thePriPart);
779  info.setMotherProperties(mother);
780  if (!mother) { return NonDefined; } // mother is not a nullptr beyond this point
781 
782  const xAOD::TruthVertex* mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
783 
784  const xAOD::TruthParticle* MotherParent{};
785 
786  if (MC::isW(motherPDGin) && mothOriVert) { // FIXME motherPDGin here could in principle be inconsistent with mothOriVert
787  MotherParent = MC::findMother(mother);
788  int pPDG(0);
789 
790  if (MotherParent) {//MotherParent checked here...
791  pPDG = MotherParent->pdgId();
792  if (MC::isTop(pPDG)) {
793  mother = MotherParent; //...so mother cannot be nullptr
794  info.setMotherProperties(mother);
795  }
796  }
797  }
798 
799  int motherPDG = mother->pdgId();
800  info.setMotherProperties(mother);
801  mothOriVert = mother->hasProdVtx() ? mother->prodVtx() : nullptr;
802  partOriVert = mother->decayVtx();
803  if (!partOriVert) return NonDefined; // FIXME not sure this could ever be true?
804 
805  numOfParents = partOriVert->nIncomingParticles();
806  auto DP = DecayProducts(partOriVert);
807  const int numOfDaug = DP.size();
808  const int NumOfPhot = DP.pd(MC::PHOTON);
809  const int NumOfEl = DP.pd(MC::ELECTRON);
810  const int NumOfPos = DP.pd(MC::POSITRON);
811  const int NumOfElNeut = DP.apd(MC::NU_E);
812  const int NumOfMuNeut = DP.apd(MC::NU_MU);
813  /* const int NumOfLQ = DP.apd(MC::LEPTOQUARK); */ // FIXME Leptoquarks not an option?
814  const int NumOfquark = DP.apd({MC::DQUARK,MC::UQUARK,MC::SQUARK,MC::CQUARK,MC::BQUARK,MC::TQUARK});
815  const int NumOfgluon = DP.apd(MC::GLUON);
816  const int NumOfMuPl = DP.pd(-MC::MUON);
817  const int NumOfMuMin = DP.pd(MC::MUON);
818  const int NumOfTau = DP.apd(MC::TAU);
819  const int NumOfTauNeut = DP.apd(MC::NU_TAU);
820 
821  if (MC::isTop(motherPDG)) return top;
822  if (MC::isW(motherPDG) && mothOriVert && mothOriVert->nIncomingParticles() != 0) {
823  const xAOD::TruthVertex* prodVert = mothOriVert;
824  const xAOD::TruthParticle* itrP;
825  do {
826  itrP = prodVert->incomingParticle(0); // FIXME just taking the first one
827  prodVert = itrP->hasProdVtx() ? itrP->prodVtx() : nullptr;
828  } while (MC::isW(itrP) && prodVert);
829 
830  if (prodVert && prodVert->nIncomingParticles() == 1 ) {
831  if (abs(itrP->pdgId()) == MC::RH_NU_E) return NuREle; // Right-handed NU_E (Pythia-specific)
832  if (abs(itrP->pdgId()) == MC::RH_NU_MU) return NuRMu; // Right-handed NU_MU (Pythia-specific)
833  if (abs(itrP->pdgId()) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
834  }
835  return WBoson;
836  }
837  if (MC::isW(motherPDG)) { return WBoson;}
838  if (MC::isZ(motherPDG)) { return ZBoson;}
839  if (numOfParents == 1 && numOfDaug > 4 && (MC::isSMQuark(motherPDG) || MC::isGluon(motherPDG))) {
840  bool isZboson = false;
841  bool isWboson = false;
842  bool skipnext = false;
843  for (unsigned int ipOut = 0; ipOut + 1 < partOriVert->nOutgoingParticles(); ipOut++) {
844  if (skipnext) {
845  skipnext = false;
846  continue;
847  }
848  const xAOD::TruthParticle* theDaug = partOriVert->outgoingParticle(ipOut);
849  if (!theDaug) continue;
850  const xAOD::TruthParticle* theNextDaug{};
851  for (unsigned int ipOut1 = ipOut + 1; ipOut1 < partOriVert->nOutgoingParticles(); ipOut1++) {
852  theNextDaug = partOriVert->outgoingParticle(ipOut1);
853  if (theNextDaug) break;
854  }
855  if (!theNextDaug) {
856  continue;
857  }
858  if (MC::isTau(theDaug) && MC::isTau(theNextDaug)) {
859  // Zboson
860  if (thePriPart == theDaug || thePriPart == theNextDaug) {
861  isZboson = true;
862  break;
863  }
864  skipnext = true;
865  } else if (MC::isTau(theDaug) && abs(theNextDaug->pdgId()) == MC::NU_TAU) {
866  // WBoson
867  if (thePriPart == theDaug || thePriPart == theNextDaug) {
868  isWboson = true;
869  break;
870  }
871  skipnext = true;
872  }
873  }
874  if (isWboson) return WBoson;
875  if (isZboson) return ZBoson;
876  }
877  if (numOfParents == 2 ) {
878  const int pdg1 = partOriVert->incomingParticle(0)->pdgId();
879  const int pdg2 = partOriVert->incomingParticle(1)->pdgId();
880  //--Sherpa Z->tautau
881  if ((numOfDaug - NumOfquark - NumOfgluon) == 2 && NumOfTau == 2 && (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return ZBoson;
882 
883  //--Sherpa W->taunu new
884  if ((numOfDaug - NumOfquark - NumOfgluon) == 2 && NumOfTau == 1 && NumOfTauNeut == 1) return WBoson;
885 
886  //--Sherpa ZZ,ZW
887  if ((numOfDaug - NumOfquark - NumOfgluon) == 4 &&
888  (NumOfEl + NumOfPos + NumOfMuPl + NumOfMuMin + NumOfTau + NumOfElNeut + NumOfMuNeut + NumOfTauNeut == 4) &&
889  (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return DiBoson;
890 
891  //--Sherpa VVV -- Note, have to allow for prompt photon radiation or these get lost
892  if ((numOfDaug - NumOfquark - NumOfgluon - NumOfPhot) == 6 &&
893  (NumOfEl + NumOfPos + NumOfMuPl + NumOfMuMin + NumOfTau + NumOfElNeut + NumOfMuNeut + NumOfTauNeut == 6) &&
894  (MC::isQuark(pdg1)||MC::isGluon(pdg1)) && (MC::isQuark(pdg2)||MC::isGluon(pdg2))) return MultiBoson;
895  }
896  // New Sherpa Z->tautau
897  if (partOriVert == mothOriVert) {
898  int NumOfTauLoop = 0;
899  int NumOfTauNeuLoop = 0;
900  int NumOfLepLoop = 0;
901  for ( const auto *const pout: partOriVert->particles_out()) {
902  if (!pout) continue;
903  for (const auto *const pin: partOriVert->particles_in()) {
904  if (!pin) continue;
905  if (!HepMC::is_same_particle(pout,pin)) continue;
906  if (MC::isTau(pout)) NumOfTauLoop++;
907  if (std::abs(pout->pdgId()) == MC::NU_TAU) NumOfTauNeuLoop++; // FIXME pin vs pout difference in behaviour compared to MCTruthClassifier::defOrigOfElectron
908  if (MC::isSMLepton(pout)) NumOfLepLoop++;
909  }
910  }
911  if (NumOfTauLoop == 2 && NumOfTauNeuLoop == 0) return ZBoson;
912  if (NumOfTauLoop == 1 && NumOfTauNeuLoop == 1) return WBoson;
913  if ((NumOfTauLoop == 4 && NumOfTauNeuLoop == 0) || (NumOfTauLoop == 3 && NumOfTauNeuLoop == 1) || (NumOfTauLoop == 2 && NumOfTauNeuLoop == 2)) return DiBoson;
914  if (NumOfLepLoop == 4) return DiBoson;
915  }
916 
917  if (MC::isHiggs(motherPDG)) return Higgs;
918  if (MC::isMSSMHiggs(motherPDG)) return HiggsMSSM; // MSSM Higgs bosons
919  if (MC::isHeavyBoson(motherPDG)) return HeavyBoson; // Heavy bosons( Z', Z'', W'+)
920  if (abs(motherPDG) == MC::WBOSON_LRSM) return WBosonLRSM; // Left-right symmetric model WBoson (Pythia-specific)
921  if (abs(motherPDG) == MC::RH_NU_TAU) return NuRTau; // Right-handed NU_TAU (Pythia-specific)
922  if (MC::isSUSY(motherPDG)) return SUSY;
923  if (MC::isBSM(motherPDG)) return OtherBSM;
924  if (abs(motherPDG) == MC::JPSI) return JPsi;
925 
926  const ParticleType pType = defTypeOfHadron(motherPDG);
927  return convHadronTypeToOrig(pType, motherPDG);
928 }

◆ detEta()

double MCTruthClassifier::detEta ( double  x,
double  y 
) const
inlineprivate

Definition at line 169 of file MCTruthClassifier.h.

◆ detPhi()

double MCTruthClassifier::detPhi ( double  x,
double  y 
) const
inlineprivate

Definition at line 170 of file MCTruthClassifier.h.

◆ 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.

95 { return m_detStore; }

◆ egammaClusMatch()

const xAOD::TruthParticle * MCTruthClassifier::egammaClusMatch ( const xAOD::CaloCluster *  clus,
bool  isFwrdEle,
MCTruthPartClassifier::Info *  info 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 44 of file MCTruthClassifierAthena.cxx.

45 {
46  ATH_MSG_DEBUG("Executing egammaClusMatch ");
47  const xAOD::TruthParticle* theMatchPart = nullptr;
48  const EventContext& ctx = info ? info->eventContext : Gaudi::Hive::currentContext();
49  // retrieve collection and get a pointer
50  SG::ReadHandle<xAOD::TruthParticleContainer> truthParticleContainerReadHandle(m_truthParticleContainerKey, ctx);
51 
52  if (!truthParticleContainerReadHandle.isValid()) {
53  ATH_MSG_WARNING( " Invalid ReadHandle for xAOD::TruthParticleContainer with key: " << truthParticleContainerReadHandle.key());
54  return theMatchPart;
55  }
56 
57  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{ m_caloMgrKey, ctx };
58  if (!caloMgrHandle.isValid()) {
59  ATH_MSG_WARNING(" Invalid ReadCondHandle for CaloDetDescrManager with key: " << m_caloMgrKey.key());
60  return theMatchPart;
61  }
62 
63  const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
64  const xAOD::TruthParticle* theEgamma(nullptr);
65  const xAOD::TruthParticle* theLeadingPartInCone(nullptr);
66  const xAOD::TruthParticle* theBestPartOutCone(nullptr);
67  const xAOD::TruthParticle* theBestPartdR(nullptr);
68  double LeadingPhtPT(0);
69  double LeadingPartPT(0);
70  double LeadingPhtdR(999.);
71  double LeadingPartdR(999.);
72  double BestPartdR(999.);
73  double etaClus = clus->etaBE(2);
74  double phiClus = clus->phiBE(2);
75  if (etaClus < -900) {
76  etaClus = clus->eta();
77  }
78  if (phiClus < -900) {
79  phiClus = clus->phi();
80  }
81  std::vector<const xAOD::TruthParticle*> tps;
82  if (!m_truthInConeTool->particlesInCone(ctx, etaClus, phiClus, 0.5, tps)) {
83  ATH_MSG_WARNING("Truth Particle in Cone failed");
84  return theMatchPart;
85  }
86 
87  for (const auto* const thePart : tps) {
88  // loop over the stable particle
89  if (!MC::isStable(thePart)) continue;
90  // excluding G4 particle
91  if ((!isFwrdEle || (isFwrdEle && m_FwdElectronUseG4Sel)) && HepMC::is_simulation_particle(thePart)) continue;
92  long iParticlePDG = thePart->pdgId();
93  // excluding neutrino
94  if (std::abs(iParticlePDG) == 12 || std::abs(iParticlePDG) == 14 || std::abs(iParticlePDG) == 16) continue;
95  double pt = thePart->pt() / Athena::Units::GeV;
96  double q = thePart?thePart->charge():0.0;
97  // exclude charged particles with pT<1 GeV
98  if (q != 0 && pt < m_pTChargePartCut) continue;
99  if (q == 0 && pt < m_pTNeutralPartCut) continue;
100 
101  // eleptical cone for extrapolations m_partExtrConePhi X m_partExtrConeEta
102  if (!isFwrdEle && m_ROICone && std::hypot( detPhi(phiClus, thePart->phi())/m_partExtrConePhi, detEta(etaClus, thePart->eta())/m_partExtrConeEta) > 1.0) {
103  continue;
104  }
105  // Also check if the clus and true have different sign , i they need both to be <0 or >0
106  if (isFwrdEle && // It is forward and
107  (((etaClus < 0) - (thePart->eta() < 0) != 0)
108  // The truth eta has different sign wrt to the fwd electron
109  || (std::fabs(thePart->eta()) < m_FwdElectronTruthExtrEtaCut) // or the truth is less than 2.4 (default cut)
110  || (std::fabs(thePart->eta() - etaClus) > m_FwdElectronTruthExtrEtaWindowCut) // or if the delta Eta between el and truth is > 0.15
111  ) // then do no extrapolate this truth Particle for this fwd electron
112  ) {
113  continue;
114  }
115  double dR(-999.);
116  bool isNCone = false;
117  bool isExt = genPartToCalo(ctx, clus, thePart, isFwrdEle, dR, isNCone, *caloDDMgr);
118  if (!isExt) continue;
119  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(), thePart);
120  if (info) {
121  info->egPartPtr.push_back(thePart);
122  info->egPartdR.push_back(dR);
123  info->egPartClas.push_back(particleTruthClassifier(theMatchPart, info));
124  }
125  // Gen particles Not forward
126  if (!isFwrdEle) {
127  // the leading photon or electron inside narrow eleptical cone
128  // m_phtClasConePhi X m_phtClasConeEta
129  if ((iParticlePDG == 22 || std::abs(iParticlePDG) == 11) && isNCone && pt > LeadingPhtPT) {
130  theEgamma = thePart;
131  LeadingPhtPT = pt;
132  LeadingPhtdR = dR;
133  }
134  // leading particle (excluding photon and electron) inside narrow eleptic
135  // cone m_phtClasConePhi X m_phtClasConeEta
136  if ((iParticlePDG != 22 && std::abs(iParticlePDG) != 11) && isNCone && pt > LeadingPartPT) {
137  theLeadingPartInCone = thePart;
138  LeadingPartPT = pt;
139  LeadingPartdR = dR;
140  };
141  // the best dR matched particle outside narrow eleptic cone cone
142  // m_phtClasConePhi X m_phtClasConeEta
143  if (!isNCone && dR < BestPartdR) {
144  theBestPartOutCone = thePart;
145  BestPartdR = dR;
146  };
147  } else {
148  if (dR < BestPartdR) {
149  theBestPartdR = thePart;
150  BestPartdR = dR;
151  };
152  }
153  }
154 
155  if (theEgamma != nullptr) {
156  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(), theEgamma);
157  if (info) info->deltaRMatch = LeadingPhtdR;
158  } else if (theLeadingPartInCone != nullptr) {
159  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(),theLeadingPartInCone);
160  if (info) info->deltaRMatch = LeadingPartdR;
161  } else if (theBestPartOutCone != nullptr) {
162  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(),theBestPartOutCone);
163  if (info) info->deltaRMatch = BestPartdR;
164  } else if (isFwrdEle && theBestPartdR != nullptr) {
165  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(),theBestPartdR );
166  if (info) info->deltaRMatch = BestPartdR;
167  } else {
168  theMatchPart = nullptr;
169  }
170  if (isFwrdEle || theMatchPart != nullptr || !m_inclG4part) return theMatchPart;
171 
172  // additional loop over G4 particles,
173  for (const auto* const thePart : tps) {
174  if (!MC::isStable(thePart)) continue;
175  if (!HepMC::is_simulation_particle(thePart)) continue;
176  long iParticlePDG = thePart->pdgId();
177  // exclude neutrino
178  if (std::abs(iParticlePDG) == 12 || std::abs(iParticlePDG) == 14 || std::abs(iParticlePDG) == 16) continue;
179  if (thePart->decayVtx() != nullptr) continue;
180  if (std::hypot( detPhi(phiClus, thePart->phi())/m_partExtrConePhi, detEta(etaClus, thePart->eta())/m_partExtrConeEta ) > 1.0) continue;
181 
182  double pt = thePart->pt() / Athena::Units::GeV;
183  double q = thePart->charge();
184  // exclude charged particles with pT<1 GeV
185  if (q != 0 && pt < m_pTChargePartCut) continue;
186  if (q == 0 && pt < m_pTNeutralPartCut) continue;
187 
188  double dR(-999.);
189  bool isNCone = false;
190  bool isExt = genPartToCalo(ctx, clus, thePart, isFwrdEle, dR, isNCone, *caloDDMgr);
191  if (!isExt) continue;
192 
193  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(),thePart);
194  if (info) {
195  info->egPartPtr.push_back(thePart);
196  info->egPartdR.push_back(dR);
197  info->egPartClas.push_back(particleTruthClassifier(theMatchPart, info));
198  }
199  // the leading photon or electron inside narrow eleptical cone
200  // m_phtClasConePhi X m_phtClasConeEta
201  if ((iParticlePDG == 22 || std::abs(iParticlePDG) == 11) && isNCone && pt > LeadingPhtPT) {
202  theEgamma = thePart;
203  LeadingPhtPT = pt;
204  LeadingPhtdR = dR;
205  }
206  // leading particle (excluding photon or electron) inside narrow eleptic
207  // cone m_phtClasConePhi X m_phtClasConeEta
208  if ((iParticlePDG != 22 && std::abs(iParticlePDG) != 11) && isNCone && pt > LeadingPartPT) {
209  theLeadingPartInCone = thePart;
210  LeadingPartPT = pt;
211  LeadingPartdR = dR;
212  }
213  // the best dR matched particle outside narrow eleptic cone cone
214  // m_phtClasConePhi X m_phtClasConeEta
215  if (!isNCone && dR < BestPartdR) {
216  theBestPartOutCone = thePart;
217  BestPartdR = dR;
218  }
219  }
220 
221  if (theEgamma != nullptr) {
222  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(),theEgamma);
223  if (info) info->deltaRMatch = LeadingPhtdR;
224  } else if (theLeadingPartInCone != nullptr) {
225  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(),theLeadingPartInCone);
226  if (info) info->deltaRMatch = LeadingPartdR;
227  } else if (theBestPartOutCone != nullptr) {
228  theMatchPart = MC::findMatching(truthParticleContainerReadHandle.ptr(),theBestPartOutCone);
229  if (info) info->deltaRMatch = BestPartdR;
230  } else {
231  theMatchPart = nullptr;
232  }
233  ATH_MSG_DEBUG("succeeded egammaClusMatch ");
234  return theMatchPart;
235 }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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

◆ findJetConstituents()

void MCTruthClassifier::findJetConstituents ( const xAOD::Jet *  jet,
std::set< const xAOD::TruthParticle * > &  constituents,
bool  DR 
) const
private

Definition at line 278 of file MCRecoToTruth.cxx.

281 {
282  if (DR) {
283  // use a DR matching scheme (default)
284  // retrieve collection and get a pointer
285  SG::ReadHandle<xAOD::TruthParticleContainer> truthParticleContainerReadHandle(m_truthParticleContainerKey);
286 
287  if (!truthParticleContainerReadHandle.isValid()) {
288  ATH_MSG_WARNING(" Invalid ReadHandle for xAOD::TruthParticleContainer with key: " << truthParticleContainerReadHandle.key());
289  return;
290  }
291  ATH_MSG_DEBUG("xAODTruthParticleContainer with key " << truthParticleContainerReadHandle.key() << " has valid ReadHandle ");
292  // find the matching truth particles
293  for (const auto *const thePart : *truthParticleContainerReadHandle) {
294  // match truth particles to the jet
295  if (MC::isStable(thePart) && thePart->p4().DeltaR(jet->p4()) < m_jetPartDRMatch) {
296  constituents.insert(thePart);
297  }
298  }
299  }
300  else {
301  xAOD::JetConstituentVector vec = jet->getConstituents();
302  for (const auto *particle0 : vec) {
303  const xAOD::TruthParticle* thePart = dynamic_cast<const xAOD::TruthParticle*>(particle0->rawConstituent());
304  if (MC::isStable(thePart)) {
305  constituents.insert(thePart);
306  }
307  }
308  }
309 }

◆ fracParticleInJet()

double MCTruthClassifier::fracParticleInJet ( const xAOD::TruthParticle *  thePart,
const xAOD::Jet *  jet,
bool  DR,
bool  nparts 
) const
private

Definition at line 310 of file MCRecoToTruth.cxx.

311 {
312  std::set<const xAOD::TruthParticle*> constituents;
313  std::set<const xAOD::TruthParticle*> daughters;
314  std::set<const xAOD::TruthParticle*> intersect;
315 
316  findJetConstituents(jet, constituents, DR);
317  MC::findParticleStableDescendants(thePart, daughters);
318  if (daughters.empty()) daughters.insert(thePart);
319  // Get the intersection of constituents and daughters
320  std::set_intersection(constituents.begin(),
321  constituents.end(),
322  daughters.begin(),
323  daughters.end(),
324  std::inserter(intersect, intersect.begin()));
325 
326  if (nparts) return 1.0*intersect.size() / daughters.size();
327  double frac = 0;
328  double tot = 0;
329  for (const auto *daughter : daughters) { tot += daughter->pt();}
330  for (const auto *particle : intersect) { frac += particle->pt();}
331  return frac/tot;
332 }

◆ genPartToCalo()

bool MCTruthClassifier::genPartToCalo ( const EventContext &  ctx,
const xAOD::CaloCluster *  clus,
const xAOD::TruthParticle *  thePart,
bool  isFwrdEle,
double &  dRmatch,
bool &  isNarrowCone,
const CaloDetDescrManager &  caloDDMgr 
) const
private

Definition at line 237 of file MCTruthClassifierAthena.cxx.

244 {
245  dRmatch = -999.;
246  isNarrowCone = false;
247  if (thePart == nullptr) return false;
248  double phiClus = clus->phiBE(2);
249  double etaClus = clus->etaBE(2);
250  if (etaClus < -900) {
251  etaClus = clus->eta();
252  }
253  if (phiClus < -900) {
254  phiClus = clus->phi();
255  }
256  //--FixMe
257  if (isFwrdEle || (etaClus == 0. && phiClus == 0.)) {
258  phiClus = clus->phi();
259  etaClus = clus->eta();
260  }
261  // define calo sample
262  CaloSampling::CaloSample sample = CaloSampling::EMB2;
263  if ((clus->inBarrel() && !clus->inEndcap()) ||
264  (clus->inBarrel() && clus->inEndcap() && clus->eSample(CaloSampling::EMB2) >= clus->eSample(CaloSampling::EME2))) {
265  // Barrel
266  sample = CaloSampling::EMB2;
267  } else if ((!clus->inBarrel() && clus->inEndcap() && !isFwrdEle) ||
268  (clus->inBarrel() && clus->inEndcap() && clus->eSample(CaloSampling::EME2) > clus->eSample(CaloSampling::EMB2))) {
269  // End-cap
270  sample = CaloSampling::EME2;
271  } else if (isFwrdEle && clus->inEndcap()) {
272  // FCAL
273  sample = CaloSampling::FCAL2;
274  } else {
275  return false;
276  }
277  std::unique_ptr<Trk::CurvilinearParameters> params = extractParamFromTruth(*thePart);
278  if (!params) return false;
279  // create extension to sample
280  std::vector<CaloSampling::CaloSample> samples = { sample };
281  auto extension = m_caloExtensionTool->layersCaloExtension(ctx, *params, samples, etaClus, caloDDMgr);
282  bool extensionOK = (!extension.empty());
283  if (!extensionOK) {
284  ATH_MSG_WARNING("extrapolation of Truth Particle with eta " << thePart->eta() << " , charge " << thePart->charge() << " , Pt " << thePart->pt() << " to calo failed");
285  return false;
286  }
287  double etaCalo = extension[0].second->position().eta();
288  double phiCalo = extension[0].second->position().phi();
289 
290  double dPhi = detPhi(phiCalo, phiClus);
291  double dEta = detEta(etaCalo, etaClus);
292  dRmatch = std::hypot(dPhi, dEta);
293 
294  if ((!isFwrdEle && dRmatch > m_phtdRtoTrCut) || (isFwrdEle && dRmatch > m_fwrdEledRtoTrCut)) return false;
295  if (!isFwrdEle && std::hypot( dPhi/m_phtClasConePhi, dEta/m_phtClasConeEta ) <= 1.0) isNarrowCone = true;
296  return true;
297 }

◆ getGenPart()

const xAOD::TruthParticle * MCTruthClassifier::getGenPart ( const xAOD::TrackParticle *  trk,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 181 of file MCRecoToTruth.cxx.

182 {
183  // return GenParticle corresponding to given TrackParticle
184  ATH_MSG_DEBUG("Executing getGenPart ");
185  if (!trk) return nullptr;
186  if (info) {
187  info->deltaRMatch = -999.;
188  info->deltaPhi = -999.;
189  info->probTrkToTruth = 0;
190  info->numOfSiHits = 0;
191  }
192 
193  uint8_t NumOfPixHits = 0;
194  uint8_t NumOfSCTHits = 0;
195  typedef ElementLink<xAOD::TruthParticleContainer> TruthLink_t;
196 
197  static const SG::AuxElement::Accessor<TruthLink_t> tPL("truthParticleLink");
198  if (!tPL.isAvailable(*trk)) {
199  ATH_MSG_DEBUG("Track particle is not associated to truth particle");
200  return nullptr;
201  }
202 
203  const auto& truthLink = tPL(*trk);
204  if (!truthLink.isValid()) {
205  ATH_MSG_DEBUG("Invalid link to truth particle");
206  return nullptr;
207  }
208 
209  const xAOD::TruthParticle* theGenParticle = (*truthLink);
210  if (!theGenParticle) {
211  ATH_MSG_DEBUG("Could not find truth matching for track");
212  return nullptr;
213  }
214 
215  if (info) {
216  static const SG::AuxElement::Accessor<float> tMP("truthMatchProbability");
217  if (tMP.isAvailable(*trk)) {
218  info->probTrkToTruth = tMP(*trk);
219  } else {
220  ATH_MSG_DEBUG("Truth match probability not available");
221  }
222  }
223 
224  if (theGenParticle->status() == 3) {
225  ATH_MSG_WARNING("track matched to the truth with status " << theGenParticle->status());
226  }
227  else if (MC::isDecayed(theGenParticle)) {
228  // Matching to status == 2 particles is to be expected if
229  // quasi-stable particle simulation was used.
230  ATH_MSG_DEBUG("track matched to the truth with status " << theGenParticle->status());
231  }
232 
233  if (MC::isDecayed(theGenParticle) && (MC::isElectron(theGenParticle) || MC::isMuon(theGenParticle))) {
234  const xAOD::TruthVertex* EndVrtx = theGenParticle->decayVtx();
235  const xAOD::TruthParticle* theGenPartTmp(nullptr);
236 
237  if (EndVrtx != nullptr) {
238  int itr = 0;
239  do {
240  theGenPartTmp = nullptr;
241  for (const auto & theDaugt: EndVrtx->particles_out()) {
242  if (!theDaugt) continue;
243  if (theDaugt->pdgId() == theGenParticle->pdgId()) theGenPartTmp = theDaugt;
244  if (theDaugt->pdgId() != theGenParticle->pdgId() && !MC::isPhoton(theDaugt)) theGenPartTmp = nullptr;
245  }
246  itr++;
247  if (itr > 100) {
248  ATH_MSG_WARNING("getGenPart infinite while");
249  break;
250  }
251  EndVrtx = theGenPartTmp ? theGenPartTmp->decayVtx() : nullptr;
252  } while (theGenPartTmp && theGenPartTmp->pdgId() == theGenParticle->pdgId() && MC::isDecayed(theGenPartTmp) && EndVrtx != nullptr);
253 
254  if (theGenPartTmp && theGenPartTmp->pdgId() == theGenParticle->pdgId()) theGenParticle = theGenPartTmp;
255  }
256  }
257 
258  if (!trk->summaryValue(NumOfSCTHits, xAOD::numberOfSCTHits)) ATH_MSG_DEBUG("Could not retrieve number of SCT hits");
259  if (!trk->summaryValue(NumOfPixHits, xAOD::numberOfPixelHits)) ATH_MSG_DEBUG("Could not retrieve number of Pixel hits");
260 
261  uint8_t NumOfSiHits = NumOfSCTHits + NumOfPixHits;
262 
263  float deltaPhi = detPhi(theGenParticle->phi(), trk->phi());
264  float deteta = detEta(theGenParticle->eta(), trk->eta());
265  float deltaRMatch = std::hypot(deltaPhi, deteta);
266  if ((NumOfSiHits > m_NumOfSiHitsCut && deltaRMatch > m_deltaRMatchCut) ||
267  (NumOfSiHits <= m_NumOfSiHitsCut && deltaPhi > m_deltaPhiMatchCut)) theGenParticle = nullptr;
268 
269  if (info) {
270  info->deltaRMatch = deltaRMatch;
271  info->deltaPhi = deltaPhi;
272  info->numOfSiHits = NumOfSiHits;
273  }
274  ATH_MSG_DEBUG("getGenPart succeeded ");
275  return (theGenParticle);
276 }

◆ getKey()

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

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

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

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

See also
asg::AsgTool::getName
Parameters
ptrThe 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.

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

◆ getName()

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

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

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

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

See also
asg::AsgTool::getKey
Parameters
ptrThe 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.

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

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ initialize()

virtual StatusCode MCTruthClassifier::initialize ( )
inlineoverridevirtual

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.

Reimplemented in D3PD::D3PDMCTruthClassifier.

Definition at line 101 of file MCTruthClassifier.h.

107  {
108  ATH_CHECK(m_caloExtensionTool.retrieve());
109  } else {
110  m_caloExtensionTool.disable();
111  }
112 
113  ATH_CHECK(m_caloMgrKey.initialize(SG::AllowEmpty));
114 
115  if (!m_truthInConeTool.empty()) {
116  ATH_CHECK(m_truthInConeTool.retrieve());
117  } else {
118  m_truthInConeTool.disable();
119  }
120 #endif
121  return StatusCode::SUCCESS;
122  }
123  virtual std::pair<MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin>
124  particleTruthClassifier(const xAOD::TruthParticle*,MCTruthPartClassifier::Info* info = nullptr) const override final;
125 
126 #ifndef XAOD_ANALYSIS /*These can not run in Analysis Base*/
127  virtual std::pair<MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin>

◆ 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.

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ 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.

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ 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.

◆ particleTruthClassifier() [1/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( const HepMcParticleLink &  theLink,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 26 of file MCTruthClassifierGen.cxx.

26  {
27  // Retrieve the links between HepMC and xAOD::TruthParticle
28  const EventContext& ctx = info ? info->eventContext : Gaudi::Hive::currentContext();
29  SG::ReadHandle<xAODTruthParticleLinkVector> truthParticleLinkVecReadHandle(m_truthLinkVecReadHandleKey, ctx);
30  if (!truthParticleLinkVecReadHandle.isValid()) {
31  ATH_MSG_WARNING(" Invalid ReadHandle for xAODTruthParticleLinkVector with key: " << truthParticleLinkVecReadHandle.key());
32  return std::make_pair(Unknown, NonDefined);
33  }
34  ElementLink<xAOD::TruthParticleContainer> tplink = truthParticleLinkVecReadHandle->find (theLink);
35  if (tplink.isValid()) {
36  return particleTruthClassifier (*tplink, info);
37  }
38  return std::make_pair(Unknown, NonDefined);
39 }

◆ particleTruthClassifier() [2/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( const xAOD::CaloCluster *  clus,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 114 of file MCRecoToTruth.cxx.

115 {
116  ATH_MSG_DEBUG("Executing egamma photon Classifier with cluster Input");
117  ParticleType parttype = Unknown;
118  ParticleOrigin partorig = NonDefined;
119  if (!clus) return std::make_pair(parttype, partorig);
120  if (std::fabs(clus->eta()) > 10.0 || std::fabs(clus->phi()) > M_PI || (clus->et()) <= 0.) return std::make_pair(parttype, partorig);
121  const xAOD::TruthParticle* genPart = nullptr;
122 #ifndef XAOD_ANALYSIS // Fwd electron available only in Athena
123  genPart = egammaClusMatch(clus, false, info);
124 #else
125  ATH_MSG_WARNING("Cluster Classification using extrapolation to Calo is available only in Athena , check your enviroment. ");
126 #endif
127  if (!genPart) return std::make_pair(parttype, partorig);
128  ATH_MSG_DEBUG("Calo Cluster Classifier succeeded ");
129  if (info) info->genPart = genPart;
130  return particleTruthClassifier(genPart, info);
131 }

◆ particleTruthClassifier() [3/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( const xAOD::Electron *  elec,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 24 of file MCRecoToTruth.cxx.

25 {
26  ATH_MSG_DEBUG("Executing egamma electron Classifier");
27  ParticleType parttype = Unknown;
28  ParticleOrigin partorig = NonDefined;
29  const xAOD::TruthParticle* genPart = nullptr;
30  const xAOD::TrackParticle* trkPtr = elec->trackParticle();
31  if (elec->author() != xAOD::EgammaParameters::AuthorFwdElectron ||trkPtr) {
32  // Central electron or forward electron with track (when reco
33  // implemented in the future)
34  if (!trkPtr){
35  return std::make_pair(parttype, partorig);
36  }
37  genPart = getGenPart(trkPtr);
38  } else {
39 #ifndef XAOD_ANALYSIS // cluster matching available only in Athena
40  const xAOD::CaloCluster* clus = elec->caloCluster();
41  genPart = egammaClusMatch(clus, true, info);
42 #else
43  ATH_MSG_WARNING("Forward Electron classification using extrapolation to Calo is available only in Athena , check your enviroment. ");
44 #endif
45  }
46 
47  if (info) info->genPart = genPart;
48  if (!genPart) return std::make_pair(parttype, partorig);
49  ATH_MSG_DEBUG("egamma electron Classifier succeeded ");
50  return particleTruthClassifier(genPart, info);
51 }

◆ particleTruthClassifier() [4/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( const xAOD::Jet *  jet,
bool  DR,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 134 of file MCRecoToTruth.cxx.

135 {
136  ATH_MSG_DEBUG("Executing Classifier with jet Input");
137  ParticleType parttype = UnknownJet;
138  ParticleOrigin partorig = NonDefined;
139  ParticleType tempparttype = UnknownJet;
140  std::set<const xAOD::TruthParticle*> allJetMothers;
141  std::set<const xAOD::TruthParticle*> constituents;
142  if (!jet) return std::make_pair(parttype, partorig);
143  allJetMothers.clear();
144  constituents.clear();
145  findJetConstituents(jet, constituents, DR);
146  // AV: Jet type is the type of hadron with "heaviest" flavour among the jet constituents.
147  // AV: No hadrons in the jet -- the flavour is unknown.
148  // AV: The algorithm will fail on 4/5 quark hadrons and probably on nonBSM hadrons. To be fixed.
149  for (const auto& thePart: constituents) {
150  MC::findParticleAncestors(thePart, allJetMothers);
151  //AV: probably skip ME particles
152  if (!MC::isPhysical(thePart)) continue;
153  // determine if hadron and its type
154  tempparttype = particleTruthClassifier(thePart, info).first;
155  if (tempparttype != Hadron) continue;
156  tempparttype = defTypeOfHadron(thePart->pdgId());
157  // classify the jet
158  if (tempparttype == BBbarMesonPart || tempparttype == BottomMesonPart || tempparttype == BottomBaryonPart) {
159  parttype = BJet;
160  continue;
161  }
162  if (tempparttype == CCbarMesonPart || tempparttype == CharmedMesonPart || tempparttype == CharmedBaryonPart) {
163  if (parttype != BJet) parttype = CJet;
164  continue;
165  }
166  if (tempparttype == StrangeBaryonPart || tempparttype == LightBaryonPart || tempparttype == StrangeMesonPart || tempparttype == LightMesonPart) {
167  if (parttype != BJet && parttype != CJet) parttype = LJet;
168  continue;
169  }
170  }
171 
172  // clasify the jet origin
173  partorig = defJetOrig(allJetMothers);
174  allJetMothers.clear();
175  constituents.clear();
176  ATH_MSG_DEBUG(" jet Classifier succeeded");
177  return std::make_pair(parttype, partorig);
178 }

◆ particleTruthClassifier() [5/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( const xAOD::Muon *  mu,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 93 of file MCRecoToTruth.cxx.

94 {
95  ATH_MSG_DEBUG("Executing muon Classifier");
96  ParticleType parttype = Unknown;
97  ParticleOrigin partorig = NonDefined;
98  const xAOD::TrackParticle* trkPtr = nullptr;
99  if (mu->primaryTrackParticleLink().isValid()) trkPtr = *mu->primaryTrackParticleLink();
100  else if (mu->combinedTrackParticleLink().isValid()) trkPtr = *mu->combinedTrackParticleLink();
101  else if (mu->inDetTrackParticleLink().isValid()) trkPtr = *mu->combinedTrackParticleLink();
102  else if (mu->muonSpectrometerTrackParticleLink().isValid()) trkPtr = *mu->muonSpectrometerTrackParticleLink();
103 
104  if (!trkPtr) return std::make_pair(parttype, partorig);
105 
106  const xAOD::TruthParticle* genPart = getGenPart(trkPtr);
107  if (!genPart) return std::make_pair(parttype, partorig);
108  if (info) info->genPart = genPart;
109  ATH_MSG_DEBUG("muon Classifier succeeded ");
110  return particleTruthClassifier(genPart, info);
111 }

◆ particleTruthClassifier() [6/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( const xAOD::Photon *  phot,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 54 of file MCRecoToTruth.cxx.

55 {
56  ATH_MSG_DEBUG("Executing egamma photon Classifier");
57  ParticleType parttype = Unknown;
58  ParticleOrigin partorig = NonDefined;
59  const xAOD::CaloCluster* clus = phot->caloCluster();
60  if (!clus) return std::make_pair(parttype, partorig);
61  if (std::fabs(clus->eta()) > 10.0 || std::fabs(clus->phi()) > 6.28 || (clus->et()) <= 0.) return std::make_pair(parttype, partorig);
62 
63  const xAOD::Vertex* VxCvPtr = phot->vertex();
64  if (VxCvPtr != nullptr) {
65  for (int itrk = 0; itrk < (int)VxCvPtr->nTrackParticles(); itrk++) {
66  if (itrk > 1) continue;
67  const xAOD::TrackParticle* trkPtr = VxCvPtr->trackParticle(itrk);
68  if (!trkPtr) continue;
69  const xAOD::TruthParticle* thePart = getGenPart(trkPtr);
70  std::pair<ParticleType, ParticleOrigin> classif = particleTruthClassifier(thePart, info);
71  if (info) {
72  info->cnvPhotTrkPtr.push_back(trkPtr);
73  info->cnvPhotTrkToTruthPart.push_back(thePart);
74  info->cnvPhotPartType.push_back(classif.first);
75  info->cnvPhotPartOrig.push_back(classif.second);
76  }
77  }
78  }
79 
80  const xAOD::TruthParticle* genPart = nullptr;
81 #ifndef XAOD_ANALYSIS // Fwd electron available only in Athena
82  genPart = egammaClusMatch(clus, false, info);
83 #else
84  ATH_MSG_WARNING("Photon Classification using extrapolation to Calo is available only in Athena , check your enviroment. ");
85 #endif
86  if (!genPart) return std::make_pair(parttype, partorig);
87  if (info) info->genPart = genPart;
88  ATH_MSG_DEBUG("egamma photon Classifier succeeded ");
89  return particleTruthClassifier(genPart, info);
90 }

◆ particleTruthClassifier() [7/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( const xAOD::TrackParticle *  trkPtr,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 11 of file MCRecoToTruth.cxx.

12 {
13  ATH_MSG_DEBUG("Executing trackClassifier");
14  ParticleType parttype = Unknown;
15  ParticleOrigin partorig = NonDefined;
16  const xAOD::TruthParticle* genPart = getGenPart(trkPtr);
17  if (info) info->genPart = genPart;
18  if (!genPart) return std::make_pair(parttype, partorig);
19  ATH_MSG_DEBUG("trackClassifier succeeded ");
20  return particleTruthClassifier(genPart, info);
21 }

◆ particleTruthClassifier() [8/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( const xAOD::TruthParticle *  thePart,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 75 of file MCTruthClassifierGen.cxx.

75  {
76  MCTruthPartClassifier::Info tmpinfo;
77  MCTruthPartClassifier::Info& info = (infoin) ? *infoin : tmpinfo;
78 
79  ATH_MSG_DEBUG("Executing particleTruthClassifier");
80 
81  ParticleType partType = Unknown;
82  ParticleOrigin partOrig = NonDefined;
83  if (!thePart) {
84  return std::make_pair(partType, partOrig);
85  }
86  info.genPart = thePart;
87 
88  // retrieve collection and get a pointer
89  SG::ReadHandle<xAOD::TruthParticleContainer> truthParticleContainerReadHandle(m_truthParticleContainerKey,info.eventContext);
90  if (!truthParticleContainerReadHandle.isValid()) {
91  ATH_MSG_WARNING( " Invalid ReadHandle for xAOD::TruthParticleContainer with key: " << truthParticleContainerReadHandle.key());
92  return std::make_pair(partType, partOrig);
93  }
94 
95  ATH_MSG_DEBUG("xAODTruthParticleContainer with key " << truthParticleContainerReadHandle.key() << " has valid ReadHandle ");
96 
97  if (!MC::isStable(thePart) && !MC::isDecayed(thePart)) {
98  return std::make_pair(GenParticle, partOrig);
99  }
100  const bool isPartHadr = MC::isHadron(thePart) && !MC::isBeam(thePart);
101  if (MC::isDecayed(thePart) && (!MC::isTau(thePart) && !isPartHadr)) return std::make_pair(GenParticle, partOrig);
102 
103  // SUSY datasets: tau(status==2)->tau(status==2)
104  if (MC::isDecayed(thePart) && MC::isTau(thePart)) {
105  const xAOD::TruthVertex* endVert = thePart->decayVtx();
106  if (endVert) {
107  const int numOfDaught = endVert->nOutgoingParticles();
108  if (numOfDaught == 1 && MC::isTau(endVert->outgoingParticle(0))) {
109  return std::make_pair(GenParticle, partOrig);
110  }
111  }
112  }
113 
114  if (MC::isStable(thePart) && MC::isSUSY(thePart)) return std::make_pair(SUSYParticle, partOrig);
115 
116  if (MC::isStable(thePart) && MC::isBSM(thePart)) return std::make_pair(OtherBSMParticle, partOrig);
117 
118  if (MC::isDecayed(thePart) &&
119  (!MC::isElectron(thePart) && !MC::isMuon(thePart) &&
120  !MC::isTau(thePart) && !MC::isPhoton(thePart)) &&
121  !isPartHadr)
122  return std::make_pair(GenParticle, partOrig);
123 
124  // FIXME vetoing protons here to preserve previous behaviour
125  if (MC::isNucleus(thePart) && std::abs(thePart->pdgId()) != MC::PROTON) return std::make_pair(NuclFrag, partOrig);
126 
127  if ( !MC::isSMLepton(thePart) && !MC::isPhoton(thePart) && !isPartHadr) return std::make_pair(partType, partOrig);
128  // don't consider generator particles
129 
130  const xAOD::TruthVertex* partOriVert = thePart->hasProdVtx() ? thePart->prodVtx() : nullptr;
131 
132  const xAOD::TruthParticle* theMoth{};
133  if (partOriVert) {
134  for (const auto& temp: partOriVert->particles_in()) {if (temp) theMoth = temp;}
135  }
136  const int motherPDG = theMoth?theMoth->pdg_id():0;
137  info.setMotherProperties(theMoth);
138 
139  if (!partOriVert && HepMC::is_simulation_particle(thePart)) {
140  return std::make_pair(NonPrimary, partOrig);
141  }
142  if (!partOriVert && MC::isElectron(thePart)) {
143  // to define electron outcome status
144  bool isPrompt = false; // updated by defOrigOfElectron
145  partOrig = defOrigOfElectron(*truthParticleContainerReadHandle, thePart, isPrompt, info);
146  return std::make_pair(UnknownElectron, partOrig);
147  }
148  if (!partOriVert && MC::isMuon(thePart)) {
149  // to define electron outcome status
150  bool isPrompt = false; // updated by defOrigOfMuon
151  partOrig = defOrigOfMuon(*truthParticleContainerReadHandle, thePart, isPrompt, info);
152  return std::make_pair(UnknownMuon, partOrig);
153  }
154  if (!partOriVert && MC::isTau(thePart)) {
155  // to define electron outcome status
156  partOrig = defOrigOfTau(*truthParticleContainerReadHandle, thePart, motherPDG, info);
157  return std::make_pair(UnknownTau, partOrig);
158  }
159  if (!partOriVert && MC::isPhoton(thePart)) {
160  // to define photon outcome
161  bool isPrompt = false; // updated by defOrigOfPhoton
162  partOrig = defOrigOfPhoton(*truthParticleContainerReadHandle, thePart, isPrompt, info);
163  return std::make_pair(UnknownPhoton, partOrig);
164  }
165  if (!partOriVert && MC::isNeutrino(thePart)) {
166  // to define neutrino outcome
167  info.particleOutCome = NonInteract;
168  return std::make_pair(Neutrino, partOrig);
169  }
170 
171  if (thePart && info.Mother() && HepMC::is_same_generator_particle(thePart,info.Mother()))
172  return std::make_pair(NonPrimary, partOrig);
173 
174  if (isPartHadr) return std::make_pair(Hadron, partOrig);
175 
176  if (partOriVert && motherPDG == 0 && partOriVert->nOutgoingParticles() == 1 &&
177  partOriVert->nIncomingParticles() == 0) {
178  if (MC::isElectron(thePart)) {
179  info.particleOutCome = defOutComeOfElectron(thePart);
180  return std::make_pair(IsoElectron, SingleElec);
181  }
182  if (MC::isMuon(thePart)) {
183  info.particleOutCome = defOutComeOfMuon(thePart);
184  return std::make_pair(IsoMuon, SingleMuon);
185  }
186  if (MC::isTau(thePart)) {
187  info.particleOutCome = defOutComeOfTau(thePart);
188  return std::make_pair(IsoTau, SingleTau);
189  }
190  if (MC::isPhoton(thePart)) {
191  info.particleOutCome = defOutComeOfPhoton(thePart);
192  return std::make_pair(IsoPhoton, SinglePhot);
193  }
194  }
195 
196  if (motherPDG == thePart->pdg_id() && theMoth && theMoth->status() == 3 && MC::isDecayed(thePart)) return std::make_pair(GenParticle, partOrig);
197 
198  if (MC::isElectron(thePart)) {
199  bool isPrompt = false; // updated by defOrigOfElectron
200  partOrig = defOrigOfElectron(*truthParticleContainerReadHandle, thePart, isPrompt, info);
201  partType = defTypeOfElectron(partOrig, isPrompt);
202  } else if (MC::isMuon(thePart)) {
203  bool isPrompt = false; // updated by defOrigOfMuon
204  partOrig = defOrigOfMuon(*truthParticleContainerReadHandle, thePart, isPrompt, info);
205  partType = defTypeOfMuon(partOrig, isPrompt);
206  } else if (MC::isTau(thePart)) {
207  partOrig = defOrigOfTau(*truthParticleContainerReadHandle, thePart, motherPDG, info);
208  partType = defTypeOfTau(partOrig);
209  } else if (MC::isPhoton(thePart)) {
210  bool isPrompt = false; // updated by defOrigOfPhoton
211  partOrig = defOrigOfPhoton(*truthParticleContainerReadHandle, thePart, isPrompt, info);
212  partType = defTypeOfPhoton(partOrig);
213  } else if (MC::isNeutrino(thePart)) {
214  bool isPrompt = false; // updated by defOrigOfNeutrino
215  partOrig = defOrigOfNeutrino(*truthParticleContainerReadHandle, thePart, isPrompt, info);
216  partType = Neutrino;
217  }
218 
219  ATH_MSG_DEBUG("particleTruthClassifier succeeded ");
220  return std::make_pair(partType, partOrig);
221 }

◆ particleTruthClassifier() [9/9]

std::pair< ParticleType, ParticleOrigin > MCTruthClassifier::particleTruthClassifier ( HepMC::ConstGenParticlePtr  theGenPart,
MCTruthPartClassifier::Info *  info = nullptr 
) const
finaloverridevirtual

Implements IMCTruthClassifier.

Definition at line 42 of file MCTruthClassifierGen.cxx.

42  {
43  ParticleType partType = Unknown;
44  ParticleOrigin partOrig = NonDefined;
45 
46  if (!theGenPart) return std::make_pair(partType, partOrig);
47 
48  // Retrieve the links between HepMC and xAOD::TruthParticle
49  const EventContext& ctx = info ? info->eventContext : Gaudi::Hive::currentContext();
50 
51  SG::ReadHandle<xAODTruthParticleLinkVector> truthParticleLinkVecReadHandle(m_truthLinkVecReadHandleKey, ctx);
52  if (!truthParticleLinkVecReadHandle.isValid()) {
53  ATH_MSG_WARNING( " Invalid ReadHandle for xAODTruthParticleLinkVector with key: " << truthParticleLinkVecReadHandle.key());
54  return std::make_pair(partType, partOrig);
55  }
56  for (const auto *const entry : *truthParticleLinkVecReadHandle) {
57  if (entry->first.isValid() && entry->second.isValid() && HepMC::is_same_particle(entry->first,theGenPart)) {
58  const xAOD::TruthParticle* truthParticle = *entry->second;
59  if (!theGenPart || !truthParticle ||
60  theGenPart->pdg_id() != truthParticle->pdgId() ||
61  theGenPart->status() != truthParticle->status() ||
62  HepMC::is_same_particle(theGenPart,truthParticle)) {
63  ATH_MSG_DEBUG(
64  "HepMC::GenParticle and xAOD::TruthParticle do not match");
65  return std::make_pair(partType, partOrig);
66  }
67  return particleTruthClassifier(truthParticle, info);
68  }
69  }
70  return std::make_pair(partType, partOrig);
71 }

◆ print() [1/2]

void asg::AsgTool::print ( ) const
virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

131  {
132 
133  ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134  return;
135  }

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const
pure virtualinherited

Print the state of the tool.

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

◆ 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.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ 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.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

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

Perform system initialization for an algorithm.

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

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_caloExtensionTool

ToolHandle<Trk::IParticleCaloExtensionTool> MCTruthClassifier::m_caloExtensionTool {this,"ParticleCaloExtensionTool",""}
private

Definition at line 224 of file MCTruthClassifier.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> MCTruthClassifier::m_caloMgrKey {this,"CaloDetDescrManager",""}
private

Definition at line 225 of file MCTruthClassifier.h.

◆ m_deltaPhiMatchCut

float MCTruthClassifier::m_deltaPhiMatchCut
private

Definition at line 252 of file MCTruthClassifier.h.

◆ m_deltaRMatchCut

float MCTruthClassifier::m_deltaRMatchCut
private

Definition at line 251 of file MCTruthClassifier.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_FwdElectronTruthExtrEtaCut

float MCTruthClassifier::m_FwdElectronTruthExtrEtaCut
private

Definition at line 230 of file MCTruthClassifier.h.

◆ m_FwdElectronTruthExtrEtaWindowCut

float MCTruthClassifier::m_FwdElectronTruthExtrEtaWindowCut
private

Definition at line 231 of file MCTruthClassifier.h.

◆ m_FwdElectronUseG4Sel

bool MCTruthClassifier::m_FwdElectronUseG4Sel
private

Definition at line 229 of file MCTruthClassifier.h.

◆ m_fwrdEledRtoTrCut

float MCTruthClassifier::m_fwrdEledRtoTrCut
private

Definition at line 238 of file MCTruthClassifier.h.

◆ m_inclG4part

bool MCTruthClassifier::m_inclG4part
private

Definition at line 243 of file MCTruthClassifier.h.

◆ m_jetPartDRMatch

float MCTruthClassifier::m_jetPartDRMatch
private

Definition at line 254 of file MCTruthClassifier.h.

◆ m_NumOfSiHitsCut

int MCTruthClassifier::m_NumOfSiHitsCut
private

Definition at line 253 of file MCTruthClassifier.h.

◆ m_partExtrConeEta

float MCTruthClassifier::m_partExtrConeEta
private

Definition at line 232 of file MCTruthClassifier.h.

◆ m_partExtrConePhi

float MCTruthClassifier::m_partExtrConePhi
private

Definition at line 233 of file MCTruthClassifier.h.

◆ m_phtClasConeEta

float MCTruthClassifier::m_phtClasConeEta
private

Definition at line 236 of file MCTruthClassifier.h.

◆ m_phtClasConePhi

float MCTruthClassifier::m_phtClasConePhi
private

Definition at line 235 of file MCTruthClassifier.h.

◆ m_phtdRtoTrCut

float MCTruthClassifier::m_phtdRtoTrCut
private

Definition at line 237 of file MCTruthClassifier.h.

◆ m_pTChargePartCut

float MCTruthClassifier::m_pTChargePartCut
private

Definition at line 241 of file MCTruthClassifier.h.

◆ m_pTNeutralPartCut

float MCTruthClassifier::m_pTNeutralPartCut
private

Definition at line 242 of file MCTruthClassifier.h.

◆ m_ROICone

bool MCTruthClassifier::m_ROICone
private

Definition at line 239 of file MCTruthClassifier.h.

◆ m_truthInConeTool

ToolHandle<xAOD::ITruthParticlesInConeTool> MCTruthClassifier::m_truthInConeTool {this,"TruthInConeTool","xAOD::TruthParticlesInConeTool/TruthParticlesInConeTool"}
private

Definition at line 227 of file MCTruthClassifier.h.

◆ m_truthLinkVecReadHandleKey

SG::ReadHandleKey<xAODTruthParticleLinkVector> MCTruthClassifier::m_truthLinkVecReadHandleKey {this,"xAODTruthLinkVector","xAODTruthLinks", "ReadHandleKey for xAODTruthParticleLinkVector"}
private

Definition at line 248 of file MCTruthClassifier.h.

◆ m_truthParticleContainerKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> MCTruthClassifier::m_truthParticleContainerKey {this,"xAODTruthParticleContainerName","TruthParticles","ReadHandleKey for xAOD::TruthParticleContainer"}
private

Definition at line 221 of file MCTruthClassifier.h.

◆ m_useCaching

bool MCTruthClassifier::m_useCaching
private

Definition at line 234 of file MCTruthClassifier.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:
grepfile.info
info
Definition: grepfile.py:38
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
xAOD::TruthVertex_v1::nOutgoingParticles
size_t nOutgoingParticles() const
Get the number of outgoing particles.
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
NuRMu
@ NuRMu
Definition: TruthClasses.h:73
temp
Definition: JetEventDict.h:21
IsoPhoton
@ IsoPhoton
Definition: TruthClasses.h:23
MCTruthPartClassifier::defOutComeOfMuon
ParticleOutCome defOutComeOfMuon(T thePart)
Definition: TruthClassifiers.h:213
LightBaryonPart
@ LightBaryonPart
Definition: TruthClasses.h:40
MCTruthPartClassifier::defTypeOfPhoton
ParticleType defTypeOfPhoton(ParticleOrigin PhotOrig)
Definition: TruthClassifiers.h:115
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
calibdata.pout
def pout(output, newline=True)
Definition: calibdata.py:130
TauLep
@ TauLep
Definition: TruthClasses.h:63
isNucleus
bool isNucleus(const T &p)
PDG rule 16 Nuclear codes are given as 10-digit numbers ±10LZZZAAAI.
Definition: AtlasPID.h:644
HepMC::is_same_vertex
bool is_same_vertex(const T1 &p1, const T2 &p2)
Method to establish if two particles in the GenEvent actually represent the same vertex.
Definition: MagicNumbers.h:370
xAOD::Vertex_v1::nTrackParticles
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
Definition: Vertex_v1.cxx:270
OtherBSMParticle
@ OtherBSMParticle
Definition: TruthClasses.h:32
MCTruthClassifier::m_FwdElectronTruthExtrEtaWindowCut
float m_FwdElectronTruthExtrEtaWindowCut
Definition: MCTruthClassifier.h:231
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:395
isHeavyBoson
bool isHeavyBoson(const T &p)
APID: Additional "Heavy"/"prime" versions of W and Z bosons (Used in MCTruthClassifier)
Definition: AtlasPID.h:359
NuREle
@ NuREle
Definition: TruthClasses.h:72
Mu
@ Mu
Definition: TruthClasses.h:62
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
xAOD::TruthVertex_v1::particles_in
std::vector< const TruthParticle * > particles_in() const
Get the incoming particles.
Definition: TruthVertex_v1.cxx:59
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
MC::findParticleAncestors
void findParticleAncestors(T thePart, std::set< T > &allancestors)
Function to find all ancestors of the particle.
Definition: HepMCHelpers.h:150
WBosonLRSM
@ WBosonLRSM
Definition: TruthClasses.h:71
columnar::ContainerId::particle0
@ particle0
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
SingleTau
@ SingleTau
Definition: TruthClasses.h:57
isBSM
bool isBSM(const T &p)
APID: graviton and all Higgs extensions are BSM.
Definition: AtlasPID.h:783
PionDecay
@ PionDecay
Definition: TruthClasses.h:90
MCTruthClassifier::findJetConstituents
void findJetConstituents(const xAOD::Jet *, std::set< const xAOD::TruthParticle * > &constituents, bool DR) const
Definition: MCRecoToTruth.cxx:278
SG::ReadHandle< xAOD::TruthParticleContainer >
MCTruthPartClassifier::defOutComeOfTau
ParticleOutCome defOutComeOfTau(T thePart)
Definition: TruthClassifiers.h:240
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
MCTruthClassifier::defOrigOfElectron
MCTruthPartClassifier::ParticleOrigin defOrigOfElectron(const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, bool &isPrompt, MCTruthPartClassifier::Info &info) const
Definition: MCTruthClassifierGen.cxx:225
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:160
MCTruthClassifier::m_phtClasConeEta
float m_phtClasConeEta
Definition: MCTruthClassifier.h:236
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
ElMagProc
@ ElMagProc
Definition: TruthClasses.h:61
xAOD::Egamma_v1::author
uint16_t author(uint16_t bitmask=EgammaParameters::AuthorALL) const
Get author.
Definition: Egamma_v1.cxx:166
MCTruthClassifier::m_partExtrConeEta
float m_partExtrConeEta
Definition: MCTruthClassifier.h:232
isNeutrino
bool isNeutrino(const T &p)
APID: the fourth generation neutrinos are neutrinos.
Definition: AtlasPID.h:201
test_pyathena.pt
pt
Definition: test_pyathena.py:11
M_PI
#define M_PI
Definition: ActiveFraction.h:11
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::CaloCluster_v1::et
double et() const
Definition: CaloCluster_v1.h:859
IsoElectron
@ IsoElectron
Definition: TruthClasses.h:11
SingleElec
@ SingleElec
Definition: TruthClasses.h:54
PhotonConv
@ PhotonConv
Definition: TruthClasses.h:59
MCTruthClassifier::m_caloExtensionTool
ToolHandle< Trk::IParticleCaloExtensionTool > m_caloExtensionTool
Definition: MCTruthClassifier.h:224
CharmedMesonPart
@ CharmedMesonPart
Definition: TruthClasses.h:36
ISRPhot
@ ISRPhot
Definition: TruthClasses.h:95
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
xAOD::Electron_v1::trackParticle
const xAOD::TrackParticle * trackParticle(size_t index=0) const
Pointer to the xAOD::TrackParticle/s that match the electron candidate.
Definition: Electron_v1.cxx:55
PromptPhot
@ PromptPhot
Definition: TruthClasses.h:93
xAOD::CaloCluster_v1::phiBE
float phiBE(const unsigned layer) const
Get the phi in one layer of the EM Calo.
Definition: CaloCluster_v1.cxx:634
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
MCTruthPartClassifier::defTypeOfElectron
ParticleType defTypeOfElectron(ParticleOrigin EleOrig, bool isPrompt)
Definition: TruthClassifiers.h:61
BottomMesonPart
@ BottomMesonPart
Definition: TruthClasses.h:34
NuRTau
@ NuRTau
Definition: TruthClasses.h:74
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
MCTruthClassifier::m_pTNeutralPartCut
float m_pTNeutralPartCut
Definition: MCTruthClassifier.h:242
xAOD::EgammaParameters::AuthorFwdElectron
const uint16_t AuthorFwdElectron
Electron reconstructed by the Forward cluster-based algorithm.
Definition: EgammaDefs.h:30
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
UnknownMuon
@ UnknownMuon
Definition: TruthClasses.h:14
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
ZBoson
@ ZBoson
Definition: TruthClasses.h:67
UnknownTau
@ UnknownTau
Definition: TruthClasses.h:18
Hadron
@ Hadron
Definition: TruthClasses.h:26
xAOD::TruthParticle_v1::pdg_id
int pdg_id() const
PDG ID code.
Definition: TruthParticle_v1.h:52
HepMC::is_same_particle
bool is_same_particle(const T1 &p1, const T2 &p2)
Method to establish if two particles in the GenEvent actually represent the same particle.
Definition: MagicNumbers.h:367
StrangeMesonPart
@ StrangeMesonPart
Definition: TruthClasses.h:41
MCTruthClassifier::m_truthParticleContainerKey
SG::ReadHandleKey< xAOD::TruthParticleContainer > m_truthParticleContainerKey
Definition: MCTruthClassifier.h:221
WBoson
@ WBoson
Definition: TruthClasses.h:66
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
isSMLepton
bool isSMLepton(const T &p)
Definition: AtlasPID.h:183
isSMQuark
bool isSMQuark(const T &p)
Definition: AtlasPID.h:162
isGluon
bool isGluon(const T &p)
Definition: AtlasPID.h:346
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
FSRPhot
@ FSRPhot
Definition: TruthClasses.h:96
isHiggs
bool isHiggs(const T &p)
APID: HIGGS boson is only one particle.
Definition: AtlasPID.h:363
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
NuclFrag
@ NuclFrag
Definition: TruthClasses.h:28
BBbarMesonPart
@ BBbarMesonPart
Definition: TruthClasses.h:33
MCTruthPartClassifier::defTypeOfMuon
ParticleType defTypeOfMuon(ParticleOrigin MuOrig, bool isPrompt)
Definition: TruthClassifiers.h:80
NonDefined
@ NonDefined
Definition: TruthClasses.h:52
MCTruthClassifier::m_NumOfSiHitsCut
int m_NumOfSiHitsCut
Definition: MCTruthClassifier.h:253
HiggsMSSM
@ HiggsMSSM
Definition: TruthClasses.h:69
xAOD::CaloCluster_v1::etaBE
float etaBE(const unsigned layer) const
Get the eta in one layer of the EM Calo.
Definition: CaloCluster_v1.cxx:628
MC::isPhysical
bool isPhysical(const T &p)
Identify if the particle is physical, i.e. is stable or decayed.
Definition: HepMCHelpers.h:51
CCbarMesonPart
@ CCbarMesonPart
Definition: TruthClasses.h:35
MCTruthClassifier::m_jetPartDRMatch
float m_jetPartDRMatch
Definition: MCTruthClassifier.h:254
isQuark
bool isQuark(const T &p)
PDG rule 2: Quarks and leptons are numbered consecutively starting from 1 and 11 respectively; to dot...
Definition: AtlasPID.h:158
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
Neutrino
@ Neutrino
Definition: TruthClasses.h:27
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
xAOD::CaloCluster_v1::inEndcap
bool inEndcap() const
Returns true if at least one clustered cell in the endcap.
Definition: CaloCluster_v1.h:892
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
MCTruthClassifier::m_FwdElectronTruthExtrEtaCut
float m_FwdElectronTruthExtrEtaCut
Definition: MCTruthClassifier.h:230
HepMC::is_same_generator_particle
bool is_same_generator_particle(const T1 &p1, const T2 &p2)
Method to establish if two particles in the GenEvent actually represent the same generated particle.
Definition: MagicNumbers.h:364
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:116
HepMC::is_simulation_particle
bool is_simulation_particle(const T &p)
Method to establish if a particle (or barcode) was created during the simulation (TODO update to be s...
Definition: MagicNumbers.h:355
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
TruthLink_t
ElementLink< xAOD::TruthParticleContainer > TruthLink_t
Definition: TauxAODHelpers.cxx:7
MC::findMatching
T findMatching(C TruthContainer, T p)
Function to find a particle in container.
Definition: HepMCHelpers.h:127
UnknownElectron
@ UnknownElectron
Definition: TruthClasses.h:10
MCTruthClassifier::defOrigOfMuon
MCTruthPartClassifier::ParticleOrigin defOrigOfMuon(const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, bool &isPrompt, MCTruthPartClassifier::Info &info) const
Definition: MCTruthClassifierGen.cxx:525
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
checkxAOD.frac
frac
Definition: Tools/PyUtils/bin/checkxAOD.py:259
ParticleOrigin
ParticleOrigin
Definition: TruthClasses.h:51
PiZero
@ PiZero
Definition: TruthClasses.h:98
xAOD::EgammaHelpers::isElectron
bool isElectron(const xAOD::Egamma *eg)
is the object an electron (not Fwd)
Definition: EgammaxAODHelpers.cxx:12
MultiBoson
@ MultiBoson
Definition: TruthClasses.h:101
isZ
bool isZ(const T &p)
Definition: AtlasPID.h:352
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:37
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:548
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition: Egamma_v1.cxx:388
xAOD::TruthParticle_v1::hasProdVtx
bool hasProdVtx() const
Check for a production vertex on this particle.
Definition: TruthParticle_v1.cxx:74
MCTruthClassifier::defOrigOfNeutrino
MCTruthPartClassifier::ParticleOrigin defOrigOfNeutrino(const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, bool &isPrompt, MCTruthPartClassifier::Info &info) const
Definition: MCTruthClassifierGen.cxx:1190
xAOD::CaloCluster_v1::inBarrel
bool inBarrel() const
Returns true if at least one clustered cell in the barrel.
Definition: CaloCluster_v1.h:887
DiBoson
@ DiBoson
Definition: TruthClasses.h:99
IsoTau
@ IsoTau
Definition: TruthClasses.h:19
MCTruthClassifier::egammaClusMatch
virtual const xAOD::TruthParticle * egammaClusMatch(const xAOD::CaloCluster *, bool, MCTruthPartClassifier::Info *info) const override final
Definition: MCTruthClassifierAthena.cxx:44
LQ
@ LQ
Definition: TruthClasses.h:75
LightMesonPart
@ LightMesonPart
Definition: TruthClasses.h:42
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
JPsi
@ JPsi
Definition: TruthClasses.h:84
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
MCTruthClassifier::m_truthLinkVecReadHandleKey
SG::ReadHandleKey< xAODTruthParticleLinkVector > m_truthLinkVecReadHandleKey
Definition: MCTruthClassifier.h:248
MC::findParticleStableDescendants
void findParticleStableDescendants(T thePart, std::set< T > &allstabledescendants)
Function to get the particle stable MC daughters.
Definition: HepMCHelpers.h:162
MC::findMother
T findMother(T thePart)
Function to get a mother of particle. MCTruthClassifier legacy.
Definition: HepMCHelpers.h:94
xAOD::Vertex_v1::trackParticle
const TrackParticle * trackParticle(size_t i) const
Get the pointer to a given track that was used in vertex reco.
Definition: Vertex_v1.cxx:249
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::TruthVertex_v1::incomingParticle
const TruthParticle_v1 * incomingParticle(size_t index) const
Get one of the incoming particles.
Definition: TruthVertex_v1.cxx:69
IsoMuon
@ IsoMuon
Definition: TruthClasses.h:15
StrangeBaryonPart
@ StrangeBaryonPart
Definition: TruthClasses.h:39
MCTruthClassifier::m_phtClasConePhi
float m_phtClasConePhi
Definition: MCTruthClassifier.h:235
MCTruthClassifier::m_partExtrConePhi
float m_partExtrConePhi
Definition: MCTruthClassifier.h:233
CharmedBaryonPart
@ CharmedBaryonPart
Definition: TruthClasses.h:38
MCTruthPartClassifier::defTypeOfHadron
ParticleType defTypeOfHadron(int pdg)
Definition: TruthClassifiers.h:46
isSUSY
bool isSUSY(const T &p)
PDG rule 11d Fundamental supersymmetric particles are identified by adding a nonzero n to the particl...
Definition: AtlasPID.h:428
LJet
@ LJet
Definition: TruthClasses.h:45
MCTruthClassifier::defOrigOfPhoton
MCTruthPartClassifier::ParticleOrigin defOrigOfPhoton(const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, bool &isPrompt, MCTruthPartClassifier::Info &info) const
Definition: MCTruthClassifierGen.cxx:930
MCTruthClassifier::genPartToCalo
bool genPartToCalo(const EventContext &ctx, const xAOD::CaloCluster *clus, const xAOD::TruthParticle *thePart, bool isFwrdEle, double &dRmatch, bool &isNarrowCone, const CaloDetDescrManager &caloDDMgr) const
Definition: MCTruthClassifierAthena.cxx:237
isTau
bool isTau(const T &p)
Definition: AtlasPID.h:197
MC::Pythia8::isConditionA
bool isConditionA(const T &p)
To be understood.
Definition: HepMCHelpers.h:23
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::TruthParticle_v1::decayVtx
const TruthVertex_v1 * decayVtx() const
The decay vertex of this particle.
xAOD::TruthParticle_v1::prodVtx
const TruthVertex_v1 * prodVtx() const
The production vertex of this particle.
Definition: TruthParticle_v1.cxx:80
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
BJet
@ BJet
Definition: TruthClasses.h:43
xAOD::TruthVertex_v1
Class describing a truth vertex in the MC record.
Definition: TruthVertex_v1.h:37
SinglePhot
@ SinglePhot
Definition: TruthClasses.h:56
MCTruthPartClassifier::defOutComeOfElectron
ParticleOutCome defOutComeOfElectron(T thePart)
Definition: TruthClassifiers.h:189
BottomBaryonPart
@ BottomBaryonPart
Definition: TruthClasses.h:37
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
columnar::final
CM final
Definition: ColumnAccessor.h:106
SUSY
@ SUSY
Definition: TruthClasses.h:77
HeavyBoson
@ HeavyBoson
Definition: TruthClasses.h:70
MCTruthClassifier::m_inclG4part
bool m_inclG4part
Definition: MCTruthClassifier.h:243
isHadron
bool isHadron(const T &p)
Definition: AtlasPID.h:324
isNeutrinoRH
bool isNeutrinoRH(const T &p)
PDG Rule 12: APID: Helper function for right-handed neutrino states These are generator defined PDG I...
Definition: AtlasPID.h:393
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
xAOD::TruthVertex_v1::particles_out
std::vector< const TruthParticle * > particles_out() const
Get the outgoing particles.
Definition: TruthVertex_v1.cxx:64
xAOD::TruthParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TruthParticle_v1.cxx:174
UndrPhot
@ UndrPhot
Definition: TruthClasses.h:94
NucReact
@ NucReact
Definition: TruthClasses.h:97
NonInteract
@ NonInteract
Definition: TruthClasses.h:110
QuarkWeakDec
@ QuarkWeakDec
Definition: TruthClasses.h:65
MCTruthClassifier::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: MCTruthClassifier.h:225
isW
bool isW(const T &p)
Definition: AtlasPID.h:355
xAOD::TruthParticle_v1::status
int status() const
Status code.
MC::isStable
bool isStable(const T &p)
Identify if the particle is stable, i.e. has not decayed.
Definition: HepMCHelpers.h:45
xAOD::CaloCluster_v1::eSample
float eSample(const CaloSample sampling) const
Definition: CaloCluster_v1.cxx:514
SUSYParticle
@ SUSYParticle
Definition: TruthClasses.h:31
a
TList * a
Definition: liststreamerinfos.cxx:10
isTop
bool isTop(const T &p)
Definition: AtlasPID.h:175
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
Amg::intersect
std::optional< double > intersect(const AmgVector(N)&posA, const AmgVector(N)&dirA, const AmgVector(N)&posB, const AmgVector(N)&dirB)
Calculates the point B' along the line B that's closest to a second line A.
Definition: GeoPrimitivesHelpers.h:347
xAOD::TruthParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle.
Definition: TruthParticle_v1.cxx:181
MCTruthPartClassifier::isPrompt
int isPrompt(const unsigned int classify, bool allow_prompt_tau_decays=true)
Definition: TruthClassifiers.h:180
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::TruthVertex_v1::nIncomingParticles
size_t nIncomingParticles() const
Get the number of incoming particles.
Definition: TruthVertex_v1.cxx:47
MC::isDecayed
bool isDecayed(const T &p)
Identify if the particle decayed.
Definition: HepMCHelpers.h:42
xAOD::EgammaHelpers::isPhoton
bool isPhoton(const xAOD::Egamma *eg)
is the object a photon
Definition: EgammaxAODHelpers.cxx:21
MC::isBeam
bool isBeam(const T &p)
Identify if the particle is beam particle.
Definition: HepMCHelpers.h:39
MCTruthClassifier::m_deltaRMatchCut
float m_deltaRMatchCut
Definition: MCTruthClassifier.h:251
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
MCTruthPartClassifier::convHadronTypeToOrig
ParticleOrigin convHadronTypeToOrig(ParticleType pType, int motherPDG)
Definition: TruthClassifiers.h:15
NonPrimary
@ NonPrimary
Definition: TruthClasses.h:29
Higgs
@ Higgs
Definition: TruthClasses.h:68
MCTruthClassifier::m_deltaPhiMatchCut
float m_deltaPhiMatchCut
Definition: MCTruthClassifier.h:252
MCTruthPartClassifier::defJetOrig
ParticleOrigin defJetOrig(const T &allJetMothers)
Definition: TruthClassifiers.h:131
isSMNeutrino
bool isSMNeutrino(const T &p)
Definition: AtlasPID.h:204
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
extractSporadic.q
list q
Definition: extractSporadic.py:98
xAOD::TruthParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TruthParticle_v1.cxx:166
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
MCTruthClassifier::m_pTChargePartCut
float m_pTChargePartCut
Definition: MCTruthClassifier.h:241
SingleMuon
@ SingleMuon
Definition: TruthClasses.h:55
CaloCell_ID_FCS::FCAL2
@ FCAL2
Definition: FastCaloSim_CaloCell_ID.h:42
MCTruthPartClassifier::defTypeOfTau
ParticleType defTypeOfTau(ParticleOrigin TauOrig)
Definition: TruthClassifiers.h:98
xAOD::JetConstituentVector
A vector of jet constituents at the scale used during jet finding.
Definition: JetConstituentVector.h:117
UnknownJet
@ UnknownJet
Definition: TruthClasses.h:48
OtherBSM
@ OtherBSM
Definition: TruthClasses.h:78
MCTruthClassifier::m_truthInConeTool
ToolHandle< xAOD::ITruthParticlesInConeTool > m_truthInConeTool
Definition: MCTruthClassifier.h:227
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
DalitzDec
@ DalitzDec
Definition: TruthClasses.h:60
top
@ top
Definition: TruthClasses.h:64
MCTruthPartClassifier::defOutComeOfPhoton
ParticleOutCome defOutComeOfPhoton(T thePart)
Definition: TruthClassifiers.h:268
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
CJet
@ CJet
Definition: TruthClasses.h:44
KaonDecay
@ KaonDecay
Definition: TruthClasses.h:91
xAOD::TruthParticle_v1::pdgId
int pdgId() const
PDG ID code.
MCTruthClassifier::defOrigOfTau
MCTruthPartClassifier::ParticleOrigin defOrigOfTau(const xAOD::TruthParticleContainer &xTruthParticleContainer, const xAOD::TruthParticle *, int motherPDG, MCTruthPartClassifier::Info &info) const
Definition: MCTruthClassifierGen.cxx:757
TauGNNUtils::Variables::Track::dEta
bool dEta(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:537
set_intersection
Set * set_intersection(Set *set1, Set *set2)
Perform an intersection of two sets.
MCTruthClassifier::particleTruthClassifier
virtual std::pair< MCTruthPartClassifier::ParticleType, MCTruthPartClassifier::ParticleOrigin > particleTruthClassifier(const xAOD::TruthParticle *, MCTruthPartClassifier::Info *info=nullptr) const override final
Definition: MCTruthClassifierGen.cxx:75
MCTruthClassifier::m_FwdElectronUseG4Sel
bool m_FwdElectronUseG4Sel
Definition: MCTruthClassifier.h:229
SG::DataProxy
Definition: DataProxy.h:45
ParticleType
ParticleType
Definition: TruthClasses.h:8
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
MCTruthClassifier::m_fwrdEledRtoTrCut
float m_fwrdEledRtoTrCut
Definition: MCTruthClassifier.h:238
MCTruthPartClassifier::Info
Definition: IMCTruthClassifier.h:49
Neutrino
Definition: Neutrino.h:33
xAOD::Photon_v1::vertex
const xAOD::Vertex * vertex(size_t index=0) const
Pointer to the xAOD::Vertex/es that match the photon candidate.
Definition: Photon_v1.cxx:46
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
xAOD::TruthVertex_v1::outgoingParticle
const TruthParticle_v1 * outgoingParticle(size_t index) const
Get one of the outgoing particles.
Definition: TruthVertex_v1.cxx:119
MCTruthClassifier::detEta
double detEta(double x, double y) const
Definition: MCTruthClassifier.h:169
MCTruthClassifier::m_ROICone
bool m_ROICone
Definition: MCTruthClassifier.h:239
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
xAOD::TruthParticle_v1::charge
double charge() const
Physical charge.
UnknownPhoton
@ UnknownPhoton
Definition: TruthClasses.h:22
isMSSMHiggs
bool isMSSMHiggs(const T &p)
APID: Additional Higgs bosons for MSSM (Used in MCTruthClassifier)
Definition: AtlasPID.h:367
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
fitman.k
k
Definition: fitman.py:528
BremPhot
@ BremPhot
Definition: TruthClasses.h:92
GenParticle
@ GenParticle
Definition: TruthClasses.h:30
MC::isHardScatteringVertex
bool isHardScatteringVertex(T pVert)
Function to classify the vertex as hard scattering vertex.
Definition: HepMCHelpers.h:178
MCTruthClassifier::m_phtdRtoTrCut
float m_phtdRtoTrCut
Definition: MCTruthClassifier.h:237
MCTruthClassifier::detPhi
double detPhi(double x, double y) const
Definition: MCTruthClassifier.h:170
isMuon
bool isMuon(const T &p)
Definition: AtlasPID.h:194
isLeptoQuark
bool isLeptoQuark(const T &p)
PDG rule 11c: “One-of-a-kind” exotic particles are assigned numbers in the range 41–80.
Definition: AtlasPID.h:381
MCTruthClassifier::getGenPart
virtual const xAOD::TruthParticle * getGenPart(const xAOD::TrackParticle *, MCTruthPartClassifier::Info *info=nullptr) const override final
Definition: MCRecoToTruth.cxx:181
Generated on Sun Apr 20 2025 21:40:06 for ATLAS Offline Software by   doxygen 1.8.18