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
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 override
RectangularEtaPhiTrackingRegion *	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 const &)=delete
RectangularEtaPhiTrackingRegion &	operator= (RectangularEtaPhiTrackingRegion &&)=delete
const Margin &	phiMargin () const
std::string	print () const override
	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, bool useMS=true)
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...
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 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 = 0
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

using RectangularEtaPhiTrackingRegion::cacheHitPointer = mayown_ptr<BaseTrackerRecHit>

private

Definition at line 221 of file RectangularEtaPhiTrackingRegion.h.

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

private

Definition at line 222 of file RectangularEtaPhiTrackingRegion.h.

typedef TkTrackingRegionsMargin<float> RectangularEtaPhiTrackingRegion::Margin

Definition at line 60 of file RectangularEtaPhiTrackingRegion.h.

Member Enumeration Documentation

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

inline

Definition at line 45 of file RectangularEtaPhiTrackingRegion.h.

References operator=().

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 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::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 116 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, 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.

References initEtaRange().

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

Member Function Documentation

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

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.

References checkRZOld().

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

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.

References funct::abs(), GeomDetEnumerators::barrel, corr, SimpleLineRZ::cotLine(), f, PixelPluginsPhase0_cfi::isBarrel, DetLayer::location(), SiStripPI::max, min(), SurfaceOrientation::outer, ptMin, DetLayer::seqNum(), funct::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(), and name().

                                                                                                  {
  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 new 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 new HitZCheck(rzConstraint, HitZCheck::Margin(corr, corr));
  } else {
    auto cosThetaInv = std::sqrt(1.f + sqr(1.f / cotTheta));
    auto corr = innerScatt * cosThetaInv;
    return new HitRCheck(rzConstraint, HitRCheck::Margin(corr, corr));
  }
}

RectangularEtaPhiTrackingRegion* RectangularEtaPhiTrackingRegion::clone ( void  ) const

inlineoverridevirtual

Implements TrackingRegion.

Definition at line 189 of file RectangularEtaPhiTrackingRegion.h.

References RectangularEtaPhiTrackingRegion().

{ return new RectangularEtaPhiTrackingRegion(*this); }

static UseMeasurementTracker RectangularEtaPhiTrackingRegion::doubleToUseMeasurementTracker ( double  value )

inlinestatic

Definition at line 34 of file RectangularEtaPhiTrackingRegion.h.

References kAlways, kForSiStrips, kNever, name(), AlCaHLTBitMon_QueryRunRegistry::string, and stringToUseMeasurementTracker().

                                                                           {
    // 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 edm::EventSetup &  iSetup  ) const

private

Definition at line 140 of file RectangularEtaPhiTrackingRegion.cc.

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(), funct::sqr(), mathSSE::sqrt(), BarrelDetLayer::surface(), Bounds::thickness(), w2, PV3DBase< T, PVType, FrameType >::z(), and HLTMuonOfflineAnalyzer_cfi::z0.

Referenced by name().

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

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

private

Definition at line 201 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(), trackingPOGFilters_cfi::phiWindow, GeometricSearchDet::position(), ptMin, OuterHitPhiPrediction::setTolerance(), ForwardDetLayer::specificSurface(), funct::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(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);
}

const Range& RectangularEtaPhiTrackingRegion::etaRange ( ) const

inline

allowed eta range [eta_min, eta_max] interval

Definition at line 166 of file RectangularEtaPhiTrackingRegion.h.

References theEtaRange.

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

{ return theEtaRange; }

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.

References alongMomentum, GeomDetEnumerators::barrel, Plane::build(), utilities::cache(), watchdog::const, funct::cos(), SeedingLayerSetsHits::SeedingLayer::detLayer(), DeadROC_duringRun::dir, GeomDetEnumerators::endcap, f, edm::EventSetup::get(), h, 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.

Referenced by isPrecise().

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

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

private

