#include <CandCloner.h>

Public Member Functions
void	add_cand (int idx, const IdxChi2List &cand_info)

void	begin_eta_bin (EventOfCombCandidates e_o_ccs, std::vector< std::pair< int, int >> update_list, std::vector< std::vector< TrackCand >> *extra_cands, int start_seed, int n_seeds)

void	begin_iteration ()

void	begin_layer (int lay)

	CandCloner ()

CombCandidate &	combCandWithOriginalIndex (int idx)

void	doWork (int idx)

void	end_eta_bin ()

void	end_iteration ()

void	end_layer ()

int	num_cands (int idx)

void	processSeedRange (int is_beg, int is_end)

void	release ()

void	setup (const IterationParams &ip)

Static Public Attributes
static const int	s_max_seed_range = 8

Private Attributes
std::vector< std::vector < IdxChi2List > >	m_hits_to_add

int	m_idx_max

int	m_idx_max_prev

int	m_layer

int	m_n_seeds

int	m_start_seed

EventOfCombCandidates *	mp_event_of_comb_candidates

std::vector< std::vector < TrackCand > > *	mp_extra_cands

const IterationParams *	mp_iteration_params = nullptr

std::vector< std::pair< int, int > > *	mp_kalman_update_list

std::vector< std::vector < TrackCand > >	t_cands_for_next_lay

Detailed Description

Definition at line 16 of file CandCloner.h.

Constructor & Destructor Documentation

mkfit::CandCloner::CandCloner ( )

inline

Definition at line 21 of file CandCloner.h.

References s_max_seed_range, and t_cands_for_next_lay.

21 { t_cands_for_next_lay.resize(s_max_seed_range); }

mkfit::CandCloner::s_max_seed_range

static const int s_max_seed_range

Definition: CandCloner.h:19

mkfit::CandCloner::t_cands_for_next_lay

std::vector< std::vector< TrackCand > > t_cands_for_next_lay

Definition: CandCloner.h:71

Member Function Documentation

void mkfit::CandCloner::add_cand	(	int	idx,
		const IdxChi2List &	cand_info
	)

inline

Definition at line 34 of file CandCloner.h.

References m_hits_to_add, m_idx_max, and SiStripPI::max.

Referenced by mkfit::MkFinder::findCandidatesCloneEngine().

                                                          {
       m_hits_to_add[idx].push_back(cand_info);
 
       m_idx_max = std::max(m_idx_max, idx);
     }

void mkfit::CandCloner::begin_eta_bin	(	EventOfCombCandidates *	e_o_ccs,
		std::vector< std::pair< int, int >> *	update_list,
		std::vector< std::vector< TrackCand >> *	extra_cands,
		int	start_seed,
		int	n_seeds
	)

Definition at line 26 of file CandCloner.cc.

References mkfit::dtime(), mps_fire::i, m_hits_to_add, m_n_seeds, m_start_seed, mp_event_of_comb_candidates, mp_extra_cands, mp_kalman_update_list, and gpuVertexFinder::printf().

Referenced by mkfit::MkBuilder::find_tracks_in_layers().

                                               {
     mp_event_of_comb_candidates = e_o_ccs;
     mp_kalman_update_list = update_list;
     mp_extra_cands = extra_cands;
     m_start_seed = start_seed;
     m_n_seeds = n_seeds;
     m_hits_to_add.resize(n_seeds);
 
     for (int i = 0; i < n_seeds; ++i)
       m_hits_to_add[i].reserve(4);
 
 #ifdef CC_TIME_ETA
     printf("CandCloner::begin_eta_bin\n");
     t_eta = dtime();
 #endif
   }

void mkfit::CandCloner::begin_iteration ( )

Definition at line 60 of file CandCloner.cc.

Referenced by mkfit::MkBuilder::find_tracks_in_layers().

                                    {
     // Do nothing, "secondary" state vars updated when work completed/assigned.
   }

