Inheritance diagram for TrackExtenderWithMTDT< TrackCollection >:

Public Types
typedef edm::View< TrackType >	InputCollection

typedef TrackCollection::value_type	TrackType

Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
reco::Track	buildTrack (const reco::TrackRef &, const Trajectory &, const Trajectory &, const reco::BeamSpot &, const MagneticField field, const Propagator prop, bool hasMTD, float &pathLength, float &tmtdOut, float &sigmatmtdOut, float &tofpi, float &tofk, float &tofp) const

reco::TrackExtra	buildTrackExtra (const Trajectory &trajectory) const

RefitDirection::GeometricalDirection	checkRecHitsOrdering (TransientTrackingRecHit::ConstRecHitContainer const &recHits) const

string	dumpLayer (const DetLayer *layer) const

void	fillMatchingHits (const DetLayer , const TrajectoryStateOnSurface &, const Trajectory &, const float, const float, const TrackSegments &, const MTDTrackingDetSetVector &, const Propagator , const reco::BeamSpot &, const float &, const bool, TransientTrackingRecHit::ConstRecHitContainer &, MTDHitMatchingInfo &) const

template<class H , class T >
void	fillValueMap (edm::Event &iEvent, const H &handle, const std::vector< T > &vec, const edm::EDPutToken &token) const

void	produce (edm::Event &ev, const edm::EventSetup &es) final

	TrackExtenderWithMTDT (const ParameterSet &pset)

TransientTrackingRecHit::ConstRecHitContainer	tryBTLLayers (const TrajectoryStateOnSurface &, const Trajectory &traj, const float, const float, const TrackSegments &, const MTDTrackingDetSetVector &, const MTDDetLayerGeometry , const MagneticField field, const Propagator *prop, const reco::BeamSpot &bs, const float vtxTime, const bool matchVertex, MTDHitMatchingInfo &bestHit) const

TransientTrackingRecHit::ConstRecHitContainer	tryETLLayers (const TrajectoryStateOnSurface &, const Trajectory &traj, const float, const float, const TrackSegments &, const MTDTrackingDetSetVector &, const MTDDetLayerGeometry , const MagneticField field, const Propagator *prop, const reco::BeamSpot &bs, const float vtxTime, const bool matchVertex, MTDHitMatchingInfo &bestHit) const

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
edm::EDPutToken	assocOrigTrkToken_

edm::EDPutToken	betaOrigTrkToken_

const float	bsTimeSpread_

edm::EDGetTokenT< reco::BeamSpot >	bsToken_

const float	btlChi2Cut_

edm::EDPutToken	btlMatchChi2Token_

edm::EDPutToken	btlMatchTimeChi2Token_

const float	btlTimeChi2Cut_

edm::ESHandle< TransientTrackBuilder >	builder_

edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	builderToken_

edm::ESGetToken< MTDDetLayerGeometry, MTDRecoGeometryRecord >	dlgeoToken_

const float	dzCut_

const float	estMaxChi2_

const float	estMaxNSigma_

const float	etlChi2Cut_

edm::EDPutToken	etlMatchChi2Token_

edm::EDPutToken	etlMatchTimeChi2Token_

const float	etlTimeChi2Cut_

edm::EDGetTokenT< GlobalPoint >	genVtxPositionToken_

edm::EDGetTokenT< float >	genVtxTimeToken_

edm::ESHandle< GlobalTrackingGeometry >	gtg_

edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	gtgToken_

edm::ESHandle< TransientTrackingRecHitBuilder >	hitbuilder_

edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	hitbuilderToken_

edm::EDGetTokenT< MTDTrackingDetSetVector >	hitsToken_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magfldToken_

const std::string	mtdRecHitBuilder_

edm::EDPutToken	npixBarrelToken_

edm::EDPutToken	npixEndcapToken_

edm::EDPutToken	pathLengthOrigTrkToken_

edm::EDPutToken	pOrigTrkToken_

const std::string	propagator_

edm::ESGetToken< Propagator, TrackingComponentsRecord >	propToken_

edm::EDPutToken	sigmat0OrigTrkToken_

edm::EDPutToken	sigmatmtdOrigTrkToken_

edm::EDPutToken	t0OrigTrkToken_

std::unique_ptr< MeasurementEstimator >	theEstimator

std::unique_ptr< TrackTransformer >	theTransformer

edm::EDPutToken	tmtdOrigTrkToken_

edm::EDPutToken	tofkOrigTrkToken_

edm::EDPutToken	tofpiOrigTrkToken_

edm::EDPutToken	tofpOrigTrkToken_

edm::EDGetTokenT< InputCollection >	tracksToken_

edm::EDGetTokenT< TrajTrackAssociationCollection >	trajTrackAToken_

const std::string	transientTrackBuilder_

edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	ttopoToken_

const bool	updateExtra_

const bool	updatePattern_

const bool	updateTraj_

const bool	useSimVertex_

const bool	useVertex_

edm::EDGetTokenT< VertexCollection >	vtxToken_

Detailed Description

template<class TrackCollection>
class TrackExtenderWithMTDT< TrackCollection >

Definition at line 376 of file TrackExtenderWithMTD.cc.

Member Typedef Documentation

◆ InputCollection

template<class TrackCollection >

typedef edm::View<TrackType> TrackExtenderWithMTDT< TrackCollection >::InputCollection

Definition at line 379 of file TrackExtenderWithMTD.cc.

◆ TrackType

template<class TrackCollection >

typedef TrackCollection::value_type TrackExtenderWithMTDT< TrackCollection >::TrackType

Definition at line 378 of file TrackExtenderWithMTD.cc.

Constructor & Destructor Documentation

◆ TrackExtenderWithMTDT()

template<class TrackCollection >

TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT ( const ParameterSet & pset )

