SeedFinder Class Reference

#include <SeedFinder.h>

Public Member Functions
void	addHitSelector (SeedFinderSelector *seedFinderSelector, unsigned int nHits)
std::vector< unsigned int >	getSeed (const std::vector< const FastTrackerRecHit * > &trackerRecHits) const
const SeedingNode< TrackingLayer > *	insertHit (const std::vector< TrajectorySeedHitCandidate > &trackerRecHits, std::vector< int > &hitIndicesInTree, const SeedingNode< TrackingLayer > *node, unsigned int trackerHit) const
std::vector< unsigned int >	iterateHits (unsigned int start, const std::vector< TrajectorySeedHitCandidate > &trackerRecHits, std::vector< int > hitIndicesInTree, bool processSkippedHits) const
	SeedFinder (const SeedingTree< TrackingLayer > &seedingTree, const TrackerTopology &trackerTopology)

Private Attributes
const SeedingTree< TrackingLayer > &	_seedingTree
std::vector< std::vector< SeedFinderSelector * > >	_selectorFunctionsByHits
const TrackerTopology *	_trackerTopology

Detailed Description

Definition at line 17 of file SeedFinder.h.

Constructor & Destructor Documentation

SeedFinder()

SeedFinder::SeedFinder ( const SeedingTree< TrackingLayer > &  seedingTree, const TrackerTopology &  trackerTopology  )

inline

Definition at line 25 of file SeedFinder.h.

      : _seedingTree(seedingTree), _trackerTopology(&trackerTopology) {}

Member Function Documentation

addHitSelector()

void SeedFinder::addHitSelector ( SeedFinderSelector *  seedFinderSelector, unsigned int  nHits  )

inline

Definition at line 28 of file SeedFinder.h.

                                                                                  {
    if (_selectorFunctionsByHits.size() < nHits) {
      _selectorFunctionsByHits.resize(nHits);
      _selectorFunctionsByHits.reserve(nHits);
    }
    //shift indices by -1 so that _selectorFunctionsByHits[0] tests 1 hit
    _selectorFunctionsByHits[nHits - 1].push_back(seedFinderSelector);
  }

References _selectorFunctionsByHits, nHits, and TrajectorySeedProducer_cfi::seedFinderSelector.

getSeed()

std::vector<unsigned int> SeedFinder::getSeed ( const std::vector< const FastTrackerRecHit * > &  trackerRecHits ) const

inline

Definition at line 37 of file SeedFinder.h.

                                                                                                   {
    std::vector<int> hitIndicesInTree(_seedingTree.numberOfNodes(), -1);
    //A SeedingNode is associated by its index to this list. The list stores the indices of the hits in 'trackerRecHits'
    /* example
           SeedingNode                     | hit index                 | hit
           -------------------------------------------------------------------------------
           index=  0:  [BPix1]             | hitIndicesInTree[0] (=1)  | trackerRecHits[1]
           index=  1:   -- [BPix2]         | hitIndicesInTree[1] (=3)  | trackerRecHits[3]
           index=  2:   --  -- [BPix3]     | hitIndicesInTree[2] (=4)  | trackerRecHits[4]
           index=  3:   --  -- [FPix1_pos] | hitIndicesInTree[3] (=6)  | trackerRecHits[6]
           index=  4:   --  -- [FPix1_neg] | hitIndicesInTree[4] (=7)  | trackerRecHits[7]
 
           The implementation has been chosen such that the tree only needs to be build once upon construction.
        */
    std::vector<TrajectorySeedHitCandidate> seedHitCandidates;
    for (const FastTrackerRecHit* trackerRecHit : trackerRecHits) {
      TrajectorySeedHitCandidate seedHitCandidate(trackerRecHit, _trackerTopology);
      seedHitCandidates.push_back(seedHitCandidate);
    }
    return iterateHits(0, seedHitCandidates, hitIndicesInTree, true);
 
    //TODO: create pairs of TrackingLayer -> remove TrajectorySeedHitCandidate class
  }

References _seedingTree, _trackerTopology, iterateHits(), and SeedingTree< DATA >::numberOfNodes().

insertHit()

const SeedingNode<TrackingLayer>* SeedFinder::insertHit ( const std::vector< TrajectorySeedHitCandidate > &  trackerRecHits, std::vector< int > &  hitIndicesInTree, const SeedingNode< TrackingLayer > *  node, unsigned int  trackerHit  ) const

inline

