IntermediateHitDoublets.h

Go to the documentation of this file.

#ifndef RecoTracker_TkHitPairs_IntermediateHitDoublets_h
#define RecoTracker_TkHitPairs_IntermediateHitDoublets_h

#include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h"
#include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h"

namespace ihd {
  class RegionIndex {
  public:
    RegionIndex(const TrackingRegion *reg, unsigned int ind):
      region_(reg),
      layerSetBeginIndex_(ind),
      layerSetEndIndex_(ind)
    {}

    void setLayerSetsEnd(unsigned int end) { layerSetEndIndex_ = end; }

    const TrackingRegion& region() const { return *region_; }

    LayerHitMapCache& layerHitMapCache() { return cache_; }
    const LayerHitMapCache& layerHitMapCache() const { return cache_; }

    unsigned int layerSetBeginIndex() const { return layerSetBeginIndex_; }
    unsigned int layerSetEndIndex() const { return layerSetEndIndex_; }

  private:
    const TrackingRegion *region_;    
    LayerHitMapCache cache_;
    unsigned int layerSetBeginIndex_; 
    unsigned int layerSetEndIndex_;   
  };

  template <typename T>
  class RegionLayerSets {
  public:
    using const_iterator = typename std::vector<T>::const_iterator;

    // Taking T* to have compatible interface with IntermediateHitTriplets::RegionLayerSets
    template <typename TMP>
    RegionLayerSets(const TrackingRegion* region, const LayerHitMapCache *cache, const TMP*, const_iterator begin, const_iterator end):
      region_(region), cache_(cache), layerSetsBegin_(begin), layerSetsEnd_(end) {}

    const TrackingRegion& region() const { return *region_; }
    const LayerHitMapCache& layerHitMapCache() const { return *cache_; }

    const_iterator begin() const { return layerSetsBegin_; }
    const_iterator cbegin() const { return begin(); }
    const_iterator end() const { return layerSetsEnd_; }
    const_iterator cend() const { return end(); }

  private:
    const TrackingRegion *region_;
    const LayerHitMapCache *cache_;
    const const_iterator layerSetsBegin_;
    const const_iterator layerSetsEnd_;
  };

  template<typename ValueType, typename HitSetType>
  class const_iterator {
  public:
    using internal_iterator_type = typename std::vector<RegionIndex>::const_iterator;
    using value_type = ValueType;
    using difference_type = internal_iterator_type::difference_type;

    const_iterator(const HitSetType *hst, internal_iterator_type iter): hitSets_(hst), iter_(iter) {}

    value_type operator*() const {
      return value_type(&(iter_->region()),
                        &(iter_->layerHitMapCache()),
                        hitSets_,
                        hitSets_->layerSetsBegin() + iter_->layerSetBeginIndex(),
                        hitSets_->layerSetsBegin() + iter_->layerSetEndIndex());
    }

    const_iterator& operator++() { ++iter_; return *this; }
    const_iterator operator++(int) {
      const_iterator clone(*this);
      ++iter_;
      return clone;
    }

    bool operator==(const const_iterator& other) const { return iter_ == other.iter_; }
    bool operator!=(const const_iterator& other) const { return !operator==(other); }

  private:
    const HitSetType *hitSets_;
    internal_iterator_type iter_;
  };
}

class IntermediateHitDoublets {
public:
  using LayerPair = std::tuple<SeedingLayerSetsHits::LayerIndex, SeedingLayerSetsHits::LayerIndex>;
  using RegionIndex = ihd::RegionIndex;

  class LayerPairHitDoublets {
  public:
    LayerPairHitDoublets(const SeedingLayerSetsHits::SeedingLayerSet& layerSet, HitDoublets&& doublets):
      layerPair_(layerSet[0].index(), layerSet[1].index()),
      doublets_(std::move(doublets))
    {}

    const LayerPair& layerPair() const { return layerPair_; }
    SeedingLayerSetsHits::LayerIndex innerLayerIndex() const { return std::get<0>(layerPair_); }
    SeedingLayerSetsHits::LayerIndex outerLayerIndex() const { return std::get<1>(layerPair_); }

    const HitDoublets& doublets() const { return doublets_; }

  private:
    LayerPair layerPair_;  
    HitDoublets doublets_; 
  };


  using RegionLayerSets = ihd::RegionLayerSets<LayerPairHitDoublets>;


  using const_iterator = ihd::const_iterator<RegionLayerSets, IntermediateHitDoublets>;


  class RegionFiller {
  public:
    RegionFiller(): obj_(nullptr) {}
    explicit RegionFiller(IntermediateHitDoublets *obj): obj_(obj) {}

    ~RegionFiller() = default;

    bool valid() const { return obj_ != nullptr; }

    LayerHitMapCache& layerHitMapCache() { return obj_->regions_.back().layerHitMapCache(); }

    void addDoublets(const SeedingLayerSetsHits::SeedingLayerSet& layerSet, HitDoublets&& doublets) {
      obj_->layerPairs_.emplace_back(layerSet, std::move(doublets));
      obj_->regions_.back().setLayerSetsEnd(obj_->layerPairs_.size());
    }
  private:
    IntermediateHitDoublets *obj_;
  };

  // allows declaring local variables with auto
  static RegionFiller dummyFiller() { return RegionFiller(); }


  IntermediateHitDoublets(): seedingLayers_(nullptr) {}
  explicit IntermediateHitDoublets(const SeedingLayerSetsHits *seedingLayers): seedingLayers_(seedingLayers) {}
  IntermediateHitDoublets(const IntermediateHitDoublets& rh); // only to make ROOT dictionary generation happy
  ~IntermediateHitDoublets() = default;

  void swap(IntermediateHitDoublets& rh) {
    std::swap(seedingLayers_, rh.seedingLayers_);
    std::swap(regions_, rh.regions_);
    std::swap(layerPairs_, rh.layerPairs_);
  }

  void reserve(size_t nregions, size_t nlayersets) {
    regions_.reserve(nregions);
    layerPairs_.reserve(nregions*nlayersets);
  }

  void shrink_to_fit() {
    regions_.shrink_to_fit();
    layerPairs_.shrink_to_fit();
  }

  RegionFiller beginRegion(const TrackingRegion *region) {
    regions_.emplace_back(region, layerPairs_.size());
    return RegionFiller(this);
  }

  const SeedingLayerSetsHits& seedingLayerHits() const { return *seedingLayers_; }
  bool empty() const { return regions_.empty(); }
  size_t regionSize() const { return regions_.size(); }
  size_t layerPairsSize() const { return layerPairs_.size(); }

  const_iterator begin() const { return const_iterator(this, regions_.begin()); }
  const_iterator cbegin() const { return begin(); }
  const_iterator end() const { return const_iterator(this, regions_.end()); }
  const_iterator cend() const { return end(); }

  // used internally by all the helper classes
  std::vector<RegionIndex>::const_iterator regionsBegin() const { return regions_.begin(); }
  std::vector<RegionIndex>::const_iterator regionsEnd() const { return regions_.end(); }
  std::vector<LayerPairHitDoublets>::const_iterator layerSetsBegin() const { return layerPairs_.begin(); }
  std::vector<LayerPairHitDoublets>::const_iterator layerSetsEnd() const { return layerPairs_.end(); }

private:
  const SeedingLayerSetsHits *seedingLayers_;    

  std::vector<RegionIndex> regions_;             
  std::vector<LayerPairHitDoublets> layerPairs_; 
};

#endif