#include <TrackProducerWithSCAssociation.h>

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	setAlias (std::string alias)
	set the aliases of produced collections More...

void	setClusterRemovalInfo (const edm::InputTag &clusterRemovalInfo)
	Sets the information on cluster removal, and turns it on. More...

void	setConf (const edm::ParameterSet &conf)
	Set parameter set. More...

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

void	setSrc (const edm::EDGetToken &src, const edm::EDGetTokenT< reco::BeamSpot > &bsSrc, const edm::EDGetTokenT< MeasurementTrackerEvent > &mteSrc)
	set label of source collection More...

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

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

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

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_

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

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

edm::EDGetTokenT< reco::BeamSpot >	bsSrc_

edm::InputTag	clusterRemovalInfo_

edm::ParameterSet	conf_

edm::EDGetTokenT< MeasurementTrackerEvent >	mteSrc_

bool	rekeyClusterRefs_

edm::OrphanHandle< TrackCollection >	rTracks_

edm::EDGetToken	src_

edm::ESHandle< NavigationSchool >	theSchool

bool	trajectoryInEvent_

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 19 of file TrackProducerWithSCAssociation.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 20 of file TrackProducerWithSCAssociation.cc.

References TrackProducerBase< reco::Track >::alias_, assoc_token, conversionTrackCandidateProducer_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), HLT_2018_cff::InputTag, measurementTrkToken_, myname_, myTrajectoryInEvent_, TrackProducerBase< reco::Track >::setAlias(), TrackProducerBase< reco::Track >::setClusterRemovalInfo(), TrackProducerBase< reco::Track >::setConf(), TrackProducerBase< reco::Track >::setSrc(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, trackCSuperClusterAssociationCollection_, and trackSuperClusterAssociationCollection_.

     : TrackProducerBase<reco::Track>(iConfig.getParameter<bool>("TrajectoryInEvent")), theAlgo(iConfig) {
   setConf(iConfig);
   setSrc(consumes<TrackCandidateCollection>(iConfig.getParameter<edm::InputTag>("src")),
          consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpot")),
          consumes<MeasurementTrackerEvent>(iConfig.getParameter<edm::InputTag>("MeasurementTrackerEvent")));
   setAlias(iConfig.getParameter<std::string>("@module_label"));
 
   if (iConfig.exists("clusterRemovalInfo")) {
     edm::InputTag tag = iConfig.getParameter<edm::InputTag>("clusterRemovalInfo");
     if (!(tag == edm::InputTag())) {
       setClusterRemovalInfo(tag);
     }
   }
 
   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

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

Definition at line 210 of file TrackProducerWithSCAssociation.cc.

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

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 56 of file TrackProducerWithSCAssociation.cc.

References assoc_token, TransientTrackingRecHitBuilder::build(), TrackProducerAlgorithm< T >::buildTrack(), generateEDF::cont, PTrajectoryStateOnDet::detId(), MillePedeFileConverter_cfg::e, edm::ValueMap< T >::empty(), edm::HandleBase::failedToGet(), benchmark_cfg::fc, edm::helper::Filler< Map >::fill(), trigObjTnPSource_cfi::filler, edm::EventSetup::get(), edm::Event::getByToken(), TrackProducerBase< reco::Track >::getFromES(), TrackProducerBase< reco::Track >::getFromEvt(), hfClusterShapes_cfi::hits, mps_fire::i, edm::helper::Filler< Map >::insert(), edm::HandleBase::isValid(), eostools::move(), ndof, convertSQLiteXML::ok, edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::Event::put(), putInEvt(), TrackCandidate::recHits(), rTracks_, TrackCandidate::seed(), SurveyInfoScenario_cff::seed, TrackCandidate::seedRef(), theAlgo, trackCSuperClusterAssociationCollection_, trackSuperClusterAssociationCollection_, TrackCandidate::trajectoryStateOnDet(), trajectoryStateTransform::transientState(), 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);
 
   edm::ESHandle<TrackerTopology> httopo;
   setup.get<TrackerTopologyRcd>().get(httopo);
   const TrackerTopology* ttopo = httopo.product();
 
   //
   //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 TrackCandidate::range& recHitVec = theTC->recHits();
         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 (edm::OwnVector<TrackingRecHit>::const_iterator i = recHitVec.first; i != recHitVec.second; i++) {
           hits.push_back(theBuilder.product()->build(&(*i)));
         }
 
         //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_);
   }
 }

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 269 of file TrackProducerWithSCAssociation.cc.

References alongMomentum, reco::TrackBase::appendHitPattern(), TrajectoryStateOnSurface::curvilinearError(), Trajectory::direction(), Trajectory::firstMeasurement(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), TrajectoryStateOnSurface::globalParameters(), mps_fire::i, training_settings::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::Track::setExtra(), reco::TrackExtraBase::setHits(), TrackProducerBase< reco::Track >::setSecondHitPattern(), reco::TrackExtraBase::setTrajParams(), OrderedSet::t, TrackProducerBase< reco::Track >::theSchool, HLT_2018_cff::track, TrackProducerBase< reco::Track >::trajectoryInEvent_, TrajectoryMeasurement::updatedState(), findQualityFiles::v, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

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