geo_types_fhicl.h

Go to the documentation of this file.

#ifndef LARCOREOBJ_SIMPLETYPESANDCONSTANTS_GEO_TYPES_FHICL_H
#define LARCOREOBJ_SIMPLETYPESANDCONSTANTS_GEO_TYPES_FHICL_H

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

// support libraries
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/OptionalAtom.h"
#include "fhiclcpp/types/OptionalSequence.h"
#include "fhiclcpp/types/OptionalTable.h"
#include "fhiclcpp/types/Sequence.h"
#include "fhiclcpp/types/Table.h"

// C/C++ standard libraries
#include <cstddef> // std::size_t
#include <optional>
#include <vector>

namespace geo::fhicl {

  // --- BEGIN -- Validated configuration parameters for geometry ID objects ---


  template <typename IDparam>
  struct IDparameterTraits;

  template <typename IDparam>
  using IDof = typename IDparameterTraits<IDparam>::ID_t;

  // --- BEGIN -- Generic ID infrastructure ------------------------------------
  struct ValidIDConfig {

    ::fhicl::Atom<bool> isValid{::fhicl::Name("isValid"),
                                ::fhicl::Comment("whether the ID is valid"),
                                true};

    bool valid() const { return isValid(); }

  }; // struct ValidIDConfig

  template <typename IDtype>
  struct IDConfig;

  template <typename IDtype>
  using IDparameter = ::fhicl::Table<IDConfig<IDtype>>;

  template <typename IDtype>
  using OptionalID = ::fhicl::OptionalTable<IDConfig<IDtype>>;

  template <typename IDtype>
  using IDsequence = ::fhicl::Sequence<IDparameter<IDtype>>;

  template <typename IDtype>
  using OptionalIDsequence = ::fhicl::OptionalSequence<IDparameter<IDtype>>;

  // --- END -- Generic ID infrastructure --------------------------------------

  // --- BEGIN -- Cryostat ID --------------------------------------------------
  template <>
  struct IDConfig<geo::CryostatID> : public ValidIDConfig {
    using ID_t = geo::CryostatID; 

    ::fhicl::Atom<geo::CryostatID::CryostatID_t> C{::fhicl::Name("C"),
                                                   ::fhicl::Comment("cryostat number"),
                                                   [this]() { return valid(); }};

    ID_t ID() const { return !valid() ? ID_t{} : ID_t{C()}; }
    operator ID_t() const { return ID(); }

  }; // struct IDConfig<geo::CryostatID>

  using CryostatID = IDparameter<geo::CryostatID>;

  using OptionalCryostatID = OptionalID<geo::CryostatID>;

  using CryostatIDsequence = IDsequence<geo::CryostatID>;

  using OptionalCryostatIDsequence = OptionalIDsequence<geo::CryostatID>;

  // --- END -- Cryostat ID ----------------------------------------------------

  // --- BEGIN -- TPC ID -------------------------------------------------------
  template <>
  struct IDConfig<geo::TPCID> : public IDConfig<geo::CryostatID> {
    using ID_t = geo::TPCID; 

    ::fhicl::Atom<geo::TPCID::TPCID_t> T{::fhicl::Name("T"),
                                         ::fhicl::Comment("TPC number within the cryostat"),
                                         [this]() { return valid(); }};

    ID_t ID() const { return !valid() ? ID_t{} : ID_t{IDConfig<geo::CryostatID>::ID(), T()}; }
    operator ID_t() const { return ID(); }
  }; // struct IDConfig<geo::TPCID>

  using TPCID = IDparameter<geo::TPCID>;

  using OptionalTPCID = OptionalID<geo::TPCID>;

  using TPCIDsequence = IDsequence<geo::TPCID>;

  using OptionalTPCIDsequence = OptionalIDsequence<geo::TPCID>;

  // --- END -- TPC ID ---------------------------------------------------------

  // --- BEGIN -- Optical detector ID ------------------------------------------
  template <>
  struct IDConfig<geo::OpDetID> : public IDConfig<geo::CryostatID> {
    using ID_t = geo::OpDetID; 

    ::fhicl::Atom<geo::OpDetID::OpDetID_t> O{
      ::fhicl::Name("O"),
      ::fhicl::Comment("Optical detector number within the cryostat"),
      [this]() { return valid(); }};

    ID_t ID() const { return !valid() ? ID_t{} : ID_t{IDConfig<geo::CryostatID>::ID(), O()}; }
    operator ID_t() const { return ID(); }
  }; // struct IDConfig<geo::OpDetID>

  using OpDetID = IDparameter<geo::OpDetID>;

  using OptionalOpDetID = OptionalID<geo::OpDetID>;

  using OpDetIDsequence = IDsequence<geo::OpDetID>;

  using OptionalOpDetIDsequence = OptionalIDsequence<geo::OpDetID>;

  // --- END -- Optical detector ID --------------------------------------------

  // --- BEGIN -- Plane ID -----------------------------------------------------
  template <>
  struct IDConfig<geo::PlaneID> : public IDConfig<geo::TPCID> {
    using ID_t = geo::PlaneID; 

