CMS 3D CMS Logo

List of all members | Public Types | Public Member Functions | Private Types | Private Attributes
mkfit::Shell Class Reference

#include <Shell.h>

Public Types

enum  SeedSelect_e { SS_UseAll = 0, SS_Label, SS_IndexPreCleaning, SS_IndexPostCleaning }
 

Public Member Functions

MkBuilderbuilder ()
 
bool CheckMkFitLayerPlanVsReferenceHits (const Track &mkft, const Track &reft, const std::string &name)
 
void Compare ()
 
EventOfHitseoh ()
 
Eventevent ()
 
void FillByLabelMaps_CkfBase ()
 
void GoToEvent (int eid)
 
int LabelFromHits (Track &t, bool replace, float good_frac)
 
void NextEvent (int skip=1)
 
void PrintIterations ()
 
void ProcessEvent (SeedSelect_e seed_select=SS_UseAll, int selected_seed=-1, int count=1)
 
void Run ()
 
void SelectIterationAlgo (int algo)
 
void SelectIterationIndex (int itidx)
 
void SetBackwardFit (bool b)
 
void SetCleanSeeds (bool b)
 
void SetDebug (bool b)
 
void SetRemoveDuplicates (bool b)
 
void SetUseDeadModules (bool b)
 
 Shell (std::vector< DeadVec > &dv, const std::string &in_file, int start_ev)
 
void Status ()
 

Private Types

using map_i = map_t::iterator
 
using map_t = std::map< int, Track * >
 

Private Attributes

bool m_backward_fit = true
 
MkBuilderm_builder = nullptr
 
std::map< int, Track * > m_ckf_map
 
bool m_clean_seeds = true
 
DataFilem_data_file = nullptr
 
std::vector< DeadVec > & m_deadvectors
 
EventOfHitsm_eoh = nullptr
 
Eventm_event = nullptr
 
int m_evs_in_file = -1
 
int m_it_index = 0
 
std::map< int, Track * > m_mkf_map
 
bool m_remove_duplicates = true
 
std::map< int, Track * > m_seed_map
 
TrackVec m_seeds
 
std::map< int, Track * > m_sim_map
 
TrackVec m_tracks
 

Detailed Description

Definition at line 16 of file Shell.h.

Member Typedef Documentation

◆ map_i

using mkfit::Shell::map_i = map_t::iterator
private

Definition at line 72 of file Shell.h.

◆ map_t

using mkfit::Shell::map_t = std::map<int, Track *>
private

Definition at line 71 of file Shell.h.

Member Enumeration Documentation

◆ SeedSelect_e

Enumerator
SS_UseAll 
SS_Label 
SS_IndexPreCleaning 
SS_IndexPostCleaning 

Definition at line 18 of file Shell.h.

Constructor & Destructor Documentation

◆ Shell()

mkfit::Shell::Shell ( std::vector< DeadVec > &  dv,
const std::string &  in_file,
int  start_ev 
)

Definition at line 40 of file Shell.cc.

References mkfit::Config::backwardFit, GoToEvent(), runGCPTkAlMap::in_file, m_backward_fit, m_builder, m_data_file, m_eoh, m_event, m_evs_in_file, mkfit::DataFile::openRead(), mkfit::Config::silent, and mkfit::Config::TrkInfo.

41  : m_deadvectors(dv)
42  {
43  m_eoh = new EventOfHits(Config::TrkInfo);
44  m_builder = new MkBuilder(Config::silent);
45 
47 
48  m_data_file = new DataFile;
50 
51  m_event = new Event(0, Config::TrkInfo.n_layers());
52  GoToEvent(start_ev);
53  }
int openRead(const std::string &fname, int expected_n_layers)
Definition: Event.cc:919
DataFile * m_data_file
Definition: Shell.h:58
MkBuilder * m_builder
Definition: Shell.h:61
std::vector< DeadVec > & m_deadvectors
Definition: Shell.h:57
EventOfHits * m_eoh
Definition: Shell.h:60
void GoToEvent(int eid)
Definition: Shell.cc:87
bool m_backward_fit
Definition: Shell.h:65
TrackerInfo TrkInfo
Event * m_event
Definition: Shell.h:59
int m_evs_in_file
Definition: Shell.h:62

Member Function Documentation

◆ builder()

MkBuilder* mkfit::Shell::builder ( )
inline

Definition at line 41 of file Shell.h.

References m_builder.

Referenced by ProcessEvent().

41 { return m_builder; }
MkBuilder * m_builder
Definition: Shell.h:61

◆ CheckMkFitLayerPlanVsReferenceHits()

bool mkfit::Shell::CheckMkFitLayerPlanVsReferenceHits ( const Track mkft,
const Track reft,
const std::string &  name 
)

Definition at line 425 of file Shell.cc.

References mkfit::TrackBase::getEtaRegion(), mkfit::Track::getHitOnTrack(), mkfit::Config::ItrInfo, mkfit::TrackBase::label(), m_it_index, mkfit::IterationConfig::m_steering_params, Skims_PA_cff::name, mkfit::Track::nTotalHits(), runTheMatrix::ret, and x.

