SeedFinder Class Reference

#include <SeedFinder.h>

Public Types
typedef std::function< bool(const std::vector< const FastTrackerRecHit * > &hits)>	Selector

Public Member Functions
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)
void	setHitSelector (Selector selector)

Private Attributes
const SeedingTree < TrackingLayer > &	_seedingTree
Selector	_selector
const TrackerTopology *	_trackerTopology

Detailed Description

Definition at line 15 of file SeedFinder.h.

Member Typedef Documentation

typedef std::function<bool(const std::vector<const FastTrackerRecHit *>& hits)> SeedFinder::Selector

Definition at line 19 of file SeedFinder.h.

Constructor & Destructor Documentation

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

inline

Definition at line 26 of file SeedFinder.h.

References _selector.

    : _seedingTree(seedingTree)
    , _trackerTopology(&trackerTopology)
        {
            _selector=[](const std::vector<const FastTrackerRecHit*>& hits) -> bool
        {
            return true;
        };
        }

Member Function Documentation

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

inline

Definition at line 41 of file SeedFinder.h.

References _seedingTree, _trackerTopology, 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 67 of file SeedFinder.h.

References _selector, SeedingNode< DATA >::getChild(), SeedingNode< DATA >::getChildrenSize(), SeedingNode< DATA >::getData(), SeedingNode< DATA >::getDepth(), SeedingNode< DATA >::getIndex(), SeedingNode< DATA >::getParent(), TrajectorySeedHitCandidate::getTrackingLayer(), TrajectorySeedHitCandidate::hit(), and fileCollector::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;
                    }
                    
                    //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();
                    }
                    
                    if (!_selector(seedCandidateHitList))
                    {
                        return nullptr;
                    }
                    
                    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 120 of file SeedFinder.h.

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().

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

void SeedFinder::setHitSelector ( Selector  selector )

inline

Definition at line 36 of file SeedFinder.h.

References _selector.

        {
            _selector = selector;
        }

Member Data Documentation

const SeedingTree<TrackingLayer>& SeedFinder::_seedingTree

private

Definition at line 22 of file SeedFinder.h.

Referenced by getSeed(), and iterateHits().

Selector SeedFinder::_selector

private

Definition at line 21 of file SeedFinder.h.

Referenced by insertHit(), SeedFinder(), and setHitSelector().

const TrackerTopology* SeedFinder::_trackerTopology

private

Definition at line 23 of file SeedFinder.h.

Referenced by getSeed().