Inheritance diagram for DuplicateListMerger:

Classes
struct	ThreeTokens
	track input collection More...

Public Types
typedef std::pair < TrackCandidate, std::pair < reco::TrackRef, reco::TrackRef > >	DuplicateRecord
	typedef container of candidate and input tracks More...

typedef edm::OwnVector < TrackingRecHit >	RecHitContainer

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 Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

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

Public Member Functions
	DuplicateListMerger (const edm::ParameterSet &iPara)
	constructor More...

virtual	~DuplicateListMerger ()
	destructor More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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
std::vector< ConsumesInfo >	consumesInfo () const

	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

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
	produce one event More...

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)

Private Member Functions
edm::ProductID	clusterProductB (const TrackingRecHit *hit)

int	matchCandidateToTrack (TrackCandidate, edm::Handle< reco::TrackCollection >)

ThreeTokens	threeTokens (const edm::InputTag &tag)

Private Attributes
edm::EDGetTokenT< edm::View < DuplicateRecord > >	candidateSource_

bool	copyExtras_

unsigned int	diffHitsCut_

bool	makeReKeyedSeeds_

edm::InputTag	mergedMVAVals_

edm::EDGetTokenT < edm::ValueMap< float > >	mergedMVAValsToken_

ThreeTokens	mergedTrackSource_

float	minTrkProbCut_

edm::InputTag	originalMVAVals_

edm::EDGetTokenT < edm::ValueMap< float > >	originalMVAValsToken_

ThreeTokens	originalTrackSource_

reco::TrackBase::TrackQuality	qualityToSet_

Additional Inherited Members
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

merges list of merge duplicate tracks with its parent list

Author: Matthew Walker

Definition at line 39 of file DuplicateListMerger.cc.

Member Typedef Documentation

typedef std::pair<TrackCandidate,std::pair<reco::TrackRef,reco::TrackRef> > DuplicateListMerger::DuplicateRecord

typedef container of candidate and input tracks

Definition at line 47 of file DuplicateListMerger.cc.

typedef edm::OwnVector<TrackingRecHit> DuplicateListMerger::RecHitContainer

Definition at line 48 of file DuplicateListMerger.cc.

Constructor & Destructor Documentation

DuplicateListMerger::DuplicateListMerger ( const edm::ParameterSet & iPara )

explicit

constructor

Definition at line 99 of file DuplicateListMerger.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HLT_25ns14e33_v1_cff::InputTag, reco::TrackBase::qualityByName(), AlCaHLTBitMon_QueryRunRegistry::string, and reco::TrackBase::undefQuality.

 {
   diffHitsCut_ = 9999;
   minTrkProbCut_ = 0.0;
   if(iPara.exists("diffHitsCut"))diffHitsCut_ = iPara.getParameter<int>("diffHitsCut");
   if(iPara.exists("minTrkProbCut"))minTrkProbCut_ = iPara.getParameter<double>("minTrkProbCut");
   if(iPara.exists("mergedSource")) mergedTrackSource_ = threeTokens(iPara.getParameter<edm::InputTag>("mergedSource"));
   if(iPara.exists("originalSource"))originalTrackSource_ = threeTokens(iPara.getParameter<edm::InputTag>("originalSource"));
   if(iPara.exists("candidateSource"))candidateSource_ = consumes<edm::View<DuplicateRecord> >(iPara.getParameter<edm::InputTag>("candidateSource"));
 
 
   if(iPara.exists("mergedMVAVals")){
     mergedMVAVals_ = iPara.getParameter<edm::InputTag>("mergedMVAVals");
   }else{
     mergedMVAVals_ = edm::InputTag(mergedTrackSource_.tag.label(),"MVAVals");
   }
   mergedMVAValsToken_ = consumes<edm::ValueMap<float> >(mergedMVAVals_);
   if(iPara.exists("originalMVAVals")){
     originalMVAVals_ = iPara.getParameter<edm::InputTag>("originalMVAVals");
   }else{
     originalMVAVals_ = edm::InputTag(originalTrackSource_.tag.label(),"MVAVals");
   }
   originalMVAValsToken_ = consumes<edm::ValueMap<float> >(originalMVAVals_);
 
   copyExtras_ = iPara.getUntrackedParameter<bool>("copyExtras",true);
   qualityToSet_ = reco::TrackBase::undefQuality;
   if (iPara.exists("newQuality")) {
     std::string qualityStr = iPara.getParameter<std::string>("newQuality");
     if (qualityStr != "") {
       qualityToSet_ = reco::TrackBase::qualityByName(qualityStr);
     }
   }
 
   produces<std::vector<reco::Track> >();
   produces< std::vector<Trajectory> >();
   produces< TrajTrackAssociationCollection >();
 
   produces<edm::ValueMap<float> >("MVAVals");
 
   makeReKeyedSeeds_ = iPara.getUntrackedParameter<bool>("makeReKeyedSeeds",false);
   if (makeReKeyedSeeds_){
     copyExtras_=true;
     produces<TrajectorySeedCollection>();
   }
   if(copyExtras_){
     produces<reco::TrackExtraCollection>();
     produces<TrackingRecHitCollection>();
   }
 
 }

