#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
using	ctfHits = ctfseeding::SeedingLayer::Hits

typedef SeedingLayerSetsHits::ConstRecHitPointer	Hit

typedef SeedingLayerSetsHits::Hits	Hits

typedef PixelRecoRange< float >	Range

Public Member Functions
virtual HitRZCompatibility *	checkRZ (const DetLayer layer, const Hit &outerHit, const edm::EventSetup &iSetup, const DetLayer outerlayer=0, float lr=0, float gz=0, float dr=0, float dz=0) const

virtual RectangularEtaPhiTrackingRegion *	clone () const

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

virtual TrackingRegion::Hits	hits (const edm::Event &ev, 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...

virtual std::string	name () const

RectangularEtaPhiTrackingRegion &	operator= (RectangularEtaPhiTrackingRegion const &)=delete

RectangularEtaPhiTrackingRegion &	operator= (RectangularEtaPhiTrackingRegion &&)=default

const Margin &	phiMargin () const

virtual std::string	print () const

	RectangularEtaPhiTrackingRegion (RectangularEtaPhiTrackingRegion const &rh)

	RectangularEtaPhiTrackingRegion (RectangularEtaPhiTrackingRegion &&)=default

	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=0, 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=0, 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=0, bool etaPhiRegion=false)

Public Member Functions inherited from TrackingRegion
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...

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
HitRZCompatibility *	checkRZOld (const DetLayer layer, const TrackingRecHit outerHit, const edm::EventSetup &iSetup) const

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

std::unique_ptr< OuterEstimator >	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

const UseMeasurementTracker	theMeasurementTrackerUsage

Margin	thePhiMargin

bool	thePrecise

bool	theUseEtaPhi

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 29 of file RectangularEtaPhiTrackingRegion.h.

Member Typedef Documentation

using RectangularEtaPhiTrackingRegion::cacheHitPointer = mayown_ptr<BaseTrackerRecHit>

private

Definition at line 205 of file RectangularEtaPhiTrackingRegion.h.

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

private

Definition at line 206 of file RectangularEtaPhiTrackingRegion.h.

typedef TkTrackingRegionsMargin<float> RectangularEtaPhiTrackingRegion::Margin

Definition at line 66 of file RectangularEtaPhiTrackingRegion.h.

Member Enumeration Documentation

enum RectangularEtaPhiTrackingRegion::UseMeasurementTracker

strong

Enumerator
kNever
kForSiStrips
kAlways

Definition at line 31 of file RectangularEtaPhiTrackingRegion.h.

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

Constructor & Destructor Documentation

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( RectangularEtaPhiTrackingRegion const & rh )

inline

Definition at line 51 of file RectangularEtaPhiTrackingRegion.h.

Referenced by clone().

                                                                               :
     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::RectangularEtaPhiTrackingRegion ( RectangularEtaPhiTrackingRegion && )

default

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 = `0`,
		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 93 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::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 = `0`,
		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 114 of file RectangularEtaPhiTrackingRegion.h.

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

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 = `0`,
		bool	etaPhiRegion = `false`
	)

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 133 of file RectangularEtaPhiTrackingRegion.h.

References initEtaRange().

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

Member Function Documentation

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

inlinevirtual

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

Implements TrackingRegion.

Definition at line 164 of file RectangularEtaPhiTrackingRegion.h.

References checkRZOld().

169 { return checkRZOld(layer,outerHit->hit(),iSetup); }

RectangularEtaPhiTrackingRegion::checkRZOld

HitRZCompatibility * checkRZOld(const DetLayer *layer, const TrackingRecHit *outerHit, const edm::EventSetup &iSetup) const

Definition: RectangularEtaPhiTrackingRegion.cc:70

HitRZCompatibility * RectangularEtaPhiTrackingRegion::checkRZOld	(	const DetLayer *	layer,
		const TrackingRecHit *	outerHit,
		const edm::EventSetup &	iSetup
	)		const

private

Definition at line 70 of file RectangularEtaPhiTrackingRegion.cc.