Definition at line 63 of file SeedFinder.h.

                                                                             {
    if (!node->getParent() || hitIndicesInTree[node->getParent()->getIndex()] >= 0) {
      if (hitIndicesInTree[node->getIndex()] < 0) {
        const TrajectorySeedHitCandidate& currentTrackerHit = trackerRecHits[trackerHit];
        if (currentTrackerHit.getTrackingLayer() != node->getData()) {
          return nullptr;
        }
 
        const unsigned int NHits = node->getDepth() + 1;
        if (_selectorFunctionsByHits.size() >= NHits) {
          //are there any selector functions stored for NHits?
          if (!_selectorFunctionsByHits[NHits - 1].empty()) {
            //fill vector of Hits from node to root to be passed to the selector function
            std::vector<const FastTrackerRecHit*> seedCandidateHitList(node->getDepth() + 1);
            seedCandidateHitList[node->getDepth()] = currentTrackerHit.hit();
            const SeedingNode<TrackingLayer>* parentNode = node->getParent();
            while (parentNode != nullptr) {
              seedCandidateHitList[parentNode->getDepth()] =
                  trackerRecHits[hitIndicesInTree[parentNode->getIndex()]].hit();
              parentNode = parentNode->getParent();
            }
 
            //loop over selector functions
            for (SeedFinderSelector* selectorFunction : _selectorFunctionsByHits[NHits - 1]) {
              if (!selectorFunction->pass(seedCandidateHitList)) {
                return nullptr;
              }
            }
          }
        }
 
        //the hit was not rejected by all selector functions -> insert it into the tree
        hitIndicesInTree[node->getIndex()] = trackerHit;
        if (node->getChildrenSize() == 0) {
          return node;
        }
 
        return nullptr;
      } else {
        for (unsigned int ichild = 0; ichild < node->getChildrenSize(); ++ichild) {
          const SeedingNode<TrackingLayer>* seed =
              insertHit(trackerRecHits, hitIndicesInTree, node->getChild(ichild), trackerHit);
          if (seed) {
            return seed;
          }
        }
      }
    }
    return nullptr;
  }

References _selectorFunctionsByHits, relativeConstraints::empty, SeedingNode< DATA >::getChild(), SeedingNode< DATA >::getChildrenSize(), SeedingNode< DATA >::getData(), SeedingNode< DATA >::getDepth(), SeedingNode< DATA >::getIndex(), SeedingNode< DATA >::getParent(), TrajectorySeedHitCandidate::getTrackingLayer(), TrajectorySeedHitCandidate::hit(), wplusjetsAnalysis_cfi::NHits, and fileCollector::seed.

Referenced by iterateHits().

iterateHits()

std::vector<unsigned int> SeedFinder::iterateHits ( unsigned int  start, const std::vector< TrajectorySeedHitCandidate > &  trackerRecHits, std::vector< int >  hitIndicesInTree, bool  processSkippedHits  ) const

inline

Definition at line 117 of file SeedFinder.h.

                                                                       {
    for (unsigned int irecHit = start; irecHit < trackerRecHits.size(); ++irecHit) {
      // only accept hits that are on one of the requested layers
      if (_seedingTree.getSingleSet().find(trackerRecHits[irecHit].getTrackingLayer()) ==
          _seedingTree.getSingleSet().end()) {
        continue;
      }
 
      unsigned int currentHitIndex = irecHit;
 
      for (unsigned int inext = currentHitIndex + 1; inext < trackerRecHits.size(); ++inext) {
        //if multiple hits are on the same layer -> follow all possibilities by recusion
        if (trackerRecHits[currentHitIndex].getTrackingLayer() == trackerRecHits[inext].getTrackingLayer()) {
          if (processSkippedHits) {
            //recusively call the method again with hit 'inext' but skip all following on the same layer though 'processSkippedHits=false'
            std::vector<unsigned int> seedHits = iterateHits(inext, trackerRecHits, hitIndicesInTree, false);
            if (!seedHits.empty()) {
              return seedHits;
            }
          }
          irecHit += 1;
        } else {
          break;
        }
      }
 
      //processSkippedHits=true
 
      const SeedingNode<TrackingLayer>* seedNode = nullptr;
      for (unsigned int iroot = 0; seedNode == nullptr && iroot < _seedingTree.numberOfRoots(); ++iroot) {
        seedNode = insertHit(trackerRecHits, hitIndicesInTree, _seedingTree.getRoot(iroot), currentHitIndex);
      }
      if (seedNode) {
        std::vector<unsigned int> seedIndices(seedNode->getDepth() + 1);
        while (seedNode) {
          seedIndices[seedNode->getDepth()] = hitIndicesInTree[seedNode->getIndex()];
          seedNode = seedNode->getParent();
        }
        return seedIndices;
      }
    }
 
    return std::vector<unsigned int>();
  }

References _seedingTree, SeedingNode< DATA >::getDepth(), SeedingNode< DATA >::getIndex(), SeedingNode< DATA >::getParent(), SeedingTree< DATA >::getRoot(), SeedingTree< DATA >::getSingleSet(), insertHit(), and SeedingTree< DATA >::numberOfRoots().

Referenced by getSeed().

Member Data Documentation

_seedingTree

const SeedingTree<TrackingLayer>& SeedFinder::_seedingTree

private

Definition at line 21 of file SeedFinder.h.

Referenced by getSeed(), and iterateHits().

_selectorFunctionsByHits

std::vector<std::vector<SeedFinderSelector*> > SeedFinder::_selectorFunctionsByHits

private

Definition at line 20 of file SeedFinder.h.

Referenced by addHitSelector(), and insertHit().

_trackerTopology

const TrackerTopology* SeedFinder::_trackerTopology

private

Definition at line 22 of file SeedFinder.h.

Referenced by getSeed().