Definition at line 524 of file TrackExtenderWithMTD.cc.

     : tracksToken_(consumes<InputCollection>(iConfig.getParameter<edm::InputTag>("tracksSrc"))),
       trajTrackAToken_(consumes<TrajTrackAssociationCollection>(iConfig.getParameter<edm::InputTag>("trjtrkAssSrc"))),
       hitsToken_(consumes<MTDTrackingDetSetVector>(iConfig.getParameter<edm::InputTag>("hitsSrc"))),
       bsToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpotSrc"))),
       updateTraj_(iConfig.getParameter<bool>("updateTrackTrajectory")),
       updateExtra_(iConfig.getParameter<bool>("updateTrackExtra")),
       updatePattern_(iConfig.getParameter<bool>("updateTrackHitPattern")),
       mtdRecHitBuilder_(iConfig.getParameter<std::string>("MTDRecHitBuilder")),
       propagator_(iConfig.getParameter<std::string>("Propagator")),
       transientTrackBuilder_(iConfig.getParameter<std::string>("TransientTrackBuilder")),
       estMaxChi2_(iConfig.getParameter<double>("estimatorMaxChi2")),
       estMaxNSigma_(iConfig.getParameter<double>("estimatorMaxNSigma")),
       btlChi2Cut_(iConfig.getParameter<double>("btlChi2Cut")),
       btlTimeChi2Cut_(iConfig.getParameter<double>("btlTimeChi2Cut")),
       etlChi2Cut_(iConfig.getParameter<double>("etlChi2Cut")),
       etlTimeChi2Cut_(iConfig.getParameter<double>("etlTimeChi2Cut")),
       useVertex_(iConfig.getParameter<bool>("useVertex")),
       useSimVertex_(iConfig.getParameter<bool>("useSimVertex")),
       dzCut_(iConfig.getParameter<double>("dZCut")),
       bsTimeSpread_(iConfig.getParameter<double>("bsTimeSpread")) {
   if (useVertex_) {
     if (useSimVertex_) {
       genVtxPositionToken_ = consumes<GlobalPoint>(iConfig.getParameter<edm::InputTag>("genVtxPositionSrc"));
       genVtxTimeToken_ = consumes<float>(iConfig.getParameter<edm::InputTag>("genVtxTimeSrc"));
     } else
       vtxToken_ = consumes<VertexCollection>(iConfig.getParameter<edm::InputTag>("vtxSrc"));
   }
 
   theEstimator = std::make_unique<Chi2MeasurementEstimator>(estMaxChi2_, estMaxNSigma_);
   theTransformer = std::make_unique<TrackTransformer>(iConfig.getParameterSet("TrackTransformer"), consumesCollector());
 
   btlMatchChi2Token_ = produces<edm::ValueMap<float>>("btlMatchChi2");
   etlMatchChi2Token_ = produces<edm::ValueMap<float>>("etlMatchChi2");
   btlMatchTimeChi2Token_ = produces<edm::ValueMap<float>>("btlMatchTimeChi2");
   etlMatchTimeChi2Token_ = produces<edm::ValueMap<float>>("etlMatchTimeChi2");
   npixBarrelToken_ = produces<edm::ValueMap<int>>("npixBarrel");
   npixEndcapToken_ = produces<edm::ValueMap<int>>("npixEndcap");
   pOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackp");
   betaOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackBeta");
   t0OrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackt0");
   sigmat0OrigTrkToken_ = produces<edm::ValueMap<float>>("generalTracksigmat0");
   pathLengthOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackPathLength");
   tmtdOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTracktmtd");
   sigmatmtdOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTracksigmatmtd");
   tofpiOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackTofPi");
   tofkOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackTofK");
   tofpOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackTofP");
   assocOrigTrkToken_ = produces<edm::ValueMap<int>>("generalTrackassoc");
 
   builderToken_ = esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", transientTrackBuilder_));
   hitbuilderToken_ =
       esConsumes<TransientTrackingRecHitBuilder, TransientRecHitRecord>(edm::ESInputTag("", mtdRecHitBuilder_));
   gtgToken_ = esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord>();
   dlgeoToken_ = esConsumes<MTDDetLayerGeometry, MTDRecoGeometryRecord>();
   magfldToken_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
   propToken_ = esConsumes<Propagator, TrackingComponentsRecord>(edm::ESInputTag("", propagator_));
   ttopoToken_ = esConsumes<TrackerTopology, TrackerTopologyRcd>();
 
   produces<edm::OwnVector<TrackingRecHit>>();
   produces<reco::TrackExtraCollection>();
   produces<TrackCollection>();
 }

Member Function Documentation

◆ buildTrack()

template<class TrackCollection >

reco::Track TrackExtenderWithMTDT< TrackCollection >::buildTrack	(	const reco::TrackRef &	orig,
		const Trajectory &	traj,
		const Trajectory &	trajWithMtd,
		const reco::BeamSpot &	bs,
		const MagneticField *	field,
		const Propagator *	prop,
		bool	hasMTD,
		float &	pathLength,
		float &	tmtdOut,
		float &	sigmatmtdOut,
		float &	tofpi,
		float &	tofk,
		float &	tofp
	)		const

Definition at line 1122 of file TrackExtenderWithMTD.cc.

References funct::abs(), cms::cuda::bs, c_cm_ns, FreeTrajectoryState::charge(), Trajectory::chiSquared(), FreeTrajectoryState::curvilinearError(), f, FastTime, DetId::Forward, createfilelist::int, LogDebug, Trajectory::measurements(), FreeTrajectoryState::momentum(), ndof, Trajectory::ndof(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), cms_rounding::roundIfNear0(), mathSSE::sqrt(), FrontierCondition_GT_autoExpress_cfi::t0, MTDTrackingRecHit::time(), MTDTrackingRecHit::timeError(), TrajectoryStateClosestToBeamLine::trackStateAtPCA(), reco::TrackBase::undefQuality, and findQualityFiles::v.

                                                                                   {
   TrajectoryStateClosestToBeamLine tscbl;
   bool tsbcl_status = getTrajectoryStateClosestToBeamLine(traj, bs, thePropagator, tscbl);
 
   if (!tsbcl_status)
     return reco::Track();
 
   GlobalPoint v = tscbl.trackStateAtPCA().position();
   math::XYZPoint pos(v.x(), v.y(), v.z());
   GlobalVector p = tscbl.trackStateAtPCA().momentum();
   math::XYZVector mom(p.x(), p.y(), p.z());
 
   int ndof = traj.ndof();
 
   float t0 = 0.f;
   float covt0t0 = -1.f;
   pathLengthOut = -1.f;  // if there is no MTD flag the pathlength with -1
   tmtdOut = 0.f;
   sigmatmtdOut = -1.f;
   float betaOut = 0.f;
   float covbetabeta = -1.f;
 
   auto routput = [&]() {
     return reco::Track(traj.chiSquared(),
                        int(ndof),
                        pos,
                        mom,
                        tscbl.trackStateAtPCA().charge(),
                        tscbl.trackStateAtPCA().curvilinearError(),
                        orig->algo(),
                        reco::TrackBase::undefQuality,
                        t0,
                        betaOut,
                        covt0t0,
                        covbetabeta);
   };
 
   //compute path length for time backpropagation, using first MTD hit for the momentum
   if (hasMTD) {
     float pathlength;
     TrackSegments trs;
     bool validpropagation = trackPathLength(trajWithMtd, bs, thePropagator, pathlength, trs);
     float thit = 0.f;
     float thiterror = -1.f;
     bool validmtd = false;
 
     if (!validpropagation) {
       return routput();
     }
 
     uint32_t ihitcount(0), ietlcount(0);
     for (auto const& hit : trajWithMtd.measurements()) {
       if (hit.recHit()->geographicalId().det() == DetId::Forward &&
           ForwardSubdetector(hit.recHit()->geographicalId().subdetId()) == FastTime) {
         ihitcount++;
         if (MTDDetId(hit.recHit()->geographicalId()).mtdSubDetector() == MTDDetId::MTDType::ETL) {
           ietlcount++;
         }
       }
     }
 
     auto ihit1 = trajWithMtd.measurements().cbegin();
     if (ihitcount == 1) {
       const MTDTrackingRecHit* mtdhit = static_cast<const MTDTrackingRecHit*>((*ihit1).recHit()->hit());
       thit = mtdhit->time();
       thiterror = mtdhit->timeError();
       validmtd = true;
     } else if (ihitcount == 2 && ietlcount == 2) {
       std::pair<float, float> lastStep = trs.getSegmentPathAndMom2(0);
       float etlpathlength = std::abs(lastStep.first * c_cm_ns);
       //
       // The information of the two ETL hits is combined and attributed to the innermost hit
       //
       if (etlpathlength == 0.f) {
         validpropagation = false;
       } else {
         pathlength -= etlpathlength;
         trs.removeFirstSegment();
         const MTDTrackingRecHit* mtdhit1 = static_cast<const MTDTrackingRecHit*>((*ihit1).recHit()->hit());
         const MTDTrackingRecHit* mtdhit2 = static_cast<const MTDTrackingRecHit*>((*(ihit1 + 1)).recHit()->hit());
         TrackTofPidInfo tofInfo = computeTrackTofPidInfo(
             lastStep.second, etlpathlength, trs, mtdhit1->time(), mtdhit1->timeError(), 0.f, 0.f, true, TofCalc::kCost);
         //
         // Protect against incompatible times
         //
         float err1 = tofInfo.dterror * tofInfo.dterror;
         float err2 = mtdhit2->timeError() * mtdhit2->timeError();
         if (cms_rounding::roundIfNear0(err1) == 0.f || cms_rounding::roundIfNear0(err2) == 0.f) {
           edm::LogError("TrackExtenderWithMTD")
               << "MTD tracking hits with zero time uncertainty: " << err1 << " " << err2;
         } else {
           if ((tofInfo.dt - mtdhit2->time()) * (tofInfo.dt - mtdhit2->time()) < (err1 + err2) * etlTimeChi2Cut_) {
             //
             // Subtract the ETL time of flight from the outermost measurement, and combine it in a weighted average with the innermost
             // the mass ambiguity related uncertainty on the time of flight is added as an additional uncertainty
             //
             err1 = 1.f / err1;
             err2 = 1.f / err2;
             thiterror = 1.f / (err1 + err2);
             thit = (tofInfo.dt * err1 + mtdhit2->time() * err2) * thiterror;
             thiterror = std::sqrt(thiterror);
             LogDebug("TrackExtenderWithMTD") << "p trk = " << p.mag() << " ETL hits times/errors: " << mtdhit1->time()
                                              << " +/- " << mtdhit1->timeError() << " , " << mtdhit2->time() << " +/- "
                                              << mtdhit2->timeError() << " extrapolated time1: " << tofInfo.dt << " +/- "
                                              << tofInfo.dterror << " average = " << thit << " +/- " << thiterror;
             validmtd = true;
           }
         }
       }
     } else {
       edm::LogInfo("TrackExtenderWithMTD")
           << "MTD hits #" << ihitcount << "ETL hits #" << ietlcount << " anomalous pattern, skipping...";
     }
 
     if (validmtd && validpropagation) {
       //here add the PID uncertainty for later use in the 1st step of 4D vtx reconstruction
       TrackTofPidInfo tofInfo =
           computeTrackTofPidInfo(p.mag2(), pathlength, trs, thit, thiterror, 0.f, 0.f, true, TofCalc::kSegm);
       pathLengthOut = pathlength;  // set path length if we've got a timing hit
       tmtdOut = thit;
       sigmatmtdOut = thiterror;
       t0 = tofInfo.dt;
       covt0t0 = tofInfo.dterror * tofInfo.dterror;
       betaOut = tofInfo.beta_pi;
       covbetabeta = tofInfo.betaerror * tofInfo.betaerror;
       tofpi = tofInfo.dt_pi;
       tofk = tofInfo.dt_k;
       tofp = tofInfo.dt_p;
     }
   }
 
   return routput();
 }

