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
using	ctfHits = ctfseeding::SeedingLayer::Hits
typedef SeedingLayerSetsHits::ConstRecHitPointer	Hit
typedef SeedingLayerSetsHits::Hits	Hits
typedef PixelRecoRange< float >	Range

Public Member Functions
virtual HitRZCompatibility *	checkRZ (const DetLayer *layer, const Hit &outerHit, const edm::EventSetup &iSetup, const DetLayer *outerlayer=0, float lr=0, float gz=0, float dr=0, float dz=0) const
virtual RectangularEtaPhiTrackingRegion *	clone () const
const Range &	etaRange () const
	allowed eta range [eta_min, eta_max] interval More...
virtual TrackingRegion::Hits	hits (const edm::Event &ev, const edm::EventSetup &es, const SeedingLayerSetsHits::SeedingLayer &layer) const override
	get hits from layer compatible with region constraints More...
bool	isPrecise () const
	is precise error calculation switched on More...
virtual std::string	name () const
RectangularEtaPhiTrackingRegion &	operator= (RectangularEtaPhiTrackingRegion const &)=delete
RectangularEtaPhiTrackingRegion &	operator= (RectangularEtaPhiTrackingRegion &&)=default
const Margin &	phiMargin () const
virtual std::string	print () const
	RectangularEtaPhiTrackingRegion (RectangularEtaPhiTrackingRegion const &rh)
	RectangularEtaPhiTrackingRegion (RectangularEtaPhiTrackingRegion &&)=default
	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, float deltaEta, float deltaPhi, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, bool precise=true, const MeasurementTrackerEvent *measurementTracker=0, bool etaPhiRegion=false)
	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, Margin etaMargin, Margin phiMargin, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, bool precise=true, const MeasurementTrackerEvent *measurementTracker=0, bool etaPhiRegion=false)
	RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, Range invPtRange, float rVertex, float zVertex, Margin etaMargin, Margin phiMargin, UseMeasurementTracker whereToUseMeasurementTracker=UseMeasurementTracker::kNever, bool precise=true, const MeasurementTrackerEvent *measurementTracker=0, bool etaPhiRegion=false)
Public Member Functions inherited from TrackingRegion
GlobalVector const &	direction () const
	the direction around which region is constructed More...
Range	invPtRange () const
	inverse pt range More...
GlobalPoint const &	origin () const
float	originRBound () const
	bounds the particle vertex in the transverse plane More...
float	originZBound () const
	bounds the particle vertex in the longitudinal plane More...
float	phiDirection () const
float	ptMin () const
	minimal pt of interest More...
TrackingRegion *	restrictedRegion (const GlobalPoint &originPos, const float &originRBound, const float &originZBound) const
	clone region with new vertex position More...
	TrackingRegion (const GlobalVector &direction, const GlobalPoint &originPos, const Range &invPtRange, const float &originRBound, const float &originZBound)
GlobalVector const &	unitDirection () const
virtual	~TrackingRegion ()

Static Public Member Functions
static UseMeasurementTracker	doubleToUseMeasurementTracker (double value)
static UseMeasurementTracker	intToUseMeasurementTracker (int value)

Private Types
using	cacheHitPointer = mayown_ptr< BaseTrackerRecHit >
using	cacheHits = std::vector< cacheHitPointer >

Private Member Functions
HitRZCompatibility *	checkRZOld (const DetLayer *layer, const TrackingRecHit *outerHit, const edm::EventSetup &iSetup) const
OuterEstimator *	estimator (const BarrelDetLayer *layer, const edm::EventSetup &iSetup) const
OuterEstimator *	estimator (const ForwardDetLayer *layer, const edm::EventSetup &iSetup) const
void	initEtaRange (const GlobalVector &dir, const Margin &margin)
OuterHitPhiPrediction	phiWindow (const edm::EventSetup &iSetup) const
HitRZConstraint	rzConstraint () const

Private Attributes
cacheHits	cache
Range	theEtaRange
Range	theLambdaRange
float	theMeanLambda
const MeasurementTrackerEvent *	theMeasurementTracker
const UseMeasurementTracker	theMeasurementTrackerUsage
Margin	thePhiMargin
bool	thePrecise
bool	theUseEtaPhi

