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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

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

Private Attributes
edm::EDPutToken	assocOrigTrkToken

edm::EDPutToken	betaOrigTrkToken

const float	bsTimeSpread_

edm::EDGetTokenT< reco::BeamSpot >	bsToken_

const float	btlChi2Cut_

edm::EDPutToken	btlMatchChi2Token

edm::EDPutToken	btlMatchTimeChi2Token

const float	btlTimeChi2Cut_

edm::ESHandle< TransientTrackBuilder >	builder_

edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	builderToken_

edm::ESGetToken< MTDDetLayerGeometry, MTDRecoGeometryRecord >	dlgeoToken_

const float	dzCut_

const float	estMaxChi2_

const float	estMaxNSigma_

const float	etlChi2Cut_

edm::EDPutToken	etlMatchChi2Token

edm::EDPutToken	etlMatchTimeChi2Token

const float	etlTimeChi2Cut_

edm::EDGetTokenT< GlobalPoint >	genVtxPositionToken_

edm::EDGetTokenT< float >	genVtxTimeToken_

edm::ESHandle< GlobalTrackingGeometry >	gtg_

edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	gtgToken_

edm::ESHandle< TransientTrackingRecHitBuilder >	hitbuilder_

edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	hitbuilderToken_

edm::EDGetTokenT< MTDTrackingDetSetVector >	hitsToken_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magfldToken_

const std::string	mtdRecHitBuilder_

edm::EDPutToken	npixBarrelToken

edm::EDPutToken	npixEndcapToken

edm::EDPutToken	pathLengthOrigTrkToken

edm::EDPutToken	pOrigTrkToken

const std::string	propagator_

edm::ESGetToken< Propagator, TrackingComponentsRecord >	propToken_

edm::EDPutToken	sigmat0OrigTrkToken

edm::EDPutToken	sigmatmtdOrigTrkToken

edm::EDPutToken	t0OrigTrkToken

std::unique_ptr< MeasurementEstimator >	theEstimator

std::unique_ptr< TrackTransformer >	theTransformer

edm::EDPutToken	tmtdOrigTrkToken

edm::EDGetTokenT< InputCollection >	tracksToken_

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

Member Typedef Documentation

◆ InputCollection

template<class TrackCollection >

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

Definition at line 287 of file TrackExtenderWithMTD.cc.

◆ TrackType

template<class TrackCollection >

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

Definition at line 286 of file TrackExtenderWithMTD.cc.

Constructor & Destructor Documentation

◆ TrackExtenderWithMTDT()

template<class TrackCollection >

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

