geo_types.h

Go to the documentation of this file.

#ifndef LARCOREOBJ_SIMPLETYPESANDCONSTANTS_GEO_TYPES_H
#define LARCOREOBJ_SIMPLETYPESANDCONSTANTS_GEO_TYPES_H

// C++ standard libraries
#include <climits>
#include <cmath>
#include <iosfwd> // std::ostream
#include <limits> // std::numeric_limits<>
#include <sstream>
#include <string>

namespace geo {
  namespace details {
    template <typename T>
    std::string writeToString(T const& value);

    template <typename ID>
    constexpr bool isTopGeoElementID = std::is_void_v<typename ID::ParentID_t>;

    template <typename ID>
    constexpr std::size_t geoElementLevel()
    {
      if constexpr (isTopGeoElementID<ID>)
        return 0U;
      else
        return geoElementLevel<typename ID::ParentID_t>() + 1U;
    } // geoElementLevel()

    template <typename ID, std::size_t Index, typename = void>
    struct AbsIDtypeStruct;

    template <std::size_t Index, typename ID>
    using AbsIDtype = typename AbsIDtypeStruct<ID, Index>::type;

    template <typename ID, std::size_t UpIndex>
    struct RelIDtypeStruct;

    template <std::size_t UpIndex, typename ID>
    using RelIDtype = typename RelIDtypeStruct<ID, UpIndex>::type;

    template <std::size_t Index, typename ID>
    constexpr auto getAbsIDindex(ID const& id)
    {
      static_assert(Index <= ID::Level, "Index not available for this type.");
      if constexpr (Index == ID::Level)
        return id.deepestIndex();
      else
        return getAbsIDindex<Index>(id.parentID());
    }

    template <std::size_t Index, typename ID>
    auto& getAbsIDindex(ID& id)
    {
      static_assert(Index <= ID::Level, "Index not available for this type.");
      if constexpr (Index == ID::Level)
        return id.deepestIndex();
      else
        return getAbsIDindex<Index>(id.parentID());
    }

    template <std::size_t UpIndex, typename ID>
    auto getRelIDindex(ID const& id)
    {
      static_assert(UpIndex <= ID::Level, "Index not available for this type.");
      if constexpr (UpIndex == 0)
        return id.deepestIndex();
      else
        return getRelIDindex<UpIndex - 1U>(id.parentID());
    }

  } // namespace details
} // namespace geo

// BEGIN Geometry --------------------------------------------------------------
namespace geo {

  // --- BEGIN -- Geometry enumerators -----------------------------------------

  typedef enum coordinates {
    kXCoord, 
    kYCoord, 
    kZCoord  
  } Coord_t;

  typedef enum _plane_proj {
    kU,      
    kV,      
    kW,      
    kZ = kW, 
    kY,      
    kX,      
    k3D,     
    kUnknown 
  } View_t;

  typedef enum _plane_orient {
    kHorizontal, 
    kVertical    
  } Orient_t;

  typedef enum _plane_sigtype {
    kInduction,  
    kCollection, 
    kMysteryType 
  } SigType_t;

  typedef enum driftdir {
    kUnknownDrift, 
    kPos,          
    kNeg,          
    kPosX = kPos,  
    kNegX = kNeg   
  } DriftDirection_t;

  struct ElementLevel {

    using Level_t = std::size_t;

    static constexpr Level_t Cryostat = 0U;
    static constexpr Level_t OpDet = 1U;
    static constexpr Level_t TPC = 1U;
    static constexpr Level_t Plane = 2U;
    static constexpr Level_t Wire = 3U;
    static constexpr Level_t NLevels = 4U;

  }; // struct ElementLevel

  // --- END -- Geometry enumerators -------------------------------------------


  struct CryostatID {
    using CryostatID_t = unsigned int; 

    using ThisID_t = CryostatID; 
    using ParentID_t = void;     

    template <std::size_t L>
    using ID_t = details::AbsIDtype<L, ThisID_t>;

    template <std::size_t A>
    using UpperID_t = details::RelIDtype<A, ThisID_t>;

    // not constexpr because we would need an implementation file to define it
    static constexpr CryostatID_t InvalidID = std::numeric_limits<CryostatID_t>::max();

