ATLAS Offline Software
Public Types | Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
PanTau::Tool_DetailsArranger Class Reference

#include <Tool_DetailsArranger.h>

Inheritance diagram for PanTau::Tool_DetailsArranger:
Collaboration diagram for PanTau::Tool_DetailsArranger:

Public Types

enum  PanTauDetailsType { t_Int, t_Float, t_NTypes }
 

Public Member Functions

 Tool_DetailsArranger (const std::string &name)
 
virtual ~Tool_DetailsArranger ()
 
virtual StatusCode initialize ()
 Dummy implementation of the initialisation function. More...
 
virtual StatusCode execute (PanTau::PanTauSeed *inSeed, xAOD::ParticleContainer &pi0Container, xAOD::PFOContainer &neutralPFOContainer) const
 
bool isInitialized ()
 
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 addPanTauDetailToTauJet (PanTauSeed *inSeed, const std::string &featName, xAOD::TauJetParameters::PanTauDetails detailEnum, PanTauDetailsType detailType) const
 
StatusCode arrangePFOLinks (PanTau::PanTauSeed *inSeed, xAOD::TauJet *tauJet, xAOD::ParticleContainer &pi0Container, xAOD::PFOContainer &neutralPFOContainer) const
 
bool HasMultPi0sInOneCluster (const xAOD::PFO *pfo, int decayModeProto, const std::string &inputAlg) const
 
std::vector< ElementLink< xAOD::PFOContainer > > CollectConstituentsAsPFOLinks (PanTau::PanTauSeed *inSeed, const std::vector< ElementLink< xAOD::PFOContainer > > &cellbased_neutralPFOLinks, PanTau::TauConstituent::Type type) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Static Protected Member Functions

static void SetHLVTau (PanTau::PanTauSeed *inSeed, xAOD::TauJet *tauJet, const std::string &inputAlg, const std::string &varTypeName_Basic)
 
static void SetNeutralConstituentMass (xAOD::PFO *neutral_pfo, double mass)
 
static void SetNeutralConstituentVectorMasses (const std::vector< ElementLink< xAOD::PFOContainer > > &neutralPFOLinks, xAOD::PFOContainer &neutralPFOContainer, double mass)
 
static void createPi0Vectors (xAOD::TauJet *tauJet, std::vector< TLorentzVector > &vPi0s, std::vector< std::vector< ElementLink< xAOD::PFOContainer > > > &vec_pi0pfos)
 

Protected Attributes

ToolHandle< PanTau::ITool_InformationStorem_Tool_InformationStore
 
std::string m_Tool_InformationStoreName
 
double m_CoreCone = 0.0
 
std::vector< double > m_EtaBinEdges
 
std::vector< double > m_EtaBinnedEtCuts
 
std::string m_varTypeName_Sum
 
std::string m_varTypeName_Ratio
 
std::string m_varTypeName_EtInRing
 
std::string m_varTypeName_Isolation
 
std::string m_varTypeName_Num
 
std::string m_varTypeName_Mean
 
std::string m_varTypeName_StdDev
 
std::string m_varTypeName_HLV
 
std::string m_varTypeName_Angle
 
std::string m_varTypeName_DeltaR
 
std::string m_varTypeName_JetMoment
 
std::string m_varTypeName_Combined
 
std::string m_varTypeName_JetShape
 
std::string m_varTypeName_ImpactParams
 
std::string m_varTypeName_Basic
 
std::string m_varTypeName_PID
 
std::string m_varTypeName_Shots
 
bool m_init =false
 

Static Protected Attributes

static constexpr const float MASS_PI0 = 134.98
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

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

Tool for PID of Tau Seeds

Author
Sebastian Fleischmann
Christian Limbach limba.nosp@m.ch@p.nosp@m.hysik.nosp@m..uni.nosp@m.-bonn.nosp@m..de

Definition at line 37 of file Tool_DetailsArranger.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ PanTauDetailsType

Enumerator
t_Int 
t_Float 
t_NTypes 

Definition at line 43 of file Tool_DetailsArranger.h.

43  {
44  t_Int,
45  t_Float,
46  t_NTypes
47  };

Constructor & Destructor Documentation

◆ Tool_DetailsArranger()

PanTau::Tool_DetailsArranger::Tool_DetailsArranger ( const std::string &  name)

Definition at line 21 of file Tool_DetailsArranger.cxx.

21  :
23  m_Tool_InformationStore("PanTau::Tool_InformationStore/Tool_InformationStore")
24 {
25  declareProperty("Tool_InformationStore", m_Tool_InformationStore, "Tool handle to the information store tool");
26  declareProperty("Tool_InformationStoreName", m_Tool_InformationStoreName, "Tool handle to the information store tool");
27 }

◆ ~Tool_DetailsArranger()

PanTau::Tool_DetailsArranger::~Tool_DetailsArranger ( )
virtualdefault

Member Function Documentation

◆ addPanTauDetailToTauJet()

void PanTau::Tool_DetailsArranger::addPanTauDetailToTauJet ( PanTauSeed inSeed,
const std::string &  featName,
xAOD::TauJetParameters::PanTauDetails  detailEnum,
PanTauDetailsType  detailType 
) const
protected

Definition at line 124 of file Tool_DetailsArranger.cxx.

127  {
128 
129  bool isValid;
130  const PanTau::TauFeature* features = inSeed->getFeatures();
131  std::string fullFeatName = inSeed->getNameInputAlgorithm() + "_" + featName;
132 
133  double theValue = features->value(fullFeatName, isValid);
134  if (!isValid) {
135  bool noAnyConstituents = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoConstituentsAtAll);
136  bool noSelConstituents = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoSelectedConstituents);
137  bool noValidInputTau = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoValidInputTau);
138  bool isBadSeed = (noAnyConstituents || noSelConstituents || noValidInputTau);
139 
140  if (!isBadSeed) {
141  ATH_MSG_DEBUG("WARNING --- Problems getting value for feature " << fullFeatName << " from map! This should not happen for this seed!");
142  ATH_MSG_DEBUG("WARNING --- Did the ModeDiscriminator set features used in BDTs that were not found to their default values?");
143  ATH_MSG_DEBUG("NOTE --- This can also happen for seeds with (for example) 0 neutrals when trying to get Neutral_SumM - check seed");
144  }
145  theValue = -1111.;
146  }
147 
148  xAOD::TauJet* tauJet = inSeed->getTauJet();
149  int valueToAddInt = -1;
150  float valueToAddFloat = -1.1;
151 
152  switch(detailType) {
154  valueToAddInt = (int)theValue;
155  tauJet->setPanTauDetail(detailEnum, valueToAddInt);
156  break;
158  valueToAddFloat = (float)theValue;
159  tauJet->setPanTauDetail(detailEnum, valueToAddFloat);
160  break;
161  default:
162  ATH_MSG_WARNING("Unknown PanTauDetailType! Please use enum PanTauDetailsType from PanTauAlgs/Tool_DetailsArranger.h.");
163  ATH_MSG_WARNING("!NOT! adding detail named " << featName);
164  break;
165  }
166 
167  }

