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

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

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

	TrackExtenderWithMTDT (const ParameterSet &pset)

TransientTrackingRecHit::ConstRecHitContainer	tryBTLLayers (const TrackType &, const MTDTrackingDetSetVector &, const MTDDetLayerGeometry , const MagneticField field, const Propagator *prop) const

TransientTrackingRecHit::ConstRecHitContainer	tryETLLayers (const TrackType &, const MTDTrackingDetSetVector &, const MTDDetLayerGeometry , const MagneticField field, const Propagator *prop) 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::EDGetTokenT< reco::BeamSpot >	bsToken_

edm::ESHandle< TransientTrackBuilder >	builder

edm::ESHandle< GlobalTrackingGeometry >	gtg

edm::ESHandle< TransientTrackingRecHitBuilder >	hitbuilder

edm::EDGetTokenT< MTDTrackingDetSetVector >	hitsToken_

const std::string	mtdRecHitBuilder_

edm::ESHandle< Propagator >	prop

const std::string	propagator_

std::unique_ptr< MeasurementEstimator >	theEstimator

std::unique_ptr< TrackTransformer >	theTransformer

edm::EDGetTokenT< InputCollection >	tracksToken_

const std::string	transientTrackBuilder_

const bool	updateExtra_

const bool	updatePattern_

const bool	updateTraj_

Static Private Attributes
static char	betaOrigTrkName [] = "generalTrackBeta"

static char	pathLengthName [] = "pathLength"

static char	pathLengthOrigTrkName [] = "generalTrackPathLength"

static char	pOrigTrkName [] = "generalTrackp"

static char	sigmat0OrigTrkName [] = "generalTracksigmat0"

static char	sigmatmtdName [] = "sigmatmtd"

static char	sigmatmtdOrigTrkName [] = "generalTracksigmatmtd"

static char	t0OrigTrkName [] = "generalTrackt0"

static char	tmtdName [] = "tmtd"

static char	tmtdOrigTrkName [] = "generalTracktmtd"

Detailed Description

template<class TrackCollection>
class TrackExtenderWithMTDT< TrackCollection >

Definition at line 60 of file TrackExtenderWithMTD.cc.

Member Typedef Documentation

template<class TrackCollection >

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

Definition at line 63 of file TrackExtenderWithMTD.cc.

template<class TrackCollection >

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

Definition at line 62 of file TrackExtenderWithMTD.cc.

Constructor & Destructor Documentation

template<class TrackCollection >

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

Definition at line 144 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")) {
   constexpr float maxChi2 = 500.;
   constexpr float nSigma = 10.;
   theEstimator = std::make_unique<Chi2MeasurementEstimator>(maxChi2, nSigma);
 
   theTransformer = std::make_unique<TrackTransformer>(iConfig.getParameterSet("TrackTransformer"));
 
   produces<edm::ValueMap<float>>(pathLengthName);
   produces<edm::ValueMap<float>>(tmtdName);
   produces<edm::ValueMap<float>>(sigmatmtdName);
   produces<edm::ValueMap<float>>(pOrigTrkName);
   produces<edm::ValueMap<float>>(betaOrigTrkName);
   produces<edm::ValueMap<float>>(t0OrigTrkName);
   produces<edm::ValueMap<float>>(sigmat0OrigTrkName);
   produces<edm::ValueMap<float>>(pathLengthOrigTrkName);
   produces<edm::ValueMap<float>>(tmtdOrigTrkName);
   produces<edm::ValueMap<float>>(sigmatmtdOrigTrkName);
 
   produces<edm::OwnVector<TrackingRecHit>>();
   produces<reco::TrackExtraCollection>();
   produces<TrackCollection>();
 }

Member Function Documentation

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