    bool isValid = false;              
    CryostatID_t Cryostat = InvalidID; 

    constexpr CryostatID() = default;

    explicit constexpr CryostatID(CryostatID_t c) : isValid(true), Cryostat(c) {}

    constexpr CryostatID(CryostatID_t c, bool valid) : isValid(valid), Cryostat(c) {}


    explicit constexpr operator bool() const { return isValid; }

    constexpr bool operator!() const { return !isValid; }

    void setValidity(bool valid) { isValid = valid; }

    void markValid() { setValidity(true); }

    void markInvalid() { setValidity(false); }

    // comparison operators are out of class

    std::string toString() const { return details::writeToString(*this); }
    explicit operator std::string() const { return toString(); }

    // the following four methods are useful for (templated) abstraction
    constexpr auto const& deepestIndex() const { return Cryostat; }
    auto& deepestIndex() { return Cryostat; }
    constexpr ParentID_t parentID() const {}
    ParentID_t parentID() {}
    template <std::size_t Index = 0U>
    constexpr auto getIndex() const;
    template <std::size_t Index = 0U>
    auto& writeIndex();
    template <std::size_t Above>
    constexpr auto getRelIndex() const;

    constexpr int cmp(CryostatID const& other) const
    {
      return ThreeWayComparison(deepestIndex(), other.deepestIndex());
    }

    constexpr CryostatID const& asCryostatID() const { return *this; }
    CryostatID& asCryostatID() { return *this; }
    constexpr CryostatID const& asConstCryostatID() { return *this; }

    static constexpr auto Level = geo::ElementLevel::Cryostat;

    static constexpr CryostatID_t getInvalidID() { return CryostatID::InvalidID; }

    template <typename T>
    static constexpr int ThreeWayComparison(T a, T b)
    {
      return (a == b) ? 0 : ((a < b) ? -1 : +1);
    }

  }; // struct CryostatID

  struct OpDetID : public CryostatID {
    using OpDetID_t = unsigned int; 

    using ThisID_t = OpDetID;      
    using ParentID_t = CryostatID; 

    template <std::size_t L>
    using ID_t = details::AbsIDtype<L, ThisID_t>;

    template <std::size_t A>
    using UpperID_t = details::RelIDtype<A, ThisID_t>;

    // not constexpr because we would need an implementation file to define it
    static constexpr OpDetID_t InvalidID = std::numeric_limits<OpDetID_t>::max();

    OpDetID_t OpDet = InvalidID;

    constexpr OpDetID() = default;

    constexpr OpDetID(CryostatID const& cryoid, OpDetID_t o) : CryostatID(cryoid), OpDet(o) {}

    constexpr OpDetID(CryostatID_t c, OpDetID_t o) : CryostatID(c), OpDet(o) {}

    // comparison operators are out of class

    std::string toString() const { return details::writeToString(*this); }
    explicit operator std::string() const { return toString(); }

    // the following two methods are useful for (templated) abstraction
    constexpr auto const& deepestIndex() const { return OpDet; }
    auto& deepestIndex() { return OpDet; }
    constexpr ParentID_t const& parentID() const { return *this; }
    ParentID_t& parentID() { return *this; }
    template <std::size_t Index = 0U>
    constexpr auto getIndex() const;
    template <std::size_t Index = 0U>
    auto& writeIndex();
    template <std::size_t Above>
    constexpr auto getRelIndex() const;

    constexpr OpDetID const& asOpDetID() const { return *this; }
    OpDetID& asOpDetID() { return *this; }
    constexpr OpDetID const& asConstOpDetID() { return *this; }

    constexpr int cmp(OpDetID const& other) const
    {
      int cmp_res = CryostatID::cmp(other);
      if (cmp_res == 0) // same cryostat: compare optical detectors
        return ThreeWayComparison(deepestIndex(), other.deepestIndex());
      else // return the order of cryostats
        return cmp_res;
    } // cmp()

    static constexpr auto Level = geo::ElementLevel::OpDet;

    static constexpr OpDetID_t getInvalidID() { return OpDetID::InvalidID; }

  }; // struct OpDetID

