#include <RectangularEtaPhiTrackingRegion.h>

Inheritance diagram for RectangularEtaPhiTrackingRegion:

Public Types
typedef TkTrackingRegionsMargin< float >	Margin

enum	UseMeasurementTracker { UseMeasurementTracker::kNever = -1, UseMeasurementTracker::kForSiStrips = 0, UseMeasurementTracker::kAlways = 1 }

Public Types inherited from TrackingRegion
typedef SeedingLayerSetsHits::ConstRecHitPointer	Hit

typedef SeedingLayerSetsHits::Hits	Hits

typedef PixelRecoRange< float >	Range

Public Member Functions
std::unique_ptr< HitRZCompatibility >	checkRZ (const DetLayer layer, const Hit &outerHit, const edm::EventSetup &iSetup, const DetLayer outerlayer=nullptr, float lr=0, float gz=0, float dr=0, float dz=0) const override

void	checkTracks (reco::TrackCollection const &tracks, std::vector< bool > &mask) const override

std::unique_ptr< TrackingRegion >	clone () const override

const Range &	etaRange () const
	allowed eta range [eta_min, eta_max] interval More...

TrackingRegion::Hits	hits (const edm::EventSetup &es, const SeedingLayerSetsHits::SeedingLayer &layer) const override
	get hits from layer compatible with region constraints More...

bool	isPrecise () const
	is precise error calculation switched on More...

std::string	name () const override

RectangularEtaPhiTrackingRegion &	operator= (RectangularEtaPhiTrackingRegion &&)=delete

RectangularEtaPhiTrackingRegion &	operator= (RectangularEtaPhiTrackingRegion const &)=delete

const Margin &	phiMargin () const

std::string	print () const override

	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, float deltaEta, float deltaPhi, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, bool precise=true, const MeasurementTrackerEvent *measurementTracker=nullptr, bool etaPhiRegion=false)

	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, Margin etaMargin, Margin phiMargin, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, bool precise=true, const MeasurementTrackerEvent *measurementTracker=nullptr, bool etaPhiRegion=false)

	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, Range invPtRange, float rVertex, float zVertex, Margin etaMargin, Margin phiMargin, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, bool precise=true, const MeasurementTrackerEvent *measurementTracker=nullptr, bool etaPhiRegion=false, bool useMS=true)

	RectangularEtaPhiTrackingRegion (RectangularEtaPhiTrackingRegion &&)=default

	RectangularEtaPhiTrackingRegion (RectangularEtaPhiTrackingRegion const &rh)

const Range &	tanLambdaRange () const

Public Member Functions inherited from TrackingRegion
std::vector< bool >	checkTracks (reco::TrackCollection const &tracks) const
	return a boolean mask over the TrackCollection reflecting the compatibility of each track with the region constraints More...

GlobalVector const &	direction () const
	the direction around which region is constructed More...

Range	invPtRange () const
	inverse pt range More...

GlobalPoint const &	origin () const

float	originRBound () const
	bounds the particle vertex in the transverse plane More...

float	originZBound () const
	bounds the particle vertex in the longitudinal plane More...

float	phiDirection () const

float	ptMin () const
	minimal pt of interest More...

std::unique_ptr< TrackingRegion >	restrictedRegion (const GlobalPoint &originPos, const float &originRBound, const float &originZBound) const
	clone region with new vertex position More...

	TrackingRegion (const GlobalVector &direction, const GlobalPoint &originPos, const Range &invPtRange, const float &originRBound, const float &originZBound)

GlobalVector const &	unitDirection () const

virtual	~TrackingRegion ()

Static Public Member Functions
static UseMeasurementTracker	doubleToUseMeasurementTracker (double value)

static UseMeasurementTracker	intToUseMeasurementTracker (int value)

static UseMeasurementTracker	stringToUseMeasurementTracker (const std::string &name)

Private Types
using	cacheHitPointer = mayown_ptr< BaseTrackerRecHit >

using	cacheHits = std::vector< cacheHitPointer >

Private Member Functions
std::unique_ptr< HitRZCompatibility >	checkRZOld (const DetLayer layer, const Hit &outerHit, const edm::EventSetup &iSetup, const DetLayer outerlayer) const

std::unique_ptr< MeasurementEstimator >	estimator (const BarrelDetLayer *layer, const edm::EventSetup &iSetup) const

std::unique_ptr< MeasurementEstimator >	estimator (const ForwardDetLayer *layer, const edm::EventSetup &iSetup) const

void	initEtaRange (const GlobalVector &dir, const Margin &margin)

OuterHitPhiPrediction	phiWindow (const edm::EventSetup &iSetup) const

HitRZConstraint	rzConstraint () const

Private Attributes
cacheHits	cache

Range	theEtaRange

Range	theLambdaRange

float	theMeanLambda

const MeasurementTrackerEvent *	theMeasurementTracker = nullptr

