Inheritance diagram for TrackProducerWithSCAssociation:

Public Member Functions
std::vector< reco::TransientTrack >	getTransient (edm::Event &, const edm::EventSetup &)

void	produce (edm::Event &, const edm::EventSetup &) override
	Method where the procduction take place. To be implemented in concrete classes. More...

	TrackProducerWithSCAssociation (const edm::ParameterSet &iConfig)

Public Member Functions inherited from TrackProducerBase< reco::Track >
const edm::ParameterSet &	getConf () const

virtual void	getFromES (const edm::EventSetup &, edm::ESHandle< TrackerGeometry > &, edm::ESHandle< MagneticField > &, edm::ESHandle< TrajectoryFitter > &, edm::ESHandle< Propagator > &, edm::ESHandle< MeasurementTracker > &, edm::ESHandle< TransientTrackingRecHitBuilder > &)
	Get needed services from the Event Setup. More...

virtual void	getFromEvt (edm::Event &, edm::Handle< TrackCandidateCollection > &, reco::BeamSpot &)
	Get TrackCandidateCollection from the Event (needed by TrackProducer) More...

virtual void	getFromEvt (edm::Event &, edm::Handle< TrackView > &, reco::BeamSpot &)
	Get TrackCollection from the Event (needed by TrackRefitter) More...

void	initTrackProducerBase (const edm::ParameterSet &conf, edm::ConsumesCollector cc, const edm::EDGetToken &src)
	Call this method in inheriting class' constructor. More...

void	setAlias (std::string alias)
	set the aliases of produced collections More...

void	setSecondHitPattern (Trajectory traj, reco::Track &track, const Propagator prop, const MeasurementTrackerEvent measTk, const TrackerTopology ttopo)

	TrackProducerBase (bool trajectoryInEvent=false)
	Constructor. More...

virtual	~TrackProducerBase () noexcept(false)
	Destructor. More...

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

Private Member Functions
void	putInEvt (edm::Event &evt, const Propagator thePropagator, const MeasurementTracker theMeasTk, std::unique_ptr< TrackingRecHitCollection > selHits, std::unique_ptr< reco::TrackCollection > selTracks, std::unique_ptr< reco::TrackExtraCollection > selTrackExtras, std::unique_ptr< std::vector< Trajectory >> selTrajectories, AlgoProductCollection &algoResults, TransientTrackingRecHitBuilder const hitBuilder, const TrackerTopology ttopo)

Private Attributes
edm::EDGetTokenT< reco::TrackCandidateCaloClusterPtrAssociation >	assoc_token

std::string	conversionTrackCandidateProducer_

edm::EDGetTokenT< MeasurementTrackerEvent >	measurementTrkToken_

std::string	myname_

bool	myTrajectoryInEvent_

edm::OrphanHandle< reco::TrackCollection >	rTracks_

TrackProducerAlgorithm< reco::Track >	theAlgo

std::string	trackCSuperClusterAssociationCollection_

std::string	trackSuperClusterAssociationCollection_

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	ttopoToken_

bool	validTrackCandidateSCAssociationInput_

Additional Inherited Members
Public Types inherited from TrackProducerBase< reco::Track >
using	AlgoProductCollection = typename Base::AlgoProductCollection

using	Base = AlgoProductTraits< reco::Track >

using	TrackCollection = typename Base::TrackCollection

using	TrackView = typename Base::TrackView

Public Types inherited from AlgoProductTraits< reco::Track >
using	AlgoProductCollection = std::vector< AlgoProduct >

using	TrackCollection = std::vector< reco::Track >

using	TrackView = edm::View< reco::Track >

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

Protected Attributes inherited from TrackProducerBase< reco::Track >
std::string	alias_

edm::EDGetTokenT< reco::BeamSpot >	bsSrc_

edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	builderSrc_

edm::ParameterSet	conf_

edm::ESGetToken< TrajectoryFitter, TrajectoryFitter::Record >	fitterSrc_