  struct TPCID : public CryostatID {
    using TPCID_t = unsigned int; 

    using ThisID_t = TPCID;        
    using ParentID_t = CryostatID; 

    template <std::size_t L>
    using ID_t = details::AbsIDtype<L, ThisID_t>;

    template <std::size_t A>
    using UpperID_t = details::RelIDtype<A, ThisID_t>;

    // not constexpr because we would need an implementation file to define it
    static constexpr TPCID_t InvalidID = std::numeric_limits<TPCID_t>::max();

    TPCID_t TPC = InvalidID; 

    constexpr TPCID() = default;

    constexpr TPCID(CryostatID const& cryoid, TPCID_t t) : CryostatID(cryoid), TPC(t) {}

    constexpr TPCID(CryostatID_t c, TPCID_t t) : CryostatID(c), TPC(t) {}

    // comparison operators are out of class

    std::string toString() const { return details::writeToString(*this); }
    explicit operator std::string() const { return toString(); }

    // the following two methods are useful for (templated) abstraction
    constexpr auto const& deepestIndex() const { return TPC; }
    auto& deepestIndex() { return TPC; }
    constexpr ParentID_t const& parentID() const { return *this; }
    ParentID_t& parentID() { return *this; }
    template <std::size_t Index = 0U>
    constexpr auto getIndex() const;
    template <std::size_t Index = 0U>
    auto& writeIndex();
    template <std::size_t Above>
    constexpr auto getRelIndex() const;

    constexpr TPCID const& asTPCID() const { return *this; }
    TPCID& asTPCID() { return *this; }
    constexpr TPCID const& asConstTPCID() { return *this; }

    constexpr int cmp(TPCID const& other) const
    {
      int cmp_res = CryostatID::cmp(other);
      if (cmp_res == 0) // same cryostat: compare TPC
        return ThreeWayComparison(deepestIndex(), other.deepestIndex());
      else // return the order of cryostats
        return cmp_res;
    } // cmp()

    static constexpr auto Level = geo::ElementLevel::TPC;

    static constexpr TPCID_t getInvalidID() { return TPCID::InvalidID; }

  }; // struct TPCID

  struct PlaneID : public TPCID {
    using PlaneID_t = unsigned int; 

    using ThisID_t = PlaneID; 
    using ParentID_t = TPCID; 

    template <std::size_t L>
    using ID_t = details::AbsIDtype<L, ThisID_t>;

    template <std::size_t A>
    using UpperID_t = details::RelIDtype<A, ThisID_t>;

    // not constexpr because we would need an implementation file to define it
    static constexpr PlaneID_t InvalidID = std::numeric_limits<PlaneID_t>::max();

    PlaneID_t Plane = InvalidID; 

    constexpr PlaneID() = default;

    constexpr PlaneID(TPCID const& tpcid, PlaneID_t p) : TPCID(tpcid), Plane(p) {}

    constexpr PlaneID(CryostatID_t c, TPCID_t t, PlaneID_t p) : TPCID(c, t), Plane(p) {}

    // comparison operators are out of class

    std::string toString() const { return details::writeToString(*this); }
    explicit operator std::string() const { return toString(); }

    // the following two methods are useful for (templated) abstraction
    constexpr auto const& deepestIndex() const { return Plane; }
    auto& deepestIndex() { return Plane; }
    constexpr ParentID_t const& parentID() const { return *this; }
    ParentID_t& parentID() { return *this; }
    template <std::size_t Index = 0U>
    constexpr auto getIndex() const;
    template <std::size_t Index = 0U>
    auto& writeIndex();
    template <std::size_t Above>
    constexpr auto getRelIndex() const;

    constexpr PlaneID const& asPlaneID() const { return *this; }
    PlaneID& asPlaneID() { return *this; }
    constexpr PlaneID const& asConstPlaneID() { return *this; }

    constexpr int cmp(PlaneID const& other) const
    {
      int cmp_res = TPCID::cmp(other);
      if (cmp_res == 0) // same TPC: compare plane
        return ThreeWayComparison(deepestIndex(), other.deepestIndex());
      else // return the order of planes
        return cmp_res;
    } // cmp()

    static constexpr auto Level = geo::ElementLevel::Plane;

