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 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 TrackType &, const Trajectory &traj, 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 TrackType &, const Trajectory &traj, 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	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () 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

edm::ESHandle< Propagator >	prop

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

Member Typedef Documentation

◆ InputCollection

template<class TrackCollection >

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

Definition at line 215 of file TrackExtenderWithMTD.cc.

◆ TrackType

template<class TrackCollection >

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

Definition at line 214 of file TrackExtenderWithMTD.cc.

Constructor & Destructor Documentation

◆ TrackExtenderWithMTDT()

template<class TrackCollection >

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

Definition at line 338 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 934 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 1014 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 259 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 1090 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 391 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(), edm::ParameterSetDescription::add(), TrackTransformer::fillPSetDescription(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ fillMatchingHits()

template<class TrackCollection >

void TrackExtenderWithMTDT< TrackCollection >::fillMatchingHits	(	const DetLayer *	ilay,
		const TrajectoryStateOnSurface &	tsos,
		const Trajectory &	traj,
		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 871 of file TrackExtenderWithMTD.cc.

                                                                                                  {
   std::set<MTDHitMatchingInfo> hitsInLayer;
   bool hitMatched = false;
  
   using namespace std::placeholders;
   auto find_hits = std::bind(find_hits_in_dets,
                              hits,
                              traj,
                              ilay,
                              tsos,
                              _1,
                              bs,
                              bsTimeSpread_,
                              prop,
                              std::ref(theEstimator),
                              _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
     if (hitsInLayer.begin()->estChi2 < etlChi2Cut_ && hitsInLayer.begin()->timeChi2 < etlTimeChi2Cut_) {
       hitMatched = true;
       output.push_back(hitbuilder->build(hitsInLayer.begin()->hit));
       if (*(hitsInLayer.begin()) < bestHit)
         bestHit = *(hitsInLayer.begin());
     }
   }
  
   if (useVertex_ && matchVertex && !hitMatched) {
     //try a second search with beamspot hypothesis
     hitsInLayer.clear();
     find_hits(0, false);
     if (!hitsInLayer.empty()) {
       if (hitsInLayer.begin()->timeChi2 < etlTimeChi2Cut_) {
         if (hitsInLayer.begin()->estChi2 < etlChi2Cut_) {
           hitMatched = true;
           output.push_back(hitbuilder->build(hitsInLayer.begin()->hit));
           if ((*hitsInLayer.begin()) < bestHit)
             bestHit = *(hitsInLayer.begin());
         }
       }
     }
   }
 }

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 431 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

setup the track extras

Definition at line 443 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> prop;
   es.get<TrackingComponentsRecord>().get(propagator_, prop);
  
   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;
  
   edm::Handle<InputCollection> tracksH;
   ev.getByToken(tracksToken_, tracksH);
   const auto& tracks = *tracksH;
  
   edm::Handle<MTDTrackingDetSetVector> hitsH;
   ev.getByToken(hitsToken_, hitsH);
   const auto& hits = *hitsH;
  
   edm::Handle<reco::BeamSpot> bsH;
   ev.getByToken(bsToken_, bsH);
   const auto& bs = *bsH;
  
   const Vertex* pv = nullptr;
   if (useVertex_ && !useSimVertex_) {
     edm::Handle<VertexCollection> vtxH;
     ev.getByToken(vtxToken_, vtxH);
     if (!vtxH.product()->empty())
       pv = &(vtxH.product()->at(0));
   }
  
   std::unique_ptr<math::XYZTLorentzVectorF> genPV(nullptr);
   if (useVertex_ && useSimVertex_) {
     const auto& genVtxPositionHandle = ev.getHandle(genVtxPositionToken_);
     const auto& genVtxTimeHandle = ev.getHandle(genVtxTimeToken_);
     genPV = std::make_unique<math::XYZTLorentzVectorF>(
         genVtxPositionHandle->x(), genVtxPositionHandle->y(), genVtxPositionHandle->z(), *(genVtxTimeHandle));
   }
  
   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()) {
       const auto& btlhits = tryBTLLayers(track,
                                          trajs.front(),
                                          hits,
                                          geo.product(),
                                          magfield.product(),
                                          prop.product(),
                                          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(track,
                                          trajs.front(),
                                          hits,
                                          geo.product(),
                                          magfield.product(),
                                          prop.product(),
                                          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 = 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.product(),
                                       !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, volumeBasedMagneticField_160812_cfi::magfield, eostools::move(), config::ordering, convertSQLitetoXML_cfg::output, edm::Handle< T >::product(), edm::ESHandle< T >::product(), MetAnalyzer::pv(), mps_fire::result, groupFilesInBlocks::reverse, mathSSE::sqrt(), HLT_2018_cff::track, and PDWG_EXOHSCP_cff::tracks.

◆ tryBTLLayers()

template<class TrackCollection >

TransientTrackingRecHit::ConstRecHitContainer TrackExtenderWithMTDT< TrackCollection >::tryBTLLayers	(	const TrackType &	track,
		const Trajectory &	traj,
		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 814 of file TrackExtenderWithMTD.cc.

                                        {
   const vector<const DetLayer*>& layers = geo->allBTLLayers();
  
   auto tTrack = builder->build(track);
   // get the outermost trajectory point on the track
   TrajectoryStateOnSurface tsos = tTrack.outermostMeasurementState();
  
   TransientTrackingRecHit::ConstRecHitContainer output;
   bestHit = MTDHitMatchingInfo();
   for (const DetLayer* ilay : layers)
     fillMatchingHits(ilay, tsos, traj, hits, prop, bs, vtxTime, matchVertex, output, bestHit);
   return output;
 }

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

◆ tryETLLayers()

template<class TrackCollection >

TransientTrackingRecHit::ConstRecHitContainer TrackExtenderWithMTDT< TrackCollection >::tryETLLayers	(	const TrackType &	track,
		const Trajectory &	traj,
		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 839 of file TrackExtenderWithMTD.cc.

                                        {
   const vector<const DetLayer*>& layers = geo->allETLLayers();
  
   auto tTrack = builder->build(track);
   // get the outermost trajectory point on the track
   TrajectoryStateOnSurface tsos = tTrack.outermostMeasurementState();
  
   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, hits, prop, bs, vtxTime, matchVertex, output, bestHit);
   }
   return output;
 }