Detailed Description

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

Definition at line 29 of file RectangularEtaPhiTrackingRegion.h.

Member Typedef Documentation

using RectangularEtaPhiTrackingRegion::cacheHitPointer = mayown_ptr<BaseTrackerRecHit>

private

Definition at line 203 of file RectangularEtaPhiTrackingRegion.h.

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

private

Definition at line 204 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 31 of file RectangularEtaPhiTrackingRegion.h.

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

Constructor & Destructor Documentation

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( RectangularEtaPhiTrackingRegion const &  rh )

inline

Definition at line 49 of file RectangularEtaPhiTrackingRegion.h.

Referenced by clone().

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

RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion ( RectangularEtaPhiTrackingRegion &&  )

default

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

inline

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

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

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

Definition at line 91 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 112 of file RectangularEtaPhiTrackingRegion.h.

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

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

inline

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

Definition at line 131 of file RectangularEtaPhiTrackingRegion.h.

References initEtaRange().

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

Member Function Documentation

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

inlinevirtual

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

Implements TrackingRegion.

Definition at line 162 of file RectangularEtaPhiTrackingRegion.h.

References checkRZOld().

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

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

private

Definition at line 54 of file RectangularEtaPhiTrackingRegion.cc.

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

Referenced by checkRZ().

{
  edm::ESHandle<TrackerGeometry> tracker;
  iSetup.get<TrackerDigiGeometryRecord>().get(tracker);

  bool isBarrel = (layer->location() == GeomDetEnumerators::barrel);
  GlobalPoint ohit =  tracker->idToDet(outerHit->geographicalId())->surface().toGlobal(outerHit->localPosition());
  float outerred_r = sqrt( sqr(ohit.x()-origin().x())+sqr(ohit.y()-origin().y()) );
  //PixelRecoPointRZ outer(ohit.perp(), ohit.z());
  PixelRecoPointRZ outer(outerred_r, ohit.z());
  
  float zMinOrigin = origin().z() - originZBound();
  float zMaxOrigin = origin().z() + originZBound();

  if (!thePrecise) {
    float vcotMin = (outer.z() > zMaxOrigin) ?
        (outer.z()-zMaxOrigin)/(outer.r()+originRBound())
      : (outer.z()-zMaxOrigin)/(outer.r()-originRBound());
    float vcotMax = (outer.z() > zMinOrigin) ?
        (outer.z()-zMinOrigin)/(outer.r()-originRBound())
      : (outer.z()-zMinOrigin)/(outer.r()+originRBound());
    float cotRight  = std::max(vcotMin,theLambdaRange.min());
    float cotLeft = std::min(vcotMax,  theLambdaRange.max());
    return new HitEtaCheck( isBarrel, outer, cotLeft, cotRight);
  }
  float hitZErr = 0.;
  float hitRErr = 0.;

  PixelRecoPointRZ  outerL, outerR;
  if (layer->location() == GeomDetEnumerators::barrel) {
    outerL = PixelRecoPointRZ(outer.r(), outer.z()-hitZErr);
    outerR = PixelRecoPointRZ(outer.r(), outer.z()+hitZErr);
  } else if (outer.z() > 0) {
    outerL = PixelRecoPointRZ(outer.r()+hitRErr, outer.z());
    outerR = PixelRecoPointRZ(outer.r()-hitRErr, outer.z());
  } else {
    outerL = PixelRecoPointRZ(outer.r()-hitRErr, outer.z());
    outerR = PixelRecoPointRZ(outer.r()+hitRErr, outer.z());
  }
  //CHECK
  MultipleScatteringParametrisation oSigma(layer,iSetup);
  float cotThetaOuter = theMeanLambda;
  float sinThetaOuter = 1/std::sqrt(1+sqr(cotThetaOuter)); 
  float outerZscatt = 3.f*oSigma(ptMin(),cotThetaOuter) / sinThetaOuter;

  PixelRecoLineRZ boundL(outerL, theLambdaRange.max());
  PixelRecoLineRZ boundR(outerR, theLambdaRange.min());
  float zMinLine = boundL.zAtR(0.)-outerZscatt;
  float zMaxLine = boundR.zAtR(0.)+outerZscatt;
  PixelRecoPointRZ vtxL(0.,max(zMinLine, zMinOrigin));
  PixelRecoPointRZ vtxR(0.,min(zMaxLine, zMaxOrigin)); 
  PixelRecoPointRZ vtxMean(0.,(vtxL.z()+vtxR.z())*0.5f);
  //CHECK
  MultipleScatteringParametrisation iSigma(layer,iSetup);
  float innerScatt = 3.f * iSigma(ptMin(),vtxMean, outer);
  
  SimpleLineRZ leftLine( vtxL, outerL);
  SimpleLineRZ rightLine( vtxR, outerR);

  HitRZConstraint rzConstraint(leftLine, rightLine);
  float cotTheta = std::abs(leftLine.cotLine()+rightLine.cotLine())*0.5f;

//  float bendR = longitudinalBendingCorrection(outer.r(),ptMin());

  // std::cout << "RectangularEtaPhiTrackingRegion " << outer.r()<<','<< outer.z() << " " << innerScatt << " " << cotTheta << " " <<  hitZErr <<  std::endl; 

  if (isBarrel) {
    float sinTheta = 1/std::sqrt(1+sqr(cotTheta));
    float corrZ = innerScatt/sinTheta + hitZErr;
    return new HitZCheck(rzConstraint, HitZCheck::Margin(corrZ,corrZ));
  } else {
    float cosTheta = 1/std::sqrt(1+sqr(1/cotTheta));
    float corrR = innerScatt/cosTheta + hitRErr;
    return new HitRCheck( rzConstraint, HitRCheck::Margin(corrR,corrR));
  }
}

