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 85 of file MkStdSeqs.cc.

                                                                                                          {
       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 355 of file MkStdSeqs.cc.

References funct::abs(), HLT_2024v14_cff::eta1, f, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, mkfit::Config::maxdEta, mkfit::Config::maxdPhi, mkfit::Config::maxdPt, mkfit::Config::maxdR, SiStripPI::min, mkfit::Config::minFracHitsShared, vertices_cff::ntracks, HLT_2024v14_cff::pt1, remove_duplicates(), mkfit::squashPhiMinimal(), HLT_2024v14_cff::track, DiMuonV_cfg::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 441 of file MkStdSeqs.cc.

References a, funct::abs(), b, mkfit::IterationConfig::dc_fracSharedHits, HLT_2024v14_cff::fraction, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, SiStripPI::min, vertices_cff::ntracks, isotrackApplyRegressor::range, remove_duplicates(), mkfit::squashPhiMinimal(), funct::tan(), DiMuonV_cfg::tracks, trk, 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 505 of file MkStdSeqs.cc.

References a, funct::abs(), b, DummyCfis::c, ztail::d, mkfit::IterationConfig::dc_drth_central, mkfit::IterationConfig::dc_drth_forward, mkfit::IterationConfig::dc_drth_obarrel, mkfit::IterationConfig::dc_fracSharedHits, HLT_2024v14_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(), DiMuonV_cfg::tracks, trk, 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 29 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 45 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 56 of file MkStdSeqs.cc.

References mps_fire::i, HLT_2024v14_cff::seeds, and HLT_2024v14_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 69 of file MkStdSeqs.cc.

References mps_fire::i, and HLT_2024v14_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_2024v14_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 19 of file MkStdSeqs.cc.

References mkfit::internal::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(), mkfit::EventOfHits::suckInHits(), and TBB_PARALLEL_FOR.

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 389 of file MkStandaloneSeqs.cc.

References prep_reftracks().

Referenced by root_val().

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

mkfit::StdSeq::prep_reftracks

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

Definition: MkStandaloneSeqs.cc:391

event

Definition: event.py:1

◆ prep_recotracks()

void mkfit::StdSeq::prep_recotracks ( Event * event )

Definition at line 296 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 391 of file MkStandaloneSeqs.cc.

References mkfit::Config::cmsSelMinLayers, prep_tracks(), HLT_2024v14_cff::track, and DiMuonV_cfg::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 310 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 402 of file MkStandaloneSeqs.cc.

References mps_fire::i, label, and DiMuonV_cfg::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 617 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 625 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 632 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 41 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 694 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 662 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 350 of file MkStdSeqs.cc.

References HLT_2024v14_cff::track, and DiMuonV_cfg::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 276 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 255 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 410 of file MkStandaloneSeqs.cc.

References mkfit::IterationConfig::get_track_scorer(), mkfit::getScoreCand(), HLT_2024v14_cff::track, and DiMuonV_cfg::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 738 of file MkStdSeqs.cc.

References isoTrack_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;
     }

Classes

Functions

Function Documentation

◆ clean_cms_seedtracks_iter()

◆ clean_duplicates()

◆ clean_duplicates_sharedhits()

◆ clean_duplicates_sharedhits_pixelseed()

◆ cmssw_LoadHits_Begin()

◆ cmssw_LoadHits_End()

◆ cmssw_Map_TrackHitIndices()

◆ cmssw_ReMap_TrackHitIndices()

◆ dump_simtracks()

◆ handle_duplicates()

◆ loadDeads()

◆ loadHitsAndBeamSpot()

◆ prep_cmsswtracks()

◆ prep_recotracks()

◆ prep_reftracks()

◆ prep_simtracks()

◆ prep_tracks()

◆ qfilter_n_hits()

◆ qfilter_n_hits_pixseed()

◆ qfilter_n_layers()

◆ qfilter_nan_n_silly()

◆ qfilter_pixelLessBkwd()

◆ qfilter_pixelLessFwd()

◆ remove_duplicates()

◆ root_val()

◆ root_val_dumb_cmssw()

◆ score_tracks()

◆ track_print()

◆ trackScoreDefault()