    static constexpr PlaneID_t getInvalidID() { return PlaneID::InvalidID; }

  }; // struct PlaneID

  // The data type to uniquely identify a code wire segment.
  struct WireID : public PlaneID {
    using WireID_t = unsigned int; 

    using ThisID_t = WireID;    
    using ParentID_t = PlaneID; 

    template <std::size_t L>
    using ID_t = details::AbsIDtype<L, ThisID_t>;

    template <std::size_t A>
    using UpperID_t = details::RelIDtype<A, ThisID_t>;

    // not constexpr because we would need an implementation file to define it
    static constexpr WireID_t InvalidID = std::numeric_limits<WireID_t>::max();

    WireID_t Wire = InvalidID; 

    constexpr WireID() = default;

    constexpr WireID(PlaneID const& planeid, WireID_t w) : PlaneID(planeid), Wire(w) {}

    constexpr WireID(CryostatID_t c, TPCID_t t, PlaneID_t p, WireID_t w) : PlaneID(c, t, p), Wire(w)
    {}

    std::string toString() const { return details::writeToString(*this); }
    explicit operator std::string() const { return toString(); }

    // the following two methods are useful for (templated) abstraction
    constexpr auto const& deepestIndex() const { return Wire; }
    auto& deepestIndex() { return Wire; }
    constexpr ParentID_t const& parentID() const { return *this; }
    ParentID_t& parentID() { return *this; }
    template <std::size_t Index = 0U>
    constexpr auto getIndex() const;
    template <std::size_t Index = 0U>
    auto& writeIndex();
    template <std::size_t Above>
    constexpr auto getRelIndex() const;

    constexpr WireID const& asWireID() const { return *this; }
    WireID& asWireID() { return *this; }
    constexpr WireID const& asConstWireID() { return *this; }

    constexpr int cmp(WireID const& other) const
    {
      int cmp_res = PlaneID::cmp(other);
      if (cmp_res == 0) // same plane: compare wires
        return ThreeWayComparison(deepestIndex(), other.deepestIndex());
      else // return the order of wire
        return cmp_res;
    } // cmp()

    constexpr PlaneID const& planeID() const { return *this; }

    static constexpr auto Level = geo::ElementLevel::Wire;

    static constexpr WireID_t getInvalidID() { return WireID::InvalidID; }

  }; // struct WireID

  //----------------------------------------------------------------------------
  //--- ID output operators
  //---
  inline std::ostream& operator<<(std::ostream& out, CryostatID const& cid)
  {
    out << "C:" << cid.Cryostat;
    return out;
  } // operator<< (CryostatID)

  inline std::ostream& operator<<(std::ostream& out, OpDetID const& oid)
  {
    out << oid.asCryostatID() << " O:" << oid.OpDet;
    return out;
  } // operator<< (OpDetID)

  inline std::ostream& operator<<(std::ostream& out, TPCID const& tid)
  {
    out << ((CryostatID const&)tid) << " T:" << tid.TPC;
    return out;
  } // operator<< (TPCID)

  inline std::ostream& operator<<(std::ostream& out, PlaneID const& pid)
  {
    out << ((TPCID const&)pid) << " P:" << pid.Plane;
    return out;
  } // operator<< (PlaneID)

  inline std::ostream& operator<<(std::ostream& out, WireID const& wid)
  {
    out << ((PlaneID const&)wid) << " W:" << wid.Wire;
    return out;
  } // operator<< (WireID)

  // Geometry element IDs

  //----------------------------------------------------------------------------
  //--- ID comparison operators
  //---


  inline constexpr bool operator==(CryostatID const& a, CryostatID const& b)
  {
    return a.Cryostat == b.Cryostat;
  }

  inline constexpr bool operator!=(CryostatID const& a, CryostatID const& b)
  {
    return a.Cryostat != b.Cryostat;
  }

  inline constexpr bool operator<(CryostatID const& a, CryostatID const& b)
  {
    return a.Cryostat < b.Cryostat;
  }

  inline constexpr bool operator==(OpDetID const& a, OpDetID const& b)
  {
    return (a.asCryostatID() == b.asCryostatID()) && (a.OpDet == b.OpDet);
  }