◆ buildTrackExtra()

template<class TrackCollection >

reco::TrackExtra TrackExtenderWithMTDT< TrackCollection >::buildTrackExtra ( const Trajectory & trajectory ) const

Definition at line 1269 of file TrackExtenderWithMTD.cc.

References alongMomentum, Surface::bounds(), TrajectoryStateOnSurface::curvilinearError(), Trajectory::direction(), Trajectory::firstMeasurement(), TrajectoryStateOnSurface::globalParameters(), Bounds::inside(), Trajectory::lastMeasurement(), LogTrace, metname, GlobalTrajectoryParameters::momentum(), oppositeToMomentum, AlCaHLTBitMon_ParallelJobs::p, GlobalTrajectoryParameters::position(), TrajectoryMeasurement::recHit(), Trajectory::recHits(), Trajectory::seedRef(), GeomDet::surface(), GeomDet::toLocal(), TrajectoryMeasurement::updatedState(), and findQualityFiles::v.

                                                                                                          {
   static const string metname = "TrackExtenderWithMTD";
 
   const Trajectory::RecHitContainer transRecHits = trajectory.recHits();
 
   // put the collection of TrackingRecHit in the event
 
   // sets the outermost and innermost TSOSs
   // ToDo: validation for track states with MTD
   TrajectoryStateOnSurface outerTSOS;
   TrajectoryStateOnSurface innerTSOS;
   unsigned int innerId = 0, outerId = 0;
   TrajectoryMeasurement::ConstRecHitPointer outerRecHit;
   DetId outerDetId;
 
   if (trajectory.direction() == alongMomentum) {
     LogTrace(metname) << "alongMomentum";
     outerTSOS = trajectory.lastMeasurement().updatedState();
     innerTSOS = trajectory.firstMeasurement().updatedState();
     outerId = trajectory.lastMeasurement().recHit()->geographicalId().rawId();
     innerId = trajectory.firstMeasurement().recHit()->geographicalId().rawId();
     outerRecHit = trajectory.lastMeasurement().recHit();
     outerDetId = trajectory.lastMeasurement().recHit()->geographicalId();
   } else if (trajectory.direction() == oppositeToMomentum) {
     LogTrace(metname) << "oppositeToMomentum";
     outerTSOS = trajectory.firstMeasurement().updatedState();
     innerTSOS = trajectory.lastMeasurement().updatedState();
     outerId = trajectory.firstMeasurement().recHit()->geographicalId().rawId();
     innerId = trajectory.lastMeasurement().recHit()->geographicalId().rawId();
     outerRecHit = trajectory.firstMeasurement().recHit();
     outerDetId = trajectory.firstMeasurement().recHit()->geographicalId();
   } else
     LogError(metname) << "Wrong propagation direction!";
 
   const GeomDet* outerDet = gtg_->idToDet(outerDetId);
   GlobalPoint outerTSOSPos = outerTSOS.globalParameters().position();
   bool inside = outerDet->surface().bounds().inside(outerDet->toLocal(outerTSOSPos));
 
   GlobalPoint hitPos =
       (outerRecHit->isValid()) ? outerRecHit->globalPosition() : outerTSOS.globalParameters().position();
 
   if (!inside) {
     LogTrace(metname) << "The Global Muon outerMostMeasurementState is not compatible with the recHit detector!"
                       << " Setting outerMost postition to recHit position if recHit isValid: "
                       << outerRecHit->isValid();
     LogTrace(metname) << "From " << outerTSOSPos << " to " << hitPos;
   }
 
   //build the TrackExtra
   GlobalPoint v = (inside) ? outerTSOSPos : hitPos;
   GlobalVector p = outerTSOS.globalParameters().momentum();
   math::XYZPoint outpos(v.x(), v.y(), v.z());
   math::XYZVector outmom(p.x(), p.y(), p.z());
 
   v = innerTSOS.globalParameters().position();
   p = innerTSOS.globalParameters().momentum();
   math::XYZPoint inpos(v.x(), v.y(), v.z());
   math::XYZVector inmom(p.x(), p.y(), p.z());
 
   reco::TrackExtra trackExtra(outpos,
                               outmom,
                               true,
                               inpos,
                               inmom,
                               true,
                               outerTSOS.curvilinearError(),
                               outerId,
                               innerTSOS.curvilinearError(),
                               innerId,
                               trajectory.direction(),
                               trajectory.seedRef());
 
   return trackExtra;
 }

