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 19 of file SeedFinder.h.

Constructor & Destructor Documentation

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

inline

Definition at line 29 of file SeedFinder.h.

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

Member Function Documentation

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

inline

Definition at line 35 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);
    }

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

inline

Definition at line 46 of file SeedFinder.h.

References iterateHits(), eostools::move(), and SeedingTree< DATA >::numberOfNodes().

    {
        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(std::move(seedHitCandidate));
        }
        return iterateHits(0,seedHitCandidates,hitIndicesInTree,true);

        //TODO: create pairs of TrackingLayer -> remove TrajectorySeedHitCandidate class
    }

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 74 of file SeedFinder.h.

References 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 SurveyInfoScenario_cff::seed.

Referenced by iterateHits().

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

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 140 of file SeedFinder.h.

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

Referenced by getSeed().

    {
        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>();
    }

Member Data Documentation

const SeedingTree<TrackingLayer>& SeedFinder::_seedingTree

private

Definition at line 25 of file SeedFinder.h.

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

private

Definition at line 24 of file SeedFinder.h.

const TrackerTopology* SeedFinder::_trackerTopology

private

Definition at line 26 of file SeedFinder.h.