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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 63 of file TrackExtenderWithMTD.cc.

Member Typedef Documentation

template<class TrackCollection >

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

Definition at line 66 of file TrackExtenderWithMTD.cc.

template<class TrackCollection >

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

Definition at line 65 of file TrackExtenderWithMTD.cc.

Constructor & Destructor Documentation

template<class TrackCollection >

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

Definition at line 138 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 439 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(), cscNeutronWriter_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 579 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 90 of file TrackExtenderWithMTD.cc.

References plotBeamSpotDB::first, RefitDirection::insideOut, plotBeamSpotDB::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 651 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 171 of file TrackExtenderWithMTD.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), TrackTransformer::fillPSetDescription(), 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 199 of file TrackExtenderWithMTD.cc.

References objects.autophobj::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 208 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 392 of file TrackExtenderWithMTD.cc.

References MTDDetLayerGeometry::allBTLLayers(), TransientTrackBuilder::build(), TrackExtenderWithMTDT< TrackCollection >::builder, TrackExtenderWithMTDT< TrackCollection >::hitbuilder, LayerTriplets::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 412 of file TrackExtenderWithMTD.cc.

References MTDDetLayerGeometry::allETLLayers(), TransientTrackBuilder::build(), TrackExtenderWithMTDT< TrackCollection >::builder, TrajectoryStateOnSurface::globalPosition(), TrackExtenderWithMTDT< TrackCollection >::hitbuilder, LayerTriplets::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;
 }