#include <TrajSeedMatcher.h>

Classes
class	HitInfo

struct	MatchInfo

class	MatchingCuts

class	SeedWithInfo

Public Member Functions
std::vector< TrajSeedMatcher::SeedWithInfo >	compatibleSeeds (const TrajectorySeedCollection &seeds, const GlobalPoint &candPos, const GlobalPoint &vprim, const float energy)

void	doEventSetup (const edm::EventSetup &iSetup)

void	setMeasTkEvtHandle (edm::Handle< MeasurementTrackerEvent > handle)

	TrajSeedMatcher (const edm::ParameterSet &pset)

	~TrajSeedMatcher ()=default

Static Public Member Functions
static edm::ParameterSetDescription	makePSetDescription ()

Private Member Functions
void	clearCache ()

size_t	getNrHitsRequired (const int nrValidLayers) const

int	getNrValidLayersAlongTraj (const HitInfo &hit1, const HitInfo &hit2, const GlobalPoint &candPos, const GlobalPoint &vprim, const float energy, const int charge)

int	getNrValidLayersAlongTraj (const DetId &hitId, const TrajectoryStateOnSurface &hitTrajState) const

const TrajectoryStateOnSurface &	getTrajStateFromPoint (const TrackingRecHit &hit, const FreeTrajectoryState &initialState, const GlobalPoint &point, const PropagatorWithMaterial &propagator)

const TrajectoryStateOnSurface &	getTrajStateFromVtx (const TrackingRecHit &hit, const TrajectoryStateOnSurface &initialState, const PropagatorWithMaterial &propagator)

bool	layerHasValidHits (const DetLayer &layer, const TrajectoryStateOnSurface &hitSurState, const Propagator &propToLayerFromState) const

TrajSeedMatcher::HitInfo	match2ndToNthHit (const TrajectorySeed &seed, const FreeTrajectoryState &trajState, const size_t hitNr, const GlobalPoint &prevHitPos, const GlobalPoint &vtxPos, const PropagatorWithMaterial &propagator)

TrajSeedMatcher::HitInfo	matchFirstHit (const TrajectorySeed &seed, const TrajectoryStateOnSurface &trajState, const GlobalPoint &vtxPos, const PropagatorWithMaterial &propagator)

bool	passesMatchSel (const HitInfo &hit, const size_t hitNr, const float scEt, const float scEta) const

bool	passTrajPreSel (const GlobalPoint &hitPos, const GlobalPoint &candPos) const

std::vector< HitInfo >	processSeed (const TrajectorySeed &seed, const GlobalPoint &candPos, const GlobalPoint &vprim, const float energy, const int charge)

Static Private Member Functions
static float	getZVtxFromExtrapolation (const GlobalPoint &primeVtxPos, const GlobalPoint &hitPos, const GlobalPoint &candPos)

Private Attributes
std::unique_ptr< PropagatorWithMaterial >	backwardPropagator_

unsigned long long	cacheIDMagField_

edm::ESHandle< DetLayerGeometry >	detLayerGeom_

std::string	detLayerGeomLabel_

std::unique_ptr< PropagatorWithMaterial >	forwardPropagator_

edm::ESHandle< MagneticField >	magField_

std::vector< MatchingCuts >	matchingCuts_

edm::Handle< MeasurementTrackerEvent >	measTkEvt_

const std::vector< unsigned int >	minNrHits_

const std::vector< int >	minNrHitsValidLayerBins_

edm::ESHandle< NavigationSchool >	navSchool_

std::string	navSchoolLabel_

std::unordered_map< std::pair< int, GlobalPoint >, TrajectoryStateOnSurface >	trajStateFromPointNegChargeCache_

std::unordered_map< std::pair< int, GlobalPoint >, TrajectoryStateOnSurface >	trajStateFromPointPosChargeCache_

std::unordered_map< int, TrajectoryStateOnSurface >	trajStateFromVtxNegChargeCache_

std::unordered_map< int, TrajectoryStateOnSurface >	trajStateFromVtxPosChargeCache_

bool	useRecoVertex_

Static Private Attributes
static float	kElectronMass_ = 0.000511

static float	kPhiCut_ = -0.801144

Detailed Description

Definition at line 77 of file TrajSeedMatcher.h.

Constructor & Destructor Documentation

TrajSeedMatcher::TrajSeedMatcher ( const edm::ParameterSet & pset )

explicit

Definition at line 23 of file TrajSeedMatcher.cc.

