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 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 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 const &)=delete
RectangularEtaPhiTrackingRegion &	operator= (RectangularEtaPhiTrackingRegion &&)=delete
const Margin &	phiMargin () const
std::string	print () const override
	RectangularEtaPhiTrackingRegion ()
	RectangularEtaPhiTrackingRegion (RectangularEtaPhiTrackingRegion const &rh)
	RectangularEtaPhiTrackingRegion (RectangularEtaPhiTrackingRegion &&)=default
	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, float deltaEta, float deltaPhi, const MagneticField &field, const MultipleScatteringParametrisationMaker *msmaker, bool precise=true, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, const MeasurementTrackerEvent *measurementTracker=nullptr, bool etaPhiRegion=false)
	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, Margin etaMargin, Margin phiMargin, const MagneticField &field, const MultipleScatteringParametrisationMaker *msmaker, bool precise=true, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, const MeasurementTrackerEvent *measurementTracker=nullptr, bool etaPhiRegion=false)
	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, Range invPtRange, float rVertex, float zVertex, Margin etaMargin, Margin phiMargin, const MagneticField &field, const MultipleScatteringParametrisationMaker *msmaker, bool precise=true, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, const MeasurementTrackerEvent *measurementTracker=nullptr, bool etaPhiRegion=false, bool useMS=true)
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 ()
	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 DetLayer *outerlayer) const
std::unique_ptr < MeasurementEstimator >	estimator (const BarrelDetLayer *layer) const
std::unique_ptr < MeasurementEstimator >	estimator (const ForwardDetLayer *layer) const
void	initEtaRange (const GlobalVector &dir, const Margin &margin)
OuterHitPhiPrediction	phiWindow (const MagneticField &field) const
HitRZConstraint	rzConstraint () const

Private Attributes
cacheHits	cache
Range	theEtaRange
const MagneticField *	theField = nullptr
Range	theLambdaRange
float	theMeanLambda
const MeasurementTrackerEvent *	theMeasurementTracker = nullptr
const UseMeasurementTracker	theMeasurementTrackerUsage = UseMeasurementTracker::kNever
const MultipleScatteringParametrisationMaker *	theMSMaker = nullptr
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 26 of file RectangularEtaPhiTrackingRegion.h.

Member Typedef Documentation

using RectangularEtaPhiTrackingRegion::cacheHitPointer = mayown_ptr<BaseTrackerRecHit>

private

Definition at line 242 of file RectangularEtaPhiTrackingRegion.h.

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

private

Definition at line 243 of file RectangularEtaPhiTrackingRegion.h.

typedef TkTrackingRegionsMargin<float> RectangularEtaPhiTrackingRegion::Margin

Definition at line 64 of file RectangularEtaPhiTrackingRegion.h.

Member Enumeration Documentation

enum RectangularEtaPhiTrackingRegion::UseMeasurementTracker

strong

Enumerator
kNever
kForSiStrips
kAlways

Definition at line 28 of file RectangularEtaPhiTrackingRegion.h.

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

Constructor & Destructor Documentation

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( )

inline

Definition at line 46 of file RectangularEtaPhiTrackingRegion.h.

{}

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( RectangularEtaPhiTrackingRegion const &  rh )

inline

Definition at line 48 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),
        theField(rh.theField),
        theMSMaker(rh.theMSMaker) {}

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( RectangularEtaPhiTrackingRegion &&  )