References funct::abs(), reco::TrackBase::algo(), alongMomentum, FreeTrajectoryState::charge(), Trajectory::chiSquared(), Trajectory::closestMeasurement(), constexpr, FreeTrajectoryState::curvilinearError(), Trajectory::direction(), FastTime, Trajectory::firstMeasurement(), DetId::Forward, TrajectoryStateOnSurface::freeState(), createfilelist::int, TrajectoryStateClosestToBeamLine::isValid(), TrajectoryStateOnSurface::isValid(), Trajectory::lastMeasurement(), m_pi, Trajectory::measurements(), FreeTrajectoryState::momentum(), ndof, Trajectory::ndof(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), Propagator::propagateWithPath(), mathSSE::sqrt(), TrajectoryStateOnSurface::surface(), FrontierCondition_GT_autoExpress_cfi::t0, MTDTrackingRecHit::time(), MTDTrackingRecHit::timeError(), TrajectoryStateClosestToBeamLine::trackStateAtPCA(), reco::TrackBase::undefQuality, UNLIKELY, TrackInfoProducer_cfi::updatedState, TrajectoryMeasurement::updatedState(), findQualityFiles::v, PV3DBase< T, PVType, FrameType >::x(), reco::BeamSpot::x0(), PV3DBase< T, PVType, FrameType >::y(), reco::BeamSpot::y0(), PV3DBase< T, PVType, FrameType >::z(), and reco::BeamSpot::z0().

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

                                                                                           {
   // get the state closest to the beamline
   TrajectoryStateOnSurface stateForProjectionToBeamLineOnSurface =
       traj.closestMeasurement(GlobalPoint(bs.x0(), bs.y0(), bs.z0())).updatedState();
 
   if
     UNLIKELY(!stateForProjectionToBeamLineOnSurface.isValid()) {
       edm::LogError("CannotPropagateToBeamLine") << "the state on the closest measurement isnot valid. skipping track.";
       return reco::Track();
     }
 
   constexpr double m_pi = 0.13957018;
   constexpr double m_pi_inv2 = 1.0 / m_pi / m_pi;
   constexpr double m_p = 0.9382720813;
   constexpr double m_p_inv2 = 1.0 / m_p / m_p;
   constexpr double c_cm_ns = CLHEP::c_light * CLHEP::ns / CLHEP::cm;  //[cm/ns]
   constexpr double c_inv = 1.0 / c_cm_ns;
 
   const FreeTrajectoryState& stateForProjectionToBeamLine = *stateForProjectionToBeamLineOnSurface.freeState();
 
   TSCBLBuilderWithPropagator tscblBuilder(*thePropagator);
   TrajectoryStateClosestToBeamLine tscbl = tscblBuilder(stateForProjectionToBeamLine, bs);
 
   if
     UNLIKELY(!tscbl.isValid()) { 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) {
     bool validpropagation = true;
     double pathlength = 0.;
     double pathlength1 = 0.;
     double pathlength2 = 0.;
     for (auto it = trajWithMtd.measurements().begin(); it != trajWithMtd.measurements().end() - 1; ++it) {
       const auto& propresult = thePropagator->propagateWithPath(it->updatedState(), (it + 1)->updatedState().surface());
       double layerpathlength = std::abs(propresult.second);
       if (layerpathlength == 0.) {
         validpropagation = false;
       }
       pathlength1 += layerpathlength;
     }
 
     double thit = 0.;
     double thiterror = -1.;
     bool validmtd = false;
     if (trajWithMtd.direction() == alongMomentum) {
       for (auto it = trajWithMtd.measurements().begin(); it != trajWithMtd.measurements().end(); ++it) {
         bool ismtd = it->recHit()->geographicalId().det() == DetId::Forward &&
                      ForwardSubdetector(it->recHit()->geographicalId().subdetId()) == FastTime;
         if (ismtd) {
           const auto& propresult2 = thePropagator->propagateWithPath(
               tscbl.trackStateAtPCA(), trajWithMtd.firstMeasurement().updatedState().surface());
           pathlength2 = propresult2.second;
           if (pathlength2 == 0.) {
             validpropagation = false;
           }
           pathlength = pathlength1 + pathlength2;
           const MTDTrackingRecHit* mtdhit = static_cast<const MTDTrackingRecHit*>(it->recHit()->hit());
           thit = mtdhit->time();
           thiterror = mtdhit->timeError();
           validmtd = true;
           break;
         }
       }
     } else {
       for (auto it = trajWithMtd.measurements().rbegin(); it != trajWithMtd.measurements().rend(); ++it) {
         bool ismtd = it->recHit()->geographicalId().det() == DetId::Forward &&
                      ForwardSubdetector(it->recHit()->geographicalId().subdetId()) == FastTime;
         if (ismtd) {
           const auto& propresult2 = thePropagator->propagateWithPath(
               tscbl.trackStateAtPCA(), trajWithMtd.lastMeasurement().updatedState().surface());
           pathlength2 = propresult2.second;
           if (pathlength2 == 0.) {
             validpropagation = false;
           }
           pathlength = pathlength1 + pathlength2;
           const MTDTrackingRecHit* mtdhit = static_cast<const MTDTrackingRecHit*>(it->recHit()->hit());
           thit = mtdhit->time();
           thiterror = mtdhit->timeError();
           validmtd = true;
           break;
         }
       }
     }
 
     if (validmtd && validpropagation) {
       double magp2 = p.mag2();
 
       double gammasq_pi = 1. + magp2 * m_pi_inv2;
       double beta_pi = std::sqrt(1. - 1. / gammasq_pi);
       double dt_pi = pathlength / beta_pi * c_inv;
 
       double gammasq_p = 1. + magp2 * m_p_inv2;
       double beta_p = std::sqrt(1. - 1. / gammasq_p);
       double dt_p = pathlength / beta_p * c_inv;
 
       double dterror = dt_p - dt_pi;
       double betaerror = beta_p - beta_pi;
 
       pathLengthOut = pathlength;  // set path length if we've got a timing hit
       tmtdOut = thit;
       sigmatmtdOut = thiterror;
       t0 = thit - dt_pi;
       covt0t0 = thiterror * thiterror + dterror * dterror;
       betaOut = beta_pi;
       covbetabeta = betaerror * 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);
 }

template<class TrackCollection >

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

Definition at line 592 of file TrackExtenderWithMTD.cc.

References alongMomentum, Surface::bounds(), TrajectoryStateOnSurface::curvilinearError(), Trajectory::direction(), Trajectory::firstMeasurement(), TrajectoryStateOnSurface::globalParameters(), TrackExtenderWithMTDT< TrackCollection >::gtg, GlobalTrackingGeometry::idToDet(), 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(), findQualityFiles::v, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

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

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

template<class TrackCollection >

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

inline

Definition at line 86 of file TrackExtenderWithMTD.cc.

References dqmdumpme::first, RefitDirection::insideOut, dqmdumpme::last, LogDebug, PV3DBase< T, PVType, FrameType >::mag2(), RefitDirection::outsideIn, position, and RefitDirection::undetermined.

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

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

template<class TrackCollection >

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

Definition at line 668 of file TrackExtenderWithMTD.cc.

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

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

template<class TrackCollection >

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

static

Definition at line 177 of file TrackExtenderWithMTD.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), TrackTransformer::fillPSetDescription(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                         {
   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<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);
   descriptions.add("trackExtenderWithMTDBase", desc);
 }