References detLayerGeomLabel_, Exception, edm::ParameterSet::getParameter(), matchingCuts_, minNrHits_, minNrHitsValidLayerBins_, navSchoolLabel_, AlCaHLTBitMon_QueryRunRegistry::string, and useRecoVertex_.

                                                            :
   cacheIDMagField_(0),
   minNrHits_(pset.getParameter<std::vector<unsigned int> >("minNrHits")),
   minNrHitsValidLayerBins_(pset.getParameter<std::vector<int> >("minNrHitsValidLayerBins"))
 {
   useRecoVertex_ = pset.getParameter<bool>("useRecoVertex");
   navSchoolLabel_ = pset.getParameter<std::string>("navSchool");
   detLayerGeomLabel_ = pset.getParameter<std::string>("detLayerGeom");
   const auto cutsPSets=pset.getParameter<std::vector<edm::ParameterSet> >("matchingCuts");
   for(const auto & cutPSet : cutsPSets){
     matchingCuts_.push_back(MatchingCuts(cutPSet));
   }
  
   if(minNrHitsValidLayerBins_.size()+1!=minNrHits_.size()){  
     throw cms::Exception("InvalidConfig")<<" minNrHitsValidLayerBins should be 1 less than minNrHits when its "<<minNrHitsValidLayerBins_.size()<<" vs "<<minNrHits_.size();
   }
 }

TrajSeedMatcher::~TrajSeedMatcher ( )

default

Member Function Documentation

void TrajSeedMatcher::clearCache ( )

private

Definition at line 245 of file TrajSeedMatcher.cc.

References trajStateFromPointNegChargeCache_, trajStateFromPointPosChargeCache_, trajStateFromVtxNegChargeCache_, and trajStateFromVtxPosChargeCache_.

Referenced by compatibleSeeds().

 {
   trajStateFromVtxPosChargeCache_.clear();
   trajStateFromVtxNegChargeCache_.clear();
   trajStateFromPointPosChargeCache_.clear();
   trajStateFromPointNegChargeCache_.clear();
 }

std::vector< TrajSeedMatcher::SeedWithInfo > TrajSeedMatcher::compatibleSeeds	(	const TrajectorySeedCollection &	seeds,
		const GlobalPoint &	candPos,
		const GlobalPoint &	vprim,
		const float	energy
	)

Definition at line 75 of file TrajSeedMatcher.cc.

References backwardPropagator_, clearCache(), Exception, forwardPropagator_, getNrHitsRequired(), getNrValidLayersAlongTraj(), edm::ESHandleBase::isValid(), magField_, hpstanc_transforms::max, processSeed(), and SurveyInfoScenario_cff::seed.

Referenced by ElectronNHitSeedProducer::produce().

 {
   if(!forwardPropagator_ || !backwardPropagator_ || !magField_.isValid()){
     throw cms::Exception("LogicError") <<__FUNCTION__<<" can not make pixel seeds as event setup has not properly been called";
   }
 
   clearCache();
   
   std::vector<SeedWithInfo> matchedSeeds;
   for(const auto& seed : seeds) {
     std::vector<HitInfo> matchedHitsNeg = processSeed(seed,candPos,vprim,energy,-1);
     std::vector<HitInfo> matchedHitsPos = processSeed(seed,candPos,vprim,energy,+1);
     int nrValidLayersPos = 0;
     int nrValidLayersNeg = 0;
     if(matchedHitsNeg.size()>=2){
       nrValidLayersNeg = getNrValidLayersAlongTraj(matchedHitsNeg[0],
                            matchedHitsNeg[1],
                            candPos,vprim,energy,-1);
     }
     if(matchedHitsPos.size()>=2){
       nrValidLayersPos = getNrValidLayersAlongTraj(matchedHitsPos[0],
                            matchedHitsPos[1],
                            candPos,vprim,energy,+1);
     }
     
     int nrValidLayers = std::max(nrValidLayersNeg,nrValidLayersPos);
     size_t nrHitsRequired = getNrHitsRequired(nrValidLayers);
     //so we require the number of hits to exactly match, this is because we currently do not
     //do any duplicate cleaning for the input seeds
     //this means is a hit pair with a 3rd hit will appear twice (or however many hits it has)
     //so if you did >=nrHitsRequired, you would get the same seed multiple times
     //ideally we should fix this and clean our input seed collection so each seed is only in once
     //also it should be studied what impact having a 3rd hit has on a GsfTrack
     //ie will we get a significantly different result seeding with a hit pair 
     //and the same the hit pair with a 3rd hit added
     //in that case, perhaps it should be >=
     if(matchedHitsNeg.size()==nrHitsRequired ||
        matchedHitsPos.size()==nrHitsRequired){
       matchedSeeds.push_back({seed,matchedHitsPos,matchedHitsNeg,nrValidLayers});
     }
     
 
   }
   return matchedSeeds;
 }

