ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Attributes | List of all members
Trk::VxJetCandidate Class Reference

#include <VxJetCandidate.h>

Inheritance diagram for Trk::VxJetCandidate:
Collaboration diagram for Trk::VxJetCandidate:

Public Member Functions

 VxJetCandidate ()
 VxJetCandidate (const Trk::RecVertex &recVertex, const std::vector< Trk::VxTrackAtVertex * > &vxTrackAtVertex)
 VxJetCandidate (const std::vector< std::pair< const Trk::TrackParticleBase *, const Trk::TrackParticleBaseCollection * > > &)
 VxJetCandidate (const std::vector< std::pair< const Track *, const TrackCollection * > > &)
 VxJetCandidate (const std::vector< const Trk::TrackParticleBase * > &)
 VxJetCandidate (const std::vector< const Track * > &)
virtual VxJetCandidate * clone () const
virtual ~VxJetCandidate ()
 VxJetCandidate (const VxJetCandidate &rhs)
VxJetCandidate & operator= (const VxJetCandidate &)
 Assignement operator.
void setTracksOrigin (const TrackCollection *)
void setTrackParticlesOrigin (const Trk::TrackParticleBaseCollection *)
const Trk::RecVertexPositions & getRecVertexPositions () const
Trk::RecVertexPositions & getRecVertexPositions ()
void setRecVertexPositions (const Trk::RecVertexPositions &)
const Trk::VertexPositions & getLinearizationVertexPositions () const
Trk::VertexPositions & getLinearizationVertexPositions ()
void setLinearizationVertexPositions (const Trk::VertexPositions &)
const std::vector< VxVertexOnJetAxis * > & getVerticesOnJetAxis (void) const
void setVerticesOnJetAxis (const std::vector< VxVertexOnJetAxis * > &)
const VxVertexOnJetAxis * getPrimaryVertex (void) const
VxVertexOnJetAxis * getPrimaryVertex (void)
void setPrimaryVertex (const VxVertexOnJetAxis *)
Trk::VxJetFitterDebugInfo *& getDebugInfo (void)
Trk::VxClusteringTable *& getClusteringTable (void)
const Trk::RecVertexPositions & getConstraintVertexPositions () const
Trk::RecVertexPositions & getConstraintVertexPositions ()
void setConstraintVertexPositions (const Trk::RecVertexPositions &)
virtual MsgStream & dump (MsgStream &sl) const
 Output Method for MsgStream, to be overloaded by child classes.
virtual std::ostream & dump (std::ostream &sl) const
 Output Method for std::ostream, to be overloaded by child classes.
const Trk::RecVertex & recVertex (void) const
 Returns a reference to reconstructed vertex.
Trk::RecVertex & recVertex (void)
 Returns unconst reference to a reconstructed vertex Required by some of the vertex fitters.
void setRecVertex (Trk::RecVertex &recVertex)
 RecVertex set method.
std::vector< Trk::VxTrackAtVertex * > * vxTrackAtVertex (void)
 Unconst pointer to the vector of tracks Required by some of the vertex fitters.
const std::vector< Trk::VxTrackAtVertex * > * vxTrackAtVertex (void) const
 Const access to the vector of tracks fitted to the vertex.
void setVertexType (VertexType vertexType)
 return the type of the vertex
VertexType vertexType () const
 return the type of the vertex

Static Public Member Functions

static std::size_t numberOfInstantiations ()

Static Public Attributes

static std::atomic_size_t s_numberOfInstantiations

Protected Attributes

Trk::VxVertexOnJetAxis * m_primaryVertex
Trk::RecVertexPositions m_fittedPositions
Trk::VertexPositions m_linearizationPositions
Trk::RecVertexPositions m_constraintPositions
std::vector< VxVertexOnJetAxis * > m_verticesOnJetAxis
Trk::VxJetFitterDebugInfo * m_debugInfo
Trk::VxClusteringTable * m_clusteringTable
Trk::VertexType m_vertexType
Trk::RecVertex m_recVertex
std::vector< Trk::VxTrackAtVertex * > m_vxTrackAtVertex

Detailed Description

