mkfit::MkFinder Class Reference

#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)
void	inputTracksAndHits (const std::vector< CombCandidate > &tracks, const LayerOfHits &layer_of_hits, const std::vector< UpdateIndices > &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 SteeringParams &sp, const std::vector< bool > *ihm, bool infwd)
void	setup_bkfit (const PropagationConfig &pc, const SteeringParams &sp)
void	updateWithLoadedHit (int N_proc, const FindingFoos &fnd_foos)
Public Member Functions inherited from mkfit::MkBase
void	clearFailFlag ()
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
void	print_par_err (int corp, 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]
bool	m_in_fwd = true
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
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
const SteeringParams *	m_steering_params = nullptr
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]
MPlexQI	m_FailFlag
MPlexLV	m_Par [2]

Detailed Description

Definition at line 39 of file MkFinder.h.

Member Typedef Documentation

MPlexHitIdx

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

Definition at line 45 of file MkFinder.h.

MPlexQHoT

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

Definition at line 46 of file MkFinder.h.

Constructor & Destructor Documentation

MkFinder()

mkfit::MkFinder::MkFinder ( )

inline

Definition at line 50 of file MkFinder.h.

{}

Member Function Documentation

add_hit()

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

inlineprivate

Definition at line 236 of file MkFinder.h.

References nano_mu_digi_cff::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 701 of file MkFinder.cc.

References funct::abs(), add_hit(), Matriplex::Matriplex< T, D1, D2, N >::At(), nano_mu_local_reco_cff::chi2, mkfit::MkBase::clearFailFlag(), 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, mkfit::MkBase::m_FailFlag, 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 doesn't vectorize with current compilers
      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;
      clearFailFlag();
      (*fnd_foos.m_compute_chi2_foo)(m_Err[iP],
                                     m_Par[iP],
                                     m_Chg,
                                     m_msErr,
                                     m_msPar,
                                     outChi2,
                                     tmpPropPar,
                                     m_FailFlag,
                                     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");
    clearFailFlag();
    (*fnd_foos.m_update_param_foo)(m_Err[iP],
                                   m_Par[iP],
                                   m_Chg,
                                   m_msErr,
                                   m_msPar,
                                   m_Err[iC],
                                   m_Par[iC],
                                   m_FailFlag,
                                   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 110 of file MkFinder.h.

References m_HoTArrs, and m_NHits.

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

bkFitFitTracks()

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

Definition at line 1669 of file MkFinder.cc.

References funct::abs(), Matriplex::Matriplex< T, D1, D2, N >::add(), Matriplex::Matriplex< T, D1, D2, N >::At(), mkfit::PropagationConfig::backward_fit_pflags, mkfit::MkBase::clearFailFlag(), Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), debug, dprintf, 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_Local_Cov, mkfit::KFO_Update_Params, dttmaxenums::L, mkfit::TrackBase::label(), mkfit::LayerInfo::layer_id(), mkfit::MkBase::m_Chg, m_Chi2, m_CurNode, mkfit::MkBase::m_Err, mkfit::MkBase::m_FailFlag, 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(), mkfit::NN, mkfit::TrackBase::posEta(), mkfit::TrackBase::posPhi(), print_par_err(), 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.

    // bool debug = true;

    MPlexQF tmp_chi2;
    MPlexQI no_mat_effs;
    float tmp_err[6] = {666, 0, 666, 0, 0, 666};
    float tmp_pos[3];

#if defined(DEBUG_PROP_UPDATE)
    const int DSLOT = 0;
    printf("bkfit entry, track in slot %d\n", DSLOT);
    print_par_err(iC, DSLOT);
#endif

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

#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.

      clearFailFlag();

      // PROP-FAIL-ENABLE Once always "copy input to output on fail" is removed from
      // propagateToR one might want to enable this for barrel or endcap or both.
      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 | KFO_Local_Cov,
                        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);
      }

