Inheritance diagram for TrackListMerger:

Classes
struct	TkEDGetTokenss

Public Member Functions
void	produce (edm::Event &e, const edm::EventSetup &c) override

	TrackListMerger (const edm::ParameterSet &conf)

	~TrackListMerger () override=default

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 Types
using	MVACollection = std::vector< float >

using	QualityMaskCollection = std::vector< unsigned char >

Private Member Functions
TkEDGetTokenss	edTokens (const edm::InputTag &tag, const edm::InputTag &seltag, const edm::InputTag &mvatag)

TkEDGetTokenss	edTokens (const edm::InputTag &tag, const edm::InputTag &mvatag)

void	returnEmptyCollections (edm::Event &e)

Private Attributes
bool	allowFirstHitShare_

bool	copyExtras_

bool	copyMVA_

float	epsilon_

float	foundHitBonus_

std::vector< int >	hasSelector_

std::vector< double >	indivShareFrac_

std::vector< std::vector< int > >	listsToMerge_

float	lostHitPenalty_

bool	makeReKeyedSeeds_

double	maxNormalizedChisq_

unsigned int	minFound_

double	minPT_

std::unique_ptr< TrajectorySeedCollection >	outputSeeds

std::unique_ptr< std::vector< Trajectory > >	outputTrajs

std::unique_ptr< reco::TrackExtraCollection >	outputTrkExtras

std::unique_ptr< TrackingRecHitCollection >	outputTrkHits

std::unique_ptr< reco::TrackCollection >	outputTrks

std::unique_ptr< TrajTrackAssociationCollection >	outputTTAss

std::string	priorityName_

edm::ESGetToken< TrackAlgoPriorityOrder, CkfComponentsRecord >	priorityToken

std::vector< bool >	promoteQuality_

reco::TrackBase::TrackQuality	qualityToSet_

edm::RefProd< std::vector< Trajectory > >	refTrajs

edm::RefProd< TrajectorySeedCollection >	refTrajSeeds

reco::TrackExtraRefProd	refTrkExtras

TrackingRecHitRefProd	refTrkHits

reco::TrackRefProd	refTrks

float	shareFrac_

std::vector< TkEDGetTokenss >	trackProducers_

bool	trkQualMod_

bool	use_sharesInput_

Additional Inherited Members
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

Detailed Description

Definition at line 32 of file TrackListMerger.cc.

Member Typedef Documentation

◆ MVACollection

using TrackListMerger::MVACollection = std::vector<float>

private

Definition at line 43 of file TrackListMerger.cc.

◆ QualityMaskCollection

using TrackListMerger::QualityMaskCollection = std::vector<unsigned char>

private

Definition at line 44 of file TrackListMerger.cc.

Constructor & Destructor Documentation

◆ TrackListMerger()

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

explicit

Definition at line 208 of file TrackListMerger.cc.

