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. More...
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. More...
virtual std::ostream &	dump (std::ostream &sl) const
	Output Method for std::ostream, to be overloaded by child classes. More...
const Trk::RecVertex &	recVertex (void) const
	Returns a reference to reconstructed vertex. More...
Trk::RecVertex &	recVertex (void)
	Returns unconst reference to a reconstructed vertex Required by some of the vertex fitters. More...
void	setRecVertex (Trk::RecVertex &recVertex)
	RecVertex set method. More...
std::vector< Trk::VxTrackAtVertex * > *	vxTrackAtVertex (void)
	Unconst pointer to the vector of tracks Required by some of the vertex fitters. More...
const std::vector< Trk::VxTrackAtVertex * > *	vxTrackAtVertex (void) const
	Const access to the vector of tracks fitted to the vertex. More...
void	setVertexType (VertexType vertexType)
	return the type of the vertex More...
VertexType	vertexType () const
	return the type of the vertex More...

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 71 of file VxJetCandidate.h.

Constructor & Destructor Documentation

VxJetCandidate() [1/7]

Trk::VxJetCandidate::VxJetCandidate

(

)

Definition at line 45 of file VxJetCandidate.cxx.

                             { }
 
 
VxJetCandidate::VxJetCandidate(const std::vector<std::pair<const Trk::TrackParticleBase*,

VxJetCandidate() [2/7]

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

Definition at line 51 of file VxJetCandidate.cxx.

                             {
 
    std::vector<std::pair<const Trk::TrackParticleBase*,const Trk::TrackParticleBaseCollection*> >::const_iterator 

VxJetCandidate() [3/7]

Trk::VxJetCandidate::VxJetCandidate

(

const std::vector< std::pair< const Trk::TrackParticleBase *, const Trk::TrackParticleBaseCollection * > > &

vectorOfTrackParticles

)

Definition at line 59 of file VxJetCandidate.cxx.

                                                     {
 
      if ((*vTPIter).first!=0) {
        ElementLink<TrackParticleBaseCollection> link;
        link.setElement((*vTPIter).first);
        LinkToTrackParticleBase * linkTT = new LinkToTrackParticleBase(link);
        linkTT->setStorableObject(*((*vTPIter).second));
        VxTrackAtVertex* newVxTrack=new VxTrackAtVertex(linkTT);
        m_vxTrackAtVertex.push_back(newVxTrack);
        std::vector<VxTrackAtVertex*> temp_vector_tracksAtVertex;
        temp_vector_tracksAtVertex.push_back(newVxTrack);
        m_verticesOnJetAxis.push_back(new VxVertexOnJetAxis(temp_vector_tracksAtVertex));
        //every track is added at the beginning to a new additional vertex (all vertices have only 1 track at the beginning)
      } else {
        std::cout << "************************************ ------------- *********************************************" << std::endl;
        std::cout << "ERROR in VxJetCandidate constructor: inconsistency in VxTrackAtVertex tracks. Skipping track..." << std::endl;
        std::cout << "************************************ ------------- *********************************************" << std::endl;
      }
    }
  }
 
VxJetCandidate::VxJetCandidate(const std::vector<const Trk::TrackParticleBase*> & vectorOfTrackParticles):
  VxCandidate(),
  m_primaryVertex(nullptr),
  m_debugInfo(nullptr),
  m_clusteringTable(nullptr) {
 
    std::vector<const Trk::TrackParticleBase*>::const_iterator vTPBegin=vectorOfTrackParticles.begin();
    std::vector<const Trk::TrackParticleBase*>::const_iterator vTPEnd=vectorOfTrackParticles.end();
 

VxJetCandidate() [4/7]

Trk::VxJetCandidate::VxJetCandidate

(

const std::vector< std::pair< const Track *, const TrackCollection * > > &

vectorOfTracks

)

Definition at line 125 of file VxJetCandidate.cxx.

                                                {
 
      if ((*vTIter).first!=0) {
        ElementLink<TrackCollection> link;
        link.setElement((*vTIter).first);
        LinkToTrack * linkTT = new LinkToTrack(link);
        linkTT->setStorableObject(*(*vTIter).second);
        VxTrackAtVertex* myPointer=new VxTrackAtVertex(linkTT);
        m_vxTrackAtVertex.push_back(myPointer);
        std::vector<VxTrackAtVertex*> temp_vector_tracksAtVertex;
        temp_vector_tracksAtVertex.push_back(myPointer);
        VxVertexOnJetAxis* myVertexOnJetAxis=new VxVertexOnJetAxis(temp_vector_tracksAtVertex);
        //  myVertexOnJetAxis->setLinearizationPosition(0.);//should already be zero
        //HERE
        m_verticesOnJetAxis.push_back(myVertexOnJetAxis);
        //every track is added at the beginning to a new additional vertex (all vertices have only 1 track at the beginning)
      } else {
        std::cout << "************************************ ------------- *********************************************" << std::endl;
        std::cout << "ERROR in VxJetCandidate constructor: inconsistency in VxTrackAtVertex tracks. Skipping track..." << std::endl;
        std::cout << "************************************ ------------- *********************************************" << std::endl;
      }
    }
 
  }
 
 
VxJetCandidate::VxJetCandidate(const std::vector<const Track*> & vectorOfTracks):
  VxCandidate(),
  m_primaryVertex(nullptr),
  m_debugInfo(nullptr),
  m_clusteringTable(nullptr) {
 
    std::vector<const Trk::Track*>::const_iterator vTBegin=vectorOfTracks.begin();
    std::vector<const Trk::Track*>::const_iterator vTEnd=vectorOfTracks.end();

VxJetCandidate() [5/7]

Trk::VxJetCandidate::VxJetCandidate

(

const std::vector< const Trk::TrackParticleBase * > &

vectorOfTrackParticles

)

Definition at line 94 of file VxJetCandidate.cxx.

                             {
        ElementLink<TrackParticleBaseCollection> link;
        link.setElement(*vTPIter);
        LinkToTrackParticleBase * linkTT = new LinkToTrackParticleBase(link);
        VxTrackAtVertex* newVxTrack=new VxTrackAtVertex(linkTT);
        m_vxTrackAtVertex.push_back(newVxTrack);
        std::vector<VxTrackAtVertex*> temp_vector_tracksAtVertex;
        temp_vector_tracksAtVertex.push_back(newVxTrack);
        m_verticesOnJetAxis.push_back(new VxVertexOnJetAxis(temp_vector_tracksAtVertex));
        //every track is added at the beginning to a new additional vertex (all vertices have only 1 track at the beginning)
      } else {
        std::cout << "************************************ ------------- *********************************************" << std::endl;
        std::cout << "ERROR in VxJetCandidate constructor: inconsistency in VxTrackAtVertex tracks. Skipping track..." << std::endl;
        std::cout << "************************************ ------------- *********************************************" << std::endl;
      }
 
    }
  }
 
 
