#include <MkFinder.h>

Inheritance diagram for mkfit::MkFinder:

Public Types
using	MPlexHitIdx = Matriplex::Matriplex< int, MPlexHitIdxMax, 1, NN >

using	MPlexQHoT = Matriplex::Matriplex< HitOnTrack, 1, 1, NN >

Public Member Functions
void	addBestHit (const LayerOfHits &layer_of_hits, const int N_proc, const FindingFoos &fnd_foos)

HitOnTrack	bestHitLastHoT (int itrack) const

void	bkFitFitTracks (const EventOfHits &eventofhits, const SteeringParams &st_par, const int N_proc, bool chiDebug=false)

void	bkFitFitTracksBH (const EventOfHits &eventofhits, const SteeringParams &st_par, const int N_proc, bool chiDebug=false)

void	bkFitInputTracks (TrackVec &cands, int beg, int end)

void	bkFitInputTracks (EventOfCombCandidates &eocss, int beg, int end)

void	bkFitOutputTracks (TrackVec &cands, int beg, int end, bool outputProp)

void	bkFitOutputTracks (EventOfCombCandidates &eocss, int beg, int end, bool outputProp)

void	bkFitPropTracksToPCA (const int N_proc)

void	copyOutParErr (std::vector< CombCandidate > &seed_cand_vec, int N_proc, bool outputProp) const

void	findCandidates (const LayerOfHits &layer_of_hits, std::vector< std::vector< TrackCand >> &tmp_candidates, const int offset, const int N_proc, const FindingFoos &fnd_foos)

void	findCandidatesCloneEngine (const LayerOfHits &layer_of_hits, CandCloner &cloner, const int offset, const int N_proc, const FindingFoos &fnd_foos)

float	getHitSelDynamicChi2Cut (const int itrk, const int ipar)

void	getHitSelDynamicWindows (const float invpt, const float theta, float &min_dq, float &max_dq, float &min_dphi, float &max_dphi)

void	inputTracksAndHitIdx (const std::vector< Track > &tracks, int beg, int end, bool inputProp)

void	inputTracksAndHitIdx (const std::vector< Track > &tracks, const std::vector< int > &idxs, int beg, int end, bool inputProp, int mp_offset)

void	inputTracksAndHitIdx (const std::vector< CombCandidate > &tracks, const std::vector< std::pair< int, int >> &idxs, int beg, int end, bool inputProp)

void	inputTracksAndHitIdx (const std::vector< CombCandidate > &tracks, const std::vector< std::pair< int, IdxChi2List >> &idxs, int beg, int end, bool inputProp)

	MkFinder ()

void	outputNonStoppedTracksAndHitIdx (std::vector< Track > &tracks, const std::vector< int > &idxs, int beg, int end, bool outputProp) const

void	outputTrackAndHitIdx (Track &track, int itrack, bool outputProp) const

void	outputTracksAndHitIdx (std::vector< Track > &tracks, int beg, int end, bool outputProp) const

void	outputTracksAndHitIdx (std::vector< Track > &tracks, const std::vector< int > &idxs, int beg, int end, bool outputProp) const

void	release ()

void	selectHitIndices (const LayerOfHits &layer_of_hits, const int N_proc)

void	setup (const PropagationConfig &pc, const IterationParams &ip, const IterationLayerConfig &ilc, const std::vector< bool > *ihm)

void	setup_bkfit (const PropagationConfig &pc)

void	updateWithLastHit (const LayerOfHits &layer_of_hits, int N_proc, const FindingFoos &fnd_foos)

Public Member Functions inherited from mkfit::MkBase
float	getPar (int itrack, int i, int par) const

	MkBase ()

void	propagateTracksToHitR (const MPlexHV &par, const int N_proc, const PropagationFlags pf, const MPlexQI *noMatEffPtr=nullptr)

void	propagateTracksToHitZ (const MPlexHV &par, const int N_proc, const PropagationFlags pf, const MPlexQI *noMatEffPtr=nullptr)

void	propagateTracksToPCAZ (const int N_proc, const PropagationFlags pf)

void	propagateTracksToR (float r, const int N_proc, const PropagationFlags pf)

void	propagateTracksToZ (float z, const int N_proc, const PropagationFlags pf)

float	radiusSqr (int itrack, int i) const

Static Public Attributes
static constexpr int	MPlexHitIdxMax = 16

Static Public Attributes inherited from mkfit::MkBase
static constexpr int	iC = 0

static constexpr int	iP = 1

Private Member Functions
void	add_hit (const int mslot, int index, int layer)

void	copy_in (const Track &trk, const int mslot, const int tslot)

void	copy_in (const TrackCand &trk, const int mslot, const int tslot)

void	copy_out (Track &trk, const int mslot, const int tslot) const

void	copy_out (TrackCand &trk, const int mslot, const int tslot) const

int	num_all_minus_one_hits (const int mslot) const

int	num_inside_minus_one_hits (const int mslot) const

Private Attributes
MPlexQI	m_CandIdx

MPlexQF	m_Chi2

CombCandidate *	m_CombCand [NN]

int	m_CurHit [NN]

int	m_CurNode [NN]

const HitOnTrack *	m_HoTArr [NN]

HitOnTrack	m_HoTArrs [NN][Config::nMaxTrkHits]

const HoTNode *	m_HoTNodeArr [NN]

const std::vector< bool > *	m_iteration_hit_mask = nullptr

const IterationLayerConfig *	m_iteration_layer_config = nullptr

const IterationParams *	m_iteration_params = nullptr

MPlexQI	m_Label

MPlexQI	m_LastHitCcIndex

HitOnTrack	m_LastHoT [NN]

MPlexHS	m_msErr

MPlexHV	m_msPar

MPlexQI	m_NFoundHits

MPlexQI	m_NHits

MPlexQI	m_NInsideMinusOneHits

MPlexQI	m_NMissingHits

MPlexQI	m_NOverlapHits

MPlexQI	m_NTailMinusOneHits

const PropagationConfig *	m_prop_config = nullptr

MPlexQI	m_SeedIdx

MPlexQI	m_Stopped

TrackCand *	m_TrkCand [NN]

TrackBase::Status	m_TrkStatus [NN]

MPlexHitIdx	m_XHitArr

MPlexQI	m_XHitSize

WSR_Result	m_XWsrResult [NN]

Friends
class	MkBuilder

Additional Inherited Members
Protected Attributes inherited from mkfit::MkBase
MPlexQI	m_Chg

MPlexLS	m_Err [2]

MPlexLV	m_Par [2]

Detailed Description

Definition at line 31 of file MkFinder.h.

Member Typedef Documentation

◆ MPlexHitIdx

using mkfit::MkFinder::MPlexHitIdx = Matriplex::Matriplex<int, MPlexHitIdxMax, 1, NN>

Definition at line 37 of file MkFinder.h.

◆ MPlexQHoT

using mkfit::MkFinder::MPlexQHoT = Matriplex::Matriplex<HitOnTrack, 1, 1, NN>

Definition at line 38 of file MkFinder.h.

Constructor & Destructor Documentation

◆ MkFinder()

mkfit::MkFinder::MkFinder ( )

inline

Definition at line 42 of file MkFinder.h.

42 {}

Member Function Documentation

◆ add_hit()

void mkfit::MkFinder::add_hit	(	const int	mslot,
		int	index,
		int	layer
	)

inlineprivate

Definition at line 220 of file MkFinder.h.

References phase1PixelTopology::layer, L1DTConfigBti_cff::LH, m_HoTArrs, m_NFoundHits, m_NHits, m_NInsideMinusOneHits, m_NTailMinusOneHits, and mkfit::Config::nMaxTrkHits.

Referenced by addBestHit().

                                                         {
       // Only used by BestHit.
       // m_NInsideMinusOneHits and m_NTailMinusOneHits are maintained here but are
       // not used and are not copied out (as Track does not have these members).
 
       int &n_tot_hits = m_NHits(mslot, 0, 0);
       int &n_fnd_hits = m_NFoundHits(mslot, 0, 0);
 
       if (n_tot_hits < Config::nMaxTrkHits) {
         m_HoTArrs[mslot][n_tot_hits++] = {index, layer};
         if (index >= 0) {
           ++n_fnd_hits;
           m_NInsideMinusOneHits(mslot, 0, 0) += m_NTailMinusOneHits(mslot, 0, 0);
           m_NTailMinusOneHits(mslot, 0, 0) = 0;
         } else if (index == -1) {
           ++m_NTailMinusOneHits(mslot, 0, 0);
         }
       } else {
         // printf("WARNING MkFinder::add_hit hit-on-track limit reached for label=%d\n", label_);
 
         const int LH = Config::nMaxTrkHits - 1;
 
         if (index >= 0) {
           if (m_HoTArrs[mslot][LH].index < 0)
             ++n_fnd_hits;
           m_HoTArrs[mslot][LH] = {index, layer};
         } else if (index == -2) {
           if (m_HoTArrs[mslot][LH].index >= 0)
             --n_fnd_hits;
           m_HoTArrs[mslot][LH] = {index, layer};
         }
       }
     }

◆ addBestHit()

void mkfit::MkFinder::addBestHit	(	const LayerOfHits &	layer_of_hits,
		const int	N_proc,
		const FindingFoos &	fnd_foos
	)

Definition at line 657 of file MkFinder.cc.

References funct::abs(), add_hit(), Matriplex::Matriplex< T, D1, D2, N >::At(), hltPixelTracks_cff::chi2, Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), dprint, mkfit::PropagationConfig::finding_intra_layer_pflags, mkfit::PropagationConfig::finding_requires_propagation_to_hit_pos, getHitSelDynamicChi2Cut(), mkfit::LayerOfHits::hitArray(), mkfit::MkBase::iC, mkfit::MkBase::iP, mkfit::Hit::kHitEdgeIdx, mkfit::Hit::kHitMissIdx, mkfit::Hit::kHitStopIdx, mkfit::LayerOfHits::layer_id(), mkfit::MkBase::m_Chg, m_Chi2, mkfit::FindingFoos::m_compute_chi2_foo, mkfit::MkBase::m_Err, m_msErr, m_msPar, mkfit::MkBase::m_Par, m_prop_config, mkfit::FindingFoos::m_update_param_foo, m_XHitArr, m_XHitSize, m_XWsrResult, SiStripPI::max, reco_skim_cfg_mod::maxSize, MTVHistoProducerAlgoForTrackerBlock_cfi::minChi2, mkfit::NN, num_all_minus_one_hits(), mkfit::LayerOfHits::refHit(), Matriplex::MatriplexSym< T, D, N >::setDiagonal3x3(), mkfit::WSR_Edge, and mkfit::WSR_Outside.

                                                                                                            {
     // debug = true;
 
     MatriplexHitPacker mhp(layer_of_hits.hitArray());
 
     float minChi2[NN];
     int bestHit[NN];
     int maxSize = 0;
 
     // Determine maximum number of hits for tracks in the collection.
     for (int it = 0; it < NN; ++it) {
       if (it < N_proc) {
         if (m_XHitSize[it] > 0) {
           maxSize = std::max(maxSize, m_XHitSize[it]);
         }
       }
 
       bestHit[it] = -1;
       minChi2[it] = getHitSelDynamicChi2Cut(it, iP);
     }
 
     for (int hit_cnt = 0; hit_cnt < maxSize; ++hit_cnt) {
       //fixme what if size is zero???
 
       mhp.reset();
 
 #pragma omp simd
       for (int itrack = 0; itrack < N_proc; ++itrack) {
         if (hit_cnt < m_XHitSize[itrack]) {
           mhp.addInputAt(itrack, layer_of_hits.refHit(m_XHitArr.At(itrack, hit_cnt, 0)));
         }
       }
 
       mhp.pack(m_msErr, m_msPar);
 
       //now compute the chi2 of track state vs hit
       MPlexQF outChi2;
       MPlexLV tmpPropPar;
       (*fnd_foos.m_compute_chi2_foo)(m_Err[iP],
                                      m_Par[iP],
                                      m_Chg,
                                      m_msErr,
                                      m_msPar,
                                      outChi2,
                                      tmpPropPar,
                                      N_proc,
                                      m_prop_config->finding_intra_layer_pflags,
                                      m_prop_config->finding_requires_propagation_to_hit_pos);
 
       //update best hit in case chi2<minChi2
 #pragma omp simd
       for (int itrack = 0; itrack < N_proc; ++itrack) {
         if (hit_cnt < m_XHitSize[itrack]) {
           const float chi2 = std::abs(outChi2[itrack]);  //fixme negative chi2 sometimes...
           dprint("chi2=" << chi2 << " minChi2[itrack]=" << minChi2[itrack]);
           if (chi2 < minChi2[itrack]) {
             minChi2[itrack] = chi2;
             bestHit[itrack] = m_XHitArr.At(itrack, hit_cnt, 0);
           }
         }
       }
     }  // end loop over hits
 
     //#pragma omp simd
     for (int itrack = 0; itrack < N_proc; ++itrack) {
       if (m_XWsrResult[itrack].m_wsr == WSR_Outside) {
         // Why am I doing this?
         m_msErr.setDiagonal3x3(itrack, 666);
         m_msPar(itrack, 0, 0) = m_Par[iP](itrack, 0, 0);
         m_msPar(itrack, 1, 0) = m_Par[iP](itrack, 1, 0);
         m_msPar(itrack, 2, 0) = m_Par[iP](itrack, 2, 0);
 
         // XXXX If not in gap, should get back the old track params. But they are gone ...
         // Would actually have to do it right after SelectHitIndices where updated params are still ok.
         // Here they got screwed during hit matching.
         // So, I'd store them there (into propagated params) and retrieve them here.
         // Or we decide not to care ...
 
         continue;
       }
 
       //fixme decide what to do in case no hit found
       if (bestHit[itrack] >= 0) {
         const Hit &hit = layer_of_hits.refHit(bestHit[itrack]);
         const float chi2 = minChi2[itrack];
 
         dprint("ADD BEST HIT FOR TRACK #"
                << itrack << std::endl
                << "prop x=" << m_Par[iP].constAt(itrack, 0, 0) << " y=" << m_Par[iP].constAt(itrack, 1, 0) << std::endl
                << "copy in hit #" << bestHit[itrack] << " x=" << hit.position()[0] << " y=" << hit.position()[1]);
 
         m_msErr.copyIn(itrack, hit.errArray());
         m_msPar.copyIn(itrack, hit.posArray());
         m_Chi2(itrack, 0, 0) += chi2;
 
         add_hit(itrack, bestHit[itrack], layer_of_hits.layer_id());
       } else {
         int fake_hit_idx = Hit::kHitMissIdx;
 
         if (m_XWsrResult[itrack].m_wsr == WSR_Edge) {
           // YYYYYY Config::store_missed_layers
           fake_hit_idx = Hit::kHitEdgeIdx;
         } else if (num_all_minus_one_hits(itrack)) {
           fake_hit_idx = Hit::kHitStopIdx;
         }
 
         dprint("ADD FAKE HIT FOR TRACK #" << itrack << " withinBounds=" << (fake_hit_idx != Hit::kHitEdgeIdx)
                                           << " r=" << std::hypot(m_Par[iP](itrack, 0, 0), m_Par[iP](itrack, 1, 0)));
 
         m_msErr.setDiagonal3x3(itrack, 666);
         m_msPar(itrack, 0, 0) = m_Par[iP](itrack, 0, 0);
         m_msPar(itrack, 1, 0) = m_Par[iP](itrack, 1, 0);
         m_msPar(itrack, 2, 0) = m_Par[iP](itrack, 2, 0);
         // Don't update chi2
 
         add_hit(itrack, fake_hit_idx, layer_of_hits.layer_id());
       }
     }
 
     // Update the track parameters with this hit. (Note that some calculations
     // are already done when computing chi2. Not sure it's worth caching them?)
 
     dprint("update parameters");
     (*fnd_foos.m_update_param_foo)(m_Err[iP],
                                    m_Par[iP],
                                    m_Chg,
                                    m_msErr,
                                    m_msPar,
                                    m_Err[iC],
                                    m_Par[iC],
                                    N_proc,
                                    m_prop_config->finding_intra_layer_pflags,
                                    m_prop_config->finding_requires_propagation_to_hit_pos);
 
     dprint("m_Par[iP](0,0,0)=" << m_Par[iP](0, 0, 0) << " m_Par[iC](0,0,0)=" << m_Par[iC](0, 0, 0));
   }