void mkfit::CandCloner::begin_layer ( int lay )

Definition at line 47 of file CandCloner.cc.

References mkfit::dtime(), m_idx_max, m_idx_max_prev, m_layer, and mp_kalman_update_list.

Referenced by mkfit::MkBuilder::find_tracks_in_layers().

                                       {
     m_layer = lay;
 
     m_idx_max = 0;
     m_idx_max_prev = 0;
 
     mp_kalman_update_list->clear();
 
 #ifdef CC_TIME_LAYER
     t_lay = dtime();
 #endif
   }

CombCandidate& mkfit::CandCloner::combCandWithOriginalIndex ( int idx )

inline

Definition at line 51 of file CandCloner.h.

References mkfit::EventOfCombCandidates::cand(), and mp_event_of_comb_candidates.

Referenced by mkfit::MkFinder::findCandidatesCloneEngine().

51 { return mp_event_of_comb_candidates->cand(idx); }

mkfit::CandCloner::mp_event_of_comb_candidates

EventOfCombCandidates * mp_event_of_comb_candidates

Definition: CandCloner.h:58

mkfit::EventOfCombCandidates::cand

CombCandidate & cand(int i)

Definition: HitStructures.h:866

void mkfit::CandCloner::doWork ( int idx )

Definition at line 102 of file CandCloner.cc.

References dprintf, dataset::end, m_idx_max_prev, SiStripPI::min, processSeedRange(), and s_max_seed_range.

Referenced by end_iteration(), and end_layer().

                                  {
     dprintf("CandCloner::DoWork assigning work from seed %d to %d\n", m_idx_max_prev, idx);
 
     int beg = m_idx_max_prev;
     int the_end = idx;
 
     dprintf("CandCloner::DoWork working on beg=%d to the_end=%d\n", beg, the_end);
 
     while (beg != the_end) {
       int end = std::min(beg + s_max_seed_range, the_end);
 
       dprintf("CandCloner::DoWork processing %4d -> %4d\n", beg, end);
 
       processSeedRange(beg, end);
 
       beg = end;
     }
 
     m_idx_max_prev = idx;
   }

void mkfit::CandCloner::end_eta_bin ( )

Definition at line 94 of file CandCloner.cc.

References mkfit::dtime(), and gpuVertexFinder::printf().

Referenced by mkfit::MkBuilder::find_tracks_in_layers().

                                {
 #ifdef CC_TIME_ETA
     t_eta = dtime() - t_eta;
     printf("CandCloner::end_eta_bin t_eta=%8.6f\n", t_eta);
 #endif
   }

void mkfit::CandCloner::end_iteration ( )

Definition at line 64 of file CandCloner.cc.

References doWork(), dprintf, m_idx_max, m_idx_max_prev, and s_max_seed_range.

Referenced by mkfit::MkBuilder::find_tracks_in_layers().

                                  {
     int proc_n = m_idx_max - m_idx_max_prev;
 
     dprintf("CandCloner::end_iteration process %d, max_prev=%d, max=%d\n", proc_n, m_idx_max_prev, m_idx_max);
 
     if (proc_n >= s_max_seed_range) {
       // Round to multiple of s_max_seed_range.
       doWork((m_idx_max / s_max_seed_range) * s_max_seed_range);
     }
   }

void mkfit::CandCloner::end_layer ( )

Definition at line 75 of file CandCloner.cc.

References doWork(), mkfit::dtime(), mps_fire::i, m_hits_to_add, m_idx_max, m_idx_max_prev, m_layer, m_n_seeds, and gpuVertexFinder::printf().