  inline constexpr bool operator!=(OpDetID const& a, OpDetID const& b)
  {
    return (a.asCryostatID() != b.asCryostatID()) || (a.OpDet != b.OpDet);
  }

  inline constexpr bool operator<(OpDetID const& a, OpDetID const& b)
  {
    int cmp_res = a.asCryostatID().cmp(b);
    if (cmp_res == 0) // same cryostat: compare optical detectors
      return a.OpDet < b.OpDet;
    else // return the order of cryostats
      return cmp_res < 0;
  } // operator< (OpDetID, OpDetID)

  inline constexpr bool operator==(TPCID const& a, TPCID const& b)
  {
    return (static_cast<CryostatID const&>(a) == static_cast<CryostatID const&>(b)) &&
           (a.TPC == b.TPC);
  } // operator== (TPCID, TPCID)

  inline constexpr bool operator!=(TPCID const& a, TPCID const& b)
  {
    return (static_cast<CryostatID const&>(a) != static_cast<CryostatID const&>(b)) ||
           (a.TPC != b.TPC);
  } // operator!= (TPCID, TPCID)

  inline constexpr bool operator<(TPCID const& a, TPCID const& b)
  {
    int cmp_res = (static_cast<CryostatID const&>(a)).cmp(b);
    if (cmp_res == 0) // same cryostat: compare TPC
      return a.TPC < b.TPC;
    else // return the order of cryostats
      return cmp_res < 0;
  } // operator< (TPCID, TPCID)

  inline constexpr bool operator==(PlaneID const& a, PlaneID const& b)
  {
    return (static_cast<TPCID const&>(a) == static_cast<TPCID const&>(b)) && (a.Plane == b.Plane);
  } // operator== (PlaneID, PlaneID)

  inline constexpr bool operator!=(PlaneID const& a, PlaneID const& b)
  {
    return (static_cast<TPCID const&>(a) != static_cast<TPCID const&>(b)) || (a.Plane != b.Plane);
  } // operator!= (PlaneID, PlaneID)

  inline constexpr bool operator<(PlaneID const& a, PlaneID const& b)
  {
    int cmp_res = (static_cast<TPCID const&>(a)).cmp(b);
    if (cmp_res == 0) // same TPC: compare plane
      return a.Plane < b.Plane;
    else // return the order of TPC
      return cmp_res < 0;
  } // operator< (PlaneID, PlaneID)

  inline constexpr bool operator==(WireID const& a, WireID const& b)
  {
    return (static_cast<PlaneID const&>(a) == static_cast<PlaneID const&>(b)) && (a.Wire == b.Wire);
  } // operator== (WireID, WireID)

  inline constexpr bool operator!=(WireID const& a, WireID const& b)
  {
    return (static_cast<PlaneID const&>(a) != static_cast<PlaneID const&>(b)) || (a.Wire != b.Wire);
  } // operator!= (WireID, WireID)

  // Order WireID in increasing plane, then wire
  inline constexpr bool operator<(WireID const& a, WireID const& b)
  {
    int cmp_res = (static_cast<PlaneID const&>(a)).cmp(b);
    if (cmp_res == 0) // same plane: compare wire
      return a.Wire < b.Wire;
    else // return the order of planes
      return cmp_res < 0;
  } // operator< (WireID, WireID)


  //----------------------------------------------------------------------------
  struct WireIDIntersection {
    double y;         
    double z;         
    unsigned int TPC; 

    // In APAs, we want this to increase in the direction wireID
    // index increases in: moving inward vertically towards y=0
    bool operator<(const WireIDIntersection& otherIntersect) const
    {
      return std::abs(y) > std::abs(otherIntersect.y);
    }
  };

  //----------------------------------------------------------------------------
  std::string SignalTypeName(geo::SigType_t sigType);

  //----------------------------------------------------------------------------

} // namespace geo
// END Geometry ----------------------------------------------------------------

namespace geo {
  namespace details {

    //--------------------------------------------------------------------------
    template <typename ID, std::size_t Index, typename /* = void */>
    struct AbsIDtypeStruct {
      static_assert(Index <= ID::Level, "Requested ID index is not available.");
      using type = typename AbsIDtypeStruct<typename ID::ParentID_t, Index>::type;
    }; // AbsIDtypeStruct<>

