mkfit::StdSeq Namespace Reference

Classes
struct	Quality

Functions
int	clean_cms_seedtracks_iter (TrackVec &seeds, const IterationConfig &itrcfg, const BeamSpot &bspot)
void	clean_duplicates (TrackVec &tracks, const IterationConfig &itconf)
void	clean_duplicates_sharedhits (TrackVec &tracks, const IterationConfig &itconf)
void	clean_duplicates_sharedhits_pixelseed (TrackVec &tracks, const IterationConfig &itconf)
void	cmssw_LoadHits_Begin (EventOfHits &eoh, const std::vector< const HitVec *> &orig_hitvectors)
void	cmssw_LoadHits_End (EventOfHits &eoh)
void	cmssw_Map_TrackHitIndices (const EventOfHits &eoh, TrackVec &seeds)
void	cmssw_ReMap_TrackHitIndices (const EventOfHits &eoh, TrackVec &out_tracks)
void	dump_simtracks (Event *event)
void	handle_duplicates (Event *)
void	loadDeads (EventOfHits &eoh, const std::vector< DeadVec > &deadvectors)
void	loadHitsAndBeamSpot (Event &ev, EventOfHits &eoh)
void	prep_cmsswtracks (Event *event)
void	prep_recotracks (Event *event)
void	prep_reftracks (Event *event, TrackVec &tracks, TrackExtraVec &extras, const bool realigntracks)
void	prep_simtracks (Event *event)
void	prep_tracks (Event *event, TrackVec &tracks, TrackExtraVec &extras, const bool realigntracks)
template<class TRACK >
bool	qfilter_n_hits (const TRACK &t, const MkJob &j)
template<class TRACK >
bool	qfilter_n_hits_pixseed (const TRACK &t, const MkJob &j)
template<class TRACK >
bool	qfilter_n_layers (const TRACK &t, const MkJob &j)
template<class TRACK >
bool	qfilter_nan_n_silly (const TRACK &t, const MkJob &)
template<class TRACK >
bool	qfilter_pixelLessBkwd (const TRACK &t, const MkJob &j)
	quality filter tuned for pixelLess iteration during backward search More...
template<class TRACK >
bool	qfilter_pixelLessFwd (const TRACK &t, const MkJob &j)
	quality filter tuned for pixelLess iteration during forward search More...
void	remove_duplicates (TrackVec &tracks)
void	root_val (Event *event)
void	root_val_dumb_cmssw (Event *event)
void	score_tracks (TrackVec &tracks)
void	track_print (Event *event, const Track &t, const char *pref)
float	trackScoreDefault (const int nfoundhits, const int ntailholes, const int noverlaphits, const int nmisshits, const float chi2, const float pt, const bool inFindCandidates)

Function Documentation

clean_cms_seedtracks_iter()

int mkfit::StdSeq::clean_cms_seedtracks_iter	(	TrackVec &	seeds,
		const IterationConfig &	itrcfg,
		const BeamSpot &	bspot
	)

Definition at line 87 of file MkStdSeqs.cc.

