mkfit::Shell Class Reference

#include <Shell.h>

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

Public Member Functions
MkBuilder *	builder ()
bool	CheckMkFitLayerPlanVsReferenceHits (const Track &mkft, const Track &reft, const std::string &name)
void	Compare ()
EventOfHits *	eoh ()
Event *	event ()
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
MkBuilder *	m_builder = nullptr
std::map< int, Track * >	m_ckf_map
bool	m_clean_seeds = true
DataFile *	m_data_file = nullptr
std::vector< DeadVec > &	m_deadvectors
EventOfHits *	m_eoh = nullptr
Event *	m_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

enum mkfit::Shell::SeedSelect_e

Enumerator
SS_UseAll
SS_Label
SS_IndexPreCleaning
SS_IndexPostCleaning

Definition at line 18 of file Shell.h.

{ SS_UseAll = 0, SS_Label, SS_IndexPreCleaning, SS_IndexPostCleaning };

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.

    : m_deadvectors(dv)
  {
    m_eoh = new EventOfHits(Config::TrkInfo);
    m_builder = new MkBuilder(Config::silent);

    m_backward_fit = Config::backwardFit;

    m_data_file = new DataFile;
    m_evs_in_file = m_data_file->openRead(in_file, Config::TrkInfo.n_layers());

    m_event = new Event(0, Config::TrkInfo.n_layers());
    GoToEvent(start_ev);
  }

Member Function Documentation

builder()

MkBuilder* mkfit::Shell::builder ( )

inline

Definition at line 41 of file Shell.h.

References m_builder.

Referenced by ProcessEvent().

{ return m_builder; }

CheckMkFitLayerPlanVsReferenceHits()

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

Definition at line 419 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().

                                                                                                            {
    // Check if all hit-layers of a reference track reft are in the mkfit layer plan.
    // Returns true if all layers are in the plan.
    // String name is printed in front of label, expected to be SIMK or CKF.
    const IterationConfig &itconf = Config::ItrInfo[m_it_index];
    auto lp = itconf.m_steering_params[ mkft.getEtaRegion() ].m_layer_plan;
    bool ret = true;
    for (int hi = 0; hi < reft.nTotalHits(); ++hi) {
      auto hot = reft.getHitOnTrack(hi);
      if (std::find_if(lp.begin(), lp.end(), [=](auto &x){ return x.m_layer == hot.layer; }) == lp.end())
      {
        printf("CheckMkfLayerPlanVsCkfHits: layer %d not in layer plan for region %d, %s label=%d\n",
                hot.layer, mkft.getEtaRegion(), name.c_str(), reft.label());
        ret = false;
      }
    }
    return ret;
  }

Compare()

void mkfit::Shell::Compare

(

)

