spacetime.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_QUANTITIES_SPACETIME_H
#define LARDATAALG_UTILITIES_QUANTITIES_SPACETIME_H

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

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

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

  namespace units {

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

    struct Second : public concepts::UnitBase {
      static constexpr auto symbol = "s"sv;
      static constexpr auto name = "second"sv;
    };

    struct Meter : public concepts::UnitBase {
      static constexpr auto symbol = "m"sv;
      static constexpr auto name = "meter"sv;
    };

  } // namespace units

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

  template <typename R, typename T = double>
  using scaled_second = concepts::scaled_quantity<units::Second, R, T>;

  //
  // seconds
  //
  template <typename T = double>
  using second_as = scaled_second<std::ratio<1>, T>;

  template <typename T = double>
  using seconds_as = second_as<T>;

  using second = second_as<>;

  using seconds = second;

  //
  // milliseconds
  //
  template <typename T = double>
  using millisecond_as = concepts::rescale<second_as<T>, std::milli>;

  template <typename T = double>
  using milliseconds_as = millisecond_as<T>;

  using millisecond = millisecond_as<>;

  using milliseconds = millisecond;

  //
  // microseconds
  //
  template <typename T = double>
  using microsecond_as = concepts::rescale<second_as<T>, std::micro>;

  template <typename T = double>
  using microseconds_as = microsecond_as<T>;

  using microsecond = microsecond_as<>;

  using microseconds = microsecond;

  //
  // nanoseconds
  //
  template <typename T = double>
  using nanosecond_as = concepts::rescale<second_as<T>, std::nano>;

  template <typename T = double>
  using nanoseconds_as = nanosecond_as<T>;

  using nanosecond = nanosecond_as<>;

  using nanoseconds = nanosecond;

  //
  // picoseconds
  //
  template <typename T = double>
  using picosecond_as = concepts::rescale<second_as<T>, std::pico>;

  template <typename T = double>
  using picoseconds_as = picosecond_as<T>;

  using picosecond = picosecond_as<>;

  using picoseconds = picosecond;

  namespace time_literals {

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

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

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

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

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

  } // time_literals

  // --- BEGIN Time intervals --------------------------------------------------

  namespace intervals {

    template <typename R, typename T = double>
    using scaled_seconds = concepts::Interval<util::quantities::scaled_second<R, T>>;

    //
    // seconds
    //
    template <typename T = double>
    using seconds_as = scaled_seconds<std::ratio<1>, T>;

    using seconds = seconds_as<>;

    //
    // milliseconds
    //

    template <typename T = double>
    using milliseconds_as = scaled_seconds<std::milli, T>;

    using milliseconds = milliseconds_as<>;

    //
    // microseconds
    //

    template <typename T = double>
    using microseconds_as = scaled_seconds<std::micro, T>;

    using microseconds = microseconds_as<>;

    //
    // nanoseconds
    //

    template <typename T = double>
    using nanoseconds_as = scaled_seconds<std::nano, T>;

    using nanoseconds = nanoseconds_as<>;

    //
    // picoseconds
    //

    template <typename T = double>
    using picoseconds_as = scaled_seconds<std::pico, T>;

    using picoseconds = picoseconds_as<>;

  } // namespace intervals

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

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

  namespace points {

    template <typename R, typename T = double, typename Cat = NoCategory>
    using scaled_second = concepts::Point<util::quantities::scaled_second<R, T>, Cat>;

    //
    // second
    //
    template <typename T = double, typename Cat = NoCategory>
    using second_as = scaled_second<std::ratio<1>, T, Cat>;

    using second = second_as<>;

    //
    // millisecond
    //

    template <typename T = double, typename Cat = NoCategory>
    using millisecond_as = scaled_second<std::milli, T, Cat>;

    using millisecond = millisecond_as<>;

    //
    // microsecond
    //

    template <typename T = double, typename Cat = NoCategory>
    using microsecond_as = scaled_second<std::micro, T, Cat>;

    using microsecond = microsecond_as<>;

    //
    // nanosecond
    //

    template <typename T = double, typename Cat = NoCategory>
    using nanosecond_as = scaled_second<std::nano, T, Cat>;

    using nanosecond = nanosecond_as<>;

    //
    // picosecond
    //

    template <typename T = double, typename Cat = NoCategory>
    using picosecond_as = scaled_second<std::pico, T, Cat>;

    using picosecond = picosecond_as<>;

  } // namespace points

  // --- END Time points -------------------------------------------------------

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

  // -- BEGIN Space ------------------------------------------------------------

  template <typename R, typename T = double>
  using scaled_meter = concepts::scaled_quantity<units::Meter, R, T>;

  //
  // meters
  //
  template <typename T = double>
  using meter_as = scaled_meter<std::ratio<1>, T>;

  template <typename T = double>
  using meters_as = meter_as<T>;

  using meter = meter_as<>;

  using meters = meter;

  //
  // kilometers
  //
  template <typename T = double>
  using kilometer_as = concepts::rescale<meter_as<T>, std::kilo>;

  template <typename T = double>
  using kilometers_as = kilometer_as<T>;

  using kilometer = kilometer_as<>;

  using kilometers = kilometer;

  //
  // centimeters
  //
  template <typename T = double>
  using centimeter_as = concepts::rescale<meter_as<T>, std::centi>;

  template <typename T = double>
  using centimeters_as = centimeter_as<T>;

  using centimeter = centimeter_as<>;

  using centimeters = centimeter;

  //
  // millimeters
  //
  template <typename T = double>
  using millimeter_as = concepts::rescale<meter_as<T>, std::milli>;

  template <typename T = double>
  using millimeters_as = millimeter_as<T>;

  using millimeter = millimeter_as<>;

  using millimeters = millimeter;

  //
  // micrometers
  //
  template <typename T = double>
  using micrometer_as = concepts::rescale<meter_as<T>, std::micro>;

  template <typename T = double>
  using micrometers_as = micrometer_as<T>;

  using micrometer = micrometer_as<>;

  using micrometers = micrometer;

  //
  // nanometers
  //
  template <typename T = double>
  using nanometer_as = concepts::rescale<meter_as<T>, std::nano>;

  template <typename T = double>
  using nanometers_as = nanometer_as<T>;

  using nanometer = nanometer_as<>;

  using nanometers = nanometer;

  //
  // picometers
  //
  template <typename T = double>
  using picometer_as = concepts::rescale<meter_as<T>, std::pico>;

  template <typename T = double>
  using picometers_as = picometer_as<T>;

  using picometer = picometer_as<>;

  using picometers = picometer;

  //
  // femtometers
  //
  template <typename T = double>
  using femtometer_as = concepts::rescale<meter_as<T>, std::femto>;

  template <typename T = double>
  using femtometers_as = femtometer_as<T>;

  using femtometer = femtometer_as<>;

  using femtometers = femtometer;

  namespace space_literals {

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

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

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

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

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

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

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

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

  } // space_literals

  // --- BEGIN Space intervals -------------------------------------------------

  namespace intervals {

    template <typename R, typename T = double>
    using scaled_meters = concepts::Interval<util::quantities::scaled_meter<R, T>>;

    //
    // meters
    //
    template <typename T = double>
    using meters_as = scaled_meters<std::ratio<1>, T>;

    using meters = meters_as<>;

    //
    // kilometers
    //

    template <typename T = double>
    using kilometers_as = scaled_meters<std::kilo, T>;

    using kilometers = kilometers_as<>;

    //
    // centimeters
    //

    template <typename T = double>
    using centimeters_as = scaled_meters<std::centi, T>;

    using centimeters = centimeters_as<>;

    //
    // millimeters
    //

    template <typename T = double>
    using millimeters_as = scaled_meters<std::milli, T>;

    using millimeters = millimeters_as<>;

    //
    // micrometers
    //

    template <typename T = double>
    using micrometers_as = scaled_meters<std::micro, T>;

    using micrometers = micrometers_as<>;

    //
    // nanometers
    //

    template <typename T = double>
    using nanometers_as = scaled_meters<std::nano, T>;

    using nanometers = nanometers_as<>;

    //
    // picometers
    //

    template <typename T = double>
    using picometers_as = scaled_meters<std::pico, T>;

    using picometers = picometers_as<>;

    //
    // femtometers
    //

    template <typename T = double>
    using femtometers_as = scaled_meters<std::femto, T>;

    using femtometers = femtometers_as<>;

  } // namespace intervals

  // --- END Space intervals ---------------------------------------------------

  // --- BEGIN Space points ----------------------------------------------------

  namespace points {

    template <typename R, typename T = double, typename Cat = NoCategory>
    using scaled_meter = concepts::Point<util::quantities::scaled_meter<R, T>, Cat>;

    //
    // meter
    //
    template <typename T = double, typename Cat = NoCategory>
    using meter_as = scaled_meter<std::ratio<1>, T, Cat>;

    using meter = meter_as<>;

    //
    // kilometer
    //

    template <typename T = double, typename Cat = NoCategory>
    using kilometer_as = scaled_meter<std::kilo, T, Cat>;

    using kilometer = kilometer_as<>;

    //
    // centimeter
    //

    template <typename T = double, typename Cat = NoCategory>
    using centimeter_as = scaled_meter<std::centi, T, Cat>;

    using centimeter = centimeter_as<>;

    //
    // millimeter
    //

    template <typename T = double, typename Cat = NoCategory>
    using millimeter_as = scaled_meter<std::milli, T, Cat>;

    using millimeter = millimeter_as<>;

    //
    // micrometer
    //

    template <typename T = double, typename Cat = NoCategory>
    using micrometer_as = scaled_meter<std::micro, T, Cat>;

    using micrometer = micrometer_as<>;

    //
    // nanometer
    //

    template <typename T = double, typename Cat = NoCategory>
    using nanometer_as = scaled_meter<std::nano, T, Cat>;

    using nanometer = nanometer_as<>;

    //
    // picometer
    //

    template <typename T = double, typename Cat = NoCategory>
    using picometer_as = scaled_meter<std::pico, T, Cat>;

    using picometer = picometer_as<>;

    //
    // femtometer
    //

    template <typename T = double, typename Cat = NoCategory>
    using femtometer_as = scaled_meter<std::femto, T, Cat>;

    using femtometer = femtometer_as<>;

  } // namespace points

  // --- END Space points -------------------------------------------------------

  // -- END Space --------------------------------------------------------------

} // namespace util::quantities

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

#endif // LARDATAALG_UTILITIES_QUANTITIES_SPACETIME_H