SeedingLayerSetsHits.h

Go to the documentation of this file.

#ifndef TrackingTools_TransientTrackingRecHit_SeedingLayerSetsHits
#define TrackingTools_TransientTrackingRecHit_SeedingLayerSetsHits

#include "DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h"
#include "DataFormats/TrackingRecHit/interface/mayown_ptr.h"

#include <vector>
#include <string>
#include <utility>

class DetLayer;

class SeedingLayerSetsHits {
public:
  using TkHit = BaseTrackerRecHit;
  using TkHitRef = BaseTrackerRecHit const &;
  using HitPointer = mayown_ptr<BaseTrackerRecHit>;
  using OwnedHits = std::vector<HitPointer>;

  using ConstRecHitPointer = BaseTrackerRecHit const *;
  using Hits = std::vector<ConstRecHitPointer>;

  typedef unsigned short LayerSetIndex;
  typedef unsigned short LayerIndex;
  typedef unsigned int HitIndex;

  class SeedingLayer {
  public:
    SeedingLayer() : seedingLayerSets_(nullptr), index_(0) {}
    SeedingLayer(const SeedingLayerSetsHits *sls, LayerIndex index) : seedingLayerSets_(sls), index_(index) {}

    LayerIndex index() const { return index_; }
    const std::string &name() const { return (*seedingLayerSets_->layerNames_)[index_]; }
    const DetLayer *detLayer() const { return (*seedingLayerSets_->layerDets_)[index_]; }
    Hits hits() const { return seedingLayerSets_->hits(index_); }

  private:
    const SeedingLayerSetsHits *seedingLayerSets_;
    LayerIndex index_;
  };

  class SeedingLayerSet {
  public:
    class const_iterator {
    public:
      typedef std::vector<LayerSetIndex>::const_iterator internal_iterator_type;
      typedef SeedingLayer value_type;
      typedef internal_iterator_type::difference_type difference_type;

      const_iterator() : seedingLayerSets_(nullptr) {}
      const_iterator(const SeedingLayerSetsHits *sls, internal_iterator_type iter)
          : seedingLayerSets_(sls), iter_(iter) {}

      value_type operator*() const { return SeedingLayer(seedingLayerSets_, *iter_); }

      const_iterator &operator++() {
        ++iter_;
        return *this;
      }
      const_iterator operator++(int) {
        const_iterator clone(*this);
        ++clone;
        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 SeedingLayerSetsHits *seedingLayerSets_;
      internal_iterator_type iter_;
    };

    SeedingLayerSet() : seedingLayerSets_(nullptr) {}
    SeedingLayerSet(const SeedingLayerSetsHits *sls,
                    std::vector<LayerSetIndex>::const_iterator begin,
                    std::vector<LayerSetIndex>::const_iterator end)
        : seedingLayerSets_(sls), begin_(begin), end_(end) {}

    LayerSetIndex size() const { return end_ - begin_; }

    SeedingLayerSet slice(size_t begin, size_t end) const {
      assert(begin < size());
      assert(0 < end && end <= size());
      assert(begin < end);
      return SeedingLayerSet(seedingLayerSets_, begin_ + begin, begin_ + end);
    }

    SeedingLayer operator[](LayerSetIndex index) const { return SeedingLayer(seedingLayerSets_, *(begin_ + index)); }

    // iterators for range-for
    const_iterator begin() const { return const_iterator(seedingLayerSets_, begin_); }
    const_iterator cbegin() const { return begin(); }
    const_iterator end() const { return const_iterator(seedingLayerSets_, end_); }
    const_iterator cend() const { return end(); }

  private:
    const SeedingLayerSetsHits *seedingLayerSets_;
    std::vector<LayerSetIndex>::const_iterator begin_;  // Iterator to SeedingLayerSetsHits::layerSetIndices_, first layer
    std::vector<LayerSetIndex>::const_iterator end_;  // Iterator to SeedingLayerSetsHits::layerSetIndices_, last+1 layer
  };

  class const_iterator {
  public:
    typedef std::vector<LayerSetIndex>::const_iterator internal_iterator_type;
    typedef SeedingLayerSet value_type;
    typedef internal_iterator_type::difference_type difference_type;

    const_iterator() : seedingLayerSets_(nullptr) {}
    const_iterator(const SeedingLayerSetsHits *sls, internal_iterator_type iter)
        : seedingLayerSets_(sls), iter_(iter) {}

    value_type operator*() const {
      return SeedingLayerSet(seedingLayerSets_, iter_, iter_ + seedingLayerSets_->nlayers_);
    }

    const_iterator &operator++() {
      std::advance(iter_, seedingLayerSets_->nlayers_);
      return *this;
    }
    const_iterator operator++(int) {
      const_iterator clone(*this);
      ++(*this);
      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 SeedingLayerSetsHits *seedingLayerSets_;
    internal_iterator_type iter_;
  };

  SeedingLayerSetsHits() = default;

  SeedingLayerSetsHits(unsigned short nlayers,
                       const std::vector<LayerSetIndex> *layerSetIndices,
                       const std::vector<std::string> *layerNames,
                       const std::vector<const DetLayer *> *layerDets);

  ~SeedingLayerSetsHits() = default;
  SeedingLayerSetsHits(SeedingLayerSetsHits const &) = delete;
  SeedingLayerSetsHits &operator=(SeedingLayerSetsHits const &) = delete;
  SeedingLayerSetsHits(SeedingLayerSetsHits &&) = default;
  SeedingLayerSetsHits &operator=(SeedingLayerSetsHits &&) = default;

  void shrink_to_fit();
  void addHits(LayerIndex layerIndex, OwnedHits &&hits);

  unsigned short numberOfLayersInSet() const { return nlayers_; }
  unsigned short size() const { return nlayers_ > 0 ? layerSetIndices_->size() / nlayers_ : 0; }

  SeedingLayerSet operator[](LayerSetIndex index) const {
    std::vector<LayerSetIndex>::const_iterator begin = layerSetIndices_->begin() + nlayers_ * index;
    std::vector<LayerSetIndex>::const_iterator end = begin + nlayers_;
    return SeedingLayerSet(this, begin, end);
  }

  // iterators for range-for
  const_iterator begin() const { return const_iterator(this, layerSetIndices_->begin()); }
  const_iterator cbegin() const { return begin(); }
  const_iterator end() const { return const_iterator(this, layerSetIndices_->end()); }
  const_iterator cend() const { return end(); }

  // for more efficient edm::Event::put()
  void swap(SeedingLayerSetsHits &other) {
    std::swap(nlayers_, other.nlayers_);
    std::swap(layerSetIndices_, other.layerSetIndices_);
    layerHitIndices_.swap(other.layerHitIndices_);
    std::swap(layerNames_, other.layerNames_);
    std::swap(layerDets_, other.layerDets_);
    rechits_.swap(other.rechits_);
  }

  void print() const;

private:
  Hits hits(LayerIndex layerIndex) const;

  unsigned short nlayers_ = 0;

  const std::vector<LayerSetIndex> *layerSetIndices_ = nullptr;

  // following are indexed by LayerIndex
  std::vector<HitIndex> layerHitIndices_;                     // Indices to first hits in rechits_
  const std::vector<std::string> *layerNames_ = nullptr;      // Names of the layers
  const std::vector<const DetLayer *> *layerDets_ = nullptr;  // Pointers to corresponding DetLayer objects

  OwnedHits rechits_;
};

#endif