Definition at line 442 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.

                      {
    Event &ev = *m_event;
    const IterationConfig &itconf = Config::ItrInfo[m_it_index];

    FillByLabelMaps_CkfBase();

    printf("------------------------------------------------------\n");

    const bool print_all_def = false;
    int mkf_cnt=0, less_hits=0, more_hits=0;

    // TOBTEC: look for rec-seeds with hits in tob1 and 2 only.
    int tot_cnt = 0, no_mkf_cnt = 0;

    for (auto& [l, simt_ptr]: m_sim_map)
    {
      auto &simt = * simt_ptr;
      auto &ckft = * m_ckf_map[l];
      auto mi = m_mkf_map.find(l);

      bool print_all = print_all_def;

      // TOBTEC: look for rec-seeds with hits in tob1 and 2 only.
      bool select = true;
      {
        auto &ckf_seed = ev.seedTracks_[ckft.label()];
        for (int hi = 0; hi < ckf_seed.nTotalHits(); ++hi) {
          const HitOnTrack hot = ckf_seed.getHitOnTrack(hi);
          if (hot.index >= 0 && (hot.layer < 10 || hot.layer > 13)) {
            select = false;
            break;
          }
        }
      }
      if ( ! select) continue;

      ++tot_cnt;
      //print_all = true;

      if (mi != m_mkf_map.end())
      {
        auto &mkft = * mi->second;
        mkf_cnt++;
        if (mkft.nFoundHits() < ckft.nFoundHits()) ++less_hits;
        if (mkft.nFoundHits() > ckft.nFoundHits()) ++more_hits;

        CheckMkFitLayerPlanVsReferenceHits(mkft, ckft, "CKF");
        // CheckMkFitLayerPlanVsReferenceHits(mkft, simt, "SIM");

        (void) print_all;
        if (/* itconf.m_track_algorithm == 10 ||*/ print_all) {
          // ckf label is wrong when validation is on (even quality val) for mixedTriplet, pixelless and tobtec
          // as seed tracks get removed for non-mkfit iterations and indices from rec-tracks are no longer valid.
          auto &ckf_seed = ev.seedTracks_[ckft.label()];
          auto &mkf_seed = m_seeds[mkft.label()];
          print("ckf  ", 0, ckft, ev);
          print("mkfit", 0, mkft, ev);
          print("sim  ", 0, simt, ev);
          print("ckf seed", 0, ckf_seed, ev);
          print("mkf seed", 0, mkf_seed, ev);
          printf("------------------------------------------------------\n");

          TrackVec ssss;
          ssss.push_back(mkf_seed);

          IterationSeedPartition pppp(1);
          IterationConfig::get_seed_partitioner("phase1:1:debug")(Config::TrkInfo, ssss, *m_eoh, pppp);

          printf("------------------------------------------------------\n");
          printf("\n");
        }
      }
      else
      {
        printf("\n!!!!! No mkfit track with this label.\n\n");
        ++no_mkf_cnt;

        auto &ckf_seed = ev.seedTracks_[ckft.label()];
        print("ckf ", 0, ckft, ev);
        print("sim ", 0, simt, ev);
        print("ckf seed", 0, ckf_seed, ev);
        auto smi = m_seed_map.find(l);
        if (smi != m_seed_map.end())
          print("seed with matching label", 0, *smi->second, ev);
        printf("------------------------------------------------------\n");
      }
    }

    printf("mkFit found %d, matching_label=%d, less_hits=%d, more_hits=%d  [algo=%d (%s)]\n",
           (int) ev.fitTracks_.size(), mkf_cnt, less_hits, more_hits,
           itconf.m_track_algorithm, TrackBase::algoint_to_cstr(itconf.m_track_algorithm));

    if (tot_cnt > 0) {
      printf("\ntobtec tob1/2 tot=%d no_mkf=%d (%f%%)\n",
            tot_cnt, no_mkf_cnt, 100.0 * no_mkf_cnt / tot_cnt);
    } else {
      printf("\nNo CKF tracks with seed hits in TOB1/2 found (need iteration idx 8, TobTec?)\n");
    }

    printf("-------------------------------------------------------------------------------------------\n");
    printf("-------------------------------------------------------------------------------------------\n");
    printf("\n");
  }

eoh()

EventOfHits* mkfit::Shell::eoh ( )

inline

Definition at line 40 of file Shell.h.

References m_eoh.

Referenced by ProcessEvent().

{ return m_eoh; }

event()

Event* mkfit::Shell::event ( )

inline

Definition at line 39 of file Shell.h.

References m_event.

{ return m_event; }

FillByLabelMaps_CkfBase()

void mkfit::Shell::FillByLabelMaps_CkfBase

(

)