Definition at line 422 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");
   npixBarrelToken = produces<edm::ValueMap<int>>("npixBarrel");
   npixEndcapToken = produces<edm::ValueMap<int>>("npixEndcap");
   pOrigTrkToken = produces<edm::ValueMap<float>>("generalTrackp");
   betaOrigTrkToken = produces<edm::ValueMap<float>>("generalTrackBeta");
   t0OrigTrkToken = produces<edm::ValueMap<float>>("generalTrackt0");
   sigmat0OrigTrkToken = produces<edm::ValueMap<float>>("generalTracksigmat0");
   pathLengthOrigTrkToken = produces<edm::ValueMap<float>>("generalTrackPathLength");
   tmtdOrigTrkToken = produces<edm::ValueMap<float>>("generalTracktmtd");
   sigmatmtdOrigTrkToken = produces<edm::ValueMap<float>>("generalTracksigmatmtd");
   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::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 978 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.;
  
   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) {
     double pathlength;
     bool validpropagation = trackPathLength(trajWithMtd, bs, thePropagator, pathlength);
     double thit = 0.;
     double thiterror = -1.;
     bool validmtd = false;
  
     if (!validpropagation) {
       return routput();
     }
  
     size_t ihitcount(0), ietlcount(0);
     for (auto const& hit : trajWithMtd.measurements()) {
       if (hit.recHit()->geographicalId().det() == DetId::Forward &&
           ForwardSubdetector(hit.recHit()->geographicalId().subdetId()) == FastTime) {
         ihitcount++;
         if (MTDDetId(hit.recHit()->geographicalId()).mtdSubDetector() == MTDDetId::MTDType::ETL) {
           ietlcount++;
         }
       }
     }
  
     auto ihit1 = trajWithMtd.measurements().cbegin();
     if (ihitcount == 1) {
       const MTDTrackingRecHit* mtdhit = static_cast<const MTDTrackingRecHit*>((*ihit1).recHit()->hit());
       thit = mtdhit->time();
       thiterror = mtdhit->timeError();
       validmtd = true;
     } else if (ihitcount == 2 && ietlcount == 2) {
       const auto& propresult =
           thePropagator->propagateWithPath(ihit1->updatedState(), (ihit1 + 1)->updatedState().surface());
       double etlpathlength = std::abs(propresult.second);
       //
       // The information of the two ETL hits is combined and attributed to the innermost hit
       //
       if (etlpathlength == 0.) {
         validpropagation = false;
       } else {
         pathlength -= etlpathlength;
         const MTDTrackingRecHit* mtdhit1 = static_cast<const MTDTrackingRecHit*>((*ihit1).recHit()->hit());
         const MTDTrackingRecHit* mtdhit2 = static_cast<const MTDTrackingRecHit*>((*(ihit1 + 1)).recHit()->hit());
         TrackTofPidInfo tofInfo =
             computeTrackTofPidInfo(p.mag2(), etlpathlength, mtdhit1->time(), mtdhit1->timeError(), 0., 0., true);
         //
         // Protect against incompatible times
         //
         double err1 = tofInfo.dterror * tofInfo.dterror;
         double err2 = mtdhit2->timeError() * mtdhit2->timeError();
         if (cms_rounding::roundIfNear0(err1) == 0. || cms_rounding::roundIfNear0(err2) == 0.) {
           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. / err1;
             err2 = 1. / err2;
             thiterror = 1. / (err1 + err2);
             thit = (tofInfo.dt * err1 + mtdhit2->time() * err2) * thiterror;
             thiterror = std::sqrt(thiterror);
             LogDebug("TrackExtenderWithMTD") << "p trk = " << p.mag() << " ETL hits times/errors: " << mtdhit1->time()
                                              << " +/- " << mtdhit1->timeError() << " , " << mtdhit2->time() << " +/- "
                                              << mtdhit2->timeError() << " extrapolated time1: " << tofInfo.dt << " +/- "
                                              << tofInfo.dterror << " average = " << thit << " +/- " << thiterror;
             validmtd = true;
           }
         }
       }
     } else {
       edm::LogInfo("TrackExtenderWithMTD")
           << "MTD hits #" << ihitcount << "ETL hits #" << ietlcount << " anomalous pattern, skipping...";
     }
  
     if (validmtd && validpropagation) {
       //here add the PID uncertainty for later use in the 1st step of 4D vtx reconstruction
       TrackTofPidInfo tofInfo = computeTrackTofPidInfo(p.mag2(), pathlength, 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 routput();
 }

References funct::abs(), reco::TrackBase::algo(), cms::cuda::bs, FreeTrajectoryState::charge(), Trajectory::chiSquared(), FreeTrajectoryState::curvilinearError(), FastTime, DetId::Forward, createfilelist::int, LogDebug, Trajectory::measurements(), FreeTrajectoryState::momentum(), ndof, Trajectory::ndof(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), Propagator::propagateWithPath(), rpcPointValidation_cfi::recHit, cms_rounding::roundIfNear0(), mathSSE::sqrt(), 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 1117 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 337 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 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 1193 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 phase1PixelTopology::layer, and convertSQLitetoXML_cfg::output.

◆ fillDescriptions()

template<class TrackCollection >

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

static

Definition at line 483 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 909 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 523 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 535 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>();
  
   gtg_ = es.getHandle(gtgToken_);
  
   auto geo = es.getTransientHandle(dlgeoToken_);
  
   auto magfield = es.getTransientHandle(magfldToken_);
  
   builder_ = es.getHandle(builderToken_);
   hitbuilder_ = es.getHandle(hitbuilderToken_);
  
   auto propH = es.getTransientHandle(propToken_);
   const Propagator* prop = propH.product();
  
   auto httopo = es.getTransientHandle(ttopoToken_);
   const TrackerTopology& ttopo = *httopo;
  
   auto output = std::make_unique<TrackCollection>();
   auto extras = std::make_unique<reco::TrackExtraCollection>();
   auto outhits = std::make_unique<edm::OwnVector<TrackingRecHit>>();
  
   std::vector<float> btlMatchChi2;
   std::vector<float> etlMatchChi2;
   std::vector<float> btlMatchTimeChi2;
   std::vector<float> etlMatchTimeChi2;
   std::vector<int> npixBarrel;
   std::vector<int> npixEndcap;
   std::vector<float> pOrigTrkRaw;
   std::vector<float> betaOrigTrkRaw;
   std::vector<float> t0OrigTrkRaw;
   std::vector<float> sigmat0OrigTrkRaw;
   std::vector<float> pathLengthsOrigTrkRaw;
   std::vector<float> tmtdOrigTrkRaw;
   std::vector<float> sigmatmtdOrigTrkRaw;
   std::vector<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);
         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);
         }
         npixBarrel.push_back(backtrack.hitPattern().numberOfValidPixelBarrelHits());
         npixEndcap.push_back(backtrack.hitPattern().numberOfValidPixelEndcapHits());
       } 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);
  
     if (iMap == -1) {
       btlMatchChi2.push_back(-1.);
       etlMatchChi2.push_back(-1.);
       btlMatchTimeChi2.push_back(-1.);
       etlMatchTimeChi2.push_back(-1.);
       npixBarrel.push_back(-1.);
       npixEndcap.push_back(-1.);
     }
  
     ++itrack;
   }
  
   auto outTrksHandle = ev.put(std::move(output));
   ev.put(std::move(extras));
   ev.put(std::move(outhits));
  
   fillValueMap(ev, tracksH, btlMatchChi2, btlMatchChi2Token);
   fillValueMap(ev, tracksH, etlMatchChi2, etlMatchChi2Token);
   fillValueMap(ev, tracksH, btlMatchTimeChi2, btlMatchTimeChi2Token);
   fillValueMap(ev, tracksH, etlMatchTimeChi2, etlMatchTimeChi2Token);
   fillValueMap(ev, tracksH, npixBarrel, npixBarrelToken);
   fillValueMap(ev, tracksH, npixEndcap, npixEndcapToken);
   fillValueMap(ev, tracksH, pOrigTrkRaw, pOrigTrkToken);
   fillValueMap(ev, tracksH, betaOrigTrkRaw, betaOrigTrkToken);
   fillValueMap(ev, tracksH, t0OrigTrkRaw, t0OrigTrkToken);
   fillValueMap(ev, tracksH, sigmat0OrigTrkRaw, sigmat0OrigTrkToken);
   fillValueMap(ev, tracksH, pathLengthsOrigTrkRaw, pathLengthOrigTrkToken);
   fillValueMap(ev, tracksH, tmtdOrigTrkRaw, tmtdOrigTrkToken);
   fillValueMap(ev, tracksH, sigmatmtdOrigTrkRaw, sigmatmtdOrigTrkToken);
   fillValueMap(ev, tracksH, assocOrigTrkRaw, assocOrigTrkToken);
 }

References funct::abs(), cms::cuda::bs, PVValHelper::dz, ev, edm::EventSetup::getHandle(), edm::EventSetup::getTransientHandle(), hfClusterShapes_cfi::hits, RefitDirection::insideOut, LogTrace, PV3DBase< T, PVType, FrameType >::mag2(), volumeBasedMagneticField_160812_cfi::magfield, FreeTrajectoryState::momentum(), eostools::move(), config::ordering, convertSQLitetoXML_cfg::output, MetAnalyzer::pv(), mps_fire::result, groupFilesInBlocks::reverse, mathSSE::sqrt(), HLT_FULL_cff::track, 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 848 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 871 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);
   }
  
   // 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;
 }