Referenced by Compare().

425  {
426  // Check if all hit-layers of a reference track reft are in the mkfit layer plan.
427  // Returns true if all layers are in the plan.
428  // String name is printed in front of label, expected to be SIMK or CKF.
429  const IterationConfig &itconf = Config::ItrInfo[m_it_index];
430  auto lp = itconf.m_steering_params[ mkft.getEtaRegion() ].m_layer_plan;
431  bool ret = true;
432  for (int hi = 0; hi < reft.nTotalHits(); ++hi) {
433  auto hot = reft.getHitOnTrack(hi);
434  if (std::find_if(lp.begin(), lp.end(), [=](auto &x){ return x.m_layer == hot.layer; }) == lp.end())
435  {
436  printf("CheckMkfLayerPlanVsCkfHits: layer %d not in layer plan for region %d, %s label=%d\n",
437  hot.layer, mkft.getEtaRegion(), name.c_str(), reft.label());
438  ret = false;
439  }
440  }
441  return ret;
442  }
ret
prodAgent to be discontinued
Definition: EPCuts.h:4
IterationsInfo ItrInfo
int m_it_index
Definition: Shell.h:63
float x

◆ Compare()

void mkfit::Shell::Compare ( )

Definition at line 448 of file Shell.cc.

References mkfit::TrackBase::algoint_to_cstr(), CheckMkFitLayerPlanVsReferenceHits(), makeMEIFBenchmarkPlots::ev, FillByLabelMaps_CkfBase(), mkfit::IterationConfig::get_seed_partitioner(), mkfit::HitOnTrack::index, mkfit::Config::ItrInfo, MainPageGenerator::l, mkfit::HitOnTrack::layer, m_ckf_map, m_eoh, m_event, m_it_index, m_mkf_map, m_seed_map, m_seeds, m_sim_map, mkfit::IterationConfig::m_track_algorithm, mkfit::print(), singleTopDQM_cfi::select, mkfit::Config::TrkInfo, and funct::void.

448  {
449  Event &ev = *m_event;
450  const IterationConfig &itconf = Config::ItrInfo[m_it_index];
451 
453 
454  printf("------------------------------------------------------\n");
455 
456  const bool print_all_def = false;
457  int mkf_cnt=0, less_hits=0, more_hits=0;
458 
459  // TOBTEC: look for rec-seeds with hits in tob1 and 2 only.
460  int tot_cnt = 0, no_mkf_cnt = 0;
461 
462  for (auto& [l, simt_ptr]: m_sim_map)
463  {
464  auto &simt = * simt_ptr;
465  auto &ckft = * m_ckf_map[l];
466  auto mi = m_mkf_map.find(l);
467 
468  bool print_all = print_all_def;
469 
470  // TOBTEC: look for rec-seeds with hits in tob1 and 2 only.
471  bool select = true;
472  {
473  auto &ckf_seed = ev.seedTracks_[ckft.label()];
474  for (int hi = 0; hi < ckf_seed.nTotalHits(); ++hi) {
475  const HitOnTrack hot = ckf_seed.getHitOnTrack(hi);
476  if (hot.index >= 0 && (hot.layer < 10 || hot.layer > 13)) {
477  select = false;
478  break;
479  }
480  }
481  }
482  if ( ! select) continue;
483 
484  ++tot_cnt;
485  //print_all = true;
486 
487  if (mi != m_mkf_map.end())
488  {
489  auto &mkft = * mi->second;
490  mkf_cnt++;
491  if (mkft.nFoundHits() < ckft.nFoundHits()) ++less_hits;
492  if (mkft.nFoundHits() > ckft.nFoundHits()) ++more_hits;
493 
494  CheckMkFitLayerPlanVsReferenceHits(mkft, ckft, "CKF");
495  // CheckMkFitLayerPlanVsReferenceHits(mkft, simt, "SIM");
496 
497  (void) print_all;
498  if (/* itconf.m_track_algorithm == 10 ||*/ print_all) {
499  // ckf label is wrong when validation is on (even quality val) for mixedTriplet, pixelless and tobtec
500  // as seed tracks get removed for non-mkfit iterations and indices from rec-tracks are no longer valid.
501  auto &ckf_seed = ev.seedTracks_[ckft.label()];
502  auto &mkf_seed = m_seeds[mkft.label()];
503  print("ckf ", 0, ckft, ev);
504  print("mkfit", 0, mkft, ev);
505  print("sim ", 0, simt, ev);
506  print("ckf seed", 0, ckf_seed, ev);
507  print("mkf seed", 0, mkf_seed, ev);
508  printf("------------------------------------------------------\n");
509 
510  TrackVec ssss;
511  ssss.push_back(mkf_seed);
512 
513  IterationSeedPartition pppp(1);
514  IterationConfig::get_seed_partitioner("phase1:1:debug")(Config::TrkInfo, ssss, *m_eoh, pppp);
515 
516  printf("------------------------------------------------------\n");
517  printf("\n");
518  }
519  }
520  else
521  {
522  printf("\n!!!!! No mkfit track with this label.\n\n");
523  ++no_mkf_cnt;
524 
525  auto &ckf_seed = ev.seedTracks_[ckft.label()];
526  print("ckf ", 0, ckft, ev);
527  print("sim ", 0, simt, ev);
528  print("ckf seed", 0, ckf_seed, ev);
529  auto smi = m_seed_map.find(l);
530  if (smi != m_seed_map.end())
531  print("seed with matching label", 0, *smi->second, ev);
532  printf("------------------------------------------------------\n");
533  }
534  }
535 
536  printf("mkFit found %d, matching_label=%d, less_hits=%d, more_hits=%d [algo=%d (%s)]\n",
537  (int) ev.fitTracks_.size(), mkf_cnt, less_hits, more_hits,
538  itconf.m_track_algorithm, TrackBase::algoint_to_cstr(itconf.m_track_algorithm));
539 
540  if (tot_cnt > 0) {
541  printf("\ntobtec tob1/2 tot=%d no_mkf=%d (%f%%)\n",
542  tot_cnt, no_mkf_cnt, 100.0 * no_mkf_cnt / tot_cnt);
543  } else {
544  printf("\nNo CKF tracks with seed hits in TOB1/2 found (need iteration idx 8, TobTec?)\n");
545  }
546 
547  printf("-------------------------------------------------------------------------------------------\n");
548  printf("-------------------------------------------------------------------------------------------\n");
549  printf("\n");
550  }
std::map< int, Track * > m_sim_map
Definition: Shell.h:74
TrackVec m_seeds
Definition: Shell.h:68
std::map< int, Track * > m_mkf_map
Definition: Shell.h:74
bool CheckMkFitLayerPlanVsReferenceHits(const Track &mkft, const Track &reft, const std::string &name)
Definition: Shell.cc:425
TEMPL(T2) struct Divides void
Definition: Factorize.h:24
void FillByLabelMaps_CkfBase()
Definition: Shell.cc:360
EventOfHits * m_eoh
Definition: Shell.h:60
Definition: EPCuts.h:4
static partition_seeds_func get_seed_partitioner(const std::string &name)
TrackerInfo TrkInfo
IterationsInfo ItrInfo
static const char * algoint_to_cstr(int algo)
Definition: Track.cc:331
std::vector< Track > TrackVec
void print(std::string_view label, const MeasurementState &s)
Definition: Hit.cc:8
Event * m_event
Definition: Shell.h:59
int m_it_index
Definition: Shell.h:63
std::map< int, Track * > m_ckf_map
Definition: Shell.h:74
std::map< int, Track * > m_seed_map
Definition: Shell.h:74