void TrajSeedMatcher::doEventSetup ( const edm::EventSetup & iSetup )

Definition at line 61 of file TrajSeedMatcher.cc.

References alongMomentum, backwardPropagator_, edm::eventsetup::EventSetupRecord::cacheIdentifier(), cacheIDMagField_, detLayerGeom_, detLayerGeomLabel_, forwardPropagator_, edm::EventSetup::get(), kElectronMass_, magField_, navSchool_, navSchoolLabel_, and oppositeToMomentum.

Referenced by ElectronNHitSeedProducer::produce().

 {
   if (cacheIDMagField_!=iSetup.get<IdealMagneticFieldRecord>().cacheIdentifier()) {
     iSetup.get<IdealMagneticFieldRecord>().get(magField_);
     cacheIDMagField_=iSetup.get<IdealMagneticFieldRecord>().cacheIdentifier();
     forwardPropagator_=std::make_unique<PropagatorWithMaterial>(alongMomentum,kElectronMass_,&*(magField_));
     backwardPropagator_=std::make_unique<PropagatorWithMaterial>(oppositeToMomentum,kElectronMass_,&*(magField_));
   }
   iSetup.get<NavigationSchoolRecord>().get(navSchoolLabel_,navSchool_);
   iSetup.get<RecoGeometryRecord>().get(detLayerGeomLabel_,detLayerGeom_);
 }

size_t TrajSeedMatcher::getNrHitsRequired ( const int nrValidLayers ) const

private

Definition at line 324 of file TrajSeedMatcher.cc.

References minNrHits_, and minNrHitsValidLayerBins_.

Referenced by compatibleSeeds().

 {
   for(size_t binNr=0;binNr<minNrHitsValidLayerBins_.size();binNr++){
     if(nrValidLayers<minNrHitsValidLayerBins_[binNr]) return minNrHits_[binNr];
   }
   return minNrHits_.back();
   
 }

int TrajSeedMatcher::getNrValidLayersAlongTraj	(	const HitInfo &	hit1,
		const HitInfo &	hit2,
		const GlobalPoint &	candPos,
		const GlobalPoint &	vprim,
		const float	energy,
		const int	charge
	)

private

Definition at line 263 of file TrajSeedMatcher.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, forwardPropagator_, TrackingRecHit::geographicalId(), FTSFromVertexToPointFactory::get(), getTrajStateFromPoint(), getZVtxFromExtrapolation(), TrajSeedMatcher::HitInfo::hit(), magField_, TrajSeedMatcher::HitInfo::pos(), useRecoVertex_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and CombinatorialSeedGeneratorForCosmicsRegionalReconstruction_cfi::zVertex.

Referenced by compatibleSeeds().

 {
   double zVertex = useRecoVertex_ ? vprim.z() : getZVtxFromExtrapolation(vprim,hit1.pos(),candPos);
   GlobalPoint vertex(vprim.x(),vprim.y(),zVertex);
   
   FreeTrajectoryState firstHitFreeTraj = FTSFromVertexToPointFactory::get(*magField_,hit1.pos(), 
                                       vertex, energy, charge);
   const TrajectoryStateOnSurface& secondHitTraj = getTrajStateFromPoint(*hit2.hit(),firstHitFreeTraj,hit1.pos(),*forwardPropagator_);
   return getNrValidLayersAlongTraj(hit2.hit()->geographicalId(),secondHitTraj); 
 }

int TrajSeedMatcher::getNrValidLayersAlongTraj	(	const DetId &	hitId,
		const TrajectoryStateOnSurface &	hitTrajState
	)		const

private

Definition at line 277 of file TrajSeedMatcher.cc.