Definition at line 50 of file VxJetCandidate.h.

Constructor & Destructor Documentation

◆ VxJetCandidate() [1/7]

Trk::VxJetCandidate::VxJetCandidate ( )

Definition at line 35 of file VxJetCandidate.cxx.

35 :
36 VxCandidate(),
37 m_primaryVertex(nullptr),
38 m_debugInfo(nullptr),
39 m_clusteringTable(nullptr) { }
Trk::VxCandidate::VxCandidate
VxCandidate()
Default constructor for persistency.
Definition VxCandidate.cxx:20
Trk::VxJetCandidate::m_debugInfo
Trk::VxJetFitterDebugInfo * m_debugInfo
Definition VxJetCandidate.h:101
Trk::VxJetCandidate::m_primaryVertex
Trk::VxVertexOnJetAxis * m_primaryVertex
Definition VxJetCandidate.h:96
Trk::VxJetCandidate::m_clusteringTable
Trk::VxClusteringTable * m_clusteringTable
Definition VxJetCandidate.h:102

◆ VxJetCandidate() [2/7]

Trk::VxJetCandidate::VxJetCandidate ( const Trk::RecVertex & recVertex,
const std::vector< Trk::VxTrackAtVertex * > & vxTrackAtVertex )

Definition at line 41 of file VxJetCandidate.cxx.

42 :
43 VxCandidate(recVertex,vxTrackAtVertex),
44 m_primaryVertex(nullptr),
45 m_debugInfo(nullptr),
46 m_clusteringTable(nullptr) { }
Trk::VxCandidate::vxTrackAtVertex
std::vector< Trk::VxTrackAtVertex * > * vxTrackAtVertex(void)
Unconst pointer to the vector of tracks Required by some of the vertex fitters.
Definition VxCandidate.h:144
Trk::VxCandidate::recVertex
const Trk::RecVertex & recVertex(void) const
Returns a reference to reconstructed vertex.
Definition VxCandidate.h:132

◆ VxJetCandidate() [3/7]

Trk::VxJetCandidate::VxJetCandidate ( const std::vector< std::pair< const Trk::TrackParticleBase *, const Trk::TrackParticleBaseCollection * > > & vectorOfTrackParticles)

Definition at line 49 of file VxJetCandidate.cxx.

50 :
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 }
Trk::VxCandidate::m_vxTrackAtVertex
std::vector< Trk::VxTrackAtVertex * > m_vxTrackAtVertex
Definition VxCandidate.h:102
Trk::VxJetCandidate::m_verticesOnJetAxis
std::vector< VxVertexOnJetAxis * > m_verticesOnJetAxis
Definition VxJetCandidate.h:100

◆ VxJetCandidate() [4/7]

Trk::VxJetCandidate::VxJetCandidate ( const std::vector< std::pair< const Track *, const TrackCollection * > > & vectorOfTracks)

Definition at line 115 of file VxJetCandidate.cxx.

115 :
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 }

◆ VxJetCandidate() [5/7]

Trk::VxJetCandidate::VxJetCandidate ( const std::vector< const Trk::TrackParticleBase * > & vectorOfTrackParticles)

Definition at line 84 of file VxJetCandidate.cxx.

84 :
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 }

◆ VxJetCandidate() [6/7]

Trk::VxJetCandidate::VxJetCandidate ( const std::vector< const Track * > & vectorOfTracks)

Definition at line 154 of file VxJetCandidate.cxx.

154 :
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 }

◆ ~VxJetCandidate()

Trk::VxJetCandidate::~VxJetCandidate ( )
virtual

Definition at line 473 of file VxJetCandidate.cxx.

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}

◆ VxJetCandidate() [7/7]

Trk::VxJetCandidate::VxJetCandidate ( const VxJetCandidate & rhs)

Definition at line 227 of file VxJetCandidate.cxx.

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}
Trk::VxCandidate::m_recVertex
Trk::RecVertex m_recVertex
Definition VxCandidate.h:99
Trk::VxJetCandidate::m_constraintPositions
Trk::RecVertexPositions m_constraintPositions
Definition VxJetCandidate.h:99
Trk::VxJetCandidate::m_linearizationPositions
Trk::VertexPositions m_linearizationPositions
Definition VxJetCandidate.h:98
Trk::VxJetCandidate::m_fittedPositions
Trk::RecVertexPositions m_fittedPositions
Definition VxJetCandidate.h:97