◆ eoh()

EventOfHits* mkfit::Shell::eoh ( )
inline

Definition at line 40 of file Shell.h.

References m_eoh.

Referenced by ProcessEvent().

40 { return m_eoh; }
EventOfHits * m_eoh
Definition: Shell.h:60

◆ event()

Event* mkfit::Shell::event ( )
inline

Definition at line 39 of file Shell.h.

References m_event.

39 { return m_event; }
Event * m_event
Definition: Shell.h:59

◆ FillByLabelMaps_CkfBase()

void mkfit::Shell::FillByLabelMaps_CkfBase ( )

Definition at line 360 of file Shell.cc.

References mkfit::TrackBase::algoint_to_cstr(), makeMEIFBenchmarkPlots::ev, createfilelist::int, mkfit::Config::ItrInfo, label, LabelFromHits(), m_ckf_map, m_event, m_it_index, m_mkf_map, m_seed_map, m_seeds, m_sim_map, m_tracks, and submitPVValidationJobs::t.

Referenced by Compare().

360  {
361  Event &ev = *m_event;
362  const int track_algo = Config::ItrInfo[m_it_index].m_track_algorithm;
363 
364  m_ckf_map.clear();
365  m_sim_map.clear();
366  m_seed_map.clear();
367  m_mkf_map.clear();
368 
369  // Pick ckf tracks with right algo and a good label.
370  int rec_algo_match = 0;
371  for (auto &t : ev.cmsswTracks_) {
372  if (t.algoint() != track_algo)
373  continue;
374  ++rec_algo_match;
375  int label = LabelFromHits(t, false, 0.5);
376  if (label >= 0) {
377  m_ckf_map.insert(std::make_pair(label, &t));
378  }
379  }
380 
381  // Pick sim tracks with labels found by ckf.
382  for (auto &t : ev.simTracks_) {
383  if (t.label() >= 0 && m_ckf_map.find(t.label()) != m_ckf_map.end()) {
384  m_sim_map.insert(std::make_pair(t.label(), &t));
385  }
386  }
387 
388  // Pick seeds with right algo and a label found by ckf.
389  for (auto &t : ev.seedTracks_) {
390  if (t.algoint() == track_algo && t.label() >= 0 && m_ckf_map.find(t.label()) != m_ckf_map.end()) {
391  m_seed_map.insert(std::make_pair(t.label(), &t));
392  }
393  }
394  // Some seeds seem to be labeled -1, try fixing when not otherwise found.
395  for (auto &t : ev.seedTracks_) {
396  if (t.algoint() == track_algo && t.label() == -1) {
397  int lab = LabelFromHits(t, true, 0.5);
398  if (lab >= 0 && m_seed_map.find(lab) == m_seed_map.end()) {
399  if (m_ckf_map.find(lab) != m_ckf_map.end()) {
400  m_seed_map.insert(std::make_pair(t.label(), &t));
401  printf("Saved seed with label -1 -> %d\n", lab);
402  }
403  }
404  }
405  }
406 
407  // Pick mkfit tracks, label by
408  for (auto &t : m_tracks) {
409  int label = LabelFromHits(t, false, 0.5);
410  if (label >= 0) {
411  m_mkf_map.insert(std::make_pair(label, &t));
412  }
413  }
414 
415  printf("Shell::FillByLabelMaps reporting tracks with label >= 0, algo=%d (%s): "
416  "ckf: %d of %d (same algo=%d)), sim: %d of %d, seed: %d of %d, mkfit: %d w/label of %d\n",
417  track_algo, TrackBase::algoint_to_cstr(track_algo),
418  (int) m_ckf_map.size(), (int) ev.cmsswTracks_.size(), rec_algo_match,
419  (int) m_sim_map.size(), (int) ev.simTracks_.size(),
420  (int) m_seed_map.size(), (int) m_seeds.size(),
421  (int) m_mkf_map.size(), (int) m_tracks.size()
422  );
423  }
std::map< int, Track * > m_sim_map
Definition: Shell.h:74
TrackVec m_seeds
Definition: Shell.h:68
std::map< int, Track * > m_mkf_map
Definition: Shell.h:74
char const * label
IterationsInfo ItrInfo
static const char * algoint_to_cstr(int algo)
Definition: Track.cc:331
TrackVec m_tracks
Definition: Shell.h:69
Event * m_event
Definition: Shell.h:59
int m_it_index
Definition: Shell.h:63
int LabelFromHits(Track &t, bool replace, float good_frac)
Definition: Shell.cc:333
std::map< int, Track * > m_ckf_map
Definition: Shell.h:74
std::map< int, Track * > m_seed_map
Definition: Shell.h:74