References allowFirstHitShare_, copyExtras_, copyMVA_, edTokens(), epsilon_, Exception, edm::ParameterSet::exists(), foundHitBonus_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hasSelector_, mps_fire::i, indivShareFrac_, createfilelist::int, label, listsToMerge_, lostHitPenalty_, makeReKeyedSeeds_, maxNormalizedChisq_, minFound_, minPT_, convertSQLiteXML::ok, priorityName_, priorityToken, promoteQuality_, reco::TrackBase::qualityByName(), qualityToSet_, TrackValidation_cff::selectors, sistrip_dqm_sourceclient-live_cfg::setsToMerge, shareFrac_, AlCaHLTBitMon_QueryRunRegistry::string, trackProducers_, trkQualMod_, reco::TrackBase::undefQuality, and use_sharesInput_.

                                                             {
   copyExtras_ = conf.getUntrackedParameter<bool>("copyExtras", true);
   priorityName_ = conf.getParameter<std::string>("trackAlgoPriorityOrder");
 
   std::vector<edm::InputTag> trackProducerTags(conf.getParameter<std::vector<edm::InputTag>>("TrackProducers"));
   //which of these do I need to turn into vectors?
   maxNormalizedChisq_ = conf.getParameter<double>("MaxNormalizedChisq");
   minPT_ = conf.getParameter<double>("MinPT");
   minFound_ = (unsigned int)conf.getParameter<int>("MinFound");
   epsilon_ = conf.getParameter<double>("Epsilon");
   shareFrac_ = conf.getParameter<double>("ShareFrac");
   allowFirstHitShare_ = conf.getParameter<bool>("allowFirstHitShare");
   foundHitBonus_ = conf.getParameter<double>("FoundHitBonus");
   lostHitPenalty_ = conf.getParameter<double>("LostHitPenalty");
   indivShareFrac_ = conf.getParameter<std::vector<double>>("indivShareFrac");
   std::string qualityStr = conf.getParameter<std::string>("newQuality");
   priorityToken = esConsumes<TrackAlgoPriorityOrder, CkfComponentsRecord>(edm::ESInputTag("", priorityName_));
 
   if (!qualityStr.empty()) {
     qualityToSet_ = reco::TrackBase::qualityByName(conf.getParameter<std::string>("newQuality"));
   } else
     qualityToSet_ = reco::TrackBase::undefQuality;
 
   use_sharesInput_ = true;
   if (epsilon_ > 0.0)
     use_sharesInput_ = false;
 
   edm::VParameterSet setsToMerge = conf.getParameter<edm::VParameterSet>("setsToMerge");
 
   for (unsigned int i = 0; i < setsToMerge.size(); i++) {
     listsToMerge_.push_back(setsToMerge[i].getParameter<std::vector<int>>("tLists"));
     promoteQuality_.push_back(setsToMerge[i].getParameter<bool>("pQual"));
   }
   hasSelector_ = conf.getParameter<std::vector<int>>("hasSelector");
   copyMVA_ = conf.getParameter<bool>("copyMVA");
 
   std::vector<edm::InputTag> selectors(conf.getParameter<std::vector<edm::InputTag>>("selectedTrackQuals"));
   std::vector<edm::InputTag> mvaStores;
   if (conf.exists("mvaValueTags")) {
     mvaStores = conf.getParameter<std::vector<edm::InputTag>>("mvaValueTags");
   } else {
     for (int i = 0; i < (int)selectors.size(); i++) {
       edm::InputTag ntag(selectors[i].label(), "MVAVals");
       mvaStores.push_back(ntag);
     }
   }
   unsigned int numTrkColl = trackProducerTags.size();
   if (numTrkColl != hasSelector_.size() || numTrkColl != selectors.size()) {
     throw cms::Exception("Inconsistent size") << "need same number of track collections and selectors";
   }
   if (numTrkColl != hasSelector_.size() || numTrkColl != mvaStores.size()) {
     throw cms::Exception("Inconsistent size") << "need same number of track collections and MVA stores";
   }
   for (unsigned int i = indivShareFrac_.size(); i < numTrkColl; i++) {
     //      edm::LogWarning("TrackListMerger") << "No indivShareFrac for " << trackProducersTags <<". Using default value of 1";
     indivShareFrac_.push_back(1.0);
   }
 
   trkQualMod_ = conf.getParameter<bool>("writeOnlyTrkQuals");
   if (trkQualMod_) {
     bool ok = true;
     for (unsigned int i = 1; i < numTrkColl; i++) {
       if (!(trackProducerTags[i] == trackProducerTags[0]))
         ok = false;
     }
     if (!ok) {
       throw cms::Exception("Bad input") << "to use writeOnlyTrkQuals=True all input InputTags must be the same";
     }
     produces<edm::ValueMap<int>>();
     produces<QualityMaskCollection>("QualityMasks");
   } else {
     makeReKeyedSeeds_ = conf.getUntrackedParameter<bool>("makeReKeyedSeeds", false);
     if (makeReKeyedSeeds_) {
       copyExtras_ = true;
       produces<TrajectorySeedCollection>();
     }
 
     if (copyExtras_) {
       produces<reco::TrackExtraCollection>();
       produces<TrackingRecHitCollection>();
     }
 
     // TrackCollection refers to TrackingRechit and TrackExtra
     // collections, need to declare its production after them to work
     // around a rare race condition in framework scheduling
     produces<reco::TrackCollection>();
 
     produces<std::vector<Trajectory>>();
     produces<TrajTrackAssociationCollection>();
   }
   produces<edm::ValueMap<float>>("MVAVals");
   produces<MVACollection>("MVAValues");
 
   // Do all the consumes
   trackProducers_.resize(numTrkColl);
   for (unsigned int i = 0; i < numTrkColl; ++i) {
     trackProducers_[i] = hasSelector_[i] > 0 ? edTokens(trackProducerTags[i], selectors[i], mvaStores[i])
                                              : edTokens(trackProducerTags[i], mvaStores[i]);
   }
 }

◆ ~TrackListMerger()

TrackListMerger::~TrackListMerger ( )

overridedefault

Member Function Documentation

◆ edTokens() [1/2]

TkEDGetTokenss TrackListMerger::edTokens	(	const edm::InputTag &	tag,
		const edm::InputTag &	seltag,
		const edm::InputTag &	mvatag
	)

inlineprivate

Definition at line 80 of file TrackListMerger.cc.

References makeGlobalPositionRcd_cfg::tag.

Referenced by TrackListMerger().

                                                                                                         {
     return TkEDGetTokenss(tag,
                           consumes<reco::TrackCollection>(tag),
                           consumes<std::vector<Trajectory>>(tag),
                           consumes<TrajTrackAssociationCollection>(tag),
                           consumes<edm::ValueMap<int>>(seltag),
                           consumes<edm::ValueMap<float>>(mvatag));
   }

◆ edTokens() [2/2]

TkEDGetTokenss TrackListMerger::edTokens	(	const edm::InputTag &	tag,
		const edm::InputTag &	mvatag
	)

inlineprivate

Definition at line 88 of file TrackListMerger.cc.

References makeGlobalPositionRcd_cfg::tag.

                                                                              {
     return TkEDGetTokenss(tag,
                           consumes<reco::TrackCollection>(tag),
                           consumes<std::vector<Trajectory>>(tag),
                           consumes<TrajTrackAssociationCollection>(tag),
                           edm::EDGetTokenT<edm::ValueMap<int>>(),
                           consumes<edm::ValueMap<float>>(mvatag));
   }

◆ produce()

void TrackListMerger::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Definition at line 310 of file TrackListMerger.cc.

