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

  // 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 ParentID_t = CryostatID; 

    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) {}

    static constexpr auto first() { return TPCsetID{CryostatID::first(), 0}; }
    static constexpr auto first(CryostatID const& id) { return TPCsetID{id, 0}; }

    // 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; }
    constexpr ParentID_t& parentID() { return *this; }
    template <std::size_t Index>
    constexpr auto getIndex() const;

    constexpr CryostatID const& asCryostatID() const { return parentID(); }
    constexpr CryostatID& asCryostatID() { return parentID(); }

    static constexpr auto Level = geo::details::index_for<TPCsetID>();

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

  }; // struct TPCsetID

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

    using ParentID_t = TPCsetID; 

    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) {}

    static constexpr auto first() { return ROPID{TPCsetID::first(), 0}; }
    static constexpr auto first(CryostatID const& id) { return ROPID{TPCsetID::first(id), 0}; }
    static constexpr auto first(TPCsetID const& id) { return ROPID{id, 0}; }

    // 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; }
    constexpr ParentID_t& parentID() { return *this; }
    template <std::size_t Index>
    constexpr auto getIndex() const;

    constexpr TPCsetID const& asTPCsetID() const { return parentID(); }
    constexpr TPCsetID& asTPCsetID() { return parentID(); }

    static constexpr auto Level = geo::details::index_for<ROPID>();

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

  }; // struct ROPID

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

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

} // namespace readout

//------------------------------------------------------------------------------
//--- template implementation
//------------------------------------------------------------------------------
template <std::size_t Index>
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);
}

//------------------------------------------------------------------------------
template <std::size_t Index>
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);
}

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

#endif // LARCOREOBJ_SIMPLETYPESANDCONSTANTS_READOUT_TYPES_H