References funct::abs(), mkfit::Track::addHitIdx(), ntupleEnum::Algo, mkfit::binnor< C, A1, A2, NB_first, NB_count >::begin_registration(), mkfit::Config::c_dpt_common, mkfit::Config::c_etamax_brl, mkfit::cdist(), ALCARECOTkAlJpsiMuMu_cff::charge, mkfit::TrackBase::charge(), gather_cfg::cout, d0, mkfit::TrackBase::d0BeamSpot(), PVValHelper::eta, HLT_2023v12_cff::eta1, HLT_2023v12_cff::eta2, f, mkfit::binnor< C, A1, A2, NB_first, NB_count >::finalize_registration(), mkfit::axis_base< R, I, M, N >::from_R_rdr_to_N_bins(), mkfit::axis_pow2_u1< R, I, M, N >::from_R_rdr_to_N_bins(), mkfit::binnor< C, A1, A2, NB_first, NB_count >::get_content(), mkfit::Track::getHitIdx(), mkfit::Track::getHitLyr(), mps_fire::i, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, mkfit::TrackBase::invpT(), dqmiolumiharvest::j, mkfit::TrackBase::Status::kMaxSeedHits, LowPtQuadStep_cff::lowPtQuadStep, mkfit::binnor< C, A1, A2, NB_first, NB_count >::m_ranks, mkfit::IterationConfig::m_track_algorithm, mkfit::TrackBase::momEta(), mkfit::TrackBase::momPhi(), mkfit::axis_base< R, I, M, N >::next_N_bin(), mkfit::axis_pow2_u1< R, I, M, N >::next_N_bin(), mkfit::Track::nFoundHits(), nHits, mkfit::Track::nTotalHits(), mkfit::Const::PI, conifer::pow(), DiDispStaMuonMonitor_cfi::pt, mkfit::TrackBase::pT(), HLT_2023v12_cff::pt1, HLT_2023v12_cff::pt2, mkfit::binnor< C, A1, A2, NB_first, NB_count >::register_entry_safe(), mkfit::IterationConfig::sc_drmax_bh, mkfit::IterationConfig::sc_drmax_bl, mkfit::IterationConfig::sc_drmax_eh, mkfit::IterationConfig::sc_drmax_el, mkfit::IterationConfig::sc_dzmax_bh, mkfit::IterationConfig::sc_dzmax_bl, mkfit::IterationConfig::sc_dzmax_eh, mkfit::IterationConfig::sc_dzmax_el, mkfit::IterationConfig::sc_ptthr_hpt, DetachedQuadStep_cff::seeds, mkfit::Track::sortHitsByLayer(), mathSSE::sqrt(), contentValuesCheck::ss, funct::tan(), mkfit::TrackBase::theta(), mkfit::Config::track1GeVradius, tier0::unique(), x, mkfit::TrackBase::x(), mkfit::BeamSpot::x, mkfit::TrackBase::y(), mkfit::BeamSpot::y, and mkfit::TrackBase::z().

                                                                                                         {
      using Algo = TrackBase::TrackAlgorithm;

      const float etamax_brl = Config::c_etamax_brl;
      const float dpt_common = Config::c_dpt_common;

      const float dzmax_bh = itrcfg.sc_dzmax_bh;
      const float drmax_bh = itrcfg.sc_drmax_bh;
      const float dzmax_eh = itrcfg.sc_dzmax_eh;
      const float drmax_eh = itrcfg.sc_drmax_eh;
      const float dzmax_bl = itrcfg.sc_dzmax_bl;
      const float drmax_bl = itrcfg.sc_drmax_bl;
      const float dzmax_el = itrcfg.sc_dzmax_el;
      const float drmax_el = itrcfg.sc_drmax_el;

      const float ptmin_hpt = itrcfg.sc_ptthr_hpt;

      const float dzmax2_inv_bh = 1.f / (dzmax_bh * dzmax_bh);
      const float drmax2_inv_bh = 1.f / (drmax_bh * drmax_bh);
      const float dzmax2_inv_eh = 1.f / (dzmax_eh * dzmax_eh);
      const float drmax2_inv_eh = 1.f / (drmax_eh * drmax_eh);
      const float dzmax2_inv_bl = 1.f / (dzmax_bl * dzmax_bl);
      const float drmax2_inv_bl = 1.f / (drmax_bl * drmax_bl);
      const float dzmax2_inv_el = 1.f / (dzmax_el * dzmax_el);
      const float drmax2_inv_el = 1.f / (drmax_el * drmax_el);

      // Merge hits from overlapping seeds?
      // For now always true, we require extra hits after seed,
      // except for lowPtQuadStep, where we only merge hits for seeds at low pT and large pseudo-rapidity
      const bool merge_hits = true;  // itrcfg.merge_seed_hits_during_cleaning();
      const float ptmax_merge_lowPtQuad = 0.2;
      const float etamin_merge_lowPtQuad = 1.5;

      if (seeds.empty())
        return 0;

      const int ns = seeds.size();
#ifdef DEBUG
      std::cout << "before seed cleaning " << seeds.size() << std::endl;
#endif
      TrackVec cleanSeedTracks;
      cleanSeedTracks.reserve(ns);
      std::vector<bool> writetrack(ns, true);

      const float invR1GeV = 1.f / Config::track1GeVradius;

      std::vector<int> nHits(ns);
      std::vector<int> charge(ns);
      std::vector<float> oldPhi(ns);
      std::vector<float> pos2(ns);
      std::vector<float> eta(ns);
      std::vector<float> ctheta(ns);
      std::vector<float> invptq(ns);
      std::vector<float> pt(ns);
      std::vector<float> x(ns);
      std::vector<float> y(ns);
      std::vector<float> z(ns);
      std::vector<float> d0(ns);
      int i1, i2;  //for the sorting

      axis_pow2_u1<float, unsigned short, 16, 8> ax_phi(-Const::PI, Const::PI);
      axis<float, unsigned short, 8, 8> ax_eta(-3.0, 3.0, 30u);
      binnor<unsigned int, decltype(ax_phi), decltype(ax_eta), 24, 8> phi_eta_binnor(ax_phi, ax_eta);

      phi_eta_binnor.begin_registration(ns);

      for (int ts = 0; ts < ns; ts++) {
        const Track &tk = seeds[ts];
        nHits[ts] = tk.nFoundHits();
        charge[ts] = tk.charge();
        oldPhi[ts] = tk.momPhi();
        pos2[ts] = std::pow(tk.x(), 2) + std::pow(tk.y(), 2);
        eta[ts] = tk.momEta();
        ctheta[ts] = 1.f / std::tan(tk.theta());
        invptq[ts] = tk.charge() * tk.invpT();
        pt[ts] = tk.pT();
        x[ts] = tk.x();
        y[ts] = tk.y();
        z[ts] = tk.z();
        d0[ts] = tk.d0BeamSpot(bspot.x, bspot.y);

        phi_eta_binnor.register_entry_safe(oldPhi[ts], eta[ts]);
        // If one is sure values are *within* axis ranges: b.register_entry(oldPhi[ts], eta[ts]);
      }

      phi_eta_binnor.finalize_registration();

      for (int sorted_ts = 0; sorted_ts < ns; sorted_ts++) {
        int ts = phi_eta_binnor.m_ranks[sorted_ts];

        if (not writetrack[ts])
          continue;  // Note: this speed up prevents transitive masking (possibly marginal gain).

        const float oldPhi1 = oldPhi[ts];
        const float pos2_first = pos2[ts];
        const float eta1 = eta[ts];
        const float pt1 = pt[ts];
        const float invptq_first = invptq[ts];

        // To study some more details -- need EventOfHits for this
        int n_ovlp_hits_added = 0;

        auto phi_rng = ax_phi.from_R_rdr_to_N_bins(oldPhi[ts], 0.08f);
        auto eta_rng = ax_eta.from_R_rdr_to_N_bins(eta[ts], .1f);

        for (auto i_phi = phi_rng.begin; i_phi != phi_rng.end; i_phi = ax_phi.next_N_bin(i_phi)) {
          for (auto i_eta = eta_rng.begin; i_eta != eta_rng.end; i_eta = ax_eta.next_N_bin(i_eta)) {
            const auto cbin = phi_eta_binnor.get_content(i_phi, i_eta);
            for (auto i = cbin.first; i < cbin.end(); ++i) {
              int tss = phi_eta_binnor.m_ranks[i];

              if (not writetrack[ts])
                continue;
              if (not writetrack[tss])
                continue;
              if (tss == ts)
                continue;

              const float pt2 = pt[tss];

              // Always require charge consistency. If different charge is assigned, do not remove seed-track
              if (charge[tss] != charge[ts])
                continue;

              const float thisDPt = std::abs(pt2 - pt1);
              // Require pT consistency between seeds. If dpT is large, do not remove seed-track.
              if (thisDPt > dpt_common * pt1)
                continue;

              const float eta2 = eta[tss];
              const float deta2 = std::pow(eta1 - eta2, 2);

              const float oldPhi2 = oldPhi[tss];

              const float pos2_second = pos2[tss];
              const float thisDXYSign05 = pos2_second > pos2_first ? -0.5f : 0.5f;

              const float thisDXY = thisDXYSign05 * sqrt(std::pow(x[ts] - x[tss], 2) + std::pow(y[ts] - y[tss], 2));

              const float invptq_second = invptq[tss];

              const float newPhi1 = oldPhi1 - thisDXY * invR1GeV * invptq_first;
              const float newPhi2 = oldPhi2 + thisDXY * invR1GeV * invptq_second;

              const float dphi = cdist(std::abs(newPhi1 - newPhi2));

              const float dr2 = deta2 + dphi * dphi;

              const float thisDZ = z[ts] - z[tss] - thisDXY * (ctheta[ts] + ctheta[tss]);
              const float dz2 = thisDZ * thisDZ;

              // Reject tracks within dR-dz elliptical window.
              // Adaptive thresholds, based on observation that duplicates are more abundant at large pseudo-rapidity and low track pT
              bool overlapping = false;
              if (std::abs(eta1) < etamax_brl) {
                if (pt1 > ptmin_hpt) {
                  if (dz2 * dzmax2_inv_bh + dr2 * drmax2_inv_bh < 1.0f)
                    overlapping = true;
                } else {
                  if (dz2 * dzmax2_inv_bl + dr2 * drmax2_inv_bl < 1.0f)
                    overlapping = true;
                }
              } else {
                if (pt1 > ptmin_hpt) {
                  if (dz2 * dzmax2_inv_eh + dr2 * drmax2_inv_eh < 1.0f)
                    overlapping = true;
                } else {
                  if (dz2 * dzmax2_inv_el + dr2 * drmax2_inv_el < 1.0f)
                    overlapping = true;
                }
              }

              if (overlapping) {
                //Mark tss as a duplicate
                i1 = ts;
                i2 = tss;
                if (d0[tss] > d0[ts])
                  writetrack[tss] = false;
                else {
                  writetrack[ts] = false;
                  i2 = ts;
                  i1 = tss;
                }
                // Add hits from tk2 to the seed we are keeping.
                // NOTE: We have a limit in Track::Status for the number of seed hits.
                //       There is a check at entry and after adding of a new hit.
                Track &tk = seeds[i1];
                if (merge_hits && tk.nTotalHits() < Track::Status::kMaxSeedHits &&
                    (Algo(itrcfg.m_track_algorithm) != Algo::lowPtQuadStep ||
                     (pt1 < ptmax_merge_lowPtQuad && std::abs(eta1) > etamin_merge_lowPtQuad))) {
                  const Track &tk2 = seeds[i2];
                  //We are not actually fitting to the extra hits; use chi2 of 0
                  float fakeChi2 = 0.0;

                  for (int j = 0; j < tk2.nTotalHits(); ++j) {
                    int hitidx = tk2.getHitIdx(j);
                    int hitlyr = tk2.getHitLyr(j);
                    if (hitidx >= 0) {
                      bool unique = true;
                      for (int i = 0; i < tk.nTotalHits(); ++i) {
                        if ((hitidx == tk.getHitIdx(i)) && (hitlyr == tk.getHitLyr(i))) {
                          unique = false;
                          break;
                        }
                      }
                      if (unique) {
                        tk.addHitIdx(tk2.getHitIdx(j), tk2.getHitLyr(j), fakeChi2);
                        ++n_ovlp_hits_added;
                        if (tk.nTotalHits() >= Track::Status::kMaxSeedHits)
                          break;
                      }
                    }
                  }
                }
                if (n_ovlp_hits_added > 0)
                  tk.sortHitsByLayer();
              }
            }  //end of inner loop over tss
          }    //eta bin
        }      //phi bin

        if (writetrack[ts]) {
          cleanSeedTracks.emplace_back(seeds[ts]);
        }
      }

      seeds.swap(cleanSeedTracks);

#ifdef DEBUG
      {
        const int ns2 = seeds.size();
        printf("Number of CMS seeds before %d --> after %d cleaning\n", ns, ns2);

        for (int it = 0; it < ns2; it++) {
          const Track &ss = seeds[it];
          printf("  %3i q=%+i pT=%7.3f eta=% 7.3f nHits=%i label=% i\n",
                 it,
                 ss.charge(),
                 ss.pT(),
                 ss.momEta(),
                 ss.nFoundHits(),
                 ss.label());
        }
      }
#endif

#ifdef DEBUG
      std::cout << "AFTER seed cleaning " << seeds.size() << std::endl;
#endif

      return seeds.size();
    }