const UseMeasurementTracker	theMeasurementTrackerUsage = UseMeasurementTracker::kNever

Margin	thePhiMargin

bool	thePrecise = false

bool	theUseEtaPhi = false

bool	theUseMS = false

Detailed Description

A concrete implementation of TrackingRegion. Apart of vertex constraint from TrackingRegion in this implementation the region of interest is further constrainted in phi and eta around the direction of the region

Definition at line 25 of file RectangularEtaPhiTrackingRegion.h.

Member Typedef Documentation

◆ cacheHitPointer

using RectangularEtaPhiTrackingRegion::cacheHitPointer = mayown_ptr<BaseTrackerRecHit>

private

Definition at line 227 of file RectangularEtaPhiTrackingRegion.h.

◆ cacheHits

using RectangularEtaPhiTrackingRegion::cacheHits = std::vector<cacheHitPointer>

private

Definition at line 228 of file RectangularEtaPhiTrackingRegion.h.

◆ Margin

typedef TkTrackingRegionsMargin<float> RectangularEtaPhiTrackingRegion::Margin

Definition at line 60 of file RectangularEtaPhiTrackingRegion.h.

Member Enumeration Documentation

◆ UseMeasurementTracker

enum RectangularEtaPhiTrackingRegion::UseMeasurementTracker

strong

Enumerator
kNever
kForSiStrips
kAlways

Definition at line 27 of file RectangularEtaPhiTrackingRegion.h.

27 { kNever = -1, kForSiStrips = 0, kAlways = 1 };

Constructor & Destructor Documentation

◆ RectangularEtaPhiTrackingRegion() [1/5]

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( RectangularEtaPhiTrackingRegion const & rh )

inline

Definition at line 45 of file RectangularEtaPhiTrackingRegion.h.

       : TrackingRegion(rh),
         theEtaRange(rh.theEtaRange),
         theLambdaRange(rh.theLambdaRange),
         thePhiMargin(rh.thePhiMargin),
         theMeanLambda(rh.theMeanLambda),
         theMeasurementTrackerUsage(rh.theMeasurementTrackerUsage),
         thePrecise(rh.thePrecise),
         theUseEtaPhi(rh.theUseEtaPhi),
         theMeasurementTracker(rh.theMeasurementTracker) {}

◆ RectangularEtaPhiTrackingRegion() [2/5]

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( RectangularEtaPhiTrackingRegion && )

default

◆ RectangularEtaPhiTrackingRegion() [3/5]

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion	(	const GlobalVector &	dir,
		const GlobalPoint &	vertexPos,
		float	ptMin,
		float	rVertex,
		float	zVertex,
		float	deltaEta,
		float	deltaPhi,
		UseMeasurementTracker	whereToUseMeasurementTracker = `UseMeasurementTracker::kNever`,
		bool	precise = `true`,
		const MeasurementTrackerEvent *	measurementTracker = `nullptr`,
		bool	etaPhiRegion = `false`
	)

inline

constructor (symmetric eta and phi margins).
dir - the direction around which region is constructed
the initial direction of the momentum of the particle should be in the range
phi of dir +- deltaPhi
eta of dir +- deltaEta

vertexPos - the position of the vertex (origin) of the of the region.
It is a centre of cylinder constraind with rVertex, zVertex. The track of the particle should cross the cylinder
WARNING: in the current implementaion the vertexPos is supposed to be placed on the beam line, i.e. to be of the form (0,0,float)

ptMin - minimal pt of interest
rVertex - radius of the cylinder around beam line where the tracks of interest should point to.
zVertex - half height of the cylinder around the beam line where the tracks of interest should point to.
deltaEta - allowed deviation of the initial direction of particle in eta in respect to direction of the region
deltaPhi - allowed deviation of the initial direction of particle in phi in respect to direction of the region whereToUseMeasurementTracker: 1=everywhere, 0=outside pixles, -1=nowhere

Definition at line 87 of file RectangularEtaPhiTrackingRegion.h.

       : RectangularEtaPhiTrackingRegion(dir,
                                         vertexPos,
                                         Range(-1 / ptMin, 1 / ptMin),
                                         rVertex,
                                         zVertex,
                                         Margin(std::abs(deltaEta), std::abs(deltaEta)),
                                         Margin(std::abs(deltaPhi), std::abs(deltaPhi)),
                                         whereToUseMeasurementTracker,
                                         precise,
                                         measurementTracker,
                                         etaPhiRegion) {}

◆ RectangularEtaPhiTrackingRegion() [4/5]

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion	(	const GlobalVector &	dir,
		const GlobalPoint &	vertexPos,
		float	ptMin,
		float	rVertex,
		float	zVertex,
		Margin	etaMargin,
		Margin	phiMargin,
		UseMeasurementTracker	whereToUseMeasurementTracker = `UseMeasurementTracker::kNever`,
		bool	precise = `true`,
		const MeasurementTrackerEvent *	measurementTracker = `nullptr`,
		bool	etaPhiRegion = `false`
	)