edm::ESGetToken< MeasurementTracker, CkfComponentsRecord >	measTkSrc_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	mfSrc_

edm::EDGetTokenT< MeasurementTrackerEvent >	mteSrc_

edm::ESGetToken< Propagator, TrackingComponentsRecord >	propagatorSrc_

edm::OrphanHandle< TrackCollection >	rTracks_

edm::ESGetToken< NavigationSchool, NavigationSchoolRecord >	schoolSrc_

edm::EDGetToken	src_

edm::ESHandle< NavigationSchool >	theSchool

edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackGeomSrc_

bool	trajectoryInEvent_

bool	useSchool_

Detailed Description

Author: Nancy Marinelli, U. of Notre Dame, US Modified version of TrackProducer by Giuseppe Cerati to have super cluster - conversion track association

Definition at line 28 of file TrackProducerWithSCAssociation.cc.

Constructor & Destructor Documentation

◆ TrackProducerWithSCAssociation()

TrackProducerWithSCAssociation::TrackProducerWithSCAssociation ( const edm::ParameterSet & iConfig )

explicit

Definition at line 66 of file TrackProducerWithSCAssociation.cc.

References TrackProducerBase< reco::Track >::alias_, assoc_token, conversionTrackCandidateProducer_, edm::ParameterSet::getParameter(), TrackProducerBase< reco::Track >::initTrackProducerBase(), ProducerED_cfi::InputTag, measurementTrkToken_, myname_, myTrajectoryInEvent_, TrackProducerBase< reco::Track >::setAlias(), AlCaHLTBitMon_QueryRunRegistry::string, trackCSuperClusterAssociationCollection_, and trackSuperClusterAssociationCollection_.

     : TrackProducerBase<reco::Track>(iConfig.getParameter<bool>("TrajectoryInEvent")),
       theAlgo(iConfig),
       ttopoToken_(esConsumes()) {
   initTrackProducerBase(
       iConfig, consumesCollector(), consumes<TrackCandidateCollection>(iConfig.getParameter<edm::InputTag>("src")));
   setAlias(iConfig.getParameter<std::string>("@module_label"));
 
   myname_ = iConfig.getParameter<std::string>("ComponentName");
   conversionTrackCandidateProducer_ = iConfig.getParameter<std::string>("producer");
   trackCSuperClusterAssociationCollection_ = iConfig.getParameter<std::string>("trackCandidateSCAssociationCollection");
   trackSuperClusterAssociationCollection_ = iConfig.getParameter<std::string>("recoTrackSCAssociationCollection");
   myTrajectoryInEvent_ = iConfig.getParameter<bool>("TrajectoryInEvent");
 
   assoc_token = consumes<reco::TrackCandidateCaloClusterPtrAssociation>(
       edm::InputTag(conversionTrackCandidateProducer_, trackCSuperClusterAssociationCollection_));
   measurementTrkToken_ = consumes<MeasurementTrackerEvent>(
       edm::InputTag("MeasurementTrackerEvent"));  //hardcoded because the original was and no time to fix (sigh)
 
   //register your products
   produces<reco::TrackCollection>().setBranchAlias(alias_ + "Tracks");
   produces<reco::TrackExtraCollection>().setBranchAlias(alias_ + "TrackExtras");
   produces<TrackingRecHitCollection>().setBranchAlias(alias_ + "RecHits");
   produces<std::vector<Trajectory>>();
   produces<TrajTrackAssociationCollection>();
   //  produces< reco::TrackSuperClusterAssociationCollection > (trackSuperClusterAssociationCollection_ );
   produces<reco::TrackCaloClusterPtrAssociation>(trackSuperClusterAssociationCollection_);
 }

Member Function Documentation

◆ getTransient()

std::vector< reco::TransientTrack > TrackProducerWithSCAssociation::getTransient	(	edm::Event &	theEvent,
		const edm::EventSetup &	setup
	)

