ATLAS Offline Software
Loading...
Searching...
No Matches
TauJet.icc
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3*/
4
5///@file TauCommonDetails.icc
6///
7/// Inline function implementations for tau event details class
8///
9///Package: Reconstruction/TauEvent
10///
11///@author Thomas Burgess <tburgess-at-cern-ch>
12///
13/// Created by Thomas Burgess on 2009-01-17.
14///
15/// $Id: TauJet.icc,v 1.7 2009-03-11 15:50:06 tburgess Exp $
16
17namespace Analysis
18{
19 inline bool TauJet::operator!=( const TauJet& rhs ) const
20 {
21 return !((*this)==rhs);
22 }
23
24 // Implementation of calorimetry info accessors
25 inline const CaloCluster *TauJet::cluster() const
26 {
27 return ( (m_cluster.isValid()) ? (*m_cluster) : 0 );
28 }
29
30 inline void TauJet::setCluster( const CaloClusterContainer *cont,
31 const CaloCluster *clust )
32 {
33 if( m_cluster.isValid() )
34 m_cluster.reset();
35 m_cluster.toContainedElement( *cont, clust);
36 }
37
38 inline const ElementLink<CaloClusterContainer> TauJet::clusterLink() const
39 {
40 return m_cluster;
41 }
42
43 inline ElementLink<CaloClusterContainer> &TauJet::clusterLink()
44 {
45 return m_cluster;
46 }
47
48 inline void TauJet::setClusterLink(
49 const ElementLink<CaloClusterContainer> &x)
50 {
51 m_cluster = x;
52 }
53
54 inline const CaloCluster *TauJet::cellCluster() const
55 {
56 return ( (m_cellCluster.isValid()) ? (*m_cellCluster) : 0 );
57 }
58
59 inline void TauJet::setCellCluster( const CaloClusterContainer *cont,
60 const CaloCluster *clust )
61 {
62 if( m_cellCluster.isValid() )
63 m_cellCluster.reset();
64 m_cellCluster.toContainedElement( *cont, clust);
65 }
66
67 inline const ElementLink<CaloClusterContainer>
68 TauJet::cellClusterLink() const
69 {
70 return m_cellCluster;
71 }
72
73 inline ElementLink<CaloClusterContainer> &TauJet::cellClusterLink()
74 {
75 return m_cellCluster;
76 }
77
78 inline void TauJet::setCellClusterLink(
79 const ElementLink<CaloClusterContainer> &x)
80 {
81 m_cellCluster = x;
82 }
83
84 // Jet accessors
85 inline const Jet *TauJet::jet() const
86 {
87 return ( (m_jet.isValid()) ? (*m_jet) : 0 );
88 }
89
90 inline void TauJet::setJet(
91 const JetCollection *cont,
92 const Jet *jet )
93 {
94 if( m_jet.isValid() )
95 m_jet.reset();
96 m_jet.toContainedElement( *cont, jet );
97 }
98
99 inline const ElementLink<JetCollection> TauJet::jetLink() const
100 {
101 return m_jet;
102 }
103
104 inline ElementLink<JetCollection> &TauJet::jetLink()
105 {
106 return m_jet;
107 }
108
109 inline void TauJet::setJetLink( const ElementLink<JetCollection> &x)
110 {
111 m_jet = x;
112 }
113
114 // Implementation of tracking info accessors
115 inline const Rec::TrackParticle *TauJet::track( unsigned int i ) const
116 {
117 if( m_tracks.size() <= i )
118 return 0;
119 else if( m_tracks[i].isValid() )
120 return *(m_tracks[i]);
121 else
122 return 0;
123 }
124
125 inline const ElementLinkVector<Rec::TrackParticleContainer>&
126 TauJet::trackLinkVector() const
127 {
128 return m_tracks;
129 }
130
131 inline ElementLinkVector<Rec::TrackParticleContainer>&
132 TauJet::trackLinkVector()
133 {
134 return m_tracks;
135 }
136
137 inline void TauJet::addTrack(
138 const Rec::TrackParticleContainer *cont,
139 const Rec::TrackParticle *track )
140 {
141 ElementLink<Rec::TrackParticleContainer> link;
142 link.toContainedElement( *cont, track ) ;
143 m_tracks.push_back( link ) ;
144 }
145
146 inline void TauJet::clearTracks()
147 {
148 return m_tracks.clear();
149 }
150
151 inline unsigned int TauJet::numTrack() const
152 {
153 return m_tracks.size();
154 }
155
156 //Implementation of conversion track accessors
157 inline const Rec :: TrackParticle * TauJet::conversionTrack(
158 unsigned int i ) const
159 {
160 if( m_conversionTracks.size() <= i )
161 return 0;
162 if( m_conversionTracks[i].isValid() )
163 return *(m_conversionTracks[i]);
164 return 0;
165 }
166
167 inline unsigned int TauJet::numConversionTrack() const
168 {
169 return m_conversionTracks.size();
170 }
171
172 inline const ElementLinkVector<Rec::TrackParticleContainer>&
173 TauJet::conversionTrackLinkVector() const
174 {
175 return m_conversionTracks;
176 }
177
178 inline ElementLinkVector<Rec::TrackParticleContainer>&
179 TauJet::conversionTrackLinkVector()
180 {
181 return m_conversionTracks;
182 }
183
184 inline void TauJet::addConversionTrack(
185 const Rec::TrackParticleContainer *cont,
186 const Rec::TrackParticle *track )
187 {
188 ElementLink<Rec::TrackParticleContainer> link;
189 link.toContainedElement( *cont, track ) ;
190 m_conversionTracks.push_back( link ) ;
191 }
192
193 inline void TauJet::clearConversionTracks()
194 {
195 return m_conversionTracks.clear();
196 }
197
198 inline int TauJet::nProng() const
199 {
200 return m_tracks.size()-m_conversionTracks.size();
201 }
202
203 inline bool TauJet::isConversionTrack(
204 unsigned int i) const
205 {
206 if (m_tracks.size()<=i) return false;
207 return find (
208 m_conversionTracks.begin(),
209 m_conversionTracks.end(),
210 m_tracks[i] ) != m_conversionTracks.end();
211 }
212
213 // Implementation of seed calo tracking info accessors
214 inline const Rec::TrackParticle *TauJet::seedTrk_track( unsigned int i ) const
215 {
216 if( m_seedTrk_tracks.size() <= i )
217 return 0;
218 else if( m_seedTrk_tracks[i].isValid() )
219 return *(m_seedTrk_tracks[i]);
220 else
221 return 0;
222 }
223
224 inline const ElementLinkVector<Rec::TrackParticleContainer>&
225 TauJet::seedTrk_trackLinkVector() const
226 {
227 return m_seedTrk_tracks;
228 }
229
230 inline ElementLinkVector<Rec::TrackParticleContainer>&
231 TauJet::seedTrk_trackLinkVector()
232 {
233 return m_seedTrk_tracks;
234 }
235
236 inline void TauJet::addSeedTrk_track(
237 const Rec::TrackParticleContainer *cont,
238 const Rec::TrackParticle *track )
239 {
240 ElementLink<Rec::TrackParticleContainer> link;
241 link.toContainedElement( *cont, track ) ;
242 m_seedTrk_tracks.push_back( link ) ;
243 }
244
245 inline void TauJet::clearSeedTrk_tracks()
246 {
247 return m_seedTrk_tracks.clear();
248 }
249
250 inline unsigned int TauJet::seedTrk_numTrack() const
251 {
252 return m_seedTrk_tracks.size();
253 }
254
255 // Implementation of seed calo tracking info accessors
256 inline const Rec::TrackParticle *TauJet::seedCalo_track( unsigned int i ) const
257 {
258 if( m_seedCalo_tracks.size() <= i )
259 return 0;
260 else if( m_seedCalo_tracks[i].isValid() )
261 return *(m_seedCalo_tracks[i]);
262 else
263 return 0;
264 }
265
266 inline const ElementLinkVector<Rec::TrackParticleContainer>&
267 TauJet::seedCalo_trackLinkVector() const
268 {
269 return m_seedCalo_tracks;
270 }
271
272 inline ElementLinkVector<Rec::TrackParticleContainer>&
273 TauJet::seedCalo_trackLinkVector()
274 {
275 return m_seedCalo_tracks;
276 }
277
278 inline void TauJet::addSeedCalo_track(
279 const Rec::TrackParticleContainer *cont,
280 const Rec::TrackParticle *track )
281 {
282 ElementLink<Rec::TrackParticleContainer> link;
283 link.toContainedElement( *cont, track ) ;
284 m_seedCalo_tracks.push_back( link ) ;
285 }
286
287 inline void TauJet::clearSeedCalo_tracks()
288 {
289 return m_seedCalo_tracks.clear();
290 }
291
292 inline unsigned int TauJet::seedCalo_numTrack() const
293 {
294 return m_seedCalo_tracks.size();
295 }
296
297
298
299 // Accessors for identification info
300 inline TauPID *TauJet::tauID()
301 {
302 return m_tauID;
303 }
304
305 inline const TauPID *TauJet::tauID() const
306 {
307 return m_tauID;
308 }
309
310 inline void TauJet::setTauID( TauPID *tauID )
311 {
312 delete m_tauID;
313 m_tauID = tauID;
314 }
315
316 // Accessors for detail classes
317 inline void TauJet::addDetails( const TauDetailsContainer *container,
318 TauDetails *details )
319 {
320 ElementLink<TauDetailsContainer> p_link;
321 p_link.toContainedElement( *container, details );
322 m_tauDetails.push_back( p_link );
323 }
324
325 // Author accessors
326 inline TauJetParameters::Author TauJet::author() const
327 {
328 return TauJetParameters::unknown;
329 }
330
331 inline bool TauJet::hasAuthor(
332 const TauJetParameters::Author &author ) const
333 {
334 return m_author.test( author );
335 }
336
337 inline void TauJet::setAuthor( const TauJetParameters::Author &author )
338 {
339 m_author.set( author ); // enum used as size_t
340 }
341
342 inline void TauJet::clearAuthor( const TauJetParameters::Author &author )
343 {
344 m_author.reset( author ); // enum used as size_t
345 }
346
347 // Independent number of tracks accessors
348 inline unsigned int TauJet::numberOfTracks() const
349 {
350 return m_numberOfTracks;
351 }
352
353 inline void TauJet::setNumberOfTracks( unsigned int numberOfTracks )
354 {
355 m_numberOfTracks = numberOfTracks;
356 }
357
358 inline void TauJet::setROIWord( unsigned int RoiWord )
359 {
360 m_roiWord = RoiWord;
361 }
362
363 inline unsigned int TauJet::ROIWord() const
364 {
365 return m_roiWord;
366 }
367
368 template <typename T> const T *TauJet::details(
369 const std::string &name ) const
370 {
371 const unsigned int p_size = m_tauDetails.size();
372 for( unsigned int i = 0; i != p_size; ++i ) {
373 if (!m_tauDetails[i].isValid()) continue;
374 const TauDetails *details = *m_tauDetails[i];
375 if( (m_tauDetails.elementDataID(i) == name)
376 && (typeid( *details ).name() == typeid( const T ).name()) )
377 return dynamic_cast<const T*>( details );
378 }
379 return 0;
380 }
381
382 template <typename T> const T *TauJet::details() const
383 {
384 const unsigned int p_size = m_tauDetails.size();
385 for( unsigned int i = 0; i != p_size; ++i ) {
386 if (!m_tauDetails[i].isValid()) continue;
387 const TauDetails *details = *m_tauDetails[i];
388 if( typeid( *details ).name() == typeid( const T ).name() )
389 return dynamic_cast<const T*>( details );
390 }
391 return 0;
392 }
393
394 inline ElementLinkVector<TauDetailsContainer>& TauJet::tauDetailLinkVector()
395 {
396 return m_tauDetails;
397 }
398 inline const ElementLinkVector<TauDetailsContainer>& TauJet::tauDetailLinkVector() const
399 {
400 return m_tauDetails;
401 }
402
403 inline void TauJet::setE( const double ene )
404 {
405 return this->momentumBase().setE(ene);
406 }
407
408 inline void TauJet::setEta( const double eta )
409 {
410 return this->momentumBase().setEta(eta);
411 }
412
413 inline void TauJet::setPhi( const double phi )
414 {
415 return this->momentumBase().setPhi(phi);
416 }
417
418 inline void TauJet::setM( const double m )
419 {
420 return this->momentumBase().setM(m);
421 }
422
423 inline bool TauJet::hasMergedToCommonDetails() const
424 {
425 return m_hasMergedToCommonDetails;
426 }
427
428 inline void TauJet::setHasMergedToCommonDetails(
429 bool state)
430 {
431 m_hasMergedToCommonDetails = state;
432 }
433
434 inline void TauJet::storeHLV( TauJetParameters::TauCalibType type, CLHEP::HepLorentzVector hlv )
435 {
436 //Some form of sanity check should probably go here...e.g. protect if already stored
437 for(std::vector<std::pair<TauJetParameters::TauCalibType, CLHEP::HepLorentzVector> >::size_type i = 0;
438 i != m_tauHLVStorage.size(); i++)
439 {
440 if(m_tauHLVStorage[i].first==type)
441 {
442 return;
443 }
444 }
445 m_tauHLVStorage.push_back( std::make_pair(type,hlv) );
446 }
447
448 inline CLHEP::HepLorentzVector TauJet::getHLV( TauJetParameters::TauCalibType type ) const
449 {
450 //loop over m_tauHLVStorage and return the hlv paired with 'type'
451 for(std::vector<std::pair<TauJetParameters::TauCalibType, CLHEP::HepLorentzVector> >::size_type i = 0;
452 i != m_tauHLVStorage.size(); i++)
453 {
454 if(m_tauHLVStorage[i].first==type)
455 {
456 return m_tauHLVStorage[i].second;
457 }
458 }
459
460 //If we find nothing, return a trivial result
461 CLHEP::HepLorentzVector dummy;
462 return dummy;
463 }
464
465 inline const std::vector<PanTau::PanTauSeed*>& TauJet::getListOfPanTauSeeds() const {
466 return m_listOfPanTauSeeds;
467 }
468
469 inline void TauJet::addPanTauSeed(PanTau::PanTauSeed* pantauSeed) {
470 m_listOfPanTauSeeds.push_back(pantauSeed);
471 }
472
473}
Generated on for ATLAS Offline Software by doxygen 1.14.0