template<class TrackCollection >

template<class H , class T >

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

Definition at line 204 of file TrackExtenderWithMTD.cc.

References trigObjTnPSource_cfi::filler, eostools::move(), MillePedeFileConverter_cfg::out, and edm::Event::put().

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

                                                                                        {
   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(std::move(out), name);
 }

template<class TrackCollection >

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

final

setup the track extras

Definition at line 216 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> 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;
 
   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;
 
   std::vector<unsigned> track_indices;
   unsigned itrack = 0;
   for (const auto& track : tracks) {
     reco::TransientTrack ttrack(track, magfield.product(), gtg);
     const auto& trajs = theTransformer->transform(track);
     auto thits = theTransformer->getTransientRecHits(ttrack);
 
     TransientTrackingRecHit::ConstRecHitContainer mtdthits;
     const auto& btlhits = tryBTLLayers(track, hits, geo.product(), magfield.product(), prop.product());
     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, hits, geo.product(), magfield.product(), prop.product());
     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;
 
     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(), !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);
         pathLengthsRaw.push_back(pathLength);
         tmtdRaw.push_back(tmtd);
         sigmatmtdRaw.push_back(sigmatmtd);
         pathLengthMap = pathLength;
         tmtdMap = tmtd;
         sigmatmtdMap = sigmatmtd;
         auto& backtrack = output->back();
         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);
         }
       }
     }
     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);
     ++itrack;
   }
 
   auto outTrksHandle = ev.put(std::move(output));
   ev.put(std::move(extras));
   ev.put(std::move(outhits));
 
   fillValueMap(ev, outTrksHandle, pathLengthsRaw, pathLengthName);
   fillValueMap(ev, outTrksHandle, tmtdRaw, tmtdName);
   fillValueMap(ev, outTrksHandle, sigmatmtdRaw, sigmatmtdName);
   fillValueMap(ev, tracksH, pOrigTrkRaw, pOrigTrkName);
   fillValueMap(ev, tracksH, betaOrigTrkRaw, betaOrigTrkName);
   fillValueMap(ev, tracksH, t0OrigTrkRaw, t0OrigTrkName);
   fillValueMap(ev, tracksH, sigmat0OrigTrkRaw, sigmat0OrigTrkName);
   fillValueMap(ev, tracksH, pathLengthsOrigTrkRaw, pathLengthOrigTrkName);
   fillValueMap(ev, tracksH, tmtdOrigTrkRaw, tmtdOrigTrkName);
   fillValueMap(ev, tracksH, sigmatmtdOrigTrkRaw, sigmatmtdOrigTrkName);
 }