    ::fhicl::Atom<geo::PlaneID::PlaneID_t> P{::fhicl::Name("P"),
                                             ::fhicl::Comment("Plane number within the TPC"),
                                             [this]() { return valid(); }};

    ID_t ID() const { return !valid() ? ID_t{} : ID_t{IDConfig<geo::TPCID>::ID(), P()}; }
    operator ID_t() const { return ID(); }
  }; // struct IDConfig<geo::PlaneID>

  using PlaneID = IDparameter<geo::PlaneID>;

  using OptionalPlaneID = OptionalID<geo::PlaneID>;

  using PlaneIDsequence = IDsequence<geo::PlaneID>;

  using OptionalPlaneIDsequence = OptionalIDsequence<geo::PlaneID>;

  // --- END -- Plane ID -------------------------------------------------------

  // --- BEGIN -- Wire ID ------------------------------------------------------
  template <>
  struct IDConfig<geo::WireID> : public IDConfig<geo::PlaneID> {
    using ID_t = geo::WireID; 

    ::fhicl::Atom<geo::WireID::WireID_t> W{::fhicl::Name("W"),
                                           ::fhicl::Comment("Wire number within the plane"),
                                           [this]() { return valid(); }};

    ID_t ID() const { return !valid() ? ID_t{} : ID_t{IDConfig<geo::PlaneID>::ID(), W()}; }
    operator ID_t() const { return ID(); }
  }; // struct IDConfig<geo::WireID>

  using WireID = IDparameter<geo::WireID>;

  using OptionalWireID = OptionalID<geo::WireID>;

  using WireIDsequence = IDsequence<geo::WireID>;

  using OptionalWireIDsequence = OptionalIDsequence<geo::WireID>;

  // --- END -- Wire ID --------------------------------------------------------

  // --- BEGIN -- ID parsing ---------------------------------------------------


  template <typename SrcID, typename ID = SrcID>
  ID readID(IDparameter<SrcID> const& atom);

  template <typename SrcID, typename ID = SrcID>
  ID readParameter(IDparameter<SrcID> const& atom)
  {
    return readID<SrcID, ID>(atom);
  }


  template <typename SrcID, typename ID = SrcID>
  std::optional<ID> readOptionalID(OptionalID<SrcID> const& atom);

  template <typename SrcID, typename ID = SrcID>
  std::optional<ID> readParameter(OptionalID<SrcID> const& atom)
  {
    return readOptionalID<SrcID, ID>(atom);
  }


  template <typename SrcID, typename ID = SrcID>
  ID readOptionalID(OptionalID<SrcID> const& atom, ID const& defValue);

  template <typename SrcID, typename ID = SrcID>
  ID readOptionalID(OptionalID<SrcID> const& atom, ID&& defValue);

  template <typename SrcID, typename ID = SrcID>
  ID readParameter(OptionalID<SrcID> const& atom, ID const& defValue)
  {
    return readOptionalID<SrcID, ID>(atom, defValue);
  }

  template <typename SrcID, typename ID = SrcID>
  ID readParameter(OptionalID<SrcID> const& atom, ID&& defValue)
  {
    return readOptionalID<SrcID, ID>(atom, std::move(defValue));
  }


  template <typename SrcID, typename ID = SrcID>
  std::vector<ID> readIDsequence(IDsequence<SrcID> const& seq);

  template <typename SrcID, typename ID = SrcID>
  std::vector<ID> readParameter(IDsequence<SrcID> const& seq)
  {
    return readIDsequence<SrcID, ID>(seq);
  }


  template <typename SrcID, typename ID = SrcID>
  std::optional<std::vector<ID>> readOptionalIDsequence(OptionalIDsequence<SrcID> const& seq);

  template <typename SrcID, typename ID = SrcID>
  std::optional<std::vector<ID>> readParameter(OptionalIDsequence<SrcID> const& seq)
  {
    return readOptionalIDsequence<SrcID, ID>(seq);
  }


  template <typename SrcID, typename ID = SrcID>
  std::vector<ID> readOptionalIDsequence(OptionalIDsequence<SrcID> const& seq,
                                         std::vector<ID> const& defValue);

  template <typename SrcID, typename ID = SrcID>
  std::vector<ID> readOptionalIDsequence(OptionalIDsequence<SrcID> const& seq,
                                         std::vector<ID>&& defValue);

  template <typename SrcID, typename ID = SrcID>
  std::vector<ID> readParameter(OptionalIDsequence<SrcID> const& seq,
                                std::vector<ID> const& defValue)
  {
    return readOptionalIDsequence<SrcID, ID>(seq, defValue);
  }

  template <typename SrcID, typename ID = SrcID>
  std::vector<ID> readParameter(OptionalIDsequence<SrcID> const& seq, std::vector<ID>&& defValue)
  {
    return readOptionalIDsequence<SrcID, ID>(seq, std::move(defValue));
  }


  // --- END -- ID parsing -----------------------------------------------------

  // --- END -- Validated configuration parameters for geometry ID objects -----

} // namespace geo::fhicl