    template <typename ID, std::size_t Index>
    struct AbsIDtypeStruct<ID, Index, std::enable_if_t<(Index == ID::Level)>> {
      using type = ID;
    };

    //--------------------------------------------------------------------------
    template <typename ID, std::size_t UpIndex>
    struct RelIDtypeStruct {
      static_assert(UpIndex <= ID::Level, "Requested parent ID index is not available.");
      using type = typename RelIDtypeStruct<typename ID::ParentID_t, UpIndex - 1U>::type;
    }; // RelIDtypeStruct<>

    template <typename ID>
    struct RelIDtypeStruct<ID, 0U> {
      using type = ID;
    };

    //--------------------------------------------------------------------------
    template <typename T>
    inline std::string writeToString(T const& value)
    {
      std::ostringstream sstr;
      sstr << value;
      return sstr.str();
    } // writeToString()

    //--------------------------------------------------------------------------

  } // namespace details

} // namespace geo

//------------------------------------------------------------------------------
//--- template implementation
//------------------------------------------------------------------------------
template <std::size_t Index /* = 0U */>
constexpr auto geo::CryostatID::getIndex() const
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::CryostatID::getIndex() const

template <std::size_t Index /* = 0U */>
auto& geo::CryostatID::writeIndex()
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::CryostatID::writeIndex()

template <std::size_t Above>
constexpr auto geo::CryostatID::getRelIndex() const
{
  static_assert(Above <= Level, "This ID type does not have the requested Index level.");
  return getIndex<Level - Above>();
} // geo::CryostatID::getRelIndex()

//------------------------------------------------------------------------------
template <std::size_t Index /* = 0U */>
constexpr auto geo::OpDetID::getIndex() const
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::OpDetID::getIndex() const

template <std::size_t Index /* = 0U */>
auto& geo::OpDetID::writeIndex()
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::OpDetID::writeIndex()

template <std::size_t Above>
constexpr auto geo::OpDetID::getRelIndex() const
{
  static_assert(Above <= Level, "This ID type does not have the requested Index level.");
  return getIndex<Level - Above>();
} // geo::OpDetID::getRelIndex()

//------------------------------------------------------------------------------
template <std::size_t Index /* = 0U */>
constexpr auto geo::TPCID::getIndex() const
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::TPCID::getIndex() const

template <std::size_t Index /* = 0U */>
auto& geo::TPCID::writeIndex()
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::TPCID::writeIndex()

template <std::size_t Above>
constexpr auto geo::TPCID::getRelIndex() const
{
  static_assert(Above <= Level, "This ID type does not have the requested Index level.");
  return getIndex<Level - Above>();
} // geo::TPCID::getRelIndex()

//------------------------------------------------------------------------------
template <std::size_t Index /* = 0U */>
constexpr auto geo::PlaneID::getIndex() const
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::PlaneID::getIndex() const

template <std::size_t Index /* = 0U */>
auto& geo::PlaneID::writeIndex()
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::PlaneID::writeIndex()

template <std::size_t Above>
constexpr auto geo::PlaneID::getRelIndex() const
{
  static_assert(Above <= Level, "This ID type does not have the requested Index level.");
  return getIndex<Level - Above>();
} // geo::PlaneID::getRelIndex()

//------------------------------------------------------------------------------
template <std::size_t Index /* = 0U */>
constexpr auto geo::WireID::getIndex() const
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::WireID::getIndex() const

template <std::size_t Index /* = 0U */>
auto& geo::WireID::writeIndex()
{
  static_assert(Index <= Level, "This ID type does not have the requested Index level.");
  return details::getAbsIDindex<Index>(*this);
} // geo::WireID::writeIndex()

template <std::size_t Above>
constexpr auto geo::WireID::getRelIndex() const
{
  static_assert(Above <= Level, "This ID type does not have the requested Index level.");
  return getIndex<Level - Above>();
} // geo::WireID::getRelIndex()

//------------------------------------------------------------------------------

#endif // LARCOREOBJ_SIMPLETYPESANDCONSTANTS_GEO_TYPES_H