clean_duplicates()

void mkfit::StdSeq::clean_duplicates	(	TrackVec &	tracks,
		const IterationConfig &	itconf
	)

Definition at line 357 of file MkStdSeqs.cc.

References funct::abs(), HLT_2023v12_cff::eta1, f, mkfit::Config::maxdEta, mkfit::Config::maxdPhi, mkfit::Config::maxdPt, mkfit::Config::maxdR, SiStripPI::min, mkfit::Config::minFracHitsShared, vertices_cff::ntracks, HLT_2023v12_cff::pt1, remove_duplicates(), mkfit::squashPhiMinimal(), HLT_2023v12_cff::track, pwdgSkimBPark_cfi::tracks, mitigatedMETSequence_cff::U, and mkfit::Config::useHitsForDuplicates.

                                                                     {
      const auto ntracks = tracks.size();
      float eta1, phi1, pt1, deta, dphi, dr2;

      if (ntracks == 0) {
        return;
      }
      for (auto itrack = 0U; itrack < ntracks - 1; itrack++) {
        auto &track = tracks[itrack];
        eta1 = track.momEta();
        phi1 = track.momPhi();
        pt1 = track.pT();
        for (auto jtrack = itrack + 1; jtrack < ntracks; jtrack++) {
          auto &track2 = tracks[jtrack];
          if (track.label() == track2.label())
            continue;
          if (track.algoint() != track2.algoint())
            continue;

          deta = std::abs(track2.momEta() - eta1);
          if (deta > Config::maxdEta)
            continue;

          dphi = std::abs(squashPhiMinimal(phi1 - track2.momPhi()));
          if (dphi > Config::maxdPhi)
            continue;

          float maxdR = Config::maxdR;
          float maxdRSquared = maxdR * maxdR;
          if (std::abs(eta1) > 2.5f)
            maxdRSquared *= 16.0f;
          else if (std::abs(eta1) > 1.44f)
            maxdRSquared *= 9.0f;
          dr2 = dphi * dphi + deta * deta;
          if (dr2 < maxdRSquared) {
            //Keep track with best score
            if (track.score() > track2.score())
              track2.setDuplicateValue(true);
            else
              track.setDuplicateValue(true);
            continue;
          } else {
            if (pt1 == 0)
              continue;
            if (track2.pT() == 0)
              continue;

            if (std::abs((1 / track2.pT()) - (1 / pt1)) < Config::maxdPt) {
              if (Config::useHitsForDuplicates) {
                float numHitsShared = 0;
                for (int ihit2 = 0; ihit2 < track2.nTotalHits(); ihit2++) {
                  const int hitidx2 = track2.getHitIdx(ihit2);
                  const int hitlyr2 = track2.getHitLyr(ihit2);
                  if (hitidx2 >= 0) {
                    auto const it = std::find_if(track.beginHitsOnTrack(),
                                                 track.endHitsOnTrack(),
                                                 [&hitidx2, &hitlyr2](const HitOnTrack &element) {
                                                   return (element.index == hitidx2 && element.layer == hitlyr2);
                                                 });
                    if (it != track.endHitsOnTrack())
                      numHitsShared++;
                  }
                }

                float fracHitsShared = numHitsShared / std::min(track.nFoundHits(), track2.nFoundHits());
                //Only remove one of the tracks if they share at least X% of the hits (denominator is the shorter track)
                if (fracHitsShared < Config::minFracHitsShared)
                  continue;
              }
              //Keep track with best score
              if (track.score() > track2.score())
                track2.setDuplicateValue(true);
              else
                track.setDuplicateValue(true);
            }  //end of if dPt
          }    //end of else
        }      //end of loop over track2
      }        //end of loop over track1

      remove_duplicates(tracks);
    }

clean_duplicates_sharedhits()

void mkfit::StdSeq::clean_duplicates_sharedhits	(	TrackVec &	tracks,
		const IterationConfig &	itconf
	)