Referenced by mkfit::MkBuilder::find_tracks_in_layers().

                              {
     if (m_n_seeds > m_idx_max_prev) {
       doWork(m_n_seeds);
     }
 
     for (int i = 0; i < m_n_seeds; ++i) {
       m_hits_to_add[i].clear();
     }
 
 #ifdef CC_TIME_LAYER
     t_lay = dtime() - t_lay;
     printf("CandCloner::end_layer %d -- t_lay=%8.6f\n", m_layer, t_lay);
     printf("                      m_idx_max=%d, m_idx_max_prev=%d, issued work=%d\n",
            m_idx_max,
            m_idx_max_prev,
            m_idx_max + 1 > m_idx_max_prev);
 #endif
   }

int mkfit::CandCloner::num_cands ( int idx )

inline

Definition at line 40 of file CandCloner.h.

References m_hits_to_add.

40 { return m_hits_to_add[idx].size(); }

mkfit::CandCloner::m_hits_to_add

std::vector< std::vector< IdxChi2List > > m_hits_to_add

Definition: CandCloner.h:55

void mkfit::CandCloner::processSeedRange	(	int	is_beg,
		int	is_end
	)

Definition at line 125 of file CandCloner.cc.

References mkfit::TrackCand::addHitIdx(), mkfit::EventOfCombCandidates::cand(), HLT_FULL_cff::chi2, mkfit::IdxChi2List::chi2_hit, mkfit::CombCandidate::clear(), cuy::cv, dprint, dprintf, mkfit::CombCandidate::emplace_back(), mkfit::CombCandidate::Finding, mkfit::IdxChi2List::hitIdx, cuy::ii, mkfit::TrackCand::incOverlapCount(), mkfit::HitMatch::m_chi2, mkfit::HitMatch::m_hit_idx, m_hits_to_add, m_layer, m_start_seed, mkfit::IterationParams::maxCandsPerSeed, SiStripPI::min, mkfit::IdxChi2List::module, mp_event_of_comb_candidates, mp_iteration_params, mp_kalman_update_list, PVValHelper::pT, mkfit::TrackBase::pT(), mkfit::IterationParams::pTCutOverlap, mkfit::CombCandidate::refBestShortCand(), mkfit::CombCandidate::resize(), mkfit::IdxChi2List::score, mkfit::TrackBase::score(), mkfit::CombCandidate::setBestShortCand(), mkfit::TrackBase::setScore(), mkfit::sortByScoreTrackCand(), mkfit::CombCandidate::state(), t_cands_for_next_lay, and mkfit::IdxChi2List::trkIdx.