◆ arrangePFOLinks()

StatusCode PanTau::Tool_DetailsArranger::arrangePFOLinks ( PanTau::PanTauSeed inSeed,
xAOD::TauJet tauJet,
xAOD::ParticleContainer pi0Container,
xAOD::PFOContainer neutralPFOContainer 
) const
protected

Definition at line 170 of file Tool_DetailsArranger.cxx.

170  {
171 
172  std::string inputAlg = inSeed->getNameInputAlgorithm();
173 
174  //get the PFO links
175  std::vector< ElementLink< xAOD::PFOContainer > > chrgPFOLinks = tauJet->protoChargedPFOLinks();
176  std::vector< ElementLink< xAOD::PFOContainer > > neutralPFOLinks = tauJet->protoNeutralPFOLinks();
177  std::vector< ElementLink< xAOD::PFOContainer > > pi0PFOLinks = CollectConstituentsAsPFOLinks( inSeed, tauJet->protoNeutralPFOLinks(), PanTau::TauConstituent::t_Pi0Neut );
178  std::vector< ElementLink< xAOD::PFOContainer > > preSelected_neutralPFOLinks = CollectConstituentsAsPFOLinks( inSeed, tauJet->protoNeutralPFOLinks(), PanTau::TauConstituent::t_Neutral );
179 
180  //clear the default links, just to be safe
181  tauJet->clearChargedPFOLinks();
182  tauJet->clearNeutralPFOLinks();
183  tauJet->clearPi0PFOLinks();
184 
185  std::vector< ElementLink< xAOD::PFOContainer > > preLinkPi0PFOLinks = tauJet->pi0PFOLinks();
186 
187  // sort PFO links according to pi0 BDT score:
188  std::sort (pi0PFOLinks.begin(), pi0PFOLinks.end(), sortBDTscore);
189  std::sort (preSelected_neutralPFOLinks.begin(), preSelected_neutralPFOLinks.end(), sortBDTscore);
190  std::sort (neutralPFOLinks.begin(), neutralPFOLinks.end(), sortBDTscore);
191 
192  // set the masses of all neutrals *and pi0 neutrals* to 0:
193  SetNeutralConstituentVectorMasses(neutralPFOLinks, neutralPFOContainer, 0.);
194 
195  // arrange charged & neutral PFOs: they are not changed -> copy from cellbased
196  tauJet->setChargedPFOLinks(chrgPFOLinks);
197  tauJet->setNeutralPFOLinks(neutralPFOLinks);
198 
199  tauJet->setDetail(xAOD::TauJetParameters::nCharged, (int)chrgPFOLinks.size());
200 
201  //arrange pi0 pfos: depends on decay mode classification
202  int decayModeProto = inSeed->getDecayModeBySubAlg();
203  int decayModeFinal = inSeed->getDecayModeByPanTau();
204 
205  if(decayModeFinal == xAOD::TauJetParameters::Mode_Other) {
206  tauJet->setPi0PFOLinks(pi0PFOLinks);
207  SetHLVTau(inSeed, tauJet, inputAlg, m_varTypeName_Basic);
208 
209  return StatusCode::SUCCESS;
210  }
211 
212  //if pantau sets the same decay mode as the substructure algorithm, just copy the links
213  if(decayModeProto == decayModeFinal) {
214 
215  if( decayModeFinal == xAOD::TauJetParameters::Mode_3pXn && pi0PFOLinks.size() > 1 ){
216 
217  // assign all neutrals but only one pi0 neutral to Pantau:
218  preLinkPi0PFOLinks.push_back( pi0PFOLinks.at(0) );
219 
220  // set all masses correctly:
221  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
222 
223  } else {
224 
225  // assign the same constituents to Pantau:
226  preLinkPi0PFOLinks=pi0PFOLinks;
227 
228  // set all masses correctly:
229  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
230  }
231 
232  } else {
233 
234  if( decayModeFinal == xAOD::TauJetParameters::Mode_1p1n && decayModeProto == xAOD::TauJetParameters::Mode_1p0n ){
235 
236  // add the highest BDT-score neutral from the sub-alg:
237  if(!preSelected_neutralPFOLinks.empty()) preLinkPi0PFOLinks.push_back( preSelected_neutralPFOLinks.at(0) );
238  else ATH_MSG_WARNING("No neutral PFO Links although there should be!!");
239 
240  // set the mass:
241  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
242 
243  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_1p0n && decayModeProto == xAOD::TauJetParameters::Mode_1p1n ){
244 
245  // do nothing (leave the pi0 neutrals list empty)
246 
247  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_1pXn && decayModeProto == xAOD::TauJetParameters::Mode_1p1n ){
248 
249 
250  if( pi0PFOLinks.size() == 1 && HasMultPi0sInOneCluster(pi0PFOLinks.at(0).cachedElement(), decayModeProto, inputAlg) ){
251 
252  // assign twice the pi0 mass to the one pi0 PFO:
253  SetNeutralConstituentVectorMasses(pi0PFOLinks, neutralPFOContainer, 2*MASS_PI0);
254 
255  // assign the same constituents to Pantau:
256  preLinkPi0PFOLinks=pi0PFOLinks;
257 
258  } else {
259 
260  // copy all (really only one) pi0s from the sub-alg and add
261  // the highest BDT-score neutral:
262  preLinkPi0PFOLinks=pi0PFOLinks;
263  if(!preSelected_neutralPFOLinks.empty()) preLinkPi0PFOLinks.push_back( preSelected_neutralPFOLinks.at(0) );
264  else ATH_MSG_WARNING("No neutral PFO Links although there should be!!");
265 
266  // set the mass:
267  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
268  }
269 
270  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_1p1n && decayModeProto == xAOD::TauJetParameters::Mode_1pXn ){
271 
272  // copy all (two) pi0s from the sub-alg:
273  preLinkPi0PFOLinks.push_back( pi0PFOLinks.at(0) );
274  preLinkPi0PFOLinks.push_back( pi0PFOLinks.at(1) );
275 
276  // set both pi0neutrals to mass 0 (photon mass):
277  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, 0.);
278 
279  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_3pXn && decayModeProto == xAOD::TauJetParameters::Mode_3p0n ){
280 
281  // add the highest BDT-score neutral from the sub-alg:
282  if(!preSelected_neutralPFOLinks.empty()) preLinkPi0PFOLinks.push_back( preSelected_neutralPFOLinks.at(0) );
283  else ATH_MSG_WARNING("No neutral PFO Links although there should be!!");
284 
285  // set the mass:
286  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
287 
288  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_3p0n && decayModeProto == xAOD::TauJetParameters::Mode_3pXn ){
289 
290  // do nothing (leave the pi0 neutrals list empty)
291  }
292  }
293 
294  tauJet->setPi0PFOLinks(preLinkPi0PFOLinks);
295 
296  SetHLVTau(inSeed, tauJet, inputAlg, m_varTypeName_Basic);
297 
298  std::vector< ElementLink< xAOD::PFOContainer > > finalChrgPFOLinks = tauJet->chargedPFOLinks();
299  std::vector< ElementLink< xAOD::PFOContainer > > finalPi0PFOLinks = tauJet->pi0PFOLinks();
300  std::vector< ElementLink< xAOD::PFOContainer > > finalNeutralPFOLinks = tauJet->neutralPFOLinks();
301 
302  // vector of 4-vectors of actual pi0s and a vector with pointers to PFOs:
303  std::vector< TLorentzVector > vec_pi04vec;
304  std::vector< std::vector< ElementLink<xAOD::PFOContainer> > > vec_pi0pfos;
305  createPi0Vectors(tauJet, vec_pi04vec, vec_pi0pfos);
306 
307  for(unsigned int itlv=0; itlv!=vec_pi04vec.size(); ++itlv) {
309  pi0Container.push_back(p);
310  p->setPxPyPzE(vec_pi04vec.at(itlv).Px(), vec_pi04vec.at(itlv).Py(), vec_pi04vec.at(itlv).Pz(), vec_pi04vec.at(itlv).E());
311  std::vector< ElementLink< xAOD::PFOContainer > > pfo_link_vector;
312  for( uint ipfo = 0; ipfo != vec_pi0pfos.at(itlv).size(); ++ipfo) {
313  pfo_link_vector.push_back(vec_pi0pfos.at(itlv).at(ipfo));
314  }
315 
316  static const SG::Accessor<std::vector< ElementLink< xAOD::PFOContainer > > > accPi0PFOLinks("pi0PFOLinks");
317  accPi0PFOLinks(*p) = pfo_link_vector;
318 
320  linkToPi0.toContainedElement(pi0Container, dynamic_cast<xAOD::IParticle*> (p));
321 
322  tauJet->addPi0Link(linkToPi0);
323  }
324 
325  return StatusCode::SUCCESS;
326 }