virtual RectangularEtaPhiTrackingRegion* RectangularEtaPhiTrackingRegion::clone ( void  ) const

inlinevirtual

Implements TrackingRegion.

Definition at line 169 of file RectangularEtaPhiTrackingRegion.h.

References RectangularEtaPhiTrackingRegion().

                                                         { 
    return new RectangularEtaPhiTrackingRegion(*this);
  }

static UseMeasurementTracker RectangularEtaPhiTrackingRegion::doubleToUseMeasurementTracker ( double  value )

inlinestatic

Definition at line 42 of file RectangularEtaPhiTrackingRegion.h.

References kAlways, kForSiStrips, and kNever.

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

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

OuterEstimator * RectangularEtaPhiTrackingRegion::estimator ( const BarrelDetLayer *  layer, const edm::EventSetup &  iSetup  ) const

private

Definition at line 132 of file RectangularEtaPhiTrackingRegion.cc.

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

{

  // det dimensions 
  float halfLength = 0.5f*layer->surface().bounds().length();
  float halfThickness  = 0.5f*layer->surface().bounds().thickness();
  float z0 = layer->position().z();
  float radius = layer->specificSurface().radius();

  // det ranges
  Range detRWindow (radius-halfThickness, radius+halfThickness);
  Range detZWindow(z0-halfLength,z0+halfLength);

  // z prediction, skip if not intersection
  HitZCheck zPrediction(rzConstraint());
  Range hitZWindow = zPrediction.range(detRWindow.min()).
                                               intersection(detZWindow);
  if (hitZWindow.empty()) return 0;

  // phi prediction
  OuterHitPhiPrediction phiPrediction = phiWindow(iSetup);

  //
  // optional corrections for tolerance (mult.scatt, error, bending)
  //
  OuterHitPhiPrediction::Range phiRange;
  if (thePrecise) {
    float cotTheta = (hitZWindow.mean()-origin().z()) / radius;
    float sinTheta = 1/std::sqrt(1+sqr(cotTheta));
    MultipleScatteringParametrisation msSigma(layer,iSetup);
    float scatt = 3.f * msSigma(ptMin(), cotTheta);
    float bendR = longitudinalBendingCorrection(radius,ptMin(),iSetup);
    
    float hitErrRPhi = 0.;
    float hitErrZ = 0.;
    float corrPhi = (scatt+ hitErrRPhi)/radius;
    float corrZ = scatt/sinTheta + bendR*std::abs(cotTheta) + hitErrZ;
    
    phiPrediction.setTolerance(OuterHitPhiPrediction::Margin(corrPhi,corrPhi));
    zPrediction.setTolerance(HitZCheck::Margin(corrZ,corrZ));

    //
    // hit ranges in det
    //
    OuterHitPhiPrediction::Range phi1 = phiPrediction(detRWindow.min());
    OuterHitPhiPrediction::Range phi2 = phiPrediction(detRWindow.max());
    phiRange = Range( std::min(phi1.min(),phi2.min()), std::max(phi1.max(),phi2.max()));
    Range w1 = zPrediction.range(detRWindow.min());
    Range w2 = zPrediction.range(detRWindow.max());
    hitZWindow = Range(std::min(w1.min(),w2.min()), std::max(w1.max(),w2.max())).intersection(detZWindow);
  }
  else {
    phiRange = phiPrediction(detRWindow.mean()); 
  }

  return new OuterEstimator(
                OuterDetCompatibility( layer, phiRange, detRWindow, hitZWindow),
                OuterHitCompatibility( phiPrediction, zPrediction ),
                iSetup);
}