References alongMomentum, backwardPropagator_, NavigationSchool::compatibleLayers(), detLayerGeom_, forwardPropagator_, TrajectoryStateOnSurface::freeState(), DetLayerGeometry::idToLayer(), GeomDetEnumerators::isTrackerPixel(), layerHasValidHits(), navSchool_, and oppositeToMomentum.

 {
   
   const DetLayer* detLayer = detLayerGeom_->idToLayer(hitId);
   if(detLayer==nullptr) return 0;
 
   const FreeTrajectoryState& hitFreeState = *hitTrajState.freeState();
   const std::vector<const DetLayer*> inLayers  = navSchool_->compatibleLayers(*detLayer,hitFreeState,oppositeToMomentum); 
   const std::vector<const DetLayer*> outLayers = navSchool_->compatibleLayers(*detLayer,hitFreeState,alongMomentum); 
   
   int nrValidLayers=1; //because our current hit is also valid and wont be included in the count otherwise
   int nrPixInLayers=0;
   int nrPixOutLayers=0;
   for(auto layer : inLayers){
     if(GeomDetEnumerators::isTrackerPixel(layer->subDetector())){ 
       nrPixInLayers++;
       if(layerHasValidHits(*layer,hitTrajState,*backwardPropagator_)) nrValidLayers++;  
     }
   }
   for(auto layer : outLayers){
     if(GeomDetEnumerators::isTrackerPixel(layer->subDetector())){ 
       nrPixOutLayers++;
       if(layerHasValidHits(*layer,hitTrajState,*forwardPropagator_)) nrValidLayers++;  
     }
   }
   return nrValidLayers;
 }

const TrajectoryStateOnSurface & TrajSeedMatcher::getTrajStateFromPoint	(	const TrackingRecHit &	hit,
		const FreeTrajectoryState &	initialState,
		const GlobalPoint &	point,
		const PropagatorWithMaterial &	propagator
	)

private

Definition at line 197 of file TrajSeedMatcher.cc.

References FreeTrajectoryState::charge(), TrackingRecHit::det(), GeomDet::gdetIndex(), crabWrapper::key, point, Propagator::propagate(), GeomDet::surface(), trajStateFromPointNegChargeCache_, trajStateFromPointPosChargeCache_, and heppy_batch::val.

Referenced by getNrValidLayersAlongTraj(), and match2ndToNthHit().

 {
   
   auto& trajStateFromPointCache = initialState.charge()==1 ? trajStateFromPointPosChargeCache_ :
                                                              trajStateFromPointNegChargeCache_;
 
   auto key = std::make_pair(hit.det()->gdetIndex(),point);
   auto res = trajStateFromPointCache.find(key);
   if(res!=trajStateFromPointCache.end()) return res->second;
   else{ //doesnt exist, need to make it
     //FIXME: check for efficiency
     auto val = trajStateFromPointCache.emplace(key,propagator.propagate(initialState,hit.det()->surface()));
     return val.first->second;
   }
 }

const TrajectoryStateOnSurface & TrajSeedMatcher::getTrajStateFromVtx	(	const TrackingRecHit &	hit,
		const TrajectoryStateOnSurface &	initialState,
		const PropagatorWithMaterial &	propagator
	)

private

Definition at line 182 of file TrajSeedMatcher.cc.

References TrajectoryStateOnSurface::charge(), TrackingRecHit::det(), GeomDet::gdetIndex(), crabWrapper::key, Propagator::propagate(), GeomDet::surface(), trajStateFromVtxNegChargeCache_, trajStateFromVtxPosChargeCache_, and heppy_batch::val.

Referenced by matchFirstHit().

 {
   auto& trajStateFromVtxCache = initialState.charge()==1 ? trajStateFromVtxPosChargeCache_ :
                                                            trajStateFromVtxNegChargeCache_;
 
   auto key = hit.det()->gdetIndex();
   auto res = trajStateFromVtxCache.find(key);
   if(res!=trajStateFromVtxCache.end()) return res->second;
   else{ //doesnt exist, need to make it
     //FIXME: check for efficiency
     auto val = trajStateFromVtxCache.emplace(key,propagator.propagate(initialState,hit.det()->surface()));
     return val.first->second;
   }
 }

float TrajSeedMatcher::getZVtxFromExtrapolation	(	const GlobalPoint &	primeVtxPos,
		const GlobalPoint &	hitPos,
		const GlobalPoint &	candPos
	)

staticprivate

Definition at line 162 of file TrajSeedMatcher.cc.

