File indexing completed on 2024-04-06 12:28:31
0001 #ifndef RecoTracker_PixelSeeding_IntermediateHitTriplets_h
0002 #define RecoTracker_PixelSeeding_IntermediateHitTriplets_h
0003
0004 #include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h"
0005 #include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h"
0006 #include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h"
0007 #include "RecoTracker/PixelSeeding/interface/OrderedHitTriplets.h"
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022 class IntermediateHitTriplets {
0023 public:
0024 using LayerPair = std::tuple<SeedingLayerSetsHits::LayerIndex, SeedingLayerSetsHits::LayerIndex>;
0025 using LayerTriplet =
0026 std::tuple<SeedingLayerSetsHits::LayerIndex, SeedingLayerSetsHits::LayerIndex, SeedingLayerSetsHits::LayerIndex>;
0027 using RegionIndex = ihd::RegionIndex;
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039 class PLayerHitTriplets {
0040 public:
0041 PLayerHitTriplets(const LayerTriplet &layerTriplet, unsigned int tripletsBegin)
0042 : layerTriplet_(layerTriplet), tripletsBegin_(tripletsBegin), tripletsEnd_(tripletsBegin) {}
0043
0044 void setTripletsEnd(unsigned int end) { tripletsEnd_ = end; }
0045
0046 const LayerTriplet &layerTriplet() const { return layerTriplet_; }
0047
0048 unsigned int tripletsBegin() const { return tripletsBegin_; }
0049 unsigned int tripletsEnd() const { return tripletsEnd_; }
0050
0051 private:
0052 LayerTriplet layerTriplet_;
0053 unsigned int tripletsBegin_;
0054 unsigned int tripletsEnd_;
0055 };
0056
0057
0058
0059
0060
0061
0062
0063 class LayerHitTriplets {
0064 public:
0065 using const_iterator = std::vector<OrderedHitTriplet>::const_iterator;
0066
0067 LayerHitTriplets(const IntermediateHitTriplets *hitSets, const PLayerHitTriplets *layerTriplet)
0068 : hitSets_(hitSets), layerTriplet_(layerTriplet) {}
0069
0070 using TripletRange =
0071 std::pair<std::vector<OrderedHitTriplet>::const_iterator, std::vector<OrderedHitTriplet>::const_iterator>;
0072
0073 SeedingLayerSetsHits::LayerIndex innerLayerIndex() const { return std::get<0>(layerTriplet_->layerTriplet()); }
0074 SeedingLayerSetsHits::LayerIndex middleLayerIndex() const { return std::get<1>(layerTriplet_->layerTriplet()); }
0075 SeedingLayerSetsHits::LayerIndex outerLayerIndex() const { return std::get<2>(layerTriplet_->layerTriplet()); }
0076
0077 const_iterator begin() const { return hitSets_->tripletsBegin() + layerTriplet_->tripletsBegin(); }
0078 const_iterator cbegin() const { return begin(); }
0079 const_iterator end() const { return hitSets_->tripletsBegin() + layerTriplet_->tripletsEnd(); }
0080 const_iterator cend() const { return end(); }
0081
0082 private:
0083 const IntermediateHitTriplets *hitSets_;
0084 const PLayerHitTriplets *layerTriplet_;
0085 };
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099 class RegionLayerSets {
0100 public:
0101 using PLayerHitTripletsConstIterator = std::vector<PLayerHitTriplets>::const_iterator;
0102 using TripletConstIterator = std::vector<OrderedHitTriplet>::const_iterator;
0103
0104 class const_iterator {
0105 public:
0106 using internal_iterator_type = PLayerHitTripletsConstIterator;
0107 using value_type = LayerHitTriplets;
0108 using difference_type = internal_iterator_type::difference_type;
0109
0110 struct end_tag {};
0111
0112
0113
0114
0115 const_iterator(const IntermediateHitTriplets *hitSets, const RegionLayerSets *regionLayerSets)
0116 : hitSets_(hitSets), regionLayerSets_(regionLayerSets), iter_(regionLayerSets->layerSetsBegin()) {
0117 assert(regionLayerSets->layerSetsBegin() != regionLayerSets->layerSetsEnd());
0118 }
0119
0120
0121
0122
0123
0124
0125 const_iterator(const IntermediateHitTriplets *hitSets, const RegionLayerSets *regionLayerSets, end_tag)
0126 : iter_(regionLayerSets->layerSetsEnd()) {}
0127
0128 value_type operator*() const { return value_type(hitSets_, &(*iter_)); }
0129
0130 const_iterator &operator++() {
0131 ++iter_;
0132 return *this;
0133 }
0134
0135 const_iterator operator++(int) {
0136 const_iterator clone(*this);
0137 operator++();
0138 return clone;
0139 }
0140
0141 bool operator==(const const_iterator &other) const { return iter_ == other.iter_; }
0142 bool operator!=(const const_iterator &other) const { return !operator==(other); }
0143
0144 private:
0145 const IntermediateHitTriplets *hitSets_;
0146 const RegionLayerSets *regionLayerSets_;
0147 internal_iterator_type iter_;
0148 };
0149
0150 RegionLayerSets(const TrackingRegion *region,
0151 const LayerHitMapCache *cache,
0152 const IntermediateHitTriplets *hitSets,
0153 PLayerHitTripletsConstIterator tripletBegin,
0154 PLayerHitTripletsConstIterator tripletEnd)
0155 : region_(region), cache_(cache), hitSets_(hitSets), layerSetsBegin_(tripletBegin), layerSetsEnd_(tripletEnd) {}
0156
0157 const TrackingRegion ®ion() const { return *region_; }
0158 const LayerHitMapCache &layerHitMapCache() const { return *cache_; }
0159 size_t layerTripletsSize() const { return std::distance(layerSetsBegin_, layerSetsEnd_); }
0160
0161 const_iterator begin() const {
0162 if (layerSetsBegin_ != layerSetsEnd_)
0163 return const_iterator(hitSets_, this);
0164 else
0165 return end();
0166 }
0167 const_iterator cbegin() const { return begin(); }
0168 const_iterator end() const { return const_iterator(hitSets_, this, const_iterator::end_tag()); }
0169 const_iterator cend() const { return end(); }
0170
0171
0172 PLayerHitTripletsConstIterator layerSetsBegin() const { return layerSetsBegin_; }
0173 PLayerHitTripletsConstIterator layerSetsEnd() const { return layerSetsEnd_; }
0174
0175 private:
0176 const TrackingRegion *region_ = nullptr;
0177 const LayerHitMapCache *cache_ = nullptr;
0178 const IntermediateHitTriplets *hitSets_ = nullptr;
0179 const PLayerHitTripletsConstIterator layerSetsBegin_;
0180 const PLayerHitTripletsConstIterator layerSetsEnd_;
0181 };
0182
0183
0184
0185
0186 using const_iterator = ihd::const_iterator<RegionLayerSets, IntermediateHitTriplets>;
0187
0188
0189
0190
0191 class RegionFiller {
0192 public:
0193 RegionFiller() : obj_(nullptr) {}
0194 explicit RegionFiller(IntermediateHitTriplets *obj) : obj_(obj) {}
0195
0196 ~RegionFiller() = default;
0197
0198 bool valid() const { return obj_ != nullptr; }
0199
0200 LayerHitMapCache &layerHitMapCache() { return obj_->regions_.back().layerHitMapCache(); }
0201
0202 void addTriplets(const LayerPair &layerPair,
0203 const std::vector<SeedingLayerSetsHits::SeedingLayer> &thirdLayers,
0204 const OrderedHitTriplets &triplets,
0205 const std::vector<int> &thirdLayerIndex,
0206 const std::vector<size_t> &permutations) {
0207 assert(triplets.size() == thirdLayerIndex.size());
0208 assert(triplets.size() == permutations.size());
0209
0210 if (triplets.empty()) {
0211 return;
0212 }
0213
0214 int prevLayer = -1;
0215 for (size_t i = 0, size = permutations.size(); i < size; ++i) {
0216
0217
0218
0219 const size_t realIndex = permutations[i];
0220
0221 const int layer = thirdLayerIndex[realIndex];
0222 if (layer != prevLayer) {
0223 prevLayer = layer;
0224 obj_->layerTriplets_.emplace_back(
0225 LayerTriplet(std::get<0>(layerPair), std::get<1>(layerPair), thirdLayers[layer].index()),
0226 obj_->hitTriplets_.size());
0227 }
0228
0229 obj_->hitTriplets_.emplace_back(triplets[realIndex]);
0230 obj_->layerTriplets_.back().setTripletsEnd(obj_->hitTriplets_.size());
0231 }
0232
0233 obj_->regions_.back().setLayerSetsEnd(obj_->layerTriplets_.size());
0234 }
0235
0236 private:
0237 IntermediateHitTriplets *obj_;
0238 };
0239
0240
0241 static RegionFiller dummyFiller() { return RegionFiller(); }
0242
0243
0244
0245 IntermediateHitTriplets() : seedingLayers_(nullptr) {}
0246 explicit IntermediateHitTriplets(const SeedingLayerSetsHits *seedingLayers) : seedingLayers_(seedingLayers) {}
0247 IntermediateHitTriplets(const IntermediateHitTriplets &rh);
0248 IntermediateHitTriplets(IntermediateHitTriplets &&) = default;
0249 IntermediateHitTriplets &operator=(IntermediateHitTriplets &&) = default;
0250 ~IntermediateHitTriplets() = default;
0251
0252 void reserve(size_t nregions, size_t nlayersets, size_t ntriplets) {
0253 regions_.reserve(nregions);
0254 layerTriplets_.reserve(nregions * nlayersets);
0255 hitTriplets_.reserve(ntriplets);
0256 }
0257
0258 void shrink_to_fit() {
0259 regions_.shrink_to_fit();
0260 layerTriplets_.shrink_to_fit();
0261 hitTriplets_.shrink_to_fit();
0262 }
0263
0264 RegionFiller beginRegion(const TrackingRegion *region) {
0265 regions_.emplace_back(region, layerTriplets_.size());
0266 return RegionFiller(this);
0267 }
0268
0269 const SeedingLayerSetsHits &seedingLayerHits() const { return *seedingLayers_; }
0270 bool empty() const { return regions_.empty(); }
0271 size_t regionSize() const { return regions_.size(); }
0272 size_t tripletsSize() const { return hitTriplets_.size(); }
0273
0274 const_iterator begin() const { return const_iterator(this, regions_.begin()); }
0275 const_iterator cbegin() const { return begin(); }
0276 const_iterator end() const { return const_iterator(this, regions_.end()); }
0277 const_iterator cend() const { return end(); }
0278
0279
0280 std::vector<RegionIndex>::const_iterator regionsBegin() const { return regions_.begin(); }
0281 std::vector<RegionIndex>::const_iterator regionsEnd() const { return regions_.end(); }
0282 std::vector<PLayerHitTriplets>::const_iterator layerSetsBegin() const { return layerTriplets_.begin(); }
0283 std::vector<PLayerHitTriplets>::const_iterator layerSetsEnd() const { return layerTriplets_.end(); }
0284 std::vector<OrderedHitTriplet>::const_iterator tripletsBegin() const { return hitTriplets_.begin(); }
0285 std::vector<OrderedHitTriplet>::const_iterator tripletsEnd() const { return hitTriplets_.end(); }
0286
0287 private:
0288 const SeedingLayerSetsHits *seedingLayers_;
0289
0290 std::vector<RegionIndex> regions_;
0291 std::vector<PLayerHitTriplets>
0292 layerTriplets_;
0293 std::vector<OrderedHitTriplet> hitTriplets_;
0294 };
0295
0296 #endif