Skip to content

Commit

Permalink
Merge pull request #14554 from ANSH0712/fastsim-tripletSeedSelectionb…
Browse files Browse the repository at this point in the history 
…ranch

Fastsim triplet seed selection branch
  • Loading branch information
@davidlange6
davidlange6 committed May 22, 2016
2 parents dd70c17 + c6ff376 commit b76718c
Show file tree
Hide file tree
Showing 27 changed files with 726 additions and 451 deletions.
3 changes: 3 additions & 0 deletions FastSimulation/Tracking/BuildFile.xml
View file
Expand Up @@ -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>
268 changes: 144 additions & 124 deletions FastSimulation/Tracking/interface/SeedFinder.h
View file
Expand Up @@ -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
Expand Down
47 changes: 47 additions & 0 deletions FastSimulation/Tracking/interface/SeedFinderSelector.h
View file
@@ -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

0 comments on commit b76718c

Please sign in to comment.