Member Function Documentation

◆ clone()

Trk::VxJetCandidate * Trk::VxJetCandidate::clone ( ) const
inlinevirtual

Reimplemented from Trk::VxCandidate.

Definition at line 106 of file VxJetCandidate.h.

107 {
108 return new Trk::VxJetCandidate(*this);
109 }

◆ dump() [1/2]

MsgStream & Trk::VxCandidate::dump ( MsgStream & sl) const
virtualinherited

Output Method for MsgStream, to be overloaded by child classes.

Reimplemented in Trk::MVFVxCandidate.

Definition at line 99 of file VxCandidate.cxx.

100{
101 sl << "Printing Trk::VxCandidate of type: " << m_vertexType << endmsg;
102 sl << m_recVertex << endmsg;
103 sl << "Tracks used in the vertex fit: " << m_vxTrackAtVertex.size() << endmsg;
104 for (unsigned i = 0; i < m_vxTrackAtVertex.size(); i++) {
105 sl << "Track " << i + 1 << " " << *(m_vxTrackAtVertex[i]);
106 }
107 return sl;
108}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
Trk::VxCandidate::m_vertexType
Trk::VertexType m_vertexType
Definition VxCandidate.h:96

◆ dump() [2/2]

std::ostream & Trk::VxCandidate::dump ( std::ostream & sl) const
virtualinherited

Output Method for std::ostream, to be overloaded by child classes.

Reimplemented in Trk::MVFVxCandidate.

Definition at line 111 of file VxCandidate.cxx.

112{
113 sl << "Printing Trk::VxCandidate of type: " << m_vertexType << std::endl;
114 sl << m_recVertex << std::endl;
115 sl << "Tracks used in the vertex fit: " << m_vxTrackAtVertex.size() << std::endl;
116 for (unsigned i = 0; i < m_vxTrackAtVertex.size(); i++) {
117 sl << "Track " << i + 1 << " " << *(m_vxTrackAtVertex[i]);
118 }
119 return sl;
120}

◆ getClusteringTable()

Trk::VxClusteringTable *& Trk::VxJetCandidate::getClusteringTable ( void )

Definition at line 559 of file VxJetCandidate.cxx.

559 {
560 return m_clusteringTable;
561}

◆ getConstraintVertexPositions() [1/2]

Trk::RecVertexPositions & Trk::VxJetCandidate::getConstraintVertexPositions ( )

Definition at line 571 of file VxJetCandidate.cxx.

571 {//non-const overload
572 return m_constraintPositions;
573}

◆ getConstraintVertexPositions() [2/2]

const Trk::RecVertexPositions & Trk::VxJetCandidate::getConstraintVertexPositions ( ) const

Definition at line 567 of file VxJetCandidate.cxx.

567 {
568 return m_constraintPositions;
569}

◆ getDebugInfo()

Trk::VxJetFitterDebugInfo *& Trk::VxJetCandidate::getDebugInfo ( void )

Definition at line 555 of file VxJetCandidate.cxx.

555 {
556 return m_debugInfo;
557}

◆ getLinearizationVertexPositions() [1/2]

Trk::VertexPositions & Trk::VxJetCandidate::getLinearizationVertexPositions ( )

Definition at line 525 of file VxJetCandidate.cxx.

525 {//non-const overlaod
526 return m_linearizationPositions;
527}

◆ getLinearizationVertexPositions() [2/2]

const Trk::VertexPositions & Trk::VxJetCandidate::getLinearizationVertexPositions ( ) const

Definition at line 521 of file VxJetCandidate.cxx.

521 {
522 return m_linearizationPositions;
523}

◆ getPrimaryVertex() [1/2]

VxVertexOnJetAxis * Trk::VxJetCandidate::getPrimaryVertex ( void )

