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_(0), 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_(0) {}
      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_(0) {}
    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_(0) {}
    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();

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

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


  void swapHits(std::vector<HitIndex>& layerHitIndices,  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_);
    layerDets_.swap(other.layerDets_);
    rechits_.swap(other.rechits_);
  }

  void print() const;

private:
  Hits hits(LayerIndex layerIndex) const;

  unsigned short nlayers_;

  const std::vector<LayerSetIndex> *layerSetIndices_;

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

  OwnedHits rechits_;
};

#endif