References p1, p2, mathSSE::sqrt(), x, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by getNrValidLayersAlongTraj(), and processSeed().

 {
   auto sq = [](float x){return x*x;};
   auto calRDiff = [sq](const GlobalPoint& p1,const GlobalPoint& p2){
     return std::sqrt(sq(p2.x()-p1.x()) + sq(p2.y()-p1.y()));
   };
   const double r1Diff = calRDiff(primeVtxPos,hitPos);
   const double r2Diff = calRDiff(hitPos,candPos);
   return hitPos.z() - r1Diff*(candPos.z()-hitPos.z())/r2Diff;
 }

bool TrajSeedMatcher::layerHasValidHits	(	const DetLayer &	layer,
		const TrajectoryStateOnSurface &	hitSurState,
		const Propagator &	propToLayerFromState
	)		const

private

Definition at line 305 of file TrajSeedMatcher.cc.

References GeometricSearchDet::compatibleDets(), gsfElectronCkfTrackCandidateMaker_cff::estimator, MeasurementTrackerEvent::idToDet(), MeasurementDetWithData::isActive(), and measTkEvt_.

Referenced by getNrValidLayersAlongTraj().

 {
   //FIXME: do not hardcode with werid magic numbers stolen from ancient tracking code
   //its taken from https://cmssdt.cern.ch/dxr/CMSSW/source/RecoTracker/TrackProducer/interface/TrackProducerBase.icc#165
   //which inspires this code
   Chi2MeasurementEstimator estimator(30.,-3.0,0.5,2.0,0.5,1.e12);  // same as defauts....
   
   const std::vector<GeometricSearchDet::DetWithState>& detWithState = layer.compatibleDets(hitSurState,propToLayerFromState,estimator);
   if(detWithState.empty()) return false;
   else{
     DetId id = detWithState.front().first->geographicalId();
     MeasurementDetWithData measDet = measTkEvt_->idToDet(id);
     if(measDet.isActive()) return true;
     else return false;
   }
 }

edm::ParameterSetDescription TrajSeedMatcher::makePSetDescription ( )

static