DuplicateListMerger::~DuplicateListMerger ( )

virtual

destructor

Definition at line 150 of file DuplicateListMerger.cc.

 {
 
   /* no op */
 
 }

Member Function Documentation

edm::ProductID DuplicateListMerger::clusterProductB ( const TrackingRecHit * hit )

inlineprivate

Definition at line 56 of file DuplicateListMerger.cc.

                                                              {
        return reinterpret_cast<const BaseTrackerRecHit *>(hit)->firstClusterRef().id();
      }

int DuplicateListMerger::matchCandidateToTrack	(	TrackCandidate	candidate,
		edm::Handle< reco::TrackCollection >	tracks
	)

private

Definition at line 490 of file DuplicateListMerger.cc.

References spr::find(), i, match(), TrackCandidate::recHits(), and TrackCandidate::seedRef().

                                                                                                               {
   int track = -1;
   std::vector<int> rawIds;
   RecHitContainer::const_iterator candBegin = candidate.recHits().first;
   RecHitContainer::const_iterator candEnd = candidate.recHits().second;
   for(; candBegin != candEnd; candBegin++){
     rawIds.push_back((*(candBegin)).rawId());
   }
  
 
   for(int i = 0; i < (int)tracks->size() && track < 0;i++){
     if( (*tracks)[i].seedRef() != candidate.seedRef())continue;
     int match = 0;
     trackingRecHit_iterator trackRecBegin = (*tracks)[i].recHitsBegin();
     trackingRecHit_iterator trackRecEnd = (*tracks)[i].recHitsEnd();
     for(;trackRecBegin != trackRecEnd; trackRecBegin++){
       if(std::find(rawIds.begin(),rawIds.end(),(*(trackRecBegin))->rawId()) != rawIds.end()) match++;
     }
     if(match != (int)( (*tracks)[i].recHitsSize() ) ) continue;
     track = i;
   }
 
   return track;
 }

void DuplicateListMerger::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprotectedvirtual

produce one event

Implements edm::stream::EDProducerBase.

Definition at line 157 of file DuplicateListMerger.cc.

