electromagnetism.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_QUANTITIES_ELECTROMAGNETISM_H
#define LARDATAALG_UTILITIES_QUANTITIES_ELECTROMAGNETISM_H

// LArSoft libraries
#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 Coulomb : public concepts::UnitBase {
      static constexpr auto symbol = "C"sv;
      static constexpr auto name = "coulomb"sv;
    };

    struct Volt : public concepts::UnitBase {
      static constexpr auto symbol = "V"sv;
      static constexpr auto name = "volt"sv;
    };

  } // namespace units

  // -- BEGIN Charge -----------------------------------------------------------

  template <typename R, typename T = double>
  using scaled_coulomb = concepts::scaled_quantity<units::Coulomb, R, T>;

  //
  // coulomb
  //
  template <typename T = double>
  using coulomb_as = scaled_coulomb<std::ratio<1>, T>;

  using coulomb = coulomb_as<>;

  //
  // millicoulomb
  //
  template <typename T = double>
  using millicoulomb_as = concepts::rescale<coulomb_as<T>, std::milli>;

  using millicoulomb = millicoulomb_as<>;

  //
  // microcoulomb
  //
  template <typename T = double>
  using microcoulomb_as = concepts::rescale<coulomb_as<T>, std::micro>;

  using microcoulomb = microcoulomb_as<>;

  //
  // nanocoulomb
  //
  template <typename T = double>
  using nanocoulomb_as = concepts::rescale<coulomb_as<T>, std::nano>;

  using nanocoulomb = nanocoulomb_as<>;

  //
  // picocoulomb
  //
  template <typename T = double>
  using picocoulomb_as = concepts::rescale<coulomb_as<T>, std::pico>;

  using picocoulomb = picocoulomb_as<>;

  //
  // femtocoulomb
  //
  template <typename T = double>
  using femtocoulomb_as = concepts::rescale<coulomb_as<T>, std::femto>;

  using femtocoulomb = femtocoulomb_as<>;

  // -- END Charge -------------------------------------------------------------

  // -- BEGIN Electric potential -----------------------------------------------

  template <typename R, typename T = double>
  using scaled_volt = concepts::scaled_quantity<units::Volt, R, T>;

  //
  // volt
  //
  template <typename T = double>
  using volt_as = scaled_volt<std::ratio<1>, T>;

  using volt = volt_as<>;

  //
  // millivolt
  //
  template <typename T = double>
  using millivolt_as = concepts::rescale<volt_as<T>, std::milli>;

  using millivolt = millivolt_as<>;

  //
  // microvolt
  //
  template <typename T = double>
  using microvolt_as = concepts::rescale<volt_as<T>, std::micro>;

  using microvolt = microvolt_as<>;

  //
  // kilovolt
  //
  template <typename T = double>
  using kilovolt_as = concepts::rescale<volt_as<T>, std::kilo>;

  using kilovolt = kilovolt_as<>;

  //
  // megavolt
  //
  template <typename T = double>
  using megavolt_as = concepts::rescale<volt_as<T>, std::mega>;

  using megavolt = megavolt_as<>;

  //
  // gigavolt
  //
  template <typename T = double>
  using gigavolt_as = concepts::rescale<volt_as<T>, std::giga>;

  using gigavolt = gigavolt_as<>;

  // -- END Electric potential -------------------------------------------------

  namespace electromagnetism_literals {

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

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

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

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

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

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

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

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

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

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

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

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

  } // electromagnetism_literals

} // namespace util::quantities

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

#endif // LARDATAALG_UTILITIES_QUANTITIES_ELECTROMAGNETISM_H