ATLAS Offline Software
TauTrackRNNClassifier.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "tauRecTools/TauTrackRNNClassifier.h"
6 #include "tauRecTools/HelperFunctions.h"
7 
8 #include "PathResolver/PathResolver.h"
9 #include "AsgDataHandles/ReadHandle.h"
10 
11 #include "xAODTracking/TrackParticle.h"
12 #include "xAODTau/TauTrackContainer.h"
13 #include "xAODTau/TauxAODHelpers.h"
14 
15 #include <fstream>
16 
17 using namespace tauRecTools;
18 
19 //==============================================================================
20 // class TauTrackRNNClassifier
21 //==============================================================================
22 
23 //______________________________________________________________________________
24 TauTrackRNNClassifier::TauTrackRNNClassifier(const std::string& name)
25  : TauRecToolBase(name) {
26 }
27 
28 //______________________________________________________________________________
29 TauTrackRNNClassifier::~TauTrackRNNClassifier()
30 {
31 }
32 
33 //______________________________________________________________________________
34 StatusCode TauTrackRNNClassifier::initialize()
35 {
36  for (const auto& classifier : m_vClassifier){
37  ATH_MSG_INFO("Intialize TauTrackRNNClassifier tool : " << classifier );
38  ATH_CHECK(classifier.retrieve());
39  }
40 
41  ATH_CHECK( m_vertexContainerKey.initialize() );
42 
43  return StatusCode::SUCCESS;
44 }
45 
46 //______________________________________________________________________________
47 StatusCode TauTrackRNNClassifier::executeTrackClassifier(xAOD::TauJet& xTau, xAOD::TauTrackContainer& tauTrackCon) const {
48 
49  SG::ReadHandle<xAOD::VertexContainer> vertexInHandle( m_vertexContainerKey );
50  if (!vertexInHandle.isValid()) {
51  ATH_MSG_ERROR ("Could not retrieve HiveDataObj with key " << vertexInHandle.key());
52  return StatusCode::FAILURE;
53  }
54  const xAOD::VertexContainer* vertexContainer = vertexInHandle.cptr();
55 
56  std::vector<xAOD::TauTrack*> vTracks = xAOD::TauHelpers::allTauTracksNonConst(&xTau, &tauTrackCon);
57 
58  for (xAOD::TauTrack* xTrack : vTracks) {
59  // reset all track flags and set status to unclassified
60  xTrack->setFlag(xAOD::TauJetParameters::classifiedCharged, false);
61  xTrack->setFlag(xAOD::TauJetParameters::classifiedConversion, false);
62  xTrack->setFlag(xAOD::TauJetParameters::classifiedIsolation, false);
63  xTrack->setFlag(xAOD::TauJetParameters::classifiedFake, false);
64  xTrack->setFlag(xAOD::TauJetParameters::unclassified, true);
65  }
66 
67  // don't classify LRTs even if LRTs were associated with taus in TauTrackFinder
68  if(!m_classifyLRT) {
69  std::vector<xAOD::TauTrack*> vLRTs;
70  std::vector<xAOD::TauTrack*>::iterator it = vTracks.begin();
71  while(it != vTracks.end()) {
72  if((*it)->flag(xAOD::TauJetParameters::LargeRadiusTrack)) {
73  vLRTs.push_back(*it);
74  it = vTracks.erase(it);
75  }
76  else {
77  ++it;
78  }
79  }
80 
81  // decorate LRTs with default RNN scores
82  for (auto classifier : m_vClassifier) {
83  ATH_CHECK(classifier->classifyTracks(vLRTs, xTau, vertexContainer, tauTrackCon, true));
84  }
85  }
86 
87  // With this options, RNN track classifier will only be applied to a unique set of tracks
88  // without any duplication between different taus (see the dedicated protection in the TauTrackFinder).
89  // This option is currently NOT applied as default, since this will change AODs in R22+ reconstruction
90  // and also can lead to reconstruction inefficiency when compared to current reconstruction.
91  // Put here as this can used for Run4 studies
92  if(m_classifyOnlyCoreTracks){
93  std::vector<xAOD::TauTrack*> excludedTracks;
94  std::vector<xAOD::TauTrack*>::iterator it = vTracks.begin();
95  while(it != vTracks.end()) {
96  if(!((*it)->flagWithMask( (1<<xAOD::TauJetParameters::TauTrackFlag::coreTrack) | (1<<xAOD::TauJetParameters::TauTrackFlag::passTrkSelector)))){
97 
98  excludedTracks.push_back(*it);
99  it = vTracks.erase(it);
100  }
101  else {
102  ++it;
103  }
104  }
105  // decorate excludedTracks with default RNN scores
106  for (auto classifier : m_vClassifier) {
107  ATH_CHECK(classifier->classifyTracks(excludedTracks, xTau, vertexContainer, tauTrackCon, true));
108  }
109  }
110 
111  // classify tracks
112  for (auto classifier : m_vClassifier) {
113  ATH_CHECK(classifier->classifyTracks(vTracks, xTau, vertexContainer, tauTrackCon));
114  }
115 
116  std::vector< ElementLink< xAOD::TauTrackContainer > >& tauTrackLinks(xTau.allTauTrackLinksNonConst());
117  std::sort(tauTrackLinks.begin(), tauTrackLinks.end(), sortTracks);
118  float charge=0.0;
119  for( const xAOD::TauTrack* trk : xTau.tracks(xAOD::TauJetParameters::classifiedCharged) ){
120  charge += trk->track()->charge();
121  }
122  xTau.setCharge(charge);
123  xTau.setDetail(xAOD::TauJetParameters::nChargedTracks, static_cast<int>(xTau.nTracks()));
124  xTau.setDetail(xAOD::TauJetParameters::nIsolatedTracks, static_cast<int>(xTau.nTracks(xAOD::TauJetParameters::classifiedIsolation)));
125 
126  // decorations for now, may be turned into Aux
127  static const SG::Accessor<int> nTrkConv("nConversionTracks");
128  static const SG::Accessor<int> nTrkFake("nFakeTracks");
129  nTrkConv(xTau) = static_cast<int>(xTau.nTracks(xAOD::TauJetParameters::classifiedConversion));
130  nTrkFake(xTau) = static_cast<int>(xTau.nTracks(xAOD::TauJetParameters::classifiedFake));
131 
132  //set modifiedIsolationTrack
133  for (xAOD::TauTrack* xTrack : vTracks) {
134  if( not xTrack->flag(xAOD::TauJetParameters::classifiedCharged) and xTrack->flag(xAOD::TauJetParameters::passTrkSelector) ) {
135  xTrack->setFlag(xAOD::TauJetParameters::modifiedIsolationTrack, true);
136  }
137  else {
138  xTrack->setFlag(xAOD::TauJetParameters::modifiedIsolationTrack, false);
139  }
140  }
141  xTau.setDetail(xAOD::TauJetParameters::nModifiedIsolationTracks, static_cast<int>(xTau.nTracks(xAOD::TauJetParameters::modifiedIsolationTrack)));
142 
143  return StatusCode::SUCCESS;
144 }
145 
146 //==============================================================================
147 // class TrackRNN
148 //==============================================================================
149 
150 //______________________________________________________________________________
151 TrackRNN::TrackRNN(const std::string& name)
152  : TauRecToolBase(name)
153 {
154 }
155 
156 //______________________________________________________________________________
157 TrackRNN::~TrackRNN()
158 {
159 }
160 
161 //______________________________________________________________________________
162 StatusCode TrackRNN::initialize()
163 {
164  std::string inputWeightsPath = find_file(m_inputWeightsPath);
165  ATH_MSG_INFO("Using calibration file: " << inputWeightsPath);
166 
167  std::ifstream nn_config_istream(inputWeightsPath);
168 
169  lwtDev::GraphConfig NNconfig = lwtDev::parse_json_graph(nn_config_istream);
170 
171  m_RNNClassifier = std::make_unique<lwtDev::LightweightGraph>(NNconfig, NNconfig.outputs.begin()->first);
172  if(!m_RNNClassifier) {
173  ATH_MSG_FATAL("Couldn't configure neural network!");
174  return StatusCode::FAILURE;
175  }
176 
177  return StatusCode::SUCCESS;
178 }
179 
180 //______________________________________________________________________________
181 StatusCode TrackRNN::classifyTracks(std::vector<xAOD::TauTrack*>& vTracks,
182  xAOD::TauJet& xTau,
183  const xAOD::VertexContainer* vertexContainer,
184  const xAOD::TauTrackContainer& tauTrackCon,
185  bool skipTracks) const
186 {
187  if(vTracks.empty()) {
188  return StatusCode::SUCCESS;
189  }
190 
191  static const SG::Accessor<float> idScoreCharged("rnn_chargedScore");
192  static const SG::Accessor<float> idScoreIso("rnn_isolationScore");
193  static const SG::Accessor<float> idScoreConv("rnn_conversionScore");
194  static const SG::Accessor<float> idScoreFake("rnn_fakeScore");
195 
196  // don't classify tracks, set default decorations
197  if(skipTracks) {
198  for(xAOD::TauTrack* track : vTracks) {
199  idScoreCharged(*track) = 0.;
200  idScoreConv(*track) = 0.;
201  idScoreIso(*track) = 0.;
202  idScoreFake(*track) = 0.;
203  }
204  return StatusCode::SUCCESS;
205  }
206 
207  std::sort(vTracks.begin(), vTracks.end(), [](const xAOD::TauTrack * a, const xAOD::TauTrack * b) {return a->pt() > b->pt();});
208 
209  VectorMap valueMap;
210  ATH_CHECK(calculateVars(vTracks, xTau, vertexContainer, valueMap));
211 
212  SeqNodeMap seqInput;
213  NodeMap nodeInput;
214 
215  seqInput["input_1"] = valueMap;
216 
217  VectorMap mValue = m_RNNClassifier->scan(nodeInput, seqInput, "time_distributed_2");
218 
219  std::vector<double> vClassProb(5);
220 
221  for (unsigned int i = 0; i < vTracks.size(); ++i){
222 
223  if(i >= m_nMaxNtracks && m_nMaxNtracks > 0){
224  vClassProb[0] = 0.0;
225  vClassProb[1] = 0.0;
226  vClassProb[2] = 0.0;
227  vClassProb[3] = 0.0;
228  vClassProb[4] = 1.0;
229  }else{
230  vClassProb[0] = mValue["type_0"][i];
231  vClassProb[1] = mValue["type_1"][i];
232  vClassProb[2] = mValue["type_2"][i];
233  vClassProb[3] = mValue["type_3"][i];
234  vClassProb[4] = 0.0;
235  }
236 
237  idScoreCharged(*vTracks[i]) = vClassProb[0];
238  idScoreConv(*vTracks[i]) = vClassProb[1];
239  idScoreIso(*vTracks[i]) = vClassProb[2];
240  idScoreFake(*vTracks[i]) = vClassProb[3];
241 
242  int iMaxIndex = 0;
243  for (unsigned int j = 1; j < vClassProb.size(); ++j){
244  if(vClassProb[j] > vClassProb[iMaxIndex]) iMaxIndex = j;
245  }
246 
247  if(iMaxIndex < 4) {
248  vTracks[i]->setFlag(xAOD::TauJetParameters::unclassified, false);
249  }
250 
251  if(iMaxIndex == 3){
252  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedFake, true);
253  }else if(iMaxIndex == 0){
254  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedCharged, true);
255  }else if(iMaxIndex == 1){
256  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedConversion, true);
257  }else if(iMaxIndex == 2){
258  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedIsolation, true);
259  }
260  }
261 
262  if(m_removeDuplicateChargedTracks){
263  bool alreadyUsed = false;
264  for (unsigned int i = 0; i < vTracks.size(); ++i){
265  alreadyUsed = false;
266  //loop over all up-to-now charged tracks
267  for( const xAOD::TauTrack* tau_trk : tauTrackCon ) {
268  if(!(vTracks[i]->flag(xAOD::TauJetParameters::TauTrackFlag::classifiedCharged))) continue;
269  if( vTracks[i]->track() == tau_trk->track()) alreadyUsed = true;
270  }
271  //if this track has already been used by another tau, don't consider
272  if (alreadyUsed) {
273  ATH_MSG_INFO( "Found Already Used charged track new, now putting it as unclassified" );
274  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedCharged, false);
275  vTracks[i]->setFlag(xAOD::TauJetParameters::TauTrackFlag::unclassified, true);
276  } else {
277  ++i;
278  }
279  }
280  }
281 
282 
283  return StatusCode::SUCCESS;
284 }
285 
286 
287 //______________________________________________________________________________
288 StatusCode TrackRNN::calculateVars(const std::vector<xAOD::TauTrack*>& vTracks,
289  const xAOD::TauJet& xTau,
290  const xAOD::VertexContainer* vertexContainer,
291  tauRecTools::VectorMap& valueMap) const
292 {
293  // initialize map with values
294  valueMap.clear();
295  unsigned int n_timeSteps = vTracks.size();
296  if(m_nMaxNtracks > 0 && n_timeSteps > m_nMaxNtracks) {
297  n_timeSteps = m_nMaxNtracks;
298  }
299 
300  valueMap["log(trackPt)"] = std::vector<double>(n_timeSteps);
301  valueMap["log(jetSeedPt)"] = std::vector<double>(n_timeSteps);
302  valueMap["trackPt/tauPtIntermediateAxis"] = std::vector<double>(n_timeSteps);
303  valueMap["trackEta"] = std::vector<double>(n_timeSteps);
304  valueMap["z0sinthetaTJVA"] = std::vector<double>(n_timeSteps);
305  valueMap["z0sinthetaSigTJVA"] = std::vector<double>(n_timeSteps);
306  valueMap["log(rConv)"] = std::vector<double>(n_timeSteps);
307  valueMap["tanh(rConvII/500)"] = std::vector<double>(n_timeSteps);
308  valueMap["dRJetSeedAxis"] = std::vector<double>(n_timeSteps);
309  valueMap["dRIntermediateAxis"] = std::vector<double>(n_timeSteps);
310  valueMap["tanh(d0SigTJVA/10)"] = std::vector<double>(n_timeSteps);
311  valueMap["tanh(d0TJVA/10)"] = std::vector<double>(n_timeSteps);
312  valueMap["qOverP*1000"] = std::vector<double>(n_timeSteps);
313  valueMap["numberOfInnermostPixelLayerHits"] = std::vector<double>(n_timeSteps);
314  valueMap["numberOfPixelSharedHits"] = std::vector<double>(n_timeSteps);
315  valueMap["numberOfSCTSharedHits"] = std::vector<double>(n_timeSteps);
316  valueMap["numberOfTRTHits"] = std::vector<double>(n_timeSteps);
317  valueMap["eProbabilityHT"] = std::vector<double>(n_timeSteps);
318  valueMap["nPixHits"] = std::vector<double>(n_timeSteps);
319  valueMap["nSCTHits"] = std::vector<double>(n_timeSteps);
320  valueMap["dz0_TV_PV0"] = std::vector<double>(n_timeSteps);
321  valueMap["log_sumpt_TV"] = std::vector<double>(n_timeSteps);
322  valueMap["log_sumpt2_TV"] = std::vector<double>(n_timeSteps);
323  valueMap["log_sumpt_PV0"] = std::vector<double>(n_timeSteps);
324  valueMap["log_sumpt2_PV0"] = std::vector<double>(n_timeSteps);
325  valueMap["charge"] = std::vector<double>(n_timeSteps);
326  // used by RNN track classifier for upgrade
327  valueMap["(trackPt/jetSeedPt)"] = std::vector<double>(n_timeSteps);
328  valueMap["numberOfInnermostPixelLayerEndcapHits"] = std::vector<double>(n_timeSteps);
329  valueMap["nSiHits"] = std::vector<double>(n_timeSteps);
330 
331  // tau variable
332  double log_ptJetSeed = std::log( xTau.ptJetSeed() );
333 
334  // vertex variables
335  double dz0_TV_PV0 = 0., sumpt_TV = 0., sumpt2_TV = 0., sumpt_PV0 = 0., sumpt2_PV0 = 0.;
336  if(vertexContainer != nullptr && !vertexContainer->empty() && xTau.vertex()!=nullptr) {
337  dz0_TV_PV0 = xTau.vertex()->z() - vertexContainer->at(0)->z();
338 
339  for (const ElementLink<xAOD::TrackParticleContainer>& trk : vertexContainer->at(0)->trackParticleLinks()) {
340  sumpt_PV0 += (*trk)->pt();
341  sumpt2_PV0 += pow((*trk)->pt(), 2.);
342  }
343  for (const ElementLink<xAOD::TrackParticleContainer>& trk : xTau.vertex()->trackParticleLinks()) {
344  sumpt_TV += (*trk)->pt();
345  sumpt2_TV += pow((*trk)->pt(), 2.);
346  }
347  }
348 
349  double log_sumpt_TV = (sumpt_TV>0.) ? std::log(sumpt_TV) : 0.;
350  double log_sumpt2_TV = (sumpt2_TV>0.) ? std::log(sumpt2_TV) : 0.;
351  double log_sumpt_PV0 = (sumpt_PV0>0.) ? std::log(sumpt_PV0) : 0.;
352  double log_sumpt2_PV0 = (sumpt2_PV0>0.) ? std::log(sumpt2_PV0) : 0.;
353 
354  // track variables
355  unsigned int i = 0;
356 
357  for(xAOD::TauTrack* xTrack : vTracks)
358  {
359  const xAOD::TrackParticle* xTrackParticle = xTrack->track();
360 
361  uint8_t numberOfInnermostPixelLayerHits = 0; ATH_CHECK( xTrackParticle->summaryValue(numberOfInnermostPixelLayerHits, xAOD::numberOfInnermostPixelLayerHits) );
362  uint8_t nPixelHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelHits, xAOD::numberOfPixelHits) );
363  uint8_t nPixelSharedHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelSharedHits, xAOD::numberOfPixelSharedHits) );
364  uint8_t nPixelDeadSensors = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelDeadSensors, xAOD::numberOfPixelDeadSensors) );
365  uint8_t nSCTHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTHits, xAOD::numberOfSCTHits) );
366  uint8_t nSCTSharedHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTSharedHits, xAOD::numberOfSCTSharedHits) );
367  uint8_t nSCTDeadSensors = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTDeadSensors, xAOD::numberOfSCTDeadSensors) );
368  uint8_t nTRTHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nTRTHits, xAOD::numberOfTRTHits) );
369  float eProbabilityHT; ATH_CHECK( xTrackParticle->summaryValue( eProbabilityHT, xAOD::eProbabilityHT) );
370 
371  // used by RNN track classifier for upgrade
372  uint8_t numberOfInnermostPixelLayerEndcapHits = 0;
373  uint8_t tmp_var = 0;
374  if(xTrackParticle->summaryValue(tmp_var, xAOD::numberOfInnermostPixelLayerEndcapHits) ){
375  numberOfInnermostPixelLayerEndcapHits = tmp_var;
376  }
377  uint8_t nSiHits = nPixelHits + nPixelDeadSensors + nSCTHits + nSCTDeadSensors;
378 
379  valueMap["log(trackPt)"][i] = std::log( xTrackParticle->pt() );
380  valueMap["log(jetSeedPt)"][i] = log_ptJetSeed;
381  valueMap["trackPt/tauPtIntermediateAxis"][i] = xTrackParticle->pt()/xTau.ptIntermediateAxis();
382  valueMap["trackEta"][i] = xTrackParticle->eta();
383  valueMap["z0sinthetaTJVA"][i] = xTrack->z0sinthetaTJVA();
384  valueMap["z0sinthetaSigTJVA"][i] = xTrack->z0sinthetaSigTJVA();
385  valueMap["log(rConv)"][i] = std::log( xTrack->rConv() );
386  valueMap["tanh(rConvII/500)"][i] = std::tanh( xTrack->rConvII()/500. );
387  // there is no seed jets in AOD so dRJetSeedAxis wont work
388  valueMap["dRJetSeedAxis"][i] = xTrack->p4().DeltaR(xTau.p4(xAOD::TauJetParameters::JetSeed));
389  valueMap["dRIntermediateAxis"][i] = xTrack->p4().DeltaR( xTau.p4(xAOD::TauJetParameters::IntermediateAxis) );
390  valueMap["tanh(d0SigTJVA/10)"][i] = std::tanh( xTrack->d0SigTJVA()/10. );
391  valueMap["tanh(d0TJVA/10)"][i] = std::tanh( xTrack->d0TJVA()/10. );
392  valueMap["qOverP*1000"][i] = xTrackParticle->qOverP()*1000.;
393  valueMap["numberOfInnermostPixelLayerHits"][i] = numberOfInnermostPixelLayerHits;
394  valueMap["numberOfPixelSharedHits"][i] = nPixelSharedHits;
395  valueMap["numberOfSCTSharedHits"][i] = nSCTSharedHits;
396  valueMap["numberOfTRTHits"][i] = nTRTHits;
397  valueMap["eProbabilityHT"][i] = eProbabilityHT;
398  valueMap["nPixHits"][i] = nPixelHits + nPixelDeadSensors;
399  valueMap["nSCTHits"][i] = nSCTHits + nSCTDeadSensors;
400  valueMap["dz0_TV_PV0"][i] = dz0_TV_PV0;
401  valueMap["log_sumpt_TV"][i] = log_sumpt_TV;
402  valueMap["log_sumpt2_TV"][i] = log_sumpt2_TV;
403  valueMap["log_sumpt_PV0"][i] = log_sumpt_PV0;
404  valueMap["log_sumpt2_PV0"][i] = log_sumpt2_PV0;
405  valueMap["charge"][i] = xTrackParticle->charge();
406  // used by RNN track classifier for upgrade
407  valueMap["(trackPt/jetSeedPt)"][i] = xTrackParticle->pt()/xTau.ptJetSeed();
408  valueMap["numberOfInnermostPixelLayerEndcapHits"][i] = numberOfInnermostPixelLayerEndcapHits;
409  valueMap["nSiHits"][i] = nSiHits;
410 
411  ++i;
412  if(m_nMaxNtracks > 0 && i >= m_nMaxNtracks) {
413  break;
414  }
415  }
416 
417  return StatusCode::SUCCESS;
418 }
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
tauRecTools::NodeMap
std::map< std::string, ValueMap > NodeMap
Definition: TauTrackRNNClassifier.h:44
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:74
xAOD::TauJetParameters::nIsolatedTracks
@ nIsolatedTracks
Definition: TauDefs.h:323
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:273
xAOD::TauJetParameters::IntermediateAxis
@ IntermediateAxis
Definition: TauDefs.h:338
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
SG::Accessor< int >
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:151
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
xAOD::TauJetParameters::classifiedFake
@ classifiedFake
Definition: TauDefs.h:409
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:78
tauRecTools::TauTrackRNNClassifier::m_vertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexContainerKey
Definition: TauTrackRNNClassifier.h:66
xAOD::TauJet_v3::setCharge
void setCharge(float)
xAOD::Vertex_v1::trackParticleLinks
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:737
xAOD::TauJet_v3::nTracks
size_t nTracks(TauJetParameters::TauTrackFlag flag=TauJetParameters::TauTrackFlag::classifiedCharged) const
Definition: TauJet_v3.cxx:488
xAOD::TauJetParameters::nModifiedIsolationTracks
@ nModifiedIsolationTracks
Definition: TauDefs.h:324
xAOD::TauJetParameters::classifiedCharged
@ classifiedCharged
Definition: TauDefs.h:406
skel.it
it
Definition: skel.GENtoEVGEN.py:407
TauGNNUtils::Variables::Track::log_sumpt2_PV0
bool log_sumpt2_PV0(const xAOD::TauJet &tau, const xAOD::TauTrack &, float &out)
Definition: TauGNNUtils.cxx:673
TauRecToolBase
The base class for all tau tools.
Definition: TauRecToolBase.h:21
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:276
tauRecTools::VectorMap
std::map< std::string, std::vector< double > > VectorMap
Definition: TauTrackRNNClassifier.h:42
TauTrackContainer.h
xAOD::TauJet_v3::ptJetSeed
double ptJetSeed() const
tauRecTools::TauTrackRNNClassifier::m_vClassifier
ToolHandleArray< TrackRNN > m_vClassifier
Definition: TauTrackRNNClassifier.h:64
xAOD::TauJetParameters::LargeRadiusTrack
@ LargeRadiusTrack
Definition: TauDefs.h:413
TauGNNUtils::Variables::Track::log_sumpt2_TV
bool log_sumpt2_TV(const xAOD::TauJet &tau, const xAOD::TauTrack &, float &out)
Definition: TauGNNUtils.cxx:661
IDTPM::nPixelHits
float nPixelHits(const U &p)
Definition: TrackParametersHelper.h:354
TauTrackRNNClassifier.h
tauRecTools::TrackRNN::m_RNNClassifier
std::unique_ptr< lwtDev::LightweightGraph > m_RNNClassifier
Definition: TauTrackRNNClassifier.h:111
xAOD::TauJetParameters::JetSeed
@ JetSeed
Definition: TauDefs.h:336
IDTPM::nSCTSharedHits
float nSCTSharedHits(const U &p)
Definition: TrackParametersHelper.h:413
tauRecTools::TrackRNN::initialize
virtual StatusCode initialize() override
Tool initializer.
Definition: TauTrackRNNClassifier.cxx:162
xAOD::TauHelpers::allTauTracksNonConst
std::vector< xAOD::TauTrack * > allTauTracksNonConst(const xAOD::TauJet *tau, xAOD::TauTrackContainer *trackCont)
Definition: TauxAODHelpers.cxx:43
tauRecTools::TrackRNN::calculateVars
StatusCode calculateVars(const std::vector< xAOD::TauTrack * > &vTracks, const xAOD::TauJet &xTau, const xAOD::VertexContainer *vertexContainer, VectorMap &valueMap) const
Definition: TauTrackRNNClassifier.cxx:288
tauRecTools::TauTrackRNNClassifier::initialize
virtual StatusCode initialize() override
Tool initializer.
Definition: TauTrackRNNClassifier.cxx:34
xAOD::TauJetParameters::passTrkSelector
@ passTrkSelector
Definition: TauDefs.h:405
xAOD::numberOfInnermostPixelLayerEndcapHits
@ numberOfInnermostPixelLayerEndcapHits
these are the hits in the 0th pixel layer endcap [unit8_t].
Definition: TrackingPrimitives.h:243
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:263
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
tauRecTools::TrackRNN::m_removeDuplicateChargedTracks
Gaudi::Property< bool > m_removeDuplicateChargedTracks
Definition: TauTrackRNNClassifier.h:109
lumiFormat.i
int i
Definition: lumiFormat.py:85
IDTPM::nSCTHits
float nSCTHits(const U &p)
Definition: TrackParametersHelper.h:393
IDTPM::nTRTHits
float nTRTHits(const U &p)
Definition: TrackParametersHelper.h:446
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TauxAODHelpers.h
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
tauRecTools::TrackRNN::m_inputWeightsPath
Gaudi::Property< std::string > m_inputWeightsPath
Definition: TauTrackRNNClassifier.h:107
master.flag
bool flag
Definition: master.py:29
TauGNNUtils::Variables::Track::dz0_TV_PV0
bool dz0_TV_PV0(const xAOD::TauJet &tau, const xAOD::TauTrack &, float &out)
Definition: TauGNNUtils.cxx:649
tauRecTools::TauTrackRNNClassifier::TauTrackRNNClassifier
TauTrackRNNClassifier(const std::string &name="TauTrackRNNClassifier")
Definition: TauTrackRNNClassifier.cxx:24
tauRecTools::TrackRNN::classifyTracks
StatusCode classifyTracks(std::vector< xAOD::TauTrack * > &vTracks, xAOD::TauJet &xTau, const xAOD::VertexContainer *vertexContainer, const xAOD::TauTrackContainer &tauTrackContainer, bool skipTracks=false) const
Definition: TauTrackRNNClassifier.cxx:181
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::Vertex_v1::z
float z() const
Returns the z position.
xAOD::TauJetParameters::coreTrack
@ coreTrack
Definition: TauDefs.h:403
tauRecTools::TauTrackRNNClassifier::m_classifyOnlyCoreTracks
Gaudi::Property< bool > m_classifyOnlyCoreTracks
Definition: TauTrackRNNClassifier.h:69
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
xAOD::TauJet_v3::allTauTrackLinksNonConst
TauTrackLinks_t & allTauTrackLinksNonConst()
In order to sort track links.
Definition: TauJet_v3.cxx:418
tauRecTools::TrackRNN::m_nMaxNtracks
Gaudi::Property< unsigned int > m_nMaxNtracks
Definition: TauTrackRNNClassifier.h:108
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::TauJetParameters::classifiedConversion
@ classifiedConversion
Definition: TauDefs.h:408
xAOD::TauJetParameters::classifiedIsolation
@ classifiedIsolation
Definition: TauDefs.h:407
TauGNNUtils::Variables::Track::log_sumpt_TV
bool log_sumpt_TV(const xAOD::TauJet &tau, const xAOD::TauTrack &, float &out)
Definition: TauGNNUtils.cxx:655
xAOD::TrackParticle_v1::qOverP
float qOverP() const
Returns the parameter.
PathResolver.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
ReadHandle.h
Handle class for reading from StoreGate.
TauRecToolBase::find_file
std::string find_file(const std::string &fname) const
Definition: TauRecToolBase.cxx:19
charge
double charge(const T &p)
Definition: AtlasPID.h:991
SG::VarHandleBase::key
virtual const std::string & key() const override final
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:64
tauRecTools::TauTrackRNNClassifier::m_classifyLRT
Gaudi::Property< bool > m_classifyLRT
Definition: TauTrackRNNClassifier.h:68
TrackParticle.h
lwtDev::parse_json_graph
GraphConfig parse_json_graph(std::istream &json)
Definition: parse_json.cxx:71
a
TList * a
Definition: liststreamerinfos.cxx:10
IDTPM::nPixelSharedHits
float nPixelSharedHits(const U &p)
Definition: TrackParametersHelper.h:374
xAOD::TauJet_v3::vertex
const Vertex * vertex() const
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:274
xAOD::TauTrack_v1
Definition: TauTrack_v1.h:27
xAOD::TauJet_v3::p4
virtual FourMom_t p4() const
The full 4-momentum of the particle.
Definition: TauJet_v3.cxx:96
xAOD::TauJetParameters::modifiedIsolationTrack
@ modifiedIsolationTrack
Definition: TauDefs.h:412
TauGNNUtils::Variables::Track::log_sumpt_PV0
bool log_sumpt_PV0(const xAOD::TauJet &tau, const xAOD::TauTrack &, float &out)
Definition: TauGNNUtils.cxx:667
HelperFunctions.h
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xAOD::TauJet_v3::setDetail
void setDetail(TauJetParameters::Detail detail, int value)
Definition: TauJet_v3.cxx:309
tauRecTools::TauTrackRNNClassifier::executeTrackClassifier
virtual StatusCode executeTrackClassifier(xAOD::TauJet &pTau, xAOD::TauTrackContainer &tauTrackContainer) const override
Definition: TauTrackRNNClassifier.cxx:47
xAOD::eProbabilityHT
@ eProbabilityHT
Electron probability from High Threshold (HT) information [float].
Definition: TrackingPrimitives.h:302
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
lwtDev::GraphConfig::outputs
std::map< std::string, OutputNodeConfig > outputs
Definition: lightweight_network_config.h:62
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:267
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
xAOD::TrackParticle_v1::track
const Trk::Track * track() const
Returns a pointer (which can be NULL) to the Trk::Track which was used to make this TrackParticle.
Definition: TrackParticle_v1.cxx:806
tauRecTools
Implementation of a TrackClassifier based on an RNN.
Definition: BDTHelper.cxx:12
tauRecTools::SeqNodeMap
std::map< std::string, VectorMap > SeqNodeMap
Definition: TauTrackRNNClassifier.h:45
xAOD::TauJet_v3::ptIntermediateAxis
double ptIntermediateAxis() const
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
xAOD::TauJet_v3::tracks
std::vector< const TauTrack * > tracks(TauJetParameters::TauTrackFlag flag=TauJetParameters::TauTrackFlag::classifiedCharged) const
Get the v<const pointer> to a given tauTrack collection associated with this tau.
Definition: TauJet_v3.cxx:461
tauRecTools::TauTrackRNNClassifier::~TauTrackRNNClassifier
~TauTrackRNNClassifier()
Definition: TauTrackRNNClassifier.cxx:29
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
lwtDev::GraphConfig
Definition: lightweight_network_config.h:58
IDTPM::nSiHits
float nSiHits(const U &p)
Definition: TrackParametersHelper.h:427
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:238
tauRecTools::sortTracks
bool sortTracks(const ElementLink< xAOD::TauTrackContainer > &l1, const ElementLink< xAOD::TauTrackContainer > &l2)
Definition: Reconstruction/tauRecTools/Root/HelperFunctions.cxx:54
xAOD::TauJetParameters::unclassified
@ unclassified
Definition: TauDefs.h:410
Generated on Mon Sep 29 2025 21:19:38 for ATLAS Offline Software by   doxygen 1.8.18