|
|
|
#include <RectangularEtaPhiTrackingRegion.h>
Public Types | |
| typedef TkTrackingRegionsMargin< float > | Margin |
Public Member Functions | |
| virtual HitRZCompatibility * | checkRZ (const DetLayer *layer, const Hit &outerHit, const edm::EventSetup &iSetup) const |
| virtual RectangularEtaPhiTrackingRegion * | clone () const |
| clone region | |
| const Range & | etaRange () const |
| allowed eta range [eta_min, eta_max] interval | |
| virtual TrackingRegion::Hits | hits (const edm::Event &ev, const edm::EventSetup &es, const ctfseeding::SeedingLayer *layer) const |
| get hits from layer compatible with region constraints | |
| bool | isPrecise () const |
| is precise error calculation switched on | |
| virtual std::string | name () const |
| const Margin & | phiMargin () const |
| virtual std::string | print () const |
| RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, float deltaEta, float deltaPhi, float whereToUseMeasurementTracker=0., bool precise=true, const std::string &measurementTrackerName="") | |
| RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, Margin etaMargin, Margin phiMargin, float whereToUseMeasurementTracker=0., bool precise=true, const std::string &measurementTrackerName="") | |
| RectangularEtaPhiTrackingRegion () | |
| dummy constructor | |
| RectangularEtaPhiTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, Range invPtRange, float rVertex, float zVertex, Margin etaMargin, Margin phiMargin, float whereToUseMeasurementTracker=0., bool precise=true, const std::string &measurementTrackerName="") | |
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 | |
| Range | theEtaRange |
| std::string | theMeasurementTrackerName |
| double | theMeasurementTrackerUsage |
| Margin | thePhiMargin |
| bool | thePrecise |
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 21 of file RectangularEtaPhiTrackingRegion.h.
| typedef TkTrackingRegionsMargin<float> RectangularEtaPhiTrackingRegion::Margin |
Definition at line 24 of file RectangularEtaPhiTrackingRegion.h.
| RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion | ( | ) | [inline] |
dummy constructor
Definition at line 27 of file RectangularEtaPhiTrackingRegion.h.
Referenced by clone().
{ }
| RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion | ( | const GlobalVector & | dir, |
| const GlobalPoint & | vertexPos, | ||
| float | ptMin, | ||
| float | rVertex, | ||
| float | zVertex, | ||
| float | deltaEta, | ||
| float | deltaPhi, | ||
| float | whereToUseMeasurementTracker = 0., |
||
| bool | precise = true, |
||
| const std::string & | measurementTrackerName = "" |
||
| ) | [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 54 of file RectangularEtaPhiTrackingRegion.h.
References initEtaRange().
: TrackingRegionBase( dir, vertexPos, Range( -1/ptMin, 1/ptMin), rVertex, zVertex), thePhiMargin( Margin( fabs(deltaPhi),fabs(deltaPhi))), theMeasurementTrackerUsage(whereToUseMeasurementTracker), thePrecise(precise), theMeasurementTrackerName(measurementTrackerName) { initEtaRange(dir, Margin( fabs(deltaEta),fabs(deltaEta))); }
| RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion | ( | const GlobalVector & | dir, |
| const GlobalPoint & | vertexPos, | ||
| float | ptMin, | ||
| float | rVertex, | ||
| float | zVertex, | ||
| Margin | etaMargin, | ||
| Margin | phiMargin, | ||
| float | whereToUseMeasurementTracker = 0., |
||
| bool | precise = true, |
||
| const std::string & | measurementTrackerName = "" |
||
| ) | [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 73 of file RectangularEtaPhiTrackingRegion.h.
References initEtaRange().
: TrackingRegionBase( dir, vertexPos, Range( -1/ptMin, 1/ptMin), rVertex, zVertex), thePhiMargin( phiMargin), theMeasurementTrackerUsage(whereToUseMeasurementTracker), thePrecise(precise), theMeasurementTrackerName(measurementTrackerName) { initEtaRange(dir, etaMargin); }
| RectangularEtaPhiTrackingRegion::RectangularEtaPhiTrackingRegion | ( | const GlobalVector & | dir, |
| const GlobalPoint & | vertexPos, | ||
| Range | invPtRange, | ||
| float | rVertex, | ||
| float | zVertex, | ||
| Margin | etaMargin, | ||
| Margin | phiMargin, | ||
| float | whereToUseMeasurementTracker = 0., |
||
| bool | precise = true, |
||
| const std::string & | measurementTrackerName = "" |
||
| ) | [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 89 of file RectangularEtaPhiTrackingRegion.h.
References initEtaRange().
: TrackingRegionBase( dir, vertexPos, invPtRange, rVertex, zVertex), thePhiMargin( phiMargin), theMeasurementTrackerUsage(whereToUseMeasurementTracker), thePrecise(precise), theMeasurementTrackerName(measurementTrackerName) { initEtaRange(dir, etaMargin); }
| virtual HitRZCompatibility* RectangularEtaPhiTrackingRegion::checkRZ | ( | const DetLayer * | layer, |
| const Hit & | outerHit, | ||
| const edm::EventSetup & | iSetup | ||
| ) | const [inline, virtual] |
utility to check eta/theta hit compatibility with region constraints and outer hit constraint
Implements TrackingRegionBase.
Definition at line 119 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 49 of file RectangularEtaPhiTrackingRegion.cc.
References Reference_intrackfit_cff::barrel, PixelRecoLineRZ::cotLine(), TrackingRecHit::geographicalId(), edm::EventSetup::get(), TrackingRecHit::localPosition(), DetLayer::location(), max(), min, SurfaceOrientation::outer, ExpressReco_HICollisions_FallBack::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) {
double vcotMin = (outer.z() > zMaxOrigin) ?
(outer.z()-zMaxOrigin)/(outer.r()+originRBound())
: (outer.z()-zMaxOrigin)/(outer.r()-originRBound());
double vcotMax = (outer.z() > zMinOrigin) ?
(outer.z()-zMinOrigin)/(outer.r()-originRBound())
: (outer.z()-zMinOrigin)/(outer.r()+originRBound());
float cotRight = max(vcotMin,(double) sinh(theEtaRange.min()));
float cotLeft = min(vcotMax, (double) sinh(theEtaRange.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 = sinh(theEtaRange.mean());
float sinThetaOuter = 1/sqrt(1+sqr(cotThetaOuter));
float outerZscatt = 3*oSigma(ptMin(),cotThetaOuter) / sinThetaOuter;
PixelRecoLineRZ boundL(outerL, sinh(theEtaRange.max()));
PixelRecoLineRZ boundR(outerR, sinh(theEtaRange.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())/2.);
//CHECK
MultipleScatteringParametrisation iSigma(layer,iSetup);
float innerScatt = 3 * iSigma(ptMin(),vtxMean, outer);
PixelRecoLineRZ leftLine( vtxL, outerL);
PixelRecoLineRZ rightLine( vtxR, outerR);
HitRZConstraint rzConstraint(leftLine, rightLine);
float cotTheta = fabs(leftLine.cotLine()+rightLine.cotLine())/2;
// float bendR = longitudinalBendingCorrection(outer.r(),ptMin());
if (isBarrel) {
float sinTheta = 1/sqrt(1+sqr(cotTheta));
float corrZ = innerScatt/sinTheta + hitZErr;
return new HitZCheck(rzConstraint, HitZCheck::Margin(corrZ,corrZ));
} else {
float cosTheta = 1/sqrt(1+sqr(1/cotTheta));
float corrR = innerScatt/cosTheta + hitRErr;
return new HitRCheck( rzConstraint, HitRCheck::Margin(corrR,corrR));
}
}
| virtual RectangularEtaPhiTrackingRegion* RectangularEtaPhiTrackingRegion::clone | ( | ) | const [inline, virtual] |
clone region
Implements TrackingRegionBase.
Definition at line 124 of file RectangularEtaPhiTrackingRegion.h.
References RectangularEtaPhiTrackingRegion().
{
return new RectangularEtaPhiTrackingRegion(*this);
}
| OuterEstimator * RectangularEtaPhiTrackingRegion::estimator | ( | const BarrelDetLayer * | layer, |
| const edm::EventSetup & | iSetup | ||
| ) | const [private] |
Definition at line 125 of file RectangularEtaPhiTrackingRegion.cc.
References BoundSurface::bounds(), PixelRecoRange< T >::empty(), PixelRecoRange< T >::intersection(), Bounds::length(), PixelRecoUtilities::longitudinalBendingCorrection(), max(), PixelRecoRange< T >::max(), PixelRecoRange< T >::mean(), min, PixelRecoRange< T >::min(), GeometricSearchDet::position(), ExpressReco_HICollisions_FallBack::ptMin, CosmicsPD_Skims::radius, Cylinder::radius(), HitZCheck::range(), HitZCheck::setTolerance(), OuterHitPhiPrediction::setTolerance(), BarrelDetLayer::specificSurface(), funct::sqr(), mathSSE::sqrt(), BarrelDetLayer::surface(), Bounds::thickness(), w2, and PV3DBase< T, PVType, FrameType >::z().
{
// det dimensions
float halfLength = layer->surface().bounds().length()/2;
float halfThickness = layer->surface().bounds().thickness()/2;
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/sqrt(1+sqr(cotTheta));
MultipleScatteringParametrisation msSigma(layer,iSetup);
float scatt = 3 * 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*fabs(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( min(phi1.min(),phi2.min()), max(phi1.max(),phi2.max()));
Range w1 = zPrediction.range(detRWindow.min());
Range w2 = zPrediction.range(detRWindow.max());
hitZWindow = Range(
min(w1.min(),w2.min()), 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 188 of file RectangularEtaPhiTrackingRegion.cc.
References BoundSurface::bounds(), PixelRecoRange< T >::empty(), BoundDisk::innerRadius(), PixelRecoRange< T >::intersection(), PixelRecoUtilities::longitudinalBendingCorrection(), PixelRecoRange< T >::max(), PixelRecoRange< T >::mean(), PixelRecoRange< T >::min(), BoundDisk::outerRadius(), GeometricSearchDet::position(), ExpressReco_HICollisions_FallBack::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 = layer->surface().bounds().thickness()/2;
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/sqrt(1+sqr(cotTheta));
MultipleScatteringParametrisation msSigma(layer,iSetup);
float scatt = 3 * 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/fabs(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 105 of file RectangularEtaPhiTrackingRegion.h.
References theEtaRange.
Referenced by GlobalTrajectoryBuilderBase::chooseRegionalTrackerTracks(), TrackerSeedCleaner::clean(), FastTSGFromL2Muon::clean(), FastTSGFromIOHit::clean(), and GlobalTrajectoryBuilderBase::defineRegionOfInterest().
{ return theEtaRange; }
| TrackingRegion::Hits RectangularEtaPhiTrackingRegion::hits | ( | const edm::Event & | ev, |
| const edm::EventSetup & | es, | ||
| const ctfseeding::SeedingLayer * | layer | ||
| ) | const [virtual] |
get hits from layer compatible with region constraints
Implements TrackingRegion.
Definition at line 280 of file RectangularEtaPhiTrackingRegion.cc.
References alongMomentum, Reference_intrackfit_cff::barrel, newFWLiteAna::build, OuterEstimator::center(), funct::cos(), ctfseeding::SeedingLayer::detLayer(), dir, ExpressReco_HICollisions_FallBack::estimator, edm::EventSetup::get(), OuterEstimator::hitCompatibility(), ctfseeding::SeedingLayer::hits(), DetLayer::location(), LayerMeasurements::measurements(), ExpressReco_HICollisions_FallBack::MeasurementTracker, PV3DBase< T, PVType, FrameType >::phi(), phi, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, edm::ESHandle< T >::product(), query::result, funct::sin(), and DetLayer::subDetector().
{
//ESTIMATOR
TrackingRegion::Hits result;
const DetLayer * detLayer = layer->detLayer();
OuterEstimator * est = 0;
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;
bool measurementMethod = false;
if ( theMeasurementTrackerUsage > 0.5) measurementMethod = true;
if ( theMeasurementTrackerUsage > -0.5 &&
!(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 = est->center() - vtx;
// TSOS
float phi = dir.phi();
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);
edm::ESHandle<MeasurementTracker> measurementTrackerESH;
es.get<CkfComponentsRecord>().get(theMeasurementTrackerName, measurementTrackerESH);
const MeasurementTracker * measurementTracker = measurementTrackerESH.product();
measurementTracker->update(ev);
LayerMeasurements lm(measurementTracker);
vector<TrajectoryMeasurement> meas = lm.measurements(*detLayer, tsos, prop, *est);
typedef vector<TrajectoryMeasurement>::const_iterator IM;
for (IM im = meas.begin(); im != meas.end(); im++) {
TrajectoryMeasurement::ConstRecHitPointer ptrHit = im->recHit();
if (ptrHit->isValid()) result.push_back( ptrHit );
}
} else {
//
// temporary solution
//
TrackingRegion::Hits layerHits = layer->hits(ev,es);
for (TrackingRegion::Hits::const_iterator ih= layerHits.begin(); ih != layerHits.end(); ih++) {
const TrackingRecHit * hit = (*ih)->hit();
if ( est->hitCompatibility()(hit,es) ) {
result.push_back( *ih );
}
}
}
delete est;
return result;
}
| void RectangularEtaPhiTrackingRegion::initEtaRange | ( | const GlobalVector & | dir, |
| const Margin & | margin | ||
| ) | [private] |
Definition at line 42 of file RectangularEtaPhiTrackingRegion.cc.
References eta(), PV3DBase< T, PVType, FrameType >::eta(), TkTrackingRegionsMargin< T >::left(), and TkTrackingRegionsMargin< T >::right().
Referenced by RectangularEtaPhiTrackingRegion().
{
float eta = dir.eta();
theEtaRange = Range(eta-margin.left(), eta+margin.right());
}
| bool RectangularEtaPhiTrackingRegion::isPrecise | ( | ) | const [inline] |
is precise error calculation switched on
Definition at line 112 of file RectangularEtaPhiTrackingRegion.h.
References thePrecise.
{ return thePrecise; }
| virtual std::string RectangularEtaPhiTrackingRegion::name | ( | ) | const [inline, virtual] |
Reimplemented from TrackingRegion.
Definition at line 128 of file RectangularEtaPhiTrackingRegion.h.
{ return "RectangularEtaPhiTrackingRegion"; }
| 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 109 of file RectangularEtaPhiTrackingRegion.h.
References thePhiMargin.
Referenced by GlobalTrajectoryBuilderBase::chooseRegionalTrackerTracks(), TrackerSeedCleaner::clean(), FastTSGFromIOHit::clean(), FastTSGFromL2Muon::clean(), and GlobalTrajectoryBuilderBase::defineRegionOfInterest().
{ return thePhiMargin; }
| OuterHitPhiPrediction RectangularEtaPhiTrackingRegion::phiWindow | ( | const edm::EventSetup & | iSetup | ) | const [private] |
Definition at line 246 of file RectangularEtaPhiTrackingRegion.cc.
References PixelRecoUtilities::curvature(), max(), and min.
{
float phi0 = direction().phi();
return OuterHitPhiPrediction(
OuterHitPhiPrediction::Range( phi0-thePhiMargin.left(),
phi0+thePhiMargin.left()),
OuterHitPhiPrediction::Range( curvature(invPtRange().min(),iSetup),
curvature(invPtRange().max(),iSetup)),
originRBound());
}
| std::string RectangularEtaPhiTrackingRegion::print | ( | void | ) | const [virtual] |
Reimplemented from TrackingRegionBase.
Definition at line 360 of file RectangularEtaPhiTrackingRegion.cc.
References reco::print().
{
std::ostringstream str;
str << TrackingRegionBase::print()
<<" eta: "<<theEtaRange<<" phi:"<<thePhiMargin
<< "precise: "<<thePrecise;
return str.str();
}
| HitRZConstraint RectangularEtaPhiTrackingRegion::rzConstraint | ( | ) | const [private] |
Definition at line 259 of file RectangularEtaPhiTrackingRegion.cc.
References PixelRecoPointRZ::z().
{
HitRZConstraint::LineOrigin pLeft,pRight;
float zMin = origin().z() - originZBound();
float zMax = origin().z() + originZBound();
float rMin = -originRBound();
float rMax = originRBound();
if(theEtaRange.max() > 0) {
pRight = HitRZConstraint::LineOrigin(rMin,zMax);
} else {
pRight = HitRZConstraint::LineOrigin(rMax,zMax);
}
if (theEtaRange.min() > 0.) {
pLeft = HitRZConstraint::LineOrigin(rMax, zMin);
} else {
pLeft = HitRZConstraint::LineOrigin(rMin, zMin);
}
return HitRZConstraint(pLeft, sinh(theEtaRange.min()),
pRight, sinh(theEtaRange.max()) );
}
Definition at line 147 of file RectangularEtaPhiTrackingRegion.h.
Referenced by etaRange().
std::string RectangularEtaPhiTrackingRegion::theMeasurementTrackerName [private] |
Definition at line 151 of file RectangularEtaPhiTrackingRegion.h.
double RectangularEtaPhiTrackingRegion::theMeasurementTrackerUsage [private] |
Definition at line 149 of file RectangularEtaPhiTrackingRegion.h.
Definition at line 148 of file RectangularEtaPhiTrackingRegion.h.
Referenced by phiMargin().
bool RectangularEtaPhiTrackingRegion::thePrecise [private] |
Definition at line 150 of file RectangularEtaPhiTrackingRegion.h.
Referenced by isPrecise().
1.7.3