References funct::abs(), allowFirstHitShare_, cms::cuda::assert(), edm::OwnVector< T, P >::back(), edm::Range< T >::begin(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), copyExtras_, copyMVA_, dumpMFGeometry_cfg::delta, TrajectorySeed::direction(), MillePedeFileConverter_cfg::e, edm::AssociationMap< Tag >::end(), mps_fire::end, HLT_2024v14_cff::eps, epsilon_, edm::HandleBase::failedToGet(), trigObjTnPSource_cfi::filler, spr::find(), edm::AssociationMap< Tag >::find(), dqmdumpme::first, nano_mu_digi_cff::float, foundHitBonus_, edm::EventSetup::getHandle(), hasSelector_, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::hh, reco::TrackBase::highPurity, mps_fire::i, edm::RefProd< C >::id(), edm::Ref< C, T, F >::id(), globals_cff::id1, globals_cff::id2, cuy::ii, indivShareFrac_, ProducerED_cfi::InputTag, sistrip::SpyUtilities::isValid(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, findQualityFiles::jj, edm::Ref< C, T, F >::key(), LIKELY, listsToMerge_, reco::TrackBase::loose, lostHitPenalty_, electrons_cff::lostHits, makeReKeyedSeeds_, match(), SiStripPI::max, maxNormalizedChisq_, SiStripPI::min, minFound_, minPT_, edm::StableProvenance::moduleLabel(), eostools::move(), dqmiodumpmetadata::n, TrajectorySeed::nHits(), outputSeeds, outputTrajs, outputTrkExtras, outputTrkHits, outputTrks, outputTTAss, priorityToken, edm::StableProvenance::processName(), edm::StableProvenance::productInstanceName(), promoteQuality_, edm::OwnVector< T, P >::push_back(), submitPVResolutionJobs::q, qualityToSet_, rpcPointValidation_cfi::recHit, TrajectorySeed::recHits(), reco::TrackExtraBase::recHitsSize(), refTrajs, refTrajSeeds, refTrkExtras, refTrkHits, refTrks, ClusterRemovalRefSetter::reKey(), edm::OwnVector< T, P >::reserve(), returnEmptyCollections(), offlineSlimmedPrimaryVertices_cfi::score, reco::TrackExtraBase::setHits(), reco::TrackExtra::setResiduals(), reco::TrackExtraBase::setTrajParams(), shareFrac_, TrackingRecHit::some, TrajectorySeed::startingState(), reco::TrackBase::tight, HLT_2024v14_cff::track, trackAlgoPriorityOrder, trackProducers_, reco::TrackExtraBase::trajParams(), trkQualMod_, reco::TrackBase::undefAlgorithm, UNLIKELY, and use_sharesInput_.

                                                                   {
   // extract tracker geometry
   //
   //edm::ESHandle<TrackerGeometry> theG;
   //es.get<TrackerDigiGeometryRecord>().get(theG);
 
   //    using namespace reco;
 
   edm::ESHandle<TrackAlgoPriorityOrder> priorityH = es.getHandle(priorityToken);
   auto const& trackAlgoPriorityOrder = *priorityH;
 
   // get Inputs
   // if 1 input list doesn't exist, make an empty list, issue a warning, and continue
   // this allows TrackListMerger to be used as a cleaner only if handed just one list
   // if both input lists don't exist, will issue 2 warnings and generate an empty output collection
   //
   static const reco::TrackCollection s_empty;
 
   std::vector<const reco::TrackCollection*> trackColls;
   std::vector<edm::Handle<reco::TrackCollection>> trackHandles(trackProducers_.size());
   for (unsigned int i = 0; i < trackProducers_.size(); i++) {
     trackColls.push_back(nullptr);
     //edm::Handle<reco::TrackCollection> trackColl;
     e.getByToken(trackProducers_[i].tk, trackHandles[i]);
     if (trackHandles[i].isValid()) {
       trackColls[i] = trackHandles[i].product();
     } else {
       edm::LogWarning("TrackListMerger") << "TrackCollection " << trackProducers_[i].tag << " not found";
       trackColls[i] = &s_empty;
     }
   }
 
   if (trackColls.empty()) {
     // output empty collections and early return
     this->returnEmptyCollections(e);
     return;
   }
 
   unsigned int collsSize = trackColls.size();
   unsigned int rSize = 0;
   unsigned int trackCollSizes[collsSize];
   unsigned int trackCollFirsts[collsSize];
   for (unsigned int i = 0; i != collsSize; i++) {
     trackCollSizes[i] = trackColls[i]->size();
     trackCollFirsts[i] = rSize;
     rSize += trackCollSizes[i];
   }
 
   if (rSize == 0) {
     // output empty collections and early return
     this->returnEmptyCollections(e);
     return;
   }
 
   statCount.begin(rSize);
 
   //
   //  quality cuts first
   //
   int i = -1;
 
   int selected[rSize];
   int indexG[rSize];
   bool trkUpdated[rSize];
   int trackCollNum[rSize];
   int trackQuals[rSize];
   float trackMVAs[rSize];
   reco::TrackBase::TrackAlgorithm oriAlgo[rSize];
   std::vector<reco::TrackBase::AlgoMask> algoMask(rSize);
   for (unsigned int j = 0; j < rSize; j++) {
     indexG[j] = -1;
     selected[j] = 1;
     trkUpdated[j] = false;
     trackCollNum[j] = 0;
     trackQuals[j] = 0;
     trackMVAs[j] = -998.0;
     oriAlgo[j] = reco::TrackBase::undefAlgorithm;
   }
 
   int ngood = 0;
   for (unsigned int j = 0; j != collsSize; j++) {
     const reco::TrackCollection* tC1 = trackColls[j];
 
     edm::Handle<edm::ValueMap<int>> trackSelColl;
     edm::Handle<edm::ValueMap<float>> trackMVAStore;
     if (copyMVA_)
       e.getByToken(trackProducers_[j].tmva, trackMVAStore);
     if (hasSelector_[j] > 0) {
       e.getByToken(trackProducers_[j].tsel, trackSelColl);
     }
 
     if (!tC1->empty()) {
       unsigned int iC = 0;
       for (reco::TrackCollection::const_iterator track = tC1->begin(); track != tC1->end(); track++) {
         i++;
         trackCollNum[i] = j;
         trackQuals[i] = track->qualityMask();
         oriAlgo[i] = track->originalAlgo();
         algoMask[i] = track->algoMask();
 
         reco::TrackRef trkRef = reco::TrackRef(trackHandles[j], iC);
         if (copyMVA_)
           if ((*trackMVAStore).contains(trkRef.id()))
             trackMVAs[i] = (*trackMVAStore)[trkRef];
         if (hasSelector_[j] > 0) {
           int qual = (*trackSelColl)[trkRef];
           if (qual < 0) {
             selected[i] = 0;
             iC++;
             continue;
           } else {
             trackQuals[i] = qual;
           }
         }
         iC++;
         selected[i] = trackQuals[i] + 10;  //10 is magic number used throughout...
         if ((short unsigned)track->ndof() < 1) {
           selected[i] = 0;
           continue;
         }
         if (track->normalizedChi2() > maxNormalizedChisq_) {
           selected[i] = 0;
           continue;
         }
         if (track->found() < minFound_) {
           selected[i] = 0;
           continue;
         }
         if (track->pt() < minPT_) {
           selected[i] = 0;
           continue;
         }
         // good!
         indexG[i] = ngood++;
         //if ( beVerb) std::cout << "inverb " << track->pt() << " " << selected[i] << std::endl;
       }  //end loop over tracks
     }    //end more than 0 track
   }      // loop over trackcolls
 
   statCount.pre(ngood);
 
   //cache the id and rechits of valid hits
   typedef std::pair<unsigned int, const TrackingRecHit*> IHit;
   std::vector<std::vector<IHit>> rh1(ngood);  // "not an array" of vectors!
   //const TrackingRecHit*  fh1[ngood];  // first hit...
   reco::TrackBase::TrackAlgorithm algo[std::max(1, ngood)];
   float score[std::max(1, ngood)];
 
   for (unsigned int j = 0; j < rSize; j++) {
     if (selected[j] == 0)
       continue;
     int i = indexG[j];
     assert(i >= 0);
     unsigned int collNum = trackCollNum[j];
     unsigned int trackNum = j - trackCollFirsts[collNum];
     const reco::Track* track = &((trackColls[collNum])->at(trackNum));
 
     algo[i] = track->algo();
     int validHits = track->numberOfValidHits();
     int validPixelHits = track->hitPattern().numberOfValidPixelHits();
     int lostHits = track->numberOfLostHits();
     score[i] =
         foundHitBonus_ * validPixelHits + foundHitBonus_ * validHits - lostHitPenalty_ * lostHits - track->chi2();
 
     rh1[i].reserve(validHits);
     auto compById = [](IHit const& h1, IHit const& h2) { return h1.first < h2.first; };
     for (trackingRecHit_iterator it = track->recHitsBegin(); it != track->recHitsEnd(); ++it) {
       const TrackingRecHit* hit = (*it);
       unsigned int id = hit->rawId();
       if (hit->geographicalId().subdetId() > 2)
         id &= (~3);  // mask mono/stereo in strips...
       if LIKELY (hit->isValid()) {
         rh1[i].emplace_back(id, hit);
         std::push_heap(rh1[i].begin(), rh1[i].end(), compById);
       }
     }
     std::sort_heap(rh1[i].begin(), rh1[i].end(), compById);
   }
 
   //DL here
   if LIKELY (ngood > 1 && collsSize > 1)
     for (unsigned int ltm = 0; ltm < listsToMerge_.size(); ltm++) {
       int saveSelected[rSize];
       bool notActive[collsSize];
       for (unsigned int cn = 0; cn != collsSize; ++cn)
         notActive[cn] = find(listsToMerge_[ltm].begin(), listsToMerge_[ltm].end(), cn) == listsToMerge_[ltm].end();
 
       for (unsigned int i = 0; i < rSize; i++)
         saveSelected[i] = selected[i];
 
       //DL protect against 0 tracks?
       for (unsigned int i = 0; i < rSize - 1; i++) {
         if (selected[i] == 0)
           continue;
         unsigned int collNum = trackCollNum[i];
 
         //check that this track is in one of the lists for this iteration
         if (notActive[collNum])
           continue;
 
         int k1 = indexG[i];
         unsigned int nh1 = rh1[k1].size();
         int qualityMaskT1 = trackQuals[i];
 
         int nhit1 = nh1;  // validHits[k1];
         float score1 = score[k1];
 
         // start at next collection
         for (unsigned int j = i + 1; j < rSize; j++) {
           if (selected[j] == 0)
             continue;
           unsigned int collNum2 = trackCollNum[j];
           if ((collNum == collNum2) && indivShareFrac_[collNum] > 0.99)
             continue;
           //check that this track is in one of the lists for this iteration
           if (notActive[collNum2])
             continue;
 
           int k2 = indexG[j];
 
           int newQualityMask = -9;  //avoid resetting quality mask if not desired 10+ -9 =1
           if (promoteQuality_[ltm]) {
             int maskT1 = saveSelected[i] > 1 ? saveSelected[i] - 10 : qualityMaskT1;
             int maskT2 = saveSelected[j] > 1 ? saveSelected[j] - 10 : trackQuals[j];
             newQualityMask = (maskT1 | maskT2);  // take OR of trackQuality
           }
           unsigned int nh2 = rh1[k2].size();
           int nhit2 = nh2;
 
           auto share = use_sharesInput_ ? [](const TrackingRecHit* it, const TrackingRecHit* jt, float) -> bool {
             return it->sharesInput(jt, TrackingRecHit::some);
           }
           : [](const TrackingRecHit* it, const TrackingRecHit* jt, float eps) -> bool {
               float delta = std::abs(it->localPosition().x() - jt->localPosition().x());
               return (it->geographicalId() == jt->geographicalId()) && (delta < eps);
             };
 
           statCount.start();
 
           //loop over rechits
           int noverlap = 0;
           int firstoverlap = 0;
           // check first hit  (should use REAL first hit?)
           if UNLIKELY (allowFirstHitShare_ && rh1[k1][0].first == rh1[k2][0].first) {
             const TrackingRecHit* it = rh1[k1][0].second;
             const TrackingRecHit* jt = rh1[k2][0].second;
             if (share(it, jt, epsilon_))
               firstoverlap = 1;
           }
 
           // exploit sorting
           unsigned int jh = 0;
           unsigned int ih = 0;
           while (ih != nh1 && jh != nh2) {
             // break if not enough to go...
             // if ( nprecut-noverlap+firstoverlap > int(nh1-ih)) break;
             // if ( nprecut-noverlap+firstoverlap > int(nh2-jh)) break;
             auto const id1 = rh1[k1][ih].first;
             auto const id2 = rh1[k2][jh].first;
             if (id1 < id2)
               ++ih;
             else if (id2 < id1)
               ++jh;
             else {
               // in case of split-hit do full conbinatorics
               auto li = ih;
               while ((++li) != nh1 && id1 == rh1[k1][li].first) {
               }
               auto lj = jh;
               while ((++lj) != nh2 && id2 == rh1[k2][lj].first) {
               }
               for (auto ii = ih; ii != li; ++ii)
                 for (auto jj = jh; jj != lj; ++jj) {
                   const TrackingRecHit* it = rh1[k1][ii].second;
                   const TrackingRecHit* jt = rh1[k2][jj].second;
                   if (share(it, jt, epsilon_))
                     noverlap++;
                 }
               jh = lj;
               ih = li;
             }  // equal ids
 
           }  //loop over ih & jh
 
           bool dupfound =
               (collNum != collNum2)
                   ? (noverlap - firstoverlap) > (std::min(nhit1, nhit2) - firstoverlap) * shareFrac_
                   : (noverlap - firstoverlap) > (std::min(nhit1, nhit2) - firstoverlap) * indivShareFrac_[collNum];
 
           auto seti = [&](unsigned int ii, unsigned int jj) {
             selected[jj] = 0;
             selected[ii] = 10 + newQualityMask;  // add 10 to avoid the case where mask = 1
             trkUpdated[ii] = true;
             if (trackAlgoPriorityOrder.priority(oriAlgo[jj]) < trackAlgoPriorityOrder.priority(oriAlgo[ii]))
               oriAlgo[ii] = oriAlgo[jj];
             algoMask[ii] |= algoMask[jj];
             algoMask[jj] = algoMask[ii];  // in case we keep discarded
           };
 
           if (dupfound) {
             float score2 = score[k2];
             constexpr float almostSame =
                 0.01f;  // difference rather than ratio due to possible negative values for score
             if (score1 - score2 > almostSame) {
               seti(i, j);
             } else if (score2 - score1 > almostSame) {
               seti(j, i);
             } else {
               // If tracks from both iterations are virtually identical, choose the one with the best quality or with lower algo
               if ((trackQuals[j] &
                    (1 << reco::TrackBase::loose | 1 << reco::TrackBase::tight | 1 << reco::TrackBase::highPurity)) ==
                   (trackQuals[i] &
                    (1 << reco::TrackBase::loose | 1 << reco::TrackBase::tight | 1 << reco::TrackBase::highPurity))) {
                 //same quality, pick earlier algo
                 if (trackAlgoPriorityOrder.priority(algo[k1]) <= trackAlgoPriorityOrder.priority(algo[k2])) {
                   seti(i, j);
                 } else {
                   seti(j, i);
                 }
               } else if ((trackQuals[j] & (1 << reco::TrackBase::loose | 1 << reco::TrackBase::tight |
                                            1 << reco::TrackBase::highPurity)) <
                          (trackQuals[i] & (1 << reco::TrackBase::loose | 1 << reco::TrackBase::tight |
                                            1 << reco::TrackBase::highPurity))) {
                 seti(i, j);
               } else {
                 seti(j, i);
               }
             }  //end fi < fj
             statCount.overlap();
             /*
         if (at0[k1]&&at0[k2]) {
           statCount.dp(dphi);
           if (dz<1.f) statCount.de(deta);
         }
         */
           }  //end got a duplicate
           else {
             statCount.noOverlap();
           }
           //stop if the ith track is now unselected
           if (selected[i] == 0)
             break;
         }  //end track2 loop
       }    //end track loop
     }      //end loop over track list sets
 
   auto vmMVA = std::make_unique<edm::ValueMap<float>>();
   edm::ValueMap<float>::Filler fillerMVA(*vmMVA);
 
   // special case - if just doing the trkquals
   if (trkQualMod_) {
     unsigned int tSize = trackColls[0]->size();
     auto vm = std::make_unique<edm::ValueMap<int>>();
     edm::ValueMap<int>::Filler filler(*vm);
 
     std::vector<int> finalQuals(tSize, -1);  //default is unselected
     for (unsigned int i = 0; i < rSize; i++) {
       unsigned int tNum = i % tSize;
 
       if (selected[i] > 1) {
         finalQuals[tNum] = selected[i] - 10;
         if (trkUpdated[i])
           finalQuals[tNum] = (finalQuals[tNum] | (1 << qualityToSet_));
       }
       if (selected[i] == 1)
         finalQuals[tNum] = trackQuals[i];
     }
 
     filler.insert(trackHandles[0], finalQuals.begin(), finalQuals.end());
     filler.fill();
 
     e.put(std::move(vm));
     for (auto& q : finalQuals)
       q = std::max(q, 0);
     auto quals = std::make_unique<QualityMaskCollection>(finalQuals.begin(), finalQuals.end());
     e.put(std::move(quals), "QualityMasks");
 
     std::vector<float> mvaVec(tSize, -99);
 
     for (unsigned int i = 0; i < rSize; i++) {
       unsigned int tNum = i % tSize;
       mvaVec[tNum] = trackMVAs[tNum];
     }
 
     fillerMVA.insert(trackHandles[0], mvaVec.begin(), mvaVec.end());
     fillerMVA.fill();
     if (copyMVA_) {
       e.put(std::move(vmMVA), "MVAVals");
       auto mvas = std::make_unique<MVACollection>(mvaVec.begin(), mvaVec.end());
       e.put(std::move(mvas), "MVAValues");
     }
     return;
   }
 
   //
   //  output selected tracks - if any
   //
 
   std::vector<reco::TrackRef> trackRefs(rSize);
   std::vector<edm::RefToBase<TrajectorySeed>> seedsRefs(rSize);
 
   unsigned int nToWrite = 0;
   for (unsigned int i = 0; i < rSize; i++)
     if (selected[i] != 0)
       nToWrite++;
 
   std::vector<float> mvaVec;
 
   outputTrks = std::make_unique<reco::TrackCollection>();
   outputTrks->reserve(nToWrite);
   refTrks = e.getRefBeforePut<reco::TrackCollection>();
 
   if (copyExtras_) {
     outputTrkExtras = std::make_unique<reco::TrackExtraCollection>();
     outputTrkExtras->reserve(nToWrite);
     refTrkExtras = e.getRefBeforePut<reco::TrackExtraCollection>();
     outputTrkHits = std::make_unique<TrackingRecHitCollection>();
     outputTrkHits->reserve(nToWrite * 25);
     refTrkHits = e.getRefBeforePut<TrackingRecHitCollection>();
     if (makeReKeyedSeeds_) {
       outputSeeds = std::make_unique<TrajectorySeedCollection>();
       outputSeeds->reserve(nToWrite);
       refTrajSeeds = e.getRefBeforePut<TrajectorySeedCollection>();
     }
   }
 
   outputTrajs = std::make_unique<std::vector<Trajectory>>();
   outputTrajs->reserve(rSize);
 
   for (unsigned int i = 0; i < rSize; i++) {
     if (selected[i] == 0) {
       trackRefs[i] = reco::TrackRef();
       continue;
     }
 
     unsigned int collNum = trackCollNum[i];
     unsigned int trackNum = i - trackCollFirsts[collNum];
     const reco::Track* track = &((trackColls[collNum])->at(trackNum));
     outputTrks->push_back(reco::Track(*track));
     mvaVec.push_back(trackMVAs[i]);
     if (selected[i] > 1) {
       outputTrks->back().setQualityMask(selected[i] - 10);
       if (trkUpdated[i])
         outputTrks->back().setQuality(qualityToSet_);
     }
     //might duplicate things, but doesnt hurt
     if (selected[i] == 1)
       outputTrks->back().setQualityMask(trackQuals[i]);
     outputTrks->back().setOriginalAlgorithm(oriAlgo[i]);
     outputTrks->back().setAlgoMask(algoMask[i]);
 
     // if ( beVerb ) std::cout << "selected " << outputTrks->back().pt() << " " << outputTrks->back().qualityMask() << " " << selected[i] << std::endl;
 
     //fill the TrackCollection
     if (copyExtras_) {
       edm::RefToBase<TrajectorySeed> 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) {
           TrackingRecHit const& hit = *origSeedRef->recHits().begin();
           if (hit.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::StableProvenance const& prov = e.getStableProvenance(pID);
             clusterRemovalInfos = edm::InputTag(prov.moduleLabel(), prov.productInstanceName(), prov.processName());
             doRekeyOnThisSeed = e.getByLabel(clusterRemovalInfos, CRIh);
           }  //valid hit
         }    //nhit!=0
 
         if (doRekeyOnThisSeed && !(clusterRemovalInfos == edm::InputTag(""))) {
           ClusterRemovalRefSetter refSetter(e, clusterRemovalInfos);
           TrajectorySeed::RecHitContainer newRecHitContainer;
           newRecHitContainer.reserve(origSeedRef->nHits());
           for (auto const& recHit : origSeedRef->recHits()) {
             newRecHitContainer.push_back(recHit);
             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));
       seedsRefs[i] = origSeedRef;
       outputTrks->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);
       tx.setTrajParams(track->extra()->trajParams(), track->extra()->chi2sX5());
       assert(tx.trajParams().size() == tx.recHitsSize());
       for (auto hh = track->recHitsBegin(), eh = track->recHitsEnd(); hh != eh; ++hh) {
         outputTrkHits->push_back((*hh)->clone());
       }
     }
     trackRefs[i] = reco::TrackRef(refTrks, outputTrks->size() - 1);
 
   }  //end faux loop over tracks
 
   //Fill the trajectories, etc. for 1st collection
   refTrajs = e.getRefBeforePut<std::vector<Trajectory>>();
 
   outputTTAss = std::make_unique<TrajTrackAssociationCollection>(refTrajs, refTrks);
 
   for (unsigned int ti = 0; ti < trackColls.size(); ti++) {
     edm::Handle<std::vector<Trajectory>> hTraj1;
     edm::Handle<TrajTrackAssociationCollection> hTTAss1;
     e.getByToken(trackProducers_[ti].traj, hTraj1);
     e.getByToken(trackProducers_[ti].tass, hTTAss1);
 
     if (hTraj1.failedToGet() || hTTAss1.failedToGet())
       continue;
 
     for (size_t i = 0, n = hTraj1->size(); i < n; ++i) {
       edm::Ref<std::vector<Trajectory>> trajRef(hTraj1, i);
       TrajTrackAssociationCollection::const_iterator match = hTTAss1->find(trajRef);
       if (match != hTTAss1->end()) {
         const edm::Ref<reco::TrackCollection>& trkRef = match->val;
         uint32_t oldKey = trackCollFirsts[ti] + static_cast<uint32_t>(trkRef.key());
         if (trackRefs[oldKey].isNonnull()) {
           outputTrajs->push_back(*trajRef);
           //if making extras and the seeds at the same time, change the seed ref on the trajectory
           if (copyExtras_ && makeReKeyedSeeds_)
             outputTrajs->back().setSeedRef(seedsRefs[oldKey]);
           outputTTAss->insert(edm::Ref<std::vector<Trajectory>>(refTrajs, outputTrajs->size() - 1), trackRefs[oldKey]);
         }
       }
     }
   }
 
   statCount.end(outputTrks->size());
 
   edm::ProductID nPID = refTrks.id();
   edm::TestHandle<reco::TrackCollection> outHandle(outputTrks.get(), nPID);
   fillerMVA.insert(outHandle, mvaVec.begin(), mvaVec.end());
   fillerMVA.fill();
 
   e.put(std::move(outputTrks));
   if (copyMVA_) {
     e.put(std::move(vmMVA), "MVAVals");
     auto mvas = std::make_unique<MVACollection>(mvaVec.begin(), mvaVec.end());
     e.put(std::move(mvas), "MVAValues");
   }
   if (copyExtras_) {
     e.put(std::move(outputTrkExtras));
     e.put(std::move(outputTrkHits));
     if (makeReKeyedSeeds_)
       e.put(std::move(outputSeeds));
   }
   e.put(std::move(outputTrajs));
   e.put(std::move(outputTTAss));
   return;
 
 }  //end produce