#if defined(DEBUG_PROP_UPDATE)
      printf("\nbkfit at layer %d, track in slot %d -- fail=%d, had hit=%d (%g, %g, %g)\n",
             LI.layer_id(),
             DSLOT,
             m_FailFlag[DSLOT],
             1 - no_mat_effs[DSLOT],
             m_msPar(DSLOT, 0, 0),
             m_msPar(DSLOT, 1, 0),
             m_msPar(DSLOT, 2, 0));
      printf("Propagated:\n");
      print_par_err(iP, DSLOT);
      printf("Updated:\n");
      print_par_err(iC, DSLOT);
#endif

      // Fixup for failed propagation or invpt sign and charge.
      for (int i = 0; i < N_proc; ++i) {
        // PROP-FAIL-ENABLE The following to be enabled when propagation failure
        // detection is properly implemented in propagate-to-R/Z.
        // 1. The following code was only expecting barrel state to be restored.
        //      auto barrel_pf(m_prop_config->backward_fit_pflags);
        //      barrel_pf.copy_input_state_on_fail = true;
        // 2. There is also check on chi2, commented out to keep physics changes minimal.
        /*
        if (m_FailFlag[i] && LI.is_barrel()) {
          // Barrel pflags are set to include PF_copy_input_state_on_fail.
          // Endcap errors are immaterial here (relevant for fwd search), with prop error codes
          // one could do other things.
          // Are there also fail conditions in KalmanUpdate?
#ifdef DEBUG
          if (debug && g_debug) {
            dprintf("MkFinder::bkFitFitTracks prop fail: chi2=%f, layer=%d, label=%d. Recovering.\n",
                    tmp_chi2[i], LI.layer_id(), m_Label[i]);
            print_par_err(iC, i);
          }
#endif
          m_Err[iC].copySlot(i, m_Err[iP]);
          m_Par[iC].copySlot(i, m_Par[iP]);
        } else if (tmp_chi2[i] > 200 || tmp_chi2[i] < 0) {
#ifdef DEBUG
          if (debug && g_debug) {
            dprintf("MkFinder::bkFitFitTracks chi2 fail: chi2=%f, layer=%d, label=%d. Recovering.\n",
                    tmp_chi2[i], LI.layer_id(), m_Label[i]);
            print_par_err(iC, i);
          }
#endif
          // Go back to propagated state (at the current hit, the previous one is lost).
          m_Err[iC].copySlot(i, m_Err[iP]);
          m_Par[iC].copySlot(i, m_Par[iP]);
        }
        */
        // Fixup invpt sign and charge.
        if (m_Par[iC].At(i, 3, 0) < 0) {
          m_Chg.At(i, 0, 0) = -m_Chg.At(i, 0, 0);
          m_Par[iC].At(i, 3, 0) = -m_Par[iC].At(i, 3, 0);
        }
      }

#if defined(DEBUG_BACKWARD_FIT)
      // clang-format off
      bool debug = true;
      const char beg_cur_sep = '/'; // set to ' ' root parsable printouts
      for (int i = 0; i < N_proc; ++i) {
        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()];

          dprintf("BKF_OVERLAP %d %d %d %d %d %d %d "
                  "%f%c%f %f %f%c%f %f %f %f %d %d %d %d "
                  "%f %f %f %f %f\n",
              m_event->evtID(),
#else
          dprintf("BKF_OVERLAP %d %d %d %d %d %d "
                  "%f%c%f %f %f%c%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(), beg_cur_sep, 1.0f / m_Par[ti].At(i, 3, 0),
              bb.posEta(),
              bb.posPhi(), beg_cur_sep, std::atan2(m_Par[ti].At(i, 1, 0), m_Par[ti].At(i, 0, 0)),
              std::hypot(m_Par[ti].At(i, 0, 0), m_Par[ti].At(i, 1, 0)),
              m_Par[ti].At(i, 2, 0),
              chi_prnt,
              std::isnan(chi), std::isfinite(chi), chi > 0,
#if defined(MKFIT_STANDALONE)
              mchi.mcTrackID(),
#endif
              // The following three can get negative / prouce nans in e2s.
              // std::abs the args for FPE hunt.
              e2s(std::abs(m_Err[ti].At(i, 0, 0))),
              e2s(std::abs(m_Err[ti].At(i, 1, 1))),
              e2s(std::abs(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
          );
        }
      }
      // clang-format on
#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 1516 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_Local_Cov, mkfit::KFO_Update_Params, dttmaxenums::L, 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 | KFO_Local_Cov,
                        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 1411 of file MkFinder.cc.

References mkfit::MatriplexErrParPackerSlurpIn< T, D >::addInput(), HLT_2023v12_cff::cands, mkfit::TrackBase::charge(), 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 1435 of file MkFinder.cc.

References mkfit::MatriplexErrParPackerSlurpIn< T, D >::addInput(), mkfit::TrackBase::charge(), mkfit::TrackCand::combCandidate(), 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 1468 of file MkFinder.cc.

References HLT_2023v12_cff::cands, mkfit::TrackBase::chi2(), Matriplex::Matriplex< T, D1, D2, N >::copyOut(), Matriplex::MatriplexSym< T, D, N >::copyOut(), mkfit::TrackBase::errors_nc(), mkfit::getScoreCand(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, mkfit::isFinite(), m_Chi2, mkfit::MkBase::m_Err, mkfit::MkBase::m_Par, m_steering_params, mkfit::SteeringParams::m_track_scorer, 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(m_steering_params->m_track_scorer, trk));
      }
    }
  }

