#include <TrajSeedMatcher.h>

Classes
struct	MatchInfo

class	MatchingCuts

class	MatchingCutsV1

class	MatchingCutsV2

class	SCHitMatch

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

const MagneticField &	getMagField (const GlobalPoint &point) const

size_t	getNrHitsRequired (const int nrValidLayers) const

int	getNrValidLayersAlongTraj (const SCHitMatch &hit1, const SCHitMatch &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

TrajectoryStateOnSurface	makeTrajStateOnSurface (const GlobalPoint &pos, const GlobalPoint &vtx, const float energy, const int charge) const

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

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

bool	passesMatchSel (const SCHitMatch &hit, const size_t hitNr) const

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

std::vector< SCHitMatch >	processSeed (const TrajectorySeed &seed, const GlobalPoint &candPos, const GlobalPoint &vprim, const float energy, const TrajectoryStateOnSurface &initialTrajState)

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_

bool	enableHitSkipping_

std::unique_ptr< PropagatorWithMaterial >	forwardPropagator_

edm::ESHandle< MagneticField >	magField_

edm::ESHandle< MagneticField >	magFieldParam_

std::vector< std::unique_ptr< 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::string	paramMagFieldLabel_

bool	requireExactMatchCount_

IntGlobalPointPairUnorderedMap< TrajectoryStateOnSurface >	trajStateFromPointNegChargeCache_

IntGlobalPointPairUnorderedMap< TrajectoryStateOnSurface >	trajStateFromPointPosChargeCache_

std::unordered_map< int, TrajectoryStateOnSurface >	trajStateFromVtxNegChargeCache_

std::unordered_map< int, TrajectoryStateOnSurface >	trajStateFromVtxPosChargeCache_

bool	useParamMagFieldIfDefined_

bool	useRecoVertex_

Static Private Attributes
static float	kElectronMass_ = 0.000511

static float	kPhiCut_ = -0.801144

Detailed Description

Definition at line 48 of file TrajSeedMatcher.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 23 of file TrajSeedMatcher.cc.

References L1TMuonDQMOffline_cfi::cutsPSets, Exception, edm::ParameterSet::getParameter(), matchingCuts_, minNrHits_, minNrHitsValidLayerBins_, and BeamSplash_cfg::version.

     : cacheIDMagField_(0),
       paramMagFieldLabel_(pset.getParameter<std::string>("paramMagField")),
       navSchoolLabel_(pset.getParameter<std::string>("navSchool")),
       detLayerGeomLabel_(pset.getParameter<std::string>("detLayerGeom")),
       useRecoVertex_(pset.getParameter<bool>("useRecoVertex")),
       enableHitSkipping_(pset.getParameter<bool>("enableHitSkipping")),
       requireExactMatchCount_(pset.getParameter<bool>("requireExactMatchCount")),
       useParamMagFieldIfDefined_(pset.getParameter<bool>("useParamMagFieldIfDefined")),
       minNrHits_(pset.getParameter<std::vector<unsigned int> >("minNrHits")),
       minNrHitsValidLayerBins_(pset.getParameter<std::vector<int> >("minNrHitsValidLayerBins")) {
   const auto cutsPSets = pset.getParameter<std::vector<edm::ParameterSet> >("matchingCuts");
   for (const auto& cutPSet : cutsPSets) {
     int version = cutPSet.getParameter<int>("version");
     switch (version) {
       case 1:
         matchingCuts_.emplace_back(std::make_unique<MatchingCutsV1>(cutPSet));
         break;
       case 2:
         matchingCuts_.emplace_back(std::make_unique<MatchingCutsV2>(cutPSet));
         break;
       default:
         throw cms::Exception("InvalidConfig") << " Error TrajSeedMatcher::TrajSeedMatcher pixel match cuts version "
                                               << version << " not recognised" << std::endl;
     }
   }
 
   if (minNrHitsValidLayerBins_.size() + 1 != minNrHits_.size()) {
     throw cms::Exception("InvalidConfig")
         << " TrajSeedMatcher::TrajSeedMatcher 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 301 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 110 of file TrajSeedMatcher.cc.

References backwardPropagator_, clearCache(), Exception, forwardPropagator_, getNrHitsRequired(), getNrValidLayersAlongTraj(), edm::ESHandleBase::isValid(), magField_, makeTrajStateOnSurface(), SiStripPI::max, processSeed(), requireExactMatchCount_, 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;
 
   //these are super expensive functions
   TrajectoryStateOnSurface scTrajStateOnSurfNeg = makeTrajStateOnSurface(candPos, vprim, energy, -1);
   TrajectoryStateOnSurface scTrajStateOnSurfPos = makeTrajStateOnSurface(candPos, vprim, energy, 1);
 
   for (const auto& seed : seeds) {
     std::vector<SCHitMatch> matchedHitsNeg = processSeed(seed, candPos, vprim, energy, scTrajStateOnSurfNeg);
     std::vector<SCHitMatch> matchedHitsPos = processSeed(seed, candPos, vprim, energy, scTrajStateOnSurfPos);
 
     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);
     bool matchCountPasses;
     if (requireExactMatchCount_) {
       // If the input seed collection is not cross-cleaned, an exact match is necessary to
       // prevent redundant seeds.
       matchCountPasses = matchedHitsNeg.size() == nrHitsRequired || matchedHitsPos.size() == nrHitsRequired;
     } else {
       matchCountPasses = matchedHitsNeg.size() >= nrHitsRequired || matchedHitsPos.size() >= nrHitsRequired;
     }
     if (matchCountPasses) {
       matchedSeeds.push_back({seed, matchedHitsPos, matchedHitsNeg, nrValidLayers});
     }
   }
   return matchedSeeds;
 }

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

Definition at line 97 of file TrajSeedMatcher.cc.

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

Referenced by ElectronNHitSeedProducer::produce().

                                                               {
   if (cacheIDMagField_ != iSetup.get<IdealMagneticFieldRecord>().cacheIdentifier()) {
     iSetup.get<IdealMagneticFieldRecord>().get(magField_);
     if (useParamMagFieldIfDefined_)
       iSetup.get<IdealMagneticFieldRecord>().get(paramMagFieldLabel_, magFieldParam_);
     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_);
 }

const MagneticField& TrajSeedMatcher::getMagField ( const GlobalPoint & point ) const

inlineprivate

Definition at line 254 of file TrajSeedMatcher.h.

References MagneticField::isDefined().

Referenced by getNrValidLayersAlongTraj(), makeTrajStateOnSurface(), and processSeed().

                                                                    {
     return useParamMagFieldIfDefined_ && magFieldParam_->isDefined(point) ? *magFieldParam_ : *magField_;
   }

size_t TrajSeedMatcher::getNrHitsRequired ( const int nrValidLayers ) const

private

Definition at line 385 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 SCHitMatch &	hit1,
		const SCHitMatch &	hit2,
		const GlobalPoint &	candPos,
		const GlobalPoint &	vprim,
		const float	energy,
		const int	charge
	)

