DetectorTimingTypes.h

Go to the documentation of this file.

#ifndef LARDATAALG_DETECTORINFO_DETECTORTIMINGTYPES_H
#define LARDATAALG_DETECTORINFO_DETECTORTIMINGTYPES_H

// LArSoft libraries
#include "lardataalg/Utilities/quantities/electronics.h"
#include "lardataalg/Utilities/quantities/frequency.h"
#include "lardataalg/Utilities/quantities/spacetime.h"

namespace detinfo::timescales {

  template <typename Cat>
  struct timescale_traits;

  using time_interval = util::quantities::intervals::microseconds;

  namespace details {

    template <typename Cat, typename = void>
    struct category_of_t {
      using type = Cat;
    };

    template <typename Cat>
    struct category_of_t<Cat, std::void_t<typename Cat::category_t>> {
      using type = typename Cat::category_t;
    };

    template <typename Cat>
    using category_of = typename category_of_t<Cat>::type;

    template <typename Cat, typename TimeUnit = util::quantities::microsecond>
    struct timescale_traits_base {

      using category_t = Cat;

      using time_interval_t = time_interval;

      using time_point_t = util::quantities::concepts::Point<TimeUnit, category_t, time_interval_t>;

      using frequency_t = decltype(1.0 / std::declval<typename time_interval_t::quantity_t>());

      using tick_interval_t =
        util::quantities::concepts::Interval<util::quantities::tick, category_t>;

      using tick_interval_d_t =
        util::quantities::concepts::Interval<util::quantities::tick_d, category_t>;

      using tick_t =
        util::quantities::concepts::Point<util::quantities::tick, category_t, tick_interval_t>;

      using tick_d_t =
        util::quantities::concepts::Point<util::quantities::tick_d, category_t, tick_interval_d_t>;

      static std::string name() { return category_t::name(); }

      template <typename OC>
      static constexpr bool same_category_as = std::is_same_v<category_of<OC>, category_t>;

      template <typename OC>
      static constexpr bool category_compatible_with = same_category_as<category_of<OC>>;

    }; // timescale_traits_base<>

  } // namespace details

  //----------------------------------------------------------------------------
  struct ElectronicsTimeCategory : util::quantities::concepts::CategoryBase {
    static std::string name() { return {"electronics time"}; }
  }; // struct ElectronicsTimeCategory

  template <>
  struct timescale_traits<ElectronicsTimeCategory>
    : public details::timescale_traits_base<ElectronicsTimeCategory> {};

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

  struct TPCelectronicsTimeCategory : util::quantities::concepts::CategoryBase {
    static std::string name() { return {"TPC electronics time"}; }
  }; // struct TPCelectronicsTimeCategory

  template <>
  struct timescale_traits<TPCelectronicsTimeCategory>
    : public details::timescale_traits_base<TPCelectronicsTimeCategory> {};

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

  struct OpticalTimeCategory : util::quantities::concepts::CategoryBase {
    static std::string name() { return {"optical electronics time"}; }
  }; // struct OpticalTimeCategory

  template <>
  struct timescale_traits<OpticalTimeCategory>
    : public details::timescale_traits_base<OpticalTimeCategory> {};

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

  struct TriggerTimeCategory : util::quantities::concepts::CategoryBase {
    static std::string name() { return {"hardware trigger time"}; }
  }; // struct TriggerTimeCategory

  template <>
  struct timescale_traits<TriggerTimeCategory>
    : public details::timescale_traits_base<TriggerTimeCategory> {};

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

  struct SimulationTimeCategory : util::quantities::concepts::CategoryBase {
    static std::string name() { return {"simulation time"}; }
  }; // struct SimulationTimeCategory

  template <>
  struct timescale_traits<SimulationTimeCategory>
    : public details::timescale_traits_base<SimulationTimeCategory, util::quantities::nanosecond> {
  };

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

  // --- BEGIN -- Continuous times ---------------------------------------------

  using electronics_time = timescale_traits<ElectronicsTimeCategory>::time_point_t;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using TPCelectronics_time = timescale_traits<TPCelectronicsTimeCategory>::time_point_t;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using optical_time = timescale_traits<OpticalTimeCategory>::time_point_t;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using trigger_time = timescale_traits<TriggerTimeCategory>::time_point_t;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using simulation_time = timescale_traits<SimulationTimeCategory>::time_point_t;

  // --- END -- Continuous times ---------------------------------------------

  // --- BEGIN -- Tick-based times -------------------------------------------

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using electronics_tick = timescale_traits<ElectronicsTimeCategory>::tick_t;

  using electronics_tick_d = timescale_traits<ElectronicsTimeCategory>::tick_d_t;

  using electronics_time_ticks = timescale_traits<ElectronicsTimeCategory>::tick_interval_t;

  using electronics_time_ticks_d = timescale_traits<ElectronicsTimeCategory>::tick_interval_d_t;

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

  using TPCelectronics_tick = timescale_traits<TPCelectronicsTimeCategory>::tick_t;

  using TPCelectronics_tick_d = timescale_traits<TPCelectronicsTimeCategory>::tick_d_t;

  using TPCelectronics_time_ticks = timescale_traits<TPCelectronicsTimeCategory>::tick_interval_t;

  using TPCelectronics_time_ticks_d =
    timescale_traits<TPCelectronicsTimeCategory>::tick_interval_d_t;

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

  using optical_tick = timescale_traits<OpticalTimeCategory>::tick_t;

  using optical_tick_d = timescale_traits<OpticalTimeCategory>::tick_d_t;

  using optical_time_ticks = timescale_traits<OpticalTimeCategory>::tick_interval_t;

  using optical_time_ticks_d = timescale_traits<OpticalTimeCategory>::tick_interval_d_t;

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

  using trigger_tick = timescale_traits<TriggerTimeCategory>::tick_t;

  using trigger_tick_d = timescale_traits<TriggerTimeCategory>::tick_d_t;

  using trigger_time_ticks = timescale_traits<TriggerTimeCategory>::tick_interval_t;

  using trigger_time_ticks_d = timescale_traits<TriggerTimeCategory>::tick_interval_d_t;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  template <typename T>
  struct is_tick_type;

  template <typename T>
  constexpr bool is_tick_v = is_tick_type<T>();

  // --- END -- Tick-based times ---------------------------------------------

} // namespace detinfo::timescales

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

namespace detinfo::timescales {

  // ---------------------------------------------------------------------------
  namespace details {

    // -------------------------------------------------------------------------
    template <typename T, typename = void>
    struct is_tick_type_impl : std::false_type {};

    template <typename Q>
    struct is_tick_type_impl<
      Q,
      std::enable_if_t<std::is_same_v<typename Q::baseunit_t, util::quantities::units::Tick>>>
      : std::true_type {};

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

    // Generally undefined; suggested to derive from `timescale_traits_base`.
    template <typename, typename = void>
    struct custom_timescale_traits;

    // Specialization for quantities: same traits as quantity category.
    template <typename WC>
    struct custom_timescale_traits<
      WC,
      std::enable_if_t<util::quantities::concepts::is_interval_or_point_v<WC>>>
      : public timescale_traits<typename WC::category_t> {};

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

  } // namespace details

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

  // For customization, pick on `details::custom_timescale_traits`.
  template <typename Cat>
  struct timescale_traits : public details::custom_timescale_traits<Cat> {};

  // ---------------------------------------------------------------------------
  template <typename T>
  struct is_tick_type : details::is_tick_type_impl<T> {};

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

} // namespace detinfo::timescales

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

#endif // LARDATAALG_DETECTORINFO_DETECTORTIMINGTYPES_H