diff --git a/RecoTracker/MkFitCMS/src/MkStdSeqs.cc b/RecoTracker/MkFitCMS/src/MkStdSeqs.cc index e1c2f5de653e9..7809f8657ed85 100644 --- a/RecoTracker/MkFitCMS/src/MkStdSeqs.cc +++ b/RecoTracker/MkFitCMS/src/MkStdSeqs.cc @@ -733,5 +733,39 @@ namespace mkfit { } rqf_instance; } // namespace + //========================================================================= + // Track scoring + //========================================================================= + + float trackScoreDefault(const int nfoundhits, + const int ntailholes, + const int noverlaphits, + const int nmisshits, + const float chi2, + const float pt, + const bool inFindCandidates) { + float maxBonus = 8.0; + float bonus = Config::validHitSlope_ * nfoundhits + Config::validHitBonus_; + float penalty = Config::missingHitPenalty_; + float tailPenalty = Config::tailMissingHitPenalty_; + float overlapBonus = Config::overlapHitBonus_; + if (pt < 0.9) { + penalty *= inFindCandidates ? 1.7f : 1.5f; + bonus = std::min(bonus * (inFindCandidates ? 0.9f : 1.0f), maxBonus); + } + float score = + bonus * nfoundhits + overlapBonus * noverlaphits - penalty * nmisshits - tailPenalty * ntailholes - chi2; + return score; + } + + namespace { + CMS_SA_ALLOW struct register_track_scorers { + register_track_scorers() { + IterationConfig::register_track_scorer("default", trackScoreDefault); + IterationConfig::register_track_scorer("phase1:default", trackScoreDefault); + } + } rts_instance; + } // namespace + } // namespace StdSeq } // namespace mkfit diff --git a/RecoTracker/MkFitCMS/standalone/MkStandaloneSeqs.cc b/RecoTracker/MkFitCMS/standalone/MkStandaloneSeqs.cc index 65a00def35bd6..e2b265b9e098e 100644 --- a/RecoTracker/MkFitCMS/standalone/MkStandaloneSeqs.cc +++ b/RecoTracker/MkFitCMS/standalone/MkStandaloneSeqs.cc @@ -3,6 +3,7 @@ #include "RecoTracker/MkFitCore/interface/HitStructures.h" #include "RecoTracker/MkFitCore/standalone/Event.h" +#include "RecoTracker/MkFitCore/interface/IterationConfig.h" #include "RecoTracker/MkFitCore/src/Debug.h" @@ -396,8 +397,9 @@ namespace mkfit { } void score_tracks(TrackVec &tracks) { + auto score_func = IterationConfig::get_track_scorer("default"); for (auto &track : tracks) { - track.setScore(getScoreCand(track)); + track.setScore(getScoreCand(score_func, track)); } } diff --git a/RecoTracker/MkFitCore/interface/FunctionTypes.h b/RecoTracker/MkFitCore/interface/FunctionTypes.h new file mode 100644 index 0000000000000..128049191d368 --- /dev/null +++ b/RecoTracker/MkFitCore/interface/FunctionTypes.h @@ -0,0 +1,44 @@ +#ifndef RecoTracker_MkFitCore_interface_FunctionTypes_h +#define RecoTracker_MkFitCore_interface_FunctionTypes_h + +#include + +namespace mkfit { + + struct BeamSpot; + class EventOfHits; + class TrackerInfo; + class Track; + class TrackCand; + class MkJob; + class IterationConfig; + class IterationSeedPartition; + + typedef std::vector TrackVec; + + // ---------------------------------------------------------- + + using clean_seeds_cf = int(TrackVec &, const IterationConfig &, const BeamSpot &); + using clean_seeds_func = std::function; + + using partition_seeds_cf = void(const TrackerInfo &, const TrackVec &, const EventOfHits &, IterationSeedPartition &); + using partition_seeds_func = std::function; + + using filter_candidates_cf = bool(const TrackCand &, const MkJob &); + using filter_candidates_func = std::function; + + using clean_duplicates_cf = void(TrackVec &, const IterationConfig &); + using clean_duplicates_func = std::function; + + using track_score_cf = float(const int nfoundhits, + const int ntailholes, + const int noverlaphits, + const int nmisshits, + const float chi2, + const float pt, + const bool inFindCandidates); + using track_score_func = std::function; + +} // end namespace mkfit + +#endif diff --git a/RecoTracker/MkFitCore/interface/IterationConfig.h b/RecoTracker/MkFitCore/interface/IterationConfig.h index d045a1c770d98..99eb837a65adc 100644 --- a/RecoTracker/MkFitCore/interface/IterationConfig.h +++ b/RecoTracker/MkFitCore/interface/IterationConfig.h @@ -1,6 +1,7 @@ #ifndef RecoTracker_MkFitCore_interface_IterationConfig_h #define RecoTracker_MkFitCore_interface_IterationConfig_h +#include "RecoTracker/MkFitCore/interface/FunctionTypes.h" #include "RecoTracker/MkFitCore/interface/SteeringParams.h" #include "nlohmann/json_fwd.hpp" @@ -9,15 +10,6 @@ namespace mkfit { - struct BeamSpot; - class EventOfHits; - class TrackerInfo; - class Track; - class TrackCand; - class MkJob; - - typedef std::vector TrackVec; - //============================================================================== // Hit masks / IterationMaskIfc //============================================================================== @@ -129,22 +121,6 @@ namespace mkfit { class IterationConfig { public: - // Called directly. - using clean_seeds_cf = int(TrackVec &, const IterationConfig &, const BeamSpot &); - using clean_seeds_func = std::function; - // Called from MkBuilder::find_tracks_load_seeds(). - using partition_seeds_cf = void(const TrackerInfo &, - const TrackVec &, - const EventOfHits &, - IterationSeedPartition &); - using partition_seeds_func = std::function; - // Passed to MkBuilder::filter_comb_cands(). - using filter_candidates_cf = bool(const TrackCand &, const MkJob &); - using filter_candidates_func = std::function; - // Called directly. - using clean_duplicates_cf = void(TrackVec &, const IterationConfig &); - using clean_duplicates_func = std::function; - int m_iteration_index = -1; int m_track_algorithm = -1; @@ -181,17 +157,24 @@ namespace mkfit { std::vector m_steering_params; std::vector m_layer_configs; - // Standard functions + // *** Standard functions + // - seed cleaning: called directly from top-level per-iteration steering code. clean_seeds_func m_seed_cleaner; + // - seed partitioning into eta regions: called from MkBuilder::find_tracks_load_seeds(). partition_seeds_func m_seed_partitioner; + // - candidate filtering: passed to MkBuilder::filter_comb_cands(). filter_candidates_func m_pre_bkfit_filter, m_post_bkfit_filter; + // - duplicate cleaning: called directly from top-level per-iteration steering code. clean_duplicates_func m_duplicate_cleaner; + // - default track scoring function, can be overriden in SteeringParams for each eta region. + track_score_func m_default_track_scorer; // Names for Standard functions that get saved to / loaded from JSON. std::string m_seed_cleaner_name; std::string m_seed_partitioner_name; std::string m_pre_bkfit_filter_name, m_post_bkfit_filter_name; std::string m_duplicate_cleaner_name; + std::string m_default_track_scorer_name = "default"; //---------------------------------------------------------------------------- @@ -225,6 +208,7 @@ namespace mkfit { m_pre_bkfit_filter_name = o.m_pre_bkfit_filter_name; m_post_bkfit_filter_name = o.m_post_bkfit_filter_name; m_duplicate_cleaner_name = o.m_duplicate_cleaner_name; + m_default_track_scorer_name = o.m_default_track_scorer_name; } void set_iteration_index_and_track_algorithm(int idx, int trk_alg) { @@ -275,11 +259,13 @@ namespace mkfit { static void register_seed_partitioner(const std::string &name, partition_seeds_func func); static void register_candidate_filter(const std::string &name, filter_candidates_func func); static void register_duplicate_cleaner(const std::string &name, clean_duplicates_func func); + static void register_track_scorer(const std::string &name, track_score_func func); static clean_seeds_func get_seed_cleaner(const std::string &name); static partition_seeds_func get_seed_partitioner(const std::string &name); static filter_candidates_func get_candidate_filter(const std::string &name); static clean_duplicates_func get_duplicate_cleaner(const std::string &name); + static track_score_func get_track_scorer(const std::string &name); }; //============================================================================== diff --git a/RecoTracker/MkFitCore/interface/MkBuilder.h b/RecoTracker/MkFitCore/interface/MkBuilder.h index caf0d3b8423c2..03aeba2c842bd 100644 --- a/RecoTracker/MkFitCore/interface/MkBuilder.h +++ b/RecoTracker/MkFitCore/interface/MkBuilder.h @@ -21,10 +21,6 @@ namespace mkfit { class Event; - //============================================================================== - // MkJob - //============================================================================== - //============================================================================== // MkBuilder //============================================================================== @@ -55,7 +51,7 @@ namespace mkfit { void import_seeds(const TrackVec &in_seeds, const bool seeds_sorted, std::function insert_seed); // filter for rearranging cands that will / will not do backward search. - int filter_comb_cands(IterationConfig::filter_candidates_func filter); + int filter_comb_cands(filter_candidates_func filter); void find_min_max_hots_size(); diff --git a/RecoTracker/MkFitCore/interface/SteeringParams.h b/RecoTracker/MkFitCore/interface/SteeringParams.h index 799ef4aecad7c..e6a1effb0c16e 100644 --- a/RecoTracker/MkFitCore/interface/SteeringParams.h +++ b/RecoTracker/MkFitCore/interface/SteeringParams.h @@ -1,6 +1,8 @@ #ifndef RecoTracker_MkFitCore_interface_SteeringParams_h #define RecoTracker_MkFitCore_interface_SteeringParams_h +#include "RecoTracker/MkFitCore/interface/FunctionTypes.h" + #include #include @@ -91,9 +93,11 @@ namespace mkfit { else return m_steering_params.m_layer_plan[m_end_index + 1].m_layer; } - }; + }; // class iterator std::vector m_layer_plan; + track_score_func m_track_scorer; + std::string m_track_scorer_name; int m_region; diff --git a/RecoTracker/MkFitCore/interface/Track.h b/RecoTracker/MkFitCore/interface/Track.h index dcb24a480eec4..1410afe08bccc 100644 --- a/RecoTracker/MkFitCore/interface/Track.h +++ b/RecoTracker/MkFitCore/interface/Track.h @@ -3,6 +3,7 @@ #include "RecoTracker/MkFitCore/interface/Config.h" #include "RecoTracker/MkFitCore/interface/MatrixSTypes.h" +#include "RecoTracker/MkFitCore/interface/FunctionTypes.h" #include "RecoTracker/MkFitCore/interface/Hit.h" #include "RecoTracker/MkFitCore/interface/TrackerInfo.h" @@ -603,31 +604,10 @@ namespace mkfit { return -1e16; // somewhat arbitrary value, used for handling of best short track during finding (will try to take it out) } - inline float getScoreCalc(const int nfoundhits, - const int ntailholes, - const int noverlaphits, - const int nmisshits, - const float chi2, - const float pt, - const bool inFindCandidates = false) { - //// Do not allow for chi2<0 in score calculation - // if(chi2<0) chi2=0.f; - - float maxBonus = 8.0; - float bonus = Config::validHitSlope_ * nfoundhits + Config::validHitBonus_; - float penalty = Config::missingHitPenalty_; - float tailPenalty = Config::tailMissingHitPenalty_; - float overlapBonus = Config::overlapHitBonus_; - if (pt < 0.9) { - penalty *= inFindCandidates ? 1.7f : 1.5f; - bonus = std::min(bonus * (inFindCandidates ? 0.9f : 1.0f), maxBonus); - } - float score_ = - bonus * nfoundhits + overlapBonus * noverlaphits - penalty * nmisshits - tailPenalty * ntailholes - chi2; - return score_; - } - - inline float getScoreCand(const Track& cand1, bool penalizeTailMissHits = false, bool inFindCandidates = false) { + inline float getScoreCand(const track_score_func& score_func, + const Track& cand1, + bool penalizeTailMissHits = false, + bool inFindCandidates = false) { int nfoundhits = cand1.nFoundHits(); int noverlaphits = cand1.nOverlapHits(); int nmisshits = cand1.nInsideMinusOneHits(); @@ -637,10 +617,10 @@ namespace mkfit { // Do not allow for chi2<0 in score calculation if (chi2 < 0) chi2 = 0.f; - return getScoreCalc(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates); + return score_func(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates); } - inline float getScoreStruct(const IdxChi2List& cand1) { + inline float getScoreStruct(const track_score_func& score_func, const IdxChi2List& cand1) { int nfoundhits = cand1.nhits; int ntailholes = cand1.ntailholes; int noverlaphits = cand1.noverlaps; @@ -650,7 +630,7 @@ namespace mkfit { // Do not allow for chi2<0 in score calculation if (chi2 < 0) chi2 = 0.f; - return getScoreCalc(nfoundhits, ntailholes, noverlaphits, nmisshits, chi2, pt, true /*inFindCandidates*/); + return score_func(nfoundhits, ntailholes, noverlaphits, nmisshits, chi2, pt, true /*inFindCandidates*/); } template diff --git a/RecoTracker/MkFitCore/interface/TrackStructures.h b/RecoTracker/MkFitCore/interface/TrackStructures.h index e17ace9ecefd8..8ce660c88c8d7 100644 --- a/RecoTracker/MkFitCore/interface/TrackStructures.h +++ b/RecoTracker/MkFitCore/interface/TrackStructures.h @@ -255,7 +255,10 @@ namespace mkfit { return cand1.score() > cand2.score(); } - inline float getScoreCand(const TrackCand& cand1, bool penalizeTailMissHits = false, bool inFindCandidates = false) { + inline float getScoreCand(const track_score_func& score_func, + const TrackCand& cand1, + bool penalizeTailMissHits = false, + bool inFindCandidates = false) { int nfoundhits = cand1.nFoundHits(); int noverlaphits = cand1.nOverlapHits(); int nmisshits = cand1.nInsideMinusOneHits(); @@ -265,7 +268,7 @@ namespace mkfit { // Do not allow for chi2<0 in score calculation if (chi2 < 0) chi2 = 0.f; - return getScoreCalc(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates); + return score_func(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates); } // CombCandidate -- a set of candidates from a given seed. @@ -371,14 +374,17 @@ namespace mkfit { m_hots.clear(); } - void importSeed(const Track& seed, int region); + void importSeed(const Track& seed, const track_score_func& score_func, int region); int addHit(const HitOnTrack& hot, float chi2, int prev_idx) { m_hots.push_back({hot, chi2, prev_idx}); return m_hots_size++; } - void mergeCandsAndBestShortOne(const IterationParams& params, bool update_score, bool sort_cands); + void mergeCandsAndBestShortOne(const IterationParams& params, + const track_score_func& score_func, + bool update_score, + bool sort_cands); void compactifyHitStorageForBestCand(bool remove_seed_hits, int backward_fit_min_hits); void beginBkwSearch(); @@ -612,10 +618,10 @@ namespace mkfit { m_n_seeds_inserted -= n_removed; } - void insertSeed(const Track& seed, int region, int pos) { + void insertSeed(const Track& seed, const track_score_func& score_func, int region, int pos) { assert(pos < m_size); - m_candidates[pos].importSeed(seed, region); + m_candidates[pos].importSeed(seed, score_func, region); ++m_n_seeds_inserted; } diff --git a/RecoTracker/MkFitCore/src/IterationConfig.cc b/RecoTracker/MkFitCore/src/IterationConfig.cc index 5025d99cd3fcf..fbf6278cd23d9 100644 --- a/RecoTracker/MkFitCore/src/IterationConfig.cc +++ b/RecoTracker/MkFitCore/src/IterationConfig.cc @@ -38,6 +38,7 @@ namespace mkfit { ITCONF_DEFINE_TYPE_NON_INTRUSIVE(mkfit::SteeringParams, /* std::vector */ m_layer_plan, + /* std::string */ m_track_scorer_name, /* int */ m_region, /* int */ m_fwd_search_pickup, /* int */ m_bkw_fit_last, @@ -84,6 +85,7 @@ namespace mkfit { /* std::string */ m_pre_bkfit_filter_name, /* std::string */ m_post_bkfit_filter_name, /* std::string */ m_duplicate_cleaner_name, + /* std::string */ m_default_track_scorer_name, /* bool */ m_requires_seed_hit_sorting, /* bool */ m_backward_search, /* bool */ m_backward_drop_seed_hits, @@ -117,10 +119,11 @@ namespace mkfit { namespace { struct FuncCatalog { - std::map seed_cleaners; - std::map seed_partitioners; - std::map candidate_filters; - std::map duplicate_cleaners; + std::map seed_cleaners; + std::map seed_partitioners; + std::map candidate_filters; + std::map duplicate_cleaners; + std::map track_scorers; std::mutex catalog_mutex; }; @@ -151,6 +154,10 @@ namespace mkfit { GET_FC; fc.duplicate_cleaners.insert({name, func}); } + void IterationConfig::register_track_scorer(const std::string &name, track_score_func func) { + GET_FC; + fc.track_scorers.insert({name, func}); + } namespace { template @@ -168,22 +175,26 @@ namespace mkfit { } } // namespace - IterationConfig::clean_seeds_func IterationConfig::get_seed_cleaner(const std::string &name) { + clean_seeds_func IterationConfig::get_seed_cleaner(const std::string &name) { GET_FC; return resolve_func_name(fc.seed_cleaners, name, __func__); } - IterationConfig::partition_seeds_func IterationConfig::get_seed_partitioner(const std::string &name) { + partition_seeds_func IterationConfig::get_seed_partitioner(const std::string &name) { GET_FC; return resolve_func_name(fc.seed_partitioners, name, __func__); } - IterationConfig::filter_candidates_func IterationConfig::get_candidate_filter(const std::string &name) { + filter_candidates_func IterationConfig::get_candidate_filter(const std::string &name) { GET_FC; return resolve_func_name(fc.candidate_filters, name, __func__); } - IterationConfig::clean_duplicates_func IterationConfig::get_duplicate_cleaner(const std::string &name) { + clean_duplicates_func IterationConfig::get_duplicate_cleaner(const std::string &name) { GET_FC; return resolve_func_name(fc.duplicate_cleaners, name, __func__); } + track_score_func IterationConfig::get_track_scorer(const std::string &name) { + GET_FC; + return resolve_func_name(fc.track_scorers, name, __func__); + } #undef GET_FC @@ -210,7 +221,12 @@ namespace mkfit { dprintf(" Set duplicate_cleaner for '%s' %s\n", m_duplicate_cleaner_name.c_str(), m_duplicate_cleaner ? "SET" : "NOT SET"); - ; + + m_default_track_scorer = get_track_scorer(m_default_track_scorer_name); + for (auto &sp : m_steering_params) { + sp.m_track_scorer = + sp.m_track_scorer_name.empty() ? m_default_track_scorer : get_track_scorer(sp.m_track_scorer_name); + } } // ============================================================================ diff --git a/RecoTracker/MkFitCore/src/MkBuilder.cc b/RecoTracker/MkFitCore/src/MkBuilder.cc index de249104b50fa..234ccd0945a42 100644 --- a/RecoTracker/MkFitCore/src/MkBuilder.cc +++ b/RecoTracker/MkFitCore/src/MkBuilder.cc @@ -301,7 +301,7 @@ namespace mkfit { //------------------------------------------------------------------------------ - int MkBuilder::filter_comb_cands(IterationConfig::filter_candidates_func filter) { + int MkBuilder::filter_comb_cands(filter_candidates_func filter) { EventOfCombCandidates &eoccs = m_event_of_comb_cands; int i = 0, place_pos = 0; @@ -527,6 +527,7 @@ namespace mkfit { mkfndr->setup(prop_config, m_job->m_iter_config.m_params, m_job->m_iter_config.m_layer_configs[curr_layer], + st_par, m_job->get_mask_for_layer(curr_layer)); const LayerOfHits &layer_of_hits = m_job->m_event_of_hits[curr_layer]; @@ -618,7 +619,7 @@ namespace mkfit { m_event_of_comb_cands.reset((int)in_seeds.size(), m_job->max_max_cands()); import_seeds(in_seeds, seeds_sorted, [&](const Track &seed, int region, int pos) { - m_event_of_comb_cands.insertSeed(seed, region, pos); + m_event_of_comb_cands.insertSeed(seed, m_job->steering_params(region).m_track_scorer, region, pos); }); } @@ -810,6 +811,7 @@ namespace mkfit { mkfndr->setup(prop_config, iter_params, m_job->m_iter_config.m_layer_configs[curr_layer], + st_par, m_job->get_mask_for_layer(curr_layer)); dprintf("\n* Processing layer %d\n", curr_layer); @@ -912,7 +914,7 @@ namespace mkfit { // final sorting for (int iseed = start_seed; iseed < end_seed; ++iseed) { - eoccs[iseed].mergeCandsAndBestShortOne(m_job->params(), true, true); + eoccs[iseed].mergeCandsAndBestShortOne(m_job->params(), st_par.m_track_scorer, true, true); } }); // end parallel-for over chunk of seeds within region }); // end of parallel-for-each over eta regions @@ -1018,6 +1020,7 @@ namespace mkfit { mkfndr->setup(prop_config, iter_params, m_job->m_iter_config.m_layer_configs[curr_layer], + st_par, m_job->get_mask_for_layer(curr_layer)); const bool pickup_only = layer_plan_it.is_pickup_only(); @@ -1144,7 +1147,7 @@ namespace mkfit { // final sorting for (int iseed = start_seed; iseed < end_seed; ++iseed) { - eoccs[iseed].mergeCandsAndBestShortOne(m_job->params(), true, true); + eoccs[iseed].mergeCandsAndBestShortOne(m_job->params(), st_par.m_track_scorer, true, true); } } @@ -1316,7 +1319,7 @@ namespace mkfit { EventOfCombCandidates &eoccs = m_event_of_comb_cands; const SteeringParams &st_par = m_job->steering_params(region); const PropagationConfig &prop_config = PropagationConfig::get_default(); - mkfndr->setup_bkfit(prop_config); + mkfndr->setup_bkfit(prop_config, st_par); int step = NN; for (int icand = start_cand; icand < end_cand; icand += step) { diff --git a/RecoTracker/MkFitCore/src/MkFinder.cc b/RecoTracker/MkFitCore/src/MkFinder.cc index 1ecf8cd441b46..10a9657f45fe0 100644 --- a/RecoTracker/MkFitCore/src/MkFinder.cc +++ b/RecoTracker/MkFitCore/src/MkFinder.cc @@ -36,19 +36,25 @@ namespace mkfit { void MkFinder::setup(const PropagationConfig &pc, const IterationParams &ip, const IterationLayerConfig &ilc, + const SteeringParams &sp, const std::vector *ihm) { m_prop_config = &pc; m_iteration_params = &ip; m_iteration_layer_config = &ilc; + m_steering_params = &sp; m_iteration_hit_mask = ihm; } - void MkFinder::setup_bkfit(const PropagationConfig &pc) { m_prop_config = &pc; } + void MkFinder::setup_bkfit(const PropagationConfig &pc, const SteeringParams &sp) { + m_prop_config = &pc; + m_steering_params = &sp; + } void MkFinder::release() { m_prop_config = nullptr; m_iteration_params = nullptr; m_iteration_layer_config = nullptr; + m_steering_params = nullptr; m_iteration_hit_mask = nullptr; } @@ -1072,7 +1078,10 @@ namespace mkfit { copy_out(newcand, itrack, iC); newcand.setCharge(tmpChg(itrack, 0, 0)); newcand.addHitIdx(hit_idx, layer_of_hits.layer_id(), chi2); - newcand.setScore(getScoreCand(newcand, true /*penalizeTailMissHits*/, true /*inFindCandidates*/)); + newcand.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 @@ -1129,7 +1138,8 @@ namespace mkfit { TrackCand newcand; copy_out(newcand, itrack, iP); newcand.addHitIdx(fake_hit_idx, layer_of_hits.layer_id(), 0.); - newcand.setScore(getScoreCand(newcand, true /*penalizeTailMissHits*/, true /*inFindCandidates*/)); + 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); @@ -1266,7 +1276,7 @@ namespace mkfit { tmpList.pt = std::abs(1.0f / m_Par[iP].At(itrack, 3, 0)); tmpList.chi2 = m_Chi2(itrack, 0, 0) + chi2; tmpList.chi2_hit = chi2; - tmpList.score = getScoreStruct(tmpList); + 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 @@ -1318,7 +1328,7 @@ namespace mkfit { tmpList.pt = std::abs(1.0f / m_Par[iP].At(itrack, 3, 0)); tmpList.chi2 = m_Chi2(itrack, 0, 0); tmpList.chi2_hit = 0; - tmpList.score = getScoreStruct(tmpList); + 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); } @@ -1439,7 +1449,7 @@ namespace mkfit { trk.setChi2(m_Chi2(itrack, 0, 0)); if (isFinite(trk.chi2())) { - trk.setScore(getScoreCand(trk)); + trk.setScore(getScoreCand(m_steering_params->m_track_scorer, trk)); } } } @@ -1460,7 +1470,7 @@ namespace mkfit { trk.setChi2(m_Chi2(itrack, 0, 0)); if (isFinite(trk.chi2())) { - trk.setScore(getScoreCand(trk)); + trk.setScore(getScoreCand(m_steering_params->m_track_scorer, trk)); } } } diff --git a/RecoTracker/MkFitCore/src/MkFinder.h b/RecoTracker/MkFitCore/src/MkFinder.h index bfd6185c5cead..8b4a538cf45ee 100644 --- a/RecoTracker/MkFitCore/src/MkFinder.h +++ b/RecoTracker/MkFitCore/src/MkFinder.h @@ -52,8 +52,9 @@ namespace mkfit { void setup(const PropagationConfig &pc, const IterationParams &ip, const IterationLayerConfig &ilc, + const SteeringParams &sp, const std::vector *ihm); - void setup_bkfit(const PropagationConfig &pc); + void setup_bkfit(const PropagationConfig &pc, const SteeringParams &sp); void release(); //---------------------------------------------------------------------------- @@ -326,6 +327,7 @@ namespace mkfit { const PropagationConfig *m_prop_config = nullptr; const IterationParams *m_iteration_params = nullptr; const IterationLayerConfig *m_iteration_layer_config = nullptr; + const SteeringParams *m_steering_params = nullptr; const std::vector *m_iteration_hit_mask = nullptr; // Backward fit diff --git a/RecoTracker/MkFitCore/src/TrackStructures.cc b/RecoTracker/MkFitCore/src/TrackStructures.cc index 8feccd9dd6a2a..0c23b2c3ad062 100644 --- a/RecoTracker/MkFitCore/src/TrackStructures.cc +++ b/RecoTracker/MkFitCore/src/TrackStructures.cc @@ -50,7 +50,7 @@ namespace mkfit { // CombCandidate //============================================================================== - void CombCandidate::importSeed(const Track &seed, int region) { + void CombCandidate::importSeed(const Track &seed, const track_score_func &score_func, int region) { m_trk_cands.emplace_back(TrackCand(seed, this)); m_state = CombCandidate::Dormant; @@ -71,18 +71,21 @@ namespace mkfit { cand.addHitIdx(hp->index, hp->layer, 0.0f); } - cand.setScore(getScoreCand(cand)); + cand.setScore(getScoreCand(score_func, cand)); } - void CombCandidate::mergeCandsAndBestShortOne(const IterationParams ¶ms, bool update_score, bool sort_cands) { + void CombCandidate::mergeCandsAndBestShortOne(const IterationParams ¶ms, + const track_score_func &score_func, + bool update_score, + bool sort_cands) { TrackCand *best_short = m_best_short_cand.combCandidate() ? &m_best_short_cand : nullptr; if (!empty()) { if (update_score) { for (auto &c : m_trk_cands) - c.setScore(getScoreCand(c)); + c.setScore(getScoreCand(score_func, c)); if (best_short) - best_short->setScore(getScoreCand(*best_short)); + best_short->setScore(getScoreCand(score_func, *best_short)); } if (sort_cands) { std::sort(m_trk_cands.begin(), m_trk_cands.end(), sortByScoreTrackCand); diff --git a/RecoTracker/MkFitCore/standalone/Event.cc b/RecoTracker/MkFitCore/standalone/Event.cc index 1a5d8259e16bb..eab6f66f8ec8e 100644 --- a/RecoTracker/MkFitCore/standalone/Event.cc +++ b/RecoTracker/MkFitCore/standalone/Event.cc @@ -1,4 +1,5 @@ #include "Event.h" +#include "RecoTracker/MkFitCore/interface/IterationConfig.h" #include "RecoTracker/MkFitCore/interface/TrackerInfo.h" //#define DEBUG @@ -538,7 +539,7 @@ namespace mkfit { void Event::print_tracks(const TrackVec &tracks, bool print_hits) const { const int nt = tracks.size(); - + auto score_func = IterationConfig::get_track_scorer("default"); //WARNING: Printouts for hits will not make any sense if mkFit is not run with a validation flag such as --quality-val printf("Event::print_tracks printing %d tracks %s hits:\n", nt, (print_hits ? "with" : "without")); for (int it = 0; it < nt; it++) { @@ -551,7 +552,7 @@ namespace mkfit { t.nFoundHits(), t.label(), t.isFindable(), - getScoreCand(t), + getScoreCand(score_func, t), t.chi2()); if (print_hits) { diff --git a/RecoTracker/MkFitCore/standalone/TTreeValidation.cc b/RecoTracker/MkFitCore/standalone/TTreeValidation.cc index 1e2e93ac745f9..8f568f9141011 100644 --- a/RecoTracker/MkFitCore/standalone/TTreeValidation.cc +++ b/RecoTracker/MkFitCore/standalone/TTreeValidation.cc @@ -1067,22 +1067,23 @@ namespace mkfit { auto& seedtracks = ev.seedTracks_; auto& candtracks = ev.candidateTracks_; auto& fittracks = ev.fitTracks_; + auto score_calc = IterationConfig::get_track_scorer("default"); // first compute score... for (auto& seedtrack : seedtracks) { - seedtrack.setScore(getScoreCand(seedtrack)); + seedtrack.setScore(getScoreCand(score_calc, seedtrack)); } // ...then use map to set seed type to for build/fit tracks and compute scores for (const auto& candToSeedPair : candToSeedMapDumbCMSSW_) { auto& candtrack = candtracks[candToSeedPair.first]; - candtrack.setScore(getScoreCand(candtrack)); + candtrack.setScore(getScoreCand(score_calc, candtrack)); } for (const auto& fitToSeedPair : fitToSeedMapDumbCMSSW_) { auto& fittrack = fittracks[fitToSeedPair.first]; - fittrack.setScore(getScoreCand(fittrack)); + fittrack.setScore(getScoreCand(score_calc, fittrack)); } }