Definition at line 545 of file VxJetCandidate.cxx.

545 {//non-const overload
546 return m_primaryVertex;
547}

◆ getPrimaryVertex() [2/2]

const VxVertexOnJetAxis * Trk::VxJetCandidate::getPrimaryVertex ( void ) const

Definition at line 541 of file VxJetCandidate.cxx.

541 {
542 return m_primaryVertex;
543}

◆ getRecVertexPositions() [1/2]

Trk::RecVertexPositions & Trk::VxJetCandidate::getRecVertexPositions ( )

Definition at line 513 of file VxJetCandidate.cxx.

513 {//non-const overload
514 return m_fittedPositions;
515}

◆ getRecVertexPositions() [2/2]

const Trk::RecVertexPositions & Trk::VxJetCandidate::getRecVertexPositions ( ) const

Definition at line 509 of file VxJetCandidate.cxx.

509 {
510 return m_fittedPositions;
511}

◆ getVerticesOnJetAxis()

const std::vector< VxVertexOnJetAxis * > & Trk::VxJetCandidate::getVerticesOnJetAxis ( void ) const

Definition at line 533 of file VxJetCandidate.cxx.

533 {
534 return m_verticesOnJetAxis;
535}

◆ numberOfInstantiations()

std::size_t Trk::ObjectCounter< Trk::VxCandidate >::numberOfInstantiations ( )
inlinestaticinherited

Definition at line 25 of file TrkObjectCounter.h.

26 {
27#ifndef NDEBUG
28 return s_numberOfInstantiations.load();
29#endif
30 return 0;
31 }
Trk::ObjectCounter
Helper to enable counting number of instantiations in debug builds.
Definition TrkObjectCounter.h:18

◆ operator=()

VxJetCandidate & Trk::VxJetCandidate::operator= ( const VxJetCandidate & rhs)

Assignement operator.

Definition at line 335 of file VxJetCandidate.cxx.

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}

◆ recVertex() [1/2]

Trk::RecVertex & Trk::VxCandidate::recVertex ( void )
inlineinherited

Returns unconst reference to a reconstructed vertex Required by some of the vertex fitters.

Definition at line 138 of file VxCandidate.h.

139{
140 return m_recVertex;
141}

◆ recVertex() [2/2]

const Trk::RecVertex & Trk::VxCandidate::recVertex ( void ) const
inlineinherited

Returns a reference to reconstructed vertex.

Definition at line 132 of file VxCandidate.h.

133{
134 return m_recVertex;
135}

◆ setConstraintVertexPositions()

void Trk::VxJetCandidate::setConstraintVertexPositions ( const Trk::RecVertexPositions & vtxPositions)

Definition at line 563 of file VxJetCandidate.cxx.

563 {
564 m_constraintPositions=vtxPositions;
565}

◆ setLinearizationVertexPositions()

void Trk::VxJetCandidate::setLinearizationVertexPositions ( const Trk::VertexPositions & vtxPositions)

Definition at line 529 of file VxJetCandidate.cxx.

529 {
530 m_linearizationPositions=vtxPositions;
531}

◆ setPrimaryVertex()

void Trk::VxJetCandidate::setPrimaryVertex ( const VxVertexOnJetAxis * newPrimary)

Definition at line 549 of file VxJetCandidate.cxx.

549 {
550 if (m_primaryVertex!=nullptr) { delete m_primaryVertex;
551}
552 m_primaryVertex=new VxVertexOnJetAxis(*newPrimary);
553}

◆ setRecVertex()

void Trk::VxCandidate::setRecVertex ( Trk::RecVertex & recVertex)
inlineinherited

RecVertex set method.

Definition at line 126 of file VxCandidate.h.

127{
128 m_recVertex = recVertex;
129}

◆ setRecVertexPositions()

void Trk::VxJetCandidate::setRecVertexPositions ( const Trk::RecVertexPositions & newPositions)

Definition at line 517 of file VxJetCandidate.cxx.

517 {
518 m_fittedPositions=newPositions;
519}

◆ setTrackParticlesOrigin()

void Trk::VxJetCandidate::setTrackParticlesOrigin ( const Trk::TrackParticleBaseCollection * trackParticleTES)