// -----------------------------------------------------------------------------
// ---  template implementation
// -----------------------------------------------------------------------------
// --- definition of the traits
// ---
template <typename ID>
struct geo::fhicl::IDparameterTraits<geo::fhicl::IDparameter<ID>> {

  using type = IDparameter<ID>; 

  using ID_t = typename type::ID_t; 

  static constexpr bool isOptional = false; 

  static constexpr bool isAtom = true; 

  static constexpr bool isSequence = false; 

}; // geo::fhicl::IDparameterTraits<geo::fhicl::IDparameter<ID>>

template <typename ID>
struct geo::fhicl::IDparameterTraits<geo::fhicl::OptionalID<ID>>
  : geo::fhicl::IDparameterTraits<geo::fhicl::IDparameter<ID>> {
  // override:
  static constexpr bool isOptional = true; 
}; // geo::fhicl::IDparameterTraits<geo::fhicl::OptionalID<ID>>

template <typename ID>
struct geo::fhicl::IDparameterTraits<geo::fhicl::IDsequence<ID>>
  : geo::fhicl::IDparameterTraits<geo::fhicl::IDparameter<ID>> {
  // override:
  static constexpr bool isAtom = false;    
  static constexpr bool isSequence = true; 
}; // geo::fhicl::IDparameterTraits<geo::fhicl::IDsequence<ID>>

template <typename ID>
struct geo::fhicl::IDparameterTraits<geo::fhicl::OptionalIDsequence<ID>>
  : geo::fhicl::IDparameterTraits<geo::fhicl::IDsequence<ID>> {
  // override:
  static constexpr bool isOptional = true; 
}; // geo::fhicl::IDparameterTraits<geo::fhicl::OptionalIDsequence<ID>>

// -----------------------------------------------------------------------------
template <typename SrcID, typename ID /* = SrcID */>
ID geo::fhicl::readID(IDparameter<SrcID> const& atom)
{
  return atom(); // conversions happen as needed (if possible)
} // geo::fhicl::readID()

// -----------------------------------------------------------------------------
template <typename SrcID, typename ID /* = SrcID */>
std::optional<ID> geo::fhicl::readOptionalID(OptionalID<SrcID> const& atom)
{
  using ID_t = ID;

  typename OptionalID<SrcID>::value_type cs;
  return atom(cs) ? std::make_optional<ID_t>(cs.ID()) : std::nullopt;
} // geo::fhicl::readOptionalID()

// -----------------------------------------------------------------------------
template <typename SrcID, typename ID /* = SrcID */>
ID geo::fhicl::readOptionalID(OptionalID<SrcID> const& atom, ID const& defValue)
{
  return readOptionalID(atom).value_or(defValue);
}

// -----------------------------------------------------------------------------
template <typename SrcID, typename ID /* = SrcID */>
ID geo::fhicl::readOptionalID(OptionalID<SrcID> const& atom, ID&& defValue)
{
  return readOptionalID(atom).value_or(std::move(defValue));
}

// -----------------------------------------------------------------------------
template <typename SrcID, typename ID /* = SrcID */>
std::vector<ID> geo::fhicl::readIDsequence(IDsequence<SrcID> const& seq)
{
  using ID_t = ID;

  std::vector<ID_t> IDs;
  std::size_t const n = seq.size();
  IDs.reserve(n);
  for (std::size_t i = 0; i < n; ++i)
    IDs.push_back(seq(i)); // seq(i) is TPCIDConfig
  return IDs;
} // geo::fhicl::readIDsequence()

// -----------------------------------------------------------------------------
template <typename SrcID, typename ID /* = SrcID */>
std::optional<std::vector<ID>> geo::fhicl::readOptionalIDsequence(
  OptionalIDsequence<SrcID> const& seq)
{
  using values_t = std::vector<ID>;

  typename OptionalIDsequence<SrcID>::value_type values;
  if (!seq(values)) return std::nullopt;

  values_t IDs;
  IDs.reserve(values.size());
  std::copy(values.begin(), values.end(), std::back_inserter(IDs));
  return {std::move(IDs)};

} // geo::fhicl::readOptionalIDsequence()

// -----------------------------------------------------------------------------
template <typename SrcID, typename ID /* = SrcID */>
std::vector<ID> geo::fhicl::readOptionalIDsequence(OptionalIDsequence<SrcID> const& seq,
                                                   std::vector<ID> const& defValue)
{
  // making sure `paramValue` is not a r-value; not sure whether it is necessary
  auto paramValue = readOptionalIDsequence(seq);
  return paramValue.value_or(defValue);
} // geo::fhicl::readOptionalIDsequence(std::vector const&)

// -----------------------------------------------------------------------------
template <typename SrcID, typename ID /* = SrcID */>
std::vector<ID> geo::fhicl::readOptionalIDsequence(OptionalIDsequence<SrcID> const& seq,
                                                   std::vector<ID>&& defValue)
{
  return readOptionalIDsequence(seq).value_or(std::move(defValue));
} // geo::fhicl::readOptionalIDsequence(std::vector const&)

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

#endif // LARCOREOBJ_SIMPLETYPESANDCONSTANTS_GEO_TYPES_FHICL_H