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>
#include <tuple>
#include <type_traits>

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

  template <typename T, typename = void>
  struct has_parent : std::false_type {};

  template <typename T>
  struct has_parent<T, std::void_t<typename T::ParentID_t>> : std::true_type {};

  template <typename ID>
  constexpr bool isTopGeoElementID = !has_parent<ID>::value;

  template <typename T>
  constexpr auto index_impl(std::size_t& index)
  {
    if constexpr (has_parent<T>::value) { index_impl<typename T::ParentID_t>(++index); }
  }

  template <typename T>
  constexpr auto const index_for()
  {
    std::size_t index{};
    index_impl<T>(index);
    return index;
  }

  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 <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());
  }

} // namespace geo::details

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

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

  enum class Coordinate { X, Y, Z };
  std::ostream& operator<<(std::ostream& os, Coordinate);
  constexpr int to_int(Coordinate const coord) noexcept
  {
    return static_cast<int>(coord);
  }

  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;

  enum class DriftSign {
    Unknown,  
    Positive, 
    Negative  
  };
  std::ostream& operator<<(std::ostream& os, DriftSign);

  constexpr int to_int(DriftSign const sign)
  {
    switch (sign) {
    case DriftSign::Positive: return 1;
    case DriftSign::Negative: return -1;
    case DriftSign::Unknown: break;
    }
    return 0;
  }

  struct DriftAxis {
    Coordinate coordinate;
    DriftSign sign;
  };
  bool operator==(DriftAxis a, DriftAxis b);
  bool operator!=(DriftAxis a, DriftAxis b);
  std::ostream& operator<<(std::ostream& os, DriftAxis);

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


  struct CryostatID {
    using CryostatID_t = unsigned int; 

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

    static constexpr auto first() { return CryostatID{0, true}; }

    explicit constexpr operator bool() 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; }
    template <std::size_t Index>
    constexpr auto getIndex() const;

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

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

  }; // struct CryostatID

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

    using ParentID_t = CryostatID; 

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

    static constexpr OpDetID first() { return OpDetID{CryostatID::first(), 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 OpDet; }
    auto& deepestIndex() { return OpDet; }
    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 = details::index_for<OpDetID>();

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

  }; // struct OpDetID

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

    using ParentID_t = CryostatID; 

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

    TPCID next() const { return {Cryostat, TPC + 1}; }

    static constexpr auto first() { return TPCID{CryostatID::first(), 0}; }
    static constexpr auto first(CryostatID const& id) { return TPCID{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 TPC; }
    auto& deepestIndex() { return TPC; }
    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 = details::index_for<TPCID>();

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

  }; // struct TPCID

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

    using ParentID_t = TPCID; 

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

    static constexpr auto first() { return PlaneID{TPCID::first(), 0}; }
    static constexpr auto first(CryostatID const& id) { return PlaneID{TPCID::first(id), 0}; }
    static constexpr auto first(TPCID const& id) { return PlaneID{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 Plane; }
    auto& deepestIndex() { return Plane; }
    constexpr ParentID_t const& parentID() const { return *this; }
    constexpr ParentID_t& parentID() { return *this; }
    template <std::size_t Index>
    constexpr auto getIndex() const;

    constexpr TPCID const& asTPCID() const { return parentID(); }
    constexpr TPCID& asTPCID() { return parentID(); }

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

    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 ParentID_t = PlaneID; 

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

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

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

    constexpr PlaneID const& asPlaneID() const { return parentID(); }
    constexpr PlaneID& asPlaneID() { return parentID(); }

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

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

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

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

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

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

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

  // 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 == b);
  }

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

  template <typename BaseID, typename GeoID>
  static constexpr bool is_base_of_strict{std::is_base_of<BaseID, GeoID>{} &&
                                          !std::is_same<BaseID, GeoID>{}};

  template <typename GeoID>
  inline constexpr std::enable_if_t<is_base_of_strict<CryostatID, GeoID>, bool> operator==(
    GeoID const& a,
    GeoID const& b)
  {
    return std::tie(a.parentID(), a.deepestIndex()) == std::tie(b.parentID(), b.deepestIndex());
  }

  template <typename GeoID>
  inline constexpr std::enable_if_t<is_base_of_strict<CryostatID, GeoID>, bool> operator!=(
    GeoID const& a,
    GeoID const& b)
  {
    return !(a == b);
  }

  template <typename GeoID>
  inline constexpr std::enable_if_t<is_base_of_strict<CryostatID, GeoID>, bool> operator<(
    GeoID const& a,
    GeoID const& b)
  {
    return std::tie(a.parentID(), a.deepestIndex()) < std::tie(b.parentID(), b.deepestIndex());
  }


  //----------------------------------------------------------------------------
  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<(WireIDIntersection const& otherIntersect) const
    {
      return std::abs(y) > std::abs(otherIntersect.y);
    }

    static constexpr WireIDIntersection invalid()
    {
      return {
        std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), -1u};
    }
  };

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

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

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

namespace geo::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;
  };

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

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

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

} // namespace geo::details

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

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

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

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

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

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

#endif // LARCOREOBJ_SIMPLETYPESANDCONSTANTS_GEO_TYPES_H