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
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

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

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

Detailed Description

Definition at line 31 of file TrackListMerger.cc.

Member Typedef Documentation

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

private

Definition at line 40 of file TrackListMerger.cc.

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

private

Definition at line 41 of file TrackListMerger.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 203 of file TrackListMerger.cc.

References Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, createfilelist::int, label, convertSQLiteXML::ok, reco::TrackBase::qualityByName(), TrackValidation_cff::selectors, sistrip_dqm_sourceclient-live_cfg::setsToMerge, AlCaHLTBitMon_QueryRunRegistry::string, and reco::TrackBase::undefQuality.

                                                            {
  copyExtras_ = conf.getUntrackedParameter<bool>("copyExtras", true);

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

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

  priorityName_ = conf.getParameter<std::string>("trackAlgoPriorityOrder");
}

TrackListMerger::~TrackListMerger ( )

override

Definition at line 301 of file TrackListMerger.cc.

{}

Member Function Documentation

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

inlineprivate

Definition at line 75 of file TrackListMerger.cc.

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

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

inlineprivate

Definition at line 83 of file TrackListMerger.cc.

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

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

override

Definition at line 304 of file TrackListMerger.cc.

References funct::abs(), ecalcalib_dqm_sourceclient-live_cfg::algo, reco::TrackBase::algo(), edm::OwnVector< T, P >::back(), begin, reco::TrackBase::chi2(), edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, constexpr, DEFINE_FWK_MODULE, dumpMFGeometry_cfg::delta, TrajectorySeed::direction(), end, edm::AssociationMap< Tag >::end(), reco::Track::extra(), edm::HandleBase::failedToGet(), trigObjTnPSource_cfi::filler, spr::find(), edm::AssociationMap< Tag >::find(), dqmdumpme::first, dqmMemoryStats::float, TrackingRecHit::geographicalId(), edm::EventSetup::get(), edm::Event::getByLabel(), edm::Event::getByToken(), edm::Event::getProvenance(), edm::Event::getRefBeforePut(), reco::TrackBase::highPurity, reco::TrackBase::hitPattern(), mps_fire::i, edm::ProductID::id(), edm::Ref< C, T, F >::id(), globals_cff::id1, globals_cff::id2, cuy::ii, reco::Track::innerDetId(), reco::Track::innerMomentum(), reco::Track::innerOk(), reco::Track::innerPosition(), reco::Track::innerStateCovariance(), HLT_2018_cff::InputTag, TrackingRecHit::isValid(), dqmiolumiharvest::j, findQualityFiles::jj, edm::Ref< C, T, F >::key(), LIKELY, TrackingRecHit::localPosition(), reco::TrackBase::loose, electrons_cff::lostHits, match(), SiStripPI::max, min(), edm::Provenance::moduleLabel(), eostools::move(), dqmiodumpmetadata::n, TrajectorySeed::nHits(), reco::TrackBase::numberOfLostHits(), reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), 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(), data-class-funcs::q, TrackingRecHit::rawId(), TrajectorySeed::recHits(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), reco::TrackExtraBase::recHitsSize(), reco::Track::recHitsSize(), ClusterRemovalRefSetter::reKey(), edm::OwnVector< T, P >::reserve(), reco::Track::residuals(), offlineSlimmedPrimaryVertices_cfi::score, reco::Track::seedDirection(), reco::Track::seedRef(), reco::TrackExtraBase::setHits(), reco::TrackExtra::setResiduals(), reco::TrackExtraBase::setTrajParams(), TrackingRecHit::some, TrajectorySeed::startingState(), DetId::subdetId(), reco::TrackBase::tight, HLT_2018_cff::track, trackAlgoPriorityOrder, reco::TrackExtraBase::trajParams(), reco::TrackBase::undefAlgorithm, UNLIKELY, 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.get<CkfComponentsRecord>().get(priorityName_, priorityH);
  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;
    }
  }

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

  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) {
          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 = e.getProvenance(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());
          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));
      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

Member Data Documentation

bool TrackListMerger::allowFirstHitShare_

private

Definition at line 109 of file TrackListMerger.cc.

bool TrackListMerger::copyExtras_

private

Definition at line 56 of file TrackListMerger.cc.

bool TrackListMerger::copyMVA_

private

Definition at line 107 of file TrackListMerger.cc.

float TrackListMerger::epsilon_

private

Definition at line 98 of file TrackListMerger.cc.

float TrackListMerger::foundHitBonus_

private

Definition at line 100 of file TrackListMerger.cc.

std::vector<int> TrackListMerger::hasSelector_

private

Definition at line 106 of file TrackListMerger.cc.

std::vector<double> TrackListMerger::indivShareFrac_

private

Definition at line 102 of file TrackListMerger.cc.

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

private

Definition at line 104 of file TrackListMerger.cc.

float TrackListMerger::lostHitPenalty_

private

Definition at line 101 of file TrackListMerger.cc.

bool TrackListMerger::makeReKeyedSeeds_

private

Definition at line 57 of file TrackListMerger.cc.

double TrackListMerger::maxNormalizedChisq_

private

Definition at line 95 of file TrackListMerger.cc.

unsigned int TrackListMerger::minFound_

private

Definition at line 97 of file TrackListMerger.cc.

double TrackListMerger::minPT_

private

Definition at line 96 of file TrackListMerger.cc.

std::unique_ptr<TrajectorySeedCollection> TrackListMerger::outputSeeds

private

Definition at line 48 of file TrackListMerger.cc.

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

private

Definition at line 46 of file TrackListMerger.cc.

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

private

Definition at line 44 of file TrackListMerger.cc.

std::unique_ptr<TrackingRecHitCollection> TrackListMerger::outputTrkHits

private

Definition at line 45 of file TrackListMerger.cc.

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

private

Definition at line 43 of file TrackListMerger.cc.

std::unique_ptr<TrajTrackAssociationCollection> TrackListMerger::outputTTAss

private

Definition at line 47 of file TrackListMerger.cc.

std::string TrackListMerger::priorityName_

private

Definition at line 93 of file TrackListMerger.cc.

std::vector<bool> TrackListMerger::promoteQuality_

private

Definition at line 105 of file TrackListMerger.cc.

reco::TrackBase::TrackQuality TrackListMerger::qualityToSet_

private

Definition at line 110 of file TrackListMerger.cc.

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

private

Definition at line 53 of file TrackListMerger.cc.

edm::RefProd<TrajectorySeedCollection> TrackListMerger::refTrajSeeds

private

Definition at line 54 of file TrackListMerger.cc.

reco::TrackExtraRefProd TrackListMerger::refTrkExtras

private

Definition at line 51 of file TrackListMerger.cc.

TrackingRecHitRefProd TrackListMerger::refTrkHits

private

Definition at line 52 of file TrackListMerger.cc.

reco::TrackRefProd TrackListMerger::refTrks

private

Definition at line 50 of file TrackListMerger.cc.

float TrackListMerger::shareFrac_

private

Definition at line 99 of file TrackListMerger.cc.

std::vector<TkEDGetTokenss> TrackListMerger::trackProducers_

private

Definition at line 91 of file TrackListMerger.cc.

bool TrackListMerger::trkQualMod_

private

Definition at line 112 of file TrackListMerger.cc.

bool TrackListMerger::use_sharesInput_

private

Definition at line 111 of file TrackListMerger.cc.