ATLAS Offline Software
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 
17 namespace 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 Thu Nov 7 2024 21:27:01 for ATLAS Offline Software by   doxygen 1.8.18