◆ bestHitLastHoT()

HitOnTrack mkfit::MkFinder::bestHitLastHoT ( int itrack ) const

inline

Definition at line 93 of file MkFinder.h.

References m_HoTArrs, and m_NHits.

93 { return m_HoTArrs[itrack][m_NHits(itrack, 0, 0) - 1]; }

mkfit::MkFinder::m_HoTArrs

HitOnTrack m_HoTArrs[NN][Config::nMaxTrkHits]

Definition: MkFinder.h:268

mkfit::MkFinder::m_NHits

MPlexQI m_NHits

Definition: MkFinder.h:265

◆ bkFitFitTracks()

void mkfit::MkFinder::bkFitFitTracks	(	const EventOfHits &	eventofhits,
		const SteeringParams &	st_par,
		const int	N_proc,
		bool	chiDebug = `false`
	)

Definition at line 1582 of file MkFinder.cc.

References Matriplex::Matriplex< T, D1, D2, N >::add(), Matriplex::Matriplex< T, D1, D2, N >::At(), mkfit::PropagationConfig::backward_fit_pflags, Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), mps_fire::i, mkfit::MkBase::iC, createfilelist::int, mkfit::MkBase::iP, mkfit::LayerInfo::is_barrel(), mkfit::SteeringParams::iterator::is_valid(), mkfit::TrackBase::isFindable(), CommonMethods::isnan(), mkfit::SteeringParams::IT_BkwFit, mkfit::kalmanOperation(), mkfit::kalmanOperationEndcap(), mkfit::KFO_Calculate_Chi2, mkfit::KFO_Update_Params, dttmaxenums::L, mkfit::TrackBase::label(), phase1PixelTopology::layer, mkfit::MkBase::m_Chg, m_Chi2, m_CurNode, mkfit::MkBase::m_Err, m_HoTNodeArr, m_msErr, m_msPar, mkfit::MkBase::m_Par, mkfit::HoTNode::m_prev_idx, m_prop_config, m_TrkCand, mkfit::SteeringParams::make_iterator(), mkfit::Hit::mcHitID(), mkfit::MCHitInfo::mcTrackID(), dqmiodumpmetadata::n, mkfit::NN, mkfit::TrackBase::posEta(), mkfit::TrackBase::posPhi(), mkfit::TrackBase::prodType(), mkfit::MkBase::propagateTracksToHitR(), mkfit::MkBase::propagateTracksToHitZ(), mkfit::TrackBase::pT(), and Matriplex::Matriplex< T, D1, D2, N >::setVal().

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

                                                {
     // Prototyping final backward fit.
     // This works with track-finding indices, before remapping.
     //
     // Layers should be collected during track finding and list all layers that have actual hits.
     // Then we could avoid checking which layers actually do have hits.
 
     MPlexQF tmp_chi2;
     MPlexQI no_mat_effs;
     float tmp_err[6] = {666, 0, 666, 0, 0, 666};
     float tmp_pos[3];
 
     for (auto lp_iter = st_par.make_iterator(SteeringParams::IT_BkwFit); lp_iter.is_valid(); ++lp_iter) {
       const int layer = lp_iter.layer();
 
       const LayerOfHits &L = eventofhits[layer];
       const LayerInfo &LI = *L.layer_info();
 
       // XXXX
 #if defined(DEBUG_BACKWARD_FIT)
       const Hit *last_hit_ptr[NN];
 #endif
 
       no_mat_effs.setVal(0);
       int done_count = 0;
       int here_count = 0;
       for (int i = 0; i < N_proc; ++i) {
         while (m_CurNode[i] >= 0 && m_HoTNodeArr[i][m_CurNode[i]].m_hot.index < 0) {
           m_CurNode[i] = m_HoTNodeArr[i][m_CurNode[i]].m_prev_idx;
         }
 
         if (m_CurNode[i] < 0)
           ++done_count;
 
         if (m_CurNode[i] >= 0 && m_HoTNodeArr[i][m_CurNode[i]].m_hot.layer == layer) {
           // Skip the overlap hits -- if they exist.
           // 1. Overlap hit gets placed *after* the original hit in TrackCand::exportTrack()
           // which is *before* in the reverse iteration that we are doing here.
           // 2. Seed-hit merging can result in more than two hits per layer.
           // while (m_CurHit[i] > 0 && m_HoTArr[ i ][ m_CurHit[i] - 1 ].layer == layer) --m_CurHit[i];
           while (m_HoTNodeArr[i][m_CurNode[i]].m_prev_idx >= 0 &&
                  m_HoTNodeArr[i][m_HoTNodeArr[i][m_CurNode[i]].m_prev_idx].m_hot.layer == layer)
             m_CurNode[i] = m_HoTNodeArr[i][m_CurNode[i]].m_prev_idx;
 
           const Hit &hit = L.refHit(m_HoTNodeArr[i][m_CurNode[i]].m_hot.index);
 
 #ifdef DEBUG_BACKWARD_FIT
           last_hit_ptr[i] = &hit;
 #endif
           m_msErr.copyIn(i, hit.errArray());
           m_msPar.copyIn(i, hit.posArray());
           ++here_count;
 
           m_CurNode[i] = m_HoTNodeArr[i][m_CurNode[i]].m_prev_idx;
         } else {
 #ifdef DEBUG_BACKWARD_FIT
           last_hit_ptr[i] = nullptr;
 #endif
           no_mat_effs[i] = 1;
           tmp_pos[0] = m_Par[iC](i, 0, 0);
           tmp_pos[1] = m_Par[iC](i, 1, 0);
           tmp_pos[2] = m_Par[iC](i, 2, 0);
           m_msErr.copyIn(i, tmp_err);
           m_msPar.copyIn(i, tmp_pos);
         }
       }
 
       if (done_count == N_proc)
         break;
       if (here_count == 0)
         continue;
 
       // ZZZ Could add missing hits here, only if there are any actual matches.
 
       if (LI.is_barrel()) {
         propagateTracksToHitR(m_msPar, N_proc, m_prop_config->backward_fit_pflags, &no_mat_effs);
 
         kalmanOperation(KFO_Calculate_Chi2 | KFO_Update_Params,
                         m_Err[iP],
                         m_Par[iP],
                         m_msErr,
                         m_msPar,
                         m_Err[iC],
                         m_Par[iC],
                         tmp_chi2,
                         N_proc);
       } else {
         propagateTracksToHitZ(m_msPar, N_proc, m_prop_config->backward_fit_pflags, &no_mat_effs);
 
         kalmanOperationEndcap(KFO_Calculate_Chi2 | KFO_Update_Params,
                               m_Err[iP],
                               m_Par[iP],
                               m_msErr,
                               m_msPar,
                               m_Err[iC],
                               m_Par[iC],
                               tmp_chi2,
                               N_proc);
       }
 
       //fixup invpt sign and charge
       for (int n = 0; n < N_proc; ++n) {
         if (m_Par[iC].At(n, 3, 0) < 0) {
           m_Chg.At(n, 0, 0) = -m_Chg.At(n, 0, 0);
           m_Par[iC].At(n, 3, 0) = -m_Par[iC].At(n, 3, 0);
         }
       }
 
       for (int i = 0; i < N_proc; ++i) {
 #if defined(DEBUG_BACKWARD_FIT)
         if (chiDebug && last_hit_ptr[i]) {
           TrackCand &bb = *m_TrkCand[i];
           int ti = iP;
           float chi = tmp_chi2.At(i, 0, 0);
           float chi_prnt = std::isfinite(chi) ? chi : -9;
 
 #if defined(MKFIT_STANDALONE)
           const MCHitInfo &mchi = m_event->simHitsInfo_[last_hit_ptr[i]->mcHitID()];
 
           printf(
               "BKF_OVERLAP %d %d %d %d %d %d %d "
               "%f %f %f %f %d %d %d %d "
               "%f %f %f %f %f\n",
               m_event->evtID(),
 #else
           printf(
               "BKF_OVERLAP %d %d %d %d %d %d "
               "%f %f %f %f %d %d %d "
               "%f %f %f %f %f\n",
 #endif
               bb.label(),
               (int)bb.prodType(),
               bb.isFindable(),
               layer,
               L.is_stereo(),
               L.is_barrel(),
               bb.pT(),
               bb.posEta(),
               bb.posPhi(),
               chi_prnt,
               std::isnan(chi),
               std::isfinite(chi),
               chi > 0,
 #if defined(MKFIT_STANDALONE)
               mchi.mcTrackID(),
 #endif
               e2s(m_Err[ti].At(i, 0, 0)),
               e2s(m_Err[ti].At(i, 1, 1)),
               e2s(m_Err[ti].At(i, 2, 2)),  // sx_t sy_t sz_t -- track errors
               1e4f * std::hypot(m_msPar.At(i, 0, 0) - m_Par[ti].At(i, 0, 0),
                                 m_msPar.At(i, 1, 0) - m_Par[ti].At(i, 1, 0)),  // d_xy
               1e4f * (m_msPar.At(i, 2, 0) - m_Par[ti].At(i, 2, 0))             // d_z
           );
         }
 #endif
       }
 
       // update chi2
       m_Chi2.add(tmp_chi2);
     }
   }

◆ bkFitFitTracksBH()

void mkfit::MkFinder::bkFitFitTracksBH	(	const EventOfHits &	eventofhits,
		const SteeringParams &	st_par,
		const int	N_proc,
		bool	chiDebug = `false`
	)

Definition at line 1445 of file MkFinder.cc.

References Matriplex::Matriplex< T, D1, D2, N >::add(), Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::MatriplexSym< T, D, N >::At(), mkfit::PropagationConfig::backward_fit_pflags, Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), submitPVResolutionJobs::count, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, mkfit::LayerInfo::is_barrel(), mkfit::kalmanOperation(), mkfit::kalmanOperationEndcap(), mkfit::KFO_Calculate_Chi2, mkfit::KFO_Update_Params, dttmaxenums::L, phase1PixelTopology::layer, mkfit::MkBase::m_Chg, m_Chi2, m_CurHit, mkfit::MkBase::m_Err, m_HoTArr, mkfit::SteeringParams::m_layer_plan, m_msErr, m_msPar, mkfit::MkBase::m_Par, m_prop_config, dqmiodumpmetadata::n, mkfit::MkBase::propagateTracksToHitR(), and mkfit::MkBase::propagateTracksToHitZ().

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

                                                  {
     // Prototyping final backward fit.
     // This works with track-finding indices, before remapping.
     //
     // Layers should be collected during track finding and list all layers that have actual hits.
     // Then we could avoid checking which layers actually do have hits.
 
     MPlexQF tmp_chi2;
     float tmp_err[6] = {666, 0, 666, 0, 0, 666};
     float tmp_pos[3];
 
     for (auto lp_iter = st_par.m_layer_plan.rbegin(); lp_iter != st_par.m_layer_plan.rend(); ++lp_iter) {
       const int layer = lp_iter->m_layer;
 
       const LayerOfHits &L = eventofhits[layer];
       const LayerInfo &LI = *L.layer_info();
 
       int count = 0;
       for (int i = 0; i < N_proc; ++i) {
         while (m_CurHit[i] >= 0 && m_HoTArr[i][m_CurHit[i]].index < 0)
           --m_CurHit[i];
 
         if (m_CurHit[i] >= 0 && m_HoTArr[i][m_CurHit[i]].layer == layer) {
           // Skip the overlap hits -- if they exist.
           // 1. Overlap hit gets placed *after* the original hit in TrackCand::exportTrack()
           // which is *before* in the reverse iteration that we are doing here.
           // 2. Seed-hit merging can result in more than two hits per layer.
           while (m_CurHit[i] > 0 && m_HoTArr[i][m_CurHit[i] - 1].layer == layer)
             --m_CurHit[i];
 
           const Hit &hit = L.refHit(m_HoTArr[i][m_CurHit[i]].index);
           m_msErr.copyIn(i, hit.errArray());
           m_msPar.copyIn(i, hit.posArray());
           ++count;
           --m_CurHit[i];
         } else {
           tmp_pos[0] = m_Par[iC](i, 0, 0);
           tmp_pos[1] = m_Par[iC](i, 1, 0);
           tmp_pos[2] = m_Par[iC](i, 2, 0);
           m_msErr.copyIn(i, tmp_err);
           m_msPar.copyIn(i, tmp_pos);
         }
       }
 
       if (count == 0)
         continue;
 
       // ZZZ Could add missing hits here, only if there are any actual matches.
 
       if (LI.is_barrel()) {
         propagateTracksToHitR(m_msPar, N_proc, m_prop_config->backward_fit_pflags);
 
         kalmanOperation(KFO_Calculate_Chi2 | KFO_Update_Params,
                         m_Err[iP],
                         m_Par[iP],
                         m_msErr,
                         m_msPar,
                         m_Err[iC],
                         m_Par[iC],
                         tmp_chi2,
                         N_proc);
       } else {
         propagateTracksToHitZ(m_msPar, N_proc, m_prop_config->backward_fit_pflags);
 
         kalmanOperationEndcap(KFO_Calculate_Chi2 | KFO_Update_Params,
                               m_Err[iP],
                               m_Par[iP],
                               m_msErr,
                               m_msPar,
                               m_Err[iC],
                               m_Par[iC],
                               tmp_chi2,
                               N_proc);
       }
 
       //fixup invpt sign and charge
       for (int n = 0; n < N_proc; ++n) {
         if (m_Par[iC].At(n, 3, 0) < 0) {
           m_Chg.At(n, 0, 0) = -m_Chg.At(n, 0, 0);
           m_Par[iC].At(n, 3, 0) = -m_Par[iC].At(n, 3, 0);
         }
       }
 
 #ifdef DEBUG_BACKWARD_FIT_BH
       // Dump per hit chi2
       for (int i = 0; i < N_proc; ++i) {
         float r_h = std::hypot(m_msPar.At(i, 0, 0), m_msPar.At(i, 1, 0));
         float r_t = std::hypot(m_Par[iC].At(i, 0, 0), m_Par[iC].At(i, 1, 0));
 
         // if ((std::isnan(tmp_chi2[i]) || std::isnan(r_t)))
         // if ( ! std::isnan(tmp_chi2[i]) && tmp_chi2[i] > 0) // && tmp_chi2[i] > 30)
         if (chiDebug) {
           int ti = iP;
           printf(
               "CHIHIT %3d %10g %10g %10g %10g %10g %11.5g %11.5g %11.5g %10g %10g %10g %10g %11.5g %11.5g %11.5g %10g "
               "%10g %10g %10g %10g %11.5g %11.5g\n",
               layer,
               tmp_chi2[i],
               m_msPar.At(i, 0, 0),
               m_msPar.At(i, 1, 0),
               m_msPar.At(i, 2, 0),
               r_h,  // x_h y_h z_h r_h -- hit pos
               e2s(m_msErr.At(i, 0, 0)),
               e2s(m_msErr.At(i, 1, 1)),
               e2s(m_msErr.At(i, 2, 2)),  // ex_h ey_h ez_h -- hit errors
               m_Par[ti].At(i, 0, 0),
               m_Par[ti].At(i, 1, 0),
               m_Par[ti].At(i, 2, 0),
               r_t,  // x_t y_t z_t r_t -- track pos
               e2s(m_Err[ti].At(i, 0, 0)),
               e2s(m_Err[ti].At(i, 1, 1)),
               e2s(m_Err[ti].At(i, 2, 2)),  // ex_t ey_t ez_t -- track errors
               1.0f / m_Par[ti].At(i, 3, 0),
               m_Par[ti].At(i, 4, 0),
               m_Par[ti].At(i, 5, 0),                                     // pt, phi, theta
               std::atan2(m_msPar.At(i, 1, 0), m_msPar.At(i, 0, 0)),      // phi_h
               std::atan2(m_Par[ti].At(i, 1, 0), m_Par[ti].At(i, 0, 0)),  // phi_t
               1e4f * std::hypot(m_msPar.At(i, 0, 0) - m_Par[ti].At(i, 0, 0),
                                 m_msPar.At(i, 1, 0) - m_Par[ti].At(i, 1, 0)),  // d_xy
               1e4f * (m_msPar.At(i, 2, 0) - m_Par[ti].At(i, 2, 0))             // d_z
               // e2s((m_msErr.At(i,0,0) + m_msErr.At(i,1,1)) / (r_h * r_h)),     // ephi_h
               // e2s((m_Err[ti].At(i,0,0) + m_Err[ti].At(i,1,1)) / (r_t * r_t))  // ephi_t
           );
         }
       }
 #endif
 
       // update chi2
       m_Chi2.add(tmp_chi2);
     }
   }

