KFBasedPixelFitter Class Reference

#include <KFBasedPixelFitter.h>

Inheritance diagram for KFBasedPixelFitter:

Classes
class	MyBeamSpotGeomDet
class	MyBeamSpotHit

Public Member Functions
	KFBasedPixelFitter (const Propagator *propagator, const Propagator *opropagator, const TransientTrackingRecHitBuilder *ttrhBuilder, const TrackerGeometry *tracker, const MagneticField *field, const reco::BeamSpot *beamSpot)
std::unique_ptr< reco::Track >	run (const std::vector< const TrackingRecHit *> &hits, const TrackingRegion &region) const override
	~KFBasedPixelFitter () override
Public Member Functions inherited from PixelFitterBase
virtual	~PixelFitterBase ()

Private Attributes
const reco::BeamSpot *	theBeamSpot
const MagneticField *	theField
const Propagator *	theOPropagator
const Propagator *	thePropagator
const TrackerGeometry *	theTracker
const TransientTrackingRecHitBuilder *	theTTRHBuilder

Detailed Description

Definition at line 22 of file KFBasedPixelFitter.h.

Constructor & Destructor Documentation

KFBasedPixelFitter()

KFBasedPixelFitter::KFBasedPixelFitter	(	const Propagator *	propagator,
		const Propagator *	opropagator,
		const TransientTrackingRecHitBuilder *	ttrhBuilder,
		const TrackerGeometry *	tracker,
		const MagneticField *	field,
		const reco::BeamSpot *	beamSpot
	)

Definition at line 55 of file KFBasedPixelFitter.cc.

    : thePropagator(propagator),
      theOPropagator(opropagator),
      theTTRHBuilder(ttrhBuilder),
      theTracker(tracker),
      theField(field),
      theBeamSpot(beamSpot) {}

~KFBasedPixelFitter()

KFBasedPixelFitter::~KFBasedPixelFitter ( )

inlineoverride

Definition at line 30 of file KFBasedPixelFitter.h.

{}

Member Function Documentation

run()

std::unique_ptr< reco::Track > KFBasedPixelFitter::run ( const std::vector< const TrackingRecHit *> &  hits, const TrackingRegion &  region  ) const

overridevirtual

Implements PixelFitterBase.

Definition at line 68 of file KFBasedPixelFitter.cc.