Definition at line 41 of file TrajSeedMatcher.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addVPSet(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ElectronNHitSeedProducer::fillDescriptions().

 {
   edm::ParameterSetDescription desc;
   desc.add<bool>("useRecoVertex",false);
   desc.add<std::string>("navSchool","SimpleNavigationSchool");
   desc.add<std::string>("detLayerGeom","hltESPGlobalDetLayerGeometry");
   desc.add<std::vector<int> >("minNrHitsValidLayerBins",{4});
   desc.add<std::vector<unsigned int> >("minNrHits",{2,3});
   
 
   edm::ParameterSetDescription cutsDesc;
   cutsDesc.add<double>("dPhiMax",0.04);
   cutsDesc.add<double>("dRZMax",0.09);
   cutsDesc.add<double>("dRZMaxLowEtThres",20.);
   cutsDesc.add<std::vector<double> >("dRZMaxLowEtEtaBins",std::vector<double>{1.,1.5});
   cutsDesc.add<std::vector<double> >("dRZMaxLowEt",std::vector<double>{0.09,0.15,0.09});
   desc.addVPSet("matchingCuts",cutsDesc);
   return desc;
 }

TrajSeedMatcher::HitInfo TrajSeedMatcher::match2ndToNthHit	(	const TrajectorySeed &	seed,
		const FreeTrajectoryState &	trajState,
		const size_t	hitNr,
		const GlobalPoint &	prevHitPos,
		const GlobalPoint &	vtxPos,
		const PropagatorWithMaterial &	propagator
	)

private

Definition at line 225 of file TrajSeedMatcher.cc.

References getTrajStateFromPoint(), hfClusterShapes_cfi::hits, TrajectoryStateOnSurface::isValid(), and TrajectorySeed::recHits().

Referenced by processSeed().

 {
   const TrajectorySeed::range& hits = seed.recHits();
   auto hitIt = hits.first+hitNr;
   
   if(hitIt->isValid()){
     const TrajectoryStateOnSurface& trajState = getTrajStateFromPoint(*hitIt,initialState,prevHitPos,propagator);
     if(trajState.isValid()){
       return HitInfo(vtxPos,trajState,*hitIt);  
     }
   }
   return HitInfo();
   
 }

TrajSeedMatcher::HitInfo TrajSeedMatcher::matchFirstHit	(	const TrajectorySeed &	seed,
		const TrajectoryStateOnSurface &	trajState,
		const GlobalPoint &	vtxPos,
		const PropagatorWithMaterial &	propagator
	)

private

Definition at line 213 of file TrajSeedMatcher.cc.

References getTrajStateFromVtx(), hfClusterShapes_cfi::hits, TrajectoryStateOnSurface::isValid(), and TrajectorySeed::recHits().

Referenced by processSeed().

 {
   const TrajectorySeed::range& hits = seed.recHits();
   auto hitIt = hits.first;
 
   if(hitIt->isValid()){
     const TrajectoryStateOnSurface& trajStateFromVtx = getTrajStateFromVtx(*hitIt,initialState,propagator);
     if(trajStateFromVtx.isValid()) return HitInfo(vtxPos,trajStateFromVtx,*hitIt);  
   }
   return HitInfo();
 }

bool TrajSeedMatcher::passesMatchSel	(	const HitInfo &	hit,
		const size_t	hitNr,
		const float	scEt,
		const float	scEta
	)		const

private

Definition at line 253 of file TrajSeedMatcher.cc.

References Exception, and matchingCuts_.

Referenced by processSeed().

 {
   if(hitNr<matchingCuts_.size()){
     return matchingCuts_[hitNr](hit,scEt,scEta);
   }else{
     throw cms::Exception("LogicError") <<" Error, attempting to apply selection to hit "<<hitNr<<" but only cuts for "<<matchingCuts_.size()<<" defined";
   }
   
 }

bool TrajSeedMatcher::passTrajPreSel	(	const GlobalPoint &	hitPos,
		const GlobalPoint &	candPos
	)		const

private

Definition at line 174 of file TrajSeedMatcher.cc.

References dt, kPhiCut_, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

 {
   float dt = hitPos.x()*candPos.x()+hitPos.y()*candPos.y();
   if (dt<0) return false;
   if (dt<kPhiCut_*(candPos.perp()*hitPos.perp())) return false;
   return true;
 }

std::vector< TrajSeedMatcher::HitInfo > TrajSeedMatcher::processSeed	(	const TrajectorySeed &	seed,
		const GlobalPoint &	candPos,
		const GlobalPoint &	vprim,
		const float	energy,
		const int	charge
	)

private

Definition at line 126 of file TrajSeedMatcher.cc.

References backwardPropagator_, ALCARECOTkAlJpsiMuMu_cff::charge, PV3DBase< T, PVType, FrameType >::eta(), forwardPropagator_, FTSFromVertexToPointFactory::get(), getZVtxFromExtrapolation(), magField_, match2ndToNthHit(), matchFirstHit(), matchingCuts_, TrajectorySeed::nHits(), passesMatchSel(), TrajSeedMatcher::HitInfo::pos(), funct::sin(), PV3DBase< T, PVType, FrameType >::theta(), useRecoVertex_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and CombinatorialSeedGeneratorForCosmicsRegionalReconstruction_cfi::zVertex.

Referenced by compatibleSeeds().

 {
   const float candEta = candPos.eta();
   const float candEt = energy*std::sin(candPos.theta());
   
   FreeTrajectoryState trajStateFromVtx = FTSFromVertexToPointFactory::get(*magField_, candPos, vprim, energy, charge);
   PerpendicularBoundPlaneBuilder bpb;
   TrajectoryStateOnSurface initialTrajState(trajStateFromVtx,*bpb(trajStateFromVtx.position(), 
                                   trajStateFromVtx.momentum()));
  
   std::vector<HitInfo> matchedHits;
   HitInfo firstHit = matchFirstHit(seed,initialTrajState,vprim,*backwardPropagator_);
   if(passesMatchSel(firstHit,0,candEt,candEta)){
     matchedHits.push_back(firstHit);
 
     //now we can figure out the z vertex
     double zVertex = useRecoVertex_ ? vprim.z() : getZVtxFromExtrapolation(vprim,firstHit.pos(),candPos);
     GlobalPoint vertex(vprim.x(),vprim.y(),zVertex);
     
     FreeTrajectoryState firstHitFreeTraj = FTSFromVertexToPointFactory::get(*magField_, firstHit.pos(), 
                                         vertex, energy, charge) ;
  
     GlobalPoint prevHitPos = firstHit.pos();
     for(size_t hitNr=1;hitNr<matchingCuts_.size() && hitNr<seed.nHits();hitNr++){
       HitInfo hit = match2ndToNthHit(seed,firstHitFreeTraj,hitNr,prevHitPos,vertex,*forwardPropagator_);
       if(passesMatchSel(hit,hitNr,candEt,candEta)){
     matchedHits.push_back(hit);
     prevHitPos = hit.pos();
       }else break;
     }
   }
   return matchedHits;
 }