ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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  declareProperty("classifyLRT", m_classifyLRT = true);
27 }
28 
29 //______________________________________________________________________________
30 TauTrackRNNClassifier::~TauTrackRNNClassifier()
31 {
32 }
33 
34 //______________________________________________________________________________
35 StatusCode TauTrackRNNClassifier::initialize()
36 {
37  for (const auto& classifier : m_vClassifier){
38  ATH_MSG_INFO("Intialize TauTrackRNNClassifier tool : " << classifier );
39  ATH_CHECK(classifier.retrieve());
40  }
41 
42  ATH_CHECK( m_vertexContainerKey.initialize() );
43 
44  return StatusCode::SUCCESS;
45 }
46 
47 //______________________________________________________________________________
48 StatusCode TauTrackRNNClassifier::executeTrackClassifier(xAOD::TauJet& xTau, xAOD::TauTrackContainer& tauTrackCon) const {
49 
50  SG::ReadHandle<xAOD::VertexContainer> vertexInHandle( m_vertexContainerKey );
51  if (!vertexInHandle.isValid()) {
52  ATH_MSG_ERROR ("Could not retrieve HiveDataObj with key " << vertexInHandle.key());
53  return StatusCode::FAILURE;
54  }
55  const xAOD::VertexContainer* vertexContainer = vertexInHandle.cptr();
56 
57  std::vector<xAOD::TauTrack*> vTracks = xAOD::TauHelpers::allTauTracksNonConst(&xTau, &tauTrackCon);
58 
59  for (xAOD::TauTrack* xTrack : vTracks) {
60  // reset all track flags and set status to unclassified
61  xTrack->setFlag(xAOD::TauJetParameters::classifiedCharged, false);
62  xTrack->setFlag(xAOD::TauJetParameters::classifiedConversion, false);
63  xTrack->setFlag(xAOD::TauJetParameters::classifiedIsolation, false);
64  xTrack->setFlag(xAOD::TauJetParameters::classifiedFake, false);
65  xTrack->setFlag(xAOD::TauJetParameters::unclassified, true);
66  }
67 
68  // don't classify LRTs even if LRTs were associated with taus in TauTrackFinder
69  if(!m_classifyLRT) {
70  std::vector<xAOD::TauTrack*> vLRTs;
71  std::vector<xAOD::TauTrack*>::iterator it = vTracks.begin();
72  while(it != vTracks.end()) {
73  if((*it)->flag(xAOD::TauJetParameters::LargeRadiusTrack)) {
74  vLRTs.push_back(*it);
75  it = vTracks.erase(it);
76  }
77  else {
78  ++it;
79  }
80  }
81 
82  // decorate LRTs with default RNN scores
83  for (auto classifier : m_vClassifier) {
84  ATH_CHECK(classifier->classifyTracks(vLRTs, xTau, vertexContainer, true));
85  }
86  }
87 
88  // classify tracks
89  for (auto classifier : m_vClassifier) {
90  ATH_CHECK(classifier->classifyTracks(vTracks, xTau, vertexContainer));
91  }
92 
93  std::vector< ElementLink< xAOD::TauTrackContainer > >& tauTrackLinks(xTau.allTauTrackLinksNonConst());
94  std::sort(tauTrackLinks.begin(), tauTrackLinks.end(), sortTracks);
95  float charge=0.0;
96  for( const xAOD::TauTrack* trk : xTau.tracks(xAOD::TauJetParameters::classifiedCharged) ){
97  charge += trk->track()->charge();
98  }
99  xTau.setCharge(charge);
100  xTau.setDetail(xAOD::TauJetParameters::nChargedTracks, (int) xTau.nTracks());
101  xTau.setDetail(xAOD::TauJetParameters::nIsolatedTracks, (int) xTau.nTracks(xAOD::TauJetParameters::classifiedIsolation));
102 
103  // decorations for now, may be turned into Aux
104  static const SG::Accessor<int> nTrkConv("nConversionTracks");
105  static const SG::Accessor<int> nTrkFake("nFakeTracks");
106  nTrkConv(xTau) = (int) xTau.nTracks(xAOD::TauJetParameters::classifiedConversion);
107  nTrkFake(xTau) = (int) xTau.nTracks(xAOD::TauJetParameters::classifiedFake);
108 
109  //set modifiedIsolationTrack
110  for (xAOD::TauTrack* xTrack : vTracks) {
111  if( not xTrack->flag(xAOD::TauJetParameters::classifiedCharged) and xTrack->flag(xAOD::TauJetParameters::passTrkSelector) ) {
112  xTrack->setFlag(xAOD::TauJetParameters::modifiedIsolationTrack, true);
113  }
114  else {
115  xTrack->setFlag(xAOD::TauJetParameters::modifiedIsolationTrack, false);
116  }
117  }
118  xTau.setDetail(xAOD::TauJetParameters::nModifiedIsolationTracks, (int) xTau.nTracks(xAOD::TauJetParameters::modifiedIsolationTrack));
119 
120  return StatusCode::SUCCESS;
121 }
122 
123 //==============================================================================
124 // class TrackRNN
125 //==============================================================================
126 
127 //______________________________________________________________________________
128 TrackRNN::TrackRNN(const std::string& name)
129  : TauRecToolBase(name)
130  , m_inputWeightsPath("")
131 {
132  declareProperty("InputWeightsPath", m_inputWeightsPath = "");
133  declareProperty("MaxNtracks", m_nMaxNtracks = 0);
134 }
135 
136 //______________________________________________________________________________
137 TrackRNN::~TrackRNN()
138 {
139 }
140 
141 //______________________________________________________________________________
142 StatusCode TrackRNN::initialize()
143 {
144  std::string inputWeightsPath = find_file(m_inputWeightsPath);
145  ATH_MSG_INFO("Using calibration file: " << inputWeightsPath);
146 
147  std::ifstream nn_config_istream(inputWeightsPath);
148 
149  lwtDev::GraphConfig NNconfig = lwtDev::parse_json_graph(nn_config_istream);
150 
151  m_RNNClassifier = std::make_unique<lwtDev::LightweightGraph>(NNconfig, NNconfig.outputs.begin()->first);
152  if(!m_RNNClassifier) {
153  ATH_MSG_FATAL("Couldn't configure neural network!");
154  return StatusCode::FAILURE;
155  }
156 
157  return StatusCode::SUCCESS;
158 }
159 
160 //______________________________________________________________________________
161 StatusCode TrackRNN::classifyTracks(std::vector<xAOD::TauTrack*>& vTracks,
162  xAOD::TauJet& xTau,
163  const xAOD::VertexContainer* vertexContainer,
164  bool skipTracks) const
165 {
166  if(vTracks.empty()) {
167  return StatusCode::SUCCESS;
168  }
169 
170  static const SG::Accessor<float> idScoreCharged("rnn_chargedScore");
171  static const SG::Accessor<float> idScoreIso("rnn_isolationScore");
172  static const SG::Accessor<float> idScoreConv("rnn_conversionScore");
173  static const SG::Accessor<float> idScoreFake("rnn_fakeScore");
174 
175  // don't classify tracks, set default decorations
176  if(skipTracks) {
177  for(xAOD::TauTrack* track : vTracks) {
178  idScoreCharged(*track) = 0.;
179  idScoreConv(*track) = 0.;
180  idScoreIso(*track) = 0.;
181  idScoreFake(*track) = 0.;
182  }
183  return StatusCode::SUCCESS;
184  }
185 
186  std::sort(vTracks.begin(), vTracks.end(), [](const xAOD::TauTrack * a, const xAOD::TauTrack * b) {return a->pt() > b->pt();});
187 
188  VectorMap valueMap;
189  ATH_CHECK(calculateVars(vTracks, xTau, vertexContainer, valueMap));
190 
191  SeqNodeMap seqInput;
192  NodeMap nodeInput;
193 
194  seqInput["input_1"] = valueMap;
195 
196  VectorMap mValue = m_RNNClassifier->scan(nodeInput, seqInput, "time_distributed_2");
197 
198  std::vector<double> vClassProb(5);
199 
200  for (unsigned int i = 0; i < vTracks.size(); ++i){
201 
202  if(i >= m_nMaxNtracks && m_nMaxNtracks > 0){
203  vClassProb[0] = 0.0;
204  vClassProb[1] = 0.0;
205  vClassProb[2] = 0.0;
206  vClassProb[3] = 0.0;
207  vClassProb[4] = 1.0;
208  }else{
209  vClassProb[0] = mValue["type_0"][i];
210  vClassProb[1] = mValue["type_1"][i];
211  vClassProb[2] = mValue["type_2"][i];
212  vClassProb[3] = mValue["type_3"][i];
213  vClassProb[4] = 0.0;
214  }
215 
216  idScoreCharged(*vTracks[i]) = vClassProb[0];
217  idScoreConv(*vTracks[i]) = vClassProb[1];
218  idScoreIso(*vTracks[i]) = vClassProb[2];
219  idScoreFake(*vTracks[i]) = vClassProb[3];
220 
221  int iMaxIndex = 0;
222  for (unsigned int j = 1; j < vClassProb.size(); ++j){
223  if(vClassProb[j] > vClassProb[iMaxIndex]) iMaxIndex = j;
224  }
225 
226  if(iMaxIndex < 4) {
227  vTracks[i]->setFlag(xAOD::TauJetParameters::unclassified, false);
228  }
229 
230  if(iMaxIndex == 3){
231  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedFake, true);
232  }else if(iMaxIndex == 0){
233  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedCharged, true);
234  }else if(iMaxIndex == 1){
235  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedConversion, true);
236  }else if(iMaxIndex == 2){
237  vTracks[i]->setFlag(xAOD::TauJetParameters::classifiedIsolation, true);
238  }
239  }
240 
241  return StatusCode::SUCCESS;
242 }
243 
244 
245 //______________________________________________________________________________
246 StatusCode TrackRNN::calculateVars(const std::vector<xAOD::TauTrack*>& vTracks,
247  const xAOD::TauJet& xTau,
248  const xAOD::VertexContainer* vertexContainer,
249  tauRecTools::VectorMap& valueMap) const
250 {
251  // initialize map with values
252  valueMap.clear();
253  unsigned int n_timeSteps = vTracks.size();
254  if(m_nMaxNtracks > 0 && n_timeSteps > m_nMaxNtracks) {
255  n_timeSteps = m_nMaxNtracks;
256  }
257 
258  valueMap["log(trackPt)"] = std::vector<double>(n_timeSteps);
259  valueMap["log(jetSeedPt)"] = std::vector<double>(n_timeSteps);
260  valueMap["trackPt/tauPtIntermediateAxis"] = std::vector<double>(n_timeSteps);
261  valueMap["trackEta"] = std::vector<double>(n_timeSteps);
262  valueMap["z0sinthetaTJVA"] = std::vector<double>(n_timeSteps);
263  valueMap["z0sinthetaSigTJVA"] = std::vector<double>(n_timeSteps);
264  valueMap["log(rConv)"] = std::vector<double>(n_timeSteps);
265  valueMap["tanh(rConvII/500)"] = std::vector<double>(n_timeSteps);
266  valueMap["dRJetSeedAxis"] = std::vector<double>(n_timeSteps);
267  valueMap["dRIntermediateAxis"] = std::vector<double>(n_timeSteps);
268  valueMap["tanh(d0SigTJVA/10)"] = std::vector<double>(n_timeSteps);
269  valueMap["tanh(d0TJVA/10)"] = std::vector<double>(n_timeSteps);
270  valueMap["qOverP*1000"] = std::vector<double>(n_timeSteps);
271  valueMap["numberOfInnermostPixelLayerHits"] = std::vector<double>(n_timeSteps);
272  valueMap["numberOfPixelSharedHits"] = std::vector<double>(n_timeSteps);
273  valueMap["numberOfSCTSharedHits"] = std::vector<double>(n_timeSteps);
274  valueMap["numberOfTRTHits"] = std::vector<double>(n_timeSteps);
275  valueMap["eProbabilityHT"] = std::vector<double>(n_timeSteps);
276  valueMap["nPixHits"] = std::vector<double>(n_timeSteps);
277  valueMap["nSCTHits"] = std::vector<double>(n_timeSteps);
278  valueMap["dz0_TV_PV0"] = std::vector<double>(n_timeSteps);
279  valueMap["log_sumpt_TV"] = std::vector<double>(n_timeSteps);
280  valueMap["log_sumpt2_TV"] = std::vector<double>(n_timeSteps);
281  valueMap["log_sumpt_PV0"] = std::vector<double>(n_timeSteps);
282  valueMap["log_sumpt2_PV0"] = std::vector<double>(n_timeSteps);
283  valueMap["charge"] = std::vector<double>(n_timeSteps);
284 
285  // tau variable
286  double log_ptJetSeed = std::log( xTau.ptJetSeed() );
287 
288  // vertex variables
289  double dz0_TV_PV0 = 0., sumpt_TV = 0., sumpt2_TV = 0., sumpt_PV0 = 0., sumpt2_PV0 = 0.;
290  if(vertexContainer != nullptr && !vertexContainer->empty() && xTau.vertex()!=nullptr) {
291  dz0_TV_PV0 = xTau.vertex()->z() - vertexContainer->at(0)->z();
292 
293  for (const ElementLink<xAOD::TrackParticleContainer>& trk : vertexContainer->at(0)->trackParticleLinks()) {
294  sumpt_PV0 += (*trk)->pt();
295  sumpt2_PV0 += pow((*trk)->pt(), 2.);
296  }
297  for (const ElementLink<xAOD::TrackParticleContainer>& trk : xTau.vertex()->trackParticleLinks()) {
298  sumpt_TV += (*trk)->pt();
299  sumpt2_TV += pow((*trk)->pt(), 2.);
300  }
301  }
302 
303  double log_sumpt_TV = (sumpt_TV>0.) ? std::log(sumpt_TV) : 0.;
304  double log_sumpt2_TV = (sumpt2_TV>0.) ? std::log(sumpt2_TV) : 0.;
305  double log_sumpt_PV0 = (sumpt_PV0>0.) ? std::log(sumpt_PV0) : 0.;
306  double log_sumpt2_PV0 = (sumpt2_PV0>0.) ? std::log(sumpt2_PV0) : 0.;
307 
308  // track variables
309  unsigned int i = 0;
310 
311  for(xAOD::TauTrack* xTrack : vTracks)
312  {
313  const xAOD::TrackParticle* xTrackParticle = xTrack->track();
314 
315  uint8_t numberOfInnermostPixelLayerHits = 0; ATH_CHECK( xTrackParticle->summaryValue(numberOfInnermostPixelLayerHits, xAOD::numberOfInnermostPixelLayerHits) );
316  uint8_t nPixelHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelHits, xAOD::numberOfPixelHits) );
317  uint8_t nPixelSharedHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelSharedHits, xAOD::numberOfPixelSharedHits) );
318  uint8_t nPixelDeadSensors = 0; ATH_CHECK( xTrackParticle->summaryValue(nPixelDeadSensors, xAOD::numberOfPixelDeadSensors) );
319  uint8_t nSCTHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTHits, xAOD::numberOfSCTHits) );
320  uint8_t nSCTSharedHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTSharedHits, xAOD::numberOfSCTSharedHits) );
321  uint8_t nSCTDeadSensors = 0; ATH_CHECK( xTrackParticle->summaryValue(nSCTDeadSensors, xAOD::numberOfSCTDeadSensors) );
322  uint8_t nTRTHits = 0; ATH_CHECK( xTrackParticle->summaryValue(nTRTHits, xAOD::numberOfTRTHits) );
323  float eProbabilityHT; ATH_CHECK( xTrackParticle->summaryValue( eProbabilityHT, xAOD::eProbabilityHT) );
324 
325  valueMap["log(trackPt)"][i] = std::log( xTrackParticle->pt() );
326  valueMap["log(jetSeedPt)"][i] = log_ptJetSeed;
327  valueMap["trackPt/tauPtIntermediateAxis"][i] = xTrackParticle->pt()/xTau.ptIntermediateAxis();
328  valueMap["trackEta"][i] = xTrackParticle->eta();
329  valueMap["z0sinthetaTJVA"][i] = xTrack->z0sinthetaTJVA();
330  valueMap["z0sinthetaSigTJVA"][i] = xTrack->z0sinthetaSigTJVA();
331  valueMap["log(rConv)"][i] = std::log( xTrack->rConv() );
332  valueMap["tanh(rConvII/500)"][i] = std::tanh( xTrack->rConvII()/500. );
333  // there is no seed jets in AOD so dRJetSeedAxis wont work
334  valueMap["dRJetSeedAxis"][i] = xTrack->p4().DeltaR(xTau.p4(xAOD::TauJetParameters::JetSeed));
335  valueMap["dRIntermediateAxis"][i] = xTrack->p4().DeltaR( xTau.p4(xAOD::TauJetParameters::IntermediateAxis) );
336  valueMap["tanh(d0SigTJVA/10)"][i] = std::tanh( xTrack->d0SigTJVA()/10. );
337  valueMap["tanh(d0TJVA/10)"][i] = std::tanh( xTrack->d0TJVA()/10. );
338  valueMap["qOverP*1000"][i] = xTrackParticle->qOverP()*1000.;
339  valueMap["numberOfInnermostPixelLayerHits"][i] = (double) numberOfInnermostPixelLayerHits;
340  valueMap["numberOfPixelSharedHits"][i] = (double) nPixelSharedHits;
341  valueMap["numberOfSCTSharedHits"][i] = (double) nSCTSharedHits;
342  valueMap["numberOfTRTHits"][i] = (double) nTRTHits;
343  valueMap["eProbabilityHT"][i] = eProbabilityHT;
344  valueMap["nPixHits"][i] = (double) (nPixelHits + nPixelDeadSensors);
345  valueMap["nSCTHits"][i] = (double) (nSCTHits + nSCTDeadSensors);
346  valueMap["dz0_TV_PV0"][i] = dz0_TV_PV0;
347  valueMap["log_sumpt_TV"][i] = log_sumpt_TV;
348  valueMap["log_sumpt2_TV"][i] = log_sumpt2_TV;
349  valueMap["log_sumpt_PV0"][i] = log_sumpt_PV0;
350  valueMap["log_sumpt2_PV0"][i] = log_sumpt2_PV0;
351  valueMap["charge"][i] = xTrackParticle->charge();
352 
353  ++i;
354  if(m_nMaxNtracks > 0 && i >= m_nMaxNtracks) {
355  break;
356  }
357  }
358 
359  return StatusCode::SUCCESS;
360 }
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
tauRecTools::NodeMap
std::map< std::string, ValueMap > NodeMap
Definition: TauTrackRNNClassifier.h:43
TauGNNUtils::Variables::Track::log_sumpt2_TV
bool log_sumpt2_TV(const xAOD::TauJet &tau, const xAOD::TauTrack &, double &out)
Definition: TauGNNUtils.cxx:781
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
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:787
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
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:150
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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:77
tauRecTools::TauTrackRNNClassifier::m_vertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexContainerKey
Definition: TauTrackRNNClassifier.h:65
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:769
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
xAOD::TauJet_v3::nTracks
size_t nTracks(TauJetParameters::TauTrackFlag flag=TauJetParameters::TauTrackFlag::classifiedCharged) const
Definition: TauJet_v3.cxx:526
xAOD::TauJetParameters::nModifiedIsolationTracks
@ nModifiedIsolationTracks
Definition: TauDefs.h:324
xAOD::TauJetParameters::classifiedCharged
@ classifiedCharged
Definition: TauDefs.h:406
skel.it
it
Definition: skel.GENtoEVGEN.py:401
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:41
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:161
xAOD::TauJet_v3::ptJetSeed
double ptJetSeed() const
tauRecTools::TauTrackRNNClassifier::m_vClassifier
ToolHandleArray< TrackRNN > m_vClassifier
Definition: TauTrackRNNClassifier.h:63
xAOD::TauJetParameters::LargeRadiusTrack
@ LargeRadiusTrack
Definition: TauDefs.h:413
tauRecTools::TauTrackRNNClassifier::m_classifyLRT
bool m_classifyLRT
Definition: TauTrackRNNClassifier.h:67
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:107
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:142
xAOD::TauHelpers::allTauTracksNonConst
std::vector< xAOD::TauTrack * > allTauTracksNonConst(const xAOD::TauJet *tau, xAOD::TauTrackContainer *trackCont)
Definition: TauxAODHelpers.cxx:85
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:246
tauRecTools::TauTrackRNNClassifier::initialize
virtual StatusCode initialize() override
Tool initializer.
Definition: TauTrackRNNClassifier.cxx:35
xAOD::TauJetParameters::passTrkSelector
@ passTrkSelector
Definition: TauDefs.h:405
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
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
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:775
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::Vertex_v1::z
float z() const
Returns the z position.
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
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:446
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:228
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
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:897
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
TrackParticle.h
lwtDev::parse_json_graph
GraphConfig parse_json_graph(std::istream &json)
Definition: parse_json.cxx:71
tauRecTools::TrackRNN::m_inputWeightsPath
std::string m_inputWeightsPath
Definition: TauTrackRNNClassifier.h:104
a
TList * a
Definition: liststreamerinfos.cxx:10
IDTPM::nPixelSharedHits
float nPixelSharedHits(const U &p)
Definition: TrackParametersHelper.h:374
tauRecTools::TrackRNN::m_nMaxNtracks
unsigned int m_nMaxNtracks
Definition: TauTrackRNNClassifier.h:105
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:97
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:337
tauRecTools::TauTrackRNNClassifier::executeTrackClassifier
virtual StatusCode executeTrackClassifier(xAOD::TauJet &pTau, xAOD::TauTrackContainer &tauTrackContainer) const override
Definition: TauTrackRNNClassifier.cxx:48
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::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:805
tauRecTools
Implementation of a TrackClassifier based on an RNN.
Definition: BDTHelper.cxx:12
tauRecTools::SeqNodeMap
std::map< std::string, VectorMap > SeqNodeMap
Definition: TauTrackRNNClassifier.h:44
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:493
tauRecTools::TauTrackRNNClassifier::~TauTrackRNNClassifier
~TauTrackRNNClassifier()
Definition: TauTrackRNNClassifier.cxx:30
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
lwtDev::GraphConfig
Definition: lightweight_network_config.h:58
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:793
Generated on Mon Mar 17 2025 21:19:34 for ATLAS Offline Software by   doxygen 1.8.18