Definition at line 354 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().

                                      {
    Event &ev = *m_event;
    const int track_algo = Config::ItrInfo[m_it_index].m_track_algorithm;

    m_ckf_map.clear();
    m_sim_map.clear();
    m_seed_map.clear();
    m_mkf_map.clear();

    // Pick ckf tracks with right algo and a good label.
    int rec_algo_match = 0;
    for (auto &t : ev.cmsswTracks_) {
      if (t.algoint() != track_algo)
        continue;
      ++rec_algo_match;
      int label = LabelFromHits(t, false, 0.5);
      if (label >= 0) {
        m_ckf_map.insert(std::make_pair(label, &t));
      }
    }

    // Pick sim tracks with labels found by ckf.
    for (auto &t : ev.simTracks_) {
      if (t.label() >= 0 && m_ckf_map.find(t.label()) != m_ckf_map.end()) {
        m_sim_map.insert(std::make_pair(t.label(), &t));
      }
    }

    // Pick seeds with right algo and a label found by ckf.
    for (auto &t : ev.seedTracks_) {
      if (t.algoint() == track_algo && t.label() >= 0 && m_ckf_map.find(t.label()) != m_ckf_map.end()) {
        m_seed_map.insert(std::make_pair(t.label(), &t));
      }
    }
    // Some seeds seem to be labeled -1, try fixing when not otherwise found.
    for (auto &t : ev.seedTracks_) {
      if (t.algoint() == track_algo && t.label() == -1) {
        int lab = LabelFromHits(t, true, 0.5);
        if (lab >= 0 && m_seed_map.find(lab) == m_seed_map.end()) {
          if (m_ckf_map.find(lab) != m_ckf_map.end()) {
            m_seed_map.insert(std::make_pair(t.label(), &t));
            printf("Saved seed with label -1 -> %d\n", lab);
          }
        }
      }
    }

    // Pick mkfit tracks, label by 
    for (auto &t : m_tracks) {
      int label = LabelFromHits(t, false, 0.5);
      if (label >= 0) {
        m_mkf_map.insert(std::make_pair(label, &t));
      }
    }

    printf("Shell::FillByLabelMaps reporting tracks with label >= 0, algo=%d (%s): "
           "ckf: %d of %d (same algo=%d)), sim: %d of %d, seed: %d of %d, mkfit: %d w/label of %d\n",
           track_algo, TrackBase::algoint_to_cstr(track_algo),
           (int) m_ckf_map.size(), (int) ev.cmsswTracks_.size(), rec_algo_match,
           (int) m_sim_map.size(), (int) ev.simTracks_.size(),
           (int) m_seed_map.size(), (int) m_seeds.size(),
           (int) m_mkf_map.size(), (int) m_tracks.size()
    );
  }

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().

                               {
    if (eid < 1) {
      fprintf(stderr, "Requested event %d is less than 1 -- 1 is the first event, %d is total number of events in file\n",
             eid, m_evs_in_file);
      throw std::runtime_error("event out of range");
    }
    if (eid > m_evs_in_file) {
      fprintf(stderr, "Requested event %d is grater than total number of events in file %d\n",
             eid, m_evs_in_file);
      throw std::runtime_error("event out of range");
    }

    int pos = m_event->evtID();
    if (eid > pos) {
      m_data_file->skipNEvents(eid - pos - 1);
    } else {
      m_data_file->rewind();
      m_data_file->skipNEvents(eid - 1);
    }
    m_event->reset(eid);
    m_event->read_in(*m_data_file);
    StdSeq::loadHitsAndBeamSpot(*m_event, *m_eoh);
    if (Config::useDeadModules) {
      StdSeq::loadDeads(*m_eoh, m_deadvectors);
    }

    printf("At event %d\n", eid);
  }

LabelFromHits()

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

Definition at line 327 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().

                                                                  {
    std::map<int, int> lab_cnt;
    for (int hi = 0; hi < t.nTotalHits(); ++hi) {
      auto hot = t.getHitOnTrack(hi);
      if (hot.index < 0)
        continue;
      const Hit &h = m_event->layerHits_[hot.layer][hot.index];
      int hl = m_event->simHitsInfo_[h.mcHitID()].mcTrackID_;
      if (hl >= 0)
        ++lab_cnt[hl];
    }
    int max_c = -1, max_l = -1;
    for (auto& x : lab_cnt) {
      if (x.second > max_c) {
        max_l = x.first;
        max_c = x.second;
      }
    }
    bool success = max_c >= good_frac * t.nFoundHits();
    int relabel = success ? max_l : -1;
    // printf("found_hits=%d, best_lab %d (%d hits), existing label=%d (replace flag=%s)\n",
    //        t.nFoundHits(), max_l, max_c, t.label(), b2a(replace));
    if (replace)
        t.setLabel(relabel);
    return relabel;
  }

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.

                                {
    GoToEvent(m_event->evtID() + skip);
  }

PrintIterations()

void mkfit::Shell::PrintIterations

(

)

