#include <FastTrackMerger.h>

Inheritance diagram for FastTrackMerger:

Public Member Functions
	FastTrackMerger (const edm::ParameterSet &conf)

virtual void	produce (edm::Event &e, const edm::EventSetup &es)

virtual	~FastTrackMerger ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
int	findId (const reco::Track &aTrack) const

Private Attributes
std::vector< edm::EDGetTokenT < TrajTrackAssociationCollection > >	assoMapTokens

unsigned	minHits

bool	promoteQuality

double	pTMin2

std::string	qualityStr

std::vector< edm::InputTag >	removeTrackProducers

std::vector< edm::EDGetTokenT < reco::TrackCollection > >	removeTrackTokens

unsigned	theMaxConsecutiveLostHits

unsigned	theMaxLostHits

unsigned	theMinimumNumberOfHits

unsigned	trackAlgo

std::vector< edm::InputTag >	trackProducers

bool	tracksOnly

std::vector< edm::EDGetTokenT < reco::TrackCollection > >	trackTokens

std::vector< edm::EDGetTokenT < std::vector< Trajectory > > >	trajectoryTokens

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 25 of file FastTrackMerger.h.

Constructor & Destructor Documentation

FastTrackMerger::FastTrackMerger ( const edm::ParameterSet & conf )

explicit

Definition at line 26 of file FastTrackMerger.cc.

References assoMapTokens, edm::EDConsumerBase::consumes(), gather_cfg::cout, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), minHits, promoteQuality, pTMin2, qualityStr, removeTrackProducers, removeTrackTokens, AlCaHLTBitMon_QueryRunRegistry::string, theMaxConsecutiveLostHits, theMaxLostHits, theMinimumNumberOfHits, trackAlgo, trackProducers, tracksOnly, trackTokens, and trajectoryTokens.

 {  
 #ifdef FAMOS_DEBUG
   std::cout << "FastTrackMerger created" << std::endl;
 #endif
 
   // The main product is a track collection, and all extras
   produces<reco::TrackCollection>();
   
   // The name of the track producers to merge
   trackProducers = conf.getParameter<std::vector<edm::InputTag> >("TrackProducers");
 
   // The name of the track producers to remove
   std::vector<edm::InputTag> defaultRemove;
   removeTrackProducers = 
     conf.getUntrackedParameter<std::vector<edm::InputTag> >("RemoveTrackProducers",defaultRemove);
 
   // Only the tracks!
   tracksOnly = conf.getUntrackedParameter<bool>("SaveTracksOnly",false);
 
   // optional pT cut
   double pTMin = conf.getUntrackedParameter<bool>("pTMin",0.);
   pTMin2 = pTMin*pTMin;
 
   // optional nHit cut
   minHits = conf.getUntrackedParameter<unsigned>("minHits",0);
 
   // optional track quality saving
   promoteQuality = conf.getUntrackedParameter<bool>("promoteTrackQuality",false);
   qualityStr = conf.getUntrackedParameter<std::string>("newQuality","");
 
   // optional trackAlgo (iter0/1/2/3/4)
   trackAlgo = conf.getUntrackedParameter<unsigned>("trackAlgo",0);
 
   //new parameters for Trajectory filtering
 
   // The minimum number of hits
   theMinimumNumberOfHits = conf.getUntrackedParameter<unsigned>("MinNumberOfTrajHits",0);
 
   // The maximum number of Lost Hits
   theMaxLostHits = conf.getUntrackedParameter<unsigned>("MaxLostTrajHits",99);
 
   // the max number of consecutive Lost Hits 
   theMaxConsecutiveLostHits = conf.getUntrackedParameter<unsigned>("MaxConsecutiveLostTrajHits",3);
 
   //======================
 
   if ( !tracksOnly ) { 
     produces<reco::TrackExtraCollection>();
     produces<TrackingRecHitCollection>();
     produces<std::vector<Trajectory> >();
     produces<TrajTrackAssociationCollection>();
   } else {
     produces<reco::TrackExtraCollection>();
     produces<TrackingRecHitCollection>();
   }
 
   // consumes
   for ( unsigned aProducer=0; aProducer<removeTrackProducers.size(); ++aProducer ) { 
     removeTrackTokens.push_back(consumes<reco::TrackCollection>(removeTrackProducers[aProducer]));
   }
   for ( unsigned aProducer=0; aProducer<trackProducers.size(); ++aProducer ) { 
     trackTokens.push_back(consumes<reco::TrackCollection>(trackProducers[aProducer]));
     trajectoryTokens.push_back(consumes<std::vector<Trajectory> >(trackProducers[aProducer]));
     assoMapTokens.push_back(consumes<TrajTrackAssociationCollection>(trackProducers[aProducer]));
   }
 }

