Inheritance diagram for TrackExtenderWithMTDT< TrackCollection >:

Public Types
typedef edm::View< TrackType >	InputCollection

typedef TrackCollection::value_type	TrackType

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Member Functions
reco::Track	buildTrack (const reco::Track &, const Trajectory &, const Trajectory &, const reco::BeamSpot &, const MagneticField field, const Propagator prop, bool hasMTD, float &pathLength, float &tmtdOut, float &sigmatmtdOut) 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 double, const double, const MTDTrackingDetSetVector &, const Propagator , const reco::BeamSpot &, const double &, 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 double, const double, const MTDTrackingDetSetVector &, const MTDDetLayerGeometry , const MagneticField field, const Propagator *prop, const reco::BeamSpot &bs, const double vtxTime, const bool matchVertex, MTDHitMatchingInfo &bestHit) const

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

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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_

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::ESHandle< TransientTrackingRecHitBuilder >	hitbuilder_

edm::EDGetTokenT< MTDTrackingDetSetVector >	hitsToken_

const std::string	mtdRecHitBuilder_

edm::EDPutToken	pathLengthOrigTrkToken

edm::EDPutToken	pathLengthToken

edm::EDPutToken	pOrigTrkToken

const std::string	propagator_

edm::EDPutToken	sigmat0OrigTrkToken

edm::EDPutToken	sigmatmtdOrigTrkToken

edm::EDPutToken	sigmatmtdToken

edm::EDPutToken	t0OrigTrkToken

std::unique_ptr< MeasurementEstimator >	theEstimator

std::unique_ptr< TrackTransformer >	theTransformer

edm::EDPutToken	tmtdOrigTrkToken

edm::EDPutToken	tmtdToken

edm::EDGetTokenT< InputCollection >	tracksToken_

const std::string	transientTrackBuilder_

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

Member Typedef Documentation

◆ InputCollection

template<class TrackCollection >

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

Definition at line 286 of file TrackExtenderWithMTD.cc.

◆ TrackType

template<class TrackCollection >

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

Definition at line 285 of file TrackExtenderWithMTD.cc.

Constructor & Destructor Documentation

◆ TrackExtenderWithMTDT()

template<class TrackCollection >

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

Definition at line 414 of file TrackExtenderWithMTD.cc.

     : tracksToken_(consumes<InputCollection>(iConfig.getParameter<edm::InputTag>("tracksSrc"))),
       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"));
  
   btlMatchChi2Token = produces<edm::ValueMap<float>>("btlMatchChi2");
   etlMatchChi2Token = produces<edm::ValueMap<float>>("etlMatchChi2");
   btlMatchTimeChi2Token = produces<edm::ValueMap<float>>("btlMatchTimeChi2");
   etlMatchTimeChi2Token = produces<edm::ValueMap<float>>("etlMatchTimeChi2");
   pathLengthToken = produces<edm::ValueMap<float>>("pathLength");
   tmtdToken = produces<edm::ValueMap<float>>("tmtd");
   sigmatmtdToken = produces<edm::ValueMap<float>>("sigmatmtd");
   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");
   assocOrigTrkToken = produces<edm::ValueMap<int>>("generalTrackassoc");
  
   produces<edm::OwnVector<TrackingRecHit>>();
   produces<reco::TrackExtraCollection>();
   produces<TrackCollection>();
 }

Member Function Documentation

◆ buildTrack()

template<class TrackCollection >

reco::Track TrackExtenderWithMTDT< TrackCollection >::buildTrack	(	const reco::Track &	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
	)		const

Definition at line 951 of file TrackExtenderWithMTD.cc.

                                                                                           {
   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();
  
   double t0 = 0.;
   double covt0t0 = -1.;
   pathLengthOut = -1.f;  // if there is no MTD flag the pathlength with -1
   tmtdOut = 0.f;
   sigmatmtdOut = -1.f;
   double betaOut = 0.;
   double covbetabeta = -1.;
  
   //compute path length for time backpropagation, using first MTD hit for the momentum
   if (hasMTD) {
     double pathlength;
     bool validpropagation = trackPathLength(trajWithMtd, bs, thePropagator, pathlength);
     double thit = 0.;
     double thiterror = -1.;
     bool validmtd = false;
  
     //need to better handle the cases with >1 hit in MTD
     for (auto const& hit : trajWithMtd.measurements()) {
       bool ismtd = hit.recHit()->geographicalId().det() == DetId::Forward &&
                    ForwardSubdetector(hit.recHit()->geographicalId().subdetId()) == FastTime;
       if (ismtd) {
         const MTDTrackingRecHit* mtdhit = static_cast<const MTDTrackingRecHit*>(hit.recHit()->hit());
         thit = mtdhit->time();
         thiterror = mtdhit->timeError();
         validmtd = true;
         break;
       }
     }
  
     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, thit, thiterror, 0., 0., true);
       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;
     }
   }
  
   return reco::Track(traj.chiSquared(),
                      int(ndof),
                      pos,
                      mom,
                      tscbl.trackStateAtPCA().charge(),
                      tscbl.trackStateAtPCA().curvilinearError(),
                      orig.algo(),
                      reco::TrackBase::undefQuality,
                      t0,
                      betaOut,
                      covt0t0,
                      covbetabeta);
 }