VxJetCandidate::VxJetCandidate(const std::vector<std::pair<const Track*,const TrackCollection*> > & vectorOfTracks):
  VxCandidate(),
  m_primaryVertex(nullptr),
  m_debugInfo(nullptr),
  m_clusteringTable(nullptr) {
 
    std::vector<std::pair<const Trk::Track*,const TrackCollection*> >::const_iterator 
      vTBegin=vectorOfTracks.begin();

VxJetCandidate() [6/7]

Trk::VxJetCandidate::VxJetCandidate

(

const std::vector< const Track * > &

vectorOfTracks

)

Definition at line 164 of file VxJetCandidate.cxx.

                                                {
 
      if (*vTIter!=nullptr) {
        ElementLink<TrackCollection> link;
        link.setElement(*vTIter);
        LinkToTrack * linkTT = new LinkToTrack(link);
        VxTrackAtVertex* myPointer=new VxTrackAtVertex(linkTT);
        m_vxTrackAtVertex.push_back(myPointer);
        std::vector<VxTrackAtVertex*> temp_vector_tracksAtVertex;
        temp_vector_tracksAtVertex.push_back(myPointer);
        VxVertexOnJetAxis* myVertexOnJetAxis=new VxVertexOnJetAxis(temp_vector_tracksAtVertex);
        //      myVertexOnJetAxis->setLinearizationPosition(0.);//should already be zero
        //HERE
        m_verticesOnJetAxis.push_back(myVertexOnJetAxis);
        //every track is added at the beginning to a new additional vertex (all vertices have only 1 track at the beginning)
      } else {
        std::cout << "************************************ ------------- *********************************************" << std::endl;
        std::cout << "ERROR in VxJetCandidate constructor: inconsistency in VxTrackAtVertex tracks. Skipping track..." << std::endl;
        std::cout << "************************************ ------------- *********************************************" << std::endl;
      }
 
    }
 
  }
 