◆ GoToEvent()

void mkfit::Shell::GoToEvent ( int  eid)

Definition at line 87 of file Shell.cc.

References runTauDisplay::eid, mkfit::Event::evtID(), mkfit::StdSeq::loadDeads(), mkfit::StdSeq::loadHitsAndBeamSpot(), m_data_file, m_deadvectors, m_eoh, m_event, m_evs_in_file, mkfit::Event::read_in(), mkfit::Event::reset(), mkfit::DataFile::rewind(), mkfit::DataFile::skipNEvents(), submitPVResolutionJobs::stderr, and mkfit::Config::useDeadModules.

Referenced by NextEvent(), and Shell().

87  {
88  if (eid < 1) {
89  fprintf(stderr, "Requested event %d is less than 1 -- 1 is the first event, %d is total number of events in file\n",
91  throw std::runtime_error("event out of range");
92  }
93  if (eid > m_evs_in_file) {
94  fprintf(stderr, "Requested event %d is grater than total number of events in file %d\n",
96  throw std::runtime_error("event out of range");
97  }
98 
99  int pos = m_event->evtID();
100  if (eid > pos) {
101  m_data_file->skipNEvents(eid - pos - 1);
102  } else {
103  m_data_file->rewind();
105  }
106  m_event->reset(eid);
111  }
112 
113  printf("At event %d\n", eid);
114  }
void rewind()
Definition: Event.cc:1007
void reset(int evtID)
Definition: Event.cc:33
DataFile * m_data_file
Definition: Shell.h:58
int evtID() const
Definition: Event.h:23
std::vector< DeadVec > & m_deadvectors
Definition: Shell.h:57
void loadHitsAndBeamSpot(Event &ev, EventOfHits &eoh)
void skipNEvents(int n_to_skip)
Definition: Event.cc:1034
EventOfHits * m_eoh
Definition: Shell.h:60
void loadDeads(EventOfHits &eoh, const std::vector< DeadVec > &deadvectors)
Definition: MkStdSeqs.cc:21
Event * m_event
Definition: Shell.h:59
int m_evs_in_file
Definition: Shell.h:62
void read_in(DataFile &data_file, FILE *in_fp=0)
Definition: Event.cc:207

◆ LabelFromHits()

int mkfit::Shell::LabelFromHits ( Track t,
bool  replace,
float  good_frac 
)

Definition at line 333 of file Shell.cc.

References h, mkfit::Event::layerHits_, m_event, python.rootplot.root2matplotlib::replace(), mkfit::Event::simHitsInfo_, summarizeEdmComparisonLogfiles::success, submitPVValidationJobs::t, and x.

Referenced by FillByLabelMaps_CkfBase().

333  {
334  std::map<int, int> lab_cnt;
335  for (int hi = 0; hi < t.nTotalHits(); ++hi) {
336  auto hot = t.getHitOnTrack(hi);
337  if (hot.index < 0)
338  continue;
339  const Hit &h = m_event->layerHits_[hot.layer][hot.index];
340  int hl = m_event->simHitsInfo_[h.mcHitID()].mcTrackID_;
341  if (hl >= 0)
342  ++lab_cnt[hl];
343  }
344  int max_c = -1, max_l = -1;
345  for (auto& x : lab_cnt) {
346  if (x.second > max_c) {
347  max_l = x.first;
348  max_c = x.second;
349  }
350  }
351  bool success = max_c >= good_frac * t.nFoundHits();
352  int relabel = success ? max_l : -1;
353  // printf("found_hits=%d, best_lab %d (%d hits), existing label=%d (replace flag=%s)\n",
354  // t.nFoundHits(), max_l, max_c, t.label(), b2a(replace));
355  if (replace)
356  t.setLabel(relabel);
357  return relabel;
358  }
def replace(string, replacements)
Definition: EPCuts.h:4
MCHitInfoVec simHitsInfo_
Definition: Event.h:72
std::vector< HitVec > layerHits_
Definition: Event.h:70
Event * m_event
Definition: Shell.h:59
float x
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4

◆ NextEvent()

void mkfit::Shell::NextEvent ( int  skip = 1)

Definition at line 116 of file Shell.cc.

References mkfit::Event::evtID(), GoToEvent(), m_event, and optionsL1T::skip.

116  {
117  GoToEvent(m_event->evtID() + skip);
118  }
int evtID() const
Definition: Event.h:23
void GoToEvent(int eid)
Definition: Shell.cc:87
Event * m_event
Definition: Shell.h:59

◆ PrintIterations()

void mkfit::Shell::PrintIterations ( )

Definition at line 302 of file Shell.cc.

References mkfit::TrackBase::algoint_to_cstr(), hltPFPuppi_cfi::algos, mps_fire::i, and m_it_index.

302  {
303  printf("Shell::PrintIterations selected index = %d, %d iterations hardcoded as\n",
304  m_it_index, n_algos);
305  for (int i = 0; i < n_algos; ++i)
306  printf("%d %2d %s\n", i, algos[i], TrackBase::algoint_to_cstr(algos[i]));
307  }
static const char * algoint_to_cstr(int algo)
Definition: Track.cc:331
int m_it_index
Definition: Shell.h:63

◆ ProcessEvent()

void mkfit::Shell::ProcessEvent ( SeedSelect_e  seed_select = SS_UseAll,
int  selected_seed = -1,
int  count = 1 
)

Definition at line 120 of file Shell.cc.

References mkfit::MkBuilder::backwardFit(), mkfit::MkBuilder::begin_event(), mkfit::MkBuilder::beginBkwSearch(), builder(), mkfit::MkBuilder::compactifyHitStorageForBestCand(), submitPVResolutionJobs::count, mkfit::MkBuilder::end_event(), mkfit::MkBuilder::endBkwSearch(), eoh(), mkfit::MkBuilder::export_best_comb_cands(), mkfit::Event::fill_hitmask_bool_vectors(), mkfit::MkBuilder::filter_comb_cands(), mkfit::MkBuilder::find_tracks_load_seeds(), mkfit::MkBuilder::findTracksCloneEngine(), mps_fire::i, createfilelist::int, mkfit::SteeringParams::IT_BkwSearch, mkfit::Config::ItrInfo, mkfit::IterationConfig::m_backward_drop_seed_hits, m_backward_fit, mkfit::IterationConfig::m_backward_fit_min_hits, mkfit::IterationConfig::m_backward_search, m_builder, m_clean_seeds, mkfit::IterationConfig::m_duplicate_cleaner, m_eoh, m_event, m_it_index, mkfit::IterationMaskIfc::m_mask_vector, mkfit::IterationConfig::m_post_bkfit_filter, mkfit::IterationConfig::m_pre_bkfit_filter, m_remove_duplicates, mkfit::IterationConfig::m_requires_seed_hit_sorting, mkfit::IterationConfig::m_seed_cleaner, m_seeds, mkfit::IterationConfig::m_track_algorithm, m_tracks, mkfit::MkBuilder::ref_eocc(), mkfit::EventOfHits::refBeamSpot(), mkfit::Event::resetCurrentSeedTracks(), alignCSCRings::s, mkfit::MkBuilder::seed_post_cleaning(), HLT_2024v14_cff::seeds, mkfit::Event::seedTracks_, mkfit::Event::setCurrentSeedTracks(), mkfit::EventOfCombCandidates::size(), SS_IndexPostCleaning, SS_IndexPreCleaning, SS_Label, SS_UseAll, and mkfit::Config::TrkInfo.

120  {
121  // count is only used for SS_IndexPreCleaning and SS_IndexPostCleaning.
122  // There are no checks for upper bounds, ie, if requested seeds beyond the first one exist.
123 
124  const IterationConfig &itconf = Config::ItrInfo[m_it_index];
125  IterationMaskIfc mask_ifc;
126  m_event->fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
127 
128  m_seeds.clear();
129  m_tracks.clear();
130 
131  {
132  int n_algo = 0; // seeds are grouped by algo
133  for (auto &s : m_event->seedTracks_) {
134  if (s.algoint() == itconf.m_track_algorithm) {
135  if (seed_select == SS_UseAll || seed_select == SS_IndexPostCleaning) {
136  m_seeds.push_back(s);
137  } else if (seed_select == SS_Label && s.label() == selected_seed) {
138  m_seeds.push_back(s);
139  break;
140  } else if (seed_select == SS_IndexPreCleaning && n_algo >= selected_seed) {
141  m_seeds.push_back(s);
142  if (--count <= 0)
143  break;
144  }
145  ++n_algo;
146  } else if (n_algo > 0)
147  break;
148  }
149  }
150 
151  printf("Shell::ProcessEvent running over %d seeds\n", (int) m_seeds.size());
152 
153  // Equivalent to run_OneIteration(...) without MkBuilder::release_memory().
154  // If seed_select == SS_IndexPostCleaning the given seed is picked after cleaning.
155  {
156  const TrackerInfo &trackerInfo = Config::TrkInfo;
157  const EventOfHits &eoh = *m_eoh;
158  const IterationMaskIfcBase &it_mask_ifc = mask_ifc;
159  MkBuilder &builder = *m_builder;
161  TrackVec &out_tracks = m_tracks;
162  bool do_seed_clean = m_clean_seeds;
163  bool do_backward_fit = m_backward_fit;
164  bool do_remove_duplicates = m_remove_duplicates;
165 
166  MkJob job({trackerInfo, itconf, eoh, eoh.refBeamSpot(), &it_mask_ifc});
167 
168  builder.begin_event(&job, m_event, __func__);
169 
170  // Seed cleaning not done on all iterations.
171  do_seed_clean = m_clean_seeds && itconf.m_seed_cleaner;
172 
173  if (do_seed_clean)
174  itconf.m_seed_cleaner(seeds, itconf, eoh.refBeamSpot());
175 
176  // Check nans in seeds -- this should not be needed when Slava fixes
177  // the track parameter coordinate transformation.
179 
180  if (seed_select == SS_IndexPostCleaning) {
181  if (selected_seed >= 0 && selected_seed < (int)seeds.size()) {
182  for (int i = 0; i < count; ++i)
183  seeds[i] = seeds[selected_seed + i];
184  seeds.resize(count);
185  } else {
186  seeds.clear();
187  }
188  }
189 
190  if (seeds.empty()) {
191  if (seed_select != SS_UseAll)
192  printf("Shell::ProcessEvent requested seed not found among seeds of the selected iteration.\n");
193  else
194  printf("Shell::ProcessEvent no seeds found.\n");
195  return;
196  }
197 
198  if (itconf.m_requires_seed_hit_sorting) {
199  for (auto &s : seeds)
200  s.sortHitsByLayer(); // sort seed hits for the matched hits (I hope it works here)
201  }
202 
204 
205  builder.find_tracks_load_seeds(seeds, do_seed_clean);
206 
208 
209  printf("Shell::ProcessEvent post fwd search: %d comb-cands\n", builder.ref_eocc().size());
210 
211  // Pre backward-fit filtering.
212  filter_candidates_func pre_filter;
213  if (do_backward_fit && itconf.m_pre_bkfit_filter)
214  pre_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
215  return itconf.m_pre_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
216  };
217  else if (itconf.m_pre_bkfit_filter)
218  pre_filter = itconf.m_pre_bkfit_filter;
219  else if (do_backward_fit)
220  pre_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
221  // pre_filter can be null if we are not doing backward fit as nan_n_silly will be run below.
222  if (pre_filter)
223  builder.filter_comb_cands(pre_filter, true);
224 
225  printf("Shell::ProcessEvent post pre-bkf-filter (%s) and nan-filter (%s) filter: %d comb-cands\n",
226  b2a(bool(itconf.m_pre_bkfit_filter)), b2a(do_backward_fit), builder.ref_eocc().size());
227 
228  job.switch_to_backward();
229 
230  if (do_backward_fit) {
231  if (itconf.m_backward_search) {
232  builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);
233  }
234 
236 
237  if (itconf.m_backward_search) {
240  }
241 
242  printf("Shell::ProcessEvent post backward fit / search: %d comb-cands\n", builder.ref_eocc().size());
243  }
244 
245  // Post backward-fit filtering.
246  filter_candidates_func post_filter;
247  if (do_backward_fit && itconf.m_post_bkfit_filter)
248  post_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
249  return itconf.m_post_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
250  };
251  else
252  post_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
253  // post_filter is always at least doing nan_n_silly filter.
254  builder.filter_comb_cands(post_filter, true);
255 
256  printf("Shell::ProcessEvent post post-bkf-filter (%s) and nan-filter (true): %d comb-cands\n",
257  b2a(do_backward_fit && itconf.m_post_bkfit_filter), builder.ref_eocc().size());
258 
259  if (do_backward_fit && itconf.m_backward_search)
261 
262  builder.export_best_comb_cands(out_tracks, true);
263 
264  if (do_remove_duplicates && itconf.m_duplicate_cleaner) {
265  itconf.m_duplicate_cleaner(out_tracks, itconf);
266  }
267 
268  printf("Shell::ProcessEvent post remove-duplicates: %d comb-cands\n", (int) out_tracks.size());
269 
271 
272  builder.end_event();
273  }
274 
275  printf("Shell::ProcessEvent found %d tracks, number of seeds at end %d\n",
276  (int) m_tracks.size(), (int) m_seeds.size());
277  }
const EventOfCombCandidates & ref_eocc() const
Definition: MkBuilder.h:74
TrackVec m_seeds
Definition: Shell.h:68
const BeamSpot & refBeamSpot() const
bool m_remove_duplicates
Definition: Shell.h:66
void compactifyHitStorageForBestCand(bool remove_seed_hits, int backward_fit_min_hits)
Definition: MkBuilder.h:63
TrackVec seedTracks_
Definition: Event.h:74
void findTracksCloneEngine(SteeringParams::IterationType_e iteration_dir=SteeringParams::IT_FwdSearch)
Definition: MkBuilder.cc:939
bool m_clean_seeds
Definition: Shell.h:64
void begin_event(MkJob *job, Event *ev, const char *build_type)
Definition: MkBuilder.cc:201
void resetCurrentSeedTracks()
Definition: Event.cc:910
EventOfHits * eoh()
Definition: Shell.h:40
MkBuilder * m_builder
Definition: Shell.h:61
std::function< filter_candidates_cf > filter_candidates_func
Definition: FunctionTypes.h:28
EventOfHits * m_eoh
Definition: Shell.h:60
void find_tracks_load_seeds(const TrackVec &in_seeds, const bool seeds_sorted)
Definition: MkBuilder.cc:616
void setCurrentSeedTracks(const TrackVec &seeds)
Definition: Event.cc:865
bool m_backward_fit
Definition: Shell.h:65
TrackerInfo TrkInfo
void seed_post_cleaning(TrackVec &tv)
Definition: MkBuilder.cc:414
void fill_hitmask_bool_vectors(int track_algo, std::vector< std::vector< bool >> &layer_masks)
Definition: Event.cc:819
IterationsInfo ItrInfo
MkBuilder * builder()
Definition: Shell.h:41
int filter_comb_cands(filter_candidates_func filter, bool attempt_all_cands)
Definition: MkBuilder.cc:308
TrackVec m_tracks
Definition: Shell.h:69
std::vector< Track > TrackVec
void beginBkwSearch()
Definition: MkBuilder.h:67
void export_best_comb_cands(TrackVec &out_vec, bool remove_missing_hits=false)
Definition: MkBuilder.cc:391
Event * m_event
Definition: Shell.h:59
int m_it_index
Definition: Shell.h:63
void endBkwSearch()
Definition: MkBuilder.h:68