Definition at line 298 of file Shell.cc.

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

                              {
    printf("Shell::PrintIterations selected index = %d, %d iterations hardcoded as\n",
            m_it_index, n_algos);
    for (int i = 0; i < n_algos; ++i)
      printf("%d %2d %s\n", i, algos[i], TrackBase::algoint_to_cstr(algos[i]));
  }

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(), alignCSCRings::s, mkfit::MkBuilder::seed_post_cleaning(), DetachedQuadStep_cff::seeds, mkfit::Event::seedTracks_, mkfit::EventOfCombCandidates::size(), SS_IndexPostCleaning, SS_IndexPreCleaning, SS_Label, SS_UseAll, and mkfit::Config::TrkInfo.

                                                                                 {
    // count is only used for SS_IndexPreCleaning and SS_IndexPostCleaning.
    //       There are no checks for upper bounds, ie, if requested seeds beyond the first one exist.

    const IterationConfig &itconf = Config::ItrInfo[m_it_index];
    IterationMaskIfc mask_ifc;
    m_event->fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);

    m_seeds.clear();
    m_tracks.clear();

    {
      int n_algo = 0; // seeds are grouped by algo
      for (auto &s : m_event->seedTracks_) {
        if (s.algoint() == itconf.m_track_algorithm) {
          if (seed_select == SS_UseAll || seed_select == SS_IndexPostCleaning) {
            m_seeds.push_back(s);
          } else if (seed_select == SS_Label && s.label() == selected_seed) {
            m_seeds.push_back(s);
            break;
          } else if (seed_select == SS_IndexPreCleaning && n_algo >= selected_seed) {
            m_seeds.push_back(s);
            if (--count <= 0)
              break;
          }
          ++n_algo;
        } else if (n_algo > 0)
          break;
      }
    }

    printf("Shell::ProcessEvent running over %d seeds\n", (int) m_seeds.size());

    // Equivalent to run_OneIteration(...) without MkBuilder::release_memory().
    // If seed_select == SS_IndexPostCleaning the given seed is picked after cleaning.
    {
      const TrackerInfo &trackerInfo = Config::TrkInfo;
      const EventOfHits &eoh = *m_eoh;
      const IterationMaskIfcBase &it_mask_ifc = mask_ifc;
      MkBuilder &builder = *m_builder;
      TrackVec &seeds = m_seeds;
      TrackVec &out_tracks = m_tracks;
      bool do_seed_clean = m_clean_seeds;
      bool do_backward_fit = m_backward_fit;
      bool do_remove_duplicates = m_remove_duplicates;

      MkJob job({trackerInfo, itconf, eoh, eoh.refBeamSpot(), &it_mask_ifc});

      builder.begin_event(&job, m_event, __func__);

      // Seed cleaning not done on all iterations.
      do_seed_clean = m_clean_seeds && itconf.m_seed_cleaner;

      if (do_seed_clean)
        itconf.m_seed_cleaner(seeds, itconf, eoh.refBeamSpot());

      // Check nans in seeds -- this should not be needed when Slava fixes
      // the track parameter coordinate transformation.
      builder.seed_post_cleaning(seeds);

      if (seed_select == SS_IndexPostCleaning) {
        if (selected_seed >= 0 && selected_seed < (int)seeds.size()) {
          for (int i = 0; i < count; ++i)
            seeds[i] = seeds[selected_seed + i];
          seeds.resize(count);
        } else {
          seeds.clear();
        }
      }

      if (seeds.empty()) {
        if (seed_select != SS_UseAll)
          printf("Shell::ProcessEvent requested seed not found among seeds of the selected iteration.\n");
        else
          printf("Shell::ProcessEvent no seeds found.\n");
        return;
      }

      if (itconf.m_requires_seed_hit_sorting) {
        for (auto &s : seeds)
          s.sortHitsByLayer();  // sort seed hits for the matched hits (I hope it works here)
      }

      builder.find_tracks_load_seeds(seeds, do_seed_clean);

      builder.findTracksCloneEngine();

      printf("Shell::ProcessEvent post fwd search: %d comb-cands\n", builder.ref_eocc().size());

      // Pre backward-fit filtering.
      filter_candidates_func pre_filter;
      if (do_backward_fit && itconf.m_pre_bkfit_filter)
        pre_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
          return itconf.m_pre_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
        };
      else if (itconf.m_pre_bkfit_filter)
        pre_filter = itconf.m_pre_bkfit_filter;
      else if (do_backward_fit)
        pre_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
      // pre_filter can be null if we are not doing backward fit as nan_n_silly will be run below.
      if (pre_filter)
        builder.filter_comb_cands(pre_filter, true);

      printf("Shell::ProcessEvent post pre-bkf-filter (%s) and nan-filter (%s) filter: %d comb-cands\n",
             b2a(bool(itconf.m_pre_bkfit_filter)), b2a(do_backward_fit), builder.ref_eocc().size());

      job.switch_to_backward();

      if (do_backward_fit) {
        if (itconf.m_backward_search) {
          builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);
        }

        builder.backwardFit();

        if (itconf.m_backward_search) {
          builder.beginBkwSearch();
          builder.findTracksCloneEngine(SteeringParams::IT_BkwSearch);
        }

        printf("Shell::ProcessEvent post backward fit / search: %d comb-cands\n", builder.ref_eocc().size());
      }

      // Post backward-fit filtering.
      filter_candidates_func post_filter;
      if (do_backward_fit && itconf.m_post_bkfit_filter)
        post_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
          return itconf.m_post_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
        };
      else
        post_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
      // post_filter is always at least doing nan_n_silly filter.
      builder.filter_comb_cands(post_filter, true);

      printf("Shell::ProcessEvent post post-bkf-filter (%s) and nan-filter (true): %d comb-cands\n",
             b2a(do_backward_fit && itconf.m_post_bkfit_filter), builder.ref_eocc().size());

      if (do_backward_fit && itconf.m_backward_search)
        builder.endBkwSearch();

      builder.export_best_comb_cands(out_tracks, true);

      if (do_remove_duplicates && itconf.m_duplicate_cleaner) {
        itconf.m_duplicate_cleaner(out_tracks, itconf);
      }

      printf("Shell::ProcessEvent post remove-duplicates: %d comb-cands\n", (int) out_tracks.size());

      builder.end_event();
    }

    printf("Shell::ProcessEvent found %d tracks, number of seeds at end %d\n",
           (int) m_tracks.size(), (int) m_seeds.size());
  }

