KVUnits.h

#ifndef KVUNITS__H
#define KVUNITS__H
 
#include <Rtypes.h>
 
namespace kaliveda
{
   namespace units
   {
      const long double cm = 1.0l;
      const long double fm = 1.e-13l;
      const long double um = 1.e-4l;
      const long double mm = 1.e-1l;
      const long double m = 1.e+2l;
      const long double g = 1.0l;
      const long double kg = 1.e+3l;
      const long double mg = 1.e-3l;
      const long double ug = 1.e-6l;
      const long double MeVpc2 = 1.782662e-27l;
      const long double torr = 1.0l;
      const long double atm = 760.l;
      const long double Pa = atm / 101325.l;
      const long double mbar = 100.l * Pa;
      const long double cc = 1.0l;
      const long double litre = 1.e+3l;
      const long double cl = 10.l * cc;
      const long double ml = cc;
      const long double MeV = 1.0l;
      const long double GeV = 1.e+3l;
      const long double keV = 1.e-3l;
      const long double eV = 1.e-6l;
      const long double Joule = 6.241509e+12l;
      const long double fmpc = 1.0l;
      const long double s = 2.997925e+23l;
      const long double nucpfm3 = 1.0l;
      const long double gpcm3 = 6.022141e-16;   // 1./(KVNucleus::kAMU*KVUnits::MeVpc2/TMath::Power(KVUnits::fm,3.))
      const long double MeVpkb = 1.0l;
      const long double GK = 8.617331e-02;
 
      struct unit
      {
         std::string name;
         long double multiplier=1.0l;// conversion factor compared to some reference unit
 
         operator long double() const { return multiplier; }
      };
   }
#define add_unit(name,base)\
   struct name##_ : base\
   {\
      name##_() : base{#name,units::name} {}\
   };\
   const name##_ name = name##_()
 
   namespace energy_units
   {
      struct energy_unit : units::unit {};
      add_unit(eV,energy_unit);
      add_unit(keV,energy_unit);
      add_unit(MeV,energy_unit);
      add_unit(GeV,energy_unit);
   }
   namespace length_units
   {
      struct length_unit : units::unit {};
      add_unit(cm,length_unit);
      add_unit(fm,length_unit);
      add_unit(mm,length_unit);
      add_unit(um,length_unit);
      add_unit(m,length_unit);
   }
   namespace dimensioned_types
   {
      template<class Type, class BaseUnit, class DefaultUnit>
      struct dimensioned_type
      {
          DefaultUnit default_units = DefaultUnit{};
          Type val;
 
          dimensioned_type(const Type& t) : default_units{}, val{t} {}
          dimensioned_type(const Type& t, const BaseUnit& U)
          : default_units{}, val{t*U.multiplier/default_units.multiplier}
          {}
          dimensioned_type() = default;
          dimensioned_type(const dimensioned_type&) = default;
          dimensioned_type(dimensioned_type&&) = default;
          dimensioned_type& operator=(const dimensioned_type&) = default;
          dimensioned_type& operator=(dimensioned_type&&) = default;
          operator Type() const { return val; }
          Type operator()() const { return val; }
          template<class NewUnit>
          Type in(const NewUnit& u) const { return val/u.multiplier; }
          template<class NewUnit>
          Type as(const NewUnit& u) const { return in(u); }
          template<class NewUnit>
          Type convert(const NewUnit& u) const { return in(u); }
 
          friend std::ostream& operator<< (std::ostream& os, const dimensioned_type& ar)
          {
              os << (Type)ar << " " << ar.default_units.name;
              return os;
          }
      };
      struct Energy : dimensioned_type<long double,
            kaliveda::energy_units::energy_unit,
            kaliveda::energy_units::MeV_>
      {
         using dimensioned_type::dimensioned_type;
 
         friend Energy operator+(const Energy& a, const Energy& b)
         {
            return a()+b();
         }
         friend Energy operator-(const Energy& a, const Energy& b)
         {
            return a()-b();
         }
      };
 
      Energy operator""_keV(long double);
      Energy operator""_GeV(long double);
      Energy operator""_eV(long double);
      Energy operator""_MeV(long double);
 
   }
}
 
namespace KVUnits = kaliveda::units;
 
using namespace kaliveda::dimensioned_types;
 
#endif