Definition at line 246 of file TrackProducerWithSCAssociation.cc.

References cms::cuda::bs, MillePedeFileConverter_cfg::e, TrackProducerBase< reco::Track >::getFromES(), TrackProducerBase< reco::Track >::getFromEvt(), edm::EventBase::id(), Propagator::magneticField(), dumpMFGeometry_cfg::prod, edm::ESHandle< T >::product(), TrackProducerAlgorithm< T >::runWithCandidate(), singleTopDQM_cfi::setup, and theAlgo.

                                                                                                            {
   edm::LogInfo("TrackProducerWithSCAssociation") << "Analyzing event number: " << theEvent.id() << "\n";
   //
   // create empty output collections
   //
   std::vector<reco::TransientTrack> ttks;
 
   //
   //declare and get stuff to be retrieved from ES
   //
   edm::ESHandle<TrackerGeometry> theG;
   edm::ESHandle<MagneticField> theMF;
   edm::ESHandle<TrajectoryFitter> theFitter;
   edm::ESHandle<Propagator> thePropagator;
   edm::ESHandle<TransientTrackingRecHitBuilder> theBuilder;
   edm::ESHandle<MeasurementTracker> theMeasTk;
   getFromES(setup, theG, theMF, theFitter, thePropagator, theMeasTk, theBuilder);
 
   //
   //declare and get TrackColection to be retrieved from the event
   //
   AlgoProductCollection algoResults;
   reco::BeamSpot bs;
 
   try {
     edm::Handle<TrackCandidateCollection> theTCCollection;
     getFromEvt(theEvent, theTCCollection, bs);
 
     //
     //run the algorithm
     //
     //LogDebug("TrackProducerWithSCAssociation") << "TrackProducerWithSCAssociation run the algorithm" << "\n";
     theAlgo.runWithCandidate(theG.product(),
                              theMF.product(),
                              *theTCCollection,
                              theFitter.product(),
                              thePropagator.product(),
                              theBuilder.product(),
                              bs,
                              algoResults);
 
   } catch (cms::Exception& e) {
     edm::LogInfo("TrackProducerWithSCAssociation") << "cms::Exception caught!!!"
                                                    << "\n"
                                                    << e << "\n";
   }
 
   for (auto& prod : algoResults) {
     ttks.emplace_back(*prod.track, thePropagator.product()->magneticField());
   }
 
   //LogDebug("TrackProducerWithSCAssociation") << "TrackProducerWithSCAssociation end" << "\n";
 
   return ttks;
 }

◆ produce()

void TrackProducerWithSCAssociation::produce	(	edm::Event &	,
		const edm::EventSetup &
	)

overridevirtual

Method where the procduction take place. To be implemented in concrete classes.

Implements TrackProducerBase< reco::Track >.

Definition at line 95 of file TrackProducerWithSCAssociation.cc.