◆ checkRecHitsOrdering()

template<class TrackCollection >

RefitDirection::GeometricalDirection TrackExtenderWithMTDT< TrackCollection >::checkRecHitsOrdering ( TransientTrackingRecHit::ConstRecHitContainer const & recHits ) const

inline

Definition at line 432 of file TrackExtenderWithMTD.cc.

References dqmdumpme::first, RefitDirection::insideOut, dqmdumpme::last, LogDebug, RefitDirection::outsideIn, position, FastTrackerRecHitMaskProducer_cfi::recHits, and RefitDirection::undetermined.

                                                                         {
     if (!recHits.empty()) {
       GlobalPoint first = gtg_->idToDet(recHits.front()->geographicalId())->position();
       GlobalPoint last = gtg_->idToDet(recHits.back()->geographicalId())->position();
 
       // maybe perp2?
       auto rFirst = first.mag2();
       auto rLast = last.mag2();
       if (rFirst < rLast)
         return RefitDirection::insideOut;
       if (rFirst > rLast)
         return RefitDirection::outsideIn;
     }
     LogDebug("TrackExtenderWithMTD") << "Impossible to determine the rechits order" << endl;
     return RefitDirection::undetermined;
   }

◆ dumpLayer()

template<class TrackCollection >

string TrackExtenderWithMTDT< TrackCollection >::dumpLayer ( const DetLayer * layer ) const

Definition at line 1345 of file TrackExtenderWithMTD.cc.

References pixelTopology::layer, and convertSQLitetoXML_cfg::output.

                                                                                     {
   stringstream output;
 
   const BoundSurface* sur = nullptr;
   const BoundCylinder* bc = nullptr;
   const BoundDisk* bd = nullptr;
 
   sur = &(layer->surface());
   if ((bc = dynamic_cast<const BoundCylinder*>(sur))) {
     output << "  Cylinder of radius: " << bc->radius() << endl;
   } else if ((bd = dynamic_cast<const BoundDisk*>(sur))) {
     output << "  Disk at: " << bd->position().z() << endl;
   }
   return output.str();
 }

◆ fillDescriptions()

template<class TrackCollection >

void TrackExtenderWithMTDT< TrackCollection >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 589 of file TrackExtenderWithMTD.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, TrackTransformer::fillPSetDescription(), ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                         {
   edm::ParameterSetDescription desc, transDesc;
   desc.add<edm::InputTag>("tracksSrc", edm::InputTag("generalTracks"));
   desc.add<edm::InputTag>("trjtrkAssSrc", edm::InputTag("generalTracks"));
   desc.add<edm::InputTag>("hitsSrc", edm::InputTag("mtdTrackingRecHits"));
   desc.add<edm::InputTag>("beamSpotSrc", edm::InputTag("offlineBeamSpot"));
   desc.add<edm::InputTag>("genVtxPositionSrc", edm::InputTag("genParticles:xyz0"));
   desc.add<edm::InputTag>("genVtxTimeSrc", edm::InputTag("genParticles:t0"));
   desc.add<edm::InputTag>("vtxSrc", edm::InputTag("offlinePrimaryVertices4D"));
   desc.add<bool>("updateTrackTrajectory", true);
   desc.add<bool>("updateTrackExtra", true);
   desc.add<bool>("updateTrackHitPattern", true);
   desc.add<std::string>("TransientTrackBuilder", "TransientTrackBuilder");
   desc.add<std::string>("MTDRecHitBuilder", "MTDRecHitBuilder");
   desc.add<std::string>("Propagator", "PropagatorWithMaterialForMTD");
   TrackTransformer::fillPSetDescription(transDesc,
                                         false,
                                         "KFFitterForRefitInsideOut",
                                         "KFSmootherForRefitInsideOut",
                                         "PropagatorWithMaterialForMTD",
                                         "alongMomentum",
                                         true,
                                         "WithTrackAngle",
                                         "MuonRecHitBuilder",
                                         "MTDRecHitBuilder");
   desc.add<edm::ParameterSetDescription>("TrackTransformer", transDesc);
   desc.add<double>("estimatorMaxChi2", 500.);
   desc.add<double>("estimatorMaxNSigma", 10.);
   desc.add<double>("btlChi2Cut", 50.);
   desc.add<double>("btlTimeChi2Cut", 10.);
   desc.add<double>("etlChi2Cut", 50.);
   desc.add<double>("etlTimeChi2Cut", 10.);
   desc.add<bool>("useVertex", false);
   desc.add<bool>("useSimVertex", false);
   desc.add<double>("dZCut", 0.1);
   desc.add<double>("bsTimeSpread", 0.2);
   descriptions.add("trackExtenderWithMTDBase", desc);
 }

◆ fillMatchingHits()

template<class TrackCollection >

void TrackExtenderWithMTDT< TrackCollection >::fillMatchingHits	(	const DetLayer *	ilay,
		const TrajectoryStateOnSurface &	tsos,
		const Trajectory &	traj,
		const float	pmag2,
		const float	pathlength0,
		const TrackSegments &	trs0,
		const MTDTrackingDetSetVector &	hits,
		const Propagator *	prop,
		const reco::BeamSpot &	bs,
		const float &	vtxTime,
		const bool	matchVertex,
		TransientTrackingRecHit::ConstRecHitContainer &	output,
		MTDHitMatchingInfo &	bestHit
	)		const

Definition at line 1048 of file TrackExtenderWithMTD.cc.

References cms::cuda::bs, hfClusterShapes_cfi::hits, and DetLayer::isBarrel().

                                                                                                  {
   std::set<MTDHitMatchingInfo> hitsInLayer;
   bool hitMatched = false;
 
   using namespace std::placeholders;
   auto find_hits = std::bind(find_hits_in_dets,
                              std::cref(hits),
                              std::cref(traj),
                              ilay,
                              std::cref(tsos),
                              pmag2,
                              pathlength0,
                              trs0,
                              _1,
                              std::cref(bs),
                              bsTimeSpread_,
                              prop,
                              theEstimator.get(),
                              _2,
                              std::ref(hitsInLayer));
 
   if (useVertex_ && matchVertex)
     find_hits(vtxTime, true);
   else
     find_hits(0, false);
 
   float spaceChi2Cut = ilay->isBarrel() ? btlChi2Cut_ : etlChi2Cut_;
   float timeChi2Cut = ilay->isBarrel() ? btlTimeChi2Cut_ : etlTimeChi2Cut_;
 
   //just take the first hit because the hits are sorted on their matching quality
   if (!hitsInLayer.empty()) {
     //check hits to pass minimum quality matching requirements
     auto const& firstHit = *hitsInLayer.begin();
     if (firstHit.estChi2 < spaceChi2Cut && firstHit.timeChi2 < timeChi2Cut) {
       hitMatched = true;
       output.push_back(hitbuilder_->build(firstHit.hit));
       if (firstHit < bestHit)
         bestHit = firstHit;
     }
   }
 
   if (useVertex_ && matchVertex && !hitMatched) {
     //try a second search with beamspot hypothesis
     hitsInLayer.clear();
     find_hits(0, false);
     if (!hitsInLayer.empty()) {
       auto const& firstHit = *hitsInLayer.begin();
       if (firstHit.timeChi2 < timeChi2Cut) {
         if (firstHit.estChi2 < spaceChi2Cut) {
           hitMatched = true;
           output.push_back(hitbuilder_->build(firstHit.hit));
           if (firstHit < bestHit)
             bestHit = firstHit;
         }
       }
     }
   }
 }