template<class TrackCollection >

TransientTrackingRecHit::ConstRecHitContainer TrackExtenderWithMTDT< TrackCollection >::tryBTLLayers	(	const TrackType &	track,
		const MTDTrackingDetSetVector &	hits,
		const MTDDetLayerGeometry *	geo,
		const MagneticField *	field,
		const Propagator *	prop
	)		const

Definition at line 399 of file TrackExtenderWithMTD.cc.

References MTDDetLayerGeometry::allBTLLayers(), TransientTrackBuilder::build(), TrackExtenderWithMTDT< TrackCollection >::builder, TrackExtenderWithMTDT< TrackCollection >::hitbuilder, hgcalTopologyTester_cfi::layers, convertSQLitetoXML_cfg::output, and TrackExtenderWithMTDT< TrackCollection >::theEstimator.

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

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

template<class TrackCollection >

TransientTrackingRecHit::ConstRecHitContainer TrackExtenderWithMTDT< TrackCollection >::tryETLLayers	(	const TrackType &	track,
		const MTDTrackingDetSetVector &	hits,
		const MTDDetLayerGeometry *	geo,
		const MagneticField *	field,
		const Propagator *	prop
	)		const

Definition at line 418 of file TrackExtenderWithMTD.cc.

References MTDDetLayerGeometry::allETLLayers(), TransientTrackBuilder::build(), TrackExtenderWithMTDT< TrackCollection >::builder, TrajectoryStateOnSurface::globalPosition(), TrackExtenderWithMTDT< TrackCollection >::hitbuilder, hgcalTopologyTester_cfi::layers, convertSQLitetoXML_cfg::output, TrackExtenderWithMTDT< TrackCollection >::theEstimator, and PV3DBase< T, PVType, FrameType >::z().

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

                                   {
   TransientTrackingRecHit::ConstRecHitContainer output;
   const vector<const DetLayer*>& layers = geo->allETLLayers();
 
   auto tTrack = builder->build(track);
 
   for (const DetLayer* ilay : layers) {
     const BoundDisk& disk = static_cast<const MTDRingForwardDoubleLayer*>(ilay)->specificSurface();
     const double diskZ = disk.position().z();
 
     // get the outermost trajectory point on the track
     TrajectoryStateOnSurface tsos = tTrack.outermostMeasurementState();
     if (tsos.globalPosition().z() * diskZ < 0)
       continue;  // only propagate to the disk that's on the same side
     find_hits_in_dets(hits, ilay, tsos, prop, *theEstimator, *hitbuilder, output);
   }
   return output;
 }