default

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( const GlobalVector &  dir, const GlobalPoint &  vertexPos, float  ptMin, float  rVertex, float  zVertex, float  deltaEta, float  deltaPhi, const MagneticField &  field, const MultipleScatteringParametrisationMaker *  msmaker, bool  precise = true, UseMeasurementTracker  whereToUseMeasurementTracker = UseMeasurementTracker::kNever, 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 msmaker - Needed if either precise or useMS is true

Definition at line 92 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)),
                                        field,
                                        msmaker,
                                        precise,
                                        whereToUseMeasurementTracker,
                                        measurementTracker,
                                        etaPhiRegion) {}

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( const GlobalVector &  dir, const GlobalPoint &  vertexPos, float  ptMin, float  rVertex, float  zVertex, Margin  etaMargin, Margin  phiMargin, const MagneticField &  field, const MultipleScatteringParametrisationMaker *  msmaker, bool  precise = true, UseMeasurementTracker  whereToUseMeasurementTracker = UseMeasurementTracker::kNever, 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 125 of file RectangularEtaPhiTrackingRegion.h.

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

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( const GlobalVector &  dir, const GlobalPoint &  vertexPos, Range  invPtRange, float  rVertex, float  zVertex, Margin  etaMargin, Margin  phiMargin, const MagneticField &  field, const MultipleScatteringParametrisationMaker *  msmaker, bool  precise = true, UseMeasurementTracker  whereToUseMeasurementTracker = UseMeasurementTracker::kNever, 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 156 of file RectangularEtaPhiTrackingRegion.h.

References initEtaRange().

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

Member Function Documentation

std::unique_ptr<HitRZCompatibility> RectangularEtaPhiTrackingRegion::checkRZ ( const DetLayer *  layer, const Hit &  outerHit, 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 199 of file RectangularEtaPhiTrackingRegion.h.

References checkRZOld().

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

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

private

Definition at line 100 of file RectangularEtaPhiTrackingRegion.cc.

References funct::abs(), GeomDetEnumerators::barrel, alignCSCRings::corr, SimpleLineRZ::cotLine(), validate-o2o-wbm::f, PixelPluginsPhase0_cfi::isBarrel, DetLayer::location(), SiStripPI::max, SiStripPI::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().

                                                                                                                  {
  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 = theMSMaker->parametrisation(layer);
    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 = theMSMaker->parametrisation(layer);

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

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 48 of file RectangularEtaPhiTrackingRegion.cc.

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

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

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

inlineoverridevirtual

Implements TrackingRegion.

Definition at line 209 of file RectangularEtaPhiTrackingRegion.h.

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

static UseMeasurementTracker RectangularEtaPhiTrackingRegion::doubleToUseMeasurementTracker ( double  value )

inlinestatic

Definition at line 35 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< MeasurementEstimator > RectangularEtaPhiTrackingRegion::estimator ( const BarrelDetLayer *  layer ) const

private

Definition at line 168 of file RectangularEtaPhiTrackingRegion.cc.

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

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

  //
  // 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 = theMSMaker->parametrisation(layer);
    auto scatt = 3.f * msSigma(ptMin(), cotTheta);
    auto bendR = longitudinalBendingCorrection(radius, ptMin(), *theField);

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

std::unique_ptr< MeasurementEstimator > RectangularEtaPhiTrackingRegion::estimator ( const ForwardDetLayer *  layer ) const

private

Definition at line 227 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(), ptMin, OuterHitPhiPrediction::setTolerance(), ForwardDetLayer::specificSurface(), sqr(), mathSSE::sqrt(), ForwardDetLayer::surface(), Bounds::thickness(), w2, and PV3DBase< T, PVType, FrameType >::z().

                                                                                                                 {
  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(*theField);
  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 = theMSMaker->parametrisation(layer);
    float scatt = 3.f * msSigma(ptMin(), cotTheta);
    float bendR = longitudinalBendingCorrection(hitRWindow.max(), ptMin(), *theField);
    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));
}

const Range& RectangularEtaPhiTrackingRegion::etaRange ( ) const

inline

allowed eta range [eta_min, eta_max] interval

Definition at line 183 of file RectangularEtaPhiTrackingRegion.h.

References theEtaRange.

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

{ return theEtaRange; }

TrackingRegion::Hits RectangularEtaPhiTrackingRegion::hits ( const SeedingLayerSetsHits::SeedingLayer &  layer ) const

overridevirtual

get hits from layer compatible with region constraints

Implements TrackingRegion.

Definition at line 307 of file RectangularEtaPhiTrackingRegion.cc.

References alongMomentum, GeomDetEnumerators::barrel, Plane::build(), utilities::cache(), runTheMatrix::const, funct::cos(), SeedingLayerSetsHits::SeedingLayer::detLayer(), DeadROC_duringRun::dir, GeomDetEnumerators::endcap, validate-o2o-wbm::f, h, SeedingLayerSetsHits::SeedingLayer::hits(), GeomDetEnumerators::isBarrel(), GeomDetEnumerators::isEndcap(), GeomDetEnumerators::isTrackerPixel(), GeomDetEnumerators::isTrackerStrip(), DetLayer::location(), LogDebug, LayerMeasurements::recHits(), mps_fire::result, makeMuonMisalignmentScenario::rot, funct::sin(), and DetLayer::subDetector().

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

    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, theField);

    FreeTrajectoryState fts(GlobalTrajectoryParameters(vtx, dir, 1, theField));
    TrajectoryStateOnSurface tsos(fts, *surface);

    // propagator
    StraightLinePropagator prop(theField, 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);
      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);
      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;
}

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

private

Definition at line 93 of file RectangularEtaPhiTrackingRegion.cc.

