energy.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_QUANTITIES_ENERGY_H
#define LARDATAALG_UTILITIES_QUANTITIES_ENERGY_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 ElectronVolt : public concepts::UnitBase {
      static constexpr auto symbol = "eV"sv;
      static constexpr auto name = "electronvolt"sv;
    };

  } // namespace units

  // -- BEGIN Particle energy --------------------------------------------------

  template <typename R, typename T = double>
  using scaled_electronvolt = concepts::scaled_quantity<units::ElectronVolt, R, T>;

  //
  // electronvolt
  //
  template <typename T = double>
  using electronvolt_as = scaled_electronvolt<std::ratio<1>, T>;

  using electronvolt = electronvolt_as<>;

  //
  // microelectronvolt
  //
  template <typename T = double>
  using microelectronvolt_as = concepts::rescale<electronvolt_as<T>, std::micro>;

  using microelectronvolt = microelectronvolt_as<>;

  //
  // millielectronvolt
  //
  template <typename T = double>
  using millielectronvolt_as = concepts::rescale<electronvolt_as<T>, std::milli>;

  using millielectronvolt = millielectronvolt_as<>;

  //
  // kiloelectronvolt
  //
  template <typename T = double>
  using kiloelectronvolt_as = concepts::rescale<electronvolt_as<T>, std::kilo>;

  using kiloelectronvolt = kiloelectronvolt_as<>;

  //
  // megaelectronvolt
  //
  template <typename T = double>
  using megaelectronvolt_as = concepts::rescale<electronvolt_as<T>, std::mega>;

  using megaelectronvolt = megaelectronvolt_as<>;

  //
  // gigaelectronvolt
  //
  template <typename T = double>
  using gigaelectronvolt_as = concepts::rescale<electronvolt_as<T>, std::giga>;

  using gigaelectronvolt = gigaelectronvolt_as<>;

  //
  // teraelectronvolt
  //
  template <typename T = double>
  using teraelectronvolt_as = concepts::rescale<electronvolt_as<T>, std::tera>;

  using teraelectronvolt = teraelectronvolt_as<>;

  // -- END Particle energy ----------------------------------------------------

  namespace energy_literals {

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

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

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

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

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

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

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

  } // energy_literals

} // namespace util::quantities

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

#endif // LARDATAALG_UTILITIES_QUANTITIES_ENERGY_H