RectangularEtaPhiTrackingRegion Class Reference

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

cacheHits

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

private

Definition at line 224 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.

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

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

References checkRZOld().

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 71 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, DetLayer::location(), 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().

clone()

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

inlineoverridevirtual

Implements TrackingRegion.

Definition at line 189 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 140 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(), Surface::bounds(), PixelRecoRange< T >::empty(), f, reco::helper::VirtualJetProducerHelper::intersection(), PixelRecoRange< T >::intersection(), Bounds::length(), PixelRecoUtilities::longitudinalBendingCorrection(), PixelRecoRange< T >::max(), SiStripPI::max, PixelRecoRange< T >::mean(), PixelRecoRange< T >::min(), min(), trackingPOGFilters_cfi::phiWindow, GeometricSearchDet::position(), ptMin, CosmicsPD_Skims::radius, HitZCheck::range(), OuterHitPhiPrediction::setTolerance(), HitZCheck::setTolerance(), BarrelDetLayer::specificSurface(), sqr(), mathSSE::sqrt(), BarrelDetLayer::surface(), Bounds::thickness(), w2, PV3DBase< T, PVType, FrameType >::z(), 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 201 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(), Surface::bounds(), PixelRecoRange< T >::empty(), reco::helper::VirtualJetProducerHelper::intersection(), PixelRecoRange< T >::intersection(), PixelRecoUtilities::longitudinalBendingCorrection(), PixelRecoRange< T >::max(), PixelRecoRange< T >::mean(), PixelRecoRange< T >::min(), trackingPOGFilters_cfi::phiWindow, GeometricSearchDet::position(), ptMin, OuterHitPhiPrediction::setTolerance(), ForwardDetLayer::specificSurface(), sqr(), mathSSE::sqrt(), ForwardDetLayer::surface(), Bounds::thickness(), w2, and PV3DBase< T, PVType, FrameType >::z().

etaRange()

const Range& RectangularEtaPhiTrackingRegion::etaRange ( ) const

inline

allowed eta range [eta_min, eta_max] interval

Definition at line 166 of file RectangularEtaPhiTrackingRegion.h.

{ 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 283 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(std::move(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(std::move(ih));
      }
    }
  }
 
  // std::cout << "RectangularEtaPhiTrackingRegion hits "  << result.size() << std::endl;
 
  return result;
}

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

initEtaRange()

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

private

Definition at line 64 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.

{ return thePrecise; }

References thePrecise.

name()

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

inlineoverridevirtual

Reimplemented from TrackingRegion.

Definition at line 193 of file RectangularEtaPhiTrackingRegion.h.

{ 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.

{ return thePhiMargin; }

References thePhiMargin.

Referenced by SeedFromConsecutiveHitsCreator::makeSeed().

phiWindow()

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

private

Definition at line 256 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 396 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 264 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 50 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)";
}

References Exception, Skims_PA_cff::name, AlCaHLTBitMon_QueryRunRegistry::string, createJobs::tmp, and HcalDetIdTransform::transform().

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

tanLambdaRange()

const Range& RectangularEtaPhiTrackingRegion::tanLambdaRange ( ) const

inline

Definition at line 167 of file RectangularEtaPhiTrackingRegion.h.

{ return theLambdaRange; }

References theLambdaRange.

Referenced by SeedFromConsecutiveHitsCreator::makeSeed().

Member Data Documentation

cache

cacheHits RectangularEtaPhiTrackingRegion::cache

mutableprivate

Definition at line 230 of file RectangularEtaPhiTrackingRegion.h.

theEtaRange

Range RectangularEtaPhiTrackingRegion::theEtaRange

private

Definition at line 213 of file RectangularEtaPhiTrackingRegion.h.

Referenced by etaRange().

theLambdaRange

Range RectangularEtaPhiTrackingRegion::theLambdaRange

private

Definition at line 214 of file RectangularEtaPhiTrackingRegion.h.

Referenced by tanLambdaRange().

theMeanLambda

float RectangularEtaPhiTrackingRegion::theMeanLambda

private

Definition at line 216 of file RectangularEtaPhiTrackingRegion.h.

theMeasurementTracker

const MeasurementTrackerEvent* RectangularEtaPhiTrackingRegion::theMeasurementTracker = nullptr

private

Definition at line 221 of file RectangularEtaPhiTrackingRegion.h.

theMeasurementTrackerUsage

const UseMeasurementTracker RectangularEtaPhiTrackingRegion::theMeasurementTrackerUsage = UseMeasurementTracker::kNever

private

Definition at line 217 of file RectangularEtaPhiTrackingRegion.h.

thePhiMargin

Margin RectangularEtaPhiTrackingRegion::thePhiMargin

private

Definition at line 215 of file RectangularEtaPhiTrackingRegion.h.

Referenced by phiMargin().

thePrecise

bool RectangularEtaPhiTrackingRegion::thePrecise = false

private

Definition at line 218 of file RectangularEtaPhiTrackingRegion.h.

Referenced by isPrecise().

theUseEtaPhi

bool RectangularEtaPhiTrackingRegion::theUseEtaPhi = false

private

Definition at line 220 of file RectangularEtaPhiTrackingRegion.h.

theUseMS

bool RectangularEtaPhiTrackingRegion::theUseMS = false

private

Definition at line 219 of file RectangularEtaPhiTrackingRegion.h.