◆ Run()

void mkfit::Shell::Run ( )

Definition at line 55 of file Shell.cc.

References dir2webdir::argc, GCPpyPlots::argv, visDQMUpload::buf, and beamvalidation::exit().

55  {
56 #ifndef NO_ROOT
57  std::vector<const char *> argv = { "mkFit", "-l" };
58  int argc = argv.size();
59  TRint rint("mkFit-shell", &argc, const_cast<char**>(argv.data()));
60 
61  char buf[256];
62  sprintf(buf, "mkfit::Shell &s = * (mkfit::Shell*) %p;", this);
63  gROOT->ProcessLine(buf);
64  printf("Shell &s variable is set\n");
65 
66  rint.Run(true);
67  printf("Shell::Run finished\n");
68 #else
69  printf("Shell::Run() no root, we rot -- erroring out. Recompile with WITH_ROOT=1\n");
70  exit(1);
71 #endif
72  }
def exit(msg="")

◆ SelectIterationAlgo()

void mkfit::Shell::SelectIterationAlgo ( int  algo)

Definition at line 291 of file Shell.cc.

References hltPFPuppi_cfi::algos, mps_fire::i, m_it_index, and submitPVResolutionJobs::stderr.

291  {
292  for (int i = 0; i < n_algos; ++i) {
293  if (algos[i] == algo) {
294  m_it_index = i;
295  return;
296  }
297  }
298  fprintf(stderr, "Requested algo %d not found", algo);
299  throw std::runtime_error("algo not found");
300  }
int m_it_index
Definition: Shell.h:63

