ATLAS Offline Software
VxJetCandidate.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 /***************************************************************************
6  VxJetCandidate.cxx - Description
7  -------------------
8  begin : Autumn 2006
9  authors : Giacinto Piacquadio (Freiburg University)
10  Christian Weiser (Freiburg University)
11  email : giacinto.piacquadio@physik.uni-freiburg.de
12  christian.weiser@cern.ch
13  changes : new!
14 
15  ***************************************************************************/
16 
17 
18 #include "VxJetVertex/VxJetCandidate.h"
19 
20 #include "VxJetVertex/RecVertexPositions.h"
21 
22 #include "VxVertex/VxTrackAtVertex.h"
23 #include "VxJetVertex/VxVertexOnJetAxis.h"
24 #include "VxJetVertex/VxJetFitterDebugInfo.h"
25 #include "VxJetVertex/VxClusteringTable.h"
26 
27 #include "TrkTrack/Track.h"
28 #include "TrkTrack/LinkToTrack.h"
29 #include "TrkParticleBase/LinkToTrackParticleBase.h"
30 
31 #include "AthLinks/ElementLink.h"
32 
33 namespace Trk {
34 
35 VxJetCandidate::VxJetCandidate() :
36  VxCandidate(),
37  m_primaryVertex(nullptr),
38  m_debugInfo(nullptr),
39  m_clusteringTable(nullptr) { }
40 
41 VxJetCandidate::VxJetCandidate(const Trk::RecVertex& recVertex,
42  const std::vector<Trk::VxTrackAtVertex*>& vxTrackAtVertex):
43  VxCandidate(recVertex,vxTrackAtVertex),
44  m_primaryVertex(nullptr),
45  m_debugInfo(nullptr),
46  m_clusteringTable(nullptr) { }
47 
48 
49 VxJetCandidate::VxJetCandidate(const std::vector<std::pair<const Trk::TrackParticleBase*,
50  const Trk::TrackParticleBaseCollection*> > & vectorOfTrackParticles):
51  VxCandidate(),
52  m_primaryVertex(nullptr),
53  m_debugInfo(nullptr),
54  m_clusteringTable(nullptr) {
55 
56  std::vector<std::pair<const Trk::TrackParticleBase*,const Trk::TrackParticleBaseCollection*> >::const_iterator
57  vTPBegin=vectorOfTrackParticles.begin();
58 
59  std::vector<std::pair<const Trk::TrackParticleBase*,const Trk::TrackParticleBaseCollection*> >::const_iterator
60  vTPEnd=vectorOfTrackParticles.end();
61 
62  for (std::vector<std::pair<const Trk::TrackParticleBase*,const Trk::TrackParticleBaseCollection*> >::const_iterator
63  vTPIter=vTPBegin;vTPIter!=vTPEnd;++vTPIter) {
64 
65  if ((*vTPIter).first!=0) {
66  ElementLink<TrackParticleBaseCollection> link;
67  link.setElement((*vTPIter).first);
68  LinkToTrackParticleBase * linkTT = new LinkToTrackParticleBase(link);
69  linkTT->setStorableObject(*((*vTPIter).second));
70  VxTrackAtVertex* newVxTrack=new VxTrackAtVertex(linkTT);
71  m_vxTrackAtVertex.push_back(newVxTrack);
72  std::vector<VxTrackAtVertex*> temp_vector_tracksAtVertex;
73  temp_vector_tracksAtVertex.push_back(newVxTrack);
74  m_verticesOnJetAxis.push_back(new VxVertexOnJetAxis(temp_vector_tracksAtVertex));
75  //every track is added at the beginning to a new additional vertex (all vertices have only 1 track at the beginning)
76  } else {
77  std::cout << "************************************ ------------- *********************************************" << std::endl;
78  std::cout << "ERROR in VxJetCandidate constructor: inconsistency in VxTrackAtVertex tracks. Skipping track..." << std::endl;
79  std::cout << "************************************ ------------- *********************************************" << std::endl;
80  }
81  }
82  }
83 
84 VxJetCandidate::VxJetCandidate(const std::vector<const Trk::TrackParticleBase*> & vectorOfTrackParticles):
85  VxCandidate(),
86  m_primaryVertex(nullptr),
87  m_debugInfo(nullptr),
88  m_clusteringTable(nullptr) {
89 
90  std::vector<const Trk::TrackParticleBase*>::const_iterator vTPBegin=vectorOfTrackParticles.begin();
91  std::vector<const Trk::TrackParticleBase*>::const_iterator vTPEnd=vectorOfTrackParticles.end();
92 
93  for (std::vector<const Trk::TrackParticleBase*>::const_iterator vTPIter=vTPBegin;vTPIter!=vTPEnd;++vTPIter) {
94 
95  if (*vTPIter!=nullptr) {
96  ElementLink<TrackParticleBaseCollection> link;
97  link.setElement(*vTPIter);
98  LinkToTrackParticleBase * linkTT = new LinkToTrackParticleBase(link);
99  VxTrackAtVertex* newVxTrack=new VxTrackAtVertex(linkTT);
100  m_vxTrackAtVertex.push_back(newVxTrack);
101  std::vector<VxTrackAtVertex*> temp_vector_tracksAtVertex;
102  temp_vector_tracksAtVertex.push_back(newVxTrack);
103  m_verticesOnJetAxis.push_back(new VxVertexOnJetAxis(temp_vector_tracksAtVertex));
104  //every track is added at the beginning to a new additional vertex (all vertices have only 1 track at the beginning)
105  } else {
106  std::cout << "************************************ ------------- *********************************************" << std::endl;
107  std::cout << "ERROR in VxJetCandidate constructor: inconsistency in VxTrackAtVertex tracks. Skipping track..." << std::endl;
108  std::cout << "************************************ ------------- *********************************************" << std::endl;
109  }
110 
111  }
112  }
113 
114 
115 VxJetCandidate::VxJetCandidate(const std::vector<std::pair<const Track*,const TrackCollection*> > & vectorOfTracks):
116  VxCandidate(),
117  m_primaryVertex(nullptr),
118  m_debugInfo(nullptr),
119  m_clusteringTable(nullptr) {
120 
121  std::vector<std::pair<const Trk::Track*,const TrackCollection*> >::const_iterator
122  vTBegin=vectorOfTracks.begin();
123 
124  std::vector<std::pair<const Trk::Track*,const TrackCollection*> >::const_iterator
125  vTEnd=vectorOfTracks.end();
126 
127  for (std::vector<std::pair<const Trk::Track*,const TrackCollection*> >::const_iterator
128  vTIter=vTBegin;vTIter!=vTEnd;++vTIter) {
129 
130  if ((*vTIter).first!=0) {
131  ElementLink<TrackCollection> link;
132  link.setElement((*vTIter).first);
133  LinkToTrack * linkTT = new LinkToTrack(link);
134  linkTT->setStorableObject(*(*vTIter).second);
135  VxTrackAtVertex* myPointer=new VxTrackAtVertex(linkTT);
136  m_vxTrackAtVertex.push_back(myPointer);
137  std::vector<VxTrackAtVertex*> temp_vector_tracksAtVertex;
138  temp_vector_tracksAtVertex.push_back(myPointer);
139  VxVertexOnJetAxis* myVertexOnJetAxis=new VxVertexOnJetAxis(temp_vector_tracksAtVertex);
140  // myVertexOnJetAxis->setLinearizationPosition(0.);//should already be zero
141  //HERE
142  m_verticesOnJetAxis.push_back(myVertexOnJetAxis);
143  //every track is added at the beginning to a new additional vertex (all vertices have only 1 track at the beginning)
144  } else {
145  std::cout << "************************************ ------------- *********************************************" << std::endl;
146  std::cout << "ERROR in VxJetCandidate constructor: inconsistency in VxTrackAtVertex tracks. Skipping track..." << std::endl;
147  std::cout << "************************************ ------------- *********************************************" << std::endl;
148  }
149  }
150 
151  }
152 
153 
154 VxJetCandidate::VxJetCandidate(const std::vector<const Track*> & vectorOfTracks):
155  VxCandidate(),
156  m_primaryVertex(nullptr),
157  m_debugInfo(nullptr),
158  m_clusteringTable(nullptr) {
159 
160  std::vector<const Trk::Track*>::const_iterator vTBegin=vectorOfTracks.begin();
161  std::vector<const Trk::Track*>::const_iterator vTEnd=vectorOfTracks.end();
162 
163  for (std::vector<const Trk::Track*>::const_iterator
164  vTIter=vTBegin;vTIter!=vTEnd;++vTIter) {
165 
166  if (*vTIter!=nullptr) {
167  ElementLink<TrackCollection> link;
168  link.setElement(*vTIter);
169  LinkToTrack * linkTT = new LinkToTrack(link);
170  VxTrackAtVertex* myPointer=new VxTrackAtVertex(linkTT);
171  m_vxTrackAtVertex.push_back(myPointer);
172  std::vector<VxTrackAtVertex*> temp_vector_tracksAtVertex;
173  temp_vector_tracksAtVertex.push_back(myPointer);
174  VxVertexOnJetAxis* myVertexOnJetAxis=new VxVertexOnJetAxis(temp_vector_tracksAtVertex);
175  // myVertexOnJetAxis->setLinearizationPosition(0.);//should already be zero
176  //HERE
177  m_verticesOnJetAxis.push_back(myVertexOnJetAxis);
178  //every track is added at the beginning to a new additional vertex (all vertices have only 1 track at the beginning)
179  } else {
180  std::cout << "************************************ ------------- *********************************************" << std::endl;
181  std::cout << "ERROR in VxJetCandidate constructor: inconsistency in VxTrackAtVertex tracks. Skipping track..." << std::endl;
182  std::cout << "************************************ ------------- *********************************************" << std::endl;
183  }
184 
185  }
186 
187  }
188 
189 void VxJetCandidate::setTracksOrigin(const TrackCollection * trackTES) {
190 
191  std::vector<Trk::VxTrackAtVertex*>::iterator tracksBegin=m_vxTrackAtVertex.begin();
192  std::vector<Trk::VxTrackAtVertex*>::iterator tracksEnd=m_vxTrackAtVertex.end();
193 
194  for (std::vector<Trk::VxTrackAtVertex*>::iterator tracksIter=tracksBegin;
195  tracksIter!=tracksEnd;++tracksIter) {
196 
197  ITrackLink* IlinkTT=(*tracksIter)->trackOrParticleLink();
198  LinkToTrack* linkTT=dynamic_cast<LinkToTrack*>(IlinkTT);
199  if(linkTT) {
200  linkTT->setStorableObject(*trackTES);
201  }
202  (*tracksIter)->setOrigTrack(linkTT);
203 
204  }
205 
206 }
207 
208 void VxJetCandidate::setTrackParticlesOrigin(const Trk::TrackParticleBaseCollection * trackParticleTES) {
209 
210  std::vector<Trk::VxTrackAtVertex*>::iterator tracksBegin=m_vxTrackAtVertex.begin();
211  std::vector<Trk::VxTrackAtVertex*>::iterator tracksEnd=m_vxTrackAtVertex.end();
212 
213  for (std::vector<Trk::VxTrackAtVertex*>::iterator tracksIter=tracksBegin;
214  tracksIter!=tracksEnd;++tracksIter) {
215 
216  ITrackLink* IlinkTT=(*tracksIter)->trackOrParticleLink();
217  LinkToTrackParticleBase* linkTT=dynamic_cast<LinkToTrackParticleBase*>(IlinkTT);
218  if(linkTT) {
219  linkTT->setStorableObject(*trackParticleTES);
220  }
221  (*tracksIter)->setOrigTrack(linkTT);
222 
223  }
224 
225 }
226 
227 VxJetCandidate::VxJetCandidate(const VxJetCandidate& rhs)
228  : VxCandidate(rhs)
229  , m_fittedPositions(rhs.m_fittedPositions)
230  , m_linearizationPositions(rhs.m_linearizationPositions)
231  , m_constraintPositions(rhs.m_constraintPositions)
232 {
233 
234  m_recVertex = rhs.m_recVertex;
235 
236  //you need this map to update all the VxVertexOnJetAxis which only have
237  //pointers to the objects... (with persistency it will be a mess anyway)
238  std::map<Trk::VxTrackAtVertex*,Trk::VxTrackAtVertex*> oldToNewPointer;
239 
240  std::vector<Trk::VxTrackAtVertex*>::const_iterator RhsVxTracksEnd=rhs.m_vxTrackAtVertex.end();
241  for (std::vector<Trk::VxTrackAtVertex*>::const_iterator itr = rhs.m_vxTrackAtVertex.begin();
242  itr != RhsVxTracksEnd; ++itr) {
243  if (*itr==nullptr) {
244  std::cout << " Pointer of one of the tracks of the object to copy is zero. PROBLEM! Skipping track " << std::endl;
245  continue;
246  }
247  Trk::VxTrackAtVertex* newVxTrackPointer=(*itr)->clone();
248  oldToNewPointer[*itr]=newVxTrackPointer;
249  this->m_vxTrackAtVertex.push_back(newVxTrackPointer);
250  }
251 
252  m_primaryVertex=(rhs.m_primaryVertex!=nullptr) ? new VxVertexOnJetAxis(*rhs.m_primaryVertex) : nullptr;
253 
254  if (rhs.m_primaryVertex!=nullptr) {
255  const std::vector<VxTrackAtVertex*> & primaryVectorTracks=rhs.m_primaryVertex->getTracksAtVertex();
256 
257  const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksBegin=primaryVectorTracks.begin();
258  const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksEnd=primaryVectorTracks.end();
259 
260  std::vector<VxTrackAtVertex*> primaryVectorNew;
261 
262  for (std::vector<VxTrackAtVertex*>::const_iterator primaryVectorIter=primaryVectorTracksBegin;
263  primaryVectorIter!=primaryVectorTracksEnd;++primaryVectorIter) {
264  VxTrackAtVertex* newTrackPointer=oldToNewPointer[*primaryVectorIter];
265  if (newTrackPointer!=nullptr) {
266  primaryVectorNew.push_back(newTrackPointer);
267  } else {
268  std::cout << "************************************ ---------------------------- ********************************" << std::endl;
269  std::cout << "Not able to copy old pointer to new one when inizializing tracks of primary vertex to new pointers" << std::endl;
270  std::cout << "************************************ ---------------------------- ********************************" << std::endl;
271  }
272  }
273 
274  m_primaryVertex->setTracksAtVertex(std::move(primaryVectorNew));
275 
276  } else {
277  std::cout << "VxJetCandidate EDM class: Warning in COPY: no primary vertex present" << std::endl;
278  }
279 
280  //copying over m_verticesOnJetAxis
281  std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=rhs.m_verticesOnJetAxis.begin();
282  std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=rhs.m_verticesOnJetAxis.end();
283 
284  for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;
285  ++VtxIter) {
286 
287  if (*VtxIter!=nullptr) {
288 
289  VxVertexOnJetAxis* newVertexOnJetAxis=new VxVertexOnJetAxis(**VtxIter);
290 
291  //now you still need to attach the new pointers...
292 
293  std::vector<VxTrackAtVertex*> vertexVectorNew;
294 
295  const std::vector<VxTrackAtVertex*> & TracksAtVertex=(*VtxIter)->getTracksAtVertex();
296 
297  const std::vector<VxTrackAtVertex*>::const_iterator TracksBegin=TracksAtVertex.begin();
298  const std::vector<VxTrackAtVertex*>::const_iterator TracksEnd=TracksAtVertex.end();
299 
300  for (std::vector<VxTrackAtVertex*>::const_iterator TrackVectorIter=TracksBegin;
301  TrackVectorIter!=TracksEnd;++TrackVectorIter) {
302  VxTrackAtVertex* newTrackPointer=oldToNewPointer[*TrackVectorIter];
303  if (newTrackPointer!=nullptr) {
304  vertexVectorNew.push_back(newTrackPointer);
305  } else {
306  std::cout << "************************************ ---------------------------- **********************(((((***********" << std::endl;
307  std::cout << "Not able to copy old pointer to new one when inizializing tracks of vertices on jet axis to new pointers" << std::endl;
308  std::cout << "************************************ ---------------------------- **************************************" << std::endl;
309  }
310  }
311  newVertexOnJetAxis->setTracksAtVertex(std::move(vertexVectorNew));
312  m_verticesOnJetAxis.push_back(newVertexOnJetAxis);
313 
314  } else {
315  std::cout << "************************************ ------------- *********************************************" << std::endl;
316  std::cout << "ERROR in copy constructor of VxJetCandidate: one of the VxVertexOnJetAxis is an empty pointer..." << std::endl;
317  std::cout << "************************************ ------------- *********************************************" << std::endl;
318  }
319  }
320 
321  if (rhs.m_debugInfo!=nullptr) {
322  m_debugInfo=new VxJetFitterDebugInfo(*rhs.m_debugInfo);
323  } else {
324  m_debugInfo=nullptr;
325  }
326 
327  // if (rhs.m_clusteringTable!=0) {
328  // std::cout << "Warning: during copy of VxJetCandidate the clusteringTable is not copied over" << std::endl;
329  m_clusteringTable=nullptr;//new VxClusteringTable(*rhs.m_clusteringTable);
330  // } else {
331  // m_clusteringTable=0;
332  // }
333 }
334 
335 VxJetCandidate& VxJetCandidate::operator= (const VxJetCandidate& rhs)
336 {
337  if (this!=&rhs)
338  {
339  // this->operator=(rhs);
340  // delete objects where pointers pointed to
341  // (otherwise -> memory leak)
342  std::vector<Trk::VxTrackAtVertex*>::iterator VxTracksEnd=this->m_vxTrackAtVertex.end();
343  for (std::vector<Trk::VxTrackAtVertex*>::iterator i = this->m_vxTrackAtVertex.begin();
344  i !=VxTracksEnd ; ++i) {
345  delete (*i);
346  (*i) = 0;
347  }
348 
349  // and clear the vector
350  this->m_vxTrackAtVertex.clear();
351 
352  //deleting m_verticesOnJetAxis
353 
354  std::vector<VxVertexOnJetAxis*>::const_iterator DelVtxBegin=m_verticesOnJetAxis.begin();
355  std::vector<VxVertexOnJetAxis*>::const_iterator DelVtxEnd=m_verticesOnJetAxis.end();
356 
357  for (std::vector<VxVertexOnJetAxis*>::const_iterator DelVtxIter=DelVtxBegin;DelVtxIter!=DelVtxEnd;
358  ++DelVtxIter) {
359 
360  if (*DelVtxIter!=nullptr) {
361  delete *DelVtxIter;
362  } else {
363  std::cout << "************************************ ---------------------------- ***********************************************" << std::endl;
364  std::cout << "ERROR in constructor of VxJetCandidate when deleting: one of the VxVertexOnJetAxis is already an empty pointer..." << std::endl;
365  std::cout << "************************************ ---------------------------- ***********************************************" << std::endl;
366  }
367  }
368 
369  m_verticesOnJetAxis.clear();//you own them... you need to delete them
370 
371 
372  //you need this map to update all the VxVertexOnJetAxis which only have
373  //pointers to the objects... (with persistency it will be a mess anyway)
374  std::map<Trk::VxTrackAtVertex*,Trk::VxTrackAtVertex*> oldToNewPointer;
375 
376  std::vector<Trk::VxTrackAtVertex*>::const_iterator RhsVxTracksEnd=rhs.m_vxTrackAtVertex.end();
377  for (std::vector<Trk::VxTrackAtVertex*>::const_iterator itr = rhs.m_vxTrackAtVertex.begin();
378  itr != RhsVxTracksEnd; ++itr) {
379  if (*itr==nullptr) {
380  std::cout << " Pointer of one of the tracks of the object to copy is zero. PROBLEM! Skipping track " << std::endl;
381  continue;
382  }
383  Trk::VxTrackAtVertex* newVxTrackPointer=(*itr)->clone();
384  oldToNewPointer[*itr]=newVxTrackPointer;
385  this->m_vxTrackAtVertex.push_back(newVxTrackPointer);
386  }
387 
388  m_primaryVertex=(rhs.m_primaryVertex!=nullptr) ? new VxVertexOnJetAxis(*rhs.m_primaryVertex) : nullptr;
389 
390  if (rhs.m_primaryVertex!=nullptr) {
391  const std::vector<VxTrackAtVertex*> & primaryVectorTracks=rhs.m_primaryVertex->getTracksAtVertex();
392 
393  const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksBegin=primaryVectorTracks.begin();
394  const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksEnd=primaryVectorTracks.end();
395 
396  std::vector<VxTrackAtVertex*> primaryVectorNew;
397 
398  for (std::vector<VxTrackAtVertex*>::const_iterator primaryVectorIter=primaryVectorTracksBegin;
399  primaryVectorIter!=primaryVectorTracksEnd;++primaryVectorIter) {
400  VxTrackAtVertex* newTrackPointer=oldToNewPointer[*primaryVectorIter];
401  if (newTrackPointer!=nullptr) {
402  primaryVectorNew.push_back(newTrackPointer);
403  } else {
404  std::cout << "************************************ ---------------------------- ********************************" << std::endl;
405  std::cout << "Not able to copy old pointer to new one when inizializing tracks of primary vertex to new pointers" << std::endl;
406  std::cout << "************************************ ---------------------------- ********************************" << std::endl;
407  }
408  }
409 
410  m_primaryVertex->setTracksAtVertex(std::move(primaryVectorNew));
411 
412  } else {
413  std::cout << "VxJetCandidate EDM class: Warning in COPY: no primary vertex present" << std::endl;
414  }
415 
416  //copying over m_verticesOnJetAxis
417  std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=rhs.m_verticesOnJetAxis.begin();
418  std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=rhs.m_verticesOnJetAxis.end();
419 
420  for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;
421  ++VtxIter) {
422 
423  if (*VtxIter!=nullptr) {
424 
425  VxVertexOnJetAxis* newVertexOnJetAxis=new VxVertexOnJetAxis(**VtxIter);
426 
427  //now you still need to attach the new pointers...
428 
429  std::vector<VxTrackAtVertex*> vertexVectorNew;
430 
431  const std::vector<VxTrackAtVertex*> & TracksAtVertex=(*VtxIter)->getTracksAtVertex();
432 
433  const std::vector<VxTrackAtVertex*>::const_iterator TracksBegin=TracksAtVertex.begin();
434  const std::vector<VxTrackAtVertex*>::const_iterator TracksEnd=TracksAtVertex.end();
435 
436  for (std::vector<VxTrackAtVertex*>::const_iterator TrackVectorIter=TracksBegin;
437  TrackVectorIter!=TracksEnd;++TrackVectorIter) {
438  VxTrackAtVertex* newTrackPointer=oldToNewPointer[*TrackVectorIter];
439  if (newTrackPointer!=nullptr) {
440  vertexVectorNew.push_back(newTrackPointer);
441  } else {
442  std::cout << "************************************ ---------------------------- **********************(((((***********" << std::endl;
443  std::cout << "Not able to copy old pointer to new one when inizializing tracks of vertices on jet axis to new pointers" << std::endl;
444  std::cout << "************************************ ---------------------------- **************************************" << std::endl;
445  }
446  }
447  newVertexOnJetAxis->setTracksAtVertex(std::move(vertexVectorNew));
448  m_verticesOnJetAxis.push_back(newVertexOnJetAxis);
449 
450  } else {
451  std::cout << "************************************ ------------- *********************************************" << std::endl;
452  std::cout << "ERROR in copy constructor of VxJetCandidate: one of the VxVertexOnJetAxis is an empty pointer..." << std::endl;
453  std::cout << "************************************ ------------- *********************************************" << std::endl;
454  }
455  }
456 
457  if (rhs.m_debugInfo!=nullptr) {
458  m_debugInfo=new VxJetFitterDebugInfo(*rhs.m_debugInfo);
459  } else {
460  m_debugInfo=nullptr;
461  }
462 
463  // if (rhs.m_clusteringTable!=0) {
464  // std::cout << "Warning: during copy of VxJetCandidate the clusteringTable is not copied over" << std::endl;
465  m_clusteringTable=nullptr;//new VxClusteringTable(*rhs.m_clusteringTable);
466  // } else {
467  // m_clusteringTable=0;
468  // }
469  }
470  return *this;
471 }
472 
473 VxJetCandidate::~VxJetCandidate()
474 {
475 
476  if (m_primaryVertex!=nullptr) {
477  delete m_primaryVertex;
478  m_primaryVertex=nullptr;
479  }
480 
481 
482  //deleting m_verticesOnJetAxis
483  std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=m_verticesOnJetAxis.begin();
484  std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=m_verticesOnJetAxis.end();
485 
486  for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;
487  ++VtxIter) {
488 
489  if (*VtxIter!=nullptr) {
490  delete *VtxIter;
491  } else {
492  std::cout << "************************************ ------------- ***********************************************" << std::endl;
493  std::cout << "ERROR in destructor of VxJetCandidate: one of the VxVertexOnJetAxis is already an empty pointer..." << std::endl;
494  std::cout << "************************************ ------------- ***********************************************" << std::endl;
495  }
496  }
497 
498  if (m_debugInfo!=nullptr) {
499  delete m_debugInfo;
500  m_debugInfo=nullptr;
501  }
502 
503  if (m_clusteringTable!=nullptr) {
504  delete m_clusteringTable;
505  m_clusteringTable=nullptr;
506  }
507 
508 }
509 const Trk::RecVertexPositions & VxJetCandidate::getRecVertexPositions() const {
510  return m_fittedPositions;
511 }
512 
513 Trk::RecVertexPositions & VxJetCandidate::getRecVertexPositions() {//non-const overload
514  return m_fittedPositions;
515 }
516 
517 void VxJetCandidate::setRecVertexPositions(const Trk::RecVertexPositions & newPositions) {
518  m_fittedPositions=newPositions;
519 }
520 
521 const Trk::VertexPositions & VxJetCandidate::getLinearizationVertexPositions() const {
522  return m_linearizationPositions;
523 }
524 
525 Trk::VertexPositions & VxJetCandidate::getLinearizationVertexPositions() {//non-const overlaod
526  return m_linearizationPositions;
527 }
528 
529 void VxJetCandidate::setLinearizationVertexPositions(const Trk::VertexPositions & vtxPositions) {
530  m_linearizationPositions=vtxPositions;
531 }
532 
533 const std::vector<VxVertexOnJetAxis*> & VxJetCandidate::getVerticesOnJetAxis(void) const {
534  return m_verticesOnJetAxis;
535 }
536 
537 void VxJetCandidate::setVerticesOnJetAxis(const std::vector<VxVertexOnJetAxis*> & newVertices) {
538  m_verticesOnJetAxis=newVertices;
539 }
540 
541 const VxVertexOnJetAxis* VxJetCandidate::getPrimaryVertex(void) const {
542  return m_primaryVertex;
543 }
544 
545 VxVertexOnJetAxis* VxJetCandidate::getPrimaryVertex(void) {//non-const overload
546  return m_primaryVertex;
547 }
548 
549 void VxJetCandidate::setPrimaryVertex(const VxVertexOnJetAxis* newPrimary) {
550  if (m_primaryVertex!=nullptr) { delete m_primaryVertex;
551 }
552  m_primaryVertex=new VxVertexOnJetAxis(*newPrimary);
553 }
554 
555 Trk::VxJetFitterDebugInfo * & VxJetCandidate::getDebugInfo(void) {
556  return m_debugInfo;
557 }
558 
559 Trk::VxClusteringTable* & VxJetCandidate::getClusteringTable(void) {
560  return m_clusteringTable;
561 }
562 
563 void VxJetCandidate::setConstraintVertexPositions(const Trk::RecVertexPositions & vtxPositions) {
564  m_constraintPositions=vtxPositions;
565 }
566 
567 const Trk::RecVertexPositions & VxJetCandidate::getConstraintVertexPositions() const {
568  return m_constraintPositions;
569 }
570 
571 Trk::RecVertexPositions & VxJetCandidate::getConstraintVertexPositions() {//non-const overload
572  return m_constraintPositions;
573 }
574 
575 
576 
577 }//end of namespace definitions
578 
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Trk::VxJetCandidate::setConstraintVertexPositions
void setConstraintVertexPositions(const Trk::RecVertexPositions &)
Definition: VxJetCandidate.cxx:573
LinkToTrack.h
Trk::VxJetCandidate::getVerticesOnJetAxis
const std::vector< VxVertexOnJetAxis * > & getVerticesOnJetAxis(void) const
Definition: VxJetCandidate.cxx:543
Trk::VxTrackAtVertex
The VxTrackAtVertex is a common class for all present TrkVertexFitters The VxTrackAtVertex is designe...
Definition: VxTrackAtVertex.h:77
Trk::VxVertexOnJetAxis::getTracksAtVertex
const std::vector< VxTrackAtVertex * > & getTracksAtVertex(void) const
get Tracks At Vertex Method
Definition: VxVertexOnJetAxis.cxx:102
Trk::VxJetCandidate::getConstraintVertexPositions
const Trk::RecVertexPositions & getConstraintVertexPositions() const
Definition: VxJetCandidate.cxx:577
Trk::VxJetCandidate::getLinearizationVertexPositions
const Trk::VertexPositions & getLinearizationVertexPositions() const
Definition: VxJetCandidate.cxx:531
Trk::VxJetCandidate::m_clusteringTable
Trk::VxClusteringTable * m_clusteringTable
Definition: VxJetCandidate.h:123
Trk::VxJetCandidate::m_verticesOnJetAxis
std::vector< VxVertexOnJetAxis * > m_verticesOnJetAxis
Definition: VxJetCandidate.h:121
VxVertexOnJetAxis.h
VxJetCandidate.h
Trk::VxJetCandidate::m_linearizationPositions
Trk::VertexPositions m_linearizationPositions
Definition: VxJetCandidate.h:119
Trk::VxJetCandidate::setTracksOrigin
void setTracksOrigin(const TrackCollection *)
Definition: VxJetCandidate.cxx:199
Trk::VxVertexOnJetAxis
VxVertexOnJetAxis inherits from Vertex.
Definition: VxVertexOnJetAxis.h:79
VxJetFitterDebugInfo.h
Trk::RecVertex
Trk::RecVertex inherits from Trk::Vertex.
Definition: RecVertex.h:44
Trk::VxJetCandidate::setTrackParticlesOrigin
void setTrackParticlesOrigin(const Trk::TrackParticleBaseCollection *)
Definition: VxJetCandidate.cxx:218
Trk::VxJetCandidate::operator=
VxJetCandidate & operator=(const VxJetCandidate &)
Assignement operator.
Definition: VxJetCandidate.cxx:345
Track.h
Trk::VxJetCandidate::getRecVertexPositions
const Trk::RecVertexPositions & getRecVertexPositions() const
Definition: VxJetCandidate.cxx:519
VxClusteringTable.h
Trk::TrackParticleBase
Definition: TrackParticleBase.h:41
Trk::VxJetCandidate::getPrimaryVertex
const VxVertexOnJetAxis * getPrimaryVertex(void) const
Definition: VxJetCandidate.cxx:551
Trk::VxCandidate::m_recVertex
Trk::RecVertex m_recVertex
Definition: VxCandidate.h:99
lumiFormat.i
int i
Definition: lumiFormat.py:85
Trk::VxClusteringTable
Definition: VxClusteringTable.h:71
Trk::VxCandidate::m_vxTrackAtVertex
std::vector< Trk::VxTrackAtVertex * > m_vxTrackAtVertex
Definition: VxCandidate.h:102
Trk::LinkToTrack
AUTO - An Undocumented Tracking Object.
Definition: LinkToTrack.h:20
VxTrackAtVertex.h
Trk::VxJetCandidate::~VxJetCandidate
virtual ~VxJetCandidate()
Definition: VxJetCandidate.cxx:483
Trk::VxJetCandidate::setRecVertexPositions
void setRecVertexPositions(const Trk::RecVertexPositions &)
Definition: VxJetCandidate.cxx:527
Trk::VxJetCandidate::setPrimaryVertex
void setPrimaryVertex(const VxVertexOnJetAxis *)
Definition: VxJetCandidate.cxx:559
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
LinkToTrackParticleBase.h
Trk::LinkToTrackParticleBase
Definition: LinkToTrackParticleBase.h:17
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition: FakeTrackBuilder.h:9
Trk::VxJetCandidate::m_constraintPositions
Trk::RecVertexPositions m_constraintPositions
Definition: VxJetCandidate.h:120
Trk::RecVertexPositions
Definition: RecVertexPositions.h:34
Trk::VxJetCandidate::getClusteringTable
Trk::VxClusteringTable *& getClusteringTable(void)
Definition: VxJetCandidate.cxx:569
Trk::VxJetCandidate::setLinearizationVertexPositions
void setLinearizationVertexPositions(const Trk::VertexPositions &)
Definition: VxJetCandidate.cxx:539
Trk::VxJetCandidate::m_primaryVertex
Trk::VxVertexOnJetAxis * m_primaryVertex
Definition: VxJetCandidate.h:117
Trk::VxCandidate
Definition: VxCandidate.h:27
Trk::VxTrackAtVertex::clone
virtual VxTrackAtVertex * clone() const
Clone method.
Definition: VxTrackAtVertex.cxx:373
Trk::VxJetCandidate::getDebugInfo
Trk::VxJetFitterDebugInfo *& getDebugInfo(void)
Definition: VxJetCandidate.cxx:565
Trk::VxJetCandidate::VxJetCandidate
VxJetCandidate()
Definition: VxJetCandidate.cxx:45
Trk::VxVertexOnJetAxis::setTracksAtVertex
void setTracksAtVertex(std::vector< VxTrackAtVertex * > tracksAtVertex)
set Tracks At Vertex Method
Definition: VxVertexOnJetAxis.cxx:106
Trk::VxJetCandidate::setVerticesOnJetAxis
void setVerticesOnJetAxis(const std::vector< VxVertexOnJetAxis * > &)
Definition: VxJetCandidate.cxx:547
Trk::VertexPositions
VertexPositions class to represent and store a vertex.
Definition: VertexPositions.h:36
Trk::VxJetCandidate::m_fittedPositions
Trk::RecVertexPositions m_fittedPositions
Definition: VxJetCandidate.h:118
Trk::VxJetCandidate::m_debugInfo
Trk::VxJetFitterDebugInfo * m_debugInfo
Definition: VxJetCandidate.h:122
Trk::VxJetFitterDebugInfo
Definition: VxJetFitterDebugInfo.h:44
RecVertexPositions.h
Generated on Mon Dec 23 2024 21:22:59 for ATLAS Offline Software by   doxygen 1.8.18