References reco::TrackBase::algo(), cms::cuda::bs, FreeTrajectoryState::charge(), Trajectory::chiSquared(), FreeTrajectoryState::curvilinearError(), FastTime, DetId::Forward, createfilelist::int, Trajectory::measurements(), FreeTrajectoryState::momentum(), ndof, Trajectory::ndof(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), FrontierCondition_GT_autoExpress_cfi::t0, MTDTrackingRecHit::time(), MTDTrackingRecHit::timeError(), TrajectoryStateClosestToBeamLine::trackStateAtPCA(), reco::TrackBase::undefQuality, and findQualityFiles::v.

◆ buildTrackExtra()

template<class TrackCollection >

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

Definition at line 1031 of file TrackExtenderWithMTD.cc.

                                                                                                          {
   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;
 }

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.

◆ checkRecHitsOrdering()

template<class TrackCollection >

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

inline

Definition at line 336 of file TrackExtenderWithMTD.cc.

                                                                         {
     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;
   }

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

◆ dumpLayer()

template<class TrackCollection >

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

Definition at line 1107 of file TrackExtenderWithMTD.cc.

                                                                                     {
   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();
 }

References convertSQLitetoXML_cfg::output, and GeometricSearchDet::surface().

◆ fillDescriptions()

template<class TrackCollection >

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

static

Definition at line 467 of file TrackExtenderWithMTD.cc.

                                                                                                         {
   edm::ParameterSetDescription desc, transDesc;
   desc.add<edm::InputTag>("tracksSrc", 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);
 }

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

◆ fillMatchingHits()

template<class TrackCollection >

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

Definition at line 882 of file TrackExtenderWithMTD.cc.

                                                                                                  {
   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,
                              _1,
                              std::cref(bs),
                              bsTimeSpread_,
                              prop,
                              theEstimator.get(),
                              _2,
                              std::ref(hitsInLayer));
  
   if (useVertex_ && matchVertex)
     find_hits(vtxTime, true);
   else
     find_hits(0, false);
  
   //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 < etlChi2Cut_ && firstHit.timeChi2 < etlTimeChi2Cut_) {
       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 < etlTimeChi2Cut_) {
         if (firstHit.estChi2 < etlChi2Cut_) {
           hitMatched = true;
           output.push_back(hitbuilder_->build(firstHit.hit));
           if (firstHit < bestHit)
             bestHit = firstHit;
         }
       }
     }
   }
 }

References cms::cuda::bs, hfClusterShapes_cfi::hits, and convertSQLitetoXML_cfg::output.

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

                                                                                             {
   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));
 }

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

◆ produce()

template<class TrackCollection >

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

final

trajs.empty()

setup the track extras