◆ returnEmptyCollections()

void TrackListMerger::returnEmptyCollections ( edm::Event & e )

private

Definition at line 892 of file TrackListMerger.cc.

References copyExtras_, MillePedeFileConverter_cfg::e, makeReKeyedSeeds_, eostools::move(), outputSeeds, outputTrajs, outputTrkExtras, outputTrkHits, outputTrks, outputTTAss, and trkQualMod_.

Referenced by produce().

                                                         {
   if (trkQualMod_) {
     auto vm = std::make_unique<edm::ValueMap<int>>();
     e.put(std::move(vm));
     auto quals = std::make_unique<QualityMaskCollection>();
     e.put(std::move(quals), "QualityMasks");
   } else {
     auto outputTrks = std::make_unique<reco::TrackCollection>();
     e.put(std::move(outputTrks));
 
     if (makeReKeyedSeeds_) {
       auto outputSeeds = std::make_unique<TrajectorySeedCollection>();
       e.put(std::move(outputSeeds));
     }
 
     if (copyExtras_) {
       auto outputTrkExtras = std::make_unique<reco::TrackExtraCollection>();
       auto outputTrkHits = std::make_unique<TrackingRecHitCollection>();
       e.put(std::move(outputTrkExtras));
       e.put(std::move(outputTrkHits));
     }
 
     auto outputTrajs = std::make_unique<std::vector<Trajectory>>();
     outputTTAss = std::make_unique<TrajTrackAssociationCollection>();
     e.put(std::move(outputTrajs));
     e.put(std::move(outputTTAss));
   }
   auto vmMVA = std::make_unique<edm::ValueMap<float>>();
   e.put(std::move(vmMVA), "MVAVals");
   auto mvas = std::make_unique<MVACollection>();
   e.put(std::move(mvas), "MVAValues");
   return;
 }