Run()

void mkfit::Shell::Run

(

)

Definition at line 55 of file Shell.cc.

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

                  {
#ifndef NO_ROOT
    std::vector<const char *> argv = { "mkFit", "-l" };
    int argc = argv.size();
    TRint rint("mkFit-shell", &argc, const_cast<char**>(argv.data()));

    char buf[256];
    sprintf(buf, "mkfit::Shell &s = * (mkfit::Shell*) %p;", this);
    gROOT->ProcessLine(buf);
    printf("Shell &s variable is set\n");

    rint.Run(true);
    printf("Shell::Run finished\n");
#else
    printf("Shell::Run() no root, we rot -- erroring out. Recompile with WITH_ROOT=1\n");
    exit(1);
#endif
  }

SelectIterationAlgo()

void mkfit::Shell::SelectIterationAlgo

(

int

algo

)

Definition at line 287 of file Shell.cc.

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

                                          {
    for (int i = 0; i < n_algos; ++i) {
      if (algos[i] == algo) {
        m_it_index = i;
        return;
      }
    }
    fprintf(stderr, "Requested algo %d not found", algo);
    throw std::runtime_error("algo not found");
  }

SelectIterationIndex()

void mkfit::Shell::SelectIterationIndex

(

int

itidx

)

Definition at line 279 of file Shell.cc.

References m_it_index, and submitPVResolutionJobs::stderr.

                                            {
    if (itidx < 0 || itidx >= n_algos) {
      fprintf(stderr, "Requested iteration index out of range [%d, %d)", 0, n_algos);
      throw std::runtime_error("iteration index out of range");
    }
    m_it_index = itidx;
  }

SetBackwardFit()

void mkfit::Shell::SetBackwardFit

(

bool

b

)

Definition at line 311 of file Shell.cc.

References b, and m_backward_fit.

{ m_backward_fit = b; }

SetCleanSeeds()

void mkfit::Shell::SetCleanSeeds

(

bool

b

)

Definition at line 310 of file Shell.cc.

References b, and m_clean_seeds.

{ m_clean_seeds = b; }

SetDebug()

void mkfit::Shell::SetDebug

(

bool

b

)

Definition at line 309 of file Shell.cc.

References b, and mkfit::g_debug.

{ g_debug = b; }

SetRemoveDuplicates()

void mkfit::Shell::SetRemoveDuplicates

(

bool

b

)

Definition at line 312 of file Shell.cc.

References b, and m_remove_duplicates.

{ m_remove_duplicates = b; }

SetUseDeadModules()

void mkfit::Shell::SetUseDeadModules

(

bool

b

)

Definition at line 313 of file Shell.cc.

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

{ Config::useDeadModules = b; }

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.

                     {
    printf("On event %d, selected iteration index %d, algo %d - %s\n"
          "  debug = %s, use_dead_modules = %s\n"
           "  clean_seeds = %s, backward_fit = %s, remove_duplicates = %s\n",
           m_event->evtID(), m_it_index, algos[m_it_index], TrackBase::algoint_to_cstr(algos[m_it_index]),
           b2a(g_debug), b2a(Config::useDeadModules),
           b2a(m_clean_seeds), b2a(m_backward_fit), b2a(m_remove_duplicates));
  }

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

Definition at line 59 of file Shell.h.

Referenced by Compare(), event(), FillByLabelMaps_CkfBase(), GoToEvent(), LabelFromHits(), NextEvent(), ProcessEvent(), Shell(), and Status().

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

Definition at line 63 of file Shell.h.

Referenced by CheckMkFitLayerPlanVsReferenceHits(), Compare(), FillByLabelMaps_CkfBase(), PrintIterations(), ProcessEvent(), SelectIterationAlgo(), SelectIterationIndex(), and Status().

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().