Definition at line 443 of file MkStdSeqs.cc.

References a, funct::abs(), b, mkfit::IterationConfig::dc_fracSharedHits, HLT_2023v12_cff::fraction, mps_fire::i, SiStripPI::min, vertices_cff::ntracks, FastTimerService_cff::range, remove_duplicates(), mkfit::squashPhiMinimal(), funct::tan(), pwdgSkimBPark_cfi::tracks, and mitigatedMETSequence_cff::U.

                                                                                      {
      const float fraction = itconf.dc_fracSharedHits;
      const auto ntracks = tracks.size();

      std::vector<float> ctheta(ntracks);
      std::multimap<int, int> hitMap;

      for (auto itrack = 0U; itrack < ntracks; itrack++) {
        auto &trk = tracks[itrack];
        ctheta[itrack] = 1.f / std::tan(trk.theta());
        for (int i = 0; i < trk.nTotalHits(); ++i) {
          if (trk.getHitIdx(i) < 0)
            continue;
          int a = trk.getHitLyr(i);
          int b = trk.getHitIdx(i);
          hitMap.insert(std::make_pair(b * 1000 + a, i > 0 ? itrack : -itrack));  //negative for first hit in trk
        }
      }

      for (auto itrack = 0U; itrack < ntracks; itrack++) {
        auto &trk = tracks[itrack];
        auto phi1 = trk.momPhi();
        auto ctheta1 = ctheta[itrack];

        std::map<int, int> sharingMap;
        for (int i = 0; i < trk.nTotalHits(); ++i) {
          if (trk.getHitIdx(i) < 0)
            continue;
          int a = trk.getHitLyr(i);
          int b = trk.getHitIdx(i);
          auto range = hitMap.equal_range(b * 1000 + a);
          for (auto it = range.first; it != range.second; ++it) {
            if (std::abs(it->second) >= (int)itrack)
              continue;  // don't check your own hits (==) nor sym. checks (>)
            if (i == 0 && it->second < 0)
              continue;  // shared first - first is not counted
            sharingMap[std::abs(it->second)]++;
          }
        }

        for (const auto &elem : sharingMap) {
          auto &track2 = tracks[elem.first];

          // broad dctheta-dphi compatibility checks; keep mostly to preserve consistency with old results
          auto dctheta = std::abs(ctheta[elem.first] - ctheta1);
          if (dctheta > 1.)
            continue;

          auto dphi = std::abs(squashPhiMinimal(phi1 - track2.momPhi()));
          if (dphi > 1.)
            continue;

          if (elem.second >= std::min(trk.nFoundHits(), track2.nFoundHits()) * fraction) {
            if (trk.score() > track2.score())
              track2.setDuplicateValue(true);
            else
              trk.setDuplicateValue(true);
          }
        }  // end sharing hits loop
      }    // end trk loop

      remove_duplicates(tracks);
    }

clean_duplicates_sharedhits_pixelseed()

void mkfit::StdSeq::clean_duplicates_sharedhits_pixelseed	(	TrackVec &	tracks,
		const IterationConfig &	itconf
	)

Definition at line 507 of file MkStdSeqs.cc.

References a, funct::abs(), b, HltBtagPostValidation_cff::c, ztail::d, mkfit::IterationConfig::dc_drth_central, mkfit::IterationConfig::dc_drth_forward, mkfit::IterationConfig::dc_drth_obarrel, mkfit::IterationConfig::dc_fracSharedHits, HLT_2023v12_cff::fraction, mps_fire::i, dqmiolumiharvest::j, mkfit::Config::maxcth_fw, mkfit::Config::maxcth_ob, mkfit::Config::maxd1pt, mkfit::Config::maxdcth, mkfit::Config::maxdphi, SiStripPI::min, vertices_cff::ntracks, remove_duplicates(), mkfit::squashPhiMinimal(), funct::tan(), pwdgSkimBPark_cfi::tracks, and mitigatedMETSequence_cff::U.

                                                                                                {
      const float fraction = itconf.dc_fracSharedHits;
      const float drth_central = itconf.dc_drth_central;
      const float drth_obarrel = itconf.dc_drth_obarrel;
      const float drth_forward = itconf.dc_drth_forward;
      const auto ntracks = tracks.size();

      std::vector<float> ctheta(ntracks);
      for (auto itrack = 0U; itrack < ntracks; itrack++) {
        auto &trk = tracks[itrack];
        ctheta[itrack] = 1.f / std::tan(trk.theta());
      }

      float phi1, invpt1, dctheta, ctheta1, dphi, dr2;
      for (auto itrack = 0U; itrack < ntracks; itrack++) {
        auto &trk = tracks[itrack];
        phi1 = trk.momPhi();
        invpt1 = trk.invpT();
        ctheta1 = ctheta[itrack];
        for (auto jtrack = itrack + 1; jtrack < ntracks; jtrack++) {
          auto &track2 = tracks[jtrack];
          if (trk.label() == track2.label())
            continue;

          dctheta = std::abs(ctheta[jtrack] - ctheta1);

          if (dctheta > Config::maxdcth)
            continue;

          dphi = std::abs(squashPhiMinimal(phi1 - track2.momPhi()));

          if (dphi > Config::maxdphi)
            continue;

          float maxdRSquared = drth_central * drth_central;
          if (std::abs(ctheta1) > Config::maxcth_fw)
            maxdRSquared = drth_forward * drth_forward;
          else if (std::abs(ctheta1) > Config::maxcth_ob)
            maxdRSquared = drth_obarrel * drth_obarrel;
          dr2 = dphi * dphi + dctheta * dctheta;
          if (dr2 < maxdRSquared) {
            //Keep track with best score
            if (trk.score() > track2.score())
              track2.setDuplicateValue(true);
            else
              trk.setDuplicateValue(true);
            continue;
          }

          if (std::abs(track2.invpT() - invpt1) > Config::maxd1pt)
            continue;

          auto sharedCount = 0;
          auto sharedFirst = 0;
          const auto minFoundHits = std::min(trk.nFoundHits(), track2.nFoundHits());

          for (int i = 0; i < trk.nTotalHits(); ++i) {
            if (trk.getHitIdx(i) < 0)
              continue;
            const int a = trk.getHitLyr(i);
            const int b = trk.getHitIdx(i);
            for (int j = 0; j < track2.nTotalHits(); ++j) {
              if (track2.getHitIdx(j) < 0)
                continue;
              const int c = track2.getHitLyr(j);
              const int d = track2.getHitIdx(j);

              //this is to count once shared matched hits (may be done more properly...)
              if (a == c && b == d)
                sharedCount += 1;
              if (j == 0 && i == 0 && a == c && b == d)
                sharedFirst += 1;

              if ((sharedCount - sharedFirst) >= ((minFoundHits - sharedFirst) * fraction))
                continue;
            }
            if ((sharedCount - sharedFirst) >= ((minFoundHits - sharedFirst) * fraction))
              continue;
          }

          //selection here - 11percent fraction of shared hits to label a duplicate
          if ((sharedCount - sharedFirst) >= ((minFoundHits - sharedFirst) * fraction)) {
            if (trk.score() > track2.score())
              track2.setDuplicateValue(true);
            else
              trk.setDuplicateValue(true);
          }
        }
      }  //end loop one over tracks

      remove_duplicates(tracks);
    }