Definition at line 208 of file VxJetCandidate.cxx.

208 {
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}

◆ setTracksOrigin()

void Trk::VxJetCandidate::setTracksOrigin ( const TrackCollection * trackTES)

Definition at line 189 of file VxJetCandidate.cxx.

189 {
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}

◆ setVertexType()

void Trk::VxCandidate::setVertexType ( VertexType vertexType)
inlineinherited

return the type of the vertex

Definition at line 114 of file VxCandidate.h.

115{
116 m_vertexType = vertexType;
117}
Trk::VxCandidate::vertexType
VertexType vertexType() const
return the type of the vertex
Definition VxCandidate.h:120

◆ setVerticesOnJetAxis()

void Trk::VxJetCandidate::setVerticesOnJetAxis ( const std::vector< VxVertexOnJetAxis * > & newVertices)

Definition at line 537 of file VxJetCandidate.cxx.

537 {
538 m_verticesOnJetAxis=newVertices;
539}

◆ vertexType()

VertexType Trk::VxCandidate::vertexType ( ) const
inlineinherited

return the type of the vertex

Definition at line 120 of file VxCandidate.h.

121{
122 return m_vertexType;
123}

◆ vxTrackAtVertex() [1/2]

std::vector< Trk::VxTrackAtVertex * > * Trk::VxCandidate::vxTrackAtVertex ( void )
inlineinherited

Unconst pointer to the vector of tracks Required by some of the vertex fitters.

Definition at line 144 of file VxCandidate.h.

145{
146 return &m_vxTrackAtVertex;
147}

◆ vxTrackAtVertex() [2/2]

const std::vector< Trk::VxTrackAtVertex * > * Trk::VxCandidate::vxTrackAtVertex ( void ) const
inlineinherited

Const access to the vector of tracks fitted to the vertex.

Definition at line 150 of file VxCandidate.h.

151{
152 return &m_vxTrackAtVertex;
153}

Member Data Documentation

◆ m_clusteringTable

Trk::VxClusteringTable* Trk::VxJetCandidate::m_clusteringTable
protected

Definition at line 102 of file VxJetCandidate.h.

◆ m_constraintPositions

Trk::RecVertexPositions Trk::VxJetCandidate::m_constraintPositions
protected

Definition at line 99 of file VxJetCandidate.h.

◆ m_debugInfo

Trk::VxJetFitterDebugInfo* Trk::VxJetCandidate::m_debugInfo
protected

Definition at line 101 of file VxJetCandidate.h.

◆ m_fittedPositions

Trk::RecVertexPositions Trk::VxJetCandidate::m_fittedPositions
protected

Definition at line 97 of file VxJetCandidate.h.

◆ m_linearizationPositions

Trk::VertexPositions Trk::VxJetCandidate::m_linearizationPositions
protected

Definition at line 98 of file VxJetCandidate.h.

◆ m_primaryVertex

Trk::VxVertexOnJetAxis* Trk::VxJetCandidate::m_primaryVertex
protected

Definition at line 96 of file VxJetCandidate.h.

◆ m_recVertex

Trk::RecVertex Trk::VxCandidate::m_recVertex
protectedinherited

Definition at line 99 of file VxCandidate.h.

◆ m_vertexType

Trk::VertexType Trk::VxCandidate::m_vertexType
protectedinherited

Definition at line 96 of file VxCandidate.h.

◆ m_verticesOnJetAxis

std::vector<VxVertexOnJetAxis*> Trk::VxJetCandidate::m_verticesOnJetAxis
protected

Definition at line 100 of file VxJetCandidate.h.

◆ m_vxTrackAtVertex

std::vector<Trk::VxTrackAtVertex*> Trk::VxCandidate::m_vxTrackAtVertex
protectedinherited

Definition at line 102 of file VxCandidate.h.

◆ s_numberOfInstantiations

std::atomic_size_t Trk::ObjectCounter< Trk::VxCandidate >::s_numberOfInstantiations
inlinestaticinherited

Definition at line 22 of file TrkObjectCounter.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0