private

Definition at line 317 of file TrajSeedMatcher.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, HCALHighEnergyHPDFilter_cfi::energy, forwardPropagator_, TrackingRecHit::geographicalId(), FTSFromVertexToPointFactory::get(), getMagField(), getTrajStateFromPoint(), getZVtxFromExtrapolation(), TrajSeedMatcher::SCHitMatch::hit(), TrajSeedMatcher::SCHitMatch::hitPos(), useRecoVertex_, bphysicsOniaDQM_cfi::vertex, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and HLT_FULL_cff::zVertex.

Referenced by compatibleSeeds().

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

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

private

Definition at line 333 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 240 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 223 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 202 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 363 of file TrajSeedMatcher.cc.

References GeometricSearchDet::compatibleDets(), 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 57 of file TrajSeedMatcher.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), l1GtPatternGenerator_cfi::defaults, eostools::move(), or, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ElectronNHitSeedProducer::fillDescriptions().

                                                                 {
   edm::ParameterSetDescription desc;
   desc.add<bool>("useRecoVertex", false);
   desc.add<bool>("enableHitSkipping", false);
   desc.add<bool>("requireExactMatchCount", true);
   desc.add<bool>("useParamMagFieldIfDefined", true);
   desc.add<std::string>("paramMagField", "ParabolicMf");
   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;
   auto cutDescCases = 1 >> (edm::ParameterDescription<double>("dPhiMax", 0.04, true) and
                             edm::ParameterDescription<double>("dRZMax", 0.09, true) and
                             edm::ParameterDescription<double>("dRZMaxLowEtThres", 20., true) and
                             edm::ParameterDescription<std::vector<double> >(
                                 "dRZMaxLowEtEtaBins", std::vector<double>{1., 1.5}, true) and
                             edm::ParameterDescription<std::vector<double> >(
                                 "dRZMaxLowEt", std::vector<double>{0.09, 0.15, 0.09}, true)) or
                       2 >> (edm::ParameterDescription<std::vector<double> >("dPhiMaxHighEt", {0.003}, true) and
                             edm::ParameterDescription<std::vector<double> >("dPhiMaxHighEtThres", {0.0}, true) and
                             edm::ParameterDescription<std::vector<double> >("dPhiMaxLowEtGrad", {0.0}, true) and
                             edm::ParameterDescription<std::vector<double> >("dRZMaxHighEt", {0.005}, true) and
                             edm::ParameterDescription<std::vector<double> >("dRZMaxHighEtThres", {30}, true) and
                             edm::ParameterDescription<std::vector<double> >("dRZMaxLowEtGrad", {-0.002}, true) and
                             edm::ParameterDescription<std::vector<double> >("etaBins", {}, true));
   cutsDesc.ifValue(edm::ParameterDescription<int>("version", 1, true), std::move(cutDescCases));
 
   edm::ParameterSet defaults;
   defaults.addParameter<double>("dPhiMax", 0.04);
   defaults.addParameter<double>("dRZMax", 0.09);
   defaults.addParameter<double>("dRZMaxLowEtThres", 0.09);
   defaults.addParameter<std::vector<double> >("dRZMaxLowEtEtaBins", std::vector<double>{1., 1.5});
   defaults.addParameter<std::vector<double> >("dRZMaxLowEt", std::vector<double>{0.09, 0.09, 0.09});
   defaults.addParameter<int>("version", 1);
   desc.addVPSet("matchingCuts", cutsDesc, std::vector<edm::ParameterSet>{defaults, defaults, defaults});
   return desc;
 }