◆ fillValueMap()

template<class TrackCollection >

template<class H , class T >

void TrackExtenderWithMTDT< TrackCollection >::fillValueMap	(	edm::Event &	iEvent,
		const H &	handle,
		const std::vector< T > &	vec,
		const edm::EDPutToken &	token
	)		const

Definition at line 630 of file TrackExtenderWithMTD.cc.

References trigObjTnPSource_cfi::filler, patZpeak::handle, iEvent, eostools::move(), MillePedeFileConverter_cfg::out, and unpackBuffers-CaloStage2::token.

                                                                                             {
   auto out = std::make_unique<edm::ValueMap<T>>();
   typename edm::ValueMap<T>::Filler filler(*out);
   filler.insert(handle, vec.begin(), vec.end());
   filler.fill();
   iEvent.put(token, std::move(out));
 }

◆ produce()

template<class TrackCollection >

void TrackExtenderWithMTDT< TrackCollection >::produce	(	edm::Event &	ev,
		const edm::EventSetup &	es
	)

final

setup the track extras

Definition at line 642 of file TrackExtenderWithMTD.cc.

References funct::abs(), cms::cuda::bs, PVValHelper::dz, makeMEIFBenchmarkPlots::ev, f, edm::EventSetup::getHandle(), edm::EventSetup::getTransientHandle(), hfClusterShapes_cfi::hits, RefitDirection::insideOut, Trajectory::isValid(), LogTrace, PV3DBase< T, PVType, FrameType >::mag2(), volumeBasedMagneticField_160812_cfi::magfield, FreeTrajectoryState::momentum(), eostools::move(), config::ordering, mps_fire::result, groupFilesInBlocks::reverse, mathSSE::sqrt(), HLT_2023v12_cff::track, and TrajectoryStateClosestToBeamLine::trackStateAtPCA().

                                                                                           {
   //this produces pieces of the track extra
   Traj2TrackHits t2t;
 
   theTransformer->setServices(es);
 
   TrackingRecHitRefProd hitsRefProd = ev.getRefBeforePut<TrackingRecHitCollection>();
   reco::TrackExtraRefProd extrasRefProd = ev.getRefBeforePut<reco::TrackExtraCollection>();
 
   gtg_ = es.getHandle(gtgToken_);
 
   auto geo = es.getTransientHandle(dlgeoToken_);
 
   auto magfield = es.getTransientHandle(magfldToken_);
 
   builder_ = es.getHandle(builderToken_);
   hitbuilder_ = es.getHandle(hitbuilderToken_);
 
   auto propH = es.getTransientHandle(propToken_);
   const Propagator* prop = propH.product();
 
   auto httopo = es.getTransientHandle(ttopoToken_);
   const TrackerTopology& ttopo = *httopo;
 
   auto output = std::make_unique<TrackCollection>();
   auto extras = std::make_unique<reco::TrackExtraCollection>();
   auto outhits = std::make_unique<edm::OwnVector<TrackingRecHit>>();
 
   std::vector<float> btlMatchChi2;
   std::vector<float> etlMatchChi2;
   std::vector<float> btlMatchTimeChi2;
   std::vector<float> etlMatchTimeChi2;
   std::vector<int> npixBarrel;
   std::vector<int> npixEndcap;
   std::vector<float> pOrigTrkRaw;
   std::vector<float> betaOrigTrkRaw;
   std::vector<float> t0OrigTrkRaw;
   std::vector<float> sigmat0OrigTrkRaw;
   std::vector<float> pathLengthsOrigTrkRaw;
   std::vector<float> tmtdOrigTrkRaw;
   std::vector<float> sigmatmtdOrigTrkRaw;
   std::vector<float> tofpiOrigTrkRaw;
   std::vector<float> tofkOrigTrkRaw;
   std::vector<float> tofpOrigTrkRaw;
   std::vector<int> assocOrigTrkRaw;
 
   auto const tracksH = ev.getHandle(tracksToken_);
 
   const auto& trjtrks = ev.get(trajTrackAToken_);
 
   //MTD hits DetSet
   const auto& hits = ev.get(hitsToken_);
 
   //beam spot
   const auto& bs = ev.get(bsToken_);
 
   const Vertex* pv = nullptr;
   if (useVertex_ && !useSimVertex_) {
     auto const& vtxs = ev.get(vtxToken_);
     if (!vtxs.empty())
       pv = &vtxs[0];
   }
 
   std::unique_ptr<math::XYZTLorentzVectorF> genPV(nullptr);
   if (useVertex_ && useSimVertex_) {
     const auto& genVtxPosition = ev.get(genVtxPositionToken_);
     const auto& genVtxTime = ev.get(genVtxTimeToken_);
     genPV = std::make_unique<math::XYZTLorentzVectorF>(
         genVtxPosition.x(), genVtxPosition.y(), genVtxPosition.z(), genVtxTime);
   }
 
   float vtxTime = 0.f;
   if (useVertex_) {
     if (useSimVertex_ && genPV) {
       vtxTime = genPV->t();
     } else if (pv)
       vtxTime = pv->t();  //already in ns
   }
 
   std::vector<unsigned> track_indices;
   unsigned itrack = 0;
 
   for (const auto& trjtrk : trjtrks) {
     const Trajectory& trajs = *trjtrk.key;
     const reco::TrackRef& track = trjtrk.val;
 
     float trackVtxTime = 0.f;
     if (useVertex_) {
       float dz;
       if (useSimVertex_)
         dz = std::abs(track->dz(math::XYZPoint(*genPV)));
       else
         dz = std::abs(track->dz(pv->position()));
 
       if (dz < dzCut_)
         trackVtxTime = vtxTime;
     }
 
     reco::TransientTrack ttrack(track, magfield.product(), gtg_);
     auto thits = theTransformer->getTransientRecHits(ttrack);
     TransientTrackingRecHit::ConstRecHitContainer mtdthits;
     MTDHitMatchingInfo mBTL, mETL;
 
     if (trajs.isValid()) {
       // get the outermost trajectory point on the track
       TrajectoryStateOnSurface tsos = builder_->build(track).outermostMeasurementState();
       TrajectoryStateClosestToBeamLine tscbl;
       bool tscbl_status = getTrajectoryStateClosestToBeamLine(trajs, bs, prop, tscbl);
 
       if (tscbl_status) {
         float pmag2 = tscbl.trackStateAtPCA().momentum().mag2();
         float pathlength0;
         TrackSegments trs0;
         trackPathLength(trajs, tscbl, prop, pathlength0, trs0);
 
         const auto& btlhits = tryBTLLayers(tsos,
                                            trajs,
                                            pmag2,
                                            pathlength0,
                                            trs0,
                                            hits,
                                            geo.product(),
                                            magfield.product(),
                                            prop,
                                            bs,
                                            trackVtxTime,
                                            trackVtxTime != 0.f,
                                            mBTL);
         mtdthits.insert(mtdthits.end(), btlhits.begin(), btlhits.end());
 
         // in the future this should include an intermediate refit before propagating to the ETL
         // for now it is ok
         const auto& etlhits = tryETLLayers(tsos,
                                            trajs,
                                            pmag2,
                                            pathlength0,
                                            trs0,
                                            hits,
                                            geo.product(),
                                            magfield.product(),
                                            prop,
                                            bs,
                                            trackVtxTime,
                                            trackVtxTime != 0.f,
                                            mETL);
         mtdthits.insert(mtdthits.end(), etlhits.begin(), etlhits.end());
       }
     }
 
     auto ordering = checkRecHitsOrdering(thits);
     if (ordering == RefitDirection::insideOut) {
       thits.insert(thits.end(), mtdthits.begin(), mtdthits.end());
     } else {
       std::reverse(mtdthits.begin(), mtdthits.end());
       mtdthits.insert(mtdthits.end(), thits.begin(), thits.end());
       thits.swap(mtdthits);
     }
 
     const auto& trajwithmtd =
         mtdthits.empty() ? std::vector<Trajectory>(1, trajs) : theTransformer->transform(ttrack, thits);
     float pMap = 0.f, betaMap = 0.f, t0Map = 0.f, sigmat0Map = -1.f, pathLengthMap = -1.f, tmtdMap = 0.f,
           sigmatmtdMap = -1.f, tofpiMap = 0.f, tofkMap = 0.f, tofpMap = 0.f;
     int iMap = -1;
 
     for (const auto& trj : trajwithmtd) {
       const auto& thetrj = (updateTraj_ ? trj : trajs);
       float pathLength = 0.f, tmtd = 0.f, sigmatmtd = -1.f, tofpi = 0.f, tofk = 0.f, tofp = 0.f;
       LogTrace("TrackExtenderWithMTD") << "Refit track " << itrack << " p/pT = " << track->p() << " " << track->pt()
                                        << " eta = " << track->eta();
       reco::Track result = buildTrack(track,
                                       thetrj,
                                       trj,
                                       bs,
                                       magfield.product(),
                                       prop,
                                       !trajwithmtd.empty() && !mtdthits.empty(),
                                       pathLength,
                                       tmtd,
                                       sigmatmtd,
                                       tofpi,
                                       tofk,
                                       tofp);
       if (result.ndof() >= 0) {
         reco::TrackExtra::TrajParams trajParams;
         reco::TrackExtra::Chi2sFive chi2s;
         size_t hitsstart = outhits->size();
         if (updatePattern_) {
           t2t(trj, *outhits, trajParams, chi2s);  // this fills the output hit collection
         } else {
           t2t(thetrj, *outhits, trajParams, chi2s);
         }
         size_t hitsend = outhits->size();
         extras->push_back(buildTrackExtra(trj));  // always push back the fully built extra, update by setting in track
         extras->back().setHits(hitsRefProd, hitsstart, hitsend - hitsstart);
         extras->back().setTrajParams(trajParams, chi2s);
         //create the track
         output->push_back(result);
         btlMatchChi2.push_back(mBTL.hit ? mBTL.estChi2 : -1.f);
         etlMatchChi2.push_back(mETL.hit ? mETL.estChi2 : -1.f);
         btlMatchTimeChi2.push_back(mBTL.hit ? mBTL.timeChi2 : -1.f);
         etlMatchTimeChi2.push_back(mETL.hit ? mETL.timeChi2 : -1.f);
         pathLengthMap = pathLength;
         tmtdMap = tmtd;
         sigmatmtdMap = sigmatmtd;
         auto& backtrack = output->back();
         iMap = output->size() - 1;
         pMap = backtrack.p();
         betaMap = backtrack.beta();
         t0Map = backtrack.t0();
         sigmat0Map = std::copysign(std::sqrt(std::abs(backtrack.covt0t0())), backtrack.covt0t0());
         tofpiMap = tofpi;
         tofkMap = tofk;
         tofpMap = tofp;
         reco::TrackExtraRef extraRef(extrasRefProd, extras->size() - 1);
         backtrack.setExtra((updateExtra_ ? extraRef : track->extra()));
         for (unsigned ihit = hitsstart; ihit < hitsend; ++ihit) {
           backtrack.appendHitPattern((*outhits)[ihit], ttopo);
         }
         npixBarrel.push_back(backtrack.hitPattern().numberOfValidPixelBarrelHits());
         npixEndcap.push_back(backtrack.hitPattern().numberOfValidPixelEndcapHits());
         LogTrace("TrackExtenderWithMTD") << "tmtd " << tmtdMap << " +/- " << sigmatmtdMap << " t0 " << t0Map << " +/- "
                                          << sigmat0Map << " tof pi/K/p " << tofpiMap << " " << tofkMap << " "
                                          << tofpMap;
       } else {
         LogTrace("TrackExtenderWithMTD") << "Error in the MTD track refitting. This should not happen";
       }
     }
 
     pOrigTrkRaw.push_back(pMap);
     betaOrigTrkRaw.push_back(betaMap);
     t0OrigTrkRaw.push_back(t0Map);
     sigmat0OrigTrkRaw.push_back(sigmat0Map);
     pathLengthsOrigTrkRaw.push_back(pathLengthMap);
     tmtdOrigTrkRaw.push_back(tmtdMap);
     sigmatmtdOrigTrkRaw.push_back(sigmatmtdMap);
     tofpiOrigTrkRaw.push_back(tofpiMap);
     tofkOrigTrkRaw.push_back(tofkMap);
     tofpOrigTrkRaw.push_back(tofpMap);
     assocOrigTrkRaw.push_back(iMap);
 
     if (iMap == -1) {
       btlMatchChi2.push_back(-1.f);
       etlMatchChi2.push_back(-1.f);
       btlMatchTimeChi2.push_back(-1.f);
       etlMatchTimeChi2.push_back(-1.f);
       npixBarrel.push_back(-1.f);
       npixEndcap.push_back(-1.f);
     }
 
     ++itrack;
   }
 
   auto outTrksHandle = ev.put(std::move(output));
   ev.put(std::move(extras));
   ev.put(std::move(outhits));
 
   fillValueMap(ev, tracksH, btlMatchChi2, btlMatchChi2Token_);
   fillValueMap(ev, tracksH, etlMatchChi2, etlMatchChi2Token_);
   fillValueMap(ev, tracksH, btlMatchTimeChi2, btlMatchTimeChi2Token_);
   fillValueMap(ev, tracksH, etlMatchTimeChi2, etlMatchTimeChi2Token_);
   fillValueMap(ev, tracksH, npixBarrel, npixBarrelToken_);
   fillValueMap(ev, tracksH, npixEndcap, npixEndcapToken_);
   fillValueMap(ev, tracksH, pOrigTrkRaw, pOrigTrkToken_);
   fillValueMap(ev, tracksH, betaOrigTrkRaw, betaOrigTrkToken_);
   fillValueMap(ev, tracksH, t0OrigTrkRaw, t0OrigTrkToken_);
   fillValueMap(ev, tracksH, sigmat0OrigTrkRaw, sigmat0OrigTrkToken_);
   fillValueMap(ev, tracksH, pathLengthsOrigTrkRaw, pathLengthOrigTrkToken_);
   fillValueMap(ev, tracksH, tmtdOrigTrkRaw, tmtdOrigTrkToken_);
   fillValueMap(ev, tracksH, sigmatmtdOrigTrkRaw, sigmatmtdOrigTrkToken_);
   fillValueMap(ev, tracksH, tofpiOrigTrkRaw, tofpiOrigTrkToken_);
   fillValueMap(ev, tracksH, tofkOrigTrkRaw, tofkOrigTrkToken_);
   fillValueMap(ev, tracksH, tofpOrigTrkRaw, tofpOrigTrkToken_);
   fillValueMap(ev, tracksH, assocOrigTrkRaw, assocOrigTrkToken_);
 }

