TrackListMerger Class Reference

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 {
    produces<reco::TrackCollection>();

    makeReKeyedSeeds_ = conf.getUntrackedParameter<bool>("makeReKeyedSeeds", false);
    if (makeReKeyedSeeds_) {
      copyExtras_ = true;
      produces<TrajectorySeedCollection>();
    }

    if (copyExtras_) {
      produces<reco::TrackExtraCollection>();
      produces<TrackingRecHitCollection>();
    }
    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 306 of file TrackListMerger.cc.

References funct::abs(), allowFirstHitShare_, cms::cuda::assert(), edm::OwnVector< T, P >::back(), edm::Range< T >::begin(), edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, copyExtras_, copyMVA_, dumpMFGeometry_cfg::delta, TrajectorySeed::direction(), MillePedeFileConverter_cfg::e, edm::AssociationMap< Tag >::end(), mps_fire::end, HLT_2022v11_cff::eps, epsilon_, edm::HandleBase::failedToGet(), trigObjTnPSource_cfi::filler, spr::find(), edm::AssociationMap< Tag >::find(), first, dqmMemoryStats::float, foundHitBonus_, TrackingRecHit::geographicalId(), edm::EventSetup::getHandle(), hasSelector_, 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_, HLT_2022v11_cff::InputTag, sistrip::SpyUtilities::isValid(), dqmiolumiharvest::j, findQualityFiles::jj, edm::Ref< C, T, F >::key(), LIKELY, listsToMerge_, TrackingRecHit::localPosition(), 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_2022v11_cff::track, trackAlgoPriorityOrder, trackProducers_, reco::TrackExtraBase::trajParams(), trkQualMod_, reco::TrackBase::undefAlgorithm, UNLIKELY, use_sharesInput_, and PV3DBase< T, PVType, FrameType >::x().

                                                                  {
  // 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[ngood];
  float score[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 888 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().