References a, reco::TrackBase::algo(), b, edm::OwnVector< T, P >::back(), reco::TrackBase::charge(), reco::TrackBase::chi2(), ChiSquaredProbability(), edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, TrajectorySeed::direction(), edm::helper::Filler< Map >::fill(), edm::Ref< C, T, F >::get(), edm::Event::getByLabel(), edm::Event::getByToken(), edm::Event::getProvenance(), edm::Event::getRefBeforePut(), i, edm::RefProd< T >::id(), reco::Track::innerDetId(), reco::Track::innerMomentum(), reco::Track::innerOk(), reco::Track::innerPosition(), reco::Track::innerStateCovariance(), HLT_25ns14e33_v1_cff::InputTag, edm::helper::Filler< Map >::insert(), edm::Ref< C, T, F >::isNonnull(), j, match(), min(), edm::Provenance::moduleLabel(), reco::TrackBase::momentum(), reco::TrackBase::ndof(), TrajectorySeed::nHits(), reco::TrackBase::normalizedChi2(), reco::Track::outerDetId(), reco::Track::outerMomentum(), reco::Track::outerOk(), reco::Track::outerPosition(), reco::Track::outerStateCovariance(), edm::Provenance::processName(), edm::Provenance::productInstanceName(), edm::OwnVector< T, P >::push_back(), edm::Event::put(), reco::TrackBase::qualityMask(), reco::Track::recHit(), TrajectorySeed::recHits(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), reco::Track::recHitsSize(), reco::TrackBase::referencePoint(), ClusterRemovalRefSetter::reKey(), edm::OwnVector< T, P >::reserve(), reco::Track::residuals(), reco::Track::seedDirection(), reco::Track::seedRef(), reco::TrackExtraBase::setHits(), reco::TrackExtra::setResiduals(), TrajectorySeed::startingState(), and trackAlgoPriorityOrder.

 {
   edm::Handle<reco::TrackCollection > originalHandle;
   iEvent.getByToken(originalTrackSource_.tk,originalHandle);
   edm::Handle<reco::TrackCollection > mergedHandle;
   iEvent.getByToken(mergedTrackSource_.tk,mergedHandle);
 
   const reco::TrackCollection& mergedTracks(*mergedHandle);
   reco::TrackRefProd originalTrackRefs(originalHandle);
   reco::TrackRefProd mergedTrackRefs(mergedHandle);
 
   edm::Handle< std::vector<Trajectory> >  mergedTrajHandle;
   iEvent.getByToken(mergedTrackSource_.traj,mergedTrajHandle);
   edm::Handle< TrajTrackAssociationCollection >  mergedTrajTrackHandle;
   iEvent.getByToken(mergedTrackSource_.tass,mergedTrajTrackHandle);
 
   edm::Handle< std::vector<Trajectory> >  originalTrajHandle;
   iEvent.getByToken(originalTrackSource_.traj,originalTrajHandle);
   edm::Handle< TrajTrackAssociationCollection >  originalTrajTrackHandle;
   iEvent.getByToken(originalTrackSource_.tass,originalTrajTrackHandle);
 
   edm::Handle<edm::View<DuplicateRecord> > candidateHandle;
   iEvent.getByToken(candidateSource_,candidateHandle);
 
   std::auto_ptr<std::vector<reco::Track> > out_generalTracks(new std::vector<reco::Track>());
   out_generalTracks->reserve(originalHandle->size());
   reco::TrackRefProd refTrks = iEvent.getRefBeforePut<reco::TrackCollection>();
   std::auto_ptr< std::vector<Trajectory> > outputTrajs = std::auto_ptr< std::vector<Trajectory> >(new std::vector<Trajectory>());
   outputTrajs->reserve(originalTrajHandle->size()+mergedTrajHandle->size());
   edm::RefProd< std::vector<Trajectory> > refTrajs;
   //std::auto_ptr< TrajectorySeedCollection > outputSeeds
 
   std::auto_ptr<reco::TrackExtraCollection> outputTrkExtras;
   reco::TrackExtraRefProd refTrkExtras;
   std::auto_ptr<TrackingRecHitCollection> outputTrkHits;
   TrackingRecHitRefProd refTrkHits;
   std::auto_ptr<TrajectorySeedCollection> outputSeeds;
   edm::RefProd< TrajectorySeedCollection > refTrajSeeds;
 
   edm::Handle<edm::ValueMap<float> > originalMVAStore;
   edm::Handle<edm::ValueMap<float> > mergedMVAStore;
 
   iEvent.getByToken(originalMVAValsToken_,originalMVAStore);
   iEvent.getByToken(mergedMVAValsToken_,mergedMVAStore);
 
   std::auto_ptr<edm::ValueMap<float> > vmMVA(new edm::ValueMap<float>);
   edm::ValueMap<float>::Filler fillerMVA(*vmMVA);
   std::vector<float> mvaVec;
 
 
   if(copyExtras_){
     outputTrkExtras = std::auto_ptr<reco::TrackExtraCollection>(new reco::TrackExtraCollection);
     outputTrkExtras->reserve(originalHandle->size());
     refTrkExtras    = iEvent.getRefBeforePut<reco::TrackExtraCollection>();
     outputTrkHits   = std::auto_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection);
     outputTrkHits->reserve(originalHandle->size()*25);
     refTrkHits      = iEvent.getRefBeforePut<TrackingRecHitCollection>();
     if (makeReKeyedSeeds_){
       outputSeeds = std::auto_ptr<TrajectorySeedCollection>(new TrajectorySeedCollection);
       outputSeeds->reserve(originalHandle->size());
       refTrajSeeds = iEvent.getRefBeforePut<TrajectorySeedCollection>();
     }
   }
 
   //match new tracks to their candidates
   std::vector<std::pair<int,const DuplicateRecord*> > matches;
   for(int i = 0; i < (int)candidateHandle->size(); i++){
     const DuplicateRecord& duplicateRecord = candidateHandle->at(i);
     int matchTrack = matchCandidateToTrack(duplicateRecord.first,mergedHandle);
     if(matchTrack < 0)continue;
     const reco::Track& matchedTrack(mergedTracks[matchTrack]);
     if( ChiSquaredProbability(matchedTrack.chi2(),matchedTrack.ndof()) < minTrkProbCut_)continue;
     unsigned int dHits = (duplicateRecord.first.recHits().second - duplicateRecord.first.recHits().first) - matchedTrack.recHitsSize();
     if(dHits > diffHitsCut_)continue;
     matches.push_back(std::pair<int,const DuplicateRecord*>(matchTrack,&duplicateRecord));
   }
 
   //check for candidates/tracks that share merged tracks, select minimum chi2, remove the rest
   std::vector<std::pair<int,const DuplicateRecord*> >::iterator matchIter0 = matches.begin();
   std::vector<std::pair<int,const DuplicateRecord*> >::iterator matchIter1;
   while(matchIter0 != matches.end()){
     double nchi2 = mergedTracks[matchIter0->first].normalizedChi2();
     bool advance = true;
     for(matchIter1 = matchIter0+1; matchIter1 != matches.end(); matchIter1++){
       const reco::Track& match0first = *(matchIter0->second->second.first.get());
       const reco::Track& match0second = *(matchIter0->second->second.second.get());
       const reco::Track& match1first = *(matchIter1->second->second.first.get());
       const reco::Track& match1second = *(matchIter1->second->second.second.get());
       if(match1first.seedRef() == match0first.seedRef() ||
      match1first.seedRef() == match0second.seedRef() || 
      match1second.seedRef() == match0first.seedRef() || 
      match1second.seedRef() == match0second.seedRef()){
     double nchi2_1 = mergedTracks[matchIter1->first].normalizedChi2();
     advance = false;
     if(nchi2_1 < nchi2){
       matches.erase(matchIter0);
     }else{
       matches.erase(matchIter1);
     }
     break;
       }
     }
     if(advance)matchIter0++;
   }
 
   //add the good merged tracks to the output list, remove input tracks
   std::vector<reco::Track> inputTracks;
 
   refTrajs = iEvent.getRefBeforePut< std::vector<Trajectory> >();
 
   std::auto_ptr< TrajTrackAssociationCollection >  outputTTAss = std::auto_ptr< TrajTrackAssociationCollection >(new TrajTrackAssociationCollection());
 
   for(matchIter0 = matches.begin(); matchIter0 != matches.end(); matchIter0++){
     reco::TrackRef inTrkRef1 = matchIter0->second->second.first;
     reco::TrackRef inTrkRef2 = matchIter0->second->second.second;
     const reco::Track& inTrk1 = *(inTrkRef1.get());
     const reco::Track& inTrk2 = *(inTrkRef2.get());
     reco::TrackBase::TrackAlgorithm newTrkAlgo = std::min(inTrk1.algo(),inTrk2.algo(),
                                                           [](reco::TrackBase::TrackAlgorithm a, reco::TrackBase::TrackAlgorithm b) {
                                                             return trackAlgoPriorityOrder[a] < trackAlgoPriorityOrder[b];
                                                           });
     int combinedQualityMask = (inTrk1.qualityMask() | inTrk2.qualityMask());
     inputTracks.push_back(inTrk1);
     inputTracks.push_back(inTrk2);
     out_generalTracks->push_back(mergedTracks[matchIter0->first]);
     reco::TrackRef curTrackRef = reco::TrackRef(refTrks, out_generalTracks->size() - 1);
     float mergedMVA = (*mergedMVAStore)[reco::TrackRef(mergedTrackRefs,matchIter0->first)];
     mvaVec.push_back(mergedMVA);
     out_generalTracks->back().setAlgorithm(newTrkAlgo);
     out_generalTracks->back().setQualityMask(combinedQualityMask);
     out_generalTracks->back().setQuality(qualityToSet_);
     edm::RefToBase<TrajectorySeed> origSeedRef;
     if(copyExtras_){
       const reco::Track& track = mergedTracks[matchIter0->first];
       origSeedRef = track.seedRef();
       //creating a seed with rekeyed clusters if required
       if (makeReKeyedSeeds_){
     bool doRekeyOnThisSeed=false;
     
     edm::InputTag clusterRemovalInfos("");
     //grab on of the hits of the seed
     if (origSeedRef->nHits()!=0){
       TrajectorySeed::const_iterator firstHit=origSeedRef->recHits().first;
       const TrackingRecHit *hit = &*firstHit;
       if (firstHit->isValid()){
         edm::ProductID  pID=clusterProductB(hit);
         // the cluster collection either produced a removalInfo or mot
         //get the clusterremoval info from the provenance: will rekey if this is found
         edm::Handle<reco::ClusterRemovalInfo> CRIh;
         edm::Provenance prov=iEvent.getProvenance(pID);
         clusterRemovalInfos=edm::InputTag(prov.moduleLabel(),
                           prov.productInstanceName(),
                           prov.processName());
         doRekeyOnThisSeed=iEvent.getByLabel(clusterRemovalInfos,CRIh);
       }//valid hit
     }//nhit!=0
     
     if (doRekeyOnThisSeed && !(clusterRemovalInfos==edm::InputTag(""))) {
       ClusterRemovalRefSetter refSetter(iEvent,clusterRemovalInfos);
       TrajectorySeed::recHitContainer  newRecHitContainer;
       newRecHitContainer.reserve(origSeedRef->nHits());
       TrajectorySeed::const_iterator iH=origSeedRef->recHits().first;
       TrajectorySeed::const_iterator iH_end=origSeedRef->recHits().second;
       for (;iH!=iH_end;++iH){
         newRecHitContainer.push_back(*iH);
         refSetter.reKey(&newRecHitContainer.back());
       }
       outputSeeds->push_back( TrajectorySeed( origSeedRef->startingState(),
                           newRecHitContainer,
                           origSeedRef->direction()));
     }
     //doRekeyOnThisSeed=true
     else{
       //just copy the one we had before
       outputSeeds->push_back( TrajectorySeed(*origSeedRef));
       }
     edm::Ref<TrajectorySeedCollection> pureRef(refTrajSeeds, outputSeeds->size()-1);
     origSeedRef=edm::RefToBase<TrajectorySeed>( pureRef);
       }//creating a new seed and rekeying it rechit clusters.
       // Fill TrackExtra collection
       outputTrkExtras->push_back( reco::TrackExtra( 
                            track.outerPosition(), track.outerMomentum(), track.outerOk(),
                            track.innerPosition(), track.innerMomentum(), track.innerOk(),
                            track.outerStateCovariance(), track.outerDetId(),
                            track.innerStateCovariance(), track.innerDetId(),
                            track.seedDirection(), origSeedRef ) );
       out_generalTracks->back().setExtra( reco::TrackExtraRef( refTrkExtras, outputTrkExtras->size() - 1) );
       reco::TrackExtra & tx = outputTrkExtras->back();
       tx.setResiduals(track.residuals());
       // fill TrackingRecHits
       unsigned nh1=track.recHitsSize();
       auto const firstTrackIndex = outputTrkHits->size();
       for ( unsigned ih=0; ih<nh1; ++ih ) { 
       //const TrackingRecHit*hit=&((*(track->recHit(ih))));
     outputTrkHits->push_back( track.recHit(ih)->clone() );
       }
       tx.setHits(  refTrkHits, firstTrackIndex, outputTrkHits->size() - firstTrackIndex );
     }
     edm::Ref< std::vector<Trajectory> > trajRef(mergedTrajHandle, (*matchIter0).first);
     TrajTrackAssociationCollection::const_iterator match = mergedTrajTrackHandle->find(trajRef);
     if (match != mergedTrajTrackHandle->end()) {
     if(curTrackRef.isNonnull()){
       outputTrajs->push_back( *trajRef );
       if (copyExtras_ && makeReKeyedSeeds_)
         outputTrajs->back().setSeedRef( origSeedRef );
       outputTTAss->insert(edm::Ref< std::vector<Trajectory> >(refTrajs, outputTrajs->size() - 1),curTrackRef );
     }
     }
   }
 
   for(int i = 0; i < (int)originalHandle->size(); i++){
     bool good = true;
     const reco::Track& origTrack = originalHandle->at(i);
     for(int j = 0; j < (int)inputTracks.size() && good; j++){
       const reco::Track& inputTrack = inputTracks[j];
       if(origTrack.seedRef() != inputTrack.seedRef())continue;
       if(origTrack.charge() != inputTrack.charge())continue;
       if(origTrack.momentum() != inputTrack.momentum())continue;
       if(origTrack.referencePoint() != inputTrack.referencePoint())continue;
       good = false;
     }
 
     if(good){
       out_generalTracks->push_back(origTrack);
       reco::TrackRef curTrackRef = reco::TrackRef(refTrks, out_generalTracks->size() - 1);
       edm::RefToBase<TrajectorySeed> origSeedRef;
       reco::TrackRef origTrackRef = reco::TrackRef(originalHandle,i);
       mvaVec.push_back((*originalMVAStore)[origTrackRef]);
       //mvaVec.push_back((*originalMVAStore)[reco::TrackRef(originalTrackRefs,i)]);
       if(copyExtras_){
     const reco::Track& track = origTrack;
     origSeedRef = track.seedRef();
     //creating a seed with rekeyed clusters if required
     if (makeReKeyedSeeds_){
       bool doRekeyOnThisSeed=false;
       
       edm::InputTag clusterRemovalInfos("");
       //grab on of the hits of the seed
       if (origSeedRef->nHits()!=0){
         TrajectorySeed::const_iterator firstHit=origSeedRef->recHits().first;
         const TrackingRecHit *hit = &*firstHit;
         if (firstHit->isValid()){
           edm::ProductID  pID=clusterProductB(hit);
           // the cluster collection either produced a removalInfo or mot
           //get the clusterremoval info from the provenance: will rekey if this is found
           edm::Handle<reco::ClusterRemovalInfo> CRIh;
           edm::Provenance prov=iEvent.getProvenance(pID);
           clusterRemovalInfos=edm::InputTag(prov.moduleLabel(),
                         prov.productInstanceName(),
                         prov.processName());
           doRekeyOnThisSeed=iEvent.getByLabel(clusterRemovalInfos,CRIh);
         }//valid hit
       }//nhit!=0
       
       if (doRekeyOnThisSeed && !(clusterRemovalInfos==edm::InputTag(""))) {
         ClusterRemovalRefSetter refSetter(iEvent,clusterRemovalInfos);
         TrajectorySeed::recHitContainer  newRecHitContainer;
         newRecHitContainer.reserve(origSeedRef->nHits());
         TrajectorySeed::const_iterator iH=origSeedRef->recHits().first;
         TrajectorySeed::const_iterator iH_end=origSeedRef->recHits().second;
         for (;iH!=iH_end;++iH){
           newRecHitContainer.push_back(*iH);
           refSetter.reKey(&newRecHitContainer.back());
         }
         outputSeeds->push_back( TrajectorySeed( origSeedRef->startingState(),
                             newRecHitContainer,
                             origSeedRef->direction()));
       }
       //doRekeyOnThisSeed=true
       else{
         //just copy the one we had before
         outputSeeds->push_back( TrajectorySeed(*origSeedRef));
       }
       edm::Ref<TrajectorySeedCollection> pureRef(refTrajSeeds, outputSeeds->size()-1);
       origSeedRef=edm::RefToBase<TrajectorySeed>( pureRef);
     }//creating a new seed and rekeying it rechit clusters.
     
     // Fill TrackExtra collection
     outputTrkExtras->push_back( reco::TrackExtra( 
                              track.outerPosition(), track.outerMomentum(), track.outerOk(),
                              track.innerPosition(), track.innerMomentum(), track.innerOk(),
                              track.outerStateCovariance(), track.outerDetId(),
                              track.innerStateCovariance(), track.innerDetId(),
                              track.seedDirection(), origSeedRef ) );
     out_generalTracks->back().setExtra( reco::TrackExtraRef( refTrkExtras, outputTrkExtras->size() - 1) );
     reco::TrackExtra & tx = outputTrkExtras->back();
     tx.setResiduals(track.residuals());
     
     // fill TrackingRecHits
     unsigned nh1=track.recHitsSize();
         tx.setHits(refTrkHits,outputTrkHits->size(),nh1);
     for (auto hh = track.recHitsBegin(), eh=track.recHitsEnd(); hh!=eh; ++hh ) { 
       outputTrkHits->push_back( (*hh)->clone() );
     }
     
       }
 
       edm::Ref< std::vector<Trajectory> > trajRef(originalTrajHandle, i);
       TrajTrackAssociationCollection::const_iterator match = originalTrajTrackHandle->find(trajRef);
       if (match != originalTrajTrackHandle->end()) {
     if(curTrackRef.isNonnull()){
       outputTrajs->push_back( *trajRef );
       if (copyExtras_ && makeReKeyedSeeds_)
         outputTrajs->back().setSeedRef( origSeedRef );
       outputTTAss->insert(edm::Ref< std::vector<Trajectory> >(refTrajs, outputTrajs->size() - 1),curTrackRef );
     }
       }
     }
   }
 
   edm::ProductID nPID = refTrks.id();
   edm::TestHandle<TrackCollection> out_gtHandle(out_generalTracks.get(),nPID);
 
   fillerMVA.insert(out_gtHandle,mvaVec.begin(),mvaVec.end());
   fillerMVA.fill();
   iEvent.put(vmMVA,"MVAVals");
 
   out_generalTracks->shrink_to_fit();  iEvent.put(out_generalTracks);
   if (copyExtras_) {
     outputTrkExtras->shrink_to_fit(); iEvent.put(outputTrkExtras);
     outputTrkHits->shrink_to_fit(); iEvent.put(outputTrkHits);
     if (makeReKeyedSeeds_) {
       outputSeeds->shrink_to_fit(); iEvent.put(outputSeeds);
     }
   }
   outputTrajs->shrink_to_fit(); iEvent.put(outputTrajs);
   iEvent.put(outputTTAss);
 }

