#include <PixelFitterByHelixProjections.h>

Inheritance diagram for PixelFitterByHelixProjections:

Public Member Functions
	PixelFitterByHelixProjections (const edm::EventSetup es, const MagneticField field, bool scaleErrorsForBPix1, float scaleFactor)

std::unique_ptr< reco::Track >	run (const std::vector< const TrackingRecHit * > &hits, const TrackingRegion &region, const edm::EventSetup &setup) const override

	~PixelFitterByHelixProjections () override

Public Member Functions inherited from PixelFitterBase
virtual	~PixelFitterBase ()

Private Attributes
const MagneticField *	theField

const bool	thescaleErrorsForBPix1

const float	thescaleFactor

TrackerTopology const *	theTopo = 0

Detailed Description

Definition at line 15 of file PixelFitterByHelixProjections.h.

Constructor & Destructor Documentation

PixelFitterByHelixProjections::PixelFitterByHelixProjections	(	const edm::EventSetup *	es,
		const MagneticField *	field,
		bool	scaleErrorsForBPix1,
		float	scaleFactor
	)

explicit

Definition at line 91 of file PixelFitterByHelixProjections.cc.

References edm::EventSetup::get(), edm::ESHandle< T >::product(), and theTopo.

     : theField(field), thescaleErrorsForBPix1(scaleErrorsForBPix1), thescaleFactor(scaleFactor) {
   //Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopo;
   es->get<TrackerTopologyRcd>().get(tTopo);
   theTopo = tTopo.product();
 }

PixelFitterByHelixProjections::~PixelFitterByHelixProjections ( )

inlineoverride

Definition at line 21 of file PixelFitterByHelixProjections.h.

References hfClusterShapes_cfi::hits, HLT_2018_cff::region, run(), and singleTopDQM_cfi::setup.

21 {}

Member Function Documentation

std::unique_ptr< reco::Track > PixelFitterByHelixProjections::run	(	const std::vector< const TrackingRecHit * > &	hits,
		const TrackingRegion &	region,
		const edm::EventSetup &	setup
	)		const

overridevirtual

Implements PixelFitterBase.

Definition at line 102 of file PixelFitterByHelixProjections.cc.

References PV3DBase< T, PVType, FrameType >::barePhi(), PV3DBase< T, PVType, FrameType >::basicVector(), PixelTrackBuilder::build(), CircleFromThreePoints::center(), ALCARECOTkAlJpsiMuMu_cff::charge, hltPixelTracks_cff::chi2, RZLine::chi2(), funct::cos(), PixelRecoUtilities::curvature(), CircleFromThreePoints::curvature(), declareDynArray, MillePedeFileConverter_cfg::e, PixelTrackErrorParam::errCot(), PixelTrackErrorParam::errPhi(), PixelTrackErrorParam::errPt(), PixelTrackErrorParam::errTip(), PixelTrackErrorParam::errZip(), f, PixelRecoUtilities::fieldInInvGev(), mps_fire::i, PixelRecoUtilities::inversePt(), PixelPluginsPhase0_cfi::isBarrel, LIKELY, Basic2DVector< T >::mag(), nhits, TrackingRegion::origin(), phi, PixelSubdetector::PixelBarrel, DiDispStaMuonMonitor_cfi::pt, TrackerTopology::pxbLayer(), rpcPointValidation_cfi::recHit, runTheMatrix::ret, singleTopDQM_cfi::setup, funct::sin(), theField, thescaleErrorsForBPix1, thescaleFactor, theTopo, qcdUeDQM_cfi::tip, Basic2DVector< T >::x(), Basic2DVector< T >::y(), and ComparisonHelper::zip().

Referenced by ~PixelFitterByHelixProjections().

                                                                                                   {
   std::unique_ptr<reco::Track> ret;
 
   int nhits = hits.size();
   if (nhits < 2)
     return ret;
 
   declareDynArray(GlobalPoint, nhits, points);
   declareDynArray(GlobalError, nhits, errors);
   declareDynArray(bool, nhits, isBarrel);
 
   for (int i = 0; i != nhits; ++i) {
     auto const& recHit = hits[i];
     points[i] = GlobalPoint(recHit->globalPosition().basicVector() - region.origin().basicVector());
     errors[i] = recHit->globalPositionError();
     isBarrel[i] = recHit->detUnit()->type().isBarrel();
   }
 
   CircleFromThreePoints circle = (nhits == 2) ? CircleFromThreePoints(GlobalPoint(0., 0., 0.), points[0], points[1])
                                               : CircleFromThreePoints(points[0], points[1], points[2]);
 
   float valPhi, valTip, valPt;
 
   int iCharge = charge(points);
   float curvature = circle.curvature();
 
   if ((curvature > 1.e-4) && (LIKELY(PixelRecoUtilities::fieldInInvGev(setup) > 0.01))) {
     float invPt = PixelRecoUtilities::inversePt(circle.curvature(), setup);
     valPt = (invPt > 1.e-4f) ? 1.f / invPt : 1.e4f;
     CircleFromThreePoints::Vector2D center = circle.center();
     valTip = iCharge * (center.mag() - 1.f / curvature);
     valPhi = phi(center.x(), center.y(), iCharge);
   } else {
     valPt = 1.e4f;
     GlobalVector direction(points[1] - points[0]);
     valPhi = direction.barePhi();
     valTip = -points[0].x() * sin(valPhi) + points[0].y() * cos(valPhi);
   }
 
   float valCotTheta = cotTheta(points[0], points[1]);
   float valEta = std::asinh(valCotTheta);
   float valZip = zip(valTip, valPhi, curvature, points[0], points[1]);
 
   // Rescale down the error to take into accont the fact that the
   // inner pixel barrel layer for PhaseI is closer to the interaction
   // point. The effective scale factor has been derived by checking
   // that the pulls of the pixelVertices derived from the pixelTracks
   // have the correct mean and sigma.
   float errFactor = 1.;
   if (thescaleErrorsForBPix1 && (hits[0]->geographicalId().subdetId() == PixelSubdetector::PixelBarrel) &&
       (theTopo->pxbLayer(hits[0]->geographicalId()) == 1))
     errFactor = thescaleFactor;
 
   PixelTrackErrorParam param(valEta, valPt);
   float errValPt = errFactor * param.errPt();
   float errValCot = errFactor * param.errCot();
   float errValTip = errFactor * param.errTip();
   float errValPhi = errFactor * param.errPhi();
   float errValZip = errFactor * param.errZip();
 
   float chi2 = 0;
   if (nhits > 2) {
     RZLine rzLine(points, errors, isBarrel);
     chi2 = rzLine.chi2();
   }
 
   PixelTrackBuilder builder;
   Measurement1D pt(valPt, errValPt);
   Measurement1D phi(valPhi, errValPhi);
   Measurement1D cotTheta(valCotTheta, errValCot);
   Measurement1D tip(valTip, errValTip);
   Measurement1D zip(valZip, errValZip);
 
   ret.reset(builder.build(pt, phi, cotTheta, tip, zip, chi2, iCharge, hits, theField, region.origin()));
   return ret;
 }