ATLAS Offline Software
Tool_DetailsArranger.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "PanTauAlgs/Tool_DetailsArranger.h"
6 #include "PanTauAlgs/PanTauSeed.h"
7 #include "PanTauAlgs/HelperFunctions.h"
8 
9 
10 bool sortBDTscore(const ElementLink< xAOD::PFOContainer >& i, const ElementLink< xAOD::PFOContainer >& j){
11 
12  return ( i.cachedElement()->bdtPi0Score() > j.cachedElement()->bdtPi0Score() );
13 }
14 
15 
16 PanTau::Tool_DetailsArranger::Tool_DetailsArranger(const std::string& name) :
17  asg::AsgTool(name)
18 {}
19 
20 PanTau::Tool_DetailsArranger::~Tool_DetailsArranger() = default;
21 
22 StatusCode PanTau::Tool_DetailsArranger::initialize() {
23 
24  m_init=true;
25 
26  ATH_CHECK( HelperFunctions::bindToolHandle( m_Tool_InformationStore, m_Tool_InformationStoreName ) );
27 
28  ATH_CHECK( m_Tool_InformationStore->getInfo_Double("TauConstituents_Types_DeltaRCore", m_CoreCone) );
29  ATH_CHECK( m_Tool_InformationStore->getInfo_VecDouble("TauConstituents_BinEdges_Eta", m_EtaBinEdges) );
30  ATH_CHECK( m_Tool_InformationStore->getInfo_VecDouble("TauConstituents_Selection_Neutral_EtaBinned_EtCut", m_EtaBinnedEtCuts) );
31  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Sum", m_varTypeName_Sum) );
32  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Ratio", m_varTypeName_Ratio) );
33  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Isolation", m_varTypeName_Isolation) );
34  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Num", m_varTypeName_Num) );
35  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Mean", m_varTypeName_Mean) );
36  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_StdDev", m_varTypeName_StdDev) );
37  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_HLV", m_varTypeName_HLV) );
38  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Angle", m_varTypeName_Angle) );
39  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_DeltaR", m_varTypeName_DeltaR) );
40  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_JetMoment", m_varTypeName_JetMoment) );
41  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Combined", m_varTypeName_Combined) );
42  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Basic", m_varTypeName_Basic) );
43  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_PID", m_varTypeName_PID) );
44  ATH_CHECK( m_Tool_InformationStore->getInfo_String("FeatureExtractor_VarTypeName_varTypeName_Shots", m_varTypeName_Shots) );
45 
46  return StatusCode::SUCCESS;
47 }
48 
49 
50 StatusCode PanTau::Tool_DetailsArranger::execute(PanTau::PanTauSeed* inSeed, xAOD::ParticleContainer& pi0Container, xAOD::PFOContainer& neutralPFOContainer) const {
51 
52  bool noAnyConstituents = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoConstituentsAtAll);
53  bool noSelConstituents = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoSelectedConstituents);
54  bool noValidInputTau = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoValidInputTau);
55  bool isBadSeed = (noAnyConstituents || noSelConstituents || noValidInputTau);
56 
57  //set the PFO link vector and pantau 4-vector to default values for every tau first (xAOD technicality)
58  //if the tau is valid, overwrite with non-default values
59  xAOD::TauJet* tauJet = inSeed->getTauJet();
60 
61  if (isBadSeed) {
62  ATH_MSG_DEBUG("This seed is not useable for detail arranging (other than validity flag)");
63  tauJet->setPanTauDetail(xAOD::TauJetParameters::PanTau_isPanTauCandidate, 0);
64  tauJet->setPanTauDetail(xAOD::TauJetParameters::PanTau_DecayMode, xAOD::TauJetParameters::Mode_NotSet);
65  return StatusCode::SUCCESS;
66  }
67 
68  ATH_CHECK(arrangePFOLinks(inSeed, tauJet, pi0Container, neutralPFOContainer));
69 
70  //Basic variables
71  addPanTauDetailToTauJet(inSeed, m_varTypeName_Basic + "_isPanTauCandidate", xAOD::TauJetParameters::PanTau_isPanTauCandidate, PanTau::Tool_DetailsArranger::t_Int);
72  addPanTauDetailToTauJet(inSeed, m_varTypeName_Basic + "_RecoMode_PanTau", xAOD::TauJetParameters::PanTau_DecayMode, PanTau::Tool_DetailsArranger::t_Int);
73  addPanTauDetailToTauJet(inSeed, m_varTypeName_Basic + "_BDTValue_1p0n_vs_1p1n", xAOD::TauJetParameters::PanTau_BDTValue_1p0n_vs_1p1n, PanTau::Tool_DetailsArranger::t_Float);
74  addPanTauDetailToTauJet(inSeed, m_varTypeName_Basic + "_BDTValue_1p1n_vs_1pXn", xAOD::TauJetParameters::PanTau_BDTValue_1p1n_vs_1pXn, PanTau::Tool_DetailsArranger::t_Float);
75  addPanTauDetailToTauJet(inSeed, m_varTypeName_Basic + "_BDTValue_3p0n_vs_3pXn", xAOD::TauJetParameters::PanTau_BDTValue_3p0n_vs_3pXn, PanTau::Tool_DetailsArranger::t_Float);
76 
77  //Final 4-vector
78  tauJet->setP4(xAOD::TauJetParameters::PanTauCellBased, inSeed->getFinalMomentum().Pt(), inSeed->getFinalMomentum().Eta(), inSeed->getFinalMomentum().Phi(), inSeed->getFinalMomentum().M());
79 
80  //BDT variables
81  addPanTauDetailToTauJet(inSeed, "Basic_NNeutralConsts",
82  xAOD::TauJetParameters::PanTau_BDTVar_Basic_NNeutralConsts, PanTau::Tool_DetailsArranger::t_Int);
83  addPanTauDetailToTauJet(inSeed, "Charged_JetMoment_EtDRxTotalEt",
84  xAOD::TauJetParameters::PanTau_BDTVar_Charged_JetMoment_EtDRxTotalEt, PanTau::Tool_DetailsArranger::t_Float);
85  addPanTauDetailToTauJet(inSeed, "Charged_StdDev_Et_WrtEtAllConsts",
86  xAOD::TauJetParameters::PanTau_BDTVar_Charged_StdDev_Et_WrtEtAllConsts, PanTau::Tool_DetailsArranger::t_Float);
87  addPanTauDetailToTauJet(inSeed, "Neutral_HLV_SumM",
88  xAOD::TauJetParameters::PanTau_BDTVar_Neutral_HLV_SumM, PanTau::Tool_DetailsArranger::t_Float);
89  addPanTauDetailToTauJet(inSeed, "Neutral_PID_BDTValues_BDTSort_1",
90  xAOD::TauJetParameters::PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_1, PanTau::Tool_DetailsArranger::t_Float);
91  addPanTauDetailToTauJet(inSeed, "Neutral_PID_BDTValues_BDTSort_2",
92  xAOD::TauJetParameters::PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_2, PanTau::Tool_DetailsArranger::t_Float);
93  addPanTauDetailToTauJet(inSeed, "Neutral_Ratio_1stBDTEtOverEtAllConsts",
94  xAOD::TauJetParameters::PanTau_BDTVar_Neutral_Ratio_1stBDTEtOverEtAllConsts, PanTau::Tool_DetailsArranger::t_Float);
95  addPanTauDetailToTauJet(inSeed, "Neutral_Ratio_EtOverEtAllConsts",
96  xAOD::TauJetParameters::PanTau_BDTVar_Neutral_Ratio_EtOverEtAllConsts, PanTau::Tool_DetailsArranger::t_Float);
97  addPanTauDetailToTauJet(inSeed, "Neutral_Shots_NPhotonsInSeed",
98  xAOD::TauJetParameters::PanTau_BDTVar_Neutral_Shots_NPhotonsInSeed, PanTau::Tool_DetailsArranger::t_Float);
99  addPanTauDetailToTauJet(inSeed, "Combined_DeltaR1stNeutralTo1stCharged",
100  xAOD::TauJetParameters::PanTau_BDTVar_Combined_DeltaR1stNeutralTo1stCharged, PanTau::Tool_DetailsArranger::t_Float);
101  addPanTauDetailToTauJet(inSeed, "Charged_HLV_SumM",
102  xAOD::TauJetParameters::PanTau_BDTVar_Charged_HLV_SumM, PanTau::Tool_DetailsArranger::t_Float);
103 
104  return StatusCode::SUCCESS;
105 }
106 
107 
108 void PanTau::Tool_DetailsArranger::addPanTauDetailToTauJet(PanTauSeed* inSeed,
109  const std::string& featName,
110  xAOD::TauJetParameters::PanTauDetails detailEnum,
111  PanTauDetailsType detailType) const {
112 
113  bool isValid;
114  const PanTau::TauFeature* features = inSeed->getFeatures();
115  std::string fullFeatName = "CellBased_" + featName;
116 
117  double theValue = features->value(fullFeatName, isValid);
118  if (!isValid) {
119  bool noAnyConstituents = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoConstituentsAtAll);
120  bool noSelConstituents = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoSelectedConstituents);
121  bool noValidInputTau = inSeed->isOfTechnicalQuality(PanTau::PanTauSeed::t_NoValidInputTau);
122  bool isBadSeed = (noAnyConstituents || noSelConstituents || noValidInputTau);
123 
124  if (!isBadSeed) {
125  ATH_MSG_DEBUG("WARNING --- Problems getting value for feature " << fullFeatName << " from map! This should not happen for this seed!");
126  ATH_MSG_DEBUG("WARNING --- Did the ModeDiscriminator set features used in BDTs that were not found to their default values?");
127  ATH_MSG_DEBUG("NOTE --- This can also happen for seeds with (for example) 0 neutrals when trying to get Neutral_SumM - check seed");
128  }
129  theValue = -1111.;
130  }
131 
132  xAOD::TauJet* tauJet = inSeed->getTauJet();
133  int valueToAddInt = -1;
134  float valueToAddFloat = -1.1;
135 
136  switch(detailType) {
137  case PanTau::Tool_DetailsArranger::t_Int:
138  valueToAddInt = static_cast<int>(theValue);
139  tauJet->setPanTauDetail(detailEnum, valueToAddInt);
140  break;
141  case PanTau::Tool_DetailsArranger::t_Float:
142  valueToAddFloat = static_cast<float>(theValue);
143  tauJet->setPanTauDetail(detailEnum, valueToAddFloat);
144  break;
145  default:
146  ATH_MSG_WARNING("Unknown PanTauDetailType! Please use enum PanTauDetailsType from PanTauAlgs/Tool_DetailsArranger.h.");
147  ATH_MSG_WARNING("!NOT! adding detail named " << featName);
148  break;
149  }
150 
151  }
152 
153 
154 StatusCode PanTau::Tool_DetailsArranger::arrangePFOLinks(PanTau::PanTauSeed* inSeed, xAOD::TauJet* tauJet, xAOD::ParticleContainer& pi0Container, xAOD::PFOContainer& neutralPFOContainer) const {
155 
156  //get the PFO links
157  std::vector< ElementLink< xAOD::PFOContainer > > chrgPFOLinks = tauJet->protoChargedPFOLinks();
158  std::vector< ElementLink< xAOD::PFOContainer > > neutralPFOLinks = tauJet->protoNeutralPFOLinks();
159  std::vector< ElementLink< xAOD::PFOContainer > > pi0PFOLinks = CollectConstituentsAsPFOLinks( inSeed, tauJet->protoNeutralPFOLinks(), PanTau::TauConstituent::t_Pi0Neut );
160  std::vector< ElementLink< xAOD::PFOContainer > > preSelected_neutralPFOLinks = CollectConstituentsAsPFOLinks( inSeed, tauJet->protoNeutralPFOLinks(), PanTau::TauConstituent::t_Neutral );
161 
162  //clear the default links, just to be safe
163  tauJet->clearChargedPFOLinks();
164  tauJet->clearNeutralPFOLinks();
165  tauJet->clearPi0PFOLinks();
166 
167  std::vector< ElementLink< xAOD::PFOContainer > > preLinkPi0PFOLinks = tauJet->pi0PFOLinks();
168 
169  // sort PFO links according to pi0 BDT score:
170  std::sort (pi0PFOLinks.begin(), pi0PFOLinks.end(), sortBDTscore);
171  std::sort (preSelected_neutralPFOLinks.begin(), preSelected_neutralPFOLinks.end(), sortBDTscore);
172  std::sort (neutralPFOLinks.begin(), neutralPFOLinks.end(), sortBDTscore);
173 
174  // set the masses of all neutrals *and pi0 neutrals* to 0:
175  SetNeutralConstituentVectorMasses(neutralPFOLinks, neutralPFOContainer, 0.);
176 
177  // arrange charged & neutral PFOs: they are not changed -> copy from cellbased
178  tauJet->setChargedPFOLinks(chrgPFOLinks);
179  tauJet->setNeutralPFOLinks(neutralPFOLinks);
180 
181  tauJet->setDetail(xAOD::TauJetParameters::nCharged, static_cast<int>(chrgPFOLinks.size()));
182 
183  //arrange pi0 pfos: depends on decay mode classification
184  int decayModeProto = inSeed->getDecayModeBySubAlg();
185  int decayModeFinal = inSeed->getDecayModeByPanTau();
186 
187  if(decayModeFinal == xAOD::TauJetParameters::Mode_Other) {
188  tauJet->setPi0PFOLinks(pi0PFOLinks);
189  SetHLVTau(inSeed, tauJet, m_varTypeName_Basic);
190 
191  return StatusCode::SUCCESS;
192  }
193 
194  //if pantau sets the same decay mode as the substructure algorithm, just copy the links
195  if(decayModeProto == decayModeFinal) {
196 
197  if( decayModeFinal == xAOD::TauJetParameters::Mode_3pXn && pi0PFOLinks.size() > 1 ){
198 
199  // assign all neutrals but only one pi0 neutral to Pantau:
200  preLinkPi0PFOLinks.push_back( pi0PFOLinks.at(0) );
201 
202  // set all masses correctly:
203  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
204 
205  } else {
206 
207  // assign the same constituents to Pantau:
208  preLinkPi0PFOLinks=pi0PFOLinks;
209 
210  // set all masses correctly:
211  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
212  }
213 
214  } else {
215 
216  if( decayModeFinal == xAOD::TauJetParameters::Mode_1p1n && decayModeProto == xAOD::TauJetParameters::Mode_1p0n ){
217 
218  // add the highest BDT-score neutral from the sub-alg:
219  if(!preSelected_neutralPFOLinks.empty()) preLinkPi0PFOLinks.push_back( preSelected_neutralPFOLinks.at(0) );
220  else ATH_MSG_WARNING("No neutral PFO Links although there should be!!");
221 
222  // set the mass:
223  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
224 
225  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_1p0n && decayModeProto == xAOD::TauJetParameters::Mode_1p1n ){
226 
227  // do nothing (leave the pi0 neutrals list empty)
228 
229  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_1pXn && decayModeProto == xAOD::TauJetParameters::Mode_1p1n ){
230 
231 
232  if( pi0PFOLinks.size() == 1 && HasMultPi0sInOneCluster(pi0PFOLinks.at(0).cachedElement(), decayModeProto) ){
233 
234  // assign twice the pi0 mass to the one pi0 PFO:
235  SetNeutralConstituentVectorMasses(pi0PFOLinks, neutralPFOContainer, 2*MASS_PI0);
236 
237  // assign the same constituents to Pantau:
238  preLinkPi0PFOLinks=pi0PFOLinks;
239 
240  } else {
241 
242  // copy all (really only one) pi0s from the sub-alg and add
243  // the highest BDT-score neutral:
244  preLinkPi0PFOLinks=pi0PFOLinks;
245  if(!preSelected_neutralPFOLinks.empty()) preLinkPi0PFOLinks.push_back( preSelected_neutralPFOLinks.at(0) );
246  else ATH_MSG_WARNING("No neutral PFO Links although there should be!!");
247 
248  // set the mass:
249  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
250  }
251 
252  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_1p1n && decayModeProto == xAOD::TauJetParameters::Mode_1pXn ){
253 
254  // copy all (two) pi0s from the sub-alg:
255  preLinkPi0PFOLinks.push_back( pi0PFOLinks.at(0) );
256  preLinkPi0PFOLinks.push_back( pi0PFOLinks.at(1) );
257 
258  // set both pi0neutrals to mass 0 (photon mass):
259  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, 0.);
260 
261  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_3pXn && decayModeProto == xAOD::TauJetParameters::Mode_3p0n ){
262 
263  // add the highest BDT-score neutral from the sub-alg:
264  if(!preSelected_neutralPFOLinks.empty()) preLinkPi0PFOLinks.push_back( preSelected_neutralPFOLinks.at(0) );
265  else ATH_MSG_WARNING("No neutral PFO Links although there should be!!");
266 
267  // set the mass:
268  SetNeutralConstituentVectorMasses(preLinkPi0PFOLinks, neutralPFOContainer, MASS_PI0);
269 
270  } else if( decayModeFinal == xAOD::TauJetParameters::Mode_3p0n && decayModeProto == xAOD::TauJetParameters::Mode_3pXn ){
271 
272  // do nothing (leave the pi0 neutrals list empty)
273  }
274  }
275 
276  tauJet->setPi0PFOLinks(preLinkPi0PFOLinks);
277 
278  SetHLVTau(inSeed, tauJet, m_varTypeName_Basic);
279 
280  std::vector< ElementLink< xAOD::PFOContainer > > finalChrgPFOLinks = tauJet->chargedPFOLinks();
281  std::vector< ElementLink< xAOD::PFOContainer > > finalPi0PFOLinks = tauJet->pi0PFOLinks();
282  std::vector< ElementLink< xAOD::PFOContainer > > finalNeutralPFOLinks = tauJet->neutralPFOLinks();
283 
284  // vector of 4-vectors of actual pi0s and a vector with pointers to PFOs:
285  std::vector< TLorentzVector > vec_pi04vec;
286  std::vector< std::vector< ElementLink<xAOD::PFOContainer> > > vec_pi0pfos;
287  createPi0Vectors(tauJet, vec_pi04vec, vec_pi0pfos);
288 
289  for(unsigned int itlv=0; itlv!=vec_pi04vec.size(); ++itlv) {
290  xAOD::Particle* p = new xAOD::Particle();
291  pi0Container.push_back(p);
292  p->setPxPyPzE(vec_pi04vec.at(itlv).Px(), vec_pi04vec.at(itlv).Py(), vec_pi04vec.at(itlv).Pz(), vec_pi04vec.at(itlv).E());
293  std::vector< ElementLink< xAOD::PFOContainer > > pfo_link_vector;
294  for( uint ipfo = 0; ipfo != vec_pi0pfos.at(itlv).size(); ++ipfo) {
295  pfo_link_vector.push_back(vec_pi0pfos.at(itlv).at(ipfo));
296  }
297 
298  static const SG::Accessor<std::vector< ElementLink< xAOD::PFOContainer > > > accPi0PFOLinks("pi0PFOLinks");
299  accPi0PFOLinks(*p) = pfo_link_vector;
300 
301  ElementLink< xAOD::IParticleContainer > linkToPi0;
302  linkToPi0.toContainedElement(pi0Container, dynamic_cast<xAOD::IParticle*> (p));
303 
304  tauJet->addPi0Link(linkToPi0);
305  }
306 
307  return StatusCode::SUCCESS;
308 }
309 
310 
311 // Calculate final 4-vector:
312 void PanTau::Tool_DetailsArranger::SetHLVTau( PanTau::PanTauSeed* inSeed, xAOD::TauJet* tauJet, const std::string& varTypeName_Basic) {
313 
314  std::vector< ElementLink< xAOD::PFOContainer > > finalChrgPFOLinks = tauJet->chargedPFOLinks();
315  std::vector< ElementLink< xAOD::PFOContainer > > finalPi0PFOLinks = tauJet->pi0PFOLinks();
316 
317  unsigned int NCharged = finalChrgPFOLinks.size();
318  unsigned int NPi0Neut = finalPi0PFOLinks.size();
319 
320  TLorentzVector tlv_PanTau_Final;
321  for(unsigned int iPFO=0; iPFO<NCharged; iPFO++) {
322  const xAOD::PFO* pfo = finalChrgPFOLinks.at(iPFO).cachedElement();
323  tlv_PanTau_Final += pfo->p4();
324  }
325  for(unsigned int iPFO=0; iPFO<NPi0Neut; iPFO++) {
326  const xAOD::PFO* pfo = finalPi0PFOLinks.at(iPFO).cachedElement();
327  tlv_PanTau_Final += pfo->p4();
328  }
329 
330  inSeed->setFinalMomentum(tlv_PanTau_Final);
331 
332  PanTau::TauFeature* featureMap = inSeed->getFeatures();
333  featureMap->addFeature("CellBased_" + varTypeName_Basic + "_FinalMomentumCore_pt", tlv_PanTau_Final.Pt() );
334  featureMap->addFeature("CellBased_" + varTypeName_Basic + "_FinalMomentumCore_eta", tlv_PanTau_Final.Eta() );
335  featureMap->addFeature("CellBased_" + varTypeName_Basic + "_FinalMomentumCore_phi", tlv_PanTau_Final.Phi() );
336  featureMap->addFeature("CellBased_" + varTypeName_Basic + "_FinalMomentumCore_m", tlv_PanTau_Final.M() );
337 }
338 
339 
340 bool PanTau::Tool_DetailsArranger::HasMultPi0sInOneCluster(const xAOD::PFO* pfo, int decayModeProto) const {
341 
342  // this is only relevant for reco 1p1n modes, hence restrict the output to these modes
343 
344  int nPi0sPerCluster = 1;
345 
346  // cell-based sets this to 1pXn however below this function is
347  // called with the decayModeProto as evaluated by Pantau!
348  if (decayModeProto != xAOD::TauJetParameters::Mode_1p1n ) return (nPi0sPerCluster > 1);
349 
350  if( !pfo->attribute(xAOD::PFODetails::nPi0Proto, nPi0sPerCluster) ) {
351  ATH_MSG_WARNING("Could not retrieve nPi0Proto. Will set it to 1.");
352  nPi0sPerCluster = 1;
353  }
354 
355  return (nPi0sPerCluster > 1);
356 }
357 
358 
359 void PanTau::Tool_DetailsArranger::SetNeutralConstituentMass(xAOD::PFO* neutral_pfo, double mass) {
360 
361  TLorentzVector momentum;
362  PanTau::SetP4EEtaPhiM( momentum, neutral_pfo->e(), neutral_pfo->eta(), neutral_pfo->phi(), mass);
363  neutral_pfo->setP4(momentum.Pt(), neutral_pfo->eta(), neutral_pfo->phi(), mass);
364 }
365 
366 
367 void PanTau::Tool_DetailsArranger::SetNeutralConstituentVectorMasses(const std::vector< ElementLink<xAOD::PFOContainer> >& neutralPFOLinks, xAOD::PFOContainer& neutralPFOContainer, double mass) {
368 
369  for (const auto& link : neutralPFOLinks) {
370  size_t index = link.index();
371  xAOD::PFO* curNeutralPFO = neutralPFOContainer.at(index);
372  SetNeutralConstituentMass(curNeutralPFO, mass);
373  }
374 
375  }
376 
377 
378 std::vector< ElementLink< xAOD::PFOContainer > > PanTau::Tool_DetailsArranger::CollectConstituentsAsPFOLinks( PanTau::PanTauSeed* inSeed,
379  const std::vector< ElementLink< xAOD::PFOContainer > >& cellbased_neutralPFOLinks,
380  PanTau::TauConstituent::Type type ) const {
381  // collect element links from tau constituents in the Pantau
382  // seed of type "type". cellbased_neutralPFOLinks is only used
383  // to obtain the ElementLinks.
384 
385  std::vector< ElementLink< xAOD::PFOContainer > > new_links;
386 
387  unsigned int nConstsOfType=0;
388  bool foundIt=false;
389  std::vector<PanTau::TauConstituent*> tauConstituents=inSeed->getConstituentsOfType(type,foundIt);
390 
391  if( (type != PanTau::TauConstituent::t_Neutral && type != PanTau::TauConstituent::t_Pi0Neut) || !foundIt){
392  ATH_MSG_WARNING("CollectConstituentsAsPFOLinks: Function was called with type = " << type << " , however it was only designed for types t_Pi0Neut and t_Neutral! Returning...");
393  return new_links;
394  }
395 
396  for(unsigned int iConst=0; iConst<tauConstituents.size(); iConst++) {
397  bool isOfType = tauConstituents[iConst]->isOfType(type);
398  if(!isOfType) continue;
399 
400  // if the requested type is t_Neutral then exclude any t_Pi0Neut
401  // from the list (note: tau constituents that are t_Pi0Neut are
402  // also t_Neutral at the same time):
403  if(type==PanTau::TauConstituent::t_Neutral && tauConstituents[iConst]->isOfType(PanTau::TauConstituent::t_Pi0Neut) ) continue;
404  ++nConstsOfType;
405 
406  for(unsigned int iPFO=0; iPFO<cellbased_neutralPFOLinks.size(); iPFO++) {
407  const xAOD::PFO* pfo = cellbased_neutralPFOLinks.at(iPFO).cachedElement();
408 
409  if( tauConstituents[iConst]->getPFO() != pfo ) continue;
410 
411  new_links.push_back( cellbased_neutralPFOLinks.at(iPFO) );
412  }
413  }
414 
415  if( nConstsOfType != new_links.size() ){
416  ATH_MSG_WARNING("CollectConstituentsAsPFOLinks: Couldn't find PFOLinks " << new_links.size() << " for all tau constituents (" << tauConstituents.size() << ")!");
417  }
418 
419  return new_links;
420 }
421 
422 
423 //______________________________________________________________________________
424 void PanTau::Tool_DetailsArranger::createPi0Vectors(xAOD::TauJet* tauJet, std::vector<TLorentzVector>& vPi0s, std::vector< std::vector< ElementLink< xAOD::PFOContainer > > > &vec_pi0pfos)
425 {
426  // reset the pi0s
427  vPi0s.clear();
428  vec_pi0pfos.clear();
429 
430  // Since the PFO links as they come out of reconstruction, only correspond to
431  // calorimeter clusters, whereas we want the consts_pi0 vectors to correspond
432  // to real pi0s, we need to be careful to collect the PFOs correctly to pi0s
433  // for the cases where number of pi0s does not match to the decay mode:
434  size_t iNumPi0PFO = tauJet->nPi0PFOs();
435 
436  int iDecayMode = -1;
437  tauJet->panTauDetail(xAOD::TauJetParameters::PanTau_DecayMode, iDecayMode);
438 
439  if (iDecayMode == xAOD::TauJetParameters::Mode_1p1n && iNumPi0PFO > 1) {
440 
441  // float fMassPi0 = ParticleConstants::piZeroMassInMeV;
442  float fMassPi0Squared = MASS_PI0*MASS_PI0;
443 
444  // combine both photons (with 0 mass that is already set) to one pi0 vector:
445  const xAOD::PFO* xPfo1 = tauJet->pi0PFO(0);
446  const xAOD::PFO* xPfo2 = tauJet->pi0PFO(1);
447  vPi0s.push_back(xPfo1->p4() + xPfo2->p4());
448 
449  // re-set the mass to one pi0:
450  double dNewMomentum = std::sqrt(vPi0s[0].E() * vPi0s[0].E() - fMassPi0Squared);
451  vPi0s[0].SetPxPyPzE(vPi0s[0].Vect().Unit().Px() * dNewMomentum,
452  vPi0s[0].Vect().Unit().Py() * dNewMomentum,
453  vPi0s[0].Vect().Unit().Pz() * dNewMomentum,
454  vPi0s[0].E());
455 
456  std::vector< ElementLink<xAOD::PFOContainer> > pfovec;
457  pfovec.push_back(tauJet->pi0PFOLinks()[0]);
458  pfovec.push_back(tauJet->pi0PFOLinks()[1]);
459  vec_pi0pfos.push_back( pfovec );
460 
461  } else if (iDecayMode == xAOD::TauJetParameters::DecayMode::Mode_1pXn && iNumPi0PFO == 1){
462 
463  // make a single pi0 from a PFO that contains two pi0s:
464  const xAOD::PFO* xPfo = tauJet->pi0PFO(0);
465  // add the 2-pi0 vector preliminarily to the pi0vector:
466  vPi0s.push_back(xPfo->p4());
467 
468  // re-set the mass back to one pi0:
469  double dNewMomentum = std::sqrt( (vPi0s[0].E()/2.)*(vPi0s[0].E()/2.) - MASS_PI0*MASS_PI0 );
470  vPi0s[0].SetVectM(vPi0s[0].Vect().Unit() * dNewMomentum, MASS_PI0 );
471 
472  // create another pi0 from the same vector:
473  vPi0s.push_back(vPi0s[0]);
474 
475  std::vector< ElementLink<xAOD::PFOContainer> > pfovec;
476  pfovec.push_back(tauJet->pi0PFOLinks()[0]);
477  vec_pi0pfos.push_back( pfovec );
478  vec_pi0pfos.push_back( pfovec );//fix rare crash?
479 
480  } else {
481  // if it's not any of the special cases above then just collect the PFOs:
482  for (size_t iPFO = 0; iPFO < iNumPi0PFO; iPFO++){
483  vPi0s.push_back(tauJet->pi0PFO(iPFO)->p4());
484  std::vector< ElementLink<xAOD::PFOContainer> > pfovec;
485  pfovec.push_back(tauJet->pi0PFOLinks()[iPFO]);
486  vec_pi0pfos.push_back( pfovec );
487  }
488  }
489 
490 }
PanTau::Tool_DetailsArranger::SetNeutralConstituentMass
static void SetNeutralConstituentMass(xAOD::PFO *neutral_pfo, double mass)
Definition: Tool_DetailsArranger.cxx:359
xAOD::TauJetParameters::Mode_1p0n
@ Mode_1p0n
Definition: TauDefs.h:386
PanTauSeed.h
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::t_Int
@ t_Int
Definition: Tool_DetailsArranger.h:46
xAOD::TauJetParameters::PanTau_BDTVar_Combined_DeltaR1stNeutralTo1stCharged
@ PanTau_BDTVar_Combined_DeltaR1stNeutralTo1stCharged
Definition: TauDefs.h:375
PanTau::TauConstituent::t_Neutral
@ t_Neutral
Definition: TauConstituent.h:45
xAOD::TauJetParameters::Mode_1p1n
@ Mode_1p1n
Definition: TauDefs.h:387
PanTau::TauConstituent::Type
Type
Type enumeration to specify type of this tau constituent.
Definition: TauConstituent.h:42
PanTau::PanTauSeed::getFeatures
const PanTau::TauFeature * getFeatures() const
Definition: PanTauSeed.h:217
TauAnalysisTools::createPi0Vectors
void createPi0Vectors(const xAOD::TauJet *xTau, std::vector< TLorentzVector > &vPi0s)
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:316
PanTau::PanTauSeed::getTauJet
const xAOD::TauJet * getTauJet() const
Definition: PanTauSeed.h:215
PanTau::PanTauSeed::getDecayModeBySubAlg
int getDecayModeBySubAlg() const
Definition: PanTauSeed.h:224
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:225
index
Definition: index.py:1
PanTau::PanTauSeed::getConstituentsOfType
std::vector< PanTau::TauConstituent * > getConstituentsOfType(int tauConstituent_Type, bool &foundit)
Definition: PanTauSeed.cxx:337
xAOD::TauJet_v3::setPanTauDetail
void setPanTauDetail(TauJetParameters::PanTauDetails panTauDetail, int value)
Definition: TauJet_v3.cxx:367
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
HelperFunctions.h
xAOD::TauJet_v3::clearNeutralPFOLinks
void clearNeutralPFOLinks()
Remove all neutral PFOs from the tau.
Definition: TauJet_v3.cxx:819
asg
Definition: DataHandleTestTool.h:28
PanTau::TauFeature::addFeature
bool addFeature(const std::string &name, const double value)
adds a new feature
Definition: TauFeature.cxx:44
xAOD::TauJet_v3::setNeutralPFOLinks
void setNeutralPFOLinks(const PFOLinks_t &neutralPFOs)
PanTau::PanTauSeed::getFinalMomentum
TLorentzVector getFinalMomentum() const
Definition: PanTauSeed.h:223
xAOD::TauJet_v3::clearPi0PFOLinks
void clearPi0PFOLinks()
Remove all pi0 PFOs from the tau.
Definition: TauJet_v3.cxx:850
PanTau::Tool_DetailsArranger::addPanTauDetailToTauJet
void addPanTauDetailToTauJet(PanTauSeed *inSeed, const std::string &featName, xAOD::TauJetParameters::PanTauDetails detailEnum, PanTauDetailsType detailType) const
Definition: Tool_DetailsArranger.cxx:108
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:339
PanTau::Tool_DetailsArranger::PanTauDetailsType
PanTauDetailsType
Definition: Tool_DetailsArranger.h:45
PanTau::Tool_DetailsArranger::~Tool_DetailsArranger
virtual ~Tool_DetailsArranger()
PanTau::TauFeature
Definition: TauFeature.h:19
sortBDTscore
bool sortBDTscore(const ElementLink< xAOD::PFOContainer > &i, const ElementLink< xAOD::PFOContainer > &j)
Definition: Tool_DetailsArranger.cxx:10
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:872
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
xAOD::TauJet_v3::nPi0PFOs
size_t nPi0PFOs() const
Get the number of pi0 PFO particles associated with this tau.
Definition: TauJet_v3.cxx:840
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
xAOD::TauJet_v3::setP4
void setP4(double pt, double eta, double phi, double m)
Set methods for IParticle values.
Definition: TauJet_v3.cxx:171
xAOD::Particle
Particle_v1 Particle
Define the latest version of the particle class.
Definition: Event/xAOD/xAODParticleEvent/xAODParticleEvent/Particle.h:17
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_HLV_SumM
@ PanTau_BDTVar_Neutral_HLV_SumM
Definition: TauDefs.h:369
xAOD::TauJetParameters::Mode_1pXn
@ Mode_1pXn
Definition: TauDefs.h:388
xAOD::TauJet_v3::pi0PFO
const PFO * pi0PFO(size_t i) const
Get the pointer to a given pi0 PFO associated with this tau.
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
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
PanTau::PanTauSeed::setFinalMomentum
void setFinalMomentum(TLorentzVector finalMom)
Definition: PanTauSeed.h:229
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
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:378
xAOD::TauJetParameters::PanTau_BDTValue_1p1n_vs_1pXn
@ PanTau_BDTValue_1p1n_vs_1pXn
Definition: TauDefs.h:363
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:154
xAOD::TauJet_v3::neutralPFOLinks
const PFOLinks_t & neutralPFOLinks() const
PanTau::Tool_DetailsArranger::initialize
virtual StatusCode initialize()
Dummy implementation of the initialisation function.
Definition: Tool_DetailsArranger.cxx:22
lumiFormat.i
int i
Definition: lumiFormat.py:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
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
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
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
xAOD::TauJetParameters::PanTauCellBased
@ PanTauCellBased
Definition: TauDefs.h:344
PanTau::Tool_DetailsArranger::execute
virtual StatusCode execute(PanTau::PanTauSeed *inSeed, xAOD::ParticleContainer &pi0Container, xAOD::PFOContainer &neutralPFOContainer) const
Definition: Tool_DetailsArranger.cxx:50
xAOD::TauJet_v3::addPi0Link
void addPi0Link(const ElementLink< IParticleContainer > &tr)
add a pi0 link to the tau
Definition: TauJet_v3.cxx:609
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
xAOD::Particle_v1
Description of a generic particle.
Definition: Particle_v1.h:31
PanTau::Tool_DetailsArranger::SetHLVTau
static void SetHLVTau(PanTau::PanTauSeed *inSeed, xAOD::TauJet *tauJet, const std::string &varTypeName_Basic)
Definition: Tool_DetailsArranger.cxx:312
xAOD::TauJetParameters::Mode_3p0n
@ Mode_3p0n
Definition: TauDefs.h:389
xAOD::PFO_v1
Class describing a particle flow object.
Definition: PFO_v1.h:35
Tool_DetailsArranger.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
PanTau::HelperFunctions::bindToolHandle
static StatusCode bindToolHandle(ToolHandle< T > &, std::string)
Definition: Reconstruction/PanTau/PanTauAlgs/PanTauAlgs/HelperFunctions.h:56
PanTau::Tool_DetailsArranger::HasMultPi0sInOneCluster
bool HasMultPi0sInOneCluster(const xAOD::PFO *pfo, int decayModeProto) const
Definition: Tool_DetailsArranger.cxx:340
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_2
@ PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_2
Definition: TauDefs.h:371
PanTau::Tool_DetailsArranger::Tool_DetailsArranger
Tool_DetailsArranger(const std::string &name)
Definition: Tool_DetailsArranger.cxx:16
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
xAOD::TauJet_v3::setChargedPFOLinks
void setChargedPFOLinks(const PFOLinks_t &chargedPFOs)
xAOD::TauJet_v3::clearChargedPFOLinks
void clearChargedPFOLinks()
Remove all charged PFOs from the tau.
Definition: TauJet_v3.cxx:788
PanTau::Tool_DetailsArranger::SetNeutralConstituentVectorMasses
static void SetNeutralConstituentVectorMasses(const std::vector< ElementLink< xAOD::PFOContainer > > &neutralPFOLinks, xAOD::PFOContainer &neutralPFOContainer, double mass)
Definition: Tool_DetailsArranger.cxx:367
PanTau::Tool_DetailsArranger::t_Float
@ t_Float
Definition: Tool_DetailsArranger.h:47
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)
xAOD::TauJetParameters::PanTauDetails
PanTauDetails
Enum for tau details (scalar) calculated by pantau.
Definition: TauDefs.h:355
xAOD::TauJetParameters::PanTau_BDTVar_Charged_StdDev_Et_WrtEtAllConsts
@ PanTau_BDTVar_Charged_StdDev_Et_WrtEtAllConsts
Definition: TauDefs.h:368
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
PanTau::PanTauSeed::isOfTechnicalQuality
bool isOfTechnicalQuality(int pantauSeed_TechnicalQuality) const
Definition: PanTauSeed.cxx:328
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:424
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:309
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
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
xAOD::TauJetParameters::Mode_NotSet
@ Mode_NotSet
Definition: TauDefs.h:392
xAOD::TauJetParameters::PanTau_BDTVar_Charged_JetMoment_EtDRxTotalEt
@ PanTau_BDTVar_Charged_JetMoment_EtDRxTotalEt
Definition: TauDefs.h:367
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
PanTau::PanTauSeed
Definition: PanTauSeed.h:24
xAOD::TauJetParameters::PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_1
@ PanTau_BDTVar_Neutral_PID_BDTValues_BDTSort_1
Definition: TauDefs.h:370
Generated on Sun Oct 26 2025 21:20:22 for ATLAS Offline Software by   doxygen 1.8.18