frequency.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_QUANTITIES_FREQUENCY_H
#define LARDATAALG_UTILITIES_QUANTITIES_FREQUENCY_H

// LArSoft libraries
#include "lardataalg/Utilities/quantities.h"
#include "lardataalg/Utilities/quantities/spacetime.h" // ...::units::Second

// C/C++ standard libraries
#include <ratio>
#include <string_view>

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

  namespace units {

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

    struct Hertz : public concepts::UnitBase {
      static constexpr auto symbol = "Hz"sv;
      static constexpr auto name = "hertz"sv;
    };

  } // namespace units

  // -- BEGIN Frequency --------------------------------------------------------

  template <typename R, typename T = double>
  using scaled_hertz = concepts::scaled_quantity<units::Hertz, R, T>;

  //
  // hertz
  //
  template <typename T = double>
  using hertz_as = scaled_hertz<std::ratio<1>, T>;

  using hertz = hertz_as<>;

  //
  // kilohertz
  //
  template <typename T = double>
  using kilohertz_as = concepts::rescale<hertz_as<T>, std::kilo>;

  using kilohertz = kilohertz_as<>;

  //
  // megahertz
  //
  template <typename T = double>
  using megahertz_as = concepts::rescale<hertz_as<T>, std::mega>;

  using megahertz = megahertz_as<>;

  //
  // gigahertz
  //
  template <typename T = double>
  using gigahertz_as = concepts::rescale<hertz_as<T>, std::giga>;

  using gigahertz = gigahertz_as<>;

  namespace frequency_literals {

    // @{
    constexpr hertz operator""_Hz(long double v)
    {
      return hertz{static_cast<double>(v)};
    }
    constexpr hertz operator""_Hz(unsigned long long int v)
    {
      return hertz{static_cast<double>(v)};
    }
    // @}

    // @{
    constexpr kilohertz operator""_kHz(long double v)
    {
      return kilohertz{static_cast<double>(v)};
    }
    constexpr kilohertz operator""_kHz(unsigned long long int v)
    {
      return kilohertz{static_cast<double>(v)};
    }
    // @}

    // @{
    constexpr megahertz operator""_MHz(long double v)
    {
      return megahertz{static_cast<double>(v)};
    }
    constexpr megahertz operator""_MHz(unsigned long long int v)
    {
      return megahertz{static_cast<double>(v)};
    }
    // @}

    // @{
    constexpr gigahertz operator""_GHz(long double v)
    {
      return gigahertz{static_cast<double>(v)};
    }
    constexpr gigahertz operator""_GHz(unsigned long long int v)
    {
      return gigahertz{static_cast<double>(v)};
    }
    // @}

  } // namespace frequency_literals

  // -- END Frequency ----------------------------------------------------------

  // -- BEGIN Special operations between Second and Hertz units ----------------

  namespace concepts {

    template <typename TR, typename TT, typename FR, typename FT>
    constexpr auto operator*(scaled_quantity<util::quantities::units::Second, TR, TT> t,
                             scaled_quantity<util::quantities::units::Hertz, FR, FT> f)
      -> decltype(std::declval<TT>() * std::declval<FT>());
    template <typename FR, typename FT, typename TR, typename TT>
    constexpr auto operator*(scaled_quantity<util::quantities::units::Hertz, FR, FT> f,
                             scaled_quantity<util::quantities::units::Second, TR, TT> t)
    {
      return t * f;
    }

    template <typename T, typename TR, typename TT>
    constexpr auto operator/(T v, scaled_second<TR, TT> t) -> std::enable_if_t<
      std::is_convertible_v<T, TT>,
      scaled_hertz<details::invert_t<TR>, decltype(std::declval<T>() / std::declval<TT>())>>;

    template <typename T, typename FR, typename FT>
    constexpr auto operator/(T v, scaled_hertz<FR, FT> f) -> std::enable_if_t<
      std::is_convertible_v<T, FT>,
      scaled_second<details::invert_t<FR>, decltype(std::declval<T>() / std::declval<FT>())>>;

  } // namespace concepts

  // -- END Special operations between Second and Hertz units ------------------

} // namespace util::quantities

//------------------------------------------------------------------------------
//--- template implementation
template <typename TR, typename TT, typename FR, typename FT>
constexpr auto util::quantities::concepts::operator*(
  scaled_quantity<util::quantities::units::Second, TR, TT> t,
  scaled_quantity<util::quantities::units::Hertz, FR, FT> f)
  -> decltype(std::declval<TT>() * std::declval<FT>())
{
  return details::applyRatioToValue<simplified_ratio_multiply<TR, FR>>(t.value() * f.value());
} // util::quantities::operator*(Second, Hertz)

//------------------------------------------------------------------------------
template <typename T, typename TR, typename TT>
constexpr auto util::quantities::concepts::operator/(T v, scaled_second<TR, TT> t)
  -> std::enable_if_t<
    std::is_convertible_v<T, TT>,
    scaled_hertz<details::invert_t<TR>, decltype(std::declval<T>() / std::declval<TT>())>>
{
  return scaled_hertz<details::invert_t<TR>,
                      decltype(std::declval<T>() / std::declval<TT>())>::castFrom(v / t.value());
} // util::quantities::operator/(Second)

//------------------------------------------------------------------------------
template <typename T, typename FR, typename FT>
constexpr auto util::quantities::concepts::operator/(T v, scaled_hertz<FR, FT> f)
  -> std::enable_if_t<
    std::is_convertible_v<T, FT>,
    scaled_second<details::invert_t<FR>, decltype(std::declval<T>() / std::declval<FT>())>>
{
  return scaled_second<details::invert_t<FR>,
                       decltype(std::declval<T>() / std::declval<FT>())>::castFrom(v / f.value());
} // util::quantities::operator/(Hertz)

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

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

#endif // LARDATAALG_UTILITIES_QUANTITIES_FREQUENCY_H