cmssw_LoadHits_Begin()

void mkfit::StdSeq::cmssw_LoadHits_Begin	(	EventOfHits &	eoh,
		const std::vector< const HitVec *> &	orig_hitvectors
	)

Definition at line 31 of file MkStdSeqs.cc.

References mps_fire::i, MainPageGenerator::l, mkfit::EventOfHits::nLayers(), and mkfit::EventOfHits::reset().

Referenced by MkFitEventOfHitsProducer::produce().

                                                                                                  {
      eoh.reset();
      for (int i = 0; i < eoh.nLayers(); ++i) {
        auto &&l = eoh[i];
        l.beginRegistrationOfHits(*orig_hitvectors[l.is_pixel() ? 0 : 1]);
      }
    }

cmssw_LoadHits_End()

void mkfit::StdSeq::cmssw_LoadHits_End

(

EventOfHits &

eoh

)

Definition at line 47 of file MkStdSeqs.cc.

References mps_fire::i, MainPageGenerator::l, and mkfit::EventOfHits::nLayers().

Referenced by MkFitEventOfHitsProducer::produce().

                                              {
      for (int i = 0; i < eoh.nLayers(); ++i) {
        auto &&l = eoh[i];
        l.endRegistrationOfHits(false);
      }
    }

cmssw_Map_TrackHitIndices()

void mkfit::StdSeq::cmssw_Map_TrackHitIndices	(	const EventOfHits &	eoh,
		TrackVec &	seeds
	)

Definition at line 58 of file MkStdSeqs.cc.

References mps_fire::i, DetachedQuadStep_cff::seeds, and HLT_2023v12_cff::track.

                                                                            {
      for (auto &&track : seeds) {
        for (int i = 0; i < track.nTotalHits(); ++i) {
          const int hitidx = track.getHitIdx(i);
          const int hitlyr = track.getHitLyr(i);
          if (hitidx >= 0) {
            const auto &loh = eoh[hitlyr];
            track.setHitIdx(i, loh.getHitIndexFromOriginal(hitidx));
          }
        }
      }
    }

cmssw_ReMap_TrackHitIndices()

void mkfit::StdSeq::cmssw_ReMap_TrackHitIndices	(	const EventOfHits &	eoh,
		TrackVec &	out_tracks
	)

Definition at line 71 of file MkStdSeqs.cc.

References mps_fire::i, and HLT_2023v12_cff::track.

                                                                                   {
      for (auto &&track : out_tracks) {
        for (int i = 0; i < track.nTotalHits(); ++i) {
          const int hitidx = track.getHitIdx(i);
          const int hitlyr = track.getHitLyr(i);
          if (hitidx >= 0) {
            const auto &loh = eoh[hitlyr];
            track.setHitIdx(i, loh.getOriginalHitIndex(hitidx));
          }
        }
      }
    }

dump_simtracks()

void mkfit::StdSeq::dump_simtracks

(

Event *

event

)

Definition at line 55 of file MkStandaloneSeqs.cc.

References dprint, createfilelist::int, and HLT_2023v12_cff::track.

                                      {
      // Ripped out of MkBuilder::begin_event, ifdefed under DEBUG

      std::vector<Track> &simtracks = event->simTracks_;

      for (int itrack = 0; itrack < (int)simtracks.size(); ++itrack) {
        // bool debug = true;
        Track track = simtracks[itrack];
        // simtracks are initially written with label = index; uncomment in case tracks were edited
        // if (track.label() != itrack) {
        //   dprintf("Bad label for simtrack %d -- %d\n", itrack, track.label());
        // }

        dprint("MX - simtrack with nHits=" << track.nFoundHits() << " chi2=" << track.chi2() << " pT=" << track.pT()
                                           << " phi=" << track.momPhi() << " eta=" << track.momEta());
      }

      for (int itrack = 0; itrack < (int)simtracks.size(); ++itrack) {
        for (int ihit = 0; ihit < simtracks[itrack].nFoundHits(); ++ihit) {
          dprint("track #" << itrack << " hit #" << ihit
                           << " hit pos=" << simtracks[itrack].hitsVector(event->layerHits_)[ihit].position()
                           << " phi=" << simtracks[itrack].hitsVector(event->layerHits_)[ihit].phi());
        }
      }
    }

handle_duplicates()

void mkfit::StdSeq::handle_duplicates

(

Event *

)

Definition at line 33 of file MkStandaloneSeqs.cc.

                                    {
      /*
      // Mark tracks as duplicates; if within CMSSW, remove duplicate tracks from fit or candidate track collection
      if (Config::removeDuplicates) {
        if (Config::quality_val || Config::sim_val || Config::cmssw_val) {
          clean_duplicates(event->candidateTracks_);
          if (Config::backwardFit)
            clean_duplicates(event->fitTracks_);
        }
        // For the MEIF benchmarks and the stress tests, no validation flags are set so we will enter this block
        else {
          // Only care about the candidate tracks here; no need to run the duplicate removal on both candidate and fit tracks
          clean_duplicates(event->candidateTracks_);
        }
      }
      */
    }

loadDeads()

void mkfit::StdSeq::loadDeads	(	EventOfHits &	eoh,
		const std::vector< DeadVec > &	deadvectors
	)

Definition at line 21 of file MkStdSeqs.cc.

References deadvectors, and mkfit::EventOfHits::suckInDeads().

Referenced by mkfit::Shell::GoToEvent(), MkFitEventOfHitsProducer::produce(), and test_standard().

                                                                            {
      for (size_t il = 0; il < deadvectors.size(); il++) {
        eoh.suckInDeads(int(il), deadvectors[il]);
      }
    }

loadHitsAndBeamSpot()

void mkfit::StdSeq::loadHitsAndBeamSpot	(	Event &	ev,
		EventOfHits &	eoh
	)

Definition at line 20 of file MkStandaloneSeqs.cc.

References makeMEIFBenchmarkPlots::ev, hgcalTBTopologyTester_cfi::layers, mkfit::EventOfHits::reset(), mkfit::EventOfHits::setBeamSpot(), and mkfit::EventOfHits::suckInHits().