References assoc_token, cms::cuda::bs, TransientTrackingRecHitBuilder::build(), TrackProducerAlgorithm< T >::buildTrack(), generateEDF::cont, MillePedeFileConverter_cfg::e, edm::ValueMap< T >::empty(), edm::HandleBase::failedToGet(), trigObjTnPSource_cfi::filler, edm::Event::getByToken(), TrackProducerBase< reco::Track >::getFromES(), TrackProducerBase< reco::Track >::getFromEvt(), hfClusterShapes_cfi::hits, mps_fire::i, edm::HandleBase::isValid(), eostools::move(), ndof, convertSQLiteXML::ok, edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::Event::put(), putInEvt(), rpcPointValidation_cfi::recHit, TrackCandidate::recHits(), rTracks_, TrackCandidate::seed(), fileCollector::seed, TrackCandidate::seedRef(), singleTopDQM_cfi::setup, theAlgo, trackCSuperClusterAssociationCollection_, trackSuperClusterAssociationCollection_, TrackCandidate::trajectoryStateOnDet(), trajectoryStateTransform::transientState(), ttopoToken_, and validTrackCandidateSCAssociationInput_.

                                                                                            {
   //edm::LogInfo("TrackProducerWithSCAssociation") << "Analyzing event number: " << theEvent.id() << "\n";
 
   //LogDebug("TrackProducerWithSCAssociation") << "Analyzing event number: " << theEvent.id() << "\n";
   //  std::cout << " TrackProducerWithSCAssociation Analyzing event number: " << theEvent.id() << "\n";
 
   //
   // create empty output collections
   //
   auto outputRHColl = std::make_unique<TrackingRecHitCollection>();
   auto outputTColl = std::make_unique<reco::TrackCollection>();
   auto outputTEColl = std::make_unique<reco::TrackExtraCollection>();
   auto outputTrajectoryColl = std::make_unique<std::vector<Trajectory>>();
   //   Reco Track - Super Cluster Association
   auto scTrkAssoc_p = std::make_unique<reco::TrackCaloClusterPtrAssociation>();
 
   //
   //declare and get stuff to be retrieved from ES
   //
   edm::ESHandle<TrackerGeometry> theG;
   edm::ESHandle<MagneticField> theMF;
   edm::ESHandle<TrajectoryFitter> theFitter;
   edm::ESHandle<Propagator> thePropagator;
   edm::ESHandle<TransientTrackingRecHitBuilder> theBuilder;
   edm::ESHandle<MeasurementTracker> theMeasTk;
   getFromES(setup, theG, theMF, theFitter, thePropagator, theMeasTk, theBuilder);
 
   const TrackerTopology* ttopo = &setup.getData(ttopoToken_);
 
   //
   //declare and get TrackColection to be retrieved from the event
   edm::Handle<TrackCandidateCollection> theTCCollection;
   validTrackCandidateSCAssociationInput_ = true;
   edm::Handle<reco::TrackCandidateCaloClusterPtrAssociation> trkCandidateSCAssocHandle;
   theEvent.getByToken(assoc_token, trkCandidateSCAssocHandle);
   if (!trkCandidateSCAssocHandle.isValid()) {
     //    std::cout << "Error! Can't get the product  "<<trackCSuperClusterAssociationCollection_.c_str() << " but keep running. Empty collection will be produced " << "\n";
     edm::LogError("TrackProducerWithSCAssociation")
         << "Error! Can't get the product  " << trackCSuperClusterAssociationCollection_.c_str()
         << " but keep running. Empty collection will be produced "
         << "\n";
     validTrackCandidateSCAssociationInput_ = false;
   }
   reco::TrackCandidateCaloClusterPtrAssociation scTrkCandAssCollection = *(trkCandidateSCAssocHandle.product());
   if (scTrkCandAssCollection.empty())
     validTrackCandidateSCAssociationInput_ = false;
 
   std::vector<int> tccLocations;
   AlgoProductCollection algoResults;
   reco::BeamSpot bs;
 
   getFromEvt(theEvent, theTCCollection, bs);
 
   if (theTCCollection.failedToGet()) {
     edm::LogError("TrackProducerWithSCAssociation")
         << "TrackProducerWithSCAssociation could not get the TrackCandidateCollection.";
   } else {
     //
     //run the algorithm
     //
     //  LogDebug("TrackProducerWithSCAssociation") << "TrackProducerWithSCAssociation run the algorithm" << "\n";
     //    theAlgo.runWithCandidate(theG.product(), theMF.product(), *theTCCollection,
     //               theFitter.product(), thePropagator.product(), theBuilder.product(), algoResults);
     // we have to copy this method from the algo in order to get the association track-seed
     // this is ugly temporary code that should be replaced!!!!!
     // start of copied code ======================================================
 
     //    std::cout << "TrackProducerWithSCAssociation  Number of TrackCandidates: " << theTCCollection->size() << "\n";
     try {
       int cont = 0;
       int tcc = 0;
 
       for (TrackCandidateCollection::const_iterator i = theTCCollection->begin(); i != theTCCollection->end(); i++) {
         const TrackCandidate* theTC = &(*i);
         PTrajectoryStateOnDet state = theTC->trajectoryStateOnDet();
         const TrajectorySeed& seed = theTC->seed();
 
         //convert PTrajectoryStateOnDet to TrajectoryStateOnSurface
 
         DetId detId(state.detId());
         TrajectoryStateOnSurface theTSOS = trajectoryStateTransform::transientState(
             state, &(theG.product()->idToDet(detId)->surface()), theMF.product());
 
         //LogDebug("TrackProducerWithSCAssociation")  << "TrackProducerWithSCAssociation  Initial TSOS\n" << theTSOS << "\n";
 
         //convert the TrackingRecHit vector to a TransientTrackingRecHit vector
         //meanwhile computes the number of degrees of freedom
         TransientTrackingRecHit::RecHitContainer hits;
 
         float ndof = 0;
 
         for (auto const& recHit : theTC->recHits()) {
           hits.push_back(theBuilder.product()->build(&recHit));
         }
 
         //build Track
         // LogDebug("TrackProducerWithSCAssociation") << "TrackProducerWithSCAssociation going to buildTrack"<< "\n";
         FitterCloner fc(theFitter.product(), theBuilder.product());
         bool ok = theAlgo.buildTrack(
             fc.fitter.get(), thePropagator.product(), algoResults, hits, theTSOS, seed, ndof, bs, theTC->seedRef());
         // LogDebug("TrackProducerWithSCAssociation")  << "TrackProducerWithSCAssociation buildTrack result: " << ok << "\n";
         if (ok) {
           cont++;
           tccLocations.push_back(tcc);
         }
         tcc++;
       }
       edm::LogInfo("TrackProducerWithSCAssociation") << "Number of Tracks found: " << cont << "\n";
       //LogDebug("TrackProducerWithSCAssociation") << "TrackProducerWithSCAssociation Number of Tracks found: " << cont << "\n";
       // end of copied code ======================================================
 
     } catch (cms::Exception& e) {
       edm::LogInfo("TrackProducerWithSCAssociation") << "cms::Exception caught!!!"
                                                      << "\n"
                                                      << e << "\n";
     }
     //
     //put everything in the event
     // we copy putInEvt to get OrphanHandle filled...
     putInEvt(theEvent,
              thePropagator.product(),
              theMeasTk.product(),
              std::move(outputRHColl),
              std::move(outputTColl),
              std::move(outputTEColl),
              std::move(outputTrajectoryColl),
              algoResults,
              theBuilder.product(),
              ttopo);
 
     // now construct associationmap and put it in the  event
     if (validTrackCandidateSCAssociationInput_) {
       int itrack = 0;
       std::vector<edm::Ptr<reco::CaloCluster>> caloPtrVec;
       for (AlgoProductCollection::iterator i = algoResults.begin(); i != algoResults.end(); i++) {
         edm::Ref<TrackCandidateCollection> trackCRef(theTCCollection, tccLocations[itrack]);
         const edm::Ptr<reco::CaloCluster>& aClus = (*trkCandidateSCAssocHandle)[trackCRef];
         caloPtrVec.push_back(aClus);
         itrack++;
       }
 
       edm::ValueMap<reco::CaloClusterPtr>::Filler filler(*scTrkAssoc_p);
       filler.insert(rTracks_, caloPtrVec.begin(), caloPtrVec.end());
       filler.fill();
     }
 
     theEvent.put(std::move(scTrkAssoc_p), trackSuperClusterAssociationCollection_);
   }
 }