inline

constructor (asymmetrinc eta and phi margins).
non equal left-right eta and phi bounds around direction are possible. The ranges are defined using Margin. the meaning of other arguments is the same as in the case of symmetring bounds to direction of the region.

Definition at line 116 of file RectangularEtaPhiTrackingRegion.h.

       : RectangularEtaPhiTrackingRegion(dir,
                                         vertexPos,
                                         Range(-1 / ptMin, 1 / ptMin),
                                         rVertex,
                                         zVertex,
                                         etaMargin,
                                         phiMargin,
                                         whereToUseMeasurementTracker,
                                         precise,
                                         measurementTracker,
                                         etaPhiRegion) {}

◆ RectangularEtaPhiTrackingRegion() [5/5]

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion	(	const GlobalVector &	dir,
		const GlobalPoint &	vertexPos,
		Range	invPtRange,
		float	rVertex,
		float	zVertex,
		Margin	etaMargin,
		Margin	phiMargin,
		UseMeasurementTracker	whereToUseMeasurementTracker = `UseMeasurementTracker::kNever`,
		bool	precise = `true`,
		const MeasurementTrackerEvent *	measurementTracker = `nullptr`,
		bool	etaPhiRegion = `false`,
		bool	useMS = `true`
	)

inline

constructor (explicit pt range, asymmetrinc eta and phi margins).
the meaning of other arguments is the same as in the case of symmetring bounds to direction of the region.

Definition at line 143 of file RectangularEtaPhiTrackingRegion.h.

       : TrackingRegionBase(dir, vertexPos, invPtRange, rVertex, zVertex),
         thePhiMargin(phiMargin),
         theMeasurementTrackerUsage(whereToUseMeasurementTracker),
         thePrecise(precise),
         theUseMS(useMS),
         theUseEtaPhi(etaPhiRegion),
         theMeasurementTracker(measurementTracker) {
     initEtaRange(dir, etaMargin);
   }

References DeadROC_duringRun::dir, and initEtaRange().

Member Function Documentation

◆ checkRZ()

std::unique_ptr<HitRZCompatibility> RectangularEtaPhiTrackingRegion::checkRZ	(	const DetLayer *	layer,
		const Hit &	outerHit,
		const edm::EventSetup &	iSetup,
		const DetLayer *	outerlayer = `nullptr`,
		float	lr = `0`,
		float	gz = `0`,
		float	dr = `0`,
		float	dz = `0`
	)		const

inlineoverridevirtual

utility to check eta/theta hit compatibility with region constraints and outer hit constraint

Implements TrackingRegion.

Definition at line 182 of file RectangularEtaPhiTrackingRegion.h.

                                                                            {
     return checkRZOld(layer, outerHit, iSetup, outerlayer);
   }

References checkRZOld(), and phase1PixelTopology::layer.

◆ checkRZOld()

std::unique_ptr< HitRZCompatibility > RectangularEtaPhiTrackingRegion::checkRZOld	(	const DetLayer *	layer,
		const Hit &	outerHit,
		const edm::EventSetup &	iSetup,
		const DetLayer *	outerlayer
	)		const

private