Definition at line 64 of file RectangularEtaPhiTrackingRegion.cc.

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

Referenced by name(), and 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 29 of file RectangularEtaPhiTrackingRegion.h.

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

References hits(), and thePrecise.

{ return thePrecise; }

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

inlineoverridevirtual

Reimplemented from TrackingRegion.

Definition at line 191 of file RectangularEtaPhiTrackingRegion.h.

References checkRZOld(), DeadROC_duringRun::dir, dso_internal, estimator(), initEtaRange(), margin, phiWindow(), print(), rzConstraint(), and AlCaHLTBitMon_QueryRunRegistry::string.

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

{ return "RectangularEtaPhiTrackingRegion"; }

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

delete

Referenced by RectangularEtaPhiTrackingRegion().

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

References thePhiMargin.

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

{ return thePhiMargin; }

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

private

Definition at line 256 of file RectangularEtaPhiTrackingRegion.cc.

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

Referenced by name().

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

overridevirtual

Reimplemented from TrackingRegion.

Definition at line 396 of file RectangularEtaPhiTrackingRegion.cc.

References TrackingRegion::print(), and str.

Referenced by name().

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

HitRZConstraint RectangularEtaPhiTrackingRegion::rzConstraint ( ) const

private

Definition at line 264 of file RectangularEtaPhiTrackingRegion.cc.

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

Referenced by name().

                                                                    {
  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, Skims_PA_cff::name, AlCaHLTBitMon_QueryRunRegistry::string, createJobs::tmp, and HcalDetIdTransform::transform().

Referenced by AreaSeededTrackingRegionsBuilder::AreaSeededTrackingRegionsBuilder(), CandidatePointSeededTrackingRegionsProducer::CandidatePointSeededTrackingRegionsProducer(), CandidateSeededTrackingRegionsProducer::CandidateSeededTrackingRegionsProducer(), doubleToUseMeasurementTracker(), 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 167 of file RectangularEtaPhiTrackingRegion.h.

References theLambdaRange.

Referenced by SeedFromConsecutiveHitsCreator::makeSeed().

{ return theLambdaRange; }

Member Data Documentation

cacheHits RectangularEtaPhiTrackingRegion::cache

mutableprivate

Definition at line 228 of file RectangularEtaPhiTrackingRegion.h.

Range RectangularEtaPhiTrackingRegion::theEtaRange

private

Definition at line 211 of file RectangularEtaPhiTrackingRegion.h.

Referenced by etaRange().

Range RectangularEtaPhiTrackingRegion::theLambdaRange

private

Definition at line 212 of file RectangularEtaPhiTrackingRegion.h.

Referenced by tanLambdaRange().

float RectangularEtaPhiTrackingRegion::theMeanLambda

private

Definition at line 214 of file RectangularEtaPhiTrackingRegion.h.

const MeasurementTrackerEvent* RectangularEtaPhiTrackingRegion::theMeasurementTracker = 0

private

Definition at line 219 of file RectangularEtaPhiTrackingRegion.h.

const UseMeasurementTracker RectangularEtaPhiTrackingRegion::theMeasurementTrackerUsage = UseMeasurementTracker::kNever

private

Definition at line 215 of file RectangularEtaPhiTrackingRegion.h.

Margin RectangularEtaPhiTrackingRegion::thePhiMargin

private

Definition at line 213 of file RectangularEtaPhiTrackingRegion.h.

Referenced by phiMargin().

bool RectangularEtaPhiTrackingRegion::thePrecise = false

private

Definition at line 216 of file RectangularEtaPhiTrackingRegion.h.

Referenced by isPrecise().

bool RectangularEtaPhiTrackingRegion::theUseEtaPhi = false

private

Definition at line 218 of file RectangularEtaPhiTrackingRegion.h.

bool RectangularEtaPhiTrackingRegion::theUseMS = false

private

Definition at line 217 of file RectangularEtaPhiTrackingRegion.h.