◆ putInEvt()

void TrackProducerWithSCAssociation::putInEvt	(	edm::Event &	evt,
		const Propagator *	thePropagator,
		const MeasurementTracker *	theMeasTk,
		std::unique_ptr< TrackingRecHitCollection >	selHits,
		std::unique_ptr< reco::TrackCollection >	selTracks,
		std::unique_ptr< reco::TrackExtraCollection >	selTrackExtras,
		std::unique_ptr< std::vector< Trajectory >>	selTrajectories,
		AlgoProductCollection &	algoResults,
		TransientTrackingRecHitBuilder const *	hitBuilder,
		const TrackerTopology *	ttopo
	)

private

Definition at line 305 of file TrackProducerWithSCAssociation.cc.

References alongMomentum, TrajectoryStateOnSurface::curvilinearError(), Trajectory::direction(), Trajectory::firstMeasurement(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), TrajectoryStateOnSurface::globalParameters(), mps_fire::i, heavyIonCSV_trainingSettings::idx, edm::ESHandleBase::isValid(), Trajectory::lastMeasurement(), measurementTrkToken_, GlobalTrajectoryParameters::momentum(), eostools::move(), myTrajectoryInEvent_, AlCaHLTBitMon_ParallelJobs::p, GlobalTrajectoryParameters::position(), edm::Event::put(), TrajectoryMeasurement::recHit(), rTracks_, Trajectory::seedRef(), reco::TrackExtraBase::setHits(), TrackProducerBase< reco::Track >::setSecondHitPattern(), reco::TrackExtraBase::setTrajParams(), submitPVValidationJobs::t, TrackProducerBase< reco::Track >::theSchool, HLT_2023v12_cff::track, TrackProducerBase< reco::Track >::trajectoryInEvent_, TrajectoryMeasurement::updatedState(), and findQualityFiles::v.