◆ tryBTLLayers()

template<class TrackCollection >

TransientTrackingRecHit::ConstRecHitContainer TrackExtenderWithMTDT< TrackCollection >::tryBTLLayers	(	const TrajectoryStateOnSurface &	tsos,
		const Trajectory &	traj,
		const float	pmag2,
		const float	pathlength0,
		const TrackSegments &	trs0,
		const MTDTrackingDetSetVector &	hits,
		const MTDDetLayerGeometry *	geo,
		const MagneticField *	field,
		const Propagator *	prop,
		const reco::BeamSpot &	bs,
		const float	vtxTime,
		const bool	matchVertex,
		MTDHitMatchingInfo &	bestHit
	)		const

Definition at line 985 of file TrackExtenderWithMTD.cc.

References MTDDetLayerGeometry::allBTLLayers(), cms::cuda::bs, hfClusterShapes_cfi::hits, hgcalTBTopologyTester_cfi::layers, and convertSQLitetoXML_cfg::output.

                                        {
   const vector<const DetLayer*>& layers = geo->allBTLLayers();
 
   TransientTrackingRecHit::ConstRecHitContainer output;
   bestHit = MTDHitMatchingInfo();
   for (const DetLayer* ilay : layers)
     fillMatchingHits(ilay, tsos, traj, pmag2, pathlength0, trs0, hits, prop, bs, vtxTime, matchVertex, output, bestHit);
   return output;
 }