Member Data Documentation

◆ allowFirstHitShare_

bool TrackListMerger::allowFirstHitShare_

private

Definition at line 114 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ copyExtras_

bool TrackListMerger::copyExtras_

private

Definition at line 59 of file TrackListMerger.cc.

Referenced by produce(), returnEmptyCollections(), and TrackListMerger().

◆ copyMVA_

bool TrackListMerger::copyMVA_

private

Definition at line 112 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ epsilon_

float TrackListMerger::epsilon_

private

Definition at line 103 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ foundHitBonus_

float TrackListMerger::foundHitBonus_

private

Definition at line 105 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ hasSelector_

std::vector<int> TrackListMerger::hasSelector_

private

Definition at line 111 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ indivShareFrac_

std::vector<double> TrackListMerger::indivShareFrac_

private

Definition at line 107 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ listsToMerge_

std::vector<std::vector<int> > TrackListMerger::listsToMerge_

private

Definition at line 109 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ lostHitPenalty_

float TrackListMerger::lostHitPenalty_

private

Definition at line 106 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ makeReKeyedSeeds_

bool TrackListMerger::makeReKeyedSeeds_

private

Definition at line 60 of file TrackListMerger.cc.

Referenced by produce(), returnEmptyCollections(), and TrackListMerger().

◆ maxNormalizedChisq_

