GeometryDataContainers.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_GEOMETRYDATACONTAINERS_H
#define LARCOREALG_GEOMETRY_GEOMETRYDATACONTAINERS_H

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"

// C/C++ standard libraries
#include <vector>
#include <stdexcept> // std::out_of_range
#include <cassert>


namespace geo {
  
  // --- BEGIN Geometry data containers ----------------------------------------
  
  template <typename T>
  class TPCDataContainer {
    
    using Container_t = std::vector<T>;
    
      public:
    
    
    // TODO the iterator is not really a random access one
    
    using reference              = typename Container_t::reference             ;
    using const_reference        = typename Container_t::const_reference       ;
    using pointer                = typename Container_t::pointer               ;
    using const_pointer          = typename Container_t::const_pointer         ;
    using iterator               = typename Container_t::iterator              ;
    using const_iterator         = typename Container_t::const_iterator        ;
    using reverse_iterator       = typename Container_t::reverse_iterator      ;
    using const_reverse_iterator = typename Container_t::const_reverse_iterator;
    using difference_type        = typename Container_t::difference_type       ;
    using size_type              = typename Container_t::size_type             ;
    
    
    TPCDataContainer(unsigned int nCryo, unsigned int nTPCs)
      : fNCryo(nCryo)
      , fNTPCs(nTPCs)
      , fData(computeSize())
      { assert(!empty()); }
    
    TPCDataContainer(unsigned int nCryo, unsigned int nTPCs, T const& defValue)
      : fNCryo(nCryo)
      , fNTPCs(nTPCs)
      , fData(computeSize(), defValue)
      { assert(!empty()); }
    
    
    // --- BEGIN Container status query ----------------------------------------
    
    size_type size() const { return fData.size(); }
    
    size_type capacity() const { return fData.capacity(); }
    
    bool empty() const { return fData.empty(); }
    
    bool hasCryostat(geo::CryostatID const& cryoid) const
      { return bounded(cryoid.Cryostat, fNCryo); }
    
    bool hasTPC(geo::TPCID const& id) const
      { return hasCryostat(id) && bounded(id.TPC, fNTPCs); }
    
    geo::TPCID firstID() const { return { 0U, 0U }; }
    
    geo::TPCID lastID() const { return { fNCryo - 1U, fNTPCs - 1U }; }
    
    // --- END Container status query ------------------------------------------
    
    
    // --- BEGIN Element access ------------------------------------------------
    
    reference operator[](geo::TPCID const& id)
      { return fData[index(id)]; }
    
    const_reference operator[](geo::TPCID const& id) const
      { return fData[index(id)]; }
    
    reference at(geo::TPCID const& id)
      {
        if (hasTPC(id)) return operator[](id);
        throw std::out_of_range("No data for " + std::string(id));
      }
    
    const_reference at (geo::TPCID const& id) const
      {
        if (hasTPC(id)) return operator[](id);
        throw std::out_of_range("No data for " + std::string(id));
      }
    
    
    reference first() { return operator[](firstID()); }
    
    const_reference first() const { return operator[](firstID()); }
    
    
    reference last() { return operator[](lastID()); }
    
    const_reference last() const { return operator[](lastID()); }
    
    
    
      private:
    using CryostatNo_t = geo::CryostatID::CryostatID_t;
    using TPCNo_t = geo::TPCID::TPCID_t;
    
    CryostatNo_t fNCryo; 
    TPCNo_t fNTPCs; 
    
    Container_t fData; 
    
    size_type index(CryostatNo_t cryo, TPCNo_t tpc) const
      { return (fNTPCs * cryo) + tpc; }
    
    size_type index(geo::TPCID const& id) const
      { return index(id.Cryostat, id.TPC); }
    
    geo::TPCID ID(size_type index) const
      { return { index / fNCryo, index % fNCryo }; }
    
    size_type computeSize() const { return computeSize(fNCryo, fNTPCs); }
    
    static size_type computeSize(CryostatNo_t nCryo, TPCNo_t nTPCs)
      { return nCryo * nTPCs; }
    
    template <typename Value, typename Upper>
    static bool bounded(Value v, Upper upper)
      { return (v >= 0) && (static_cast<size_type>(v) < upper); }
    
  }; // class TPCDataContainer
  
  
  
  template <typename T>
  class PlaneDataContainer {
    
    using Container_t = std::vector<T>;
    
      public:
    
    
    // TODO the iterator is not really a random access one
    