OuterEstimator * RectangularEtaPhiTrackingRegion::estimator ( const ForwardDetLayer *  layer, const edm::EventSetup &  iSetup  ) const

private

Definition at line 194 of file RectangularEtaPhiTrackingRegion.cc.

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

{

  // det dimensions, ranges
  float halfThickness  = 0.5f*layer->surface().bounds().thickness();
  float zLayer = layer->position().z() ;
  Range detZWindow( zLayer-halfThickness, zLayer+halfThickness);
  Range detRWindow( layer->specificSurface().innerRadius(), 
                    layer->specificSurface().outerRadius());
  
  // r prediction, skip if not intersection
  HitRCheck rPrediction(rzConstraint());
  Range hitRWindow = rPrediction.range(zLayer).intersection(detRWindow);
  if (hitRWindow.empty()) return 0;

  // phi prediction
  OuterHitPhiPrediction phiPrediction = phiWindow(iSetup);
  OuterHitPhiPrediction::Range phiRange = phiPrediction(detRWindow.max());

  //
  // optional corrections for tolerance (mult.scatt, error, bending)
  //
  if (thePrecise) {
    float cotTheta = (detZWindow.mean()-origin().z())/hitRWindow.mean();
    float cosTheta = cotTheta/std::sqrt(1+sqr(cotTheta)); 
    MultipleScatteringParametrisation msSigma(layer,iSetup);
    float scatt = 3.f * msSigma(ptMin(),cotTheta);
    float bendR = longitudinalBendingCorrection(hitRWindow.max(),ptMin(),iSetup);
    float hitErrRPhi = 0.;
    float hitErrR = 0.;
    float corrPhi = (scatt+hitErrRPhi)/detRWindow.min();
    float corrR   = scatt/std::abs(cosTheta) + bendR + hitErrR;

    phiPrediction.setTolerance(OuterHitPhiPrediction::Margin(corrPhi,corrPhi));
    rPrediction.setTolerance(HitRCheck::Margin(corrR,corrR));

    //
    // hit ranges in det
    //
    Range w1,w2;
    if (zLayer > 0) {
      w1 = rPrediction.range(detZWindow.min());
      w2 = rPrediction.range(detZWindow.max());
    } else {
      w1 = rPrediction.range(detZWindow.max());
      w2 = rPrediction.range(detZWindow.min());
    }
    hitRWindow = Range(w1.min(),w2.max()).intersection(detRWindow);
  }

  return new OuterEstimator(
    OuterDetCompatibility( layer, phiRange, hitRWindow, detZWindow),
    OuterHitCompatibility( phiPrediction, rPrediction),iSetup );
}

const Range& RectangularEtaPhiTrackingRegion::etaRange ( ) const

inline

allowed eta range [eta_min, eta_max] interval