◆ tryETLLayers()

template<class TrackCollection >

TransientTrackingRecHit::ConstRecHitContainer TrackExtenderWithMTDT< TrackCollection >::tryETLLayers	(	const TrajectoryStateOnSurface &	tsos,
		const Trajectory &	traj,
		const float	pmag2,
		const float	pathlength0,
		const TrackSegments &	trs0,
		const MTDTrackingDetSetVector &	hits,
		const MTDDetLayerGeometry *	geo,
		const MagneticField *	field,
		const Propagator *	prop,
		const reco::BeamSpot &	bs,
		const float	vtxTime,
		const bool	matchVertex,
		MTDHitMatchingInfo &	bestHit
	)		const

Definition at line 1009 of file TrackExtenderWithMTD.cc.

References funct::abs(), MTDDetLayerGeometry::allETLLayers(), cms::cuda::bs, TrajectoryStateOnSurface::globalPosition(), hfClusterShapes_cfi::hits, hgcalTBTopologyTester_cfi::layers, convertSQLitetoXML_cfg::output, groupFilesInBlocks::reverse, detailsBasic3DVector::z, and PV3DBase< T, PVType, FrameType >::z().

                                        {
   const vector<const DetLayer*>& layers = geo->allETLLayers();
 
   TransientTrackingRecHit::ConstRecHitContainer output;
   bestHit = MTDHitMatchingInfo();
   for (const DetLayer* ilay : layers) {
     const BoundDisk& disk = static_cast<const ForwardDetLayer*>(ilay)->specificSurface();
     const float diskZ = disk.position().z();
 
     if (tsos.globalPosition().z() * diskZ < 0)
       continue;  // only propagate to the disk that's on the same side
 
     fillMatchingHits(ilay, tsos, traj, pmag2, pathlength0, trs0, hits, prop, bs, vtxTime, matchVertex, output, bestHit);
   }
 
   // the ETL hits order must be from the innermost to the outermost
 
   if (output.size() == 2) {
     if (std::abs(output[0]->globalPosition().z()) > std::abs(output[1]->globalPosition().z())) {
       std::reverse(output.begin(), output.end());
     }
   }
   return output;
 }

Member Data Documentation

◆ assocOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::assocOrigTrkToken_

private

Definition at line 484 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ betaOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::betaOrigTrkToken_

private

Definition at line 475 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ bsTimeSpread_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::bsTimeSpread_

private

Definition at line 520 of file TrackExtenderWithMTD.cc.

◆ bsToken_

template<class TrackCollection >

edm::EDGetTokenT<reco::BeamSpot> TrackExtenderWithMTDT< TrackCollection >::bsToken_

private

Definition at line 489 of file TrackExtenderWithMTD.cc.

◆ btlChi2Cut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::btlChi2Cut_

private

Definition at line 512 of file TrackExtenderWithMTD.cc.

◆ btlMatchChi2Token_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::btlMatchChi2Token_

private

Definition at line 468 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ btlMatchTimeChi2Token_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::btlMatchTimeChi2Token_

private

Definition at line 470 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ btlTimeChi2Cut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::btlTimeChi2Cut_

private

Definition at line 513 of file TrackExtenderWithMTD.cc.

◆ builder_

template<class TrackCollection >

edm::ESHandle<TransientTrackBuilder> TrackExtenderWithMTDT< TrackCollection >::builder_

private

Definition at line 498 of file TrackExtenderWithMTD.cc.

◆ builderToken_

template<class TrackCollection >

edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> TrackExtenderWithMTDT< TrackCollection >::builderToken_

private

Definition at line 499 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ dlgeoToken_

template<class TrackCollection >

edm::ESGetToken<MTDDetLayerGeometry, MTDRecoGeometryRecord> TrackExtenderWithMTDT< TrackCollection >::dlgeoToken_

private

Definition at line 505 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ dzCut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::dzCut_

private

Definition at line 519 of file TrackExtenderWithMTD.cc.

◆ estMaxChi2_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::estMaxChi2_

private

Definition at line 510 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ estMaxNSigma_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::estMaxNSigma_

private

Definition at line 511 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ etlChi2Cut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::etlChi2Cut_

private

Definition at line 514 of file TrackExtenderWithMTD.cc.

◆ etlMatchChi2Token_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::etlMatchChi2Token_

private

Definition at line 469 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ etlMatchTimeChi2Token_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::etlMatchTimeChi2Token_

private

Definition at line 471 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ etlTimeChi2Cut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::etlTimeChi2Cut_

private

Definition at line 515 of file TrackExtenderWithMTD.cc.

◆ genVtxPositionToken_

template<class TrackCollection >

edm::EDGetTokenT<GlobalPoint> TrackExtenderWithMTDT< TrackCollection >::genVtxPositionToken_

private

Definition at line 490 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ genVtxTimeToken_

