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, GlobalPoint &tmtdPosOut, float &tofpi, float &tofk, float &tofp, float &sigmatofpi, float &sigmatofk, float &sigmatofp) 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	outermostHitPositionToken_

edm::EDPutToken	pathLengthOrigTrkToken_

edm::EDPutToken	pOrigTrkToken_

const std::string	propagator_

edm::ESGetToken< Propagator, TrackingComponentsRecord >	propToken_

edm::EDPutToken	sigmat0OrigTrkToken_

edm::EDPutToken	sigmatmtdOrigTrkToken_

edm::EDPutToken	sigmatofkOrigTrkToken_

edm::EDPutToken	sigmatofpiOrigTrkToken_

edm::EDPutToken	sigmatofpOrigTrkToken_

edm::EDPutToken	t0OrigTrkToken_

std::unique_ptr< MeasurementEstimator >	theEstimator

std::unique_ptr< TrackTransformer >	theTransformer

edm::EDPutToken	tmtdOrigTrkToken_

edm::EDPutToken	tmtdPosOrigTrkToken_

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 469 of file TrackExtenderWithMTD.cc.

Member Typedef Documentation

◆ InputCollection

template<class TrackCollection >

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

Definition at line 472 of file TrackExtenderWithMTD.cc.

◆ TrackType

template<class TrackCollection >

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

Definition at line 471 of file TrackExtenderWithMTD.cc.

Constructor & Destructor Documentation

◆ TrackExtenderWithMTDT()

template<class TrackCollection >

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

Definition at line 626 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");
   outermostHitPositionToken_ = produces<edm::ValueMap<float>>("generalTrackOutermostHitPosition");
   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");
   tmtdPosOrigTrkToken_ = produces<edm::ValueMap<GlobalPoint>>("generalTrackmtdpos");
   tofpiOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackTofPi");
   tofkOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackTofK");
   tofpOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackTofP");
   sigmatofpiOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackSigmaTofPi");
   sigmatofkOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackSigmaTofK");
   sigmatofpOrigTrkToken_ = produces<edm::ValueMap<float>>("generalTrackSigmaTofP");
   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,
		GlobalPoint &	tmtdPosOut,
		float &	tofpi,
		float &	tofk,
		float &	tofp,
		float &	sigmatofpi,
		float &	sigmatofk,
		float &	sigmatofp
	)		const

Definition at line 1328 of file TrackExtenderWithMTD.cc.

References funct::abs(), cms::cuda::bs, c_cm_ns, FreeTrajectoryState::charge(), Trajectory::chiSquared(), FreeTrajectoryState::curvilinearError(), f, FastTime, DetId::Forward, BaseTrackerRecHit::globalPosition(), createfilelist::int, LogTrace, Trajectory::measurements(), FreeTrajectoryState::momentum(), PixelVertexMonitor_cff::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;
     GlobalPoint thitpos{0., 0., 0.};
     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++;
         }
       }
     }
 
     LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: selected #hits " << ihitcount << " from 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();
       thitpos = mtdhit->globalPosition();
       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.dterror2;
         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);
             thitpos = mtdhit2->globalPosition();
             LogTrace("TrackExtenderWithMTD")
                 << "TrackExtenderWithMTD: p trk = " << p.mag() << " ETL hits times/errors: 1) " << mtdhit1->time()
                 << " +/- " << mtdhit1->timeError() << " , 2) " << mtdhit2->time() << " +/- " << mtdhit2->timeError()
                 << " extrapolated time1: " << tofInfo.dt << " +/- " << tofInfo.dterror << " average = " << thit
                 << " +/- " << thiterror << "\n    hit1 pos: " << mtdhit1->globalPosition()
                 << " hit2 pos: " << mtdhit2->globalPosition() << " etl path length " << etlpathlength << std::endl;
             validmtd = true;
           } else {
             // if back extrapolated time of the outermost measurement not compatible with the innermost, keep the one with smallest error
             if (err1 <= err2) {
               thit = tofInfo.dt;
               thiterror = tofInfo.dterror;
               validmtd = true;
             } else {
               thit = mtdhit2->time();
               thiterror = mtdhit2->timeError();
               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, SigmaTofCalc::kCost);
 
       pathLengthOut = pathlength;  // set path length if we've got a timing hit
       tmtdOut = thit;
       sigmatmtdOut = thiterror;
       tmtdPosOut = thitpos;
       t0 = tofInfo.dt;
       covt0t0 = tofInfo.dterror2;
       betaOut = tofInfo.beta_pi;
       covbetabeta = tofInfo.betaerror * tofInfo.betaerror;
       tofpi = tofInfo.dt_pi;
       tofk = tofInfo.dt_k;
       tofp = tofInfo.dt_p;
       sigmatofpi = tofInfo.sigma_dt_pi;
       sigmatofk = tofInfo.sigma_dt_k;
       sigmatofp = tofInfo.sigma_dt_p;
     }
   }
 
   return routput();
 }