double TrackListMerger::maxNormalizedChisq_

private

Definition at line 100 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ minFound_

unsigned int TrackListMerger::minFound_

private

Definition at line 102 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ minPT_

double TrackListMerger::minPT_

private

Definition at line 101 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ outputSeeds

std::unique_ptr<TrajectorySeedCollection> TrackListMerger::outputSeeds

private

Definition at line 51 of file TrackListMerger.cc.

Referenced by produce(), and returnEmptyCollections().

◆ outputTrajs

std::unique_ptr<std::vector<Trajectory> > TrackListMerger::outputTrajs

private

Definition at line 49 of file TrackListMerger.cc.

Referenced by produce(), and returnEmptyCollections().

◆ outputTrkExtras

std::unique_ptr<reco::TrackExtraCollection> TrackListMerger::outputTrkExtras

private

Definition at line 47 of file TrackListMerger.cc.

Referenced by produce(), and returnEmptyCollections().

◆ outputTrkHits

std::unique_ptr<TrackingRecHitCollection> TrackListMerger::outputTrkHits

private

Definition at line 48 of file TrackListMerger.cc.

Referenced by produce(), and returnEmptyCollections().

◆ outputTrks

std::unique_ptr<reco::TrackCollection> TrackListMerger::outputTrks

private

Definition at line 46 of file TrackListMerger.cc.