◆ CollectConstituentsAsPFOLinks()

std::vector< ElementLink< xAOD::PFOContainer > > PanTau::Tool_DetailsArranger::CollectConstituentsAsPFOLinks ( PanTau::PanTauSeed inSeed,
const std::vector< ElementLink< xAOD::PFOContainer > > &  cellbased_neutralPFOLinks,
PanTau::TauConstituent::Type  type 
) const
protected

Definition at line 398 of file Tool_DetailsArranger.cxx.

400  {
401  // collect element links from tau constituents in the Pantau
402  // seed of type "type". cellbased_neutralPFOLinks is only used
403  // to obtain the ElementLinks.
404 
405  std::vector< ElementLink< xAOD::PFOContainer > > new_links;
406 
407  unsigned int nConstsOfType=0;
408  bool foundIt=false;
409  std::vector<PanTau::TauConstituent*> tauConstituents=inSeed->getConstituentsOfType(type,foundIt);
410 
412  ATH_MSG_WARNING("CollectConstituentsAsPFOLinks: Function was called with type = " << type << " , however it was only designed for types t_Pi0Neut and t_Neutral! Returning...");
413  return new_links;
414  }
415 
416  for(unsigned int iConst=0; iConst<tauConstituents.size(); iConst++) {
417  bool isOfType = tauConstituents[iConst]->isOfType(type);
418  if(!isOfType) continue;
419 
420  // if the requested type is t_Neutral then exclude any t_Pi0Neut
421  // from the list (note: tau constituents that are t_Pi0Neut are
422  // also t_Neutral at the same time):
423  if(type==PanTau::TauConstituent::t_Neutral && tauConstituents[iConst]->isOfType(PanTau::TauConstituent::t_Pi0Neut) ) continue;
424  ++nConstsOfType;
425 
426  for(unsigned int iPFO=0; iPFO<cellbased_neutralPFOLinks.size(); iPFO++) {
427  const xAOD::PFO* pfo = cellbased_neutralPFOLinks.at(iPFO).cachedElement();
428 
429  if( tauConstituents[iConst]->getPFO() != pfo ) continue;
430 
431  new_links.push_back( cellbased_neutralPFOLinks.at(iPFO) );
432  }
433  }
434 
435  if( nConstsOfType != new_links.size() ){
436  ATH_MSG_WARNING("CollectConstituentsAsPFOLinks: Couldn't find PFOLinks " << new_links.size() << " for all tau constituents (" << tauConstituents.size() << ")!");
437  }
438 
439  return new_links;
440 }

◆ createPi0Vectors()

void PanTau::Tool_DetailsArranger::createPi0Vectors ( xAOD::TauJet tauJet,
std::vector< TLorentzVector > &  vPi0s,
std::vector< std::vector< ElementLink< xAOD::PFOContainer > > > &  vec_pi0pfos 
)
staticprotected

Definition at line 444 of file Tool_DetailsArranger.cxx.