◆ bkFitInputTracks() [1/2]

void mkfit::MkFinder::bkFitInputTracks	(	TrackVec &	cands,
		int	beg,
		int	end
	)

Definition at line 1340 of file MkFinder.cc.

References mkfit::MatriplexErrParPackerSlurpIn< T, D >::addInput(), HLT_2022v12_cff::cands, mkfit::TrackBase::charge(), mps_fire::end, f, mkfit::Track::getHitsOnTrackArray(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::m_Chg, m_Chi2, m_CurHit, mkfit::MkBase::m_Err, m_HoTArr, mkfit::MkBase::m_Par, mkfit::Track::nTotalHits(), mkfit::MatriplexErrParPackerSlurpIn< T, D >::pack(), Matriplex::MatriplexSym< T, D, N >::scale(), and Matriplex::Matriplex< T, D1, D2, N >::setVal().

Referenced by mkfit::MkBuilder::fit_cands(), and mkfit::MkBuilder::fit_cands_BH().

                                                                    {
     // Uses HitOnTrack vector from Track directly + a local cursor array to current hit.
 
     MatriplexTrackPacker mtp(&cands[beg]);
 
     int itrack = 0;
 
     for (int i = beg; i < end; ++i, ++itrack) {
       const Track &trk = cands[i];
 
       m_Chg(itrack, 0, 0) = trk.charge();
       m_CurHit[itrack] = trk.nTotalHits() - 1;
       m_HoTArr[itrack] = trk.getHitsOnTrackArray();
 
       mtp.addInput(trk);
     }
 
     m_Chi2.setVal(0);
 
     mtp.pack(m_Err[iC], m_Par[iC]);
 
     m_Err[iC].scale(100.0f);
   }

◆ bkFitInputTracks() [2/2]

void mkfit::MkFinder::bkFitInputTracks	(	EventOfCombCandidates &	eocss,
		int	beg,
		int	end
	)

Definition at line 1364 of file MkFinder.cc.

References mkfit::MatriplexErrParPackerSlurpIn< T, D >::addInput(), mkfit::TrackBase::charge(), mkfit::TrackCand::combCandidate(), mps_fire::end, f, mkfit::CombCandidate::hotsData(), mps_fire::i, mkfit::MkBase::iC, mkfit::TrackCand::lastCcIndex(), mkfit::MkBase::m_Chg, m_Chi2, m_CurNode, mkfit::MkBase::m_Err, m_HoTNodeArr, mkfit::MkBase::m_Par, m_TrkCand, mkfit::MatriplexErrParPackerSlurpIn< T, D >::pack(), Matriplex::MatriplexSym< T, D, N >::scale(), and Matriplex::Matriplex< T, D1, D2, N >::setVal().

                                                                                 {
     // Could as well use HotArrays from tracks directly + a local cursor array to last hit.
 
     // XXXX - shall we assume only TrackCand-zero is needed and that we can freely
     // bork the HoTNode array?
 
     MatriplexTrackPacker mtp(&eocss[beg][0]);
 
     int itrack = 0;
 
     for (int i = beg; i < end; ++i, ++itrack) {
       const TrackCand &trk = eocss[i][0];
 
       m_Chg(itrack, 0, 0) = trk.charge();
       m_CurNode[itrack] = trk.lastCcIndex();
       m_HoTNodeArr[itrack] = trk.combCandidate()->hotsData();
 
       // XXXX Need TrackCand* to update num-hits. Unless I collect info elsewhere
       // and fix it in BkFitOutputTracks.
       m_TrkCand[itrack] = &eocss[i][0];
 
       mtp.addInput(trk);
     }
 
     m_Chi2.setVal(0);
 
     mtp.pack(m_Err[iC], m_Par[iC]);
 
     m_Err[iC].scale(100.0f);
   }

◆ bkFitOutputTracks() [1/2]

void mkfit::MkFinder::bkFitOutputTracks	(	TrackVec &	cands,
		int	beg,
		int	end,
		bool	outputProp
	)

Definition at line 1397 of file MkFinder.cc.

References HLT_2022v12_cff::cands, mkfit::TrackBase::chi2(), Matriplex::Matriplex< T, D1, D2, N >::copyOut(), Matriplex::MatriplexSym< T, D, N >::copyOut(), mps_fire::end, mkfit::TrackBase::errors_nc(), mkfit::getScoreCand(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, edm::isFinite(), m_Chi2, mkfit::MkBase::m_Err, mkfit::MkBase::m_Par, mkfit::TrackBase::parameters_nc(), mkfit::TrackBase::setChi2(), and mkfit::TrackBase::setScore().

Referenced by mkfit::MkBuilder::fit_cands(), and mkfit::MkBuilder::fit_cands_BH().

                                                                                      {
     // Only copy out track params / errors / chi2, all the rest is ok.
 
     const int iO = outputProp ? iP : iC;
 
     int itrack = 0;
     for (int i = beg; i < end; ++i, ++itrack) {
       Track &trk = cands[i];
 
       m_Err[iO].copyOut(itrack, trk.errors_nc().Array());
       m_Par[iO].copyOut(itrack, trk.parameters_nc().Array());
 
       trk.setChi2(m_Chi2(itrack, 0, 0));
       if (isFinite(trk.chi2())) {
         trk.setScore(getScoreCand(trk));
       }
     }
   }

◆ bkFitOutputTracks() [2/2]

void mkfit::MkFinder::bkFitOutputTracks	(	EventOfCombCandidates &	eocss,
		int	beg,
		int	end,
		bool	outputProp
	)

Definition at line 1416 of file MkFinder.cc.

References mkfit::TrackBase::chi2(), Matriplex::Matriplex< T, D1, D2, N >::copyOut(), Matriplex::MatriplexSym< T, D, N >::copyOut(), mps_fire::end, mkfit::TrackBase::errors_nc(), mkfit::getScoreCand(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, edm::isFinite(), m_Chi2, mkfit::MkBase::m_Err, mkfit::MkBase::m_Par, mkfit::TrackBase::parameters_nc(), mkfit::TrackBase::setChi2(), and mkfit::TrackBase::setScore().

                                                                                                   {
     // Only copy out track params / errors / chi2, all the rest is ok.
 
     // XXXX - where will rejected hits get removed?
 
     const int iO = outputProp ? iP : iC;
 
     int itrack = 0;
     for (int i = beg; i < end; ++i, ++itrack) {
       TrackCand &trk = eocss[i][0];
 
       m_Err[iO].copyOut(itrack, trk.errors_nc().Array());
       m_Par[iO].copyOut(itrack, trk.parameters_nc().Array());
 
       trk.setChi2(m_Chi2(itrack, 0, 0));
       if (isFinite(trk.chi2())) {
         trk.setScore(getScoreCand(trk));
       }
     }
   }

◆ bkFitPropTracksToPCA()

void mkfit::MkFinder::bkFitPropTracksToPCA ( const int N_proc )

Definition at line 1749 of file MkFinder.cc.

References m_prop_config, mkfit::PropagationConfig::pca_prop_pflags, and mkfit::MkBase::propagateTracksToPCAZ().

Referenced by mkfit::MkBuilder::fit_cands(), and mkfit::MkBuilder::fit_cands_BH().

                                                       {
     propagateTracksToPCAZ(N_proc, m_prop_config->pca_prop_pflags);
   }

◆ copy_in() [1/2]

void mkfit::MkFinder::copy_in	(	const Track &	trk,
		const int	mslot,
		const int	tslot
	)

inlineprivate

Definition at line 150 of file MkFinder.h.

References mkfit::Track::beginHitsOnTrack(), mkfit::TrackBase::charge(), mkfit::TrackBase::chi2(), filterCSVwithJSON::copy, Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), mkfit::Track::endHitsOnTrack(), mkfit::TrackBase::errors(), mkfit::TrackBase::label(), mkfit::MkBase::m_Chg, m_Chi2, mkfit::MkBase::m_Err, m_HoTArrs, m_Label, m_NFoundHits, m_NHits, m_NInsideMinusOneHits, m_NTailMinusOneHits, mkfit::MkBase::m_Par, mkfit::Track::nFoundHits(), mkfit::Track::nInsideMinusOneHits(), mkfit::Track::nTailMinusOneHits(), mkfit::Track::nTotalHits(), and mkfit::TrackBase::parameters().

Referenced by inputTracksAndHitIdx().

                                                                      {
       m_Err[tslot].copyIn(mslot, trk.errors().Array());
       m_Par[tslot].copyIn(mslot, trk.parameters().Array());
 
       m_Chg(mslot, 0, 0) = trk.charge();
       m_Chi2(mslot, 0, 0) = trk.chi2();
       m_Label(mslot, 0, 0) = trk.label();
 
       m_NHits(mslot, 0, 0) = trk.nTotalHits();
       m_NFoundHits(mslot, 0, 0) = trk.nFoundHits();
 
       m_NInsideMinusOneHits(mslot, 0, 0) = trk.nInsideMinusOneHits();
       m_NTailMinusOneHits(mslot, 0, 0) = trk.nTailMinusOneHits();
 
       std::copy(trk.beginHitsOnTrack(), trk.endHitsOnTrack(), m_HoTArrs[mslot]);
     }

◆ copy_in() [2/2]

void mkfit::MkFinder::copy_in	(	const TrackCand &	trk,
		const int	mslot,
		const int	tslot
	)

inlineprivate

Definition at line 179 of file MkFinder.h.

References mkfit::TrackBase::charge(), mkfit::TrackBase::chi2(), mkfit::TrackCand::combCandidate(), Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), mkfit::TrackBase::errors(), mkfit::TrackCand::getLastHitOnTrack(), mkfit::TrackBase::getStatus(), mkfit::TrackBase::label(), mkfit::TrackCand::lastCcIndex(), mkfit::MkBase::m_Chg, m_Chi2, m_CombCand, mkfit::MkBase::m_Err, m_Label, m_LastHitCcIndex, m_LastHoT, m_NFoundHits, m_NInsideMinusOneHits, m_NMissingHits, m_NOverlapHits, m_NTailMinusOneHits, mkfit::MkBase::m_Par, m_TrkStatus, mkfit::TrackCand::nFoundHits(), mkfit::TrackCand::nInsideMinusOneHits(), mkfit::TrackCand::nMissingHits(), mkfit::TrackCand::nOverlapHits(), mkfit::TrackCand::nTailMinusOneHits(), and mkfit::TrackBase::parameters().

                                                                          {
       m_Err[tslot].copyIn(mslot, trk.errors().Array());
       m_Par[tslot].copyIn(mslot, trk.parameters().Array());
 
       m_Chg(mslot, 0, 0) = trk.charge();
       m_Chi2(mslot, 0, 0) = trk.chi2();
       m_Label(mslot, 0, 0) = trk.label();
 
       m_LastHitCcIndex(mslot, 0, 0) = trk.lastCcIndex();
       m_NFoundHits(mslot, 0, 0) = trk.nFoundHits();
       m_NMissingHits(mslot, 0, 0) = trk.nMissingHits();
       m_NOverlapHits(mslot, 0, 0) = trk.nOverlapHits();
 
       m_NInsideMinusOneHits(mslot, 0, 0) = trk.nInsideMinusOneHits();
       m_NTailMinusOneHits(mslot, 0, 0) = trk.nTailMinusOneHits();
 
       m_LastHoT[mslot] = trk.getLastHitOnTrack();
       m_CombCand[mslot] = trk.combCandidate();
       m_TrkStatus[mslot] = trk.getStatus();
     }

◆ copy_out() [1/2]

void mkfit::MkFinder::copy_out	(	Track &	trk,
		const int	mslot,
		const int	tslot
	)		const

inlineprivate

Definition at line 167 of file MkFinder.h.

References mkfit::Track::beginHitsOnTrack_nc(), filterCSVwithJSON::copy, Matriplex::Matriplex< T, D1, D2, N >::copyOut(), Matriplex::MatriplexSym< T, D, N >::copyOut(), mkfit::TrackBase::errors_nc(), mkfit::MkBase::m_Chg, m_Chi2, mkfit::MkBase::m_Err, m_HoTArrs, m_Label, m_NFoundHits, m_NHits, mkfit::MkBase::m_Par, mkfit::TrackBase::parameters_nc(), mkfit::Track::resizeHits(), mkfit::TrackBase::setCharge(), mkfit::TrackBase::setChi2(), and mkfit::TrackBase::setLabel().

Referenced by findCandidates(), outputNonStoppedTracksAndHitIdx(), outputTrackAndHitIdx(), and outputTracksAndHitIdx().

                                                                       {
       m_Err[tslot].copyOut(mslot, trk.errors_nc().Array());
       m_Par[tslot].copyOut(mslot, trk.parameters_nc().Array());
 
       trk.setCharge(m_Chg(mslot, 0, 0));
       trk.setChi2(m_Chi2(mslot, 0, 0));
       trk.setLabel(m_Label(mslot, 0, 0));
 
       trk.resizeHits(m_NHits(mslot, 0, 0), m_NFoundHits(mslot, 0, 0));
       std::copy(m_HoTArrs[mslot], &m_HoTArrs[mslot][m_NHits(mslot, 0, 0)], trk.beginHitsOnTrack_nc());
     }

◆ copy_out() [2/2]

void mkfit::MkFinder::copy_out	(	TrackCand &	trk,
		const int	mslot,
		const int	tslot
	)		const

inlineprivate

Definition at line 200 of file MkFinder.h.

References Matriplex::Matriplex< T, D1, D2, N >::copyOut(), Matriplex::MatriplexSym< T, D, N >::copyOut(), mkfit::TrackBase::errors_nc(), mkfit::MkBase::m_Chg, m_Chi2, m_CombCand, mkfit::MkBase::m_Err, m_Label, m_LastHitCcIndex, m_NFoundHits, m_NInsideMinusOneHits, m_NMissingHits, m_NOverlapHits, m_NTailMinusOneHits, mkfit::MkBase::m_Par, m_TrkStatus, mkfit::TrackBase::parameters_nc(), mkfit::TrackBase::setCharge(), mkfit::TrackBase::setChi2(), mkfit::TrackCand::setCombCandidate(), mkfit::TrackBase::setLabel(), mkfit::TrackCand::setLastCcIndex(), mkfit::TrackCand::setNFoundHits(), mkfit::TrackCand::setNInsideMinusOneHits(), mkfit::TrackCand::setNMissingHits(), mkfit::TrackCand::setNOverlapHits(), mkfit::TrackCand::setNTailMinusOneHits(), and mkfit::TrackBase::setStatus().

                                                                           {
       m_Err[tslot].copyOut(mslot, trk.errors_nc().Array());
       m_Par[tslot].copyOut(mslot, trk.parameters_nc().Array());
 
       trk.setCharge(m_Chg(mslot, 0, 0));
       trk.setChi2(m_Chi2(mslot, 0, 0));
       trk.setLabel(m_Label(mslot, 0, 0));
 
       trk.setLastCcIndex(m_LastHitCcIndex(mslot, 0, 0));
       trk.setNFoundHits(m_NFoundHits(mslot, 0, 0));
       trk.setNMissingHits(m_NMissingHits(mslot, 0, 0));
       trk.setNOverlapHits(m_NOverlapHits(mslot, 0, 0));
 
       trk.setNInsideMinusOneHits(m_NInsideMinusOneHits(mslot, 0, 0));
       trk.setNTailMinusOneHits(m_NTailMinusOneHits(mslot, 0, 0));
 
       trk.setCombCandidate(m_CombCand[mslot]);
       trk.setStatus(m_TrkStatus[mslot]);
     }

◆ copyOutParErr()

void mkfit::MkFinder::copyOutParErr	(	std::vector< CombCandidate > &	seed_cand_vec,
		int	N_proc,
		bool	outputProp
	)		const

Definition at line 1319 of file MkFinder.cc.

References Matriplex::Matriplex< T, D1, D2, N >::copyOut(), Matriplex::MatriplexSym< T, D, N >::copyOut(), dprint, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, m_CandIdx, mkfit::MkBase::m_Chg, mkfit::MkBase::m_Err, mkfit::MkBase::m_Par, and m_SeedIdx.

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

                                                                                                          {
     const int iO = outputProp ? iP : iC;
 
     for (int i = 0; i < N_proc; ++i) {
       TrackCand &cand = seed_cand_vec[m_SeedIdx(i, 0, 0)][m_CandIdx(i, 0, 0)];
 
       // Set the track state to the updated parameters
       m_Err[iO].copyOut(i, cand.errors_nc().Array());
       m_Par[iO].copyOut(i, cand.parameters_nc().Array());
       cand.setCharge(m_Chg(i, 0, 0));
 
       dprint((outputProp ? "propagated" : "updated")
              << " track parameters x=" << cand.parameters()[0] << " y=" << cand.parameters()[1]
              << " z=" << cand.parameters()[2] << " pt=" << 1. / cand.parameters()[3] << " posEta=" << cand.posEta());
     }
   }

◆ findCandidates()

void mkfit::MkFinder::findCandidates	(	const LayerOfHits &	layer_of_hits,
		std::vector< std::vector< TrackCand >> &	tmp_candidates,
		const int	offset,
		const int	N_proc,
		const FindingFoos &	fnd_foos
	)

Definition at line 865 of file MkFinder.cc.

References funct::abs(), mkfit::TrackCand::addHitIdx(), Matriplex::Matriplex< T, D1, D2, N >::At(), hltPixelTracks_cff::chi2, mkfit::TrackCand::combCandidate(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), copy_out(), mkfit::Hit::detIDinLayer(), dprint, dprintf, mkfit::PropagationConfig::finding_intra_layer_pflags, mkfit::PropagationConfig::finding_requires_propagation_to_hit_pos, getHitSelDynamicChi2Cut(), mkfit::getScoreCand(), mkfit::LayerOfHits::hitArray(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, mkfit::LayerOfHits::is_barrel(), mkfit::LayerOfHits::is_pixel(), mkfit::isStripQCompatible(), mkfit::Hit::kHitEdgeIdx, mkfit::Hit::kHitInGapIdx, mkfit::Hit::kHitMaxClusterIdx, mkfit::Hit::kHitMissIdx, mkfit::Hit::kHitStopIdx, phase1PixelTopology::layer, mkfit::LayerOfHits::layer_id(), m_CandIdx, mkfit::MkBase::m_Chg, mkfit::FindingFoos::m_compute_chi2_foo, mkfit::MkBase::m_Err, m_HoTArrs, m_iteration_params, m_msErr, m_msPar, m_NFoundHits, m_NTailMinusOneHits, mkfit::MkBase::m_Par, m_prop_config, m_SeedIdx, mkfit::FindingFoos::m_update_param_foo, m_XHitArr, m_XHitSize, m_XWsrResult, SiStripPI::max, mkfit::IterationParams::maxClusterSize, mkfit::IterationParams::maxConsecHoles, NuclearSeed_cfi::maxHits, mkfit::IterationParams::maxHolesPerCand, reco_skim_cfg_mod::maxSize, mkfit::Hit::minChargePerCM(), mkfit::NN, num_all_minus_one_hits(), hltrates_dqm_sourceclient-live_cfg::offset, mkfit::TrackBase::parameters(), mkfit::passStripChargePCMfromTrack(), mkfit::LayerOfHits::refHit(), mkfit::TrackBase::setCharge(), mkfit::TrackCand::setOriginIndex(), mkfit::TrackBase::setScore(), mkfit::WSR_Edge, and mkfit::WSR_Outside.

                                                              {
     // bool debug = true;
 
     MatriplexHitPacker mhp(layer_of_hits.hitArray());
 
     int maxSize = 0;
 
     // Determine maximum number of hits for tracks in the collection.
     for (int it = 0; it < NN; ++it) {
       if (it < N_proc) {
         if (m_XHitSize[it] > 0) {
           maxSize = std::max(maxSize, m_XHitSize[it]);
         }
       }
     }
 
     dprintf("FindCandidates max hits to process=%d\n", maxSize);
 
     int nHitsAdded[NN]{};
     bool isTooLargeCluster[NN]{false};
 
     for (int hit_cnt = 0; hit_cnt < maxSize; ++hit_cnt) {
       mhp.reset();
 
       int charge_pcm[NN];
 
 #pragma omp simd
       for (int itrack = 0; itrack < N_proc; ++itrack) {
         if (hit_cnt < m_XHitSize[itrack]) {
           const auto &hit = layer_of_hits.refHit(m_XHitArr.At(itrack, hit_cnt, 0));
           mhp.addInputAt(itrack, hit);
           charge_pcm[itrack] = hit.chargePerCM();
         }
       }
 
       mhp.pack(m_msErr, m_msPar);
 
       //now compute the chi2 of track state vs hit
       MPlexQF outChi2;
       MPlexLV propPar;
       (*fnd_foos.m_compute_chi2_foo)(m_Err[iP],
                                      m_Par[iP],
                                      m_Chg,
                                      m_msErr,
                                      m_msPar,
                                      outChi2,
                                      propPar,
                                      N_proc,
                                      m_prop_config->finding_intra_layer_pflags,
                                      m_prop_config->finding_requires_propagation_to_hit_pos);
 
       // Now update the track parameters with this hit (note that some
       // calculations are already done when computing chi2, to be optimized).
       // 1. This is not needed for candidates the hit is not added to, but it's
       // vectorized so doing it serially below should take the same time.
       // 2. Still it's a waste of time in case the hit is not added to any of the
       // candidates, so check beforehand that at least one cand needs update.
       bool oneCandPassCut = false;
       for (int itrack = 0; itrack < N_proc; ++itrack) {
         float max_c2 = getHitSelDynamicChi2Cut(itrack, iP);
 
         if (hit_cnt < m_XHitSize[itrack]) {
           const float chi2 = std::abs(outChi2[itrack]);  //fixme negative chi2 sometimes...
           dprint("chi2=" << chi2);
           if (chi2 < max_c2) {
             bool isCompatible = true;
             if (!layer_of_hits.is_pixel()) {
               //check module compatibility via long strip side = L/sqrt(12)
               isCompatible =
                   isStripQCompatible(itrack, layer_of_hits.is_barrel(), m_Err[iP], propPar, m_msErr, m_msPar);
 
               //rescale strip charge to track parameters and reapply the cut
               isCompatible &= passStripChargePCMfromTrack(
                   itrack, layer_of_hits.is_barrel(), charge_pcm[itrack], Hit::minChargePerCM(), propPar, m_msErr);
             }
             // Select only SiStrip hits with cluster size < maxClusterSize
             if (!layer_of_hits.is_pixel()) {
               if (layer_of_hits.refHit(m_XHitArr.At(itrack, hit_cnt, 0)).spanRows() >=
                   m_iteration_params->maxClusterSize) {
                 isTooLargeCluster[itrack] = true;
                 isCompatible = false;
               }
             }
 
             if (isCompatible) {
               oneCandPassCut = true;
               break;
             }
           }
         }
       }
 
       if (oneCandPassCut) {
         MPlexQI tmpChg = m_Chg;
         (*fnd_foos.m_update_param_foo)(m_Err[iP],
                                        m_Par[iP],
                                        tmpChg,
                                        m_msErr,
                                        m_msPar,
                                        m_Err[iC],
                                        m_Par[iC],
                                        N_proc,
                                        m_prop_config->finding_intra_layer_pflags,
                                        m_prop_config->finding_requires_propagation_to_hit_pos);
 
         dprint("update parameters" << std::endl
                                    << "propagated track parameters x=" << m_Par[iP].constAt(0, 0, 0)
                                    << " y=" << m_Par[iP].constAt(0, 1, 0) << std::endl
                                    << "               hit position x=" << m_msPar.constAt(0, 0, 0)
                                    << " y=" << m_msPar.constAt(0, 1, 0) << std::endl
                                    << "   updated track parameters x=" << m_Par[iC].constAt(0, 0, 0)
                                    << " y=" << m_Par[iC].constAt(0, 1, 0));
 
         //create candidate with hit in case chi2 < max_c2
         //fixme: please vectorize me... (not sure it's possible in this case)
         for (int itrack = 0; itrack < N_proc; ++itrack) {
           float max_c2 = getHitSelDynamicChi2Cut(itrack, iP);
 
           if (hit_cnt < m_XHitSize[itrack]) {
             const float chi2 = std::abs(outChi2[itrack]);  //fixme negative chi2 sometimes...
             dprint("chi2=" << chi2);
             if (chi2 < max_c2) {
               bool isCompatible = true;
               if (!layer_of_hits.is_pixel()) {
                 //check module compatibility via long strip side = L/sqrt(12)
                 isCompatible =
                     isStripQCompatible(itrack, layer_of_hits.is_barrel(), m_Err[iP], propPar, m_msErr, m_msPar);
 
                 //rescale strip charge to track parameters and reapply the cut
                 isCompatible &= passStripChargePCMfromTrack(
                     itrack, layer_of_hits.is_barrel(), charge_pcm[itrack], Hit::minChargePerCM(), propPar, m_msErr);
               }
               // Select only SiStrip hits with cluster size < maxClusterSize
               if (!layer_of_hits.is_pixel()) {
                 if (layer_of_hits.refHit(m_XHitArr.At(itrack, hit_cnt, 0)).spanRows() >=
                     m_iteration_params->maxClusterSize)
                   isCompatible = false;
               }
 
               if (isCompatible) {
                 bool hitExists = false;
                 int maxHits = m_NFoundHits(itrack, 0, 0);
                 if (layer_of_hits.is_pixel()) {
                   for (int i = 0; i <= maxHits; ++i) {
                     if (i > 2)
                       break;
                     if (m_HoTArrs[itrack][i].layer == layer_of_hits.layer_id()) {
                       hitExists = true;
                       break;
                     }
                   }
                 }
                 if (hitExists)
                   continue;
 
                 nHitsAdded[itrack]++;
                 dprint("chi2 cut passed, creating new candidate");
                 // Create a new candidate and fill the tmp_candidates output vector.
                 // QQQ only instantiate if it will pass, be better than N_best
 
                 const int hit_idx = m_XHitArr.At(itrack, hit_cnt, 0);
 
                 TrackCand newcand;
                 copy_out(newcand, itrack, iC);
                 newcand.setCharge(tmpChg(itrack, 0, 0));
                 newcand.addHitIdx(hit_idx, layer_of_hits.layer_id(), chi2);
                 newcand.setScore(getScoreCand(newcand, true /*penalizeTailMissHits*/, true /*inFindCandidates*/));
                 newcand.setOriginIndex(m_CandIdx(itrack, 0, 0));
 
                 // To apply a fixed cut instead of dynamic cut for overlap: m_iteration_params->chi2CutOverlap
                 if (chi2 < max_c2) {
                   CombCandidate &ccand = *newcand.combCandidate();
                   ccand[m_CandIdx(itrack, 0, 0)].considerHitForOverlap(
                       hit_idx, layer_of_hits.refHit(hit_idx).detIDinLayer(), chi2);
                 }
 
                 dprint("updated track parameters x=" << newcand.parameters()[0] << " y=" << newcand.parameters()[1]
                                                      << " z=" << newcand.parameters()[2]
                                                      << " pt=" << 1. / newcand.parameters()[3]);
 
                 tmp_candidates[m_SeedIdx(itrack, 0, 0) - offset].emplace_back(newcand);
               }
             }
           }
         }
       }  //end if (oneCandPassCut)
 
     }  //end loop over hits
 
     //now add invalid hit
     //fixme: please vectorize me...
     for (int itrack = 0; itrack < N_proc; ++itrack) {
       // Cands that miss the layer are stashed away in MkBuilder(), before propagation,
       // and then merged back afterwards.
       if (m_XWsrResult[itrack].m_wsr == WSR_Outside) {
         continue;
       }
 
       int fake_hit_idx = ((num_all_minus_one_hits(itrack) < m_iteration_params->maxHolesPerCand) &&
                           (m_NTailMinusOneHits(itrack, 0, 0) < m_iteration_params->maxConsecHoles))
                              ? Hit::kHitMissIdx
                              : Hit::kHitStopIdx;
 
       if (m_XWsrResult[itrack].m_wsr == WSR_Edge) {
         // YYYYYY m_iteration_params->store_missed_layers
         fake_hit_idx = Hit::kHitEdgeIdx;
       }
       //now add fake hit for tracks that passsed through inactive modules
       else if (m_XWsrResult[itrack].m_in_gap == true && nHitsAdded[itrack] == 0) {
         fake_hit_idx = Hit::kHitInGapIdx;
       }
       //now add fake hit for cases where hit cluster size is larger than maxClusterSize
       else if (isTooLargeCluster[itrack] == true && nHitsAdded[itrack] == 0) {
         fake_hit_idx = Hit::kHitMaxClusterIdx;
       }
 
       dprint("ADD FAKE HIT FOR TRACK #" << itrack << " withinBounds=" << (fake_hit_idx != Hit::kHitEdgeIdx)
                                         << " r=" << std::hypot(m_Par[iP](itrack, 0, 0), m_Par[iP](itrack, 1, 0)));
 
       // QQQ as above, only create and add if score better
       TrackCand newcand;
       copy_out(newcand, itrack, iP);
       newcand.addHitIdx(fake_hit_idx, layer_of_hits.layer_id(), 0.);
       newcand.setScore(getScoreCand(newcand, true /*penalizeTailMissHits*/, true /*inFindCandidates*/));
       // Only relevant when we actually add a hit
       // newcand.setOriginIndex(m_CandIdx(itrack, 0, 0));
       tmp_candidates[m_SeedIdx(itrack, 0, 0) - offset].emplace_back(newcand);
     }
   }

◆ findCandidatesCloneEngine()

void mkfit::MkFinder::findCandidatesCloneEngine	(	const LayerOfHits &	layer_of_hits,
		CandCloner &	cloner,
		const int	offset,
		const int	N_proc,
		const FindingFoos &	fnd_foos
	)

Definition at line 1103 of file MkFinder.cc.

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

                                                                         {
     // bool debug = true;
 
     MatriplexHitPacker mhp(layer_of_hits.hitArray());
 
     int maxSize = 0;
 
     // Determine maximum number of hits for tracks in the collection.
 #pragma omp simd
     for (int it = 0; it < NN; ++it) {
       if (it < N_proc) {
         if (m_XHitSize[it] > 0) {
           maxSize = std::max(maxSize, m_XHitSize[it]);
         }
       }
     }
 
     dprintf("FindCandidatesCloneEngine max hits to process=%d\n", maxSize);
 
     int nHitsAdded[NN]{};
     bool isTooLargeCluster[NN]{false};
 
     for (int hit_cnt = 0; hit_cnt < maxSize; ++hit_cnt) {
       mhp.reset();
 
       int charge_pcm[NN];
 
 #pragma omp simd
       for (int itrack = 0; itrack < N_proc; ++itrack) {
         if (hit_cnt < m_XHitSize[itrack]) {
           const auto &hit = layer_of_hits.refHit(m_XHitArr.At(itrack, hit_cnt, 0));
           mhp.addInputAt(itrack, hit);
           charge_pcm[itrack] = hit.chargePerCM();
         }
       }
 
       mhp.pack(m_msErr, m_msPar);
 
       //now compute the chi2 of track state vs hit
       MPlexQF outChi2;
       MPlexLV propPar;
       (*fnd_foos.m_compute_chi2_foo)(m_Err[iP],
                                      m_Par[iP],
                                      m_Chg,
                                      m_msErr,
                                      m_msPar,
                                      outChi2,
                                      propPar,
                                      N_proc,
                                      m_prop_config->finding_intra_layer_pflags,
                                      m_prop_config->finding_requires_propagation_to_hit_pos);
 
 #pragma omp simd  // DOES NOT VECTORIZE AS IT IS NOW
       for (int itrack = 0; itrack < N_proc; ++itrack) {
         // make sure the hit was in the compatiblity window for the candidate
 
         float max_c2 = getHitSelDynamicChi2Cut(itrack, iP);
 
         if (hit_cnt < m_XHitSize[itrack]) {
           // XXX-NUM-ERR assert(chi2 >= 0);
           const float chi2 = std::abs(outChi2[itrack]);  //fixme negative chi2 sometimes...
 
           dprint("chi2=" << chi2 << " for trkIdx=" << itrack << " hitIdx=" << m_XHitArr.At(itrack, hit_cnt, 0));
           if (chi2 < max_c2) {
             bool isCompatible = true;
             if (!layer_of_hits.is_pixel()) {
               //check module compatibility via long strip side = L/sqrt(12)
               isCompatible =
                   isStripQCompatible(itrack, layer_of_hits.is_barrel(), m_Err[iP], propPar, m_msErr, m_msPar);
 
               //rescale strip charge to track parameters and reapply the cut
               isCompatible &= passStripChargePCMfromTrack(
                   itrack, layer_of_hits.is_barrel(), charge_pcm[itrack], Hit::minChargePerCM(), propPar, m_msErr);
             }
 
             // Select only SiStrip hits with cluster size < maxClusterSize
             if (!layer_of_hits.is_pixel()) {
               if (layer_of_hits.refHit(m_XHitArr.At(itrack, hit_cnt, 0)).spanRows() >=
                   m_iteration_params->maxClusterSize) {
                 isTooLargeCluster[itrack] = true;
                 isCompatible = false;
               }
             }
 
             if (isCompatible) {
               CombCandidate &ccand = cloner.combCandWithOriginalIndex(m_SeedIdx(itrack, 0, 0));
               bool hitExists = false;
               int maxHits = m_NFoundHits(itrack, 0, 0);
               if (layer_of_hits.is_pixel()) {
                 for (int i = 0; i <= maxHits; ++i) {
                   if (i > 2)
                     break;
                   if (ccand.hot(i).layer == layer_of_hits.layer_id()) {
                     hitExists = true;
                     break;
                   }
                 }
               }
               if (hitExists)
                 continue;
 
               nHitsAdded[itrack]++;
               const int hit_idx = m_XHitArr.At(itrack, hit_cnt, 0);
 
               // Register hit for overlap consideration, if chi2 cut is passed
               // To apply a fixed cut instead of dynamic cut for overlap: m_iteration_params->chi2CutOverlap
               if (chi2 < max_c2) {
                 ccand[m_CandIdx(itrack, 0, 0)].considerHitForOverlap(
                     hit_idx, layer_of_hits.refHit(hit_idx).detIDinLayer(), chi2);
               }
 
               IdxChi2List tmpList;
               tmpList.trkIdx = m_CandIdx(itrack, 0, 0);
               tmpList.hitIdx = hit_idx;
               tmpList.module = layer_of_hits.refHit(hit_idx).detIDinLayer();
               tmpList.nhits = m_NFoundHits(itrack, 0, 0) + 1;
               tmpList.ntailholes = 0;
               tmpList.noverlaps = m_NOverlapHits(itrack, 0, 0);
               tmpList.nholes = num_all_minus_one_hits(itrack);
               tmpList.pt = std::abs(1.0f / m_Par[iP].At(itrack, 3, 0));
               tmpList.chi2 = m_Chi2(itrack, 0, 0) + chi2;
               tmpList.chi2_hit = chi2;
               tmpList.score = getScoreStruct(tmpList);
               cloner.add_cand(m_SeedIdx(itrack, 0, 0) - offset, tmpList);
 
               dprint("  adding hit with hit_cnt=" << hit_cnt << " for trkIdx=" << tmpList.trkIdx
                                                   << " orig Seed=" << m_Label(itrack, 0, 0));
             }
           }
         }
       }
 
     }  //end loop over hits
 
     //now add invalid hit
     for (int itrack = 0; itrack < N_proc; ++itrack) {
       dprint("num_all_minus_one_hits(" << itrack << ")=" << num_all_minus_one_hits(itrack));
 
       // Cands that miss the layer are stashed away in MkBuilder(), before propagation,
       // and then merged back afterwards.
       if (m_XWsrResult[itrack].m_wsr == WSR_Outside) {
         continue;
       }
 
       // int fake_hit_idx = num_all_minus_one_hits(itrack) < m_iteration_params->maxHolesPerCand ? -1 : -2;
       int fake_hit_idx = ((num_all_minus_one_hits(itrack) < m_iteration_params->maxHolesPerCand) &&
                           (m_NTailMinusOneHits(itrack, 0, 0) < m_iteration_params->maxConsecHoles))
                              ? Hit::kHitMissIdx
                              : Hit::kHitStopIdx;
 
       if (m_XWsrResult[itrack].m_wsr == WSR_Edge) {
         fake_hit_idx = Hit::kHitEdgeIdx;
       }
       //now add fake hit for tracks that passsed through inactive modules
       else if (m_XWsrResult[itrack].m_in_gap == true && nHitsAdded[itrack] == 0) {
         fake_hit_idx = Hit::kHitInGapIdx;
       }
       //now add fake hit for cases where hit cluster size is larger than maxClusterSize
       else if (isTooLargeCluster[itrack] == true && nHitsAdded[itrack] == 0) {
         fake_hit_idx = Hit::kHitMaxClusterIdx;
       }
 
       IdxChi2List tmpList;
       tmpList.trkIdx = m_CandIdx(itrack, 0, 0);
       tmpList.hitIdx = fake_hit_idx;
       tmpList.module = -1;
       tmpList.nhits = m_NFoundHits(itrack, 0, 0);
       tmpList.ntailholes = (fake_hit_idx == Hit::kHitMissIdx ? m_NTailMinusOneHits(itrack, 0, 0) + 1
                                                              : m_NTailMinusOneHits(itrack, 0, 0));
       tmpList.noverlaps = m_NOverlapHits(itrack, 0, 0);
       tmpList.nholes = num_inside_minus_one_hits(itrack);
       tmpList.pt = std::abs(1.0f / m_Par[iP].At(itrack, 3, 0));
       tmpList.chi2 = m_Chi2(itrack, 0, 0);
       tmpList.chi2_hit = 0;
       tmpList.score = getScoreStruct(tmpList);
       cloner.add_cand(m_SeedIdx(itrack, 0, 0) - offset, tmpList);
       dprint("adding invalid hit " << fake_hit_idx);
     }
   }

◆ getHitSelDynamicChi2Cut()

float mkfit::MkFinder::getHitSelDynamicChi2Cut	(	const int	itrk,
		const int	ipar
	)

inline

Definition at line 205 of file MkFinder.cc.

References funct::abs(), Matriplex::Matriplex< T, D1, D2, N >::At(), mkfit::IterationLayerConfig::c_c2_0, mkfit::IterationLayerConfig::c_c2_1, mkfit::IterationLayerConfig::c_c2_2, mkfit::IterationLayerConfig::c_c2_sf, mkfit::IterationParams::chi2Cut_min, m_iteration_layer_config, m_iteration_params, mkfit::MkBase::m_Par, mkfit::Const::PIOver2, and theta().

Referenced by addBestHit(), findCandidates(), and findCandidatesCloneEngine().

                                                                                {
     const IterationLayerConfig &ILC = *m_iteration_layer_config;
 
     const float minChi2Cut = m_iteration_params->chi2Cut_min;
     const float invpt = m_Par[ipar].At(itrk, 3, 0);
     const float theta = std::abs(m_Par[ipar].At(itrk, 5, 0) - Const::PIOver2);
 
     float max_invpt = invpt;
     if (invpt > 10.0)
       max_invpt = 10.0;
 
     float this_c2 = ILC.c_c2_0 * max_invpt + ILC.c_c2_1 * theta + ILC.c_c2_2;
     // In case layer is missing (e.g., seeding layers, or too low stats for training), leave original limits
     if ((ILC.c_c2_sf) * this_c2 > minChi2Cut)
       return ILC.c_c2_sf * this_c2;
     else
       return minChi2Cut;
   }

◆ getHitSelDynamicWindows()

void mkfit::MkFinder::getHitSelDynamicWindows	(	const float	invpt,
		const float	theta,
		float &	min_dq,
		float &	max_dq,
		float &	min_dphi,
		float &	max_dphi
	)

Definition at line 168 of file MkFinder.cc.

References mkfit::IterationLayerConfig::c_dp_0, mkfit::IterationLayerConfig::c_dp_1, mkfit::IterationLayerConfig::c_dp_2, mkfit::IterationLayerConfig::c_dp_sf, mkfit::IterationLayerConfig::c_dq_0, mkfit::IterationLayerConfig::c_dq_1, mkfit::IterationLayerConfig::c_dq_2, mkfit::IterationLayerConfig::c_dq_sf, m_iteration_layer_config, and theta().

Referenced by selectHitIndices().

                                                                                                             {
     const IterationLayerConfig &ILC = *m_iteration_layer_config;
 
     float max_invpt = invpt;
     if (invpt > 10.0)
       max_invpt = 10.0;  // => pT>0.1 GeV
 
     // dq hit selection window
     float this_dq = (ILC.c_dq_0) * max_invpt + (ILC.c_dq_1) * theta + (ILC.c_dq_2);
     // In case layer is missing (e.g., seeding layers, or too low stats for training), leave original limits
     if ((ILC.c_dq_sf) * this_dq > 0.f) {
       min_dq = (ILC.c_dq_sf) * this_dq;
       max_dq = 2.0f * min_dq;
     }
 
     // dphi hit selection window
     float this_dphi = (ILC.c_dp_0) * max_invpt + (ILC.c_dp_1) * theta + (ILC.c_dp_2);
     // In case layer is missing (e.g., seeding layers, or too low stats for training), leave original limits
     if ((ILC.c_dp_sf) * this_dphi > min_dphi) {
       min_dphi = (ILC.c_dp_sf) * this_dphi;
       max_dphi = 2.0f * min_dphi;
     }
 
     //float this_c2 = (ILC.c_c2_0)*invpt+(ILC.c_c2_1)*theta+(ILC.c_c2_2);
     //if(this_c2>0.f){
     //  max_c2 = (ILC.c_c2_sf)*this_c2;
     //}
   }

◆ inputTracksAndHitIdx() [1/4]

void mkfit::MkFinder::inputTracksAndHitIdx	(	const std::vector< Track > &	tracks,
		int	beg,
		int	end,
		bool	inputProp
	)

Definition at line 59 of file MkFinder.cc.

References copy_in(), mps_fire::end, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, and tracks.

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

                                                                                                       {
     // Assign track parameters to initial state and copy hit values in.
 
     // This might not be true for the last chunk!
     // assert(end - beg == NN);
 
     const int iI = inputProp ? iP : iC;
 
     for (int i = beg, imp = 0; i < end; ++i, ++imp) {
       copy_in(tracks[i], imp, iI);
     }
   }

◆ inputTracksAndHitIdx() [2/4]

void mkfit::MkFinder::inputTracksAndHitIdx	(	const std::vector< Track > &	tracks,
		const std::vector< int > &	idxs,
		int	beg,
		int	end,
		bool	inputProp,
		int	mp_offset
	)

Definition at line 72 of file MkFinder.cc.

References copy_in(), mps_fire::end, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, and tracks.

                                                                                                                    {
     // Assign track parameters to initial state and copy hit values in.
 
     // This might not be true for the last chunk!
     // assert(end - beg == NN);
 
     const int iI = inputProp ? iP : iC;
 
     for (int i = beg, imp = mp_offset; i < end; ++i, ++imp) {
       copy_in(tracks[idxs[i]], imp, iI);
     }
   }

◆ inputTracksAndHitIdx() [3/4]

void mkfit::MkFinder::inputTracksAndHitIdx	(	const std::vector< CombCandidate > &	tracks,
		const std::vector< std::pair< int, int >> &	idxs,
		int	beg,
		int	end,
		bool	inputProp
	)

Definition at line 86 of file MkFinder.cc.

References copy_in(), mps_fire::end, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, m_CandIdx, m_SeedIdx, and tracks.

                                                       {
     // Assign track parameters to initial state and copy hit values in.
 
     // This might not be true for the last chunk!
     // assert(end - beg == NN);
 
     const int iI = inputProp ? iP : iC;
 
     for (int i = beg, imp = 0; i < end; ++i, ++imp) {
       const TrackCand &trk = tracks[idxs[i].first][idxs[i].second];
 
       copy_in(trk, imp, iI);
 
 #ifdef DUMPHITWINDOW
       m_SeedAlgo(imp, 0, 0) = tracks[idxs[i].first].seed_algo();
       m_SeedLabel(imp, 0, 0) = tracks[idxs[i].first].seed_label();
 #endif
 
       m_SeedIdx(imp, 0, 0) = idxs[i].first;
       m_CandIdx(imp, 0, 0) = idxs[i].second;
     }
   }

◆ inputTracksAndHitIdx() [4/4]

void mkfit::MkFinder::inputTracksAndHitIdx	(	const std::vector< CombCandidate > &	tracks,
		const std::vector< std::pair< int, IdxChi2List >> &	idxs,
		int	beg,
		int	end,
		bool	inputProp
	)

Definition at line 113 of file MkFinder.cc.

References copy_in(), mps_fire::end, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, m_CandIdx, m_SeedIdx, and tracks.

                                                       {
     // Assign track parameters to initial state and copy hit values in.
 
     // This might not be true for the last chunk!
     // assert(end - beg == NN);
 
     const int iI = inputProp ? iP : iC;
 
     for (int i = beg, imp = 0; i < end; ++i, ++imp) {
       const TrackCand &trk = tracks[idxs[i].first][idxs[i].second.trkIdx];
 
       copy_in(trk, imp, iI);
 
 #ifdef DUMPHITWINDOW
       m_SeedAlgo(imp, 0, 0) = tracks[idxs[i].first].seed_algo();
       m_SeedLabel(imp, 0, 0) = tracks[idxs[i].first].seed_label();
 #endif
 
       m_SeedIdx(imp, 0, 0) = idxs[i].first;
       m_CandIdx(imp, 0, 0) = idxs[i].second.trkIdx;
     }
   }

◆ num_all_minus_one_hits()

int mkfit::MkFinder::num_all_minus_one_hits ( const int mslot ) const

inlineprivate

Definition at line 254 of file MkFinder.h.

References m_NInsideMinusOneHits, and m_NTailMinusOneHits.

Referenced by addBestHit(), findCandidates(), and findCandidatesCloneEngine().

                                                       {
       return m_NInsideMinusOneHits(mslot, 0, 0) + m_NTailMinusOneHits(mslot, 0, 0);
     }

◆ num_inside_minus_one_hits()

int mkfit::MkFinder::num_inside_minus_one_hits ( const int mslot ) const

inlineprivate

Definition at line 258 of file MkFinder.h.

References m_NInsideMinusOneHits.

Referenced by findCandidatesCloneEngine().

258 { return m_NInsideMinusOneHits(mslot, 0, 0); }

mkfit::MkFinder::m_NInsideMinusOneHits

MPlexQI m_NInsideMinusOneHits

Definition: MkFinder.h:287

◆ outputNonStoppedTracksAndHitIdx()

void mkfit::MkFinder::outputNonStoppedTracksAndHitIdx	(	std::vector< Track > &	tracks,
		const std::vector< int > &	idxs,
		int	beg,
		int	end,
		bool	outputProp
	)		const

inline

Definition at line 84 of file MkFinder.h.

References copy_out(), mps_fire::end, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, m_Stopped, and tracks.

                                                                                                        {
       const int iO = outputProp ? iP : iC;
       for (int i = beg, imp = 0; i < end; ++i, ++imp) {
         if (!m_Stopped[imp])
           copy_out(tracks[idxs[i]], imp, iO);
       }
     }

◆ outputTrackAndHitIdx()

void mkfit::MkFinder::outputTrackAndHitIdx	(	Track &	track,
		int	itrack,
		bool	outputProp
	)		const

inline

Definition at line 79 of file MkFinder.h.

References copy_out(), mkfit::MkBase::iC, mkfit::MkBase::iP, and HLT_2022v12_cff::track.

                                                                                {
       const int iO = outputProp ? iP : iC;
       copy_out(track, itrack, iO);
     }

◆ outputTracksAndHitIdx() [1/2]

void mkfit::MkFinder::outputTracksAndHitIdx	(	std::vector< Track > &	tracks,
		int	beg,
		int	end,
		bool	outputProp
	)		const

Definition at line 140 of file MkFinder.cc.

References copy_out(), mps_fire::end, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, and tracks.

                                                                                                         {
     // Copies requested track parameters into Track objects.
     // The tracks vector should be resized to allow direct copying.
 
     const int iO = outputProp ? iP : iC;
 
     for (int i = beg, imp = 0; i < end; ++i, ++imp) {
       copy_out(tracks[i], imp, iO);
     }
   }

◆ outputTracksAndHitIdx() [2/2]

void mkfit::MkFinder::outputTracksAndHitIdx	(	std::vector< Track > &	tracks,
		const std::vector< int > &	idxs,
		int	beg,
		int	end,
		bool	outputProp
	)		const

Definition at line 151 of file MkFinder.cc.

References copy_out(), mps_fire::end, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, and tracks.

                                                                                                      {
     // Copies requested track parameters into Track objects.
     // The tracks vector should be resized to allow direct copying.
 
     const int iO = outputProp ? iP : iC;
 
     for (int i = beg, imp = 0; i < end; ++i, ++imp) {
       copy_out(tracks[idxs[i]], imp, iO);
     }
   }

◆ release()

void mkfit::MkFinder::release ( )

Definition at line 48 of file MkFinder.cc.

References m_iteration_hit_mask, m_iteration_layer_config, m_iteration_params, and m_prop_config.

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

                          {
     m_prop_config = nullptr;
     m_iteration_params = nullptr;
     m_iteration_layer_config = nullptr;
     m_iteration_hit_mask = nullptr;
   }

◆ selectHitIndices()

void mkfit::MkFinder::selectHitIndices	(	const LayerOfHits &	layer_of_hits,
		const int	N_proc
	)

Definition at line 228 of file MkFinder.cc.

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

                                                                                     {
     // bool debug = true;
     using bidx_t = LayerOfHits::bin_index_t;
     using bcnt_t = LayerOfHits::bin_content_t;
     const LayerOfHits &L = layer_of_hits;
     const IterationLayerConfig &ILC = *m_iteration_layer_config;
 
     const int iI = iP;
     const float nSigmaPhi = 3;
     const float nSigmaZ = 3;
     const float nSigmaR = 3;
 
     dprintf("LayerOfHits::SelectHitIndices %s layer=%d N_proc=%d\n",
             L.is_barrel() ? "barrel" : "endcap",
             L.layer_id(),
             N_proc);
 
     float dqv[NN], dphiv[NN], qv[NN], phiv[NN];
     bidx_t qb1v[NN], qb2v[NN], qbv[NN], pb1v[NN], pb2v[NN];
 
     const auto assignbins = [&](int itrack,
                                 float q,
                                 float dq,
                                 float phi,
                                 float dphi,
                                 float min_dq,
                                 float max_dq,
                                 float min_dphi,
                                 float max_dphi) {
       dphi = std::clamp(std::abs(dphi), min_dphi, max_dphi);
       dq = std::clamp(dq, min_dq, max_dq);
       //
       qv[itrack] = q;
       phiv[itrack] = phi;
       dphiv[itrack] = dphi;
       dqv[itrack] = dq;
       //
       qbv[itrack] = L.qBinChecked(q);
       qb1v[itrack] = L.qBinChecked(q - dq);
       qb2v[itrack] = L.qBinChecked(q + dq) + 1;
       pb1v[itrack] = L.phiBinChecked(phi - dphi);
       pb2v[itrack] = L.phiMaskApply(L.phiBin(phi + dphi) + 1);
     };
 
     const auto calcdphi2 = [&](int itrack, float dphidx, float dphidy) {
       return dphidx * dphidx * m_Err[iI].constAt(itrack, 0, 0) + dphidy * dphidy * m_Err[iI].constAt(itrack, 1, 1) +
              2 * dphidx * dphidy * m_Err[iI].constAt(itrack, 0, 1);
     };
 
     const auto calcdphi = [&](float dphi2, float min_dphi) {
       return std::max(nSigmaPhi * std::sqrt(std::abs(dphi2)), min_dphi);
     };
 
     if (L.is_barrel()) {
       // Pull out the part of the loop that vectorizes
 #pragma omp simd
       for (int itrack = 0; itrack < NN; ++itrack) {
         m_XHitSize[itrack] = 0;
 
         float min_dq = ILC.min_dq();
         float max_dq = ILC.max_dq();
         float min_dphi = ILC.min_dphi();
         float max_dphi = ILC.max_dphi();
 
         const float invpt = m_Par[iI].At(itrack, 3, 0);
         const float theta = std::fabs(m_Par[iI].At(itrack, 5, 0) - Const::PIOver2);
         getHitSelDynamicWindows(invpt, theta, min_dq, max_dq, min_dphi, max_dphi);
 
         const float x = m_Par[iI].constAt(itrack, 0, 0);
         const float y = m_Par[iI].constAt(itrack, 1, 0);
         const float r2 = x * x + y * y;
         const float dphidx = -y / r2, dphidy = x / r2;
         const float dphi2 = calcdphi2(itrack, dphidx, dphidy);
 #ifdef HARD_CHECK
         assert(dphi2 >= 0);
 #endif
 
         const float phi = getPhi(x, y);
         float dphi = calcdphi(dphi2, min_dphi);
 
         const float z = m_Par[iI].constAt(itrack, 2, 0);
         const float dz = std::abs(nSigmaZ * std::sqrt(m_Err[iI].constAt(itrack, 2, 2)));
         const float edgeCorr = std::abs(0.5f * (L.layer_info()->rout() - L.layer_info()->rin()) /
                                         std::tan(m_Par[iI].constAt(itrack, 5, 0)));
         // XXX-NUM-ERR above, m_Err(2,2) gets negative!
 
         m_XWsrResult[itrack] = L.is_within_z_sensitive_region(z, std::sqrt(dz * dz + edgeCorr * edgeCorr));
         assignbins(itrack, z, dz, phi, dphi, min_dq, max_dq, min_dphi, max_dphi);
       }
     } else  // endcap
     {
       // Pull out the part of the loop that vectorizes
 #pragma omp simd
       for (int itrack = 0; itrack < NN; ++itrack) {
         m_XHitSize[itrack] = 0;
 
         float min_dq = ILC.min_dq();
         float max_dq = ILC.max_dq();
         float min_dphi = ILC.min_dphi();
         float max_dphi = ILC.max_dphi();
 
         const float invpt = m_Par[iI].At(itrack, 3, 0);
         const float theta = std::fabs(m_Par[iI].At(itrack, 5, 0) - Const::PIOver2);
         getHitSelDynamicWindows(invpt, theta, min_dq, max_dq, min_dphi, max_dphi);
 
         const float x = m_Par[iI].constAt(itrack, 0, 0);
         const float y = m_Par[iI].constAt(itrack, 1, 0);
         const float r2 = x * x + y * y;
         const float dphidx = -y / r2, dphidy = x / r2;
         const float dphi2 = calcdphi2(itrack, dphidx, dphidy);
 #ifdef HARD_CHECK
         assert(dphi2 >= 0);
 #endif
 
         const float phi = getPhi(x, y);
         float dphi = calcdphi(dphi2, min_dphi);
 
         const float r = std::sqrt(r2);
         const float dr = nSigmaR * std::sqrt(std::abs(x * x * m_Err[iI].constAt(itrack, 0, 0) +
                                                       y * y * m_Err[iI].constAt(itrack, 1, 1) +
                                                       2 * x * y * m_Err[iI].constAt(itrack, 0, 1)) /
                                              r2);
         const float edgeCorr = std::abs(0.5f * (L.layer_info()->zmax() - L.layer_info()->zmin()) *
                                         std::tan(m_Par[iI].constAt(itrack, 5, 0)));
 
         m_XWsrResult[itrack] = L.is_within_r_sensitive_region(r, std::sqrt(dr * dr + edgeCorr * edgeCorr));
         assignbins(itrack, r, dr, phi, dphi, min_dq, max_dq, min_dphi, max_dphi);
       }
     }
 
     // Vectorizing this makes it run slower!
     //#pragma omp simd
     for (int itrack = 0; itrack < N_proc; ++itrack) {
       if (m_XWsrResult[itrack].m_wsr == WSR_Outside) {
         m_XHitSize[itrack] = -1;
         continue;
       }
 
       const bidx_t qb = qbv[itrack];
       const bidx_t qb1 = qb1v[itrack];
       const bidx_t qb2 = qb2v[itrack];
       const bidx_t pb1 = pb1v[itrack];
       const bidx_t pb2 = pb2v[itrack];
 
       // Used only by usePhiQArrays
       const float q = qv[itrack];
       const float phi = phiv[itrack];
       const float dphi = dphiv[itrack];
       const float dq = dqv[itrack];
       // clang-format off
       dprintf("  %2d/%2d: %6.3f %6.3f %6.6f %7.5f %3u %3u %4u %4u\n",
               L.layer_id(), itrack, q, phi, dq, dphi,
               qb1, qb2, pb1, pb2);
       // clang-format on
       // MT: One could iterate in "spiral" order, to pick hits close to the center.
       // http://stackoverflow.com/questions/398299/looping-in-a-spiral
       // This would then work best with relatively small bin sizes.
       // Or, set them up so I can always take 3x3 array around the intersection.
 
 #if defined(DUMPHITWINDOW) && defined(MKFIT_STANDALONE)
       int thisseedmcid = -999999;
       {
         int seedlabel = m_SeedLabel(itrack, 0, 0);
         TrackVec &seedtracks = m_event->seedTracks_;
         int thisidx = -999999;
         for (int i = 0; i < int(seedtracks.size()); ++i) {
           auto &thisseed = seedtracks[i];
           if (thisseed.label() == seedlabel) {
             thisidx = i;
             break;
           }
         }
         if (thisidx > -999999) {
           auto &seedtrack = m_event->seedTracks_[thisidx];
           std::vector<int> thismcHitIDs;
           seedtrack.mcHitIDsVec(m_event->layerHits_, m_event->simHitsInfo_, thismcHitIDs);
           if (std::adjacent_find(thismcHitIDs.begin(), thismcHitIDs.end(), std::not_equal_to<>()) ==
               thismcHitIDs.end()) {
             thisseedmcid = thismcHitIDs.at(0);
           }
         }
       }
 #endif
 
       for (bidx_t qi = qb1; qi != qb2; ++qi) {
         for (bidx_t pi = pb1; pi != pb2; pi = L.phiMaskApply(pi + 1)) {
           // Limit to central Q-bin
           if (qi == qb && L.isBinDead(pi, qi) == true) {
             dprint("dead module for track in layer=" << L.layer_id() << " qb=" << qi << " pi=" << pi << " q=" << q
                                                      << " phi=" << phi);
             m_XWsrResult[itrack].m_in_gap = true;
           }
 
           // MT: The following line is the biggest hog (4% total run time).
           // This comes from cache misses, I presume.
           // It might make sense to make first loop to extract bin indices
           // and issue prefetches at the same time.
           // Then enter vectorized loop to actually collect the hits in proper order.
 
           //SK: ~20x1024 bin sizes give mostly 1 hit per bin. Commented out for 128 bins or less
           // #pragma nounroll
           auto pbi = L.phiQBinContent(pi, qi);
           for (bcnt_t hi = pbi.begin(); hi < pbi.end(); ++hi) {
             // MT: Access into m_hit_zs and m_hit_phis is 1% run-time each.
 
             unsigned int hi_orig = L.getOriginalHitIndex(hi);
 
             if (m_iteration_hit_mask && (*m_iteration_hit_mask)[hi_orig]) {
               dprintf(
                   "Yay, denying masked hit on layer %u, hi %u, orig idx %u\n", L.layer_info()->layer_id(), hi, hi_orig);
               continue;
             }
 
             if (Config::usePhiQArrays) {
               if (m_XHitSize[itrack] >= MPlexHitIdxMax)
                 break;
 
               const float ddq = std::abs(q - L.hit_q(hi));
               const float ddphi = cdist(std::abs(phi - L.hit_phi(hi)));
 
 #if defined(DUMPHITWINDOW) && defined(MKFIT_STANDALONE)
               {
                 const MCHitInfo &mchinfo = m_event->simHitsInfo_[L.refHit(hi).mcHitID()];
                 int mchid = mchinfo.mcTrackID();
                 int st_isfindable = 0;
                 int st_label = -999999;
                 int st_prodtype = 0;
                 int st_nhits = -1;
                 int st_charge = 0;
                 float st_r = -999.;
                 float st_z = -999.;
                 float st_pt = -999.;
                 float st_eta = -999.;
                 float st_phi = -999.;
                 if (mchid >= 0) {
                   Track simtrack = m_event->simTracks_[mchid];
                   st_isfindable = (int)simtrack.isFindable();
                   st_label = simtrack.label();
                   st_prodtype = (int)simtrack.prodType();
                   st_pt = simtrack.pT();
                   st_eta = simtrack.momEta();
                   st_phi = simtrack.momPhi();
                   st_nhits = simtrack.nTotalHits();
                   st_charge = simtrack.charge();
                   st_r = simtrack.posR();
                   st_z = simtrack.z();
                 }
 
                 const Hit &thishit = L.refHit(hi);
                 m_msErr.copyIn(itrack, thishit.errArray());
                 m_msPar.copyIn(itrack, thishit.posArray());
 
                 MPlexQF thisOutChi2;
                 MPlexLV tmpPropPar;
                 const FindingFoos &fnd_foos = FindingFoos::get_finding_foos(L.is_barrel());
                 (*fnd_foos.m_compute_chi2_foo)(m_Err[iI],
                                                m_Par[iI],
                                                m_Chg,
                                                m_msErr,
                                                m_msPar,
                                                thisOutChi2,
                                                tmpPropPar,
                                                N_proc,
                                                m_prop_config->finding_intra_layer_pflags,
                                                m_prop_config->finding_requires_propagation_to_hit_pos);
 
                 float hx = thishit.x();
                 float hy = thishit.y();
                 float hz = thishit.z();
                 float hr = std::hypot(hx, hy);
                 float hphi = std::atan2(hy, hx);
                 float hex = std::sqrt(thishit.exx());
                 if (std::isnan(hex))
                   hex = -999.;
                 float hey = std::sqrt(thishit.eyy());
                 if (std::isnan(hey))
                   hey = -999.;
                 float hez = std::sqrt(thishit.ezz());
                 if (std::isnan(hez))
                   hez = -999.;
                 float her = std::sqrt(
                     (hx * hx * thishit.exx() + hy * hy * thishit.eyy() + 2.0f * hx * hy * m_msErr.At(itrack, 0, 1)) /
                     (hr * hr));
                 if (std::isnan(her))
                   her = -999.;
                 float hephi = std::sqrt(thishit.ephi());
                 if (std::isnan(hephi))
                   hephi = -999.;
                 float hchi2 = thisOutChi2[itrack];
                 if (std::isnan(hchi2))
                   hchi2 = -999.;
                 float tx = m_Par[iI].At(itrack, 0, 0);
                 float ty = m_Par[iI].At(itrack, 1, 0);
                 float tz = m_Par[iI].At(itrack, 2, 0);
                 float tr = std::hypot(tx, ty);
                 float tphi = std::atan2(ty, tx);
                 float tchi2 = m_Chi2(itrack, 0, 0);
                 if (std::isnan(tchi2))
                   tchi2 = -999.;
                 float tex = std::sqrt(m_Err[iI].At(itrack, 0, 0));
                 if (std::isnan(tex))
                   tex = -999.;
                 float tey = std::sqrt(m_Err[iI].At(itrack, 1, 1));
                 if (std::isnan(tey))
                   tey = -999.;
                 float tez = std::sqrt(m_Err[iI].At(itrack, 2, 2));
                 if (std::isnan(tez))
                   tez = -999.;
                 float ter = std::sqrt(
                     (tx * tx * tex * tex + ty * ty * tey * tey + 2.0f * tx * ty * m_Err[iI].At(itrack, 0, 1)) /
                     (tr * tr));
                 if (std::isnan(ter))
                   ter = -999.;
                 float tephi = std::sqrt(
                     (ty * ty * tex * tex + tx * tx * tey * tey - 2.0f * tx * ty * m_Err[iI].At(itrack, 0, 1)) /
                     (tr * tr * tr * tr));
                 if (std::isnan(tephi))
                   tephi = -999.;
                 float ht_dxy = std::hypot(hx - tx, hy - ty);
                 float ht_dz = hz - tz;
                 float ht_dphi = cdist(std::abs(hphi - tphi));
 
                 static bool first = true;
                 if (first) {
                   printf(
                       "HITWINDOWSEL "
                       "evt_id/I:"
                       "lyr_id/I:lyr_isbrl/I:hit_idx/I:"
                       "trk_cnt/I:trk_idx/I:trk_label/I:"
                       "trk_pt/F:trk_eta/F:trk_mphi/F:trk_chi2/F:"
                       "nhits/I:"
                       "seed_idx/I:seed_label/I:seed_algo/I:seed_mcid/I:"
                       "hit_mcid/I:"
                       "st_isfindable/I:st_prodtype/I:st_label/I:"
                       "st_pt/F:st_eta/F:st_phi/F:"
                       "st_nhits/I:st_charge/I:st_r/F:st_z/F:"
                       "trk_q/F:hit_q/F:dq_trkhit/F:dq_cut/F:trk_phi/F:hit_phi/F:dphi_trkhit/F:dphi_cut/F:"
                       "t_x/F:t_y/F:t_r/F:t_phi/F:t_z/F:"
                       "t_ex/F:t_ey/F:t_er/F:t_ephi/F:t_ez/F:"
                       "h_x/F:h_y/F:h_r/F:h_phi/F:h_z/F:"
                       "h_ex/F:h_ey/F:h_er/F:h_ephi/F:h_ez/F:"
                       "ht_dxy/F:ht_dz/F:ht_dphi/F:"
                       "h_chi2/F"
                       "\n");
                   first = false;
                 }
 
                 if (!(std::isnan(phi)) && !(std::isnan(getEta(m_Par[iI].At(itrack, 5, 0))))) {
                   //|| std::isnan(ter) || std::isnan(her) || std::isnan(m_Chi2(itrack, 0, 0)) || std::isnan(hchi2)))
                   // clang-format off
                   printf("HITWINDOWSEL "
                          "%d "
                          "%d %d %d "
                          "%d %d %d "
                          "%6.3f %6.3f %6.3f %6.3f "
                          "%d "
                          "%d %d %d %d "
                          "%d "
                          "%d %d %d "
                          "%6.3f %6.3f %6.3f "
                          "%d %d %6.3f %6.3f "
                          "%6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f "
                          "%6.3f %6.3f %6.3f %6.3f %6.3f "
                          "%6.6f %6.6f %6.6f %6.6f %6.6f "
                          "%6.3f %6.3f %6.3f %6.3f %6.3f "
                          "%6.6f %6.6f %6.6f %6.6f %6.6f "
                          "%6.3f %6.3f %6.3f "
                          "%6.3f"
                          "\n",
                          m_event->evtID(),
                          L.layer_id(), L.is_barrel(), L.getOriginalHitIndex(hi),
                          itrack, m_CandIdx(itrack, 0, 0), m_Label(itrack, 0, 0),
                          1.0f / m_Par[iI].At(itrack, 3, 0), getEta(m_Par[iI].At(itrack, 5, 0)), m_Par[iI].At(itrack, 4, 0), m_Chi2(itrack, 0, 0),
                          m_NFoundHits(itrack, 0, 0),
                          m_SeedIdx(itrack, 0, 0), m_SeedLabel(itrack, 0, 0), m_SeedAlgo(itrack, 0, 0), thisseedmcid,
                          mchid,
                          st_isfindable, st_prodtype, st_label,
                          st_pt, st_eta, st_phi,
                          st_nhits, st_charge, st_r, st_z,
                          q, L.hit_q(hi), ddq, dq, phi, L.hit_phi(hi), ddphi, dphi,
                          tx, ty, tr, tphi, tz,
                          tex, tey, ter, tephi, tez,
                          hx, hy, hr, hphi, hz,
                          hex, hey, her, hephi, hez,
                          ht_dxy, ht_dz, ht_dphi,
                          hchi2);
                   // clang-format on
                 }
               }
 #endif
 
               if (ddq >= dq)
                 continue;
               if (ddphi >= dphi)
                 continue;
               // clang-format off
               dprintf("     SHI %3u %4u %5u  %6.3f %6.3f %6.4f %7.5f   %s\n",
                       qi, pi, hi, L.hit_q(hi), L.hit_phi(hi),
                       ddq, ddphi, (ddq < dq && ddphi < dphi) ? "PASS" : "FAIL");
               // clang-format on
 
               // MT: Removing extra check gives full efficiency ...
               //     and means our error estimations are wrong!
               // Avi says we should have *minimal* search windows per layer.
               // Also ... if bins are sufficiently small, we do not need the extra
               // checks, see above.
               m_XHitArr.At(itrack, m_XHitSize[itrack]++, 0) = hi_orig;
             } else {
               // MT: The following check alone makes more sense with spiral traversal,
               // we'd be taking in closest hits first.
 
               // Hmmh -- there used to be some more checks here.
               // Or, at least, the phi binning was much smaller and no further checks were done.
               assert(false && "this code has not been used in a while -- see comments in code");
 
               if (m_XHitSize[itrack] < MPlexHitIdxMax) {
                 m_XHitArr.At(itrack, m_XHitSize[itrack]++, 0) = hi_orig;
               }
             }
           }  //hi
         }    //pi
       }      //qi
     }        //itrack
   }

◆ setup()

void mkfit::MkFinder::setup	(	const PropagationConfig &	pc,
		const IterationParams &	ip,
		const IterationLayerConfig &	ilc,
		const std::vector< bool > *	ihm
	)

Definition at line 36 of file MkFinder.cc.

References m_iteration_hit_mask, m_iteration_layer_config, m_iteration_params, and m_prop_config.

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

                                                    {
     m_prop_config = &pc;
     m_iteration_params = &ip;
     m_iteration_layer_config = &ilc;
     m_iteration_hit_mask = ihm;
   }

◆ setup_bkfit()

void mkfit::MkFinder::setup_bkfit ( const PropagationConfig & pc )

Definition at line 46 of file MkFinder.cc.

References m_prop_config.

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

46 { m_prop_config = &pc; }

mkfit::MkFinder::m_prop_config

const PropagationConfig * m_prop_config

Definition: MkFinder.h:313

◆ updateWithLastHit()

void mkfit::MkFinder::updateWithLastHit	(	const LayerOfHits &	layer_of_hits,
		int	N_proc,
		const FindingFoos &	fnd_foos
	)

Definition at line 1291 of file MkFinder.cc.

References Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), mkfit::PropagationConfig::finding_inter_layer_pflags, mkfit::PropagationConfig::finding_requires_propagation_to_hit_pos, mps_fire::i, mkfit::MkBase::iC, mkfit::HitOnTrack::index, mkfit::MkBase::iP, mkfit::MkBase::m_Chg, mkfit::MkBase::m_Err, m_LastHoT, m_msErr, m_msPar, mkfit::MkBase::m_Par, m_prop_config, mkfit::FindingFoos::m_update_param_foo, and mkfit::LayerOfHits::refHit().

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

                                                                                                             {
     for (int i = 0; i < N_proc; ++i) {
       const HitOnTrack &hot = m_LastHoT[i];
 
       const Hit &hit = layer_of_hits.refHit(hot.index);
 
       m_msErr.copyIn(i, hit.errArray());
       m_msPar.copyIn(i, hit.posArray());
     }
 
     // See comment in MkBuilder::find_tracks_in_layer() about intra / inter flags used here
     // for propagation to the hit.
     (*fnd_foos.m_update_param_foo)(m_Err[iP],
                                    m_Par[iP],
                                    m_Chg,
                                    m_msErr,
                                    m_msPar,
                                    m_Err[iC],
                                    m_Par[iC],
                                    N_proc,
                                    m_prop_config->finding_inter_layer_pflags,
                                    m_prop_config->finding_requires_propagation_to_hit_pos);
   }

Friends And Related Function Documentation

◆ MkBuilder

friend class MkBuilder

friend

Definition at line 32 of file MkFinder.h.

Member Data Documentation

◆ m_CandIdx

MPlexQI mkfit::MkFinder::m_CandIdx

private

Definition at line 277 of file MkFinder.h.

Referenced by copyOutParErr(), findCandidates(), findCandidatesCloneEngine(), inputTracksAndHitIdx(), and selectHitIndices().

◆ m_Chi2

MPlexQF mkfit::MkFinder::m_Chi2

private

Definition at line 262 of file MkFinder.h.

Referenced by addBestHit(), bkFitFitTracks(), bkFitFitTracksBH(), bkFitInputTracks(), bkFitOutputTracks(), copy_in(), copy_out(), findCandidatesCloneEngine(), mkfit::MkBuilder::fit_cands_BH(), and selectHitIndices().

◆ m_CombCand

CombCandidate* mkfit::MkFinder::m_CombCand[NN]

private

Definition at line 292 of file MkFinder.h.

Referenced by copy_in(), and copy_out().

◆ m_CurHit

int mkfit::MkFinder::m_CurHit[NN]

private

Definition at line 319 of file MkFinder.h.

Referenced by bkFitFitTracksBH(), and bkFitInputTracks().

◆ m_CurNode

int mkfit::MkFinder::m_CurNode[NN]

private

Definition at line 321 of file MkFinder.h.

Referenced by bkFitFitTracks(), and bkFitInputTracks().

◆ m_HoTArr

const HitOnTrack* mkfit::MkFinder::m_HoTArr[NN]

private

Definition at line 320 of file MkFinder.h.

Referenced by bkFitFitTracksBH(), and bkFitInputTracks().

◆ m_HoTArrs

HitOnTrack mkfit::MkFinder::m_HoTArrs[NN][Config::nMaxTrkHits]

private

Definition at line 268 of file MkFinder.h.

Referenced by add_hit(), bestHitLastHoT(), copy_in(), copy_out(), and findCandidates().

◆ m_HoTNodeArr

const HoTNode* mkfit::MkFinder::m_HoTNodeArr[NN]

private

Definition at line 322 of file MkFinder.h.

Referenced by bkFitFitTracks(), and bkFitInputTracks().

◆ m_iteration_hit_mask

const std::vector<bool>* mkfit::MkFinder::m_iteration_hit_mask = nullptr

private

Definition at line 316 of file MkFinder.h.

Referenced by release(), selectHitIndices(), and setup().

◆ m_iteration_layer_config

const IterationLayerConfig* mkfit::MkFinder::m_iteration_layer_config = nullptr

private

Definition at line 315 of file MkFinder.h.

Referenced by getHitSelDynamicChi2Cut(), getHitSelDynamicWindows(), release(), selectHitIndices(), and setup().

◆ m_iteration_params

const IterationParams* mkfit::MkFinder::m_iteration_params = nullptr

private

Definition at line 314 of file MkFinder.h.

Referenced by findCandidates(), findCandidatesCloneEngine(), getHitSelDynamicChi2Cut(), release(), and setup().

◆ m_Label

MPlexQI mkfit::MkFinder::m_Label

private

Definition at line 263 of file MkFinder.h.

Referenced by copy_in(), copy_out(), mkfit::MkBuilder::find_tracks_in_layers(), findCandidatesCloneEngine(), and selectHitIndices().

◆ m_LastHitCcIndex

MPlexQI mkfit::MkFinder::m_LastHitCcIndex

private

Definition at line 289 of file MkFinder.h.

Referenced by copy_in(), and copy_out().

◆ m_LastHoT

HitOnTrack mkfit::MkFinder::m_LastHoT[NN]

private

Definition at line 291 of file MkFinder.h.

Referenced by copy_in(), and updateWithLastHit().

◆ m_msErr

MPlexHS mkfit::MkFinder::m_msErr

private

Definition at line 303 of file MkFinder.h.

Referenced by addBestHit(), bkFitFitTracks(), bkFitFitTracksBH(), findCandidates(), findCandidatesCloneEngine(), selectHitIndices(), and updateWithLastHit().

◆ m_msPar

MPlexHV mkfit::MkFinder::m_msPar

private

Definition at line 304 of file MkFinder.h.

Referenced by addBestHit(), bkFitFitTracks(), bkFitFitTracksBH(), findCandidates(), findCandidatesCloneEngine(), selectHitIndices(), and updateWithLastHit().

◆ m_NFoundHits

MPlexQI mkfit::MkFinder::m_NFoundHits

private

Definition at line 266 of file MkFinder.h.

Referenced by add_hit(), copy_in(), copy_out(), findCandidates(), findCandidatesCloneEngine(), and selectHitIndices().

◆ m_NHits

MPlexQI mkfit::MkFinder::m_NHits

private

Definition at line 265 of file MkFinder.h.

Referenced by add_hit(), bestHitLastHoT(), copy_in(), and copy_out().

◆ m_NInsideMinusOneHits

MPlexQI mkfit::MkFinder::m_NInsideMinusOneHits

private

Definition at line 287 of file MkFinder.h.

Referenced by add_hit(), copy_in(), copy_out(), num_all_minus_one_hits(), and num_inside_minus_one_hits().

◆ m_NMissingHits

MPlexQI mkfit::MkFinder::m_NMissingHits

private

Definition at line 285 of file MkFinder.h.

Referenced by copy_in(), and copy_out().

◆ m_NOverlapHits

MPlexQI mkfit::MkFinder::m_NOverlapHits

private

Definition at line 286 of file MkFinder.h.

Referenced by copy_in(), copy_out(), and findCandidatesCloneEngine().

◆ m_NTailMinusOneHits

MPlexQI mkfit::MkFinder::m_NTailMinusOneHits

private

Definition at line 288 of file MkFinder.h.

Referenced by add_hit(), copy_in(), copy_out(), findCandidates(), findCandidatesCloneEngine(), and num_all_minus_one_hits().

◆ m_prop_config

const PropagationConfig* mkfit::MkFinder::m_prop_config = nullptr

private

Definition at line 313 of file MkFinder.h.

Referenced by addBestHit(), bkFitFitTracks(), bkFitFitTracksBH(), bkFitPropTracksToPCA(), findCandidates(), findCandidatesCloneEngine(), release(), selectHitIndices(), setup(), setup_bkfit(), and updateWithLastHit().

◆ m_SeedIdx

MPlexQI mkfit::MkFinder::m_SeedIdx

private

Definition at line 276 of file MkFinder.h.

Referenced by copyOutParErr(), findCandidates(), findCandidatesCloneEngine(), inputTracksAndHitIdx(), and selectHitIndices().

◆ m_Stopped

MPlexQI mkfit::MkFinder::m_Stopped

private

Definition at line 279 of file MkFinder.h.

Referenced by outputNonStoppedTracksAndHitIdx().

◆ m_TrkCand

TrackCand* mkfit::MkFinder::m_TrkCand[NN]

private

Definition at line 295 of file MkFinder.h.

Referenced by bkFitFitTracks(), and bkFitInputTracks().

◆ m_TrkStatus

TrackBase::Status mkfit::MkFinder::m_TrkStatus[NN]

private

Definition at line 290 of file MkFinder.h.

Referenced by copy_in(), and copy_out().

◆ m_XHitArr

MPlexHitIdx mkfit::MkFinder::m_XHitArr

private

Definition at line 300 of file MkFinder.h.

Referenced by addBestHit(), findCandidates(), findCandidatesCloneEngine(), and selectHitIndices().

◆ m_XHitSize

MPlexQI mkfit::MkFinder::m_XHitSize

private

Definition at line 299 of file MkFinder.h.

Referenced by addBestHit(), mkfit::MkBuilder::find_tracks_handle_missed_layers(), findCandidates(), findCandidatesCloneEngine(), and selectHitIndices().

◆ m_XWsrResult

WSR_Result mkfit::MkFinder::m_XWsrResult[NN]

private

Definition at line 298 of file MkFinder.h.

Referenced by addBestHit(), mkfit::MkBuilder::find_tracks_handle_missed_layers(), findCandidates(), findCandidatesCloneEngine(), and selectHitIndices().

◆ MPlexHitIdxMax

constexpr int mkfit::MkFinder::MPlexHitIdxMax = 16

static

Definition at line 35 of file MkFinder.h.

Referenced by selectHitIndices().

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ MPlexHitIdx

◆ MPlexQHoT

Constructor & Destructor Documentation

◆ MkFinder()

Member Function Documentation

◆ add_hit()

◆ addBestHit()

◆ bestHitLastHoT()

◆ bkFitFitTracks()

◆ bkFitFitTracksBH()

◆ bkFitInputTracks() [1/2]

◆ bkFitInputTracks() [2/2]

◆ bkFitOutputTracks() [1/2]

◆ bkFitOutputTracks() [2/2]

◆ bkFitPropTracksToPCA()

◆ copy_in() [1/2]

◆ copy_in() [2/2]

◆ copy_out() [1/2]

◆ copy_out() [2/2]

◆ copyOutParErr()

◆ findCandidates()

◆ findCandidatesCloneEngine()

◆ getHitSelDynamicChi2Cut()

◆ getHitSelDynamicWindows()

◆ inputTracksAndHitIdx() [1/4]

◆ inputTracksAndHitIdx() [2/4]

◆ inputTracksAndHitIdx() [3/4]

◆ inputTracksAndHitIdx() [4/4]

◆ num_all_minus_one_hits()

◆ num_inside_minus_one_hits()

◆ outputNonStoppedTracksAndHitIdx()

◆ outputTrackAndHitIdx()

◆ outputTracksAndHitIdx() [1/2]

◆ outputTracksAndHitIdx() [2/2]

◆ release()

◆ selectHitIndices()

◆ setup()

◆ setup_bkfit()

◆ updateWithLastHit()

Friends And Related Function Documentation

◆ MkBuilder

Member Data Documentation

◆ m_CandIdx

◆ m_Chi2

◆ m_CombCand

◆ m_CurHit

◆ m_CurNode

◆ m_HoTArr

◆ m_HoTArrs

◆ m_HoTNodeArr

◆ m_iteration_hit_mask

◆ m_iteration_layer_config

◆ m_iteration_params

◆ m_Label

◆ m_LastHitCcIndex

◆ m_LastHoT

◆ m_msErr

◆ m_msPar

◆ m_NFoundHits

◆ m_NHits

◆ m_NInsideMinusOneHits

◆ m_NMissingHits

◆ m_NOverlapHits

◆ m_NTailMinusOneHits

◆ m_prop_config

◆ m_SeedIdx

◆ m_Stopped

◆ m_TrkCand

◆ m_TrkStatus

◆ m_XHitArr

◆ m_XHitSize