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, 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, true));
108  }
109  }
110 
111  // classify tracks
112  for (auto classifier : m_vClassifier) {
113  ATH_CHECK(classifier->classifyTracks(vTracks, xTau, vertexContainer));
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  bool skipTracks) const
185 {
186  if(vTracks.empty()) {
187  return StatusCode::SUCCESS;
188  }
189 
190  static const SG::Accessor<float> idScoreCharged("rnn_chargedScore");
191  static const SG::Accessor<float> idScoreIso("rnn_isolationScore");
192  static const SG::Accessor<float> idScoreConv("rnn_conversionScore");
193  static const SG::Accessor<float> idScoreFake("rnn_fakeScore");
194 
195  // don't classify tracks, set default decorations
196  if(skipTracks) {
197  for(xAOD::TauTrack* track : vTracks) {
198  idScoreCharged(*track) = 0.;
199  idScoreConv(*track) = 0.;
200  idScoreIso(*track) = 0.;
201  idScoreFake(*track) = 0.;
202  }
203  return StatusCode::SUCCESS;
204  }
205 
206  std::sort(vTracks.begin(), vTracks.end(), [](const xAOD::TauTrack * a, const xAOD::TauTrack * b) {return a->pt() > b->pt();});
207 
208  VectorMap valueMap;
209  ATH_CHECK(calculateVars(vTracks, xTau, vertexContainer, valueMap));
210 
211  SeqNodeMap seqInput;
212  NodeMap nodeInput;
213 
214  seqInput["input_1"] = valueMap;
215 
216  VectorMap mValue = m_RNNClassifier->scan(nodeInput, seqInput, "time_distributed_2");
217 
218  std::vector<double> vClassProb(5);
219 
220  for (unsigned int i = 0; i < vTracks.size(); ++i){
221 
222  if(i >= m_nMaxNtracks && m_nMaxNtracks > 0){
223  vClassProb[0] = 0.0;
224  vClassProb[1] = 0.0;
225  vClassProb[2] = 0.0;
226  vClassProb[3] = 0.0;
227  vClassProb[4] = 1.0;
228  }else{
229  vClassProb[0] = mValue["type_0"][i];
230  vClassProb[1] = mValue["type_1"][i];
231  vClassProb[2] = mValue["type_2"][i];
232  vClassProb[3] = mValue["type_3"][i];
233  vClassProb[4] = 0.0;
234  }
235 
236  idScoreCharged(*vTracks[i]) = vClassProb[0];
237  idScoreConv(*vTracks[i]) = vClassProb[1];
238  idScoreIso(*vTracks[i]) = vClassProb[2];
239  idScoreFake(*vTracks[i]) = vClassProb[3];
240 
241  int iMaxIndex = 0;
242  for (unsigned int j = 1; j < vClassProb.size(); ++j){
243  if(vClassProb[j] > vClassProb[iMaxIndex]) iMaxIndex = j;
244  }
245 
246  if(iMaxIndex < 4) {
247  vTracks[i]->setFlag(xAOD::TauJetParameters::unclassified, false);
248  }
249 
250  if(iMaxIndex == 3){
251  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedFake, true);
252  }else if(iMaxIndex == 0){
253  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedCharged, true);
254  }else if(iMaxIndex == 1){
255  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedConversion, true);
256  }else if(iMaxIndex == 2){
257  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedIsolation, true);
258  }
259  }
260 
261  return StatusCode::SUCCESS;
262 }
263 
264 
265 //______________________________________________________________________________
266 StatusCode TrackRNN::calculateVars(const std::vector<xAOD::TauTrack*>& vTracks,
267  const xAOD::TauJet& xTau,
268  const xAOD::VertexContainer* vertexContainer,
269  tauRecTools::VectorMap& valueMap) const
270 {
271  // initialize map with values
272  valueMap.clear();
273  unsigned int n_timeSteps = vTracks.size();
274  if(m_nMaxNtracks > 0 && n_timeSteps > m_nMaxNtracks) {
275  n_timeSteps = m_nMaxNtracks;
276  }
277 
278  valueMap["log(trackPt)"] = std::vector<double>(n_timeSteps);
279  valueMap["log(jetSeedPt)"] = std::vector<double>(n_timeSteps);
280  valueMap["trackPt/tauPtIntermediateAxis"] = std::vector<double>(n_timeSteps);
281  valueMap["trackEta"] = std::vector<double>(n_timeSteps);
282  valueMap["z0sinthetaTJVA"] = std::vector<double>(n_timeSteps);
283  valueMap["z0sinthetaSigTJVA"] = std::vector<double>(n_timeSteps);
284  valueMap["log(rConv)"] = std::vector<double>(n_timeSteps);
285  valueMap["tanh(rConvII/500)"] = std::vector<double>(n_timeSteps);
286  valueMap["dRJetSeedAxis"] = std::vector<double>(n_timeSteps);
287  valueMap["dRIntermediateAxis"] = std::vector<double>(n_timeSteps);
288  valueMap["tanh(d0SigTJVA/10)"] = std::vector<double>(n_timeSteps);
289  valueMap["tanh(d0TJVA/10)"] = std::vector<double>(n_timeSteps);
290  valueMap["qOverP*1000"] = std::vector<double>(n_timeSteps);
291  valueMap["numberOfInnermostPixelLayerHits"] = std::vector<double>(n_timeSteps);
292  valueMap["numberOfPixelSharedHits"] = std::vector<double>(n_timeSteps);
293  valueMap["numberOfSCTSharedHits"] = std::vector<double>(n_timeSteps);
294  valueMap["numberOfTRTHits"] = std::vector<double>(n_timeSteps);
295  valueMap["eProbabilityHT"] = std::vector<double>(n_timeSteps);
296  valueMap["nPixHits"] = std::vector<double>(n_timeSteps);
297  valueMap["nSCTHits"] = std::vector<double>(n_timeSteps);
298  valueMap["dz0_TV_PV0"] = std::vector<double>(n_timeSteps);
299  valueMap["log_sumpt_TV"] = std::vector<double>(n_timeSteps);
300  valueMap["log_sumpt2_TV"] = std::vector<double>(n_timeSteps);
301  valueMap["log_sumpt_PV0"] = std::vector<double>(n_timeSteps);
302  valueMap["log_sumpt2_PV0"] = std::vector<double>(n_timeSteps);
303  valueMap["charge"] = std::vector<double>(n_timeSteps);
304  // used by RNN track classifier for upgrade
305  valueMap["(trackPt/jetSeedPt)"] = std::vector<double>(n_timeSteps);
306  valueMap["numberOfInnermostPixelLayerEndcapHits"] = std::vector<double>(n_timeSteps);
307  valueMap["nSiHits"] = std::vector<double>(n_timeSteps);
308 
309  // tau variable
310  double log_ptJetSeed = std::log( xTau.ptJetSeed() );
311 
312  // vertex variables
313  double dz0_TV_PV0 = 0., sumpt_TV = 0., sumpt2_TV = 0., sumpt_PV0 = 0., sumpt2_PV0 = 0.;
314  if(vertexContainer != nullptr && !vertexContainer->empty() && xTau.vertex()!=nullptr) {
315  dz0_TV_PV0 = xTau.vertex()->z() - vertexContainer->at(0)->z();
316 
317  for (const ElementLink<xAOD::TrackParticleContainer>& trk : vertexContainer->at(0)->trackParticleLinks()) {
318  sumpt_PV0 += (*trk)->pt();
319  sumpt2_PV0 += pow((*trk)->pt(), 2.);
320  }
321  for (const ElementLink<xAOD::TrackParticleContainer>& trk : xTau.vertex()->trackParticleLinks()) {
322  sumpt_TV += (*trk)->pt();
323  sumpt2_TV += pow((*trk)->pt(), 2.);
324  }
325  }
326 
327  double log_sumpt_TV = (sumpt_TV>0.) ? std::log(sumpt_TV) : 0.;
328  double log_sumpt2_TV = (sumpt2_TV>0.) ? std::log(sumpt2_TV) : 0.;
329  double log_sumpt_PV0 = (sumpt_PV0>0.) ? std::log(sumpt_PV0) : 0.;
330  double log_sumpt2_PV0 = (sumpt2_PV0>0.) ? std::log(sumpt2_PV0) : 0.;
331 
332  // track variables
333  unsigned int i = 0;
334 
335  for(xAOD::TauTrack* xTrack : vTracks)
336  {
337  const xAOD::TrackParticle* xTrackParticle = xTrack->track();
338 
339  uint8_t numberOfInnermostPixelLayerHits = 0; ATH_CHECK( xTrackParticle->summaryValue(numberOfInnermostPixelLayerHits, xAOD::numberOfInnermostPixelLayerHits) );
340  uint8_t nPixelHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelHits, xAOD::numberOfPixelHits) );
341  uint8_t nPixelSharedHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelSharedHits, xAOD::numberOfPixelSharedHits) );
342  uint8_t nPixelDeadSensors = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelDeadSensors, xAOD::numberOfPixelDeadSensors) );
343  uint8_t nSCTHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTHits, xAOD::numberOfSCTHits) );
344  uint8_t nSCTSharedHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTSharedHits, xAOD::numberOfSCTSharedHits) );
345  uint8_t nSCTDeadSensors = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTDeadSensors, xAOD::numberOfSCTDeadSensors) );
346  uint8_t nTRTHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nTRTHits, xAOD::numberOfTRTHits) );
347  float eProbabilityHT; ATH_CHECK( xTrackParticle->summaryValue( eProbabilityHT, xAOD::eProbabilityHT) );
348 
349  // used by RNN track classifier for upgrade
350  uint8_t numberOfInnermostPixelLayerEndcapHits = 0;
351  uint8_t tmp_var = 0;
352  if(xTrackParticle->summaryValue(tmp_var, xAOD::numberOfInnermostPixelLayerEndcapHits) ){
353  numberOfInnermostPixelLayerEndcapHits = tmp_var;
354  }
355  uint8_t nSiHits = nPixelHits + nPixelDeadSensors + nSCTHits + nSCTDeadSensors;
356 
357  valueMap["log(trackPt)"][i] = std::log( xTrackParticle->pt() );
358  valueMap["log(jetSeedPt)"][i] = log_ptJetSeed;
359  valueMap["trackPt/tauPtIntermediateAxis"][i] = xTrackParticle->pt()/xTau.ptIntermediateAxis();
360  valueMap["trackEta"][i] = xTrackParticle->eta();
361  valueMap["z0sinthetaTJVA"][i] = xTrack->z0sinthetaTJVA();
362  valueMap["z0sinthetaSigTJVA"][i] = xTrack->z0sinthetaSigTJVA();
363  valueMap["log(rConv)"][i] = std::log( xTrack->rConv() );
364  valueMap["tanh(rConvII/500)"][i] = std::tanh( xTrack->rConvII()/500. );
365  // there is no seed jets in AOD so dRJetSeedAxis wont work
366  valueMap["dRJetSeedAxis"][i] = xTrack->p4().DeltaR(xTau.p4(xAOD::TauJetParameters::JetSeed));
367  valueMap["dRIntermediateAxis"][i] = xTrack->p4().DeltaR( xTau.p4(xAOD::TauJetParameters::IntermediateAxis) );
368  valueMap["tanh(d0SigTJVA/10)"][i] = std::tanh( xTrack->d0SigTJVA()/10. );
369  valueMap["tanh(d0TJVA/10)"][i] = std::tanh( xTrack->d0TJVA()/10. );
370  valueMap["qOverP*1000"][i] = xTrackParticle->qOverP()*1000.;
371  valueMap["numberOfInnermostPixelLayerHits"][i] = numberOfInnermostPixelLayerHits;
372  valueMap["numberOfPixelSharedHits"][i] = nPixelSharedHits;
373  valueMap["numberOfSCTSharedHits"][i] = nSCTSharedHits;
374  valueMap["numberOfTRTHits"][i] = nTRTHits;
375  valueMap["eProbabilityHT"][i] = eProbabilityHT;
376  valueMap["nPixHits"][i] = nPixelHits + nPixelDeadSensors;
377  valueMap["nSCTHits"][i] = nSCTHits + nSCTDeadSensors;
378  valueMap["dz0_TV_PV0"][i] = dz0_TV_PV0;
379  valueMap["log_sumpt_TV"][i] = log_sumpt_TV;
380  valueMap["log_sumpt2_TV"][i] = log_sumpt2_TV;
381  valueMap["log_sumpt_PV0"][i] = log_sumpt_PV0;
382  valueMap["log_sumpt2_PV0"][i] = log_sumpt2_PV0;
383  valueMap["charge"][i] = xTrackParticle->charge();
384  // used by RNN track classifier for upgrade
385  valueMap["(trackPt/jetSeedPt)"][i] = xTrackParticle->pt()/xTau.ptJetSeed();
386  valueMap["numberOfInnermostPixelLayerEndcapHits"][i] = numberOfInnermostPixelLayerEndcapHits;
387  valueMap["nSiHits"][i] = nSiHits;
388 
389  ++i;
390  if(m_nMaxNtracks > 0 && i >= m_nMaxNtracks) {
391  break;
392  }
393  }
394 
395  return StatusCode::SUCCESS;
396 }
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
tauRecTools::NodeMap
std::map< std::string, ValueMap > NodeMap
Definition: TauTrackRNNClassifier.h:44
TauGNNUtils::Variables::Track::log_sumpt2_TV
bool log_sumpt2_TV(const xAOD::TauJet &tau, const xAOD::TauTrack &, double &out)
Definition: TauGNNUtils.cxx:792
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
TauGNNUtils::Variables::Track::log_sumpt_PV0
bool log_sumpt_PV0(const xAOD::TauJet &tau, const xAOD::TauTrack &, double &out)
Definition: TauGNNUtils.cxx:798
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.
TauGNNUtils::Variables::Track::dz0_TV_PV0
bool dz0_TV_PV0(const xAOD::TauJet &tau, const xAOD::TauTrack &, double &out)
Definition: TauGNNUtils.cxx:780
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
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
tauRecTools::TrackRNN::classifyTracks
StatusCode classifyTracks(std::vector< xAOD::TauTrack * > &vTracks, xAOD::TauJet &xTau, const xAOD::VertexContainer *vertexContainer, bool skipTracks=false) const
Definition: TauTrackRNNClassifier.cxx:181
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
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:109
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:266
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
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:106
tauRecTools::TauTrackRNNClassifier::TauTrackRNNClassifier
TauTrackRNNClassifier(const std::string &name="TauTrackRNNClassifier")
Definition: TauTrackRNNClassifier.cxx:24
TauGNNUtils::Variables::Track::log_sumpt_TV
bool log_sumpt_TV(const xAOD::TauJet &tau, const xAOD::TauTrack &, double &out)
Definition: TauGNNUtils.cxx:786
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:107
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
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:986
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
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
TauGNNUtils::Variables::Track::log_sumpt2_PV0
bool log_sumpt2_PV0(const xAOD::TauJet &tau, const xAOD::TauTrack &, double &out)
Definition: TauGNNUtils.cxx:804
Generated on Tue Sep 2 2025 21:21:55 for ATLAS Offline Software by   doxygen 1.8.18