electronics.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_QUANTITIES_ELECTRONICS_H
#define LARDATAALG_UTILITIES_QUANTITIES_ELECTRONICS_H

// LArSoft libraries
#include "lardataalg/Utilities/intervals.h"
#include "lardataalg/Utilities/quantities.h"

// C/C++ standard libraries
#include <cstddef> // std::ptrdiff_t
#include <ratio>
#include <string_view>

//------------------------------------------------------------------------------
namespace util::quantities {

  namespace units {

    using namespace std::string_view_literals; // for operator""sv()

    struct Tick : public concepts::UnitBase {
      static constexpr auto symbol = "#"sv;
      static constexpr auto name = "tick"sv;
    };

    struct Counts : public concepts::UnitBase {
      static constexpr auto symbol = "#"sv;
      static constexpr auto name = "counts"sv;
    };

  } // namespace units

  // -- BEGIN Ticks ------------------------------------------------------------

  template <typename T = std::ptrdiff_t>
  using tick_as = concepts::scaled_quantity<units::Tick, std::ratio<1>, T>;

  template <typename T = tick_as<>::value_t>
  using ticks_as = tick_as<T>;

  using tick = tick_as<>;

  using ticks = tick;

  using tick_f = tick_as<float>;

  using ticks_f = tick_f;

  using tick_d = tick_as<double>;

  using ticks_d = tick_d;

  // -- END Ticks --------------------------------------------------------------

  // -- BEGIN ADC counts -------------------------------------------------------

  template <typename T = signed short int>
  using counts_as = concepts::scaled_quantity<units::Counts, std::ratio<1>, T>;

  using counts = counts_as<>;

  using counts_f = counts_as<float>;

  // -- END ADC counts ---------------------------------------------------------

  namespace electronics_literals {

    // @{
    constexpr tick operator""_tick(long double v)
    {
      return tick::castFrom(v);
    }
    constexpr tick operator""_tick(unsigned long long int v)
    {
      return tick::castFrom(v);
    }
    // @}

    // @{
    constexpr tick_d operator""_tickd(long double v)
    {
      return tick_d::castFrom(v);
    }
    constexpr tick_d operator""_tickd(unsigned long long int v)
    {
      return tick_d::castFrom(v);
    }
    // @}

    // @{
    constexpr counts operator""_ADC(long double v)
    {
      return counts{static_cast<signed short int>(v)};
    }
    constexpr counts operator""_ADC(unsigned long long int v)
    {
      return counts{static_cast<signed short int>(v)};
    }
    // @}

    // @{
    constexpr counts_f operator""_ADCf(long double v)
    {
      return counts_f{static_cast<float>(v)};
    }
    constexpr counts_f operator""_ADCf(unsigned long long int v)
    {
      return counts_f{static_cast<float>(v)};
    }
    // @}

  } // electronics_literals

  // --- BEGIN Tick intervals --------------------------------------------------

  namespace intervals {

    template <typename T = util::quantities::tick_as<>::value_t>
    using ticks_as = concepts::Interval<util::quantities::tick_as<T>>;

    using ticks = ticks_as<>;

    using ticks_f = ticks_as<float>;

    using ticks_d = ticks_as<double>;

  } // namespace intervals

  // --- END Time intervals ----------------------------------------------------

  // --- BEGIN Time points -----------------------------------------------------

  namespace points {

    template <typename T = util::quantities::tick_as<>::value_t, typename Cat = NoCategory>
    using tick_as = concepts::Point<util::quantities::tick_as<T>, Cat>;

    using tick = tick_as<>;

    using tick_f = tick_as<float>;

    using tick_d = tick_as<double>;

  } // namespace points

  // --- END Tick points -------------------------------------------------------


} // namespace util::quantities

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

#endif // LARDATAALG_UTILITIES_QUANTITIES_ELECTRONICS_H