Referenced by doWork().

                                                           {
     // Process new hits for a range of seeds.
 
     // bool debug = true;
 
     dprintf("\nCandCloner::ProcessSeedRange is_beg=%d, is_end=%d\n", is_beg, is_end);
 
     //1) sort the candidates
     for (int is = is_beg; is < is_end; ++is) {
       std::vector<IdxChi2List> &hitsForSeed = m_hits_to_add[is];
 
       CombCandidate &ccand = mp_event_of_comb_candidates->cand(m_start_seed + is);
       std::vector<TrackCand> &extras = (*mp_extra_cands)[is];
       auto extra_i = extras.begin();
       auto extra_e = extras.end();
 
       // Extras are sorted by candScore.
 
 #ifdef DEBUG
       dprint("  seed n " << is << " with input candidates=" << hitsForSeed.size());
       for (int ih = 0; ih < (int)hitsForSeed.size(); ih++) {
         dprint("trkIdx=" << hitsForSeed[ih].trkIdx << " hitIdx=" << hitsForSeed[ih].hitIdx
                          << " chi2=" << hitsForSeed[ih].chi2 << std::endl
                          << "    "
                          << "original pt=" << ccand[hitsForSeed[ih].trkIdx].pT() << " "
                          << "nTotalHits=" << ccand[hitsForSeed[ih].trkIdx].nTotalHits() << " "
                          << "nFoundHits=" << ccand[hitsForSeed[ih].trkIdx].nFoundHits() << " "
                          << "chi2=" << ccand[hitsForSeed[ih].trkIdx].chi2());
       }
 #endif
 
       if (!hitsForSeed.empty()) {
         //sort the new hits
         std::sort(hitsForSeed.begin(), hitsForSeed.end(), sortCandListByScore);
 
         int num_hits = std::min((int)hitsForSeed.size(), mp_iteration_params->maxCandsPerSeed);
 
         // This is from buffer, we know it was cleared after last usage.
         std::vector<TrackCand> &cv = t_cands_for_next_lay[is - is_beg];
 
         int n_pushed = 0;
 
         for (int ih = 0; ih < num_hits; ih++) {
           const IdxChi2List &h2a = hitsForSeed[ih];
 
           TrackCand tc(ccand[h2a.trkIdx]);
           tc.addHitIdx(h2a.hitIdx, m_layer, h2a.chi2_hit);
           tc.setScore(h2a.score);
 
           if (h2a.hitIdx == -2) {
             if (h2a.score > ccand.refBestShortCand().score()) {
               ccand.setBestShortCand(tc);
             }
             continue;
           }
 
           // Could also skip storing of cands with last -3 hit.
 
           // Squeeze in extra tracks that are better than current one.
           while (extra_i != extra_e && sortByScoreTrackCand(*extra_i, tc) &&
                  n_pushed < mp_iteration_params->maxCandsPerSeed) {
             cv.emplace_back(*extra_i);
             ++n_pushed;
             ++extra_i;
           }
 
           if (n_pushed >= mp_iteration_params->maxCandsPerSeed)
             break;
 
           // set the overlap if we have a true hit and pT > pTCutOverlap
           HitMatch *hm;
           if (tc.pT() > mp_iteration_params->pTCutOverlap && h2a.hitIdx >= 0 &&
               (hm = ccand[h2a.trkIdx].findOverlap(h2a.hitIdx, h2a.module))) {
             tc.addHitIdx(hm->m_hit_idx, m_layer, hm->m_chi2);
             tc.incOverlapCount();
           }
 
           cv.emplace_back(tc);
           ++n_pushed;
 
           if (h2a.hitIdx >= 0) {
             mp_kalman_update_list->push_back(std::pair<int, int>(m_start_seed + is, n_pushed - 1));
           }
         }
 
         // Add remaining extras as long as there is still room for them.
         while (extra_i != extra_e && n_pushed < mp_iteration_params->maxCandsPerSeed) {
           cv.emplace_back(*extra_i);
           ++n_pushed;
           ++extra_i;
         }
 
         // Can not use ccand.swap(cv) -- allocations for TrackCand vectors need to be
         // in the same memory segment for gather operation to work in backward-fit.
         ccand.resize(cv.size());
         for (size_t ii = 0; ii < cv.size(); ++ii) {
           ccand[ii] = cv[ii];
         }
         cv.clear();
       } else  // hitsForSeed.empty()
       {
         if (ccand.state() == CombCandidate::Finding) {
           ccand.clear();
 
           while (extra_i != extra_e) {
             ccand.emplace_back(*extra_i);
             ++extra_i;
           }
         }
       }
 
       extras.clear();
     }
   }

void mkfit::CandCloner::release ( )

Definition at line 24 of file CandCloner.cc.

References mp_iteration_params.

24 { mp_iteration_params = nullptr; }

mkfit::CandCloner::mp_iteration_params

const IterationParams * mp_iteration_params

Definition: CandCloner.h:57

void mkfit::CandCloner::setup ( const IterationParams & ip )

Definition at line 17 of file CandCloner.cc.

References iseed, mkfit::IterationParams::maxCandsPerSeed, mp_iteration_params, s_max_seed_range, and t_cands_for_next_lay.

                                                   {
     mp_iteration_params = &ip;
     for (int iseed = 0; iseed < s_max_seed_range; ++iseed) {
       t_cands_for_next_lay[iseed].reserve(mp_iteration_params->maxCandsPerSeed);
     }
   }