Referenced by produce().

                                                                             {
   TrackingRecHitRefProd rHits = evt.getRefBeforePut<TrackingRecHitCollection>();
   reco::TrackExtraRefProd rTrackExtras = evt.getRefBeforePut<reco::TrackExtraCollection>();
 
   edm::Ref<reco::TrackExtraCollection>::key_type idx = 0;
   edm::Ref<reco::TrackCollection>::key_type iTkRef = 0;
   edm::Ref<std::vector<Trajectory>>::key_type iTjRef = 0;
   std::map<unsigned int, unsigned int> tjTkMap;
 
   for (auto& i : algoResults) {
     Trajectory* theTraj = i.trajectory;
     if (myTrajectoryInEvent_) {
       selTrajectories->push_back(*theTraj);
       iTjRef++;
     }
 
     reco::Track* theTrack = i.track;
     PropagationDirection seedDir = i.pDir;
 
     //LogDebug("TrackProducer") << "In KfTrackProducerBase::putInEvt - seedDir=" << seedDir;
 
     reco::Track t = *theTrack;
     selTracks->push_back(t);
     iTkRef++;
 
     // Store indices in local map (starts at 0)
     if (trajectoryInEvent_)
       tjTkMap[iTjRef - 1] = iTkRef - 1;
 
     //sets the outermost and innermost TSOSs
 
     TrajectoryStateOnSurface outertsos;
     TrajectoryStateOnSurface innertsos;
     unsigned int innerId, outerId;
 
     // ---  NOTA BENE: the convention is to sort hits and measurements "along the momentum".
     // This is consistent with innermost and outermost labels only for tracks from LHC collision
     if (theTraj->direction() == alongMomentum) {
       outertsos = theTraj->lastMeasurement().updatedState();
       innertsos = theTraj->firstMeasurement().updatedState();
       outerId = theTraj->lastMeasurement().recHit()->geographicalId().rawId();
       innerId = theTraj->firstMeasurement().recHit()->geographicalId().rawId();
     } else {
       outertsos = theTraj->firstMeasurement().updatedState();
       innertsos = theTraj->lastMeasurement().updatedState();
       outerId = theTraj->firstMeasurement().recHit()->geographicalId().rawId();
       innerId = theTraj->lastMeasurement().recHit()->geographicalId().rawId();
     }
     // ---
     //build the TrackExtra
     GlobalPoint v = outertsos.globalParameters().position();
     GlobalVector p = outertsos.globalParameters().momentum();
     math::XYZVector outmom(p.x(), p.y(), p.z());
     math::XYZPoint outpos(v.x(), v.y(), v.z());
     v = innertsos.globalParameters().position();
     p = innertsos.globalParameters().momentum();
     math::XYZVector inmom(p.x(), p.y(), p.z());
     math::XYZPoint inpos(v.x(), v.y(), v.z());
 
     reco::TrackExtraRef teref = reco::TrackExtraRef(rTrackExtras, idx++);
     reco::Track& track = selTracks->back();
     track.setExtra(teref);
 
     //======= I want to set the second hitPattern here =============
     if (theSchool.isValid()) {
       edm::Handle<MeasurementTrackerEvent> mte;
       evt.getByToken(measurementTrkToken_, mte);
       setSecondHitPattern(theTraj, track, thePropagator, &*mte, ttopo);
     }
     //==============================================================
 
     selTrackExtras->push_back(reco::TrackExtra(outpos,
                                                outmom,
                                                true,
                                                inpos,
                                                inmom,
                                                true,
                                                outertsos.curvilinearError(),
                                                outerId,
                                                innertsos.curvilinearError(),
                                                innerId,
                                                seedDir,
                                                theTraj->seedRef()));
 
     reco::TrackExtra& tx = selTrackExtras->back();
     // ---  NOTA BENE: the convention is to sort hits and measurements "along the momentum".
     // This is consistent with innermost and outermost labels only for tracks from LHC collisions
     reco::TrackExtra::TrajParams trajParams;
     reco::TrackExtra::Chi2sFive chi2s;
     Traj2TrackHits t2t;
     auto ih = selHits->size();
     t2t(*theTraj, *selHits, trajParams, chi2s);
     auto ie = selHits->size();
     tx.setHits(rHits, ih, ie - ih);
     tx.setTrajParams(std::move(trajParams), std::move(chi2s));
     for (; ih < ie; ++ih) {
       auto const& hit = (*selHits)[ih];
       track.appendHitPattern(hit, *ttopo);
     }
     // ----
 
     delete theTrack;
     delete theTraj;
   }
 
   //LogTrace("TrackingRegressionTest") << "========== TrackProducer Info ===================";
   //LogDebug("TrackProducerWithSCAssociation") << "number of finalTracks: " << selTracks->size() << std::endl;
   //for (reco::TrackCollection::const_iterator it = selTracks->begin(); it != selTracks->end(); it++) {
   //LogDebug("TrackProducerWithSCAssociation")  << "track's n valid and invalid hit, chi2, pt : "
   //                                  << it->found() << " , "
   //                                  << it->lost()  <<" , "
   //                                  << it->normalizedChi2() << " , "
   //           << it->pt() << std::endl;
   // }
   //LogTrace("TrackingRegressionTest") << "=================================================";
 
   rTracks_ = evt.put(std::move(selTracks));
 
   evt.put(std::move(selTrackExtras));
   evt.put(std::move(selHits));
 
   if (myTrajectoryInEvent_) {
     edm::OrphanHandle<std::vector<Trajectory>> rTrajs = evt.put(std::move(selTrajectories));
 
     // Now Create traj<->tracks association map
     auto trajTrackMap = std::make_unique<TrajTrackAssociationCollection>(rTrajs, rTracks_);
     for (std::map<unsigned int, unsigned int>::iterator i = tjTkMap.begin(); i != tjTkMap.end(); i++) {
       edm::Ref<std::vector<Trajectory>> trajRef(rTrajs, (*i).first);
       edm::Ref<reco::TrackCollection> tkRef(rTracks_, (*i).second);
       trajTrackMap->insert(edm::Ref<std::vector<Trajectory>>(rTrajs, (*i).first),
                            edm::Ref<reco::TrackCollection>(rTracks_, (*i).second));
     }
     evt.put(std::move(trajTrackMap));
   }
 }