Definition at line 519 of file TrackExtenderWithMTD.cc.

                                                                                           {
   //this produces pieces of the track extra
   Traj2TrackHits t2t;
  
   theTransformer->setServices(es);
  
   TrackingRecHitRefProd hitsRefProd = ev.getRefBeforePut<TrackingRecHitCollection>();
   reco::TrackExtraRefProd extrasRefProd = ev.getRefBeforePut<reco::TrackExtraCollection>();
  
   es.get<GlobalTrackingGeometryRecord>().get(gtg_);
  
   edm::ESHandle<MTDDetLayerGeometry> geo;
   es.get<MTDRecoGeometryRecord>().get(geo);
  
   edm::ESHandle<MagneticField> magfield;
   es.get<IdealMagneticFieldRecord>().get(magfield);
  
   es.get<TransientTrackRecord>().get(transientTrackBuilder_, builder_);
   es.get<TransientRecHitRecord>().get(mtdRecHitBuilder_, hitbuilder_);
  
   edm::ESHandle<Propagator> propH;
   es.get<TrackingComponentsRecord>().get(propagator_, propH);
   const Propagator* prop = propH.product();
  
   edm::ESHandle<TrackerTopology> httopo;
   es.get<TrackerTopologyRcd>().get(httopo);
   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<float> pathLengthsRaw;
   std::vector<float> tmtdRaw;
   std::vector<float> sigmatmtdRaw;
   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<int> assocOrigTrkRaw;
  
   auto const tracksH = ev.getHandle(tracksToken_);
   const auto& tracks = *tracksH;
  
   //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);
   }
  
   double vtxTime = 0.;
   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& track : tracks) {
     double trackVtxTime = 0.;
     if (useVertex_) {
       double 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_);
     const auto& trajs = theTransformer->transform(track);
     auto thits = theTransformer->getTransientRecHits(ttrack);
     TransientTrackingRecHit::ConstRecHitContainer mtdthits;
     MTDHitMatchingInfo mBTL, mETL;
     if (!trajs.empty()) {
       // get the outermost trajectory point on the track
       TrajectoryStateOnSurface tsos = builder_->build(track).outermostMeasurementState();
       TrajectoryStateClosestToBeamLine tscbl;
       bool tscbl_status = getTrajectoryStateClosestToBeamLine(trajs.front(), bs, prop, tscbl);
  
       if (tscbl_status) {
         double pmag2 = tscbl.trackStateAtPCA().momentum().mag2();
         double pathlength0;
         trackPathLength(trajs.front(), tscbl, prop, pathlength0);
  
         const auto& btlhits = tryBTLLayers(tsos,
                                            trajs.front(),
                                            pmag2,
                                            pathlength0,
                                            hits,
                                            geo.product(),
                                            magfield.product(),
                                            prop,
                                            bs,
                                            trackVtxTime,
                                            trackVtxTime != 0.,
                                            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.front(),
                                            pmag2,
                                            pathlength0,
                                            hits,
                                            geo.product(),
                                            magfield.product(),
                                            prop,
                                            bs,
                                            trackVtxTime,
                                            trackVtxTime != 0.,
                                            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() ? 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;
     int iMap = -1;
  
     for (const auto& trj : trajwithmtd) {
       const auto& thetrj = (updateTraj_ ? trj : trajs.front());
       float pathLength = 0.f, tmtd = 0.f, sigmatmtd = -1.f;
       reco::Track result = buildTrack(track,
                                       thetrj,
                                       trj,
                                       bs,
                                       magfield.product(),
                                       prop,
                                       !trajwithmtd.empty() && !mtdthits.empty(),
                                       pathLength,
                                       tmtd,
                                       sigmatmtd);
       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);
         etlMatchChi2.push_back(mETL.hit ? mETL.estChi2 : -1);
         btlMatchTimeChi2.push_back(mBTL.hit ? mBTL.timeChi2 : -1);
         etlMatchTimeChi2.push_back(mETL.hit ? mETL.timeChi2 : -1);
         pathLengthsRaw.push_back(pathLength);
         tmtdRaw.push_back(tmtd);
         sigmatmtdRaw.push_back(sigmatmtd);
         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());
         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);
         }
       } 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);
     assocOrigTrkRaw.push_back(iMap);
     ++itrack;
   }
  
   auto outTrksHandle = ev.put(std::move(output));
   ev.put(std::move(extras));
   ev.put(std::move(outhits));
  
   fillValueMap(ev, outTrksHandle, btlMatchChi2, btlMatchChi2Token);
   fillValueMap(ev, outTrksHandle, etlMatchChi2, etlMatchChi2Token);
   fillValueMap(ev, outTrksHandle, btlMatchTimeChi2, btlMatchTimeChi2Token);
   fillValueMap(ev, outTrksHandle, etlMatchTimeChi2, etlMatchTimeChi2Token);
   fillValueMap(ev, outTrksHandle, pathLengthsRaw, pathLengthToken);
   fillValueMap(ev, outTrksHandle, tmtdRaw, tmtdToken);
   fillValueMap(ev, outTrksHandle, sigmatmtdRaw, sigmatmtdToken);
   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, assocOrigTrkRaw, assocOrigTrkToken);
 }

References funct::abs(), cms::cuda::bs, PVValHelper::dz, ev, edm::EventSetup::get(), get, hfClusterShapes_cfi::hits, RefitDirection::insideOut, LogTrace, PV3DBase< T, PVType, FrameType >::mag2(), volumeBasedMagneticField_160812_cfi::magfield, FreeTrajectoryState::momentum(), eostools::move(), config::ordering, convertSQLitetoXML_cfg::output, edm::ESHandle< T >::product(), MetAnalyzer::pv(), mps_fire::result, groupFilesInBlocks::reverse, mathSSE::sqrt(), HLT_FULL_cff::track, PDWG_EXOHSCP_cff::tracks, and TrajectoryStateClosestToBeamLine::trackStateAtPCA().

◆ tryBTLLayers()

template<class TrackCollection >

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

Definition at line 829 of file TrackExtenderWithMTD.cc.

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

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

◆ tryETLLayers()

template<class TrackCollection >

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

Definition at line 852 of file TrackExtenderWithMTD.cc.

                                        {
   const vector<const DetLayer*>& layers = geo->allETLLayers();
  
   TransientTrackingRecHit::ConstRecHitContainer output;
   bestHit = MTDHitMatchingInfo();
   for (const DetLayer* ilay : layers) {
     const BoundDisk& disk = static_cast<const MTDRingForwardDoubleLayer*>(ilay)->specificSurface();
     const double 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, hits, prop, bs, vtxTime, matchVertex, output, bestHit);
   }
   return output;
 }