Definition at line 148 of file RectangularEtaPhiTrackingRegion.h.

References theEtaRange.

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

{ return theEtaRange; }

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

overridevirtual

get hits from layer compatible with region constraints

Implements TrackingRegion.

Definition at line 286 of file RectangularEtaPhiTrackingRegion.cc.

References alongMomentum, GeomDetEnumerators::barrel, newFWLiteAna::build, funct::cos(), SeedingLayerSetsHits::SeedingLayer::detLayer(), dir, GeomDetEnumerators::endcap, HLT_25ns14e33_v1_cff::estimator, f, edm::EventSetup::get(), h, OuterEstimator::hitCompatibility(), SeedingLayerSetsHits::SeedingLayer::hits(), DetLayer::location(), LogDebug, phi, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, edm::ESHandle< class >::product(), LayerMeasurements::recHits(), query::result, makeMuonMisalignmentScenario::rot, funct::sin(), and DetLayer::subDetector().

                                                           {
  TrackingRegion::Hits result;

  //ESTIMATOR

  const DetLayer * detLayer = layer.detLayer();
  OuterEstimator * est = 0;

  bool measurementMethod = false;
  if(theMeasurementTrackerUsage == UseMeasurementTracker::kAlways) measurementMethod = true;
  else if(theMeasurementTrackerUsage == UseMeasurementTracker::kForSiStrips &&
       !(detLayer->subDetector() == GeomDetEnumerators::PixelBarrel ||
         detLayer->subDetector() == GeomDetEnumerators::PixelEndcap) ) measurementMethod = true;

  if(measurementMethod) {
    edm::ESHandle<MagneticField> field;
    es.get<IdealMagneticFieldRecord>().get(field);
    const MagneticField * magField = field.product();
    
    const GlobalPoint vtx = origin();
    GlobalVector dir = direction();
    
    if (detLayer->subDetector() == GeomDetEnumerators::PixelBarrel || (!theUseEtaPhi  && detLayer->location() == GeomDetEnumerators::barrel)){
      const BarrelDetLayer& bl = dynamic_cast<const BarrelDetLayer&>(*detLayer);
      est = estimator(&bl,es);
    } else if (detLayer->subDetector() == GeomDetEnumerators::PixelEndcap || (!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;
    }
    else{
      LogDebug("RectangularEtaPhiTrackingRegion")<<"use generic etat phi estimator.";
    }
    
    // TSOS
    float phi = phiDirection();
    // std::cout << "dir " << direction().x()/direction().perp() <<','<< direction().y()/direction().perp() << " " << sin(phi) <<','<<cos(phi)<< std::endl;
    Surface::RotationType rot( sin(phi), -cos(phi),           0,
                   0,                0,          -1,
                   cos(phi),  sin(phi),           0);
    
    Plane::PlanePointer surface = Plane::build(GlobalPoint(0.,0.,0.), rot);
    //TrajectoryStateOnSurface tsos(lpar, *surface, magField);
    
    FreeTrajectoryState fts( GlobalTrajectoryParameters(vtx, dir, 1, magField) );
    TrajectoryStateOnSurface tsos(fts, *surface);
    
    // propagator
    StraightLinePropagator prop( magField, alongMomentum);
    
    LayerMeasurements lm(theMeasurementTracker->measurementTracker(), *theMeasurementTracker);
    
    LayerMeasurements:: SimpleHitContainer hits;
    lm.recHits(hits,*detLayer, tsos, prop, *findDetAndHits);
    /*
    {  // old code
      vector<TrajectoryMeasurement> meas = lm.measurements(*detLayer, tsos, prop, *findDetAndHits);
      auto n=0UL;
      for (auto const & im : meas) 
    if(im.recHit()->isValid()) ++n;
      assert(n==hits.size());
      // std::cout << "old/new " << n <<'/'<<hits.size() << std::endl;      
    }
    */

    result.reserve(hits.size());
    for (auto h : hits) {
      cache.emplace_back(h);
      result.emplace_back(h);
    }
  
    LogDebug("RectangularEtaPhiTrackingRegion")<<" found "<< hits.size()<<" minus one measurements on layer: "<<detLayer->subDetector();
    // std::cout << "RectangularEtaPhiTrackingRegion" <<" found "<< meas.size()<<" minus one measurements on layer: "<<detLayer->subDetector() << std::endl;
  
  } else {
    //
    // temporary solution 
    //
    if (detLayer->location() == GeomDetEnumerators::barrel) {
      const BarrelDetLayer& bl = dynamic_cast<const BarrelDetLayer&>(*detLayer);
      est = estimator(&bl,es);
    } else {
      const ForwardDetLayer& fl = dynamic_cast<const ForwardDetLayer&>(*detLayer);
      est = estimator(&fl,es);
    }
    if (!est) return result;
    
    auto layerHits = layer.hits();
    result.reserve(layerHits.size());
    for (auto && ih : layerHits) {
      if ( est->hitCompatibility()(*ih) ) {
    result.emplace_back( std::move(ih) );
      }
    }
  }
  
  // std::cout << "RectangularEtaPhiTrackingRegion hits "  << result.size() << std::endl;
  delete est;

  return result;
}

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

private

Definition at line 46 of file RectangularEtaPhiTrackingRegion.cc.

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

Referenced by RectangularEtaPhiTrackingRegion().

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

static UseMeasurementTracker RectangularEtaPhiTrackingRegion::intToUseMeasurementTracker ( int  value )

inlinestatic

Definition at line 37 of file RectangularEtaPhiTrackingRegion.h.

References assert(), and relativeConstraints::value.

Referenced by 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 155 of file RectangularEtaPhiTrackingRegion.h.

References thePrecise.

{ return thePrecise; }

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

inlinevirtual

Reimplemented from TrackingRegion.

Definition at line 173 of file RectangularEtaPhiTrackingRegion.h.

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

{ return "RectangularEtaPhiTrackingRegion"; }

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

delete

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

default

const Margin& RectangularEtaPhiTrackingRegion::phiMargin ( ) const

inline

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

Definition at line 152 of file RectangularEtaPhiTrackingRegion.h.

References thePhiMargin.

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

{ return thePhiMargin; }

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

private

Definition at line 252 of file RectangularEtaPhiTrackingRegion.cc.

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

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

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

virtual

Reimplemented from TrackingRegion.

Definition at line 398 of file RectangularEtaPhiTrackingRegion.cc.

References TrackingRegion::print().

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

HitRZConstraint RectangularEtaPhiTrackingRegion::rzConstraint ( ) const

private

Definition at line 265 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() 
             );
}