Referenced by mkfit::Shell::GoToEvent(), and test_standard().

                                                          {
      eoh.reset();

      // fill vector of hits in each layer
      // XXXXMT: Does it really makes sense to multi-thread this?
      tbb::parallel_for(tbb::blocked_range<int>(0, ev.layerHits_.size()), [&](const tbb::blocked_range<int> &layers) {
        for (int ilay = layers.begin(); ilay < layers.end(); ++ilay) {
          eoh.suckInHits(ilay, ev.layerHits_[ilay]);
        }
      });
      eoh.setBeamSpot(ev.beamSpot_);
    }

prep_cmsswtracks()

void mkfit::StdSeq::prep_cmsswtracks

(

Event *

event

)

Definition at line 373 of file MkStandaloneSeqs.cc.

References prep_reftracks().

Referenced by root_val().

{ prep_reftracks(event, event->cmsswTracks_, event->cmsswTracksExtra_, true); }

prep_recotracks()

void mkfit::StdSeq::prep_recotracks

(

Event *

event

)

Definition at line 280 of file MkStandaloneSeqs.cc.

References mkfit::Config::cmssw_val, prep_tracks(), mkfit::Config::sim_val, and mkfit::Config::sim_val_for_cmssw.

Referenced by root_val(), and root_val_dumb_cmssw().

                                       {
      // seed tracks extras always needed
      if (Config::sim_val || Config::sim_val_for_cmssw) {
        prep_tracks(event, event->seedTracks_, event->seedTracksExtra_, true);
      } else if (Config::cmssw_val)  // seed tracks are not validated, labels used for maps --> do NOT align index and labels!
      {
        prep_tracks(event, event->seedTracks_, event->seedTracksExtra_, false);
      }

      // make extras + align index == label() for candidate tracks
      prep_tracks(event, event->candidateTracks_, event->candidateTracksExtra_, true);
      prep_tracks(event, event->fitTracks_, event->fitTracksExtra_, true);
    }

prep_reftracks()

void mkfit::StdSeq::prep_reftracks	(	Event *	event,
		TrackVec &	tracks,
		TrackExtraVec &	extras,
		const bool	realigntracks
	)

Definition at line 375 of file MkStandaloneSeqs.cc.

References mkfit::Config::cmsSelMinLayers, prep_tracks(), HLT_2023v12_cff::track, and pwdgSkimBPark_cfi::tracks.

Referenced by prep_cmsswtracks(), and prep_simtracks().

                                                                                                         {
      prep_tracks(event, tracks, extras, realigntracks);

      // mark cmsswtracks as unfindable if too short
      for (auto &track : tracks) {
        const int nlyr = track.nUniqueLayers();
        if (nlyr < Config::cmsSelMinLayers)
          track.setNotFindable();
      }
    }

prep_simtracks()

void mkfit::StdSeq::prep_simtracks

(

Event *

event

)

Definition at line 294 of file MkStandaloneSeqs.cc.

References funct::abs(), submitPVResolutionJobs::count, spr::find(), heavyIonCSV_trainingSettings::idx, label, mkfit::Config::mtvLikeValidation, mkfit::Config::mtvRequireSeeds, prep_reftracks(), and mkfit::TrackBase::Signal.

Referenced by root_val_dumb_cmssw(), and mkfit::runBtpCe_MultiIter().

                                      {
      // First prep sim tracks to have hits sorted, then mark unfindable if too short
      prep_reftracks(event, event->simTracks_, event->simTracksExtra_, false);

      // Now, make sure sim track shares at least four hits with a single cmssw seed.
      // This ensures we factor out any weakness from CMSSW

      // First, make a make a map of [lyr][hit idx].vector(seed trk labels)
      LayIdxIDVecMapMap seedHitIDMap;
      std::map<int, int> labelNHitsMap;
      std::map<int, int> labelAlgoMap;
      std::map<int, std::vector<int>> labelSeedHitsMap;
      for (const auto &seedtrack : event->seedTracks_) {
        for (int ihit = 0; ihit < seedtrack.nTotalHits(); ihit++) {
          const auto lyr = seedtrack.getHitLyr(ihit);
          const auto idx = seedtrack.getHitIdx(ihit);

          if (lyr < 0 || idx < 0)
            continue;  // standard check
          seedHitIDMap[lyr][idx].push_back(seedtrack.label());
          labelSeedHitsMap[seedtrack.label()].push_back(lyr);
        }
        labelNHitsMap[seedtrack.label()] = seedtrack.nTotalHits();
        labelAlgoMap[seedtrack.label()] = seedtrack.algoint();
      }

      // Then, loop over sim tracks, and add up how many lyrs they possess of a single seed track
      unsigned int count = 0;
      for (auto &simtrack : event->simTracks_) {
        if (simtrack.isNotFindable())
          continue;  // skip ones we already know are bad
        TrkIDLaySetMap seedIDMap;
        for (int ihit = 0; ihit < simtrack.nTotalHits(); ihit++) {
          const auto lyr = simtrack.getHitLyr(ihit);
          const auto idx = simtrack.getHitIdx(ihit);

          if (lyr < 0 || idx < 0)
            continue;  // standard check

          if (!seedHitIDMap.count(lyr))
            continue;  // ensure seed hit map has at least one entry for this layer
          if (!seedHitIDMap.at(lyr).count(idx))
            continue;  // ensure seed hit map has at least one entry for this idx

          for (const auto label : seedHitIDMap.at(lyr).at(idx)) {
            const auto &seedLayers = labelSeedHitsMap[label];
            if (std::find(seedLayers.begin(), seedLayers.end(), lyr) != seedLayers.end())  //seed check moved here
              seedIDMap[label].emplace(lyr);
          }
        }

        // now see if one of the seedIDs matched has at least 4 hits!
        bool isSimSeed = false;
        for (const auto &seedIDpair : seedIDMap) {
          if ((int)seedIDpair.second.size() == labelNHitsMap[seedIDpair.first]) {
            isSimSeed = true;
            if (Config::mtvRequireSeeds)
              simtrack.setAlgoint(labelAlgoMap[seedIDpair.first]);
            if (Config::mtvRequireSeeds)
              event->simTracksExtra_[count].addAlgo(labelAlgoMap[seedIDpair.first]);
            //break;
          }
        }
        if (Config::mtvLikeValidation) {
          // Apply MTV selection criteria and then return
          if (simtrack.prodType() != Track::ProdType::Signal || simtrack.charge() == 0 || simtrack.posR() > 2.5 ||
              std::abs(simtrack.z()) > 30 || std::abs(simtrack.momEta()) > 3.0)
            simtrack.setNotFindable();
          else if (Config::mtvRequireSeeds && !isSimSeed)
            simtrack.setNotFindable();
        } else {
          // set findability based on bool isSimSeed
          if (!isSimSeed)
            simtrack.setNotFindable();
        }
        count++;
      }
    }

prep_tracks()

void mkfit::StdSeq::prep_tracks	(	Event *	event,
		TrackVec &	tracks,
		TrackExtraVec &	extras,
		const bool	realigntracks
	)

Definition at line 386 of file MkStandaloneSeqs.cc.