References funct::abs(), GeomDetEnumerators::barrel, SimpleLineRZ::cotLine(), f, TrackingRecHit::geographicalId(), edm::EventSetup::get(), GeomDetEnumerators::isBarrel(), TrackingRecHit::localPosition(), DetLayer::location(), bookConverter::max, min(), SurfaceOrientation::outer, PtMinSelector_cfg::ptMin, funct::sqr(), mathSSE::sqrt(), patCandidatesForDimuonsSequences_cff::tracker, vtxMean(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PixelRecoPointRZ::z(), PV3DBase< T, PVType, FrameType >::z(), and PixelRecoLineRZ::zAtR().

Referenced by checkRZ().

 {
   edm::ESHandle<TrackerGeometry> tracker;
   iSetup.get<TrackerDigiGeometryRecord>().get(tracker);
 
   bool isBarrel = (layer->location() == GeomDetEnumerators::barrel);
   GlobalPoint ohit =  tracker->idToDet(outerHit->geographicalId())->surface().toGlobal(outerHit->localPosition());
   float outerred_r = sqrt( sqr(ohit.x()-origin().x())+sqr(ohit.y()-origin().y()) );
   //PixelRecoPointRZ outer(ohit.perp(), ohit.z());
   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 new HitEtaCheck( isBarrel, outer, cotLeft, cotRight);
   }
   float hitZErr = 0.;
   float hitRErr = 0.;
 
   PixelRecoPointRZ  outerL, outerR;
   if (layer->location() == GeomDetEnumerators::barrel) {
     outerL = PixelRecoPointRZ(outer.r(), outer.z()-hitZErr);
     outerR = PixelRecoPointRZ(outer.r(), outer.z()+hitZErr);
   } else if (outer.z() > 0) {
     outerL = PixelRecoPointRZ(outer.r()+hitRErr, outer.z());
     outerR = PixelRecoPointRZ(outer.r()-hitRErr, outer.z());
   } else {
     outerL = PixelRecoPointRZ(outer.r()-hitRErr, outer.z());
     outerR = PixelRecoPointRZ(outer.r()+hitRErr, outer.z());
   }
   //CHECK
   MultipleScatteringParametrisation oSigma(layer,iSetup);
   float cotThetaOuter = theMeanLambda;
   float sinThetaOuter = 1/std::sqrt(1+sqr(cotThetaOuter)); 
   float outerZscatt = 3.f*oSigma(ptMin(),cotThetaOuter) / sinThetaOuter;
 
   PixelRecoLineRZ boundL(outerL, theLambdaRange.max());
   PixelRecoLineRZ boundR(outerR, 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
   MultipleScatteringParametrisation iSigma(layer,iSetup);
   float innerScatt = 3.f * iSigma(ptMin(),vtxMean, outer);
   
   SimpleLineRZ leftLine( vtxL, outerL);
   SimpleLineRZ rightLine( vtxR, outerR);
 
   HitRZConstraint rzConstraint(leftLine, rightLine);
   float cotTheta = std::abs(leftLine.cotLine()+rightLine.cotLine())*0.5f;
 
 //  float bendR = longitudinalBendingCorrection(outer.r(),ptMin());
 
   // std::cout << "RectangularEtaPhiTrackingRegion " << outer.r()<<','<< outer.z() << " " << innerScatt << " " << cotTheta << " " <<  hitZErr <<  std::endl; 
 
   if (isBarrel) {
     float sinTheta = 1/std::sqrt(1+sqr(cotTheta));
     float corrZ = innerScatt/sinTheta + hitZErr;
     return new HitZCheck(rzConstraint, HitZCheck::Margin(corrZ,corrZ));
   } else {
     float cosTheta = 1/std::sqrt(1+sqr(1/cotTheta));
     float corrR = innerScatt/cosTheta + hitRErr;
     return new HitRCheck( rzConstraint, HitRCheck::Margin(corrR,corrR));
   }
 }

virtual RectangularEtaPhiTrackingRegion* RectangularEtaPhiTrackingRegion::clone ( void ) const

inlinevirtual

Implements TrackingRegion.

Definition at line 171 of file RectangularEtaPhiTrackingRegion.h.

References RectangularEtaPhiTrackingRegion().

                                                          { 
     return new RectangularEtaPhiTrackingRegion(*this);
   }

static UseMeasurementTracker RectangularEtaPhiTrackingRegion::doubleToUseMeasurementTracker ( double value )

inlinestatic

Definition at line 42 of file RectangularEtaPhiTrackingRegion.h.

References kAlways, kForSiStrips, and kNever.

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

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

private

Definition at line 148 of file RectangularEtaPhiTrackingRegion.cc.

References funct::abs(), Surface::bounds(), PixelRecoRange< T >::empty(), reco::helper::VirtualJetProducerHelper::intersection(), PixelRecoRange< T >::intersection(), Bounds::length(), PixelRecoUtilities::longitudinalBendingCorrection(), PixelRecoRange< T >::max(), bookConverter::max, PixelRecoRange< T >::mean(), PixelRecoRange< T >::min(), min(), GeometricSearchDet::position(), PtMinSelector_cfg::ptMin, CosmicsPD_Skims::radius, HitZCheck::range(), OuterHitPhiPrediction::setTolerance(), HitZCheck::setTolerance(), BarrelDetLayer::specificSurface(), funct::sqr(), mathSSE::sqrt(), BarrelDetLayer::surface(), Bounds::thickness(), w2, and PV3DBase< T, PVType, FrameType >::z().

 {
 
   // 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 0;
 
   // phi prediction
   OuterHitPhiPrediction phiPrediction = phiWindow(iSetup);
 
   //
   // optional corrections for tolerance (mult.scatt, error, bending)
   //
   OuterHitPhiPrediction::Range phiRange;
   if (thePrecise) {
     float cotTheta = (hitZWindow.mean()-origin().z()) / radius;
     float sinTheta = 1/std::sqrt(1+sqr(cotTheta));
     MultipleScatteringParametrisation msSigma(layer,iSetup);
     float scatt = 3.f * msSigma(ptMin(), cotTheta);
     float bendR = longitudinalBendingCorrection(radius,ptMin(),iSetup);
     
     float hitErrRPhi = 0.;
     float hitErrZ = 0.;
     float corrPhi = (scatt+ hitErrRPhi)/radius;
     float corrZ = scatt/sinTheta + bendR*std::abs(cotTheta) + hitErrZ;
     
     phiPrediction.setTolerance(OuterHitPhiPrediction::Margin(corrPhi,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>(
                 OuterDetCompatibility( layer, phiRange, detRWindow, hitZWindow),
                 OuterHitCompatibility( phiPrediction, zPrediction ),
                 iSetup);
 }

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

private

Definition at line 210 of file RectangularEtaPhiTrackingRegion.cc.

References funct::abs(), Surface::bounds(), PixelRecoRange< T >::empty(), reco::helper::VirtualJetProducerHelper::intersection(), PixelRecoRange< T >::intersection(), PixelRecoUtilities::longitudinalBendingCorrection(), PixelRecoRange< T >::max(), PixelRecoRange< T >::mean(), PixelRecoRange< T >::min(), GeometricSearchDet::position(), PtMinSelector_cfg::ptMin, OuterHitPhiPrediction::setTolerance(), ForwardDetLayer::specificSurface(), funct::sqr(), mathSSE::sqrt(), ForwardDetLayer::surface(), Bounds::thickness(), w2, and PV3DBase< T, PVType, FrameType >::z().

 {
 
   // 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 0;
 
   // 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 cosTheta = cotTheta/std::sqrt(1+sqr(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(cosTheta) + bendR + hitErrR;
 
     phiPrediction.setTolerance(OuterHitPhiPrediction::Margin(corrPhi,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>(
     OuterDetCompatibility( layer, phiRange, hitRWindow, detZWindow),
     OuterHitCompatibility( phiPrediction, rPrediction),iSetup );
 }

const Range& RectangularEtaPhiTrackingRegion::etaRange ( ) const

inline

allowed eta range [eta_min, eta_max] interval

Definition at line 150 of file RectangularEtaPhiTrackingRegion.h.

References theEtaRange.

Referenced by FastTSGFromL2Muon::clean(), FastTSGFromIOHit::clean(), TrackerSeedCleaner::clean(), and SeedFromConsecutiveHitsCreator::makeSeed().

150 { return theEtaRange; }

RectangularEtaPhiTrackingRegion::theEtaRange

Range theEtaRange

Definition: RectangularEtaPhiTrackingRegion.h:194

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

overridevirtual

get hits from layer compatible with region constraints

Implements TrackingRegion.

Definition at line 302 of file RectangularEtaPhiTrackingRegion.cc.

References alongMomentum, GeomDetEnumerators::barrel, Plane::build(), funct::cos(), SeedingLayerSetsHits::SeedingLayer::detLayer(), dir, GeomDetEnumerators::endcap, HLT_FULL_cff::estimator, f, edm::EventSetup::get(), h, SeedingLayerSetsHits::SeedingLayer::hits(), GeomDetEnumerators::isBarrel(), GeomDetEnumerators::isEndcap(), GeomDetEnumerators::isTrackerPixel(), GeomDetEnumerators::isTrackerStrip(), DetLayer::location(), LogDebug, eostools::move(), phi(), edm::ESHandle< class >::product(), LayerMeasurements::recHits(), mps_fire::result, makeMuonMisalignmentScenario::rot, funct::sin(), and DetLayer::subDetector().

                                                            {
   TrackingRegion::Hits result;
 
   //ESTIMATOR
 
   const DetLayer * detLayer = layer.detLayer();
   std::unique_ptr<OuterEstimator> est;
 
   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();
     
     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);
     
     LayerMeasurements:: SimpleHitContainer hits;
     lm.recHits(hits,*detLayer, tsos, prop, *findDetAndHits);
     /*
     {  // old code
       vector<TrajectoryMeasurement> meas = lm.measurements(*detLayer, tsos, prop, *findDetAndHits);
       auto n=0UL;
       for (auto const & im : meas) 
     if(im.recHit()->isValid()) ++n;
       assert(n==hits.size());
       // std::cout << "old/new " << n <<'/'<<hits.size() << std::endl;      
     }
     */
 
     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 
     //
     if (detLayer->location() == GeomDetEnumerators::barrel) {
       const BarrelDetLayer& bl = dynamic_cast<const BarrelDetLayer&>(*detLayer);
       est = estimator(&bl,es);
     } else {
       const ForwardDetLayer& fl = dynamic_cast<const ForwardDetLayer&>(*detLayer);
       est = estimator(&fl,es);
     }
     if (!est) return result;
     
     auto layerHits = layer.hits();
     result.reserve(layerHits.size());
     for (auto && ih : layerHits) {
       if ( est->hitCompatibility()(*ih) ) {
     result.emplace_back( std::move(ih) );
       }
     }
   }
   
   // std::cout << "RectangularEtaPhiTrackingRegion hits "  << result.size() << std::endl;
 
   return result;
 }

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

private

Definition at line 62 of file RectangularEtaPhiTrackingRegion.cc.

References eta, PV3DBase< T, PVType, FrameType >::eta(), TkTrackingRegionsMargin< T >::left(), and TkTrackingRegionsMargin< T >::right().

Referenced by RectangularEtaPhiTrackingRegion().

                                                                                                    {
   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());
 }

static UseMeasurementTracker RectangularEtaPhiTrackingRegion::intToUseMeasurementTracker ( int value )

inlinestatic

Definition at line 37 of file RectangularEtaPhiTrackingRegion.h.

References assert(), and relativeConstraints::value.

Referenced by MuonTrackingRegionBuilder::build(), and SeedFilter::SeedFilter().

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

bool RectangularEtaPhiTrackingRegion::isPrecise ( ) const

inline

is precise error calculation switched on

Definition at line 157 of file RectangularEtaPhiTrackingRegion.h.

References thePrecise.

157 { return thePrecise; }

RectangularEtaPhiTrackingRegion::thePrecise

bool thePrecise

Definition: RectangularEtaPhiTrackingRegion.h:199

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

inlinevirtual

Reimplemented from TrackingRegion.

Definition at line 175 of file RectangularEtaPhiTrackingRegion.h.

Referenced by cuy.divideElement::__init__(), cuy.plotElement::__init__(), cuy.additionElement::__init__(), cuy.superimposeElement::__init__(), cuy.graphElement::__init__(), config.CFG::__str__(), and validation.Sample::digest().

175 { return "RectangularEtaPhiTrackingRegion"; }

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

delete

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

default

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 154 of file RectangularEtaPhiTrackingRegion.h.

References thePhiMargin.

Referenced by FastTSGFromL2Muon::clean(), FastTSGFromIOHit::clean(), TrackerSeedCleaner::clean(), and SeedFromConsecutiveHitsCreator::makeSeed().

154 { return thePhiMargin; }

RectangularEtaPhiTrackingRegion::thePhiMargin

Margin thePhiMargin

Definition: RectangularEtaPhiTrackingRegion.h:196

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

private

Definition at line 268 of file RectangularEtaPhiTrackingRegion.cc.

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

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

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

virtual

Reimplemented from TrackingRegion.

Definition at line 414 of file RectangularEtaPhiTrackingRegion.cc.

References TrackingRegion::print().

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

HitRZConstraint RectangularEtaPhiTrackingRegion::rzConstraint ( ) const

private

Definition at line 281 of file RectangularEtaPhiTrackingRegion.cc.

References PixelRecoPointRZ::z().

                                                         {
   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() 
              );
 }

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

static

Definition at line 50 of file RectangularEtaPhiTrackingRegion.cc.

References Exception, mergeVDriftHistosByStation::name, AlCaHLTBitMon_QueryRunRegistry::string, tmp, and create_public_lumi_plots::transform.

Referenced by CandidateSeededTrackingRegionsProducer::CandidateSeededTrackingRegionsProducer(), L3MumuTrackingRegion::L3MumuTrackingRegion(), PointSeededTrackingRegionsProducer::PointSeededTrackingRegionsProducer(), TauRegionalPixelSeedGenerator::TauRegionalPixelSeedGenerator(), and TrackingRegionsFromBeamSpotAndL2Tau::TrackingRegionsFromBeamSpotAndL2Tau().

                                                                                                                                          {
   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)";
 }