SeedFinder.h

Go to the documentation of this file.

#ifndef FASTSIMULATION_TRACKING_SEEDFINDER_H
#define FASTSIMULATION_TRACKING_SEEDFINDER_H

// system
#include <vector>
#include <functional>
#include <array>

// fastsim tracking
#include "FastSimulation/Tracking/interface/SeedingTree.h"
#include "FastSimulation/Tracking/interface/TrajectorySeedHitCandidate.h"
#include "FastSimulation/Tracking/interface/SeedFinderSelector.h"

class TrackerTopology;
class FastTrackerRecHit;



class SeedFinder
{

public:
private:
    std::vector<std::vector<SeedFinderSelector*> > _selectorFunctionsByHits;
    const SeedingTree<TrackingLayer>& _seedingTree;
    const TrackerTopology * _trackerTopology;

public:
    SeedFinder(const SeedingTree<TrackingLayer>& seedingTree,const TrackerTopology & trackerTopology):
        _seedingTree(seedingTree),
        _trackerTopology(&trackerTopology)
    {
    }

    void addHitSelector(SeedFinderSelector * seedFinderSelector,unsigned int nHits)
    {
        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> getSeed(const std::vector<const FastTrackerRecHit *>& trackerRecHits) const
    {
        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
    }
    
    //this method attempts to insert the hit at position 'trackerRecHit' in 'trackerRecHits'
    //into the seeding tree (stored as 'hitIndicesInTree')
    const SeedingNode<TrackingLayer>* insertHit(
        const std::vector<TrajectorySeedHitCandidate>& trackerRecHits,
        std::vector<int>& hitIndicesInTree,
        const SeedingNode<TrackingLayer>* node, unsigned int trackerHit) const
    {
        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> iterateHits(
        unsigned int start,
        const std::vector<TrajectorySeedHitCandidate>& trackerRecHits,
        std::vector<int> hitIndicesInTree,
        bool processSkippedHits) const
    {
        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>();
    }
};

#endif