445 {
446  // reset the pi0s
447  vPi0s.clear();
448  vec_pi0pfos.clear();
449 
450  // Since the PFO links as they come out of reconstruction, only correspond to
451  // calorimeter clusters, whereas we want the consts_pi0 vectors to correspond
452  // to real pi0s, we need to be careful to collect the PFOs correctly to pi0s
453  // for the cases where number of pi0s does not match to the decay mode:
454  size_t iNumPi0PFO = tauJet->nPi0PFOs();
455 
456  int iDecayMode = -1;
458 
459  if (iDecayMode == xAOD::TauJetParameters::Mode_1p1n && iNumPi0PFO > 1) {
460 
461  // TODO: find out if the pi0 mass is defined elsewhere in atlas code!
462  // float fMassPi0 = 134.98;
463  float fMassPi0Squared = MASS_PI0*MASS_PI0;
464 
465  // combine both photons (with 0 mass that is already set) to one pi0 vector:
466  const xAOD::PFO* xPfo1 = tauJet->pi0PFO(0);
467  const xAOD::PFO* xPfo2 = tauJet->pi0PFO(1);
468  vPi0s.push_back(xPfo1->p4() + xPfo2->p4());
469 
470  // re-set the mass to one pi0:
471  double dNewMomentum = std::sqrt(vPi0s[0].E() * vPi0s[0].E() - fMassPi0Squared);
472  vPi0s[0].SetPxPyPzE(vPi0s[0].Vect().Unit().Px() * dNewMomentum,
473  vPi0s[0].Vect().Unit().Py() * dNewMomentum,
474  vPi0s[0].Vect().Unit().Pz() * dNewMomentum,
475  vPi0s[0].E());
476 
477  std::vector< ElementLink<xAOD::PFOContainer> > pfovec;
478  pfovec.push_back(tauJet->pi0PFOLinks()[0]);
479  pfovec.push_back(tauJet->pi0PFOLinks()[1]);
480  vec_pi0pfos.push_back( pfovec );
481 
482  } else if (iDecayMode == xAOD::TauJetParameters::DecayMode::Mode_1pXn && iNumPi0PFO == 1){
483 
484  // make a single pi0 from a PFO that contains two pi0s:
485  const xAOD::PFO* xPfo = tauJet->pi0PFO(0);
486  // add the 2-pi0 vector preliminarily to the pi0vector:
487  vPi0s.push_back(xPfo->p4());
488 
489  // re-set the mass back to one pi0:
490  double dNewMomentum = std::sqrt( (vPi0s[0].E()/2.)*(vPi0s[0].E()/2.) - MASS_PI0*MASS_PI0 );
491  vPi0s[0].SetVectM(vPi0s[0].Vect().Unit() * dNewMomentum, MASS_PI0 );
492 
493  // create another pi0 from the same vector:
494  vPi0s.push_back(vPi0s[0]);
495 
496  std::vector< ElementLink<xAOD::PFOContainer> > pfovec;
497  pfovec.push_back(tauJet->pi0PFOLinks()[0]);
498  vec_pi0pfos.push_back( pfovec );
499  vec_pi0pfos.push_back( pfovec );//fix rare crash?
500 
501  } else {
502  // if it's not any of the special cases above then just collect the PFOs:
503  for (size_t iPFO = 0; iPFO < iNumPi0PFO; iPFO++){
504  vPi0s.push_back(tauJet->pi0PFO(iPFO)->p4());
505  std::vector< ElementLink<xAOD::PFOContainer> > pfovec;
506  pfovec.push_back(tauJet->pi0PFOLinks()[iPFO]);
507  vec_pi0pfos.push_back( pfovec );
508  }
509  }
510 
511 }

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

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

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

◆ execute()

StatusCode PanTau::Tool_DetailsArranger::execute ( PanTau::PanTauSeed inSeed,
xAOD::ParticleContainer pi0Container,
xAOD::PFOContainer neutralPFOContainer 
) const
virtual

Implements PanTau::ITool_DetailsArranger.

Definition at line 64 of file Tool_DetailsArranger.cxx.

