Fastsim triplet seed selection branch

FastSimulation/Tracking/BuildFile.xml

@@ -13,6 +13,9 @@
 <use   name="Geometry/TrackerGeometryBuilder"/>
 <use   name="Geometry/Records"/>
 <use   name="DataFormats/EgammaReco"/>
+<use   name="RecoTracker/TkHitPairs"/>
+<use   name="RecoPixelVertexing/PixelTriplets"/>
+<use   name="RecoTracker/MeasurementDet"/>
 <export>
   <lib   name="1"/>
 </export>

FastSimulation/Tracking/interface/SeedFinder.h

@@ -4,185 +4,205 @@
 // 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:
-    typedef std::function<bool(const std::vector<const FastTrackerRecHit *>& hits)> Selector;
 private:
-    Selector _selector;
+    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)
+    SeedFinder(const SeedingTree<TrackingLayer>& seedingTree,const TrackerTopology & trackerTopology):
+        _seedingTree(seedingTree),
+        _trackerTopology(&trackerTopology)
+    {
+    }
+
+    void addHitSelector(SeedFinderSelector * seedFinderSelector,unsigned int nHits)
+    {
+        if (_selectorFunctionsByHits.size()<nHits)
         {
-            _selector=[](const std::vector<const FastTrackerRecHit*>& hits) -> bool
-		{
-		    return true;
-		};
+            _selectorFunctionsByHits.resize(nHits);
+            _selectorFunctionsByHits.reserve(nHits);
         }
+        //shift indices by -1 so that _selectorFunctionsByHits[0] tests 1 hit
+        _selectorFunctionsByHits[nHits-1].push_back(seedFinderSelector);
+    }
 
-    void setHitSelector(Selector selector)
-        {
-            _selector = selector;
-        }
-
     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)
         {
-            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
+            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
+        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 (!node->getParent() || hitIndicesInTree[node->getParent()->getIndex()]>=0)
+            if (hitIndicesInTree[node->getIndex()]<0)
             {
-                if (hitIndicesInTree[node->getIndex()]<0)
+                const TrajectorySeedHitCandidate& currentTrackerHit = trackerRecHits[trackerHit];
+                if (currentTrackerHit.getTrackingLayer()!=node->getData())
                 {
-                    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
+                }
+
+                const unsigned int NHits = node->getDepth()+1;
+                if (_selectorFunctionsByHits.size()>=NHits)
                 {
-                    for (unsigned int ichild = 0; ichild<node->getChildrenSize(); ++ichild)
+                    //are there any selector functions stored for NHits?
+                    if (_selectorFunctionsByHits[NHits-1].size()>0)
                     {
-                        const SeedingNode<TrackingLayer>* seed = insertHit(trackerRecHits,hitIndicesInTree,node->getChild(ichild),trackerHit);
-                        if (seed)
+                        //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)
                         {
-                            return seed;
+                            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;
-	}
+        }
+        return nullptr;
+    }
 
     std::vector<unsigned int> iterateHits(
-	unsigned int start,
-	const std::vector<TrajectorySeedHitCandidate>& trackerRecHits,
-	std::vector<int> hitIndicesInTree,
-	bool processSkippedHits) const
+        unsigned int start,
+        const std::vector<TrajectorySeedHitCandidate>& trackerRecHits,
+        std::vector<int> hitIndicesInTree,
+        bool processSkippedHits) const
+    {
+        for (unsigned int irecHit = start; irecHit<trackerRecHits.size(); ++irecHit)
         {
-            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;
+            }
 
-		// 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;
+            unsigned int currentHitIndex=irecHit;
 
-                for (unsigned int inext=currentHitIndex+1; inext< trackerRecHits.size(); ++inext)
+            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 multiple hits are on the same layer -> follow all possibilities by recusion
-                    if (trackerRecHits[currentHitIndex].getTrackingLayer()==trackerRecHits[inext].getTrackingLayer())
+                    if (processSkippedHits)
                     {
-                        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)
                         {
-                            //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;
-                            }
+                            return seedHits;
                         }
-                        irecHit+=1; 
-                    }
-                    else
-                    {
-                        break;
                     }
+                    irecHit+=1;
                 }
-
-                //processSkippedHits=true
-
-                const SeedingNode<TrackingLayer>* seedNode = nullptr;
-                for (unsigned int iroot=0; seedNode==nullptr && iroot<_seedingTree.numberOfRoots(); ++iroot)
+                else
                 {
-                    seedNode=insertHit(trackerRecHits,hitIndicesInTree,_seedingTree.getRoot(iroot), currentHitIndex);
+                    break;
                 }
-                if (seedNode)
+            }
+
+            //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)
                 {
-                    std::vector<unsigned int> seedIndices(seedNode->getDepth()+1);
-                    while (seedNode)
-                    {
-                        seedIndices[seedNode->getDepth()]=hitIndicesInTree[seedNode->getIndex()];
-                        seedNode=seedNode->getParent();
-                    }
-                    return seedIndices;
+                    seedIndices[seedNode->getDepth()]=hitIndicesInTree[seedNode->getIndex()];
+                    seedNode=seedNode->getParent();
                 }
-
+                return seedIndices;
             }
 
-            return std::vector<unsigned int>();
         }
+
+        return std::vector<unsigned int>();
+    }
 };
 
 #endif

FastSimulation/Tracking/interface/SeedFinderSelector.h

@@ -0,0 +1,47 @@
+#ifndef SEEDFINDERSELECTOR_H
+#define SEEDFINDERSELECTOR_H
+
+#include <vector>
+#include <memory>
+#include <string>
+
+class TrackingRegion;
+class FastTrackerRecHit;
+class MultiHitGeneratorFromPairAndLayers;
+class HitTripletGeneratorFromPairAndLayers;
+class MeasurementTracker;
+
+namespace edm
+{
+    class Event;
+    class EventSetup;
+    class ParameterSet;
+    class ConsumesCollector;
+}
+
+class SeedFinderSelector
+{
+public:
+
+    SeedFinderSelector(const edm::ParameterSet & cfg,edm::ConsumesCollector && consumesCollector);
+
+    ~SeedFinderSelector();
+
+    void initEvent(const edm::Event & ev,const edm::EventSetup & es);
+
+    void setTrackingRegion(const TrackingRegion * trackingRegion){trackingRegion_ = trackingRegion;}
+
+    bool pass(const std::vector<const FastTrackerRecHit *>& hits) const;
+
+private:
+
+    std::unique_ptr<HitTripletGeneratorFromPairAndLayers> pixelTripletGenerator_;
+    std::unique_ptr<MultiHitGeneratorFromPairAndLayers> multiHitGenerator_;
+    const TrackingRegion * trackingRegion_;
+    const edm::EventSetup * eventSetup_;
+    const MeasurementTracker * measurementTracker_;
+    const std::string measurementTrackerLabel_;
+
+};
+
+#endif