Definition at line 103 of file RectangularEtaPhiTrackingRegion.cc.

                                                                                                                   {
   bool isBarrel = (layer->location() == GeomDetEnumerators::barrel);
   GlobalPoint ohit = outerHit->globalPosition();
   float outerred_r = std::sqrt(sqr(ohit.x() - origin().x()) + sqr(ohit.y() - origin().y()));
   PixelRecoPointRZ outer(outerred_r, ohit.z());
  
   float zMinOrigin = origin().z() - originZBound();
   float zMaxOrigin = origin().z() + originZBound();
  
   if (!thePrecise) {
     float vcotMin = (outer.z() > zMaxOrigin) ? (outer.z() - zMaxOrigin) / (outer.r() + originRBound())
                                              : (outer.z() - zMaxOrigin) / (outer.r() - originRBound());
     float vcotMax = (outer.z() > zMinOrigin) ? (outer.z() - zMinOrigin) / (outer.r() - originRBound())
                                              : (outer.z() - zMinOrigin) / (outer.r() + originRBound());
     float cotRight = std::max(vcotMin, theLambdaRange.min());
     float cotLeft = std::min(vcotMax, theLambdaRange.max());
     return std::make_unique<HitEtaCheck>(isBarrel, outer, cotLeft, cotRight);
   }
  
   float outerZscatt = 0;
   float innerScatt = 0;
   //CHECK
   if (theUseMS) {
     MultipleScatteringParametrisation oSigma(layer, iSetup);
     float cotThetaOuter = theMeanLambda;
     float sinThetaOuterInv = std::sqrt(1.f + sqr(cotThetaOuter));
     outerZscatt = 3.f * oSigma(ptMin(), cotThetaOuter) * sinThetaOuterInv;
   }
  
   PixelRecoLineRZ boundL(outer, theLambdaRange.max());
   PixelRecoLineRZ boundR(outer, theLambdaRange.min());
   float zMinLine = boundL.zAtR(0.) - outerZscatt;
   float zMaxLine = boundR.zAtR(0.) + outerZscatt;
   PixelRecoPointRZ vtxL(0., max(zMinLine, zMinOrigin));
   PixelRecoPointRZ vtxR(0., min(zMaxLine, zMaxOrigin));
   PixelRecoPointRZ vtxMean(0., (vtxL.z() + vtxR.z()) * 0.5f);
   //CHECK
  
   if (theUseMS) {
     MultipleScatteringParametrisation iSigma(layer, iSetup);
  
     innerScatt =
         3.f * (outerlayer ? iSigma(ptMin(), vtxMean, outer, outerlayer->seqNum()) : iSigma(ptMin(), vtxMean, outer));
  
     // innerScatt = 3.f *iSigma( ptMin(), vtxMean, outer);
   }
  
   SimpleLineRZ leftLine(vtxL, outer);
   SimpleLineRZ rightLine(vtxR, outer);
  
   HitRZConstraint rzConstraint(leftLine, rightLine);
   auto cotTheta = std::abs(leftLine.cotLine() + rightLine.cotLine()) * 0.5f;
  
   // std::cout << "RectangularEtaPhiTrackingRegion " << outer.r()<<','<< outer.z() << " " << innerScatt << " " << cotTheta << " " <<  hitZErr <<  std::endl;
  
   if (isBarrel) {
     auto sinThetaInv = std::sqrt(1.f + sqr(cotTheta));
     auto corr = innerScatt * sinThetaInv;
     return std::make_unique<HitZCheck>(rzConstraint, HitZCheck::Margin(corr, corr));
   } else {
     auto cosThetaInv = std::sqrt(1.f + sqr(1.f / cotTheta));
     auto corr = innerScatt * cosThetaInv;
     return std::make_unique<HitRCheck>(rzConstraint, HitRCheck::Margin(corr, corr));
   }
 }