64  {
65 
66  std::string inputAlg = inSeed->getNameInputAlgorithm();
67 
68  bool noAnyConstituents = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoConstituentsAtAll);
70  bool noValidInputTau = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoValidInputTau);
71  bool isBadSeed = (noAnyConstituents || noSelConstituents || noValidInputTau);
72 
73  //set the PFO link vector and pantau 4-vector to default values for every tau first (xAOD technicality)
74  //if the tau is valid, overwrite with non-default values
75  xAOD::TauJet* tauJet = inSeed->getTauJet();
76 
77  if (isBadSeed) {
78  ATH_MSG_DEBUG("This seed is not useable for detail arranging (other than validity flag)");
81  return StatusCode::SUCCESS;
82  }
83 
84  ATH_CHECK(arrangePFOLinks(inSeed, tauJet, pi0Container, neutralPFOContainer));
85 
86  //Basic variables
92 
93  //Final 4-vector
94  tauJet->setP4(xAOD::TauJetParameters::PanTauCellBased, inSeed->getFinalMomentum().Pt(), inSeed->getFinalMomentum().Eta(), inSeed->getFinalMomentum().Phi(), inSeed->getFinalMomentum().M());
95 
96  //BDT variables
97  addPanTauDetailToTauJet(inSeed, "Basic_NNeutralConsts",
99  addPanTauDetailToTauJet(inSeed, "Charged_JetMoment_EtDRxTotalEt",
101  addPanTauDetailToTauJet(inSeed, "Charged_StdDev_Et_WrtEtAllConsts",
103  addPanTauDetailToTauJet(inSeed, "Neutral_HLV_SumM",
105  addPanTauDetailToTauJet(inSeed, "Neutral_PID_BDTValues_BDTSort_1",
107  addPanTauDetailToTauJet(inSeed, "Neutral_PID_BDTValues_BDTSort_2",
109  addPanTauDetailToTauJet(inSeed, "Neutral_Ratio_1stBDTEtOverEtAllConsts",
111  addPanTauDetailToTauJet(inSeed, "Neutral_Ratio_EtOverEtAllConsts",
113  addPanTauDetailToTauJet(inSeed, "Neutral_Shots_NPhotonsInSeed",
115  addPanTauDetailToTauJet(inSeed, "Combined_DeltaR1stNeutralTo1stCharged",
117  addPanTauDetailToTauJet(inSeed, "Charged_HLV_SumM",
119 
120  return StatusCode::SUCCESS;
121 }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ getKey()

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

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

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

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

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

◆ HasMultPi0sInOneCluster()

bool PanTau::Tool_DetailsArranger::HasMultPi0sInOneCluster ( const xAOD::PFO pfo,
int  decayModeProto,
const std::string &  inputAlg 
) const
protected

Definition at line 358 of file Tool_DetailsArranger.cxx.

358  {
359 
360  // this is only relevant for reco 1p1n modes, hence restrict the output to these modes
361 
362  int nPi0sPerCluster = 1;
363 
364  if (inputAlg != "CellBased" ) return (nPi0sPerCluster > 1);
365 
366  // cell-based sets this to 1pXn however below this function is
367  // called with the decayModeProto as evaluated by Pantau!
368  if (decayModeProto != xAOD::TauJetParameters::Mode_1p1n ) return (nPi0sPerCluster > 1);
369 
370  if( !pfo->attribute(xAOD::PFODetails::nPi0Proto, nPi0sPerCluster) ) {
371  ATH_MSG_WARNING("Could not retrieve nPi0Proto. Will set it to 1.");
372  nPi0sPerCluster = 1;
373  }
374 
375  return (nPi0sPerCluster > 1);
376 }

◆ initialize()

StatusCode PanTau::Tool_DetailsArranger::initialize ( )
virtual

Dummy implementation of the initialisation function.

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

Reimplemented from asg::AsgTool.

Definition at line 33 of file Tool_DetailsArranger.cxx.

33  {
34 
35  m_init=true;
36 
38 
39  ATH_CHECK( m_Tool_InformationStore->getInfo_Double("TauConstituents_Types_DeltaRCore", m_CoreCone) );
40  ATH_CHECK( m_Tool_InformationStore->getInfo_VecDouble("TauConstituents_BinEdges_Eta", m_EtaBinEdges) );
41  ATH_CHECK( m_Tool_InformationStore->getInfo_VecDouble("TauConstituents_Selection_Neutral_EtaBinned_EtCut", m_EtaBinnedEtCuts) );
42  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Sum", m_varTypeName_Sum) );
43  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Ratio", m_varTypeName_Ratio) );
44  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_EtInRing", m_varTypeName_EtInRing) );
45  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Isolation", m_varTypeName_Isolation) );
46  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Num", m_varTypeName_Num) );
47  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Mean", m_varTypeName_Mean) );
48  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_StdDev", m_varTypeName_StdDev) );
49  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_HLV", m_varTypeName_HLV) );
50  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Angle", m_varTypeName_Angle) );
51  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_DeltaR", m_varTypeName_DeltaR) );
52  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_JetMoment", m_varTypeName_JetMoment) );
53  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Combined", m_varTypeName_Combined) );
54  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_JetShape", m_varTypeName_JetShape) );
55  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_ImpactParams", m_varTypeName_ImpactParams) );
56  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Basic", m_varTypeName_Basic) );
57  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_PID", m_varTypeName_PID) );
58  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Shots", m_varTypeName_Shots) );
59 
60  return StatusCode::SUCCESS;
61 }

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

◆ isInitialized()

bool PanTau::Tool_DetailsArranger::isInitialized ( )
inlinevirtual

Implements PanTau::ITool_DetailsArranger.

Definition at line 108 of file Tool_DetailsArranger.h.

108 {return m_init;}

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

◆ print()

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

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

◆ SetHLVTau()

void PanTau::Tool_DetailsArranger::SetHLVTau ( PanTau::PanTauSeed inSeed,
xAOD::TauJet tauJet,
const std::string &  inputAlg,
const std::string &  varTypeName_Basic 
)
staticprotected

Definition at line 330 of file Tool_DetailsArranger.cxx.

330  {
331 
332  std::vector< ElementLink< xAOD::PFOContainer > > finalChrgPFOLinks = tauJet->chargedPFOLinks();
333  std::vector< ElementLink< xAOD::PFOContainer > > finalPi0PFOLinks = tauJet->pi0PFOLinks();
334 
335  unsigned int NCharged = finalChrgPFOLinks.size();
336  unsigned int NPi0Neut = finalPi0PFOLinks.size();
337 
338  TLorentzVector tlv_PanTau_Final;
339  for(unsigned int iPFO=0; iPFO<NCharged; iPFO++) {
340  const xAOD::PFO* pfo = finalChrgPFOLinks.at(iPFO).cachedElement();
341  tlv_PanTau_Final += pfo->p4();
342  }
343  for(unsigned int iPFO=0; iPFO<NPi0Neut; iPFO++) {
344  const xAOD::PFO* pfo = finalPi0PFOLinks.at(iPFO).cachedElement();
345  tlv_PanTau_Final += pfo->p4();
346  }
347 
348  inSeed->setFinalMomentum(tlv_PanTau_Final);
349 
350  PanTau::TauFeature* featureMap = inSeed->getFeatures();
351  featureMap->addFeature(inputAlg + "_" + varTypeName_Basic + "_FinalMomentumCore_pt", tlv_PanTau_Final.Pt() );
352  featureMap->addFeature(inputAlg + "_" + varTypeName_Basic + "_FinalMomentumCore_eta", tlv_PanTau_Final.Eta() );
353  featureMap->addFeature(inputAlg + "_" + varTypeName_Basic + "_FinalMomentumCore_phi", tlv_PanTau_Final.Phi() );
354  featureMap->addFeature(inputAlg + "_" + varTypeName_Basic + "_FinalMomentumCore_m", tlv_PanTau_Final.M() );
355 }

◆ SetNeutralConstituentMass()

void PanTau::Tool_DetailsArranger::SetNeutralConstituentMass ( xAOD::PFO neutral_pfo,
double  mass 
)
staticprotected

Definition at line 379 of file Tool_DetailsArranger.cxx.

379  {
380 
381  TLorentzVector momentum;
382  PanTau::SetP4EEtaPhiM( momentum, neutral_pfo->e(), neutral_pfo->eta(), neutral_pfo->phi(), mass);
383  neutral_pfo->setP4(momentum.Pt(), neutral_pfo->eta(), neutral_pfo->phi(), mass);
384 }

◆ SetNeutralConstituentVectorMasses()

void PanTau::Tool_DetailsArranger::SetNeutralConstituentVectorMasses ( const std::vector< ElementLink< xAOD::PFOContainer > > &  neutralPFOLinks,
xAOD::PFOContainer neutralPFOContainer,
double  mass 
)
staticprotected

Definition at line 387 of file Tool_DetailsArranger.cxx.

387  {
388 
389  for (const auto& link : neutralPFOLinks) {
390  size_t index = link.index();
391  xAOD::PFO* curNeutralPFO = neutralPFOContainer.at(index);
392  SetNeutralConstituentMass(curNeutralPFO, mass);
393  }
394 
395  }

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

double PanTau::Tool_DetailsArranger::m_CoreCone = 0.0
protected

Definition at line 84 of file Tool_DetailsArranger.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_EtaBinEdges

std::vector<double> PanTau::Tool_DetailsArranger::m_EtaBinEdges
protected

Definition at line 85 of file Tool_DetailsArranger.h.

◆ m_EtaBinnedEtCuts

std::vector<double> PanTau::Tool_DetailsArranger::m_EtaBinnedEtCuts
protected

Definition at line 86 of file Tool_DetailsArranger.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_init

bool PanTau::Tool_DetailsArranger::m_init =false
protected

Definition at line 106 of file Tool_DetailsArranger.h.

◆ m_Tool_InformationStore

ToolHandle<PanTau::ITool_InformationStore> PanTau::Tool_DetailsArranger::m_Tool_InformationStore
protected

Definition at line 58 of file Tool_DetailsArranger.h.

◆ m_Tool_InformationStoreName

std::string PanTau::Tool_DetailsArranger::m_Tool_InformationStoreName
protected

Definition at line 59 of file Tool_DetailsArranger.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_varTypeName_Angle

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Angle
protected

Definition at line 96 of file Tool_DetailsArranger.h.

◆ m_varTypeName_Basic

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Basic
protected

Definition at line 102 of file Tool_DetailsArranger.h.

◆ m_varTypeName_Combined

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Combined
protected

Definition at line 99 of file Tool_DetailsArranger.h.

◆ m_varTypeName_DeltaR

std::string PanTau::Tool_DetailsArranger::m_varTypeName_DeltaR
protected

Definition at line 97 of file Tool_DetailsArranger.h.

◆ m_varTypeName_EtInRing

std::string PanTau::Tool_DetailsArranger::m_varTypeName_EtInRing
protected

Definition at line 90 of file Tool_DetailsArranger.h.

◆ m_varTypeName_HLV

std::string PanTau::Tool_DetailsArranger::m_varTypeName_HLV
protected

Definition at line 95 of file Tool_DetailsArranger.h.

◆ m_varTypeName_ImpactParams

std::string PanTau::Tool_DetailsArranger::m_varTypeName_ImpactParams
protected

Definition at line 101 of file Tool_DetailsArranger.h.

◆ m_varTypeName_Isolation

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Isolation
protected

Definition at line 91 of file Tool_DetailsArranger.h.

◆ m_varTypeName_JetMoment

std::string PanTau::Tool_DetailsArranger::m_varTypeName_JetMoment
protected

Definition at line 98 of file Tool_DetailsArranger.h.

◆ m_varTypeName_JetShape

std::string PanTau::Tool_DetailsArranger::m_varTypeName_JetShape
protected

Definition at line 100 of file Tool_DetailsArranger.h.

◆ m_varTypeName_Mean

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Mean
protected

Definition at line 93 of file Tool_DetailsArranger.h.

◆ m_varTypeName_Num

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Num
protected

Definition at line 92 of file Tool_DetailsArranger.h.

◆ m_varTypeName_PID

std::string PanTau::Tool_DetailsArranger::m_varTypeName_PID
protected

Definition at line 103 of file Tool_DetailsArranger.h.

◆ m_varTypeName_Ratio

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Ratio
protected

Definition at line 89 of file Tool_DetailsArranger.h.

◆ m_varTypeName_Shots

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Shots
protected

Definition at line 104 of file Tool_DetailsArranger.h.

◆ m_varTypeName_StdDev

std::string PanTau::Tool_DetailsArranger::m_varTypeName_StdDev
protected

Definition at line 94 of file Tool_DetailsArranger.h.

◆ m_varTypeName_Sum

std::string PanTau::Tool_DetailsArranger::m_varTypeName_Sum
protected

Definition at line 88 of file Tool_DetailsArranger.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ MASS_PI0

constexpr const float PanTau::Tool_DetailsArranger::MASS_PI0 = 134.98
staticconstexprprotected

Definition at line 82 of file Tool_DetailsArranger.h.


The documentation for this class was generated from the following files:
PanTau::Tool_DetailsArranger::SetNeutralConstituentMass
static void SetNeutralConstituentMass(xAOD::PFO *neutral_pfo, double mass)
Definition: Tool_DetailsArranger.cxx:379
xAOD::TauJetParameters::Mode_1p0n
@ Mode_1p0n
Definition: TauDefs.h:386
xAOD::TauJetParameters::PanTau_DecayMode
@ PanTau_DecayMode
Definition: TauDefs.h:360
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_Ratio_1stBDTEtOverEtAllConsts
@ PanTau_BDTVar_Neutral_Ratio_1stBDTEtOverEtAllConsts
Definition: TauDefs.h:372
PanTau::Tool_DetailsArranger::SetHLVTau
static void SetHLVTau(PanTau::PanTauSeed *inSeed, xAOD::TauJet *tauJet, const std::string &inputAlg, const std::string &varTypeName_Basic)
Definition: Tool_DetailsArranger.cxx:330
PanTau::Tool_DetailsArranger::m_varTypeName_Mean
std::string m_varTypeName_Mean
Definition: Tool_DetailsArranger.h:93
PanTau::Tool_DetailsArranger::t_Int
@ t_Int
Definition: Tool_DetailsArranger.h:44
xAOD::TauJetParameters::PanTau_BDTVar_Combined_DeltaR1stNeutralTo1stCharged
@ PanTau_BDTVar_Combined_DeltaR1stNeutralTo1stCharged
Definition: TauDefs.h:375
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
PanTau::TauConstituent::t_Neutral
@ t_Neutral
Definition: TauConstituent.h:45
xAOD::TauJetParameters::Mode_1p1n
@ Mode_1p1n
Definition: TauDefs.h:387
PanTau::PanTauSeed::getFeatures
const PanTau::TauFeature * getFeatures() const
Definition: PanTauSeed.h:230
PanTau::Tool_DetailsArranger::m_varTypeName_EtInRing
std::string m_varTypeName_EtInRing
Definition: Tool_DetailsArranger.h:90
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
PanTau::PanTauSeed::getTauJet
const xAOD::TauJet * getTauJet() const
Definition: PanTauSeed.h:228
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
PanTau::PanTauSeed::getDecayModeBySubAlg
int getDecayModeBySubAlg() const
Definition: PanTauSeed.h:239
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
xAOD::TauJetParameters::nCharged
@ nCharged
Definition: TauDefs.h:266
PanTau::PanTauSeed::getDecayModeByPanTau
int getDecayModeByPanTau() const
Definition: PanTauSeed.h:240
PanTau::Tool_DetailsArranger::m_varTypeName_DeltaR
std::string m_varTypeName_DeltaR
Definition: Tool_DetailsArranger.h:97
index
Definition: index.py:1
PanTau::Tool_DetailsArranger::m_varTypeName_JetShape
std::string m_varTypeName_JetShape
Definition: Tool_DetailsArranger.h:100
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
PanTau::PanTauSeed::getNameInputAlgorithm
std::string getNameInputAlgorithm() const
Definition: PanTauSeed.h:227
PanTau::Tool_DetailsArranger::m_CoreCone
double m_CoreCone
Definition: Tool_DetailsArranger.h:84
PanTau::Tool_DetailsArranger::m_init
bool m_init
Definition: Tool_DetailsArranger.h:106
PanTau::PanTauSeed::getConstituentsOfType
std::vector< PanTau::TauConstituent * > getConstituentsOfType(int tauConstituent_Type, bool &foundit)
Definition: PanTauSeed.cxx:358
xAOD::TauJet_v3::setPanTauDetail
void setPanTauDetail(TauJetParameters::PanTauDetails panTauDetail, int value)
Definition: TauJet_v3.cxx:395
PanTau::Tool_DetailsArranger::m_varTypeName_Ratio
std::string m_varTypeName_Ratio
Definition: Tool_DetailsArranger.h:89
xAOD::TauJetParameters::PanTau_BDTValue_3p0n_vs_3pXn
@ PanTau_BDTValue_3p0n_vs_3pXn
Definition: TauDefs.h:364
xAOD::PFO_v1::attribute
bool attribute(PFODetails::PFOAttributes AttributeType, T &anAttribute) const
get a PFO Variable via enum
xAOD::PFO_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: PFO_v1.cxx:60
PanTau::PanTauSeed::t_NoValidInputTau
@ t_NoValidInputTau
Definition: PanTauSeed.h:34
xAOD::TauJet_v3::clearNeutralPFOLinks
void clearNeutralPFOLinks()
Remove all neutral PFOs from the tau.
Definition: TauJet_v3.cxx:859
PanTau::TauFeature::addFeature
bool addFeature(const std::string &name, const double value)
adds a new feature
Definition: TauFeature.cxx:44
PanTau::PanTauSeed::getFinalMomentum
TLorentzVector getFinalMomentum() const
Definition: PanTauSeed.h:238
xAOD::TauJet_v3::setNeutralPFOLinks
void setNeutralPFOLinks(const PFOLinks_t &neutralPFOs)
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::TauJet_v3::clearPi0PFOLinks
void clearPi0PFOLinks()
Remove all pi0 PFOs from the tau.
Definition: TauJet_v3.cxx:890
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
PanTau::Tool_DetailsArranger::addPanTauDetailToTauJet
void addPanTauDetailToTauJet(PanTauSeed *inSeed, const std::string &featName, xAOD::TauJetParameters::PanTauDetails detailEnum, PanTauDetailsType detailType) const
Definition: Tool_DetailsArranger.cxx:124
PanTau::Tool_DetailsArranger::m_varTypeName_Angle
std::string m_varTypeName_Angle
Definition: Tool_DetailsArranger.h:96
xAOD::TauJet_v3::panTauDetail
bool panTauDetail(TauJetParameters::PanTauDetails panTauDetail, int &value) const
Get and set values of pantau details variables via enum.
Definition: TauJet_v3.cxx:367
PanTau::TauFeature
Definition: TauFeature.h:19
sortBDTscore
bool sortBDTscore(const ElementLink< xAOD::PFOContainer > &i, const ElementLink< xAOD::PFOContainer > &j)
Definition: Tool_DetailsArranger.cxx:15
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:620
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
PanTau::Tool_DetailsArranger::m_varTypeName_Isolation
std::string m_varTypeName_Isolation
Definition: Tool_DetailsArranger.h:91
PanTau::Tool_DetailsArranger::HasMultPi0sInOneCluster
bool HasMultPi0sInOneCluster(const xAOD::PFO *pfo, int decayModeProto, const std::string &inputAlg) const
Definition: Tool_DetailsArranger.cxx:358
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
PanTau::Tool_DetailsArranger::m_Tool_InformationStore
ToolHandle< PanTau::ITool_InformationStore > m_Tool_InformationStore
Definition: Tool_DetailsArranger.h:58
xAOD::TauJet_v3::nPi0PFOs
size_t nPi0PFOs() const
Get the number of pi0 PFO particles associated with this tau.
Definition: TauJet_v3.cxx:880
PanTau::Tool_DetailsArranger::m_varTypeName_ImpactParams
std::string m_varTypeName_ImpactParams
Definition: Tool_DetailsArranger.h:101
xAOD::TauJet_v3::setP4
void setP4(double pt, double eta, double phi, double m)
Set methods for IParticle values.
Definition: TauJet_v3.cxx:172
xAOD::Particle
Particle_v1 Particle
Define the latest version of the particle class.
Definition: Event/xAOD/xAODParticleEvent/xAODParticleEvent/Particle.h:17
PanTau::Tool_DetailsArranger::m_varTypeName_Sum
std::string m_varTypeName_Sum
Definition: Tool_DetailsArranger.h:88
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_HLV_SumM
@ PanTau_BDTVar_Neutral_HLV_SumM
Definition: TauDefs.h:369
PanTau::Tool_DetailsArranger::m_varTypeName_Num
std::string m_varTypeName_Num
Definition: Tool_DetailsArranger.h:92
PanTau::Tool_DetailsArranger::m_varTypeName_HLV
std::string m_varTypeName_HLV
Definition: Tool_DetailsArranger.h:95
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
xAOD::TauJetParameters::Mode_1pXn
@ Mode_1pXn
Definition: TauDefs.h:388
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
xAOD::TauJet_v3::pi0PFO
const PFO * pi0PFO(size_t i) const
Get the pointer to a given pi0 PFO associated with this tau.
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
xAOD::PFO_v1::e
virtual double e() const
The total energy of the particle.
Definition: PFO_v1.cxx:81
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
PanTau::PanTauSeed::setFinalMomentum
void setFinalMomentum(TLorentzVector finalMom)
Definition: PanTauSeed.h:244
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
PanTau::Tool_DetailsArranger::CollectConstituentsAsPFOLinks
std::vector< ElementLink< xAOD::PFOContainer > > CollectConstituentsAsPFOLinks(PanTau::PanTauSeed *inSeed, const std::vector< ElementLink< xAOD::PFOContainer > > &cellbased_neutralPFOLinks, PanTau::TauConstituent::Type type) const
Definition: Tool_DetailsArranger.cxx:398
xAOD::TauJetParameters::PanTau_BDTValue_1p1n_vs_1pXn
@ PanTau_BDTValue_1p1n_vs_1pXn
Definition: TauDefs.h:363
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
xAOD::TauJet_v3::protoNeutralPFOLinks
const PFOLinks_t & protoNeutralPFOLinks() const
PanTau::Tool_DetailsArranger::arrangePFOLinks
StatusCode arrangePFOLinks(PanTau::PanTauSeed *inSeed, xAOD::TauJet *tauJet, xAOD::ParticleContainer &pi0Container, xAOD::PFOContainer &neutralPFOContainer) const
Definition: Tool_DetailsArranger.cxx:170
xAOD::TauJet_v3::neutralPFOLinks
const PFOLinks_t & neutralPFOLinks() const
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
PanTau::TauFeature::value
double value(const std::string &name, bool &isValid) const
returns the value of the feature given by its name
Definition: TauFeature.cxx:23
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
xAOD::PFO_v1::p4
virtual FourMom_t p4() const
The full 4-momentum of the particle.
Definition: PFO_v1.cxx:95
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
xAOD::PFO_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: PFO_v1.cxx:67
xAOD::TauJetParameters::PanTau_BDTValue_1p0n_vs_1p1n
@ PanTau_BDTValue_1p0n_vs_1p1n
Definition: TauDefs.h:362
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::TauJetParameters::PanTauCellBased
@ PanTauCellBased
Definition: TauDefs.h:344
xAOD::TauJet_v3::addPi0Link
void addPi0Link(const ElementLink< IParticleContainer > &tr)
add a pi0 link to the tau
Definition: TauJet_v3.cxx:649
xAOD::Particle_v1
Description of a generic particle.
Definition: Particle_v1.h:31
xAOD::TauJetParameters::Mode_3p0n
@ Mode_3p0n
Definition: TauDefs.h:389
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
PanTau::Tool_DetailsArranger::t_NTypes
@ t_NTypes
Definition: Tool_DetailsArranger.h:46
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
xAOD::PFO_v1
Class describing a particle flow object.
Definition: PFO_v1.h:35
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
PanTau::HelperFunctions::bindToolHandle
static StatusCode bindToolHandle(ToolHandle< T > &, std::string)
Definition: Reconstruction/PanTau/PanTauAlgs/PanTauAlgs/HelperFunctions.h:60
PanTau::Tool_DetailsArranger::m_varTypeName_JetMoment
std::string m_varTypeName_JetMoment
Definition: Tool_DetailsArranger.h:98
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_2
@ PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_2
Definition: TauDefs.h:371
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
PanTau::PanTauSeed::t_NoConstituentsAtAll
@ t_NoConstituentsAtAll
Definition: PanTauSeed.h:35
xAOD::TauJet_v3::pi0PFOLinks
const PFOLinks_t & pi0PFOLinks() const
xAOD::PFODetails::nPi0Proto
@ nPi0Proto
Definition: Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h:31
PanTau::Tool_DetailsArranger::m_varTypeName_Basic
std::string m_varTypeName_Basic
Definition: Tool_DetailsArranger.h:102
xAOD::TauJet_v3::setChargedPFOLinks
void setChargedPFOLinks(const PFOLinks_t &chargedPFOs)
PanTau::Tool_DetailsArranger::m_varTypeName_Combined
std::string m_varTypeName_Combined
Definition: Tool_DetailsArranger.h:99
xAOD::TauJet_v3::clearChargedPFOLinks
void clearChargedPFOLinks()
Remove all charged PFOs from the tau.
Definition: TauJet_v3.cxx:828
PanTau::Tool_DetailsArranger::SetNeutralConstituentVectorMasses
static void SetNeutralConstituentVectorMasses(const std::vector< ElementLink< xAOD::PFOContainer > > &neutralPFOLinks, xAOD::PFOContainer &neutralPFOContainer, double mass)
Definition: Tool_DetailsArranger.cxx:387
PanTau::Tool_DetailsArranger::t_Float
@ t_Float
Definition: Tool_DetailsArranger.h:45
PanTau::TauConstituent::t_Pi0Neut
@ t_Pi0Neut
Definition: TauConstituent.h:46
xAOD::PFO_v1::setP4
void setP4(const FourMom_t &vec)
set the 4-vec
Definition: PFO_v1.cxx:107
xAOD::TauJet_v3::setPi0PFOLinks
void setPi0PFOLinks(const PFOLinks_t &pi0PFOs)
a
TList * a
Definition: liststreamerinfos.cxx:10
h
xAOD::TauJetParameters::PanTau_BDTVar_Charged_StdDev_Et_WrtEtAllConsts
@ PanTau_BDTVar_Charged_StdDev_Et_WrtEtAllConsts
Definition: TauDefs.h:368
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
PanTau::Tool_DetailsArranger::m_varTypeName_StdDev
std::string m_varTypeName_StdDev
Definition: Tool_DetailsArranger.h:94
PanTau::PanTauSeed::isOfTechnicalQuality
bool isOfTechnicalQuality(int pantauSeed_TechnicalQuality) const
Definition: PanTauSeed.cxx:349
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
PanTau::Tool_DetailsArranger::createPi0Vectors
static void createPi0Vectors(xAOD::TauJet *tauJet, std::vector< TLorentzVector > &vPi0s, std::vector< std::vector< ElementLink< xAOD::PFOContainer > > > &vec_pi0pfos)
Definition: Tool_DetailsArranger.cxx:444
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
PanTau::PanTauSeed::t_NoSelectedConstituents
@ t_NoSelectedConstituents
Definition: PanTauSeed.h:36
xAOD::TauJet_v3::protoChargedPFOLinks
const PFOLinks_t & protoChargedPFOLinks() const
cellbased pfos
xAOD::TauJet_v3::setDetail
void setDetail(TauJetParameters::Detail detail, int value)
Definition: TauJet_v3.cxx:337
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
PanTau::Tool_DetailsArranger::m_varTypeName_PID
std::string m_varTypeName_PID
Definition: Tool_DetailsArranger.h:103
xAOD::TauJetParameters::Mode_3pXn
@ Mode_3pXn
Definition: TauDefs.h:390
xAOD::TauJetParameters::PanTau_isPanTauCandidate
@ PanTau_isPanTauCandidate
Definition: TauDefs.h:357
xAOD::TauJetParameters::PanTau_BDTVar_Basic_NNeutralConsts
@ PanTau_BDTVar_Basic_NNeutralConsts
Definition: TauDefs.h:366
PanTau::Tool_DetailsArranger::m_varTypeName_Shots
std::string m_varTypeName_Shots
Definition: Tool_DetailsArranger.h:104
PanTau::Tool_DetailsArranger::m_EtaBinEdges
std::vector< double > m_EtaBinEdges
Definition: Tool_DetailsArranger.h:85
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
PanTau::Tool_DetailsArranger::m_Tool_InformationStoreName
std::string m_Tool_InformationStoreName
Definition: Tool_DetailsArranger.h:59
PanTau::Tool_DetailsArranger::m_EtaBinnedEtCuts
std::vector< double > m_EtaBinnedEtCuts
Definition: Tool_DetailsArranger.h:86
xAOD::TauJet_v3::chargedPFOLinks
const PFOLinks_t & chargedPFOLinks() const
default pfos
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_Shots_NPhotonsInSeed
@ PanTau_BDTVar_Neutral_Shots_NPhotonsInSeed
Definition: TauDefs.h:374
xAOD::TauJetParameters::PanTau_BDTVar_Charged_HLV_SumM
@ PanTau_BDTVar_Charged_HLV_SumM
Definition: TauDefs.h:379
SG::DataProxy
Definition: DataProxy.h:45
xAOD::TauJetParameters::Mode_NotSet
@ Mode_NotSet
Definition: TauDefs.h:392
PanTau::Tool_DetailsArranger::MASS_PI0
static constexpr const float MASS_PI0
Definition: Tool_DetailsArranger.h:82
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::TauJetParameters::PanTau_BDTVar_Charged_JetMoment_EtDRxTotalEt
@ PanTau_BDTVar_Charged_JetMoment_EtDRxTotalEt
Definition: TauDefs.h:367
readCCLHist.float
float
Definition: readCCLHist.py:83
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_Ratio_EtOverEtAllConsts
@ PanTau_BDTVar_Neutral_Ratio_EtOverEtAllConsts
Definition: TauDefs.h:373
xAOD::TauJetParameters::Mode_Other
@ Mode_Other
Definition: TauDefs.h:391
fitman.k
k
Definition: fitman.py:528
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_1
@ PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_1
Definition: TauDefs.h:370