References PVValHelper::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 30 of file RectangularEtaPhiTrackingRegion.h.

References cms::cuda::assert(), and relativeConstraints::value.

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

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

bool RectangularEtaPhiTrackingRegion::isPrecise ( ) const

inline

is precise error calculation switched on

Definition at line 191 of file RectangularEtaPhiTrackingRegion.h.

References thePrecise.

{ return thePrecise; }

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

inlineoverridevirtual

Reimplemented from TrackingRegion.

Definition at line 213 of file RectangularEtaPhiTrackingRegion.h.

Referenced by config.CFG::__str__(), geometryComparison.GeometryComparison::createScript(), validation.Sample::digest(), primaryVertexResolution.PrimaryVertexResolution::getRepMap(), primaryVertexValidation.PrimaryVertexValidation::getRepMap(), and zMuMuValidation.ZMuMuValidation::getRepMap().

{ return "RectangularEtaPhiTrackingRegion"; }

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

delete

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

delete

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

References thePhiMargin.

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

{ return thePhiMargin; }

OuterHitPhiPrediction RectangularEtaPhiTrackingRegion::phiWindow ( const MagneticField &  field ) const

private

Definition at line 280 of file RectangularEtaPhiTrackingRegion.cc.

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

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

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

overridevirtual

Reimplemented from TrackingRegion.

Definition at line 415 of file RectangularEtaPhiTrackingRegion.cc.

References TrackingRegion::print(), and str.

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

HitRZConstraint RectangularEtaPhiTrackingRegion::rzConstraint ( ) const

private

Definition at line 288 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 79 of file RectangularEtaPhiTrackingRegion.cc.

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

Referenced by AreaSeededTrackingRegionsBuilder::AreaSeededTrackingRegionsBuilder(), CandidatePointSeededTrackingRegionsProducer::CandidatePointSeededTrackingRegionsProducer(), CandidateSeededTrackingRegionsProducer::CandidateSeededTrackingRegionsProducer(), L1MuonSeededTrackingRegionsProducer::L1MuonSeededTrackingRegionsProducer(), 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)";
}

const Range& RectangularEtaPhiTrackingRegion::tanLambdaRange ( ) const

inline

Definition at line 184 of file RectangularEtaPhiTrackingRegion.h.

References theLambdaRange.

Referenced by SeedFromConsecutiveHitsCreator::makeSeed().

{ return theLambdaRange; }

Member Data Documentation

cacheHits RectangularEtaPhiTrackingRegion::cache

mutableprivate

Definition at line 249 of file RectangularEtaPhiTrackingRegion.h.

Range RectangularEtaPhiTrackingRegion::theEtaRange

private

Definition at line 230 of file RectangularEtaPhiTrackingRegion.h.

Referenced by etaRange().

const MagneticField* RectangularEtaPhiTrackingRegion::theField = nullptr

private

Definition at line 239 of file RectangularEtaPhiTrackingRegion.h.

Range RectangularEtaPhiTrackingRegion::theLambdaRange

private

Definition at line 231 of file RectangularEtaPhiTrackingRegion.h.

Referenced by tanLambdaRange().

float RectangularEtaPhiTrackingRegion::theMeanLambda

private

Definition at line 233 of file RectangularEtaPhiTrackingRegion.h.

const MeasurementTrackerEvent* RectangularEtaPhiTrackingRegion::theMeasurementTracker = nullptr

private

Definition at line 238 of file RectangularEtaPhiTrackingRegion.h.

const UseMeasurementTracker RectangularEtaPhiTrackingRegion::theMeasurementTrackerUsage = UseMeasurementTracker::kNever

private

Definition at line 234 of file RectangularEtaPhiTrackingRegion.h.

const MultipleScatteringParametrisationMaker* RectangularEtaPhiTrackingRegion::theMSMaker = nullptr

private

Definition at line 240 of file RectangularEtaPhiTrackingRegion.h.

Margin RectangularEtaPhiTrackingRegion::thePhiMargin

private

Definition at line 232 of file RectangularEtaPhiTrackingRegion.h.

Referenced by phiMargin().

bool RectangularEtaPhiTrackingRegion::thePrecise = false

private

Definition at line 235 of file RectangularEtaPhiTrackingRegion.h.

Referenced by isPrecise().

bool RectangularEtaPhiTrackingRegion::theUseEtaPhi = false

private

Definition at line 237 of file RectangularEtaPhiTrackingRegion.h.

bool RectangularEtaPhiTrackingRegion::theUseMS = false

private

Definition at line 236 of file RectangularEtaPhiTrackingRegion.h.