Referenced by produce(), and returnEmptyCollections().

◆ outputTTAss

std::unique_ptr<TrajTrackAssociationCollection> TrackListMerger::outputTTAss

private

Definition at line 50 of file TrackListMerger.cc.

Referenced by produce(), and returnEmptyCollections().

◆ priorityName_

std::string TrackListMerger::priorityName_

private

Definition at line 98 of file TrackListMerger.cc.

Referenced by TrackListMerger().

◆ priorityToken

edm::ESGetToken<TrackAlgoPriorityOrder, CkfComponentsRecord> TrackListMerger::priorityToken

private

Definition at line 62 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ promoteQuality_

std::vector<bool> TrackListMerger::promoteQuality_

private

Definition at line 110 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ qualityToSet_

reco::TrackBase::TrackQuality TrackListMerger::qualityToSet_

private

Definition at line 115 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ refTrajs

edm::RefProd<std::vector<Trajectory> > TrackListMerger::refTrajs

private

Definition at line 56 of file TrackListMerger.cc.

Referenced by produce().

◆ refTrajSeeds

edm::RefProd<TrajectorySeedCollection> TrackListMerger::refTrajSeeds

private

Definition at line 57 of file TrackListMerger.cc.

Referenced by produce().

◆ refTrkExtras

reco::TrackExtraRefProd TrackListMerger::refTrkExtras