void VxJetCandidate::setTracksOrigin(const TrackCollection * trackTES) {
 
  std::vector<Trk::VxTrackAtVertex*>::iterator tracksBegin=m_vxTrackAtVertex.begin();
  std::vector<Trk::VxTrackAtVertex*>::iterator tracksEnd=m_vxTrackAtVertex.end();
 
  for (std::vector<Trk::VxTrackAtVertex*>::iterator tracksIter=tracksBegin;
       tracksIter!=tracksEnd;++tracksIter) {
 
    ITrackLink* IlinkTT=(*tracksIter)->trackOrParticleLink();

~VxJetCandidate()

Trk::VxJetCandidate::~VxJetCandidate ( )

virtual

Definition at line 483 of file VxJetCandidate.cxx.

                  {
 
    if (*VtxIter!=nullptr) {
      delete *VtxIter;
    } else {
      std::cout << "************************************ ------------- ***********************************************" << std::endl;
      std::cout << "ERROR in destructor of VxJetCandidate: one of the VxVertexOnJetAxis is already an empty pointer..." << std::endl;
      std::cout << "************************************ ------------- ***********************************************" << std::endl;
    }
  }
 
  if (m_debugInfo!=nullptr) {
    delete m_debugInfo;
    m_debugInfo=nullptr;
  }
 
  if (m_clusteringTable!=nullptr) {
    delete m_clusteringTable;
    m_clusteringTable=nullptr;
  }
 
}
const Trk::RecVertexPositions & VxJetCandidate::getRecVertexPositions() const {
  return m_fittedPositions;
}
 
Trk::RecVertexPositions & VxJetCandidate::getRecVertexPositions() {//non-const overload
  return m_fittedPositions;
}
 
void VxJetCandidate::setRecVertexPositions(const Trk::RecVertexPositions & newPositions) {
  m_fittedPositions=newPositions;

VxJetCandidate() [7/7]

Trk::VxJetCandidate::VxJetCandidate

(

const VxJetCandidate &

rhs

)

Definition at line 237 of file VxJetCandidate.cxx.

                                     {
    if (*itr==nullptr) {
      std::cout << " Pointer of one of the tracks of the object to copy is zero. PROBLEM! Skipping track " << std::endl;
      continue;
    }
    Trk::VxTrackAtVertex* newVxTrackPointer=(*itr)->clone();
    oldToNewPointer[*itr]=newVxTrackPointer;
    this->m_vxTrackAtVertex.push_back(newVxTrackPointer);
  }
 
  m_primaryVertex=(rhs.m_primaryVertex!=nullptr) ? new VxVertexOnJetAxis(*rhs.m_primaryVertex) : nullptr;
 
  if (rhs.m_primaryVertex!=nullptr) {
    const std::vector<VxTrackAtVertex*> & primaryVectorTracks=rhs.m_primaryVertex->getTracksAtVertex();
 
    const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksBegin=primaryVectorTracks.begin();
    const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksEnd=primaryVectorTracks.end();
 
    std::vector<VxTrackAtVertex*> primaryVectorNew;
 
    for (std::vector<VxTrackAtVertex*>::const_iterator  primaryVectorIter=primaryVectorTracksBegin;
         primaryVectorIter!=primaryVectorTracksEnd;++primaryVectorIter) {
      VxTrackAtVertex* newTrackPointer=oldToNewPointer[*primaryVectorIter];
      if (newTrackPointer!=nullptr) {
        primaryVectorNew.push_back(newTrackPointer);
      } else {
        std::cout << "************************************ ---------------------------- ********************************" << std::endl;
        std::cout << "Not able to copy old pointer to new one when inizializing tracks of primary vertex to new pointers" << std::endl;
        std::cout << "************************************ ---------------------------- ********************************" << std::endl;
      }
    }
 
    m_primaryVertex->setTracksAtVertex(std::move(primaryVectorNew));
 
  } else {
    std::cout << "VxJetCandidate EDM class: Warning in COPY: no primary vertex present" << std::endl;
  }
 
  //copying over m_verticesOnJetAxis
  std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=rhs.m_verticesOnJetAxis.begin();
  std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=rhs.m_verticesOnJetAxis.end();
 
  for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;
       ++VtxIter) {
 
    if (*VtxIter!=nullptr) {
 
      VxVertexOnJetAxis* newVertexOnJetAxis=new VxVertexOnJetAxis(**VtxIter);
 
      //now you still need to attach the new pointers...
 
      std::vector<VxTrackAtVertex*> vertexVectorNew;
 
      const std::vector<VxTrackAtVertex*> & TracksAtVertex=(*VtxIter)->getTracksAtVertex();
 
      const std::vector<VxTrackAtVertex*>::const_iterator TracksBegin=TracksAtVertex.begin();
      const std::vector<VxTrackAtVertex*>::const_iterator TracksEnd=TracksAtVertex.end();
 
      for (std::vector<VxTrackAtVertex*>::const_iterator  TrackVectorIter=TracksBegin;
           TrackVectorIter!=TracksEnd;++TrackVectorIter) {
        VxTrackAtVertex* newTrackPointer=oldToNewPointer[*TrackVectorIter];
        if (newTrackPointer!=nullptr) {
          vertexVectorNew.push_back(newTrackPointer);
        } else {
          std::cout << "************************************ ---------------------------- **********************(((((***********" << std::endl;
          std::cout << "Not able to copy old pointer to new one when inizializing tracks of vertices on jet axis to new pointers" << std::endl;
          std::cout << "************************************ ---------------------------- **************************************" << std::endl;
        }
      }
      newVertexOnJetAxis->setTracksAtVertex(std::move(vertexVectorNew));
      m_verticesOnJetAxis.push_back(newVertexOnJetAxis);
 
    } else {
      std::cout << "************************************ ------------- *********************************************" << std::endl;
      std::cout << "ERROR in copy constructor of VxJetCandidate: one of the VxVertexOnJetAxis is an empty pointer..." << std::endl;
      std::cout << "************************************ ------------- *********************************************" << std::endl;
    }
  }
 
  if (rhs.m_debugInfo!=nullptr) {
    m_debugInfo=new VxJetFitterDebugInfo(*rhs.m_debugInfo);
  } else {
    m_debugInfo=nullptr;
  }
 
  //    if (rhs.m_clusteringTable!=0) {
  //      std::cout << "Warning: during copy of VxJetCandidate the clusteringTable is not copied over" << std::endl;
  m_clusteringTable=nullptr;//new VxClusteringTable(*rhs.m_clusteringTable);
  //    } else {
  //      m_clusteringTable=0;
  //    }
}
 
