constants.h

Go to the documentation of this file.

/* Copyright (C) 2019
 * Richard Larsson <ric.larsson@gmail.com>
 * 
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA. */
 
#ifndef CONSTANTS_IN_ARTS_H
#define CONSTANTS_IN_ARTS_H
 
#include "enums.h"
#include "matpack.h"
#include <cmath>
 
namespace Constant {
template <class T>
constexpr auto pow2(T x) -> decltype(x * x) {
  return x * x;
}
 
template <class T>
constexpr auto pow3(T x) -> decltype(pow2(x) * x) {
  return pow2(x) * x;
}
 
template <class T>
constexpr auto pow4(T x) -> decltype(pow2(pow2(x))) {
  return pow2(pow2(x));
}
 
static constexpr Numeric pi =
    3.141592653589793238462643383279502884197169399375105820974944592307816406286;
 
static constexpr Numeric inv_pi =
    0.3183098861837906715377675267450287240689192914809128974953346881177935952685;
 
static constexpr Numeric two_pi =
    6.283185307179586476925286766559005768394338798750211641949889184615632812572;
 
static constexpr Numeric inv_two_pi =
    0.1591549430918953357688837633725143620344596457404564487476673440588967976342;
 
static constexpr Numeric sqrt_pi =
    1.772453850905516027298167483341145182797549456122387128213807789852911284591;
 
static constexpr Numeric inv_sqrt_pi =
    0.5641895835477562869480794515607725858440506293289988568440857217106424684415;
 
static constexpr Numeric euler =
    2.718281828459045235360287471352662497757247093699959574966967627724076630354;
 
static constexpr Numeric inv_euler =
    0.3678794411714423215955237701614608674458111310317678345078368016974614957448;
 
static constexpr Numeric log10_euler =
    0.4342944819032518276511289189166050822943970058036665661144537831658646492089;
 
static constexpr Numeric ln_10 =
    2.302585092994045684017991454684364207601101488628772976033327900967572609677;
 
static constexpr Numeric sqrt_2 =
    1.414213562373095048801688724209698078569671875376948073176679737990732478462;
 
static constexpr Numeric inv_sqrt_2 =
    0.7071067811865475244008443621048490392848359376884740365883398689953662392311;
 
static constexpr Numeric ln_2 =
    0.6931471805599453094172321214581765680755001343602552541206800094933936219697;
 
static constexpr Numeric inv_ln_2 =
    1.442695040888963407359924681001892137426645954152985934135449406931109219181;
 
static constexpr Numeric sqrt_ln_2 =
    0.8325546111576977563531646448952010476305888522644407291668291172340794351973;
 
static constexpr Numeric inv_sqrt_ln_2 =
    1.201122408786449794857803286095221722566764028068699423868879896733837175546;
 
static constexpr Numeric Delta_nu_Cs = 9192631770;
 
static constexpr Numeric speed_of_light = 299792458;
 
static constexpr Numeric c = speed_of_light;
 
static constexpr Numeric planck_constant = 6.62607015e-34;
 
static constexpr Numeric h = planck_constant;
 
static constexpr Numeric reduced_planck_constant = h * inv_two_pi;
 
static constexpr Numeric h_bar = reduced_planck_constant;
 
static constexpr Numeric elementary_charge = 1.602176634e-19;
 
static constexpr Numeric e = elementary_charge;
 
static constexpr Numeric boltzmann_constant = 1.380649e-23;
 
static constexpr Numeric k = boltzmann_constant;
 
static constexpr Numeric avogadro_constant = 6.02214076e23;
 
static constexpr Numeric NA = avogadro_constant;
 
static constexpr Numeric K_cd = 683;
 
static constexpr Numeric fine_structure_constant = 7.2973525693e-3;
 
static constexpr Numeric alpha = fine_structure_constant;
 
static constexpr Numeric rydberg_constant = 10973731.568160;
 
static constexpr Numeric R_inf = rydberg_constant;
 
static constexpr Numeric magnetic_constant = 2 * h * alpha / (c * pow2(e));
 
static constexpr Numeric mu_0 = magnetic_constant;
 
static constexpr Numeric vacuum_permittivity = pow2(e) / (2 * h * c * alpha);
 
static constexpr Numeric epsilon_0 = vacuum_permittivity;
 
static constexpr Numeric electron_mass = 2 * h * R_inf / (c * pow2(alpha));
 
static constexpr Numeric m_e = electron_mass;
 
static constexpr Numeric unified_atomic_mass_unit = 1.66053906660e-27;
 
static constexpr Numeric m_u = unified_atomic_mass_unit;
 
static constexpr Numeric mass_ratio_electrons_per_proton = 1'836.152'673'43;
 
static constexpr Numeric proton_mass = electron_mass * mass_ratio_electrons_per_proton;
 
static constexpr Numeric mass_ratio_electrons_per_neutron = 1'838.683'661'73;
 
static constexpr Numeric neutron_mass = electron_mass * mass_ratio_electrons_per_neutron;
 
static constexpr Numeric bohr_magneton = e * h_bar / (2 * m_e);
 
static constexpr Numeric ideal_gas_constant = k * NA;
 
static constexpr Numeric R = ideal_gas_constant;
 
static constexpr Numeric doppler_broadening_const_squared = 2'000 * R / pow2(c);
 
static constexpr Numeric one_degree_in_radians = pi / 180;
};  // namespace Constant
 