References mps_fire::i, label, and pwdgSkimBPark_cfi::tracks.

Referenced by prep_recotracks(), and prep_reftracks().

                                                                                                      {
      for (size_t i = 0; i < tracks.size(); i++) {
        extras.emplace_back(tracks[i].label());
      }
      if (realigntracks)
        event->validation_.alignTracks(tracks, extras, false);
    }

qfilter_n_hits()

template<class TRACK >

bool mkfit::StdSeq::qfilter_n_hits	(	const TRACK &	t,
		const MkJob &	j
	)

Definition at line 619 of file MkStdSeqs.cc.

References dqmiolumiharvest::j, and submitPVValidationJobs::t.

                                                        {
      int seedHits = t.getNSeedHits();
      int seedReduction = (seedHits <= 5) ? 2 : 3;
      return t.nFoundHits() - seedReduction >= j.params_cur().minHitsQF;
    }

qfilter_n_hits_pixseed()

template<class TRACK >

bool mkfit::StdSeq::qfilter_n_hits_pixseed	(	const TRACK &	t,
		const MkJob &	j
	)

Definition at line 627 of file MkStdSeqs.cc.

References dqmiolumiharvest::j, and submitPVValidationJobs::t.

                                                                {
      return t.nFoundHits() >= j.params_cur().minHitsQF;
    }

qfilter_n_layers()

template<class TRACK >

bool mkfit::StdSeq::qfilter_n_layers	(	const TRACK &	t,
		const MkJob &	j
	)

Definition at line 634 of file MkStdSeqs.cc.

References funct::abs(), MuonTCMETValueMapProducer_cff::d0_max, dqmiolumiharvest::j, submitPVValidationJobs::t, mkfit::BeamSpot::x, and mkfit::BeamSpot::y.

                                                          {
      const BeamSpot &bspot = j.m_beam_spot;
      const TrackerInfo &trk_inf = j.m_trk_info;
      int enhits = t.nHitsByTypeEncoded(trk_inf);
      int npixhits = t.nPixelDecoded(enhits);
      int enlyrs = t.nLayersByTypeEncoded(trk_inf);
      int npixlyrs = t.nPixelDecoded(enlyrs);
      int nmatlyrs = t.nTotMatchDecoded(enlyrs);
      int llyr = t.getLastFoundHitLyr();
      int lplyr = t.getLastFoundPixelHitLyr();
      float invpt = t.invpT();

      // based on fr and eff vs pt (convert to native invpt)
      float invptmin = 1.43;  // min 1/pT (=1/0.7) for full filter on (npixhits<=3 .or. npixlyrs<=3)
      float d0BS = t.d0BeamSpot(bspot.x, bspot.y);
      float d0_max = 0.1;  // 1 mm, max for somewhat prompt

      // next-to-outermost pixel layers (almost): BPIX3 or FPIX1
      bool endsInsidePix = (llyr == 2 || llyr == 18 || llyr == 45);
      // not last pixel layers: BPIX[123] or FPIX[12]
      bool lastInsidePix = ((0 <= lplyr && lplyr < 3) || (18 <= lplyr && lplyr < 20) || (45 <= lplyr && lplyr < 47));
      // reject short tracks missing last pixel layer except for prompt-looking
      return !(((npixhits <= 3 || npixlyrs <= 3) && endsInsidePix &&
                (invpt < invptmin || (invpt >= invptmin && std::abs(d0BS) > d0_max))) ||
               ((npixlyrs <= 3 && nmatlyrs <= 6) && lastInsidePix && llyr != lplyr && std::abs(d0BS) > d0_max));
    }

qfilter_nan_n_silly()

template<class TRACK >

bool mkfit::StdSeq::qfilter_nan_n_silly	(	const TRACK &	t,
		const MkJob &
	)

Definition at line 40 of file MkStdSeqs.h.

References submitPVValidationJobs::t.

                                                            {
      return !(t.hasNanNSillyValues());
    }

qfilter_pixelLessBkwd()

template<class TRACK >

bool mkfit::StdSeq::qfilter_pixelLessBkwd	(	const TRACK &	t,
		const MkJob &	j
	)

quality filter tuned for pixelLess iteration during backward search

Definition at line 696 of file MkStdSeqs.cc.

References funct::abs(), MuonTCMETValueMapProducer_cff::d0_max, dqmiolumiharvest::j, nHits, mkfit::Const::PIOver2, submitPVValidationJobs::t, mkfit::BeamSpot::x, and mkfit::BeamSpot::y.

                                                               {
      const BeamSpot &bspot = j.m_beam_spot;
      const TrackerInfo &tk_info = j.m_trk_info;
      float d0BS = t.d0BeamSpot(bspot.x, bspot.y);
      float d0_max = 0.1;  // 1 mm

      int encoded;
      encoded = t.nLayersByTypeEncoded(tk_info);
      int nLyrs = t.nTotMatchDecoded(encoded);
      encoded = t.nHitsByTypeEncoded(tk_info);
      int nHits = t.nTotMatchDecoded(encoded);

      // based on fr and eff vs pt and eta (convert to native invpt and theta)
      float invpt = t.invpT();
      float invptmin = 1.11;  // =1/0.9

      float thetasym = std::abs(t.theta() - Const::PIOver2);
      float thetasymmin_l = 0.80;  // -> |eta|=0.9
      float thetasymmin_h = 1.11;  // -> |eta|=1.45

      // reject too short or too displaced tracks
      return !(
          ((nLyrs <= 3 || nHits <= 3)) ||
          ((nLyrs <= 4 || nHits <= 4) && (invpt < invptmin || (thetasym > thetasymmin_l && std::abs(d0BS) > d0_max))) ||
          ((nLyrs <= 5 || nHits <= 5) && (invpt > invptmin && thetasym > thetasymmin_h && std::abs(d0BS) > d0_max)));
    }

qfilter_pixelLessFwd()

template<class TRACK >

bool mkfit::StdSeq::qfilter_pixelLessFwd	(	const TRACK &	t,
		const MkJob &	j
	)

quality filter tuned for pixelLess iteration during forward search

Definition at line 664 of file MkStdSeqs.cc.

