readout_types.h

Go to the documentation of this file.

#ifndef LARCOREOBJ_SIMPLETYPESANDCONSTANTS_READOUT_TYPES_H
#define LARCOREOBJ_SIMPLETYPESANDCONSTANTS_READOUT_TYPES_H

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

// C/C++ standard libraries
#include <iosfwd> // std::ostream

namespace readout {

  namespace details {

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

    template <std::size_t Index, typename ID>
    using AbsIDtype = geo::details::AbsIDtype<Index, ID>;

    template <std::size_t UpIndex, typename ID>
    using RelIDtype = geo::details::RelIDtype<UpIndex, ID>;

    template <std::size_t Index, typename ID>
    inline constexpr auto getAbsIDindex(ID const& id)
    {
      return geo::details::getAbsIDindex<Index, ID>(id);
    }

    template <std::size_t Index, typename ID>
    inline auto& getAbsIDindex(ID& id)
    {
      return geo::details::getAbsIDindex<Index, ID>(id);
    }

  } // namespace details

  struct ElementLevel {

    using Level_t = geo::ElementLevel::Level_t;

    static constexpr Level_t Cryostat = 0U;
    static constexpr Level_t TPCset = 1U;
    static constexpr Level_t ReadoutPlane = 2U;
    static constexpr Level_t Channel = 3U;
    static constexpr Level_t NLevels = 4U;

  }; // struct ElementLevel

  // We define our own cryostat ID as an alias of the one from geometry
  using CryostatID = geo::CryostatID;

  struct TPCsetID : public CryostatID {
    using TPCsetID_t = unsigned short; 

    using ThisID_t = TPCsetID;     
    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>;

    static constexpr TPCsetID_t InvalidID = std::numeric_limits<TPCsetID_t>::max();

    TPCsetID_t TPCset = InvalidID;

    constexpr TPCsetID() = default;

    constexpr TPCsetID(CryostatID const& cryoid, TPCsetID_t s) : CryostatID(cryoid), TPCset(s) {}

    constexpr TPCsetID(CryostatID_t c, TPCsetID_t s) : CryostatID(c), TPCset(s) {}

    // 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 TPCset; }
    auto& deepestIndex() { return TPCset; }
    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 TPCsetID const& asTPCsetID() const { return *this; }
    TPCsetID& asTPCsetID() { return *this; }
    constexpr TPCsetID const& asConstTPCsetID() { return *this; }

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

    static constexpr auto Level = readout::ElementLevel::TPCset;

    static constexpr TPCsetID_t getInvalidID() { return TPCsetID::InvalidID; }

  }; // struct TPCsetID

  struct ROPID : public TPCsetID {
    using ROPID_t = unsigned int; 

    using ThisID_t = ROPID;      
    using ParentID_t = TPCsetID; 

    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>;

    static constexpr ROPID_t InvalidID = std::numeric_limits<ROPID_t>::max();

    ROPID_t ROP = InvalidID; 

    constexpr ROPID() = default;

    constexpr ROPID(TPCsetID const& tpcsetid, ROPID_t r) : TPCsetID(tpcsetid), ROP(r) {}

    constexpr ROPID(CryostatID_t c, TPCsetID_t s, ROPID_t r) : TPCsetID(c, s), ROP(r) {}

    // 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 ROP; }
    auto& deepestIndex() { return ROP; }
    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 ROPID const& asROPID() const { return *this; }
    ROPID& asROPID() { return *this; }
    constexpr ROPID const& asConstROPID() { return *this; }

    constexpr int cmp(ROPID const& other) const
    {
      int cmp_res = TPCsetID::cmp(other);
      if (cmp_res == 0) // same TPC set: compare plane
        return ThreeWayComparison(ROP, other.ROP);
      else // return the order of TPC set
        return cmp_res;
    } // cmp()

    static constexpr auto Level = readout::ElementLevel::ReadoutPlane;

    static constexpr ROPID_t getInvalidID() { return ROPID::InvalidID; }

  }; // struct ROPID

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


  inline constexpr bool operator==(TPCsetID const& a, TPCsetID const& b)
  {
    return (a.asCryostatID() == b.asCryostatID()) && (a.TPCset == b.TPCset);
  } // operator== (TPCsetID, TPCsetID)

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

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

  inline constexpr bool operator==(ROPID const& a, ROPID const& b)
  {
    return (a.asTPCsetID() == b.asTPCsetID()) && (a.ROP == b.ROP);
  } // operator== (ROPID, ROPID)

  inline constexpr bool operator!=(ROPID const& a, ROPID const& b)
  {
    return (a.asTPCsetID() != b.asTPCsetID()) || (a.ROP != b.ROP);
  } // operator!= (ROPID, ROPID)

  inline constexpr bool operator<(ROPID const& a, ROPID const& b)
  {
    int cmp_res = a.asTPCsetID().cmp(b);
    if (cmp_res == 0) // same TPC set: compare ROP
      return a.ROP < b.ROP;
    else // return the order of TPC set
      return cmp_res < 0;
  } // operator< (ROPID, ROPID)


  //----------------------------------------------------------------------------
  //--- ID output operators
  //---
  inline std::ostream& operator<<(std::ostream& out, TPCsetID const& sid)
  {
    out << sid.asCryostatID() << " S:" << sid.TPCset;
    return out;
  } // operator<< (TPCsetID)

  inline std::ostream& operator<<(std::ostream& out, ROPID const& rid)
  {
    out << rid.asTPCsetID() << " R:" << rid.ROP;
    return out;
  } // operator<< (ROPID)

} // namespace readout

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

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

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

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

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

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

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

#endif // LARCOREOBJ_SIMPLETYPESANDCONSTANTS_READOUT_TYPES_H