◆ buildTrackExtra()

template<class TrackCollection >

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

Definition at line 1503 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 525 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 1579 of file TrackExtenderWithMTD.cc.

References nano_mu_digi_cff::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 696 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 1241 of file TrackExtenderWithMTD.cc.

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

                                                                                                  {
   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();
     LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: matching trial 1: estChi2= " << firstHit.estChi2
                                      << " timeChi2= " << firstHit.timeChi2;
     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();
       LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: matching trial 2: estChi2= " << firstHit.estChi2
                                        << " timeChi2= " << firstHit.timeChi2;
       if (firstHit.timeChi2 < timeChi2Cut) {
         if (firstHit.estChi2 < spaceChi2Cut) {
           hitMatched = true;
           output.push_back(hitbuilder_->build(firstHit.hit));
           if (firstHit < bestHit)
             bestHit = firstHit;
         }
       }
     }
   }
 
 #ifdef EDM_ML_DEBUG
   if (hitMatched) {
     LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: matched hit with time: " << bestHit.hit->time()
                                      << " +/- " << bestHit.hit->timeError();
   } else {
     LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: no matched hit";
   }
 #endif
 }

◆ 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 737 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 749 of file TrackExtenderWithMTD.cc.

References funct::abs(), cms::cuda::bs, gather_cfg::cout, PVValHelper::dz, makeMEIFBenchmarkPlots::ev, f, nano_mu_digi_cff::float, dqm-mbProfile::format, edm::EventSetup::getHandle(), edm::EventSetup::getTransientHandle(), hfClusterShapes_cfi::hits, mps_fire::i, RefitDirection::insideOut, Trajectory::isValid(), LogTrace, PV3DBase< T, PVType, FrameType >::mag2(), volumeBasedMagneticField_160812_cfi::magfield, reco::HitPattern::MISSING_INNER_HITS, FreeTrajectoryState::momentum(), eostools::move(), config::ordering, mps_fire::result, groupFilesInBlocks::reverse, mathSSE::sqrt(), HLT_2024v14_cff::track, reco::HitPattern::TRACK_HITS, 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> outermostHitPosition;
   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<GlobalPoint> tmtdPosOrigTrkRaw;
   std::vector<float> tofpiOrigTrkRaw;
   std::vector<float> tofkOrigTrkRaw;
   std::vector<float> tofpOrigTrkRaw;
   std::vector<float> sigmatofpiOrigTrkRaw;
   std::vector<float> sigmatofkOrigTrkRaw;
   std::vector<float> sigmatofpOrigTrkRaw;
   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;
 
     LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: extrapolating track " << itrack
                                      << " p/pT = " << track->p() << " " << track->pt() << " eta = " << track->eta();
     LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: sigma_p = "
                                      << sqrt(track->covariance()(0, 0)) * track->p2()
                                      << " sigma_p/p = " << sqrt(track->covariance()(0, 0)) * track->p() * 100 << " %";
 
     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());
       }
 #ifdef EDM_ML_DEBUG
       else {
         LogTrace("TrackExtenderWithMTD") << "Failing getTrajectoryStateClosestToBeamLine, no search for hits in MTD!";
       }
 #endif
     }
 
     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, sigmatofpiMap = -1.f, sigmatofkMap = -1.f,
           sigmatofpMap = -1.f;
     GlobalPoint tmtdPosMap{0., 0., 0.};
     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, sigmatofpi = -1.f,
             sigmatofk = -1.f, sigmatofp = -1.f;
       GlobalPoint tmtdPos{0., 0., 0.};
       LogTrace("TrackExtenderWithMTD") << "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,
                                       tmtdPos,
                                       tofpi,
                                       tofk,
                                       tofp,
                                       sigmatofpi,
                                       sigmatofk,
                                       sigmatofp);
       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;
         tmtdPosMap = tmtdPos;
         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;
         sigmatofpiMap = sigmatofpi;
         sigmatofkMap = sigmatofk;
         sigmatofpMap = sigmatofp;
         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);
         }
 #ifdef EDM_ML_DEBUG
         LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: hit pattern of refitted track";
         for (int i = 0; i < backtrack.hitPattern().numberOfAllHits(reco::HitPattern::TRACK_HITS); i++) {
           backtrack.hitPattern().printHitPattern(reco::HitPattern::TRACK_HITS, i, std::cout);
         }
         LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: missing hit pattern of refitted track";
         for (int i = 0; i < backtrack.hitPattern().numberOfAllHits(reco::HitPattern::MISSING_INNER_HITS); i++) {
           backtrack.hitPattern().printHitPattern(reco::HitPattern::MISSING_INNER_HITS, i, std::cout);
         }
 #endif
         npixBarrel.push_back(backtrack.hitPattern().numberOfValidPixelBarrelHits());
         npixEndcap.push_back(backtrack.hitPattern().numberOfValidPixelEndcapHits());
         outermostHitPosition.push_back(
             mBTL.hit ? (float)(*track).outerRadius()
                      : (float)(*track).outerZ());  // save R of the outermost hit for BTL, z for ETL.
 
         LogTrace("TrackExtenderWithMTD") << "TrackExtenderWithMTD: tmtd " << tmtdMap << " +/- " << sigmatmtdMap
                                          << " t0 " << t0Map << " +/- " << sigmat0Map << " tof pi/K/p " << tofpiMap
                                          << "+/-" << fmt::format("{:0.2g}", sigmatofpiMap) << " ("
                                          << fmt::format("{:0.2g}", sigmatofpiMap / tofpiMap * 100) << "%) " << tofkMap
                                          << "+/-" << fmt::format("{:0.2g}", sigmatofkMap) << " ("
                                          << fmt::format("{:0.2g}", sigmatofkMap / tofkMap * 100) << "%) " << tofpMap
                                          << "+/-" << fmt::format("{:0.2g}", sigmatofpMap) << " ("
                                          << fmt::format("{:0.2g}", sigmatofpMap / tofpMap * 100) << "%) ";
       } 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);
     tmtdPosOrigTrkRaw.push_back(tmtdPosMap);
     tofpiOrigTrkRaw.push_back(tofpiMap);
     tofkOrigTrkRaw.push_back(tofkMap);
     tofpOrigTrkRaw.push_back(tofpMap);
     sigmatofpiOrigTrkRaw.push_back(sigmatofpiMap);
     sigmatofkOrigTrkRaw.push_back(sigmatofkMap);
     sigmatofpOrigTrkRaw.push_back(sigmatofpMap);
     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);
       outermostHitPosition.push_back(0.);
     }
 
     ++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, outermostHitPosition, outermostHitPositionToken_);
   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, tmtdPosOrigTrkRaw, tmtdPosOrigTrkToken_);
   fillValueMap(ev, tracksH, tofpiOrigTrkRaw, tofpiOrigTrkToken_);
   fillValueMap(ev, tracksH, tofkOrigTrkRaw, tofkOrigTrkToken_);
   fillValueMap(ev, tracksH, tofpOrigTrkRaw, tofpOrigTrkToken_);
   fillValueMap(ev, tracksH, sigmatofpiOrigTrkRaw, sigmatofpiOrigTrkToken_);
   fillValueMap(ev, tracksH, sigmatofkOrigTrkRaw, sigmatofkOrigTrkToken_);
   fillValueMap(ev, tracksH, sigmatofpOrigTrkRaw, sigmatofpOrigTrkToken_);
   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 1171 of file TrackExtenderWithMTD.cc.

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

                                        {
   const vector<const DetLayer*>& layers = geo->allBTLLayers();
 
   TransientTrackingRecHit::ConstRecHitContainer output;
   bestHit = MTDHitMatchingInfo();
   for (const DetLayer* ilay : layers) {
     LogTrace("TrackExtenderWithMTD") << "Hit search: BTL layer at R= "
                                      << static_cast<const BarrelDetLayer*>(ilay)->specificSurface().radius();
 
     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 1200 of file TrackExtenderWithMTD.cc.

References funct::abs(), MTDDetLayerGeometry::allETLLayers(), cms::cuda::bs, TrajectoryStateOnSurface::globalPosition(), hfClusterShapes_cfi::hits, hgcalTBTopologyTester_cfi::layers, LogTrace, 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
 
     LogTrace("TrackExtenderWithMTD") << "Hit search: ETL disk at Z = " << diskZ;
 
     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 586 of file TrackExtenderWithMTD.cc.

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

◆ betaOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::betaOrigTrkToken_

private

Definition at line 573 of file TrackExtenderWithMTD.cc.

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

◆ bsTimeSpread_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::bsTimeSpread_

private

Definition at line 622 of file TrackExtenderWithMTD.cc.

◆ bsToken_

template<class TrackCollection >

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

private

Definition at line 591 of file TrackExtenderWithMTD.cc.

◆ btlChi2Cut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::btlChi2Cut_

private

Definition at line 614 of file TrackExtenderWithMTD.cc.

◆ btlMatchChi2Token_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::btlMatchChi2Token_

private

Definition at line 565 of file TrackExtenderWithMTD.cc.

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

◆ btlMatchTimeChi2Token_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::btlMatchTimeChi2Token_

private

Definition at line 567 of file TrackExtenderWithMTD.cc.

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

◆ btlTimeChi2Cut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::btlTimeChi2Cut_

private

Definition at line 615 of file TrackExtenderWithMTD.cc.

◆ builder_

template<class TrackCollection >

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

private

Definition at line 600 of file TrackExtenderWithMTD.cc.

◆ builderToken_

template<class TrackCollection >

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

private

Definition at line 601 of file TrackExtenderWithMTD.cc.

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

◆ dlgeoToken_

template<class TrackCollection >

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

private

Definition at line 607 of file TrackExtenderWithMTD.cc.

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

◆ dzCut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::dzCut_

private

Definition at line 621 of file TrackExtenderWithMTD.cc.

◆ estMaxChi2_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::estMaxChi2_

private

Definition at line 612 of file TrackExtenderWithMTD.cc.

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

◆ estMaxNSigma_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::estMaxNSigma_

private

Definition at line 613 of file TrackExtenderWithMTD.cc.

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

◆ etlChi2Cut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::etlChi2Cut_

private

Definition at line 616 of file TrackExtenderWithMTD.cc.

◆ etlMatchChi2Token_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::etlMatchChi2Token_

private

Definition at line 566 of file TrackExtenderWithMTD.cc.

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

◆ etlMatchTimeChi2Token_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::etlMatchTimeChi2Token_

private

Definition at line 568 of file TrackExtenderWithMTD.cc.

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

◆ etlTimeChi2Cut_

template<class TrackCollection >

const float TrackExtenderWithMTDT< TrackCollection >::etlTimeChi2Cut_

private

Definition at line 617 of file TrackExtenderWithMTD.cc.

◆ genVtxPositionToken_

template<class TrackCollection >

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

private

Definition at line 592 of file TrackExtenderWithMTD.cc.

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

◆ genVtxTimeToken_

template<class TrackCollection >

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

private

Definition at line 593 of file TrackExtenderWithMTD.cc.

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

◆ gtg_

template<class TrackCollection >

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

private

Definition at line 604 of file TrackExtenderWithMTD.cc.

◆ gtgToken_

template<class TrackCollection >

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

private

Definition at line 605 of file TrackExtenderWithMTD.cc.

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

◆ hitbuilder_

template<class TrackCollection >

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

private

Definition at line 602 of file TrackExtenderWithMTD.cc.

◆ hitbuilderToken_

template<class TrackCollection >

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

private

Definition at line 603 of file TrackExtenderWithMTD.cc.

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

◆ hitsToken_

template<class TrackCollection >

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

private

Definition at line 590 of file TrackExtenderWithMTD.cc.

◆ magfldToken_

template<class TrackCollection >

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

private

Definition at line 608 of file TrackExtenderWithMTD.cc.

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

◆ mtdRecHitBuilder_

template<class TrackCollection >

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

private

Definition at line 597 of file TrackExtenderWithMTD.cc.

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

◆ npixBarrelToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::npixBarrelToken_

private

Definition at line 569 of file TrackExtenderWithMTD.cc.

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

◆ npixEndcapToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::npixEndcapToken_

private

Definition at line 570 of file TrackExtenderWithMTD.cc.

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

◆ outermostHitPositionToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::outermostHitPositionToken_

private

Definition at line 571 of file TrackExtenderWithMTD.cc.

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

◆ pathLengthOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::pathLengthOrigTrkToken_

private

Definition at line 576 of file TrackExtenderWithMTD.cc.

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

◆ pOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::pOrigTrkToken_

private

Definition at line 572 of file TrackExtenderWithMTD.cc.

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

◆ propagator_

template<class TrackCollection >

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

private

Definition at line 597 of file TrackExtenderWithMTD.cc.

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

◆ propToken_

template<class TrackCollection >

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

private

Definition at line 609 of file TrackExtenderWithMTD.cc.

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

◆ sigmat0OrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::sigmat0OrigTrkToken_

private

Definition at line 575 of file TrackExtenderWithMTD.cc.

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

◆ sigmatmtdOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::sigmatmtdOrigTrkToken_

private

Definition at line 578 of file TrackExtenderWithMTD.cc.

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

◆ sigmatofkOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::sigmatofkOrigTrkToken_

private

Definition at line 584 of file TrackExtenderWithMTD.cc.

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

◆ sigmatofpiOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::sigmatofpiOrigTrkToken_

private

Definition at line 583 of file TrackExtenderWithMTD.cc.

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

◆ sigmatofpOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::sigmatofpOrigTrkToken_

private

Definition at line 585 of file TrackExtenderWithMTD.cc.

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

◆ t0OrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::t0OrigTrkToken_

private

Definition at line 574 of file TrackExtenderWithMTD.cc.

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

◆ theEstimator

template<class TrackCollection >

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

private

Definition at line 598 of file TrackExtenderWithMTD.cc.

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

◆ theTransformer

template<class TrackCollection >

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

private

Definition at line 599 of file TrackExtenderWithMTD.cc.

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

◆ tmtdOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tmtdOrigTrkToken_

private

Definition at line 577 of file TrackExtenderWithMTD.cc.

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

◆ tmtdPosOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tmtdPosOrigTrkToken_

private

Definition at line 579 of file TrackExtenderWithMTD.cc.

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

◆ tofkOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tofkOrigTrkToken_

private

Definition at line 581 of file TrackExtenderWithMTD.cc.

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

◆ tofpiOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tofpiOrigTrkToken_

private

Definition at line 580 of file TrackExtenderWithMTD.cc.

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

◆ tofpOrigTrkToken_

template<class TrackCollection >

edm::EDPutToken TrackExtenderWithMTDT< TrackCollection >::tofpOrigTrkToken_

private

Definition at line 582 of file TrackExtenderWithMTD.cc.

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

◆ tracksToken_

template<class TrackCollection >

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

private

Definition at line 588 of file TrackExtenderWithMTD.cc.

◆ trajTrackAToken_

template<class TrackCollection >

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

private

Definition at line 589 of file TrackExtenderWithMTD.cc.

◆ transientTrackBuilder_

template<class TrackCollection >

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

private

Definition at line 597 of file TrackExtenderWithMTD.cc.

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

◆ ttopoToken_

template<class TrackCollection >

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

private

Definition at line 610 of file TrackExtenderWithMTD.cc.

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

◆ updateExtra_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::updateExtra_

private

Definition at line 596 of file TrackExtenderWithMTD.cc.

◆ updatePattern_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::updatePattern_

private

Definition at line 596 of file TrackExtenderWithMTD.cc.

◆ updateTraj_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::updateTraj_

private

Definition at line 596 of file TrackExtenderWithMTD.cc.

◆ useSimVertex_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::useSimVertex_

private

Definition at line 620 of file TrackExtenderWithMTD.cc.

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

◆ useVertex_

template<class TrackCollection >

const bool TrackExtenderWithMTDT< TrackCollection >::useVertex_

private

Definition at line 619 of file TrackExtenderWithMTD.cc.

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

◆ vtxToken_

template<class TrackCollection >

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

private

Definition at line 594 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_

◆ outermostHitPositionToken_

◆ pathLengthOrigTrkToken_

◆ pOrigTrkToken_

◆ propagator_

◆ propToken_

◆ sigmat0OrigTrkToken_

◆ sigmatmtdOrigTrkToken_

◆ sigmatofkOrigTrkToken_

◆ sigmatofpiOrigTrkToken_

◆ sigmatofpOrigTrkToken_

◆ t0OrigTrkToken_

◆ theEstimator

◆ theTransformer

◆ tmtdOrigTrkToken_

◆ tmtdPosOrigTrkToken_

◆ tofkOrigTrkToken_

◆ tofpiOrigTrkToken_

◆ tofpOrigTrkToken_

◆ tracksToken_

◆ trajTrackAToken_

◆ transientTrackBuilder_

◆ ttopoToken_

◆ updateExtra_

◆ updatePattern_

◆ updateTraj_

◆ useSimVertex_

◆ useVertex_

◆ vtxToken_

template<class TrackCollection>
class TrackExtenderWithMTDT< TrackCollection >