MkFitCore/interface/MkBuilder.h

0001 #ifndef RecoTracker_MkFitCore_interface_MkBuilder_h
0002 #define RecoTracker_MkFitCore_interface_MkBuilder_h
0003
0004 #include "RecoTracker/MkFitCore/interface/IterationConfig.h"
0005 #include "RecoTracker/MkFitCore/interface/HitStructures.h"
0006 #include "RecoTracker/MkFitCore/interface/TrackStructures.h"
0007 #include "RecoTracker/MkFitCore/interface/MkJob.h"
0008
0009 #include <atomic>
0010 #include <functional>
0011 #include <map>
0012 #include <vector>
0013
0014 namespace mkfit {
0015
0016   class CandCloner;
0017   class LayerInfo;
0018   class MkFinder;
0019   class MkFitter;
0020   class TrackerInfo;
0021
0022   class Event;
0023
0024   //==============================================================================
0025   // MkBuilder
0026   //==============================================================================
0027
0028   class MkBuilder {
0029   public:
0030     using insert_seed_foo = void(const Track &, int, int);
0031
0032     typedef std::vector<std::pair<int, int>> CandIdx_t;
0033
0034     MkBuilder(bool silent = true) : m_silent(silent) {}
0035     ~MkBuilder() = default;
0036
0037     // --------
0038
0039     static std::unique_ptr<MkBuilder> make_builder(bool silent = true);
0040     static void populate();
0041
0042     int total_cands() const;
0043     std::pair<int, int> max_hits_layer(const EventOfHits &eoh) const;
0044
0045     // --------
0046
0047     void begin_event(MkJob *job, Event *ev, const char *build_type);
0048     void end_event();
0049     void release_memory();
0050
0051     void import_seeds(const TrackVec &in_seeds, const bool seeds_sorted, std::function<insert_seed_foo> insert_seed);
0052
0053     // filter for rearranging cands that will / will not do backward search.
0054     int filter_comb_cands(filter_candidates_func filter, bool attempt_all_cands);
0055
0056     void find_min_max_hots_size();
0057
0058     void select_best_comb_cands(bool clear_m_tracks = false, bool remove_missing_hits = false);
0059     void export_best_comb_cands(TrackVec &out_vec, bool remove_missing_hits = false);
0060     void export_tracks(TrackVec &out_vec);
0061
0062     void compactifyHitStorageForBestCand(bool remove_seed_hits, int backward_fit_min_hits) {
0063       m_event_of_comb_cands.compactifyHitStorageForBestCand(remove_seed_hits, backward_fit_min_hits);
0064     }
0065
0066     void beginBkwSearch() { m_event_of_comb_cands.beginBkwSearch(); }
0067     void endBkwSearch() { m_event_of_comb_cands.endBkwSearch(); }
0068
0069     // MIMI hack to export tracks for BH
0070     const TrackVec &ref_tracks() const { return m_tracks; }
0071     TrackVec &ref_tracks_nc() { return m_tracks; }
0072
0073     const EventOfCombCandidates &ref_eocc() const { return m_event_of_comb_cands; }
0074
0075     // --------
0076
0077     void find_tracks_load_seeds_BH(const TrackVec &in_seeds, const bool seeds_sorted);  // for FindTracksBestHit
0078     void find_tracks_load_seeds(const TrackVec &in_seeds, const bool seeds_sorted);
0079
0080     int find_tracks_unroll_candidates(std::vector<std::pair<int, int>> &seed_cand_vec,
0081                                       int start_seed,
0082                                       int end_seed,
0083                                       int layer,
0084                                       int prev_layer,
0085                                       bool pickup_only,
0086                                       SteeringParams::IterationType_e iteration_dir);
0087
0088     void find_tracks_handle_missed_layers(MkFinder *mkfndr,
0089                                           const LayerInfo &layer_info,
0090                                           std::vector<std::vector<TrackCand>> &tmp_cands,
0091                                           const std::vector<std::pair<int, int>> &seed_cand_idx,
0092                                           const int region,
0093                                           const int start_seed,
0094                                           const int itrack,
0095                                           const int end);
0096
0097     void find_tracks_in_layers(CandCloner &cloner,
0098                                MkFinder *mkfndr,
0099                                SteeringParams::IterationType_e iteration_dir,
0100                                const int start_seed,
0101                                const int end_seed,
0102                                const int region);
0103
0104     // --------
0105
0106     void seed_post_cleaning(TrackVec &tv);
0107
0108     void findTracksBestHit(SteeringParams::IterationType_e iteration_dir = SteeringParams::IT_FwdSearch);
0109     void findTracksStandard(SteeringParams::IterationType_e iteration_dir = SteeringParams::IT_FwdSearch);
0110     void findTracksCloneEngine(SteeringParams::IterationType_e iteration_dir = SteeringParams::IT_FwdSearch);
0111
0112     void backwardFitBH();
0113     void fit_cands_BH(MkFinder *mkfndr, int start_cand, int end_cand, int region);
0114
0115     void backwardFit();
0116     void fit_cands(MkFinder *mkfndr, int start_cand, int end_cand, int region);
0117
0118   private:
0119     void fit_one_seed_set(TrackVec &simtracks, int itrack, int end, MkFitter *mkfttr, const bool is_brl[]);
0120
0121     MkJob *m_job = nullptr;
0122
0123     // MIMI -- Used by seed processing / validation.
0124     Event *m_event = nullptr;
0125
0126     // State for BestHit
0127     TrackVec m_tracks;
0128
0129     // State for Std / CloneEngine
0130     EventOfCombCandidates m_event_of_comb_cands;
0131
0132     // Per-region seed information
0133     std::vector<int> m_seedEtaSeparators;
0134     std::vector<int> m_seedMinLastLayer;
0135     std::vector<int> m_seedMaxLastLayer;
0136
0137     std::atomic<int> m_nan_n_silly_per_layer_count;
0138
0139     bool m_silent;
0140   };
0141
0142 }  // end namespace mkfit
0143
0144 #endif