References funct::abs(), GeomDetEnumerators::barrel, alignCSCRings::corr, SimpleLineRZ::cotLine(), f, PixelPluginsPhase0_cfi::isBarrel, phase1PixelTopology::layer, SiStripPI::max, min(), SurfaceOrientation::outer, ptMin, DetLayer::seqNum(), sqr(), mathSSE::sqrt(), vtxMean(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PixelRecoPointRZ::z(), PV3DBase< T, PVType, FrameType >::z(), and PixelRecoLineRZ::zAtR().

Referenced by checkRZ().

◆ checkTracks()

void RectangularEtaPhiTrackingRegion::checkTracks	(	reco::TrackCollection const &	tracks,
		std::vector< bool > &	mask
	)		const

overridevirtual

Set the elements of the mask corresponding to the tracks that are compatable with the region. Does not reset the elements corresponding to the tracks that are not compatible.

Implements TrackingRegion.

Definition at line 51 of file RectangularEtaPhiTrackingRegion.cc.

                                                                                                                 {
   const math::XYZPoint regOrigin(origin().x(), origin().y(), origin().z());
   auto phi0 = phiDirection() + 0.5 * (phiMargin().right() - phiMargin().left());
   auto dphi = 0.5 * (phiMargin().right() + phiMargin().left());
  
   assert(mask.size() == tracks.size());
   int i = -1;
   for (auto const& track : tracks) {
     i++;
     if (mask[i])
       continue;
  
     if (track.pt() < ptMin()) {
       continue;
     }
     if (!etaRange().inside(track.eta())) {
       continue;
     }
     if (std::abs(proxim(track.phi(), phi0) - phi0) > dphi) {
       continue;
     }
     if (std::abs(track.dxy(regOrigin)) > originRBound()) {
       continue;
     }
     if (std::abs(track.dz(regOrigin)) > originZBound()) {
       continue;
     }
     mask[i] = true;
   }
 }

References funct::abs(), cms::cuda::assert(), generateTowerEtThresholdLUT::etaRange, mps_fire::i, proxim(), ptMin, HLT_FULL_cff::track, and tracks.

◆ clone()

std::unique_ptr<TrackingRegion> RectangularEtaPhiTrackingRegion::clone ( void ) const

inlineoverridevirtual

Implements TrackingRegion.

Definition at line 193 of file RectangularEtaPhiTrackingRegion.h.

                                                        {
     return std::make_unique<RectangularEtaPhiTrackingRegion>(*this);
   }

◆ doubleToUseMeasurementTracker()

static UseMeasurementTracker RectangularEtaPhiTrackingRegion::doubleToUseMeasurementTracker ( double value )

inlinestatic

Definition at line 34 of file RectangularEtaPhiTrackingRegion.h.

                                                                            {
     // mimic the old behaviour
     if (value > 0.5)
       return UseMeasurementTracker::kAlways;
     if (value > -0.5)
       return UseMeasurementTracker::kForSiStrips;
     return UseMeasurementTracker::kNever;
   }

References kAlways, kForSiStrips, and kNever.

◆ estimator() [1/2]

std::unique_ptr< MeasurementEstimator > RectangularEtaPhiTrackingRegion::estimator	(	const BarrelDetLayer *	layer,
		const edm::EventSetup &	iSetup
	)		const

private

Definition at line 172 of file RectangularEtaPhiTrackingRegion.cc.

                                                                                                                     {
   using Algo = HitZCheck;
  
   // det dimensions
   float halfLength = 0.5f * layer->surface().bounds().length();
   float halfThickness = 0.5f * layer->surface().bounds().thickness();
   float z0 = layer->position().z();
   float radius = layer->specificSurface().radius();
  
   // det ranges
   Range detRWindow(radius - halfThickness, radius + halfThickness);
   Range detZWindow(z0 - halfLength, z0 + halfLength);
  
   // z prediction, skip if not intersection
   HitZCheck zPrediction(rzConstraint());
   Range hitZWindow = zPrediction.range(detRWindow.min()).intersection(detZWindow);
   if (hitZWindow.empty())
     return nullptr;
  
   // phi prediction
   OuterHitPhiPrediction phiPrediction = phiWindow(iSetup);
  
   //
   // optional corrections for tolerance (mult.scatt, error, bending)
   //
   OuterHitPhiPrediction::Range phiRange;
   if (thePrecise) {
     auto invR = 1.f / radius;
     auto cotTheta = (hitZWindow.mean() - origin().z()) * invR;
     auto sinThetaInv = std::sqrt(1.f + sqr(cotTheta));
     MultipleScatteringParametrisation msSigma(layer, iSetup);
     auto scatt = 3.f * msSigma(ptMin(), cotTheta);
     auto bendR = longitudinalBendingCorrection(radius, ptMin(), iSetup);
  
     float hitErrRPhi = 0.;
     float hitErrZ = 0.;
     float corrPhi = (scatt + hitErrRPhi) * invR;
     float corrZ = scatt * sinThetaInv + bendR * std::abs(cotTheta) + hitErrZ;
  
     phiPrediction.setTolerance(corrPhi);
     zPrediction.setTolerance(HitZCheck::Margin(corrZ, corrZ));
  
     //
     // hit ranges in det
     //
     OuterHitPhiPrediction::Range phi1 = phiPrediction(detRWindow.min());
     OuterHitPhiPrediction::Range phi2 = phiPrediction(detRWindow.max());
     phiRange = Range(std::min(phi1.min(), phi2.min()), std::max(phi1.max(), phi2.max()));
     Range w1 = zPrediction.range(detRWindow.min());
     Range w2 = zPrediction.range(detRWindow.max());
     hitZWindow = Range(std::min(w1.min(), w2.min()), std::max(w1.max(), w2.max())).intersection(detZWindow);
   } else {
     phiRange = phiPrediction(detRWindow.mean());
   }
  
   return std::make_unique<OuterEstimator<Algo>>(OuterDetCompatibility(layer, phiRange, detRWindow, hitZWindow),
                                                 OuterHitCompatibility<Algo>(phiPrediction, zPrediction),
                                                 iSetup);
 }

References funct::abs(), PixelRecoRange< T >::empty(), f, reco::helper::VirtualJetProducerHelper::intersection(), PixelRecoRange< T >::intersection(), phase1PixelTopology::layer, PixelRecoUtilities::longitudinalBendingCorrection(), PixelRecoRange< T >::max(), SiStripPI::max, PixelRecoRange< T >::mean(), PixelRecoRange< T >::min(), min(), trackingPOGFilters_cfi::phiWindow, ptMin, CosmicsPD_Skims::radius, HitZCheck::range(), OuterHitPhiPrediction::setTolerance(), HitZCheck::setTolerance(), sqr(), mathSSE::sqrt(), w2, and HLTMuonOfflineAnalyzer_cfi::z0.

◆ estimator() [2/2]

std::unique_ptr< MeasurementEstimator > RectangularEtaPhiTrackingRegion::estimator	(	const ForwardDetLayer *	layer,
		const edm::EventSetup &	iSetup
	)		const

private

Definition at line 233 of file RectangularEtaPhiTrackingRegion.cc.

                                                                                                                     {
   using Algo = HitRCheck;
   // det dimensions, ranges
   float halfThickness = 0.5f * layer->surface().bounds().thickness();
   float zLayer = layer->position().z();
   Range detZWindow(zLayer - halfThickness, zLayer + halfThickness);
   Range detRWindow(layer->specificSurface().innerRadius(), layer->specificSurface().outerRadius());
  
   // r prediction, skip if not intersection
   HitRCheck rPrediction(rzConstraint());
   Range hitRWindow = rPrediction.range(zLayer).intersection(detRWindow);
   if (hitRWindow.empty())
     return nullptr;
  
   // phi prediction
   OuterHitPhiPrediction phiPrediction = phiWindow(iSetup);
   OuterHitPhiPrediction::Range phiRange = phiPrediction(detRWindow.max());
  
   //
   // optional corrections for tolerance (mult.scatt, error, bending)
   //
   if (thePrecise) {
     float cotTheta = (detZWindow.mean() - origin().z()) / hitRWindow.mean();
     float cosThetaInv = std::sqrt(1 + sqr(cotTheta)) / cotTheta;
     MultipleScatteringParametrisation msSigma(layer, iSetup);
     float scatt = 3.f * msSigma(ptMin(), cotTheta);
     float bendR = longitudinalBendingCorrection(hitRWindow.max(), ptMin(), iSetup);
     float hitErrRPhi = 0.;
     float hitErrR = 0.;
     float corrPhi = (scatt + hitErrRPhi) / detRWindow.min();
     float corrR = scatt * std::abs(cosThetaInv) + bendR + hitErrR;
  
     phiPrediction.setTolerance(corrPhi);
     rPrediction.setTolerance(HitRCheck::Margin(corrR, corrR));
  
     //
     // hit ranges in det
     //
     Range w1, w2;
     if (zLayer > 0) {
       w1 = rPrediction.range(detZWindow.min());
       w2 = rPrediction.range(detZWindow.max());
     } else {
       w1 = rPrediction.range(detZWindow.max());
       w2 = rPrediction.range(detZWindow.min());
     }
     hitRWindow = Range(w1.min(), w2.max()).intersection(detRWindow);
   }
  
   return std::make_unique<OuterEstimator<Algo>>(OuterDetCompatibility(layer, phiRange, hitRWindow, detZWindow),
                                                 OuterHitCompatibility<Algo>(phiPrediction, rPrediction),
                                                 iSetup);
 }

References funct::abs(), PixelRecoRange< T >::empty(), reco::helper::VirtualJetProducerHelper::intersection(), PixelRecoRange< T >::intersection(), phase1PixelTopology::layer, PixelRecoUtilities::longitudinalBendingCorrection(), PixelRecoRange< T >::max(), PixelRecoRange< T >::mean(), PixelRecoRange< T >::min(), trackingPOGFilters_cfi::phiWindow, ptMin, OuterHitPhiPrediction::setTolerance(), sqr(), mathSSE::sqrt(), and w2.

◆ etaRange()

const Range& RectangularEtaPhiTrackingRegion::etaRange ( ) const

inline

allowed eta range [eta_min, eta_max] interval

Definition at line 166 of file RectangularEtaPhiTrackingRegion.h.

166 { return theEtaRange; }

References theEtaRange.

◆ hits()

TrackingRegion::Hits RectangularEtaPhiTrackingRegion::hits	(	const edm::EventSetup &	es,
		const SeedingLayerSetsHits::SeedingLayer &	layer
	)		const

overridevirtual

get hits from layer compatible with region constraints

Implements TrackingRegion.

Definition at line 315 of file RectangularEtaPhiTrackingRegion.cc.

                                                                                                                 {
   TrackingRegion::Hits result;
  
   //ESTIMATOR
  
   const DetLayer* detLayer = layer.detLayer();
  
   bool measurementMethod = false;
   if (theMeasurementTrackerUsage == UseMeasurementTracker::kAlways)
     measurementMethod = true;
   else if (theMeasurementTrackerUsage == UseMeasurementTracker::kForSiStrips &&
            GeomDetEnumerators::isTrackerStrip(detLayer->subDetector()))
     measurementMethod = true;
  
   if (measurementMethod) {
     edm::ESHandle<MagneticField> field;
     es.get<IdealMagneticFieldRecord>().get(field);
     const MagneticField* magField = field.product();
  
     const GlobalPoint vtx = origin();
     GlobalVector dir = direction();
  
     std::unique_ptr<MeasurementEstimator> est;
     if ((GeomDetEnumerators::isTrackerPixel(detLayer->subDetector()) &&
          GeomDetEnumerators::isBarrel(detLayer->subDetector())) ||
         (!theUseEtaPhi && detLayer->location() == GeomDetEnumerators::barrel)) {
       const BarrelDetLayer& bl = dynamic_cast<const BarrelDetLayer&>(*detLayer);
       est = estimator(&bl, es);
     } else if ((GeomDetEnumerators::isTrackerPixel(detLayer->subDetector()) &&
                 GeomDetEnumerators::isEndcap(detLayer->subDetector())) ||
                (!theUseEtaPhi && detLayer->location() == GeomDetEnumerators::endcap)) {
       const ForwardDetLayer& fl = dynamic_cast<const ForwardDetLayer&>(*detLayer);
       est = estimator(&fl, es);
     }
  
     EtaPhiMeasurementEstimator etaPhiEstimator((theEtaRange.second - theEtaRange.first) * 0.5f,
                                                (thePhiMargin.left() + thePhiMargin.right()) * 0.5f);
     MeasurementEstimator* findDetAndHits = &etaPhiEstimator;
     if (est) {
       LogDebug("RectangularEtaPhiTrackingRegion") << "use pixel specific estimator.";
       findDetAndHits = est.get();
     } else {
       LogDebug("RectangularEtaPhiTrackingRegion") << "use generic etat phi estimator.";
     }
  
     // TSOS
     float phi = phiDirection();
     // std::cout << "dir " << direction().x()/direction().perp() <<','<< direction().y()/direction().perp() << " " << sin(phi) <<','<<cos(phi)<< std::endl;
     Surface::RotationType rot(sin(phi), -cos(phi), 0, 0, 0, -1, cos(phi), sin(phi), 0);
  
     Plane::PlanePointer surface = Plane::build(GlobalPoint(0., 0., 0.), rot);
     //TrajectoryStateOnSurface tsos(lpar, *surface, magField);
  
     FreeTrajectoryState fts(GlobalTrajectoryParameters(vtx, dir, 1, magField));
     TrajectoryStateOnSurface tsos(fts, *surface);
  
     // propagator
     StraightLinePropagator prop(magField, alongMomentum);
  
     LayerMeasurements lm(theMeasurementTracker->measurementTracker(), *theMeasurementTracker);
  
     auto hits = lm.recHits(*detLayer, tsos, prop, *findDetAndHits);
  
     result.reserve(hits.size());
     for (auto h : hits) {
       cache.emplace_back(h);
       result.emplace_back(h);
     }
  
     LogDebug("RectangularEtaPhiTrackingRegion")
         << " found " << hits.size() << " minus one measurements on layer: " << detLayer->subDetector();
     // std::cout << "RectangularEtaPhiTrackingRegion" <<" found "<< meas.size()<<" minus one measurements on layer: "<<detLayer->subDetector() << std::endl;
  
   } else {
     //
     // temporary solution (actually heavily used for Pixels....)
     //
     if (detLayer->location() == GeomDetEnumerators::barrel) {
       const BarrelDetLayer& bl = dynamic_cast<const BarrelDetLayer&>(*detLayer);
       auto est = estimator(&bl, es);
       if (!est)
         return result;
       using Algo = HitZCheck;
       auto const& hitComp = (reinterpret_cast<OuterEstimator<Algo> const&>(*est)).hitCompatibility();
       auto layerHits = layer.hits();
       result.reserve(layerHits.size());
       for (auto&& ih : layerHits) {
         if (hitComp(*ih))
           result.emplace_back(ih);
       }
  
     } else {
       const ForwardDetLayer& fl = dynamic_cast<const ForwardDetLayer&>(*detLayer);
       auto est = estimator(&fl, es);
       if (!est)
         return result;
       using Algo = HitRCheck;
       auto const& hitComp = (reinterpret_cast<OuterEstimator<Algo> const&>(*est)).hitCompatibility();
       auto layerHits = layer.hits();
       result.reserve(layerHits.size());
       for (auto&& ih : layerHits) {
         if (hitComp(*ih))
           result.emplace_back(ih);
       }
     }
   }
  
   // std::cout << "RectangularEtaPhiTrackingRegion hits "  << result.size() << std::endl;
  
   return result;
 }

References alongMomentum, GeomDetEnumerators::barrel, Plane::build(), utilities::cache(), watchdog::const, funct::cos(), DeadROC_duringRun::dir, GeomDetEnumerators::endcap, f, edm::EventSetup::get(), get, hfClusterShapes_cfi::hits, GeomDetEnumerators::isBarrel(), GeomDetEnumerators::isEndcap(), GeomDetEnumerators::isTrackerPixel(), GeomDetEnumerators::isTrackerStrip(), phase1PixelTopology::layer, DetLayer::location(), LogDebug, edm::ESHandle< T >::product(), mps_fire::result, makeMuonMisalignmentScenario::rot, funct::sin(), DetLayer::subDetector(), and extraflags_cff::vtx.

◆ initEtaRange()

void RectangularEtaPhiTrackingRegion::initEtaRange	(	const GlobalVector &	dir,
		const Margin &	margin
	)

private

Definition at line 96 of file RectangularEtaPhiTrackingRegion.cc.

                                                                                                 {
   float eta = dir.eta();
   theEtaRange = Range(eta - margin.left(), eta + margin.right());
   theLambdaRange = Range(std::sinh(theEtaRange.min()), std::sinh(theEtaRange.max()));
   theMeanLambda = std::sinh(theEtaRange.mean());
 }

References DeadROC_duringRun::dir, PVValHelper::eta, and margin.

Referenced by RectangularEtaPhiTrackingRegion().

◆ intToUseMeasurementTracker()

static UseMeasurementTracker RectangularEtaPhiTrackingRegion::intToUseMeasurementTracker ( int value )

inlinestatic

Definition at line 29 of file RectangularEtaPhiTrackingRegion.h.

                                                                      {
     assert(value >= -1 && value <= 1);
     return static_cast<UseMeasurementTracker>(value);
   }

References cms::cuda::assert().

Referenced by MuonTrackingRegionBuilder::build().

◆ isPrecise()

bool RectangularEtaPhiTrackingRegion::isPrecise ( ) const

inline

is precise error calculation switched on

Definition at line 174 of file RectangularEtaPhiTrackingRegion.h.

174 { return thePrecise; }

References thePrecise.

◆ name()

std::string RectangularEtaPhiTrackingRegion::name ( void ) const

inlineoverridevirtual

Reimplemented from TrackingRegion.

Definition at line 197 of file RectangularEtaPhiTrackingRegion.h.

197 { return "RectangularEtaPhiTrackingRegion"; }

Referenced by config.CFG::__str__(), and validation.Sample::digest().

◆ operator=() [1/2]

RectangularEtaPhiTrackingRegion& RectangularEtaPhiTrackingRegion::operator= ( RectangularEtaPhiTrackingRegion && )

delete

◆ operator=() [2/2]

RectangularEtaPhiTrackingRegion& RectangularEtaPhiTrackingRegion::operator= ( RectangularEtaPhiTrackingRegion const & )

delete

◆ phiMargin()

const Margin& RectangularEtaPhiTrackingRegion::phiMargin ( ) const

inline

defined phi range around phi0, margin is [phi_left,phi_right]. region is defined in a range: [phi0-phi_left, phi0+phi_right]

Definition at line 171 of file RectangularEtaPhiTrackingRegion.h.

171 { return thePhiMargin; }

References thePhiMargin.

Referenced by SeedFromConsecutiveHitsCreator::makeSeed().

◆ phiWindow()

OuterHitPhiPrediction RectangularEtaPhiTrackingRegion::phiWindow ( const edm::EventSetup & iSetup ) const

private

Definition at line 288 of file RectangularEtaPhiTrackingRegion.cc.

                                                                                                   {
   auto phi0 = phiDirection();
   return OuterHitPhiPrediction(
       OuterHitPhiPrediction::Range(phi0 - thePhiMargin.left(), phi0 + thePhiMargin.right()),
       OuterHitPhiPrediction::Range(curvature(invPtRange().min(), iSetup), curvature(invPtRange().max(), iSetup)),
       originRBound());
 }

References PixelRecoUtilities::curvature(), SiStripPI::max, and min().

◆ print()

std::string RectangularEtaPhiTrackingRegion::print ( void ) const

overridevirtual

Reimplemented from TrackingRegion.

Definition at line 428 of file RectangularEtaPhiTrackingRegion.cc.

                                                        {
   std::ostringstream str;
   str << TrackingRegionBase::print() << " eta: " << theEtaRange << " phi:" << thePhiMargin << "precise: " << thePrecise;
   return str.str();
 }

References TrackingRegion::print(), and str.

◆ rzConstraint()

HitRZConstraint RectangularEtaPhiTrackingRegion::rzConstraint ( ) const

private

Definition at line 296 of file RectangularEtaPhiTrackingRegion.cc.

                                                                     {
   HitRZConstraint::Point pLeft, pRight;
   float zMin = origin().z() - originZBound();
   float zMax = origin().z() + originZBound();
   float rMin = -originRBound();
   float rMax = originRBound();
   if (theEtaRange.max() > 0) {
     pRight = HitRZConstraint::Point(rMin, zMax);
   } else {
     pRight = HitRZConstraint::Point(rMax, zMax);
   }
   if (theEtaRange.min() > 0.) {
     pLeft = HitRZConstraint::Point(rMax, zMin);
   } else {
     pLeft = HitRZConstraint::Point(rMin, zMin);
   }
   return HitRZConstraint(pLeft, theLambdaRange.min(), pRight, theLambdaRange.max());
 }

References photonAnalyzer_cfi::rMax, photonAnalyzer_cfi::rMin, photonAnalyzer_cfi::zMax, and photonAnalyzer_cfi::zMin.

◆ stringToUseMeasurementTracker()

RectangularEtaPhiTrackingRegion::UseMeasurementTracker RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker ( const std::string & name )

static

Definition at line 82 of file RectangularEtaPhiTrackingRegion.cc.

                            {
   std::string tmp = name;
   std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
   if (tmp == "never")
     return UseMeasurementTracker::kNever;
   if (tmp == "forsistrips")
     return UseMeasurementTracker::kForSiStrips;
   if (tmp == "always")
     return UseMeasurementTracker::kAlways;
   throw cms::Exception("Configuration") << "Got invalid string '" << name
                                         << "', valid values are 'Never', 'ForSiStrips', 'Always' (case insensitive)";
 }