    using reference              = typename Container_t::reference             ;
    using const_reference        = typename Container_t::const_reference       ;
    using pointer                = typename Container_t::pointer               ;
    using const_pointer          = typename Container_t::const_pointer         ;
    using iterator               = typename Container_t::iterator              ;
    using const_iterator         = typename Container_t::const_iterator        ;
    using reverse_iterator       = typename Container_t::reverse_iterator      ;
    using const_reverse_iterator = typename Container_t::const_reverse_iterator;
    using difference_type        = typename Container_t::difference_type       ;
    using size_type              = typename Container_t::size_type             ;
    
    
    PlaneDataContainer
      (unsigned int nCryo, unsigned int nTPCs, unsigned int nPlanes)
      : fNCryo(nCryo)
      , fNTPCs(nTPCs)
      , fNPlanes(nPlanes)
      , fData(computeSize())
      { assert(!empty()); }
    
    PlaneDataContainer(
      unsigned int nCryo, unsigned int nTPCs, unsigned int nPlanes,
      T const& defValue
      )
      : fNCryo(nCryo)
      , fNTPCs(nTPCs)
      , fNPlanes(nPlanes)
      , fData(computeSize(), defValue)
      { assert(!empty()); }
    
    
    // --- BEGIN Container status query ----------------------------------------
    
    size_type size() const { return fData.size(); }
    
    size_type capacity() const { return fData.capacity(); }
    
    bool empty() const { return fData.empty(); }
    
    bool hasCryostat(geo::CryostatID const& cryoid) const
      { return bounded(cryoid.Cryostat, fNCryo); }
    
    bool hasTPC(geo::TPCID const& id) const
      { return hasCryostat(id) && bounded(id.TPC, fNTPCs); }
    
    bool hasPlane(geo::PlaneID const& id) const
      { return hasTPC(id) && bounded(id.Plane, fNPlanes); }
    
    geo::PlaneID firstID() const { return { 0U, 0U, 0U }; }
    
    geo::PlaneID lastID() const
      { return { fNCryo - 1U, fNTPCs - 1U, fNPlanes - 1U }; }
    
    // --- END Container status query ------------------------------------------
    
    
    // --- BEGIN Element access ------------------------------------------------
    
    reference operator[](geo::PlaneID const& id)
      { return fData[index(id)]; }
    
    const_reference operator[](geo::PlaneID const& id) const
      { return fData[index(id)]; }
    
    reference at(geo::PlaneID const& id)
      {
        if (hasPlane(id)) return operator[](id);
        throw std::out_of_range("No data for " + std::string(id));
      }
    
    const_reference at(geo::PlaneID const& id) const
      {
        if (hasPlane(id)) return operator[](id);
        throw std::out_of_range("No data for " + std::string(id));
      }
    
    
    reference first() { return operator[](firstID()); }
    
    const_reference first() const { return operator[](firstID()); }
    
    
    reference last() { return operator[](lastID()); }
    
    const_reference last() const { return operator[](lastID()); }
    
    
    
      private:
    using CryostatNo_t = geo::CryostatID::CryostatID_t;
    using TPCNo_t = geo::TPCID::TPCID_t;
    using PlaneNo_t = geo::PlaneID::PlaneID_t;
    
    CryostatNo_t fNCryo; 
    TPCNo_t fNTPCs; 
    PlaneNo_t fNPlanes; 
    
    Container_t fData; 
    
    size_type index(CryostatNo_t cryo, TPCNo_t tpc, PlaneNo_t plane) const
      { return ((cryo) * fNTPCs + tpc) * fNPlanes + plane; }
    
    size_type index(geo::PlaneID const& id) const
      { return index(id.Cryostat, id.TPC, id.Plane); }
    
    geo::PlaneID ID(size_type index) const
      {
        return
          { index / fNCryo, index % fNCryo / fNPlanes, index % fNPlanes };
      }
    
    size_type computeSize() const
      { return computeSize(fNCryo, fNTPCs, fNPlanes); }
    
    static size_type computeSize
      (CryostatNo_t nCryo, TPCNo_t nTPCs, PlaneNo_t nPlanes)
      { return nCryo * nTPCs * nPlanes; }
    
    template <typename Value, typename Upper>
    static bool bounded(Value v, Upper upper)
      { return (v >= 0) && (static_cast<size_type>(v) < upper); }
    
  }; // class PlaneDataContainer
  
  
  // --- END Geometry data containers ------------------------------------------
  
} // namespace geo



#endif // LARCOREALG_GEOMETRY_GEOMETRYDATACONTAINERS_H