Member Data Documentation

cacheHits RectangularEtaPhiTrackingRegion::cache

mutableprivate

Definition at line 212 of file RectangularEtaPhiTrackingRegion.h.

Range RectangularEtaPhiTrackingRegion::theEtaRange

private

Definition at line 192 of file RectangularEtaPhiTrackingRegion.h.

Referenced by etaRange().

Range RectangularEtaPhiTrackingRegion::theLambdaRange

private

Definition at line 193 of file RectangularEtaPhiTrackingRegion.h.

float RectangularEtaPhiTrackingRegion::theMeanLambda

private

Definition at line 195 of file RectangularEtaPhiTrackingRegion.h.

const MeasurementTrackerEvent* RectangularEtaPhiTrackingRegion::theMeasurementTracker

private

Definition at line 199 of file RectangularEtaPhiTrackingRegion.h.

const UseMeasurementTracker RectangularEtaPhiTrackingRegion::theMeasurementTrackerUsage

private

Definition at line 196 of file RectangularEtaPhiTrackingRegion.h.

Margin RectangularEtaPhiTrackingRegion::thePhiMargin

private

Definition at line 194 of file RectangularEtaPhiTrackingRegion.h.

Referenced by phiMargin().

bool RectangularEtaPhiTrackingRegion::thePrecise

private

Definition at line 197 of file RectangularEtaPhiTrackingRegion.h.

Referenced by isPrecise().

bool RectangularEtaPhiTrackingRegion::theUseEtaPhi

private

Definition at line 198 of file RectangularEtaPhiTrackingRegion.h.