ThreeTokens DuplicateListMerger::threeTokens ( const edm::InputTag & tag )

inlineprivate

Definition at line 70 of file DuplicateListMerger.cc.

                                                          {
             return ThreeTokens(tag, consumes<reco::TrackCollection>(tag), consumes<std::vector<Trajectory> >(tag), consumes<TrajTrackAssociationCollection >(tag));
          }

Member Data Documentation

edm::EDGetTokenT<edm::View<DuplicateRecord> > DuplicateListMerger::candidateSource_

private

Definition at line 74 of file DuplicateListMerger.cc.

bool DuplicateListMerger::copyExtras_

private

Definition at line 84 of file DuplicateListMerger.cc.

unsigned int DuplicateListMerger::diffHitsCut_

private

Definition at line 82 of file DuplicateListMerger.cc.

bool DuplicateListMerger::makeReKeyedSeeds_

private

Definition at line 85 of file DuplicateListMerger.cc.

edm::InputTag DuplicateListMerger::mergedMVAVals_

private

Definition at line 77 of file DuplicateListMerger.cc.

edm::EDGetTokenT<edm::ValueMap<float> > DuplicateListMerger::mergedMVAValsToken_

private

Definition at line 79 of file DuplicateListMerger.cc.

ThreeTokens DuplicateListMerger::mergedTrackSource_

private

Definition at line 73 of file DuplicateListMerger.cc.

float DuplicateListMerger::minTrkProbCut_

private

Definition at line 83 of file DuplicateListMerger.cc.

edm::InputTag DuplicateListMerger::originalMVAVals_

private

Definition at line 76 of file DuplicateListMerger.cc.

edm::EDGetTokenT<edm::ValueMap<float> > DuplicateListMerger::originalMVAValsToken_

private

Definition at line 78 of file DuplicateListMerger.cc.

ThreeTokens DuplicateListMerger::originalTrackSource_

private

Definition at line 73 of file DuplicateListMerger.cc.

reco::TrackBase::TrackQuality DuplicateListMerger::qualityToSet_

private

Definition at line 81 of file DuplicateListMerger.cc.

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation