#include <PixelFitterByHelixProjections.h>

Inheritance diagram for PixelFitterByHelixProjections:

Public Member Functions
	PixelFitterByHelixProjections (const edm::ParameterSet &cfg)

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

virtual	~PixelFitterByHelixProjections ()

Public Member Functions inherited from PixelFitter
virtual reco::Track *	run (const edm::Event &ev, const edm::EventSetup &es, const std::vector< const TrackingRecHit * > &hits, const TrackingRegion &region) const

virtual	~PixelFitter ()

Private Attributes
edm::ParameterSet	theConfig

const MagneticField *	theField

edm::ESWatcher < IdealMagneticFieldRecord >	theFieldWatcher

const TrackerGeometry *	theTracker

edm::ESWatcher < TrackerDigiGeometryRecord >	theTrackerWatcher

const TransientTrackingRecHitBuilder *	theTTRecHitBuilder

edm::ESWatcher < TransientRecHitRecord >	theTTRecHitBuilderWatcher

Detailed Description

Definition at line 23 of file PixelFitterByHelixProjections.h.

Constructor & Destructor Documentation

PixelFitterByHelixProjections::PixelFitterByHelixProjections ( const edm::ParameterSet & cfg )

Definition at line 95 of file PixelFitterByHelixProjections.cc.

97 : theConfig(cfg), theTracker(0), theField(0), theTTRecHitBuilder(0) {}

PixelFitterByHelixProjections::theField

const MagneticField * theField

Definition: PixelFitterByHelixProjections.h:47

PixelFitterByHelixProjections::theTracker

const TrackerGeometry * theTracker

Definition: PixelFitterByHelixProjections.h:46

PixelFitterByHelixProjections::theConfig

edm::ParameterSet theConfig

Definition: PixelFitterByHelixProjections.h:44

PixelFitterByHelixProjections::theTTRecHitBuilder

const TransientTrackingRecHitBuilder * theTTRecHitBuilder

Definition: PixelFitterByHelixProjections.h:48

virtual PixelFitterByHelixProjections::~PixelFitterByHelixProjections ( )

inlinevirtual

Definition at line 26 of file PixelFitterByHelixProjections.h.

26 {}

Member Function Documentation

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

virtual

Reimplemented from PixelFitter.

Definition at line 99 of file PixelFitterByHelixProjections.cc.

References PixelTrackBuilder::build(), CircleFromThreePoints::center(), edm::ESWatcher< T >::check(), RZLine::chi2(), funct::cos(), PixelRecoUtilities::curvature(), CircleFromThreePoints::curvature(), alignCSCRings::e, PixelTrackErrorParam::errCot(), benchmark_cfg::errors, PixelTrackErrorParam::errPhi(), PixelTrackErrorParam::errPt(), PixelTrackErrorParam::errTip(), PixelTrackErrorParam::errZip(), f, RZLine::fit(), edm::EventSetup::get(), edm::ParameterSet::getParameter(), i, MagneticField::inTesla(), PixelRecoUtilities::inversePt(), likely, Basic2DVector< T >::mag(), TrackingRegion::origin(), phi, PV3DBase< T, PVType, FrameType >::phi(), edm::ESHandle< class >::product(), RecoTauCleanerPlugins::pt, funct::sin(), AlCaHLTBitMon_QueryRunRegistry::string, theConfig, theField, theFieldWatcher, theTracker, theTrackerWatcher, theTTRecHitBuilder, theTTRecHitBuilderWatcher, PV3DBase< T, PVType, FrameType >::x(), Basic2DVector< T >::x(), PV3DBase< T, PVType, FrameType >::y(), Basic2DVector< T >::y(), PV3DBase< T, PVType, FrameType >::z(), and archive::zip.

 {
   int nhits = hits.size();
   if (nhits <2) return 0;
 
   vector<GlobalPoint> points(nhits);
   vector<GlobalError> errors(nhits);
   vector<bool> isBarrel(nhits);
   
   if (theTrackerWatcher.check(es)) {
     edm::ESHandle<TrackerGeometry> trackerESH;
     es.get<TrackerDigiGeometryRecord>().get(trackerESH);
     theTracker = trackerESH.product();
   }
 
   if (theFieldWatcher.check(es)) {
     edm::ESHandle<MagneticField> fieldESH;
     es.get<IdealMagneticFieldRecord>().get(fieldESH);
     theField = fieldESH.product();
   }
 
   if (theTTRecHitBuilderWatcher.check(es)) {
     edm::ESHandle<TransientTrackingRecHitBuilder> ttrhbESH;
     std::string builderName = theConfig.getParameter<std::string>("TTRHBuilder");
     es.get<TransientRecHitRecord>().get(builderName,ttrhbESH);
     theTTRecHitBuilder = ttrhbESH.product();
   }
 
 
   for ( int i=0; i!=nhits; ++i) {
     auto const & recHit = hits[i];
     points[i]  = GlobalPoint( recHit->globalPosition().x()-region.origin().x(), 
                   recHit->globalPosition().y()-region.origin().y(),
                   recHit->globalPosition().z()-region.origin().z() 
                   );
     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(theField->inTesla(GlobalPoint(0.,0.,0.)).z()>0.01))) {
     float invPt = PixelRecoUtilities::inversePt( circle.curvature(), es);
     valPt = (invPt > 1.e-4f) ? 1.f/invPt : 1.e4f;
     CircleFromThreePoints::Vector2D center = circle.center();
     valTip = iCharge * (center.mag()-1.f/curvature);
     valPhi = func_phi(center.x(), center.y(), iCharge);
   } 
   else {
     valPt = 1.e4f; 
     GlobalVector direction(points[1]-points[0]);
     valPhi =  direction.phi(); 
     valTip = -points[0].x()*sin(valPhi) + points[0].y()*cos(valPhi); 
   }
 
   float valCotTheta = cotTheta(points[0],points[1]);
   float valEta = asinh(valCotTheta);
   float valZip = zip(valTip, valPhi, curvature, points[0],points[1]);
 
   PixelTrackErrorParam param(valEta, valPt);
   float errValPt  = param.errPt();
   float errValCot = param.errCot();
   float errValTip = param.errTip();
   float errValPhi = param.errPhi();
   float errValZip = param.errZip();
 
 
   float chi2 = 0;
   if (nhits > 2) {
     RZLine rzLine(points,errors,isBarrel);
     float cottheta, intercept, covss, covii, covsi; 
     rzLine.fit(cottheta, intercept, covss, covii, covsi);
     chi2 = rzLine.chi2(cottheta, intercept);         //FIXME: check which intercept to use!
   }
 
   PixelTrackBuilder builder;
   Measurement1D pt(valPt, errValPt);
   Measurement1D phi(valPhi, errValPhi);
   Measurement1D cotTheta(valCotTheta, errValCot);
   Measurement1D tip(valTip, errValTip);
   Measurement1D zip(valZip, errValZip);
 
   return builder.build(pt, phi, cotTheta, tip, zip, chi2, iCharge, hits, theField, region.origin() );
 }