VxJetCandidate& VxJetCandidate::operator= (const VxJetCandidate& rhs)
{
  if (this!=&rhs)
  {
    //  this->operator=(rhs);
    // delete objects where pointers pointed to
    // (otherwise -> memory leak)
    std::vector<Trk::VxTrackAtVertex*>::iterator VxTracksEnd=this->m_vxTrackAtVertex.end();
    for (std::vector<Trk::VxTrackAtVertex*>::iterator i = this->m_vxTrackAtVertex.begin();

Member Function Documentation

clone()

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

inlinevirtual

Reimplemented from Trk::VxCandidate.

Definition at line 127 of file VxJetCandidate.h.

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 106 of file VxCandidate.cxx.

{
  sl << "Printing Trk::VxCandidate of type: " << m_vertexType << std::endl;
  sl << m_recVertex << std::endl;
  sl << "Tracks used in the vertex fit: " << m_vxTrackAtVertex.size() << std::endl;

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 118 of file VxCandidate.cxx.

{
  return sf.dump(sl);
}
 

getClusteringTable()

Trk::VxClusteringTable *& Trk::VxJetCandidate::getClusteringTable

(

void

)

Definition at line 569 of file VxJetCandidate.cxx.

                                                                      {//non-const overload

getConstraintVertexPositions() [1/2]

Trk::RecVertexPositions & Trk::VxJetCandidate::getConstraintVertexPositions

(

)

Definition at line 581 of file VxJetCandidate.cxx.

getConstraintVertexPositions() [2/2]

const Trk::RecVertexPositions & Trk::VxJetCandidate::getConstraintVertexPositions

(

)

const

Definition at line 577 of file VxJetCandidate.cxx.

getDebugInfo()

Trk::VxJetFitterDebugInfo *& Trk::VxJetCandidate::getDebugInfo

(

void

)

Definition at line 565 of file VxJetCandidate.cxx.

                                                                                 {

getLinearizationVertexPositions() [1/2]

Trk::VertexPositions & Trk::VxJetCandidate::getLinearizationVertexPositions

(

)

Definition at line 535 of file VxJetCandidate.cxx.

                                                                                           {

getLinearizationVertexPositions() [2/2]

const Trk::VertexPositions & Trk::VxJetCandidate::getLinearizationVertexPositions

(

)

const

Definition at line 531 of file VxJetCandidate.cxx.

                                                                                     {

getPrimaryVertex() [1/2]

VxVertexOnJetAxis * Trk::VxJetCandidate::getPrimaryVertex

(

void

)

Definition at line 555 of file VxJetCandidate.cxx.

                                                             {
  return m_debugInfo;
}

getPrimaryVertex() [2/2]

const VxVertexOnJetAxis * Trk::VxJetCandidate::getPrimaryVertex

(

void

)

const

Definition at line 551 of file VxJetCandidate.cxx.

getRecVertexPositions() [1/2]

Trk::RecVertexPositions & Trk::VxJetCandidate::getRecVertexPositions

(

)

Definition at line 523 of file VxJetCandidate.cxx.

                                                                     {//non-const overlaod

getRecVertexPositions() [2/2]

const Trk::RecVertexPositions & Trk::VxJetCandidate::getRecVertexPositions

(

)

const

Definition at line 519 of file VxJetCandidate.cxx.

                                                                                 {

getVerticesOnJetAxis()

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

(

void

)

const

Definition at line 543 of file VxJetCandidate.cxx.

                                                        {//non-const overload

numberOfInstantiations()

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

inlinestaticinherited

Definition at line 25 of file TrkObjectCounter.h.

  {
#ifndef NDEBUG
    return s_numberOfInstantiations.load();
#endif
    return 0;
  }

operator=()

VxJetCandidate & Trk::VxJetCandidate::operator=

(

const VxJetCandidate &

rhs

)

Assignement operator.

Definition at line 345 of file VxJetCandidate.cxx.

                       {
 
      if (*DelVtxIter!=nullptr) {
        delete *DelVtxIter;
      } else {
        std::cout << "************************************ ---------------------------- ***********************************************" << std::endl;
        std::cout << "ERROR in constructor of VxJetCandidate when deleting: one of the VxVertexOnJetAxis is already an empty pointer..." << std::endl;
        std::cout << "************************************ ---------------------------- ***********************************************" << std::endl;
      }
    }
 
    m_verticesOnJetAxis.clear();//you own them... you need to delete them
 
 
    //you need this map to update all the VxVertexOnJetAxis which only have 
    //pointers to the objects... (with persistency it will be a mess anyway)
    std::map<Trk::VxTrackAtVertex*,Trk::VxTrackAtVertex*> oldToNewPointer;
 
    std::vector<Trk::VxTrackAtVertex*>::const_iterator RhsVxTracksEnd=rhs.m_vxTrackAtVertex.end();
    for (std::vector<Trk::VxTrackAtVertex*>::const_iterator itr = rhs.m_vxTrackAtVertex.begin();
         itr != RhsVxTracksEnd; ++itr) {
      if (*itr==nullptr) {
        std::cout << " Pointer of one of the tracks of the object to copy is zero. PROBLEM! Skipping track " << std::endl;
        continue;
      }
      Trk::VxTrackAtVertex* newVxTrackPointer=(*itr)->clone();
      oldToNewPointer[*itr]=newVxTrackPointer;
      this->m_vxTrackAtVertex.push_back(newVxTrackPointer);
    }
 
    m_primaryVertex=(rhs.m_primaryVertex!=nullptr) ? new VxVertexOnJetAxis(*rhs.m_primaryVertex) : nullptr;
 
    if (rhs.m_primaryVertex!=nullptr) {
      const std::vector<VxTrackAtVertex*> & primaryVectorTracks=rhs.m_primaryVertex->getTracksAtVertex();
 
      const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksBegin=primaryVectorTracks.begin();
      const std::vector<VxTrackAtVertex*>::const_iterator primaryVectorTracksEnd=primaryVectorTracks.end();
 
      std::vector<VxTrackAtVertex*> primaryVectorNew;
 
      for (std::vector<VxTrackAtVertex*>::const_iterator  primaryVectorIter=primaryVectorTracksBegin;
           primaryVectorIter!=primaryVectorTracksEnd;++primaryVectorIter) {
        VxTrackAtVertex* newTrackPointer=oldToNewPointer[*primaryVectorIter];
        if (newTrackPointer!=nullptr) {
          primaryVectorNew.push_back(newTrackPointer);
        } else {
          std::cout << "************************************ ---------------------------- ********************************" << std::endl;
          std::cout << "Not able to copy old pointer to new one when inizializing tracks of primary vertex to new pointers" << std::endl;
          std::cout << "************************************ ---------------------------- ********************************" << std::endl;
        }
      }
 
      m_primaryVertex->setTracksAtVertex(std::move(primaryVectorNew));
 
    } else {
      std::cout << "VxJetCandidate EDM class: Warning in COPY: no primary vertex present" << std::endl;
    }
 
    //copying over m_verticesOnJetAxis
    std::vector<VxVertexOnJetAxis*>::const_iterator VtxBegin=rhs.m_verticesOnJetAxis.begin();
    std::vector<VxVertexOnJetAxis*>::const_iterator VtxEnd=rhs.m_verticesOnJetAxis.end();
 
    for (std::vector<VxVertexOnJetAxis*>::const_iterator VtxIter=VtxBegin;VtxIter!=VtxEnd;
         ++VtxIter) {
 
      if (*VtxIter!=nullptr) {
 
        VxVertexOnJetAxis* newVertexOnJetAxis=new VxVertexOnJetAxis(**VtxIter);
 
        //now you still need to attach the new pointers...
 
        std::vector<VxTrackAtVertex*> vertexVectorNew;
 
        const std::vector<VxTrackAtVertex*> & TracksAtVertex=(*VtxIter)->getTracksAtVertex();
 
        const std::vector<VxTrackAtVertex*>::const_iterator TracksBegin=TracksAtVertex.begin();
        const std::vector<VxTrackAtVertex*>::const_iterator TracksEnd=TracksAtVertex.end();
 
        for (std::vector<VxTrackAtVertex*>::const_iterator  TrackVectorIter=TracksBegin;
             TrackVectorIter!=TracksEnd;++TrackVectorIter) {
          VxTrackAtVertex* newTrackPointer=oldToNewPointer[*TrackVectorIter];
          if (newTrackPointer!=nullptr) {
            vertexVectorNew.push_back(newTrackPointer);
          } else {
            std::cout << "************************************ ---------------------------- **********************(((((***********" << std::endl;
            std::cout << "Not able to copy old pointer to new one when inizializing tracks of vertices on jet axis to new pointers" << std::endl;
            std::cout << "************************************ ---------------------------- **************************************" << std::endl;
          }
        }
        newVertexOnJetAxis->setTracksAtVertex(std::move(vertexVectorNew));
        m_verticesOnJetAxis.push_back(newVertexOnJetAxis);
 
      } else {
        std::cout << "************************************ ------------- *********************************************" << std::endl;
        std::cout << "ERROR in copy constructor of VxJetCandidate: one of the VxVertexOnJetAxis is an empty pointer..." << std::endl;
        std::cout << "************************************ ------------- *********************************************" << std::endl;
      }
    }
 
    if (rhs.m_debugInfo!=nullptr) {
      m_debugInfo=new VxJetFitterDebugInfo(*rhs.m_debugInfo);
    } else {
      m_debugInfo=nullptr;
    }
 
    //    if (rhs.m_clusteringTable!=0) {
    //      std::cout << "Warning: during copy of VxJetCandidate the clusteringTable is not copied over" << std::endl;
    m_clusteringTable=nullptr;//new VxClusteringTable(*rhs.m_clusteringTable);
    //    } else {
    //      m_clusteringTable=0;
    //    }
  }
  return *this;
}
 
VxJetCandidate::~VxJetCandidate()
{
 
  if (m_primaryVertex!=nullptr) {
    delete m_primaryVertex;
    m_primaryVertex=nullptr;
  }
 
 

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.

{
  return m_recVertex;
}

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.

{
  return m_recVertex;
}

setConstraintVertexPositions()

void Trk::VxJetCandidate::setConstraintVertexPositions

(

const Trk::RecVertexPositions &

vtxPositions

)

Definition at line 573 of file VxJetCandidate.cxx.

setLinearizationVertexPositions()

void Trk::VxJetCandidate::setLinearizationVertexPositions

(

const Trk::VertexPositions &

vtxPositions

)

Definition at line 539 of file VxJetCandidate.cxx.

                                                                    {

setPrimaryVertex()

void Trk::VxJetCandidate::setPrimaryVertex

(

const VxVertexOnJetAxis *

newPrimary

)

Definition at line 559 of file VxJetCandidate.cxx.

                                                               {
  return m_clusteringTable;
}
 
void VxJetCandidate::setConstraintVertexPositions(const Trk::RecVertexPositions & vtxPositions) {

setRecVertex()

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

inlineinherited

RecVertex set method.

Definition at line 126 of file VxCandidate.h.

{
  m_recVertex = recVertex;
}

setRecVertexPositions()

void Trk::VxJetCandidate::setRecVertexPositions

(

const Trk::RecVertexPositions &

newPositions

)

Definition at line 527 of file VxJetCandidate.cxx.

                                                                                            {

setTrackParticlesOrigin()

void Trk::VxJetCandidate::setTrackParticlesOrigin

(

const Trk::TrackParticleBaseCollection *

trackParticleTES

)

Definition at line 218 of file VxJetCandidate.cxx.

               {
      linkTT->setStorableObject(*trackParticleTES);
    }
    (*tracksIter)->setOrigTrack(linkTT);
 
  }
 
}
 
VxJetCandidate::VxJetCandidate(const VxJetCandidate& rhs)
  : VxCandidate(rhs)
  , m_fittedPositions(rhs.m_fittedPositions)
  , m_linearizationPositions(rhs.m_linearizationPositions)
  , m_constraintPositions(rhs.m_constraintPositions)
{
 
  m_recVertex = rhs.m_recVertex;
 

setTracksOrigin()

void Trk::VxJetCandidate::setTracksOrigin

(

const TrackCollection *

trackTES

)

Definition at line 199 of file VxJetCandidate.cxx.

               {
      linkTT->setStorableObject(*trackTES);
    }
    (*tracksIter)->setOrigTrack(linkTT);
 
  }
 
}
 
void VxJetCandidate::setTrackParticlesOrigin(const Trk::TrackParticleBaseCollection * trackParticleTES) {
 
  std::vector<Trk::VxTrackAtVertex*>::iterator tracksBegin=m_vxTrackAtVertex.begin();
  std::vector<Trk::VxTrackAtVertex*>::iterator tracksEnd=m_vxTrackAtVertex.end();
 
  for (std::vector<Trk::VxTrackAtVertex*>::iterator tracksIter=tracksBegin;
       tracksIter!=tracksEnd;++tracksIter) {
 
    ITrackLink* IlinkTT=(*tracksIter)->trackOrParticleLink();

setVertexType()

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

inlineinherited

return the type of the vertex

Definition at line 114 of file VxCandidate.h.

{
  m_vertexType = vertexType;
}

setVerticesOnJetAxis()

void Trk::VxJetCandidate::setVerticesOnJetAxis

(

const std::vector< VxVertexOnJetAxis * > &

newVertices

)

Definition at line 547 of file VxJetCandidate.cxx.

                                                                         {

vertexType()

VertexType Trk::VxCandidate::vertexType ( ) const

inlineinherited

return the type of the vertex

Definition at line 120 of file VxCandidate.h.

{
  return m_vertexType;
}

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.

{
  return &m_vxTrackAtVertex;
}

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.

{
  return &m_vxTrackAtVertex;
}

Member Data Documentation

m_clusteringTable

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

protected

Definition at line 123 of file VxJetCandidate.h.

m_constraintPositions

Trk::RecVertexPositions Trk::VxJetCandidate::m_constraintPositions

protected

Definition at line 120 of file VxJetCandidate.h.

m_debugInfo

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

protected

Definition at line 122 of file VxJetCandidate.h.

m_fittedPositions

Trk::RecVertexPositions Trk::VxJetCandidate::m_fittedPositions

protected

Definition at line 118 of file VxJetCandidate.h.

m_linearizationPositions

Trk::VertexPositions Trk::VxJetCandidate::m_linearizationPositions

protected

Definition at line 119 of file VxJetCandidate.h.

m_primaryVertex

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

protected

Definition at line 117 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 121 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:

• VxJetCandidate.h
• VxJetCandidate.cxx