TrajectoryStateOnSurface TrajSeedMatcher::makeTrajStateOnSurface	(	const GlobalPoint &	pos,
		const GlobalPoint &	vtx,
		const float	energy,
		const int	charge
	)		const

private

Definition at line 258 of file TrajSeedMatcher.cc.

References FTSFromVertexToPointFactory::get(), getMagField(), FreeTrajectoryState::momentum(), and FreeTrajectoryState::position().

Referenced by compatibleSeeds().

                                                                                          {
   FreeTrajectoryState freeTS = FTSFromVertexToPointFactory::get(getMagField(pos), pos, vtx, energy, charge);
   PerpendicularBoundPlaneBuilder bpb;
   return TrajectoryStateOnSurface(freeTS, *bpb(freeTS.position(), freeTS.momentum()));
 }

TrajSeedMatcher::SCHitMatch 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 282 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 SCHitMatch(vtxPos, trajState, *hitIt);
     }
   }
   return SCHitMatch();
 }

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

private

Definition at line 267 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 SCHitMatch(vtxPos, trajStateFromVtx, *hitIt);
   }
   return SCHitMatch();
 }

bool TrajSeedMatcher::passesMatchSel	(	const SCHitMatch &	hit,
		const size_t	hitNr
	)		const

private

Definition at line 308 of file TrajSeedMatcher.cc.

References Exception, and matchingCuts_.

Referenced by processSeed().

                                                                                                    {
   if (hitNr < matchingCuts_.size()) {
     return (*matchingCuts_[hitNr])(hit);
   } 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 214 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::SCHitMatch > TrajSeedMatcher::processSeed	(	const TrajectorySeed &	seed,
		const GlobalPoint &	candPos,
		const GlobalPoint &	vprim,
		const float	energy,
		const TrajectoryStateOnSurface &	initialTrajState
	)

private

Definition at line 157 of file TrajSeedMatcher.cc.

References backwardPropagator_, ALCARECOTkAlJpsiMuMu_cff::charge, TrajectoryStateOnSurface::charge(), enableHitSkipping_, HCALHighEnergyHPDFilter_cfi::energy, PV3DBase< T, PVType, FrameType >::eta(), forwardPropagator_, FTSFromVertexToPointFactory::get(), getMagField(), getZVtxFromExtrapolation(), TrajSeedMatcher::SCHitMatch::hitPos(), match2ndToNthHit(), muonTagProbeFilters_cff::matched, matchFirstHit(), matchingCuts_, TrajectorySeed::nHits(), passesMatchSel(), PV3DBase< T, PVType, FrameType >::phi(), TrajSeedMatcher::SCHitMatch::setExtra(), funct::sin(), PV3DBase< T, PVType, FrameType >::theta(), useRecoVertex_, bphysicsOniaDQM_cfi::vertex, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and HLT_FULL_cff::zVertex.

Referenced by compatibleSeeds().

                                                                                                                         {
   //next try passing these variables in once...
   const float candEta = candPos.eta();
   const float candEt = energy * std::sin(candPos.theta());
   const int charge = initialTrajState.charge();
 
   std::vector<SCHitMatch> matchedHits;
   FreeTrajectoryState firstHitFreeTraj;
   GlobalPoint prevHitPos;
   GlobalPoint vertex;
   for (size_t hitNr = 0; hitNr < matchingCuts_.size() && hitNr < seed.nHits(); hitNr++) {
     bool matched = false;
     if (matchedHits.empty()) {  // First hit is special
       SCHitMatch firstHit = matchFirstHit(seed, initialTrajState, vprim, *backwardPropagator_);
       firstHit.setExtra(candEt, candEta, candPos.phi(), charge, 1);
       if (passesMatchSel(firstHit, 0)) {
         matched = true;
         matchedHits.push_back(firstHit);
         //now we can figure out the z vertex
         double zVertex = useRecoVertex_ ? vprim.z() : getZVtxFromExtrapolation(vprim, firstHit.hitPos(), candPos);
         vertex = GlobalPoint(vprim.x(), vprim.y(), zVertex);
         firstHitFreeTraj =
             FTSFromVertexToPointFactory::get(getMagField(firstHit.hitPos()), firstHit.hitPos(), vertex, energy, charge);
         prevHitPos = firstHit.hitPos();
       }
     } else {  // All subsequent hits are handled the same
       SCHitMatch hit = match2ndToNthHit(seed, firstHitFreeTraj, hitNr, prevHitPos, vertex, *forwardPropagator_);
       hit.setExtra(candEt, candEta, candPos.phi(), charge, 1);
       if (passesMatchSel(hit, matchedHits.size())) {
         matched = true;
         matchedHits.push_back(hit);
         prevHitPos = hit.hitPos();
       }
     }
     if (!matched and !enableHitSkipping_)
       break;
   }
   return matchedHits;
 }