namespace Conversion {
using namespace Constant;
 
template <class T>
constexpr auto deg2rad(T x) -> decltype(x * one_degree_in_radians) {
  return x * one_degree_in_radians;
}
 
template <class T>
constexpr auto rad2deg(T x) -> decltype(x / one_degree_in_radians) {
  return x / one_degree_in_radians;
}
 
template <class T>
auto cosd(T x) -> decltype(std::cos(deg2rad(x))) {
  return std::cos(deg2rad(x));
}
 
template <class T>
auto sind(T x) -> decltype(std::sin(deg2rad(x))) {
  return std::sin(deg2rad(x));
}
 
template <class T>
auto tand(T x) -> decltype(std::tan(deg2rad(x)))  {
  return std::tan(deg2rad(x));
}
 
template <class T>
auto acosd(T x) -> decltype(rad2deg(std::acos(x))) {
  return rad2deg(std::acos(x));
}
 
template <class T>
auto asind(T x) -> decltype(rad2deg(std::asin(x))) {
  return rad2deg(std::asin(x));
}
 
template <class T>
auto atand(T x) -> decltype(rad2deg(std::atan(x)))  {
  return rad2deg(std::atan(x));
}
 
template <class T1, class T2>
auto atan2d(T1 y, T2 x) -> decltype(rad2deg(std::atan2(y, x))) {
  return rad2deg(std::atan2(y, x));
}
 
template <class T>
constexpr auto kaycm2freq(T x) -> decltype(x * (100 * c)) {
  return x * (100 * c);
}
 
template <class T>
constexpr auto freq2kaycm(T x) -> decltype(x / (100 * c)) {
  return x / (100 * c);
}
 
template <class T>
constexpr auto angcm2freq(T x) -> decltype(kaycm2freq(inv_two_pi)) {
  return x * kaycm2freq(inv_two_pi);
}
 
template <class T>
constexpr auto freq2angcm(T x) -> decltype(x / kaycm2freq(inv_two_pi)) {
  return x / kaycm2freq(inv_two_pi);
}
 
template <class T>
constexpr auto angfreq2freq(T x) -> decltype(x * inv_two_pi) {
  return x * inv_two_pi;
}
 
template <class T>
constexpr auto freq2angfreq(T x) -> decltype(x * two_pi) {
  return x * two_pi;
}
 
template <class T>
constexpr auto wavelen2freq(T x) -> decltype(c / x) {
  return c / x;
}
 
template <class T>
constexpr auto freq2wavelen(T x) -> decltype(c / x) {
  return c / x;
}
 
template <class T>
constexpr auto atm2pa(T x) -> decltype(x * 101'325.0) {
  return x * 101'325.0;
}
 
template <class T>
constexpr auto pa2atm(T x) -> decltype(x / 101'325.0) {
  return x / 101'325.0;
}
 
template <class T>
constexpr auto torr2pa(T x) -> decltype(x * atm2pa(1.0 / 760.0)) {
  return x * atm2pa(1.0 / 760.0);
}
 
template <class T>
constexpr auto pa2torr(T x) -> decltype(x / atm2pa(1.0 / 760.0)) {
  return x / atm2pa(1.0 / 760.0);
}
 
template <class T>
constexpr auto mhz_per_torr2hz_per_pa(T x) -> decltype(x * pa2torr(1e6)) {
  return x * pa2torr(1e6);
}
 
template <class T>
constexpr auto celsius2kelvin(T x) -> decltype(x + 273.15) {
  return x + 273.15;
}
 
template <class T>
constexpr auto kelvin2celsius(T x) -> decltype(x - 273.15) {
  return x - 273.15;
}
 
template <class T>
constexpr auto kaycm_per_cmsquared2hz_per_msquared(T x) -> decltype(x * kaycm2freq(1e-4)) {
  return x * kaycm2freq(1e-4);
}
 
template <class T>
constexpr auto hz_per_msquared2kaycm_per_cmsquared(T x) -> decltype(x * freq2kaycm(1e4)) {
  return x * freq2kaycm(1e4);
}
 
template <class T>
constexpr auto kaycm_per_atm2hz_per_pa(T x) -> decltype(x * kaycm2freq(pa2atm(1))) {
  return x * kaycm2freq(pa2atm(1));
}
 
template <class T>
constexpr auto hz_per_pa2kaycm_per_atm(T x) -> decltype(x * freq2kaycm(atm2pa(1))) {
  return x * freq2kaycm(atm2pa(1));
}
 
template <class T>
constexpr auto kaycm2joule(T x) -> decltype(x * kaycm2freq(h)) {
  return x * kaycm2freq(h);
}
 
template <class T>
constexpr auto hz2joule(T x) -> decltype(x * h) {
  return x * h;
}
 
template <class T>
constexpr auto mhz2joule(T x) -> decltype(hz2joule(x) * 1e6) {
  return hz2joule(x) * 1e6;
}
 
template <class T>
constexpr auto kelvin2joule(T x) -> decltype(x * k) {
  return x * k;
}
 
template <class T>
constexpr auto joule2hz(T x) -> decltype(x / h) {
  return x / h;
}
 
template <class T>
constexpr auto joule2kaycm(T x) -> decltype(x / kaycm2freq(h)) {
  return x / kaycm2freq(h);
}
 
template <class T>
constexpr auto angstrom2meter(T x) -> decltype(x * 1e-10) {
  return x * 1e-10;
}
 
template <class T>
constexpr auto meter2angstrom(T x) -> decltype(x * 1e10) {
  return x * 1e10;
}
};  // namespace Conversion
 
namespace Options {
  ENUMCLASS(TimeStep, char,
            hour, hours, h,
            minute, minutes, min,
            second, seconds, s)
  
  
  ENUMCLASS(LineShapeCoeff, char,
            X0,
            X1,
            X2,
            X3)
  
  ENUMCLASS(WindMagJacobian, char,
            u, v, w, strength)
  
  ENUMCLASS(BasicCatParamJacobian, char,
            LineStrength,
            LineCenter)
  
  ENUMCLASS(HitranType, char,
            Pre2004,  // 2004 version changed the .par-length
            From2004To2012, // New par length but old isotopologues order
            Post2012, // 2012 version changed the order of isotopologues
            Online    // Onine expects a modern .par line followed by Upper then Lower quantum numbers
  )
  
  ENUMCLASS(LblSpeedup, char,
            None,
            QuadraticIndependent,
            LinearIndependent)
} // namespace Options
 
#endif