Creates a vector of vectors, that knows which track is conflicting with which other. More...

#include <OverlapMatrixCreator.h>

Public Member Functions
	OverlapMatrixCreator (std::vector< std::vector< unsigned short > > const &hitRelatedTracks, unsigned short nSpacePointTrackCandidates)
	Constructor taking information necessary to perform algorithm.

std::vector< std::vector< unsigned short > >	getOverlapMatrix (unsigned allowedOverlaps=0)
	Fills and returns the overlap matrix.

Private Attributes
std::vector< std::vector< unsigned short > > const &	m_hitRelatedTracks
	Input information, see constructor.

std::vector< std::vector< unsigned short > >	m_overlapMatrix
	Output information, see getOverlapMatrix.

Detailed Description

Creates a vector of vectors, that knows which track is conflicting with which other.

Definition at line 19 of file OverlapMatrixCreator.h.

Constructor & Destructor Documentation

◆ OverlapMatrixCreator()

OverlapMatrixCreator	(	std::vector< std::vector< unsigned short > > const &	hitRelatedTracks,
		unsigned short	nSpacePointTrackCandidates
	)

inline

Constructor taking information necessary to perform algorithm.

The index of the first vector of hitRelatedTracks is the hit index. The vector at that place holds all tracks, that are connected to that index. m_overlapMatrix is the output and needs to know for how many tracks overlaps need to be saved, hence the second parameter.

Definition at line 28 of file OverlapMatrixCreator.h.

                                                                    :
      m_hitRelatedTracks(hitRelatedTracks), m_overlapMatrix(nSpacePointTrackCandidates)
    {}

Member Function Documentation

◆ getOverlapMatrix()

std::vector< std::vector< unsigned short > > getOverlapMatrix ( unsigned allowedOverlaps = 0 )

inline

Fills and returns the overlap matrix.

It is fairly easily possible to extend the algorithm to allow a number of overlaps without telling the tracks to be in conflict.

Definition at line 38 of file OverlapMatrixCreator.h.

    {
      //Loop over all the hits and make corresponding connections for the tracks
      //This yields unordered indices of tracks, one for each shared hit.
      for (auto&& tracks : m_hitRelatedTracks) {
        for (unsigned short ii = 0; ii < tracks.size(); ii++) {
          for (unsigned short jj = ii + 1; jj < tracks.size(); jj++) {
            m_overlapMatrix[tracks[ii]].push_back(tracks[jj]);
            m_overlapMatrix[tracks[jj]].push_back(tracks[ii]);
          }
        }
      }
 
      //If it makes sense to have this can be explored by Jonas and Felix...
      //... so let's start with something that works, not necessarily what is fastest.
      //This is probably slower then the version below for 0 overlaps, but shall work with
      //any number of allowed overlaps.
      if (allowedOverlaps) {
        std::vector <unsigned short> overlapChache;
 
        for (auto&& overlapTracks : m_overlapMatrix) {
          std::sort(overlapTracks.begin(), overlapTracks.end());
 
          auto endIter    = overlapTracks.end();
          auto cacheIter  = overlapTracks.begin();
          for (auto iter = overlapTracks.begin(); iter != endIter; iter++) {
            if (*iter != *cacheIter) {
              cacheIter = iter;
            } else if (iter - cacheIter == allowedOverlaps) {
              overlapChache.push_back(*iter);
            }
          }
          overlapTracks = overlapChache;
          overlapChache.clear();
        }
        return m_overlapMatrix;
      }
 
      //sort and erase duplicate overlaps
      //TODO: Check in realistic situation alternative approach:
      //see http://stackoverflow.com/questions/1041620/whats-the-most-efficient-way-to-erase-duplicates-and-sort-a-vector
      for (auto&& overlapTracks : m_overlapMatrix) {
        std::sort(overlapTracks.begin(), overlapTracks.end());
        overlapTracks.erase(std::unique(overlapTracks.begin(), overlapTracks.end()), overlapTracks.end());
      }
 
      return m_overlapMatrix;
    }

Member Data Documentation

◆ m_hitRelatedTracks

std::vector<std::vector <unsigned short> > const& m_hitRelatedTracks

private

Input information, see constructor.

Definition at line 88 of file OverlapMatrixCreator.h.

◆ m_overlapMatrix

std::vector<std::vector <unsigned short> > m_overlapMatrix

private

Output information, see getOverlapMatrix.

Definition at line 89 of file OverlapMatrixCreator.h.

The documentation for this class was generated from the following file:

tracking/trackFindingVXD/trackSetEvaluator/include/OverlapMatrixCreator.h

Public Member Functions

Private Attributes