References funct::abs(), MuonTCMETValueMapProducer_cff::d0_max, dqmiolumiharvest::j, nHits, mkfit::Const::PIOver2, submitPVValidationJobs::t, mkfit::BeamSpot::x, and mkfit::BeamSpot::y.

                                                              {
      const BeamSpot &bspot = j.m_beam_spot;
      const TrackerInfo &tk_info = j.m_trk_info;
      float d0BS = t.d0BeamSpot(bspot.x, bspot.y);
      float d0_max = 0.05;  // 0.5 mm, max for somewhat prompt

      int encoded;
      encoded = t.nLayersByTypeEncoded(tk_info);
      int nLyrs = t.nTotMatchDecoded(encoded);
      encoded = t.nHitsByTypeEncoded(tk_info);
      int nHits = t.nTotMatchDecoded(encoded);

      // to subtract stereo seed layers to count just r-phi seed layers (better pt err)
      int seedReduction = (t.getNSeedHits() <= 5) ? 2 : 3;

      // based on fr and eff vs pt and eta (convert to native invpt and theta)
      float invpt = t.invpT();
      float invptmin = 1.11;  // =1/0.9

      float thetasym = std::abs(t.theta() - Const::PIOver2);
      float thetasymmin = 1.11;  // -> |eta|=1.45

      // accept longer tracks, reject too short and displaced
      return (((t.nFoundHits() - seedReduction >= 4 && invpt < invptmin) ||
               (t.nFoundHits() - seedReduction >= 3 && invpt > invptmin && thetasym <= thetasymmin) ||
               (t.nFoundHits() - seedReduction >= 4 && invpt > invptmin && thetasym > thetasymmin)) &&
              !((nLyrs <= 4 || nHits <= 4) && std::abs(d0BS) > d0_max && invpt < invptmin));
    }

remove_duplicates()

void mkfit::StdSeq::remove_duplicates

(

TrackVec &

tracks

)

Definition at line 352 of file MkStdSeqs.cc.

References HLT_2023v12_cff::track, and pwdgSkimBPark_cfi::tracks.

Referenced by clean_duplicates(), clean_duplicates_sharedhits(), and clean_duplicates_sharedhits_pixelseed().

                                             {
      tracks.erase(std::remove_if(tracks.begin(), tracks.end(), [](auto track) { return track.getDuplicateValue(); }),
                   tracks.end());
    }

root_val()

void mkfit::StdSeq::root_val

(

Event *

event

)

Definition at line 260 of file MkStandaloneSeqs.cc.

References mkfit::Config::backwardFit, mkfit::Config::cmssw_val, prep_cmsswtracks(), prep_recotracks(), and score_tracks().

Referenced by mkfit::runBtpCe_MultiIter(), mkfit::runBuildingTestPlexBestHit(), mkfit::runBuildingTestPlexCloneEngine(), and mkfit::runBuildingTestPlexStandard().

                                {
      // score the tracks
      score_tracks(event->seedTracks_);
      score_tracks(event->candidateTracks_);

      // deal with fit tracks
      if (Config::backwardFit) {
        score_tracks(event->fitTracks_);
      } else
        event->fitTracks_ = event->candidateTracks_;

      // sort hits + make extras, align if needed
      prep_recotracks(event);
      if (Config::cmssw_val)
        prep_cmsswtracks(event);

      // validate
      event->validate();
    }

root_val_dumb_cmssw()

void mkfit::StdSeq::root_val_dumb_cmssw

(

Event *

event

)

Definition at line 239 of file MkStandaloneSeqs.cc.

References mkfit::Config::nItersCMSSW, prep_recotracks(), and prep_simtracks().

Referenced by mkfit::runBuildingTestPlexDumbCMSSW().

                                           {
      // get labels correct first
      event->relabel_bad_seedtracks();
      event->relabel_cmsswtracks_from_seeds();

      //collection cleaning
      if (Config::nItersCMSSW > 0)
        event->select_tracks_iter(Config::nItersCMSSW);

      // set the track collections to each other
      event->candidateTracks_ = event->cmsswTracks_;
      event->fitTracks_ = event->candidateTracks_;

      // prep the tracks + extras
      prep_simtracks(event);
      prep_recotracks(event);

      // validate
      event->validate();
    }

score_tracks()

void mkfit::StdSeq::score_tracks

(

TrackVec &

tracks

)

Definition at line 394 of file MkStandaloneSeqs.cc.

References mkfit::IterationConfig::get_track_scorer(), mkfit::getScoreCand(), HLT_2023v12_cff::track, and pwdgSkimBPark_cfi::tracks.

Referenced by root_val().

                                        {
      auto score_func = IterationConfig::get_track_scorer("default");
      for (auto &track : tracks) {
        track.setScore(getScoreCand(score_func, track));
      }
    }

track_print()

void mkfit::StdSeq::track_print	(	Event *	event,
		const Track &	t,
		const char *	pref
	)

Definition at line 81 of file MkStandaloneSeqs.cc.

References heavyIonCSV_trainingSettings::idx, mkfit::print(), submitPVValidationJobs::t, and hit::z.

                                                                     {
      printf("%s with q=%+i pT=%7.3f eta=% 7.3f nHits=%2d  label=%4d\nState:\n",
             pref,
             t.charge(),
             t.pT(),
             t.momEta(),
             t.nFoundHits(),
             t.label());

      print(t.state());

      printf("Hits:\n");
      for (int ih = 0; ih < t.nTotalHits(); ++ih) {
        int lyr = t.getHitLyr(ih);
        int idx = t.getHitIdx(ih);
        if (idx >= 0) {
          const Hit &hit = event->layerHits_[lyr][idx];
          printf("    hit %2d lyr=%2d idx=%4d pos r=%7.3f z=% 8.3f   mc_hit=%4d mc_trk=%4d\n",
                 ih,
                 lyr,
                 idx,
                 hit.r(),
                 hit.z(),
                 hit.mcHitID(),
                 hit.mcTrackID(event->simHitsInfo_));
        } else
          printf("    hit %2d        idx=%i\n", ih, t.getHitIdx(ih));
      }
    }

trackScoreDefault()

float mkfit::StdSeq::trackScoreDefault	(	const int	nfoundhits,
		const int	ntailholes,
		const int	noverlaphits,
		const int	nmisshits,
		const float	chi2,
		const float	pt,
		const bool	inFindCandidates
	)

Definition at line 740 of file MkStdSeqs.cc.

References nano_mu_local_reco_cff::chi2, f, SiStripPI::min, mkfit::Config::missingHitPenalty_, mkfit::Config::overlapHitBonus_, DiDispStaMuonMonitor_cfi::pt, offlineSlimmedPrimaryVertices_cfi::score, mkfit::Config::tailMissingHitPenalty_, mkfit::Config::validHitBonus_, and mkfit::Config::validHitSlope_.

                                                         {
      float maxBonus = 8.0;
      float bonus = Config::validHitSlope_ * nfoundhits + Config::validHitBonus_;
      float penalty = Config::missingHitPenalty_;
      float tailPenalty = Config::tailMissingHitPenalty_;
      float overlapBonus = Config::overlapHitBonus_;
      if (pt < 0.9) {
        penalty *= inFindCandidates ? 1.7f : 1.5f;
        bonus = std::min(bonus * (inFindCandidates ? 0.9f : 1.0f), maxBonus);
      }
      float score =
          bonus * nfoundhits + overlapBonus * noverlaphits - penalty * nmisshits - tailPenalty * ntailholes - chi2;
      return score;
    }