◆ SelectIterationIndex()

void mkfit::Shell::SelectIterationIndex ( int  itidx)

Definition at line 283 of file Shell.cc.

References m_it_index, and submitPVResolutionJobs::stderr.

283  {
284  if (itidx < 0 || itidx >= n_algos) {
285  fprintf(stderr, "Requested iteration index out of range [%d, %d)", 0, n_algos);
286  throw std::runtime_error("iteration index out of range");
287  }
288  m_it_index = itidx;
289  }
int m_it_index
Definition: Shell.h:63

◆ SetBackwardFit()

void mkfit::Shell::SetBackwardFit ( bool  b)

Definition at line 315 of file Shell.cc.

References b, and m_backward_fit.

315 { m_backward_fit = b; }
bool m_backward_fit
Definition: Shell.h:65
double b
Definition: hdecay.h:120

◆ SetCleanSeeds()

void mkfit::Shell::SetCleanSeeds ( bool  b)

Definition at line 314 of file Shell.cc.

References b, and m_clean_seeds.

314 { m_clean_seeds = b; }
bool m_clean_seeds
Definition: Shell.h:64
double b
Definition: hdecay.h:120

◆ SetDebug()

void mkfit::Shell::SetDebug ( bool  b)

Definition at line 313 of file Shell.cc.