private

Definition at line 54 of file TrackListMerger.cc.

Referenced by produce().

◆ refTrkHits

TrackingRecHitRefProd TrackListMerger::refTrkHits

private

Definition at line 55 of file TrackListMerger.cc.

Referenced by produce().

◆ refTrks

reco::TrackRefProd TrackListMerger::refTrks

private

Definition at line 53 of file TrackListMerger.cc.

Referenced by produce().

◆ shareFrac_

float TrackListMerger::shareFrac_

private

Definition at line 104 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ trackProducers_

std::vector<TkEDGetTokenss> TrackListMerger::trackProducers_

private

Definition at line 96 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

◆ trkQualMod_

bool TrackListMerger::trkQualMod_

private

Definition at line 117 of file TrackListMerger.cc.

Referenced by produce(), returnEmptyCollections(), and TrackListMerger().

◆ use_sharesInput_

bool TrackListMerger::use_sharesInput_

private

Definition at line 116 of file TrackListMerger.cc.

Referenced by produce(), and TrackListMerger().

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ MVACollection

◆ QualityMaskCollection

Constructor & Destructor Documentation

◆ TrackListMerger()

◆ ~TrackListMerger()

Member Function Documentation

◆ edTokens() [1/2]

◆ edTokens() [2/2]

◆ produce()

◆ returnEmptyCollections()

Member Data Documentation

◆ allowFirstHitShare_

◆ copyExtras_

◆ copyMVA_

◆ epsilon_

◆ foundHitBonus_

◆ hasSelector_

◆ indivShareFrac_

◆ listsToMerge_

◆ lostHitPenalty_

◆ makeReKeyedSeeds_

◆ maxNormalizedChisq_

◆ minFound_

◆ minPT_

◆ outputSeeds

◆ outputTrajs

◆ outputTrkExtras

◆ outputTrkHits

◆ outputTrks

◆ outputTTAss

◆ priorityName_

◆ priorityToken

◆ promoteQuality_

◆ qualityToSet_

◆ refTrajs

◆ refTrajSeeds

◆ refTrkExtras

◆ refTrkHits

◆ refTrks

◆ shareFrac_

◆ trackProducers_

◆ trkQualMod_

◆ use_sharesInput_