bkFitOutputTracks() [2/2]

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

Definition at line 1487 of file MkFinder.cc.

References mkfit::TrackBase::chi2(), Matriplex::Matriplex< T, D1, D2, N >::copyOut(), Matriplex::MatriplexSym< T, D, N >::copyOut(), mkfit::TrackBase::errors_nc(), mkfit::getScoreCand(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, mkfit::isFinite(), m_Chi2, mkfit::MkBase::m_Err, mkfit::MkBase::m_Par, m_steering_params, mkfit::SteeringParams::m_track_scorer, 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(m_steering_params->m_track_scorer, trk));
      }
    }
  }

bkFitPropTracksToPCA()

void mkfit::MkFinder::bkFitPropTracksToPCA

(

const int

N_proc

)

Definition at line 1897 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 167 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(), and inputTracksAndHits().

                                                                     {
      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 196 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::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_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_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 184 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 216 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 1390 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 913 of file MkFinder.cc.

References funct::abs(), mkfit::TrackCand::addHitIdx(), Matriplex::Matriplex< T, D1, D2, N >::At(), nano_mu_local_reco_cff::chi2, mkfit::MkBase::clearFailFlag(), 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, mkfit::LayerOfHits::layer_id(), m_CandIdx, mkfit::MkBase::m_Chg, mkfit::FindingFoos::m_compute_chi2_foo, mkfit::MkBase::m_Err, mkfit::MkBase::m_FailFlag, m_HoTArrs, m_iteration_params, m_msErr, m_msPar, m_NFoundHits, m_NTailMinusOneHits, mkfit::MkBase::m_Par, m_prop_config, m_SeedIdx, m_steering_params, mkfit::SteeringParams::m_track_scorer, 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 doesn't vectorize with current compilers
      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;
      clearFailFlag();
      (*fnd_foos.m_compute_chi2_foo)(m_Err[iP],
                                     m_Par[iP],
                                     m_Chg,
                                     m_msErr,
                                     m_msPar,
                                     outChi2,
                                     propPar,
                                     m_FailFlag,
                                     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;
        clearFailFlag();
        (*fnd_foos.m_update_param_foo)(m_Err[iP],
                                       m_Par[iP],
                                       tmpChg,
                                       m_msErr,
                                       m_msPar,
                                       m_Err[iC],
                                       m_Par[iC],
                                       m_FailFlag,
                                       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(m_steering_params->m_track_scorer,
                                              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(
          m_steering_params->m_track_scorer, 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
	)

m_FailFlag[itrack] &&

Definition at line 1159 of file MkFinder.cc.

References funct::abs(), mkfit::CandCloner::add_cand(), Matriplex::Matriplex< T, D1, D2, N >::At(), mkfit::IdxChi2List::chi2, nano_mu_local_reco_cff::chi2, mkfit::IdxChi2List::chi2_hit, mkfit::MkBase::clearFailFlag(), mkfit::CandCloner::combCandWithOriginalIndex(), mkfit::Hit::detIDinLayer(), dprint, dprintf, f, mkfit::PropagationConfig::finding_intra_layer_pflags, mkfit::PropagationConfig::finding_requires_propagation_to_hit_pos, getHitSelDynamicChi2Cut(), mkfit::getScoreStruct(), mkfit::LayerOfHits::hitArray(), mkfit::IdxChi2List::hitIdx, mkfit::CombCandidate::hot(), mps_fire::i, 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, mkfit::HitOnTrack::layer, mkfit::LayerOfHits::layer_id(), m_CandIdx, mkfit::MkBase::m_Chg, m_Chi2, mkfit::FindingFoos::m_compute_chi2_foo, mkfit::MkBase::m_Err, mkfit::MkBase::m_FailFlag, m_iteration_params, m_Label, m_msErr, m_msPar, m_NFoundHits, m_NOverlapHits, m_NTailMinusOneHits, mkfit::MkBase::m_Par, m_prop_config, m_SeedIdx, m_steering_params, mkfit::SteeringParams::m_track_scorer, 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::IdxChi2List::module, mkfit::IdxChi2List::nhits, mkfit::IdxChi2List::nholes, mkfit::NN, mkfit::IdxChi2List::noverlaps, mkfit::IdxChi2List::ntailholes, num_all_minus_one_hits(), num_inside_minus_one_hits(), hltrates_dqm_sourceclient-live_cfg::offset, mkfit::passStripChargePCMfromTrack(), mkfit::IdxChi2List::pt, mkfit::LayerOfHits::refHit(), mkfit::IdxChi2List::score, mkfit::IdxChi2List::trkIdx, mkfit::WSR_Edge, and mkfit::WSR_Outside.

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 doesn't vectorize with current compilers
      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;
      clearFailFlag();
      (*fnd_foos.m_compute_chi2_foo)(m_Err[iP],
                                     m_Par[iP],
                                     m_Chg,
                                     m_msErr,
                                     m_msPar,
                                     outChi2,
                                     propPar,
                                     m_FailFlag,
                                     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) {
        // We can be in failed state from the initial propagation before selectHitIndices
        // and there hit_count for track is set to -1 and WSR state to Failed, handled below.
        // Or we might have hit it here in propagate-to-hit.
        // PROP-FAIL-ENABLE FailFlag check to be enabled when propagation failure
        // detection is properly implemented in propagate-to-R/Z.
        if ( hit_cnt < m_XHitSize[itrack]) {
          // make sure the hit was in the compatiblity window for the candidate
          const float max_c2 = getHitSelDynamicChi2Cut(itrack, iP);
          const float chi2 = std::abs(outChi2[itrack]);  //fixme negative chi2 sometimes...
          // XXX-NUM-ERR assert(chi2 >= 0);

          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(m_steering_params->m_track_scorer, 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;
      }

      // PROP-FAIL-ENABLE The following to be enabled when propagation failure
      // detection is properly implemented in propagate-to-R/Z.
      // // Override for failed propagation, this trumps all other cases.
      // if (m_XWsrResult[itrack].m_wsr == WSR_Failed) {
      //   fake_hit_idx = Hit::kHitStopIdx;
      // }

      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(m_steering_params->m_track_scorer, 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 225 of file MkFinder.cc.

References funct::abs(), Matriplex::Matriplex< T, D1, D2, N >::At(), mkfit::IterationParams::chi2Cut_min, f, mkfit::IterationLayerConfig::get_window_params(), m_in_fwd, m_iteration_layer_config, m_iteration_params, mkfit::MkBase::m_Par, SiStripPI::min, mkfit::Const::PIOver2, theta(), and findQualityFiles::v.

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

                                                                               {
    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 = std::min(invpt, 10.0f);  // => pT>0.1 GeV

    enum SelWinParameters_e { c2_sf = 8, c2_0, c2_1, c2_2 };
    auto &v = m_iteration_layer_config->get_window_params(m_in_fwd, true);

    if (!v.empty()) {
      float this_c2 = v[c2_sf] * (v[c2_0] * max_invpt + v[c2_1] * theta + v[c2_2]);
      // In case value is too low (bad window derivation or other reasons), leave original limits
      if (this_c2 > minChi2Cut)
        return this_c2;
    }
    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 194 of file MkFinder.cc.

References f, mkfit::IterationLayerConfig::get_window_params(), m_in_fwd, m_iteration_layer_config, SiStripPI::min, theta(), and findQualityFiles::v.

Referenced by selectHitIndices().

                                                                                                            {
    float max_invpt = std::min(invpt, 10.0f);  // => pT>0.1 GeV

    enum SelWinParameters_e { dp_sf = 0, dp_0, dp_1, dp_2, dq_sf, dq_0, dq_1, dq_2 };
    auto &v = m_iteration_layer_config->get_window_params(m_in_fwd, true);

    if (!v.empty()) {
      // dq hit selection window
      float this_dq = v[dq_sf] * (v[dq_0] * max_invpt + v[dq_1] * theta + v[dq_2]);
      // In case value is below 0 (bad window derivation or other reasons), leave original limits
      if (this_dq > 0.f) {
        min_dq = this_dq;
        max_dq = 2.0f * min_dq;
      }

      // dphi hit selection window
      float this_dphi = v[dp_sf] * (v[dp_0] * max_invpt + v[dp_1] * theta + v[dp_2]);
      // In case value is too low (bad window derivation or other reasons), leave original limits
      if (this_dphi > min_dphi) {
        min_dphi = this_dphi;
        max_dphi = 2.0f * min_dphi;
      }
    }
  }

inputTracksAndHitIdx() [1/4]

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

Definition at line 53 of file MkFinder.cc.

References copy_in(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, and pwdgSkimBPark_cfi::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 66 of file MkFinder.cc.

References copy_in(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, and pwdgSkimBPark_cfi::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 80 of file MkFinder.cc.

References copy_in(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, m_CandIdx, m_SeedIdx, and pwdgSkimBPark_cfi::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 139 of file MkFinder.cc.

References copy_in(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, m_CandIdx, m_SeedIdx, and pwdgSkimBPark_cfi::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;
    }
  }

inputTracksAndHits()

void mkfit::MkFinder::inputTracksAndHits	(	const std::vector< CombCandidate > &	tracks,
		const LayerOfHits &	layer_of_hits,
		const std::vector< UpdateIndices > &	idxs,
		int	beg,
		int	end,
		bool	inputProp
	)

Definition at line 107 of file MkFinder.cc.

References copy_in(), Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, m_CandIdx, m_msErr, m_msPar, m_SeedIdx, mkfit::LayerOfHits::refHit(), and pwdgSkimBPark_cfi::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) {
      const TrackCand &trk = tracks[idxs[i].seed_idx][idxs[i].cand_idx];

      copy_in(trk, imp, iI);

#ifdef DUMPHITWINDOW
      m_SeedAlgo(imp, 0, 0) = tracks[idxs[i].seed_idx].seed_algo();
      m_SeedLabel(imp, 0, 0) = tracks[idxs[i].seed_idx.seed_label();
#endif

      m_SeedIdx(imp, 0, 0) = idxs[i].seed_idx;
      m_CandIdx(imp, 0, 0) = idxs[i].cand_idx;

      const Hit &hit = layer_of_hits.refHit(idxs[i].hit_idx);
      m_msErr.copyIn(imp, hit.errArray());
      m_msPar.copyIn(imp, hit.posArray());
    }
  }

num_all_minus_one_hits()

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

inlineprivate

Definition at line 270 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 274 of file MkFinder.h.

References m_NInsideMinusOneHits.

Referenced by findCandidatesCloneEngine().

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

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 101 of file MkFinder.h.

References copy_out(), mps_fire::end, mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, m_Stopped, and pwdgSkimBPark_cfi::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 96 of file MkFinder.h.

References copy_out(), mkfit::MkBase::iC, mkfit::MkBase::iP, and HLT_2023v12_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 166 of file MkFinder.cc.

References copy_out(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, and pwdgSkimBPark_cfi::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 177 of file MkFinder.cc.

References copy_out(), mps_fire::i, mkfit::MkBase::iC, mkfit::MkBase::iP, and pwdgSkimBPark_cfi::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);
    }
  }

print_par_err()

void mkfit::MkFinder::print_par_err ( int  corp, int  mslot  ) const

private

Definition at line 1653 of file MkFinder.cc.

References mps_fire::i, dqmiolumiharvest::j, mkfit::MkBase::m_Err, and mkfit::MkBase::m_Par.

Referenced by bkFitFitTracks().

                                                        {
#ifdef DEBUG
    printf("Parameters:\n");
    for (int i = 0; i < 6; ++i) {
      printf("  %12.4g", m_Par[corp].constAt(mslot, i, 0));
    }
    printf("\nError matrix\n");
    for (int i = 0; i < 6; ++i) {
      for (int j = 0; j < 6; ++j) {
        printf("  %12.4g", m_Err[corp].constAt(mslot, i, j));
      }
      printf("\n");
    }
#endif
  }

release()

void mkfit::MkFinder::release

(

)

Definition at line 40 of file MkFinder.cc.

References m_in_fwd, m_iteration_hit_mask, m_iteration_layer_config, m_iteration_params, m_prop_config, and m_steering_params.

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

                         {
    m_prop_config = nullptr;
    m_iteration_params = nullptr;
    m_iteration_layer_config = nullptr;
    m_steering_params = nullptr;
    m_iteration_hit_mask = nullptr;
    m_in_fwd = true;
  }

selectHitIndices()

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

Definition at line 248 of file MkFinder.cc.

References funct::abs(), cms::cuda::assert(), Matriplex::Matriplex< T, D1, D2, N >::At(), Matriplex::MatriplexSym< T, D, N >::At(), mkfit::cdist(), mkfit::TrackBase::charge(), Matriplex::Matriplex< T, D1, D2, N >::constAt(), Matriplex::MatriplexSym< T, D, N >::constAt(), Matriplex::Matriplex< T, D1, D2, N >::copyIn(), Matriplex::MatriplexSym< T, D, N >::copyIn(), dprint, dprintf, PVValHelper::dz, mkfit::Hit::ephi(), mkfit::Hit::errArray(), mkfit::Hit::exx(), mkfit::Hit::eyy(), mkfit::Hit::ezz(), f, mkfit::PropagationConfig::finding_intra_layer_pflags, mkfit::PropagationConfig::finding_requires_propagation_to_hit_pos, dqmdumpme::first, mkfit::FindingFoos::get_finding_foos(), mkfit::getEta(), getHitSelDynamicWindows(), mkfit::getPhi(), mps_fire::i, createfilelist::int, mkfit::MkBase::iP, mkfit::TrackBase::isFindable(), CommonMethods::isnan(), dttmaxenums::L, mkfit::TrackBase::label(), m_CandIdx, mkfit::MkBase::m_Chg, m_Chi2, mkfit::FindingFoos::m_compute_chi2_foo, mkfit::MkBase::m_Err, mkfit::WSR_Result::m_in_gap, m_iteration_hit_mask, m_iteration_layer_config, m_iteration_params, m_Label, m_msErr, m_msPar, m_NFoundHits, mkfit::MkBase::m_Par, m_prop_config, m_SeedIdx, m_XHitArr, m_XHitSize, m_XWsrResult, SiStripPI::max, mkfit::IterationLayerConfig::max_dphi(), mkfit::IterationLayerConfig::max_dq(), mkfit::IterationParams::maxConsecHoles, mkfit::IterationParams::maxHolesPerCand, mkfit::MCHitInfo::mcTrackID(), mkfit::IterationLayerConfig::min_dphi(), mkfit::IterationLayerConfig::min_dq(), mkfit::TrackBase::momEta(), mkfit::TrackBase::momPhi(), MPlexHitIdxMax, mkfit::NN, nSigmaPhi, HLT_2023v12_cff::nSigmaZ, mkfit::Track::nTotalHits(), pi, mkfit::Const::PIOver2, mkfit::Hit::posArray(), mkfit::TrackBase::posR(), conifer::pow(), mkfit::TrackBase::prodType(), mkfit::TrackBase::pT(), submitPVResolutionJobs::q, diffTwoXMLs::r2, funct::sin(), mathSSE::sqrt(), funct::tan(), cuy::tex, theta(), mkfit::Config::usePhiQArrays, mkfit::WSR_Outside, x, mkfit::Hit::x(), mkfit::Hit::y(), mkfit::TrackBase::z(), and mkfit::Hit::z().

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 with icc and gcc
      // In llvm16 clang issues a warning that it can't vectorize
      // the loop.  Unfortunately, there doesn't seem to be a
      // pragma to suppress the warning, so we ifdef it out.  This
      // should be rechecked if llvm vectorization improves.
#if !defined(__clang__)
#pragma omp simd
#endif
      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
    {
      //layer half-thikness for dphi spread calculation; only for very restrictive iters
      const float layerD = std::abs(L.layer_info()->zmax() - L.layer_info()->zmin()) * 0.5f *
                           (m_iteration_params->maxConsecHoles == 0 || m_iteration_params->maxHolesPerCand == 0);
      // Pull out the part of the loop that vectorizes with icc and gcc
#if !defined(__clang__)
#pragma omp simd
#endif
      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 r2Inv = 1.f / r2;
        const float dphidx = -y * r2Inv, dphidy = x * r2Inv;
        const float phi = getPhi(x, y);
        const float dphi2 =
            calcdphi2(itrack, dphidx, dphidy)
            //range from finite layer thickness
            + std::pow(layerD * std::tan(m_Par[iI].At(itrack, 5, 0)) * std::sin(m_Par[iI].At(itrack, 4, 0) - phi), 2) *
                  r2Inv;
#ifdef HARD_CHECK
        assert(dphi2 >= 0);
#endif

        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) {
      // PROP-FAIL-ENABLE The following to be enabled when propagation failure
      // detection is properly implemented in propagate-to-R/Z.
      // if (m_FailFlag[itrack]) {
      //   m_XWsrResult[itrack].m_wsr = WSR_Failed;
      //   m_XHitSize[itrack] = -1;
      //   continue;
      // }

      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 SteeringParams &	sp,
		const std::vector< bool > *	ihm,
		bool	infwd
	)

Definition at line 21 of file MkFinder.cc.

References m_in_fwd, m_iteration_hit_mask, m_iteration_layer_config, m_iteration_params, m_prop_config, and m_steering_params.

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

                                   {
    m_prop_config = &pc;
    m_iteration_params = &ip;
    m_iteration_layer_config = &ilc;
    m_steering_params = &sp;
    m_iteration_hit_mask = ihm;
    m_in_fwd = infwd;
  }

setup_bkfit()

void mkfit::MkFinder::setup_bkfit	(	const PropagationConfig &	pc,
		const SteeringParams &	sp
	)

Definition at line 35 of file MkFinder.cc.

References m_prop_config, and m_steering_params.

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

                                                                                  {
    m_prop_config = &pc;
    m_steering_params = &sp;
  }

updateWithLoadedHit()

void mkfit::MkFinder::updateWithLoadedHit	(	int	N_proc,
		const FindingFoos &	fnd_foos
	)

Definition at line 1359 of file MkFinder.cc.

References mkfit::MkBase::clearFailFlag(), mkfit::PropagationConfig::finding_inter_layer_pflags, mkfit::PropagationConfig::finding_requires_propagation_to_hit_pos, mkfit::MkBase::iC, mkfit::MkBase::iP, mkfit::MkBase::m_Chg, mkfit::MkBase::m_Err, mkfit::MkBase::m_FailFlag, m_msErr, m_msPar, mkfit::MkBase::m_Par, m_prop_config, and mkfit::FindingFoos::m_update_param_foo.

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

                                                                            {
    // See comment in MkBuilder::find_tracks_in_layer() about intra / inter flags used here
    // for propagation to the hit.
    clearFailFlag();
    (*fnd_foos.m_update_param_foo)(m_Err[iP],
                                   m_Par[iP],
                                   m_Chg,
                                   m_msErr,
                                   m_msPar,
                                   m_Err[iC],
                                   m_Par[iC],
                                   m_FailFlag,
                                   N_proc,
                                   m_prop_config->finding_inter_layer_pflags,
                                   m_prop_config->finding_requires_propagation_to_hit_pos);

    // PROP-FAIL-ENABLE The following to be enabled when propagation failure
    // detection is properly implemented in propagate-to-R/Z.
    // for (int i = 0; i < N_proc; ++i) {
    //   if (m_FailFlag[i]) {
    //     dprintf("MkFinder::updateWithLoadedHit fail in update, recovering.\n");
    //     m_Err[iC].copySlot(i, m_Err[iP]);
    //     m_Par[iC].copySlot(i, m_Par[iP]);
    //   }
    // }
  }

Friends And Related Function Documentation

MkBuilder

friend class MkBuilder

friend

Definition at line 40 of file MkFinder.h.

Member Data Documentation

m_CandIdx

MPlexQI mkfit::MkFinder::m_CandIdx

private

Definition at line 295 of file MkFinder.h.

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

m_Chi2

MPlexQF mkfit::MkFinder::m_Chi2

private

Definition at line 280 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 309 of file MkFinder.h.

Referenced by copy_in(), and copy_out().

m_CurHit

int mkfit::MkFinder::m_CurHit[NN]

private

Definition at line 338 of file MkFinder.h.

Referenced by bkFitFitTracksBH(), and bkFitInputTracks().

m_CurNode

int mkfit::MkFinder::m_CurNode[NN]

private

Definition at line 340 of file MkFinder.h.

Referenced by bkFitFitTracks(), and bkFitInputTracks().

m_HoTArr

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

private

Definition at line 339 of file MkFinder.h.

Referenced by bkFitFitTracksBH(), and bkFitInputTracks().

m_HoTArrs

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

private

Definition at line 286 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 341 of file MkFinder.h.

Referenced by bkFitFitTracks(), and bkFitInputTracks().

m_in_fwd

bool mkfit::MkFinder::m_in_fwd = true

private

Definition at line 335 of file MkFinder.h.

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

m_iteration_hit_mask

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

private

Definition at line 334 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 332 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 331 of file MkFinder.h.

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

m_Label

MPlexQI mkfit::MkFinder::m_Label

private

Definition at line 281 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 307 of file MkFinder.h.

Referenced by copy_in(), and copy_out().

m_msErr

MPlexHS mkfit::MkFinder::m_msErr

private

Definition at line 320 of file MkFinder.h.

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

m_msPar

MPlexHV mkfit::MkFinder::m_msPar

private

Definition at line 321 of file MkFinder.h.

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

m_NFoundHits

MPlexQI mkfit::MkFinder::m_NFoundHits

private

Definition at line 284 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 283 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 305 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 303 of file MkFinder.h.

Referenced by copy_in(), and copy_out().

m_NOverlapHits

MPlexQI mkfit::MkFinder::m_NOverlapHits

private

Definition at line 304 of file MkFinder.h.

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

m_NTailMinusOneHits

MPlexQI mkfit::MkFinder::m_NTailMinusOneHits

private

Definition at line 306 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 330 of file MkFinder.h.

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

m_SeedIdx

MPlexQI mkfit::MkFinder::m_SeedIdx

private

Definition at line 294 of file MkFinder.h.

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

m_steering_params

const SteeringParams* mkfit::MkFinder::m_steering_params = nullptr

private

Definition at line 333 of file MkFinder.h.

Referenced by bkFitOutputTracks(), findCandidates(), findCandidatesCloneEngine(), release(), setup(), and setup_bkfit().

m_Stopped

MPlexQI mkfit::MkFinder::m_Stopped

private

Definition at line 297 of file MkFinder.h.

Referenced by outputNonStoppedTracksAndHitIdx().

m_TrkCand

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

private

Definition at line 312 of file MkFinder.h.

Referenced by bkFitFitTracks(), and bkFitInputTracks().

m_TrkStatus

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

private

Definition at line 308 of file MkFinder.h.

Referenced by copy_in(), and copy_out().

m_XHitArr

MPlexHitIdx mkfit::MkFinder::m_XHitArr

private

Definition at line 317 of file MkFinder.h.

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

m_XHitSize

MPlexQI mkfit::MkFinder::m_XHitSize

private

Definition at line 316 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 315 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 43 of file MkFinder.h.

Referenced by selectHitIndices().