References b, and mkfit::g_debug.

313 { g_debug = b; }
bool g_debug
Definition: Debug.cc:2
double b
Definition: hdecay.h:120

◆ SetRemoveDuplicates()

void mkfit::Shell::SetRemoveDuplicates ( bool  b)

Definition at line 316 of file Shell.cc.

References b, and m_remove_duplicates.

316 { m_remove_duplicates = b; }
bool m_remove_duplicates
Definition: Shell.h:66
double b
Definition: hdecay.h:120

◆ SetUseDeadModules()

void mkfit::Shell::SetUseDeadModules ( bool  b)

Definition at line 317 of file Shell.cc.

References b, and mkfit::Config::useDeadModules.

double b
Definition: hdecay.h:120

◆ Status()

void mkfit::Shell::Status ( )

Definition at line 74 of file Shell.cc.

References mkfit::TrackBase::algoint_to_cstr(), hltPFPuppi_cfi::algos, mkfit::Event::evtID(), mkfit::g_debug, m_backward_fit, m_clean_seeds, m_event, m_it_index, m_remove_duplicates, and mkfit::Config::useDeadModules.

74  {
75  printf("On event %d, selected iteration index %d, algo %d - %s\n"
76  " debug = %s, use_dead_modules = %s\n"
77  " clean_seeds = %s, backward_fit = %s, remove_duplicates = %s\n",
81  }
bool m_remove_duplicates
Definition: Shell.h:66
int evtID() const
Definition: Event.h:23
bool m_clean_seeds
Definition: Shell.h:64
bool g_debug
Definition: Debug.cc:2
bool m_backward_fit
Definition: Shell.h:65
static const char * algoint_to_cstr(int algo)
Definition: Track.cc:331
Event * m_event
Definition: Shell.h:59
int m_it_index
Definition: Shell.h:63

Member Data Documentation

◆ m_backward_fit

bool mkfit::Shell::m_backward_fit = true
private

Definition at line 65 of file Shell.h.

Referenced by ProcessEvent(), SetBackwardFit(), Shell(), and Status().

◆ m_builder

MkBuilder* mkfit::Shell::m_builder = nullptr
private

Definition at line 61 of file Shell.h.

Referenced by builder(), ProcessEvent(), and Shell().

◆ m_ckf_map

std::map<int, Track *> mkfit::Shell::m_ckf_map
private

Definition at line 74 of file Shell.h.

Referenced by Compare(), and FillByLabelMaps_CkfBase().

◆ m_clean_seeds

bool mkfit::Shell::m_clean_seeds = true
private

Definition at line 64 of file Shell.h.

Referenced by ProcessEvent(), SetCleanSeeds(), and Status().

◆ m_data_file

DataFile* mkfit::Shell::m_data_file = nullptr
private

Definition at line 58 of file Shell.h.

Referenced by GoToEvent(), and Shell().

◆ m_deadvectors

std::vector<DeadVec>& mkfit::Shell::m_deadvectors
private

Definition at line 57 of file Shell.h.

Referenced by GoToEvent().

◆ m_eoh

EventOfHits* mkfit::Shell::m_eoh = nullptr
private

Definition at line 60 of file Shell.h.

Referenced by Compare(), eoh(), GoToEvent(), ProcessEvent(), and Shell().

◆ m_event

Event* mkfit::Shell::m_event = nullptr
private

◆ m_evs_in_file

int mkfit::Shell::m_evs_in_file = -1
private

Definition at line 62 of file Shell.h.

Referenced by GoToEvent(), and Shell().

◆ m_it_index

int mkfit::Shell::m_it_index = 0
private

◆ m_mkf_map

std::map<int, Track *> mkfit::Shell::m_mkf_map
private

Definition at line 74 of file Shell.h.

Referenced by Compare(), and FillByLabelMaps_CkfBase().

◆ m_remove_duplicates

bool mkfit::Shell::m_remove_duplicates = true
private

Definition at line 66 of file Shell.h.

Referenced by ProcessEvent(), SetRemoveDuplicates(), and Status().

◆ m_seed_map

std::map<int, Track *> mkfit::Shell::m_seed_map
private

Definition at line 74 of file Shell.h.

Referenced by Compare(), and FillByLabelMaps_CkfBase().

◆ m_seeds

TrackVec mkfit::Shell::m_seeds
private

Definition at line 68 of file Shell.h.

Referenced by Compare(), FillByLabelMaps_CkfBase(), and ProcessEvent().

◆ m_sim_map

std::map<int, Track *> mkfit::Shell::m_sim_map
private

Definition at line 74 of file Shell.h.

Referenced by Compare(), and FillByLabelMaps_CkfBase().

◆ m_tracks

TrackVec mkfit::Shell::m_tracks
private

Definition at line 69 of file Shell.h.

Referenced by FillByLabelMaps_CkfBase(), and ProcessEvent().