References TransientTrackingRecHitBuilder::build(), Plane::build(), correctionTermsCaloMet_cff::C, CircleFromThreePoints::center(), ALCARECOTkAlJpsiMuMu_cff::charge, hltPixelTracks_cff::chi2, funct::cos(), CircleFromThreePoints::curvature(), GlobalErrorBase< T, ErrorWeightType >::cxx(), GlobalErrorBase< T, ErrorWeightType >::czz(), TransverseImpactPointExtrapolator::extrapolate(), hfClusterShapes_cfi::hits, TrackerGeometry::idToDet(), PixelRecoUtilities::inversePt(), TrajectoryStateOnSurface::isValid(), SiStripPI::max, ndof, nhits, PV3DBase< T, PVType, FrameType >::perp(), hiPixelPairStep_cff::points, createTree::pp, Propagator::propagate(), ptMin, rpcPointValidation_cfi::recHit, HLT_2022v12_cff::region, TrajectoryStateOnSurface::rescaleError(), runTheMatrix::ret, funct::sin(), sqr(), GeomDet::surface(), funct::tan(), theBeamSpot, theField, theOPropagator, thePropagator, PV3DBase< T, PVType, FrameType >::theta(), theta(), theTracker, theTTRHBuilder, GeomDet::toGlobal(), HLT_2022v12_cff::updator, x, PV3DBase< T, PVType, FrameType >::x(), Basic2DVector< T >::x(), y, PV3DBase< T, PVType, FrameType >::y(), Basic2DVector< T >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                         {
  std::unique_ptr<reco::Track> ret;

  int nhits = hits.size();
  if (nhits < 2)
    return ret;

  float ptMin = region.ptMin();

  const GlobalPoint &vertexPos = region.origin();
  GlobalError vertexErr(sqr(region.originRBound()), 0, sqr(region.originRBound()), 0, 0, sqr(region.originZBound()));

  std::vector<GlobalPoint> points(nhits);
  points[0] = theTracker->idToDet(hits[0]->geographicalId())->toGlobal(hits[0]->localPosition());
  points[1] = theTracker->idToDet(hits[1]->geographicalId())->toGlobal(hits[1]->localPosition());
  points[2] = theTracker->idToDet(hits[2]->geographicalId())->toGlobal(hits[2]->localPosition());

  //
  //initial Kinematics
  //
  GlobalVector initMom;
  int charge;
  float theta;
  CircleFromThreePoints circle(points[0], points[1], points[2]);
  if (circle.curvature() > 1.e-4) {
    float invPt = PixelRecoUtilities::inversePt(circle.curvature(), *theField);
    float valPt = 1.f / invPt;
    float chargeTmp = (points[1].x() - points[0].x()) * (points[2].y() - points[1].y()) -
                      (points[1].y() - points[0].y()) * (points[2].x() - points[1].x());
    charge = (chargeTmp > 0) ? -1 : 1;
    float valPhi = (charge > 0) ? std::atan2(circle.center().x(), -circle.center().y())
                                : std::atan2(-circle.center().x(), circle.center().y());
    theta = GlobalVector(points[1] - points[0]).theta();
    initMom = GlobalVector(valPt * cos(valPhi), valPt * sin(valPhi), valPt / tan(theta));
  } else {
    initMom = GlobalVector(points[1] - points[0]);
    initMom *= 10000. / initMom.perp();
    charge = 1;
    theta = initMom.theta();
  }
  GlobalTrajectoryParameters initialKine(vertexPos, initMom, TrackCharge(charge), theField);

  //
  // initial error
  //
  AlgebraicSymMatrix55 C = ROOT::Math::SMatrixIdentity();
  float sin2th = sqr(sin(theta));
  float minC00 = 1.0;
  C[0][0] = std::max(sin2th / sqr(ptMin), minC00);
  float zErr = vertexErr.czz();
  float transverseErr = vertexErr.cxx();  // assume equal cxx cyy
  C[3][3] = transverseErr;
  C[4][4] = zErr * sin2th + transverseErr * (1 - sin2th);
  CurvilinearTrajectoryError initialError(C);

  FreeTrajectoryState fts(initialKine, initialError);

  // get updator
  KFUpdator updator;

  // Now update initial state track using information from hits.
  TrajectoryStateOnSurface outerState;
  DetId outerDetId = 0;
  const TrackingRecHit *hit = nullptr;
  for (unsigned int iHit = 0; iHit < hits.size(); iHit++) {
    hit = hits[iHit];
    if (iHit == 0)
      outerState = thePropagator->propagate(fts, theTracker->idToDet(hit->geographicalId())->surface());
    outerDetId = hit->geographicalId();
    TrajectoryStateOnSurface state = thePropagator->propagate(outerState, theTracker->idToDet(outerDetId)->surface());
    if (!state.isValid())
      return ret;
    //    TransientTrackingRecHit::RecHitPointer recHit = (theTTRHBuilder->build(hit))->clone(state);
    TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder->build(hit);
    outerState = updator.update(state, *recHit);
    if (!outerState.isValid())
      return ret;
  }

  TrajectoryStateOnSurface innerState = outerState;
  DetId innerDetId = 0;
  innerState.rescaleError(100000.);
  for (int iHit = 2; iHit >= 0; --iHit) {
    hit = hits[iHit];
    innerDetId = hit->geographicalId();
    TrajectoryStateOnSurface state = theOPropagator->propagate(innerState, theTracker->idToDet(innerDetId)->surface());
    if (!state.isValid())
      return ret;
    //  TransientTrackingRecHit::RecHitPointer recHit = (theTTRHBuilder->build(hit))->clone(state);
    TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder->build(hit);
    innerState = updator.update(state, *recHit);
    if (!innerState.isValid())
      return ret;
  }

  // extrapolate to vertex
  auto impactPointState = TransverseImpactPointExtrapolator(theField).extrapolate(innerState, vertexPos);
  if (!impactPointState.isValid())
    return ret;

  //
  // optionally update impact point state with Bs constraint
  // using this potion makes sense if vertexPos (from TrackingRegion is centerewd at BeamSpot).
  //
  if (theBeamSpot) {
    MyBeamSpotGeomDet bsgd(Plane::build(impactPointState.surface().position(), impactPointState.surface().rotation()));
    MyBeamSpotHit bsrh(*theBeamSpot, &bsgd);
    impactPointState = updator.update(impactPointState, bsrh);  //update
    impactPointState =
        TransverseImpactPointExtrapolator(theField).extrapolate(impactPointState, vertexPos);  //reextrapolate
    if (!impactPointState.isValid())
      return ret;
  }

  int ndof = 2 * hits.size() - 5;
  GlobalPoint vv = impactPointState.globalPosition();
  math::XYZPoint pos(vv.x(), vv.y(), vv.z());
  GlobalVector pp = impactPointState.globalMomentum();
  math::XYZVector mom(pp.x(), pp.y(), pp.z());

  float chi2 = 0.;
  ret = std::make_unique<reco::Track>(
      chi2, ndof, pos, mom, impactPointState.charge(), impactPointState.curvilinearError());

  /*
    vv = outerState.globalPosition(); 
    pp = outerState.globalMomentum();
    math::XYZPoint  outerPosition( vv.x(), vv.y(), vv.z()); 
    math::XYZVector outerMomentum( pp.x(), pp.y(), pp.z());
    vv = innerState.globalPosition(); 
    pp = innerState.globalMomentum();
    math::XYZPoint  innerPosition( vv.x(), vv.y(), vv.z()); 
    math::XYZVector innerMomentum( pp.x(), pp.y(), pp.z());

    reco::TrackExtra extra( outerPosition, outerMomentum, true,
                      innerPosition, innerMomentum, true,
                      outerState.curvilinearError(), outerDetId,
                      innerState.curvilinearError(), innerDetId,  
                      anyDirection);
*/

  //  std::cout <<"TRACK CREATED" << std::endl;
  return ret;
}

Member Data Documentation

theBeamSpot

const reco::BeamSpot* KFBasedPixelFitter::theBeamSpot

private

Definition at line 69 of file KFBasedPixelFitter.h.

Referenced by run().

theField

const MagneticField* KFBasedPixelFitter::theField

private

Definition at line 68 of file KFBasedPixelFitter.h.

Referenced by run().

theOPropagator

const Propagator* KFBasedPixelFitter::theOPropagator

private

Definition at line 65 of file KFBasedPixelFitter.h.

Referenced by run().

thePropagator

const Propagator* KFBasedPixelFitter::thePropagator

private

Definition at line 64 of file KFBasedPixelFitter.h.

Referenced by run().

theTracker

const TrackerGeometry* KFBasedPixelFitter::theTracker

private

Definition at line 67 of file KFBasedPixelFitter.h.

Referenced by run().

theTTRHBuilder

const TransientTrackingRecHitBuilder* KFBasedPixelFitter::theTTRHBuilder

private

Definition at line 66 of file KFBasedPixelFitter.h.

Referenced by run().