template<class TrackCollection >

edm::EDGetTokenT<float> TrackExtenderWithMTDT< TrackCollection >::genVtxTimeToken_

private

Definition at line 491 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ gtg_

template<class TrackCollection >

edm::ESHandle<GlobalTrackingGeometry> TrackExtenderWithMTDT< TrackCollection >::gtg_

private

Definition at line 502 of file TrackExtenderWithMTD.cc.

◆ gtgToken_

template<class TrackCollection >

edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> TrackExtenderWithMTDT< TrackCollection >::gtgToken_

private

Definition at line 503 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ hitbuilder_

template<class TrackCollection >

edm::ESHandle<TransientTrackingRecHitBuilder> TrackExtenderWithMTDT< TrackCollection >::hitbuilder_

private

Definition at line 500 of file TrackExtenderWithMTD.cc.

◆ hitbuilderToken_

template<class TrackCollection >

edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> TrackExtenderWithMTDT< TrackCollection >::hitbuilderToken_

private

Definition at line 501 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ hitsToken_

template<class TrackCollection >

edm::EDGetTokenT<MTDTrackingDetSetVector> TrackExtenderWithMTDT< TrackCollection >::hitsToken_

private

Definition at line 488 of file TrackExtenderWithMTD.cc.

◆ magfldToken_

template<class TrackCollection >

edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> TrackExtenderWithMTDT< TrackCollection >::magfldToken_

private

Definition at line 506 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ mtdRecHitBuilder_

template<class TrackCollection >

const std::string TrackExtenderWithMTDT< TrackCollection >::mtdRecHitBuilder_

private

Definition at line 495 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ npixBarrelToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::npixBarrelToken_

private

Definition at line 472 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ npixEndcapToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::npixEndcapToken_

private

Definition at line 473 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ pathLengthOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::pathLengthOrigTrkToken_

private

Definition at line 478 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ pOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::pOrigTrkToken_

private

Definition at line 474 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ propagator_

template<class TrackCollection >

const std::string TrackExtenderWithMTDT< TrackCollection >::propagator_

private

Definition at line 495 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ propToken_

template<class TrackCollection >

edm::ESGetToken<Propagator, TrackingComponentsRecord> TrackExtenderWithMTDT< TrackCollection >::propToken_

private

Definition at line 507 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ sigmat0OrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::sigmat0OrigTrkToken_

private

Definition at line 477 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ sigmatmtdOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::sigmatmtdOrigTrkToken_

private

Definition at line 480 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ t0OrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::t0OrigTrkToken_

private

Definition at line 476 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ theEstimator

template<class TrackCollection >

std::unique_ptr<MeasurementEstimator> TrackExtenderWithMTDT< TrackCollection >::theEstimator

private

Definition at line 496 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ theTransformer

template<class TrackCollection >

std::unique_ptr<TrackTransformer> TrackExtenderWithMTDT< TrackCollection >::theTransformer

private

Definition at line 497 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ tmtdOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tmtdOrigTrkToken_

private

Definition at line 479 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ tofkOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tofkOrigTrkToken_

private

Definition at line 482 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ tofpiOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tofpiOrigTrkToken_

private

Definition at line 481 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ tofpOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tofpOrigTrkToken_

private

Definition at line 483 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ tracksToken_

template<class TrackCollection >

edm::EDGetTokenT<InputCollection> TrackExtenderWithMTDT< TrackCollection >::tracksToken_

private

Definition at line 486 of file TrackExtenderWithMTD.cc.

◆ trajTrackAToken_

template<class TrackCollection >

edm::EDGetTokenT<TrajTrackAssociationCollection> TrackExtenderWithMTDT< TrackCollection >::trajTrackAToken_

private

Definition at line 487 of file TrackExtenderWithMTD.cc.

◆ transientTrackBuilder_

template<class TrackCollection >

const std::string TrackExtenderWithMTDT< TrackCollection >::transientTrackBuilder_

private

Definition at line 495 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ ttopoToken_

template<class TrackCollection >

edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> TrackExtenderWithMTDT< TrackCollection >::ttopoToken_

private

Definition at line 508 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ updateExtra_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::updateExtra_

private

Definition at line 494 of file TrackExtenderWithMTD.cc.

◆ updatePattern_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::updatePattern_

private

Definition at line 494 of file TrackExtenderWithMTD.cc.

◆ updateTraj_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::updateTraj_

private

Definition at line 494 of file TrackExtenderWithMTD.cc.

◆ useSimVertex_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::useSimVertex_

private

Definition at line 518 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ useVertex_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::useVertex_

private

Definition at line 517 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

◆ vtxToken_

template<class TrackCollection >

edm::EDGetTokenT<VertexCollection> TrackExtenderWithMTDT< TrackCollection >::vtxToken_

private

Definition at line 492 of file TrackExtenderWithMTD.cc.

Referenced by TrackExtenderWithMTDT< TrackCollection >::TrackExtenderWithMTDT().

Public Types

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

template<class TrackCollection> class TrackExtenderWithMTDT< TrackCollection >

Member Typedef Documentation

◆ InputCollection

◆ TrackType

Constructor & Destructor Documentation

◆ TrackExtenderWithMTDT()

Member Function Documentation

◆ buildTrack()

◆ buildTrackExtra()

◆ checkRecHitsOrdering()

◆ dumpLayer()

◆ fillDescriptions()

◆ fillMatchingHits()

◆ fillValueMap()

◆ produce()

◆ tryBTLLayers()

◆ tryETLLayers()

Member Data Documentation

◆ assocOrigTrkToken_

◆ betaOrigTrkToken_

◆ bsTimeSpread_

◆ bsToken_

◆ btlChi2Cut_

◆ btlMatchChi2Token_

◆ btlMatchTimeChi2Token_

◆ btlTimeChi2Cut_

◆ builder_

◆ builderToken_

◆ dlgeoToken_

◆ dzCut_

◆ estMaxChi2_

◆ estMaxNSigma_

◆ etlChi2Cut_

◆ etlMatchChi2Token_

◆ etlMatchTimeChi2Token_

◆ etlTimeChi2Cut_

◆ genVtxPositionToken_

◆ genVtxTimeToken_

◆ gtg_

◆ gtgToken_

◆ hitbuilder_

◆ hitbuilderToken_

◆ hitsToken_

◆ magfldToken_

◆ mtdRecHitBuilder_

◆ npixBarrelToken_

◆ npixEndcapToken_

◆ pathLengthOrigTrkToken_

◆ pOrigTrkToken_

◆ propagator_

◆ propToken_

◆ sigmat0OrigTrkToken_

◆ sigmatmtdOrigTrkToken_

◆ t0OrigTrkToken_

◆ theEstimator

◆ theTransformer

◆ tmtdOrigTrkToken_

◆ tofkOrigTrkToken_

◆ tofpiOrigTrkToken_

◆ tofpOrigTrkToken_

◆ tracksToken_

◆ trajTrackAToken_

◆ transientTrackBuilder_

◆ ttopoToken_

◆ updateExtra_

◆ updatePattern_

◆ updateTraj_

◆ useSimVertex_

◆ useVertex_

◆ vtxToken_

template<class TrackCollection>
class TrackExtenderWithMTDT< TrackCollection >