virtual FastTrackMerger::~FastTrackMerger ( )

inlinevirtual

Definition at line 31 of file FastTrackMerger.h.

31 {}

Member Function Documentation

int FastTrackMerger::findId ( const reco::Track & aTrack ) const

private

Definition at line 465 of file FastTrackMerger.cc.

References reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), and SiTrackerGSMatchedRecHit2D::simtrackId().

Referenced by produce().

                                                      {
   int trackId = -1;
   trackingRecHit_iterator aHit = aTrack.recHitsBegin();
   trackingRecHit_iterator lastHit = aTrack.recHitsEnd();
   for ( ; aHit!=lastHit; ++aHit ) {
     if ( !aHit->get()->isValid() ) continue;
     //    const SiTrackerGSRecHit2D * rechit = (const SiTrackerGSRecHit2D*) (aHit->get());
     const SiTrackerGSMatchedRecHit2D * rechit = (const SiTrackerGSMatchedRecHit2D*) (aHit->get());
     trackId = rechit->simtrackId();
     break;
   }
   return trackId;
 }

void FastTrackMerger::produce	(	edm::Event &	e,
		const edm::EventSetup &	es
	)

virtual

Implements edm::EDProducer.

Definition at line 97 of file FastTrackMerger.cc.

References reco::TrackExtraBase::add(), assoMapTokens, edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, gather_cfg::cout, findId(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), cmsHarvester::index, reco::Track::innerDetId(), reco::Track::innerMomentum(), reco::Track::innerOk(), reco::Track::innerPosition(), reco::Track::innerStateCovariance(), reco::TrackBase::iter0, reco::TrackBase::iter1, reco::TrackBase::iter2, reco::TrackBase::iter3, reco::TrackBase::iter4, reco::TrackBase::iter5, reco::TrackBase::iter6, edm::Ref< C, T, F >::key(), Trajectory::lost(), minHits, reco::Track::outerDetId(), reco::Track::outerMomentum(), reco::Track::outerOk(), reco::Track::outerPosition(), reco::Track::outerStateCovariance(), promoteQuality, pTMin2, edm::Event::put(), reco::TrackBase::qualityByName(), qualityStr, reco::Track::recHit(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), reco::Track::recHitsSize(), removeTrackProducers, removeTrackTokens, reco::Track::residuals(), reco::Track::seedDirection(), reco::Track::seedRef(), reco::TrackExtra::setResiduals(), theMaxConsecutiveLostHits, theMaxLostHits, theMinimumNumberOfHits, trackAlgo, trackProducers, tracksOnly, trackTokens, trajectoryTokens, reco::TrackBase::undefAlgorithm, and reco::TrackBase::undefQuality.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                              {        
 
 #ifdef FAMOS_DEBUG
   std::cout << "################################################################" << std::endl;
   std::cout << " FastTrackMerger produce init " << std::endl;
 #endif
 
   // The track algorithm (only of merging after iterative tracking)
   reco::TrackBase::TrackAlgorithm algo;
   switch(trackAlgo)  {
   case 4:  algo = reco::TrackBase::iter0; break;
   case 5:  algo = reco::TrackBase::iter1; break;
   case 6:  algo = reco::TrackBase::iter2; break;
   case 7:  algo = reco::TrackBase::iter3; break;
   case 8:  algo = reco::TrackBase::iter4; break;
   case 9:  algo = reco::TrackBase::iter5; break;
   case 10: algo = reco::TrackBase::iter6; break;
   default: algo = reco::TrackBase::undefAlgorithm;
   }
 
   // The produced objects
   std::auto_ptr<reco::TrackCollection> recoTracks(new reco::TrackCollection);
   std::auto_ptr<reco::TrackExtraCollection> recoTrackExtras(new reco::TrackExtraCollection);
   std::auto_ptr<TrackingRecHitCollection> recoHits(new TrackingRecHitCollection);
   std::auto_ptr<std::vector<Trajectory> > recoTrajectories(new std::vector<Trajectory>);
   std::auto_ptr<TrajTrackAssociationCollection> recoTrajTrackMap(new TrajTrackAssociationCollection());
 
   //prepare the ref to copy the extras
   reco::TrackExtraRefProd rTrackExtras = e.getRefBeforePut<reco::TrackExtraCollection>();
   TrackingRecHitRefProd rHits = e.getRefBeforePut<TrackingRecHitCollection>();
   std::vector<reco::TrackRef> trackRefs;
 
   // No seed -> output an empty track collection
   if(trackProducers.size() == 0) {
     e.put(recoTracks);
     if ( !tracksOnly ) { 
       e.put(recoTrackExtras);
       e.put(recoHits);
       e.put(recoTrajectories);
       e.put(recoTrajTrackMap);
     } else {
       e.put(recoTrackExtras);
       e.put(recoHits);
     }
     return;
   }
 
   // The quality to be set
   reco::TrackBase::TrackQuality qualityToSet;
   if (qualityStr != "")
     qualityToSet = reco::TrackBase::qualityByName(qualityStr);
   else 
     qualityToSet = reco::TrackBase::undefQuality;
 
   // The input track collection handle
   edm::Handle<reco::TrackCollection> theTrackCollection;
 
   // First, the tracks to be removed
   std::set<unsigned> removeTracks;
   for ( unsigned aProducer=0; aProducer<removeTrackProducers.size(); ++aProducer ) { 
     bool isTrackCollection = e.getByToken(removeTrackTokens[aProducer],theTrackCollection); 
     if (!isTrackCollection) continue;
     reco::TrackCollection::const_iterator aTrack = theTrackCollection->begin();
     reco::TrackCollection::const_iterator lastTrack = theTrackCollection->end();
     for ( ; aTrack!=lastTrack; ++aTrack ) {
       // Get the simtrack Id
       int recoTrackId = findId(*aTrack);
       if ( recoTrackId < 0 ) continue;
       // Remove the track if requested
       if ( removeTracks.find((unsigned)recoTrackId) != removeTracks.end() ) continue;
       removeTracks.insert((unsigned)recoTrackId);
     }      
   }
   
   // Then the tracks to be added
   std::set<unsigned> alreadyAddedTracks;
   
   // Loop on the track producers to be merged
   for ( unsigned aProducer=0; aProducer<trackProducers.size(); ++aProducer ) { 
     
     bool isTrackCollection = e.getByToken(trackTokens[aProducer],theTrackCollection); 
     if ( ! isTrackCollection ) { 
 #ifdef FAMOS_DEBUG
       std::cout << "***FastTrackMerger*** Warning! The track collection " 
         << trackProducers[aProducer].encode() 
         << " does not exist." << std::endl;
 #endif
       continue;
     }
 
 #ifdef FAMOS_DEBUG
     std::cout << "***FastTrackMerger*** of track collection " 
           << trackProducers[aProducer].encode() 
           << " with " << theTrackCollection->size() 
           << " tracks to be copied"
           << std::endl;
 #endif
     reco::TrackCollection::const_iterator aTrack = theTrackCollection->begin();
     reco::TrackCollection::const_iterator lastTrack = theTrackCollection->end();
 
     //Copy Tracks and TracksExtra 
     if ( tracksOnly ) { 
 
       edm:: Handle<reco::TrackExtraCollection > theTrackExtraCollection;
       //      bool isTrackExtraCollection = e.getByLabel(trackProducers[aProducer],theTrackExtraCollection); 
 
       bool index = 0;
       for ( ; aTrack!=lastTrack; ++aTrack,++index ) {
 
     // Find the track id
     int recoTrackId = findId(*aTrack);
     if ( recoTrackId < 0 ) continue;
         
     // Ignore tracks to be removed or tracks already copied
     std::set<unsigned>::iterator iR = removeTracks.find((unsigned)recoTrackId);
 #ifdef FAMOS_DEBUG
     if( iR != removeTracks.end() ) std::cout << recoTrackId << "(REMOVED) ";
 #endif
     if( iR != removeTracks.end() ) continue;
     
     // Ignore tracks already copied
     std::set<unsigned>::iterator iA = alreadyAddedTracks.find((unsigned)recoTrackId);
 #ifdef FAMOS_DEBUG
     if( iA != alreadyAddedTracks.end() ) std::cout << recoTrackId << "(ALREADY ADDED) ";
 #endif
     if( iA != alreadyAddedTracks.end() ) continue;
     //if it is not there then add it! 
     alreadyAddedTracks.insert(recoTrackId);
 
     
 #ifdef FAMOS_DEBUG
     std::cout << recoTrackId << " ADDED ";
 #endif
 
     // Ignore tracks with too small a pT
 #ifdef FAMOS_DEBUG
     if ( aTrack->innerMomentum().Perp2() < pTMin2 ) 
       std::cout << "PTMIN CUT APPLIED = " <<  aTrack->innerMomentum().Perp2() << std::endl;
 #endif
 
     if ( aTrack->innerMomentum().Perp2() < pTMin2 ) continue;
     
     // Ignore tracks with too small a pT
     if ( aTrack->recHitsSize() < minHits ) continue;
     
     // A copy of the track + save the transient reference to the track extra reference
     reco::Track aRecoTrack(*aTrack);
     recoTracks->push_back(aRecoTrack);
     
 
     recoTrackExtras->push_back(reco::TrackExtra(aRecoTrack.outerPosition(), aRecoTrack.outerMomentum(), aRecoTrack.outerOk(),
                            aRecoTrack.innerPosition(), aRecoTrack.innerMomentum(), aRecoTrack.innerOk(),
                            aRecoTrack.outerStateCovariance(), aRecoTrack.outerDetId(),
                            aRecoTrack.innerStateCovariance(), aRecoTrack.innerDetId(),
                            aRecoTrack.seedDirection(), aRecoTrack.seedRef() ) ); 
 
 
     recoTracks->back().setExtra(reco::TrackExtraRef(rTrackExtras,recoTrackExtras->size()-1)); 
 
     reco::TrackExtra & tx = recoTrackExtras->back();
     tx.setResiduals(aRecoTrack.residuals());
     //TrackingRecHits
     for( trackingRecHit_iterator hit = aRecoTrack.recHitsBegin(); hit != aRecoTrack.recHitsEnd(); ++ hit ) {
       recoHits->push_back( (*hit)->clone() );
       tx.add( TrackingRecHitRef( rHits , recoHits->size() - 1) );
     }
     
     // Save the quality if requested
     if (promoteQuality) recoTracks->back().setQuality(qualityToSet);
     if ( trackAlgo ) recoTracks->back().setAlgorithm(algo);
     
       }
       
       
       // All extras are to be copied too -> loop on the Trajectory/Track map association 
     } else { 
       
       edm:: Handle<std::vector<Trajectory> > theTrajectoryCollection;
       edm::Handle<TrajTrackAssociationCollection> theAssoMap;  
 
       // Count the number of hits and reserve appropriate memory
       unsigned nRecoHits = 0;
       for ( ; aTrack!=lastTrack; ++aTrack ) nRecoHits+= aTrack->recHitsSize();
       recoHits->reserve(nRecoHits); // This is to save some time at push_back.
       
       e.getByToken(trajectoryTokens[aProducer],theTrajectoryCollection);
       e.getByToken(assoMapTokens[aProducer],theAssoMap);
       
       // The track collection iterators.
       TrajTrackAssociationCollection::const_iterator anAssociation;  
       TrajTrackAssociationCollection::const_iterator lastAssociation;
       anAssociation = theAssoMap->begin();
       lastAssociation = theAssoMap->end();
 #ifdef FAMOS_DEBUG
       std::cout << "List of tracks to be copied " << std::endl;
 #endif
       // Build the map of correspondance between reco tracks and sim tracks
       for ( ; anAssociation != lastAssociation; ++anAssociation ) { 
     edm::Ref<std::vector<Trajectory> > aTrajectoryRef = anAssociation->key;
     reco::TrackRef aTrackRef = anAssociation->val;
     // Find the track id
     int recoTrackId = findId(*aTrackRef);
     if ( recoTrackId < 0 ) continue;
         
     // Ignore tracks to be removed or tracks already copied
     std::set<unsigned>::iterator iR = removeTracks.find((unsigned)recoTrackId);
 #ifdef FAMOS_DEBUG
     if( iR != removeTracks.end() ) std::cout << recoTrackId << "(REMOVED) ";
 #endif
     if( iR != removeTracks.end() ) continue;
     
     // Ignore tracks already copied
     std::set<unsigned>::iterator iA = alreadyAddedTracks.find((unsigned)recoTrackId);
 #ifdef FAMOS_DEBUG
     if( iA != alreadyAddedTracks.end() ) std::cout << recoTrackId << "(ALREADY ADDED) ";
 #endif
     if( iA != alreadyAddedTracks.end() ) continue;
     
 #ifdef FAMOS_DEBUG
     std::cout << recoTrackId << " Newly Added " << std::endl;
 #endif
     //if it is not there then add it! 
     alreadyAddedTracks.insert(recoTrackId);
     
     // Ignore tracks with too small a pT
     if ( aTrackRef->innerMomentum().Perp2() < pTMin2 ) continue;
     
     // Ignore tracks with too few hits
     if ( aTrackRef->recHitsSize() < minHits ) continue;
     
     //==== add more cuts on the trajectory (emulate the Trajectory Filter) 
 
 #ifdef FAMOS_DEBUG
     if(aTrajectoryRef->lostHits() > theMaxLostHits )
       std::cout << "\tmaxLostHits= " << aTrajectoryRef->lostHits() << "\tCUT =" << theMaxLostHits << std::endl;
 #endif
 
     if((unsigned)aTrajectoryRef->lostHits() > theMaxLostHits ) continue;
 
 #ifdef FAMOS_DEBUG
     if(aTrajectoryRef->foundHits() < theMinimumNumberOfHits )
       std::cout << "\tMinimumNumberOfHits = " <<  aTrajectoryRef->foundHits() << "\tCUT = " <<theMinimumNumberOfHits <<  std::endl;
 #endif
     
     if((unsigned)aTrajectoryRef->foundHits() < theMinimumNumberOfHits ) continue;
     //calculate the consecutive Lost Hits
     unsigned consecLostHits = 0;
     const std::vector<TrajectoryMeasurement> tms = aTrajectoryRef->measurements();
     for(int itm= tms.size();itm!=0; --itm){
       if(tms[itm-1].recHit()->isValid())break;
       else if (Trajectory::lost(*tms[itm-1].recHit())) consecLostHits++;
     }
 
 #ifdef FAMOS_DEBUG
     if( consecLostHits > theMaxConsecutiveLostHits ) 
       std::cout << "\tconsecLostHits = " << consecLostHits << std::endl;
 #endif
 
     if( consecLostHits > theMaxConsecutiveLostHits ) continue;
 
 
     //=============end new filters
 
 
     // A copy of the track
     reco::Track aRecoTrack(*aTrackRef);
     recoTracks->push_back(aRecoTrack);      
     // Save the quality if requested
     if (promoteQuality) recoTracks->back().setQuality(qualityToSet);    
     if ( trackAlgo ) recoTracks->back().setAlgorithm(algo);
     
      
     // A copy of the hits
     unsigned nh = aRecoTrack.recHitsSize();
     for ( unsigned ih=0; ih<nh; ++ih ) {
       TrackingRecHit *hit = aRecoTrack.recHit(ih)->clone();
       recoHits->push_back(hit);
     }
     
     // A copy of the trajectories
     recoTrajectories->push_back(*aTrajectoryRef);
     
       }
 #ifdef FAMOS_DEBUG
       std::cout << std::endl;
 #endif
     }
 }
     
     // Save the track candidates in the event
 #ifdef FAMOS_DEBUG
   std::cout << "Saving " 
         << recoTracks->size() << " reco::Tracks " << std::endl;
 
 #endif
   
   if ( tracksOnly ) { 
     // Save only the tracks (with transient reference to track extras)
     e.put(recoTracks);
     e.put(recoTrackExtras);
     e.put(recoHits);
 
 
   } else { 
     // Save the tracking recHits
     edm::OrphanHandle <TrackingRecHitCollection> theRecoHits = e.put(recoHits );
     
     // Create the track extras and add the references to the rechits
     unsigned hits=0;
     unsigned nTracks = recoTracks->size();
     recoTrackExtras->reserve(nTracks); // To save some time at push_back
     for ( unsigned index = 0; index < nTracks; ++index ) { 
 
       //reco::TrackExtra aTrackExtra;
       reco::Track& aTrack = recoTracks->at(index);
 
       // std::cout << "initial TrackAlgo = " << trackAlgo << "\tNAME " << aTrack.algoName() << "\tnumber = " << aTrack.algo() << std::endl;
 
       reco::TrackExtra aTrackExtra(aTrack.outerPosition(),
                    aTrack.outerMomentum(),
                    aTrack.outerOk(),
                    aTrack.innerPosition(),
                    aTrack.innerMomentum(),
                    aTrack.innerOk(),
                    aTrack.outerStateCovariance(),
                    aTrack.outerDetId(),
                    aTrack.innerStateCovariance(),
                    aTrack.innerDetId(),
                    aTrack.seedDirection(),
                    aTrack.seedRef());
       
       unsigned nHits = aTrack.recHitsSize();
       for ( unsigned int ih=0; ih<nHits; ++ih) {
     aTrackExtra.add(TrackingRecHitRef(theRecoHits,hits++));
       }
       recoTrackExtras->push_back(aTrackExtra);
     }
     
     // Save the track extras
     edm::OrphanHandle<reco::TrackExtraCollection> theRecoTrackExtras = e.put(recoTrackExtras);
     
     // Add the reference to the track extra in the tracks
     for ( unsigned index = 0; index<nTracks; ++index ) { 
       const reco::TrackExtraRef theTrackExtraRef(theRecoTrackExtras,index);
       (recoTracks->at(index)).setExtra(theTrackExtraRef);
     }
     
     // Save the tracks
     edm::OrphanHandle<reco::TrackCollection> theRecoTracks = e.put(recoTracks);
     
     // Save the trajectories
     edm::OrphanHandle<std::vector<Trajectory> > theRecoTrajectories = e.put(recoTrajectories);
     
     // Create and set the trajectory/track association map 
     for ( unsigned index = 0; index<nTracks; ++index ) { 
       edm::Ref<std::vector<Trajectory> > trajRef( theRecoTrajectories, index );
       edm::Ref<reco::TrackCollection>    tkRef( theRecoTracks, index );
       recoTrajTrackMap->insert(trajRef,tkRef);
     }
     
     // Save the association map.
     e.put(recoTrajTrackMap);
     
   }
 
 }