TRestSystemOfUnits.h

 
 
#ifndef RestCore_TRestSystemOfUnits
#define RestCore_TRestSystemOfUnits
 
#include <TMath.h>
#include <TString.h>
#include <TVector2.h>
#include <TVector3.h>
 
#include <iostream>
#include <map>
#include <string>
 
#ifdef REST_UnitsAdd_Caller
#define AddUnit(name, type, scale) double name = _AddUnit(#name, type, scale)
#else
#define AddUnit(name, type, scale) constexpr double name = scale
#endif
 
namespace REST_Units {
 
// We use more common physics units instead of SI unit
enum Physical_Unit { Energy, Time, Length, Mass, Voltage, MagneticField, Pressure, Angle, NOT_A_UNIT = -1 };
 
class TRestSystemOfUnits {
   private:
    // stores a list of base units for composite units
    std::vector<int> fComponents;
    // stores a list of units order for composite units
    std::vector<double> fComponentOrder;
 
    Bool_t fZombie;
 
    double fScaleCombined;
 
    int GetUnitType(std::string singleUnit);
    double GetUnitScale(std::string singleUnit);
 
   public:
    TRestSystemOfUnits(std::string unitsStr);
    bool IsZombie() const { return fZombie; }
    std::string ToStandardDefinition();
 
    friend Double_t operator*(const Double_t& val, const TRestSystemOfUnits& units) {
        if (units.fZombie) return val;
        return val * units.fScaleCombined;
    }
 
    friend Double_t operator/(const Double_t& val, const TRestSystemOfUnits& units) {
        if (units.fZombie) return val;
        return val / units.fScaleCombined;
    }
};
 
bool IsBasicUnit(std::string in);
bool IsUnit(std::string in);
 
double GetScaleToStandardUnit(std::string unitsdef);
std::string GetStandardUnitDefinition(std::string unitsdef);
std::string FindRESTUnitsInString(std::string InString);
std::string RemoveUnitsFromString(std::string s);
Double_t ConvertValueToRESTUnits(Double_t value, std::string unitsStr);
Double_t ConvertRESTUnitsValueToCustomUnits(Double_t value, std::string unitsStr);
 
Double_t GetDblValueInString(std::string in);
TVector2 Get2DVectorValueInString(std::string in);
TVector3 Get3DVectorValueInString(std::string in);
 
Double_t GetValueInRESTUnits(std::string in);
Double_t GetDblValueInRESTUnits(std::string in);
TVector2 Get2DVectorInRESTUnits(std::string in);
TVector3 Get3DVectorInRESTUnits(std::string in);
 
double _AddUnit(std::string name, int type, double scale);
 
// energy unit multiplier
AddUnit(meV, REST_Units::Energy, 1e6);
AddUnit(eV, REST_Units::Energy, 1e3);
AddUnit(keV, REST_Units::Energy, 1);
AddUnit(MeV, REST_Units::Energy, 1e-3);
AddUnit(GeV, REST_Units::Energy, 1e-6);
AddUnit(J, REST_Units::Energy, 1.60e-19);
AddUnit(kJ, REST_Units::Energy, 1.60e-22);
 
// time unit multiplier
AddUnit(ns, REST_Units::Time, 1.e3);
AddUnit(us, REST_Units::Time, 1.);
AddUnit(ms, REST_Units::Time, 1.e-3);
AddUnit(s, REST_Units::Time, 1.e-6);
AddUnit(Hz, REST_Units::Time, 1.e6);
AddUnit(minu, REST_Units::Time, 1.67e-8);
AddUnit(hr, REST_Units::Time, 2.78e-10);
AddUnit(day, REST_Units::Time, 1.16e-11);
AddUnit(mon, REST_Units::Time, 3.85e-13);
AddUnit(yr, REST_Units::Time, 3.17e-14);
 
// length unit multiplier
AddUnit(nm, REST_Units::Length, 1e6);
AddUnit(um, REST_Units::Length, 1e3);
AddUnit(mm, REST_Units::Length, 1.);
AddUnit(cm, REST_Units::Length, 1e-1);
AddUnit(m, REST_Units::Length, 1e-3);
 
// mass unit multiplier
AddUnit(mg, REST_Units::Mass, 1e6);
AddUnit(gram, REST_Units::Mass, 1e3);
AddUnit(g, REST_Units::Mass, 1e3);
AddUnit(kg, REST_Units::Mass, 1.);
AddUnit(ton, REST_Units::Mass, 1e-3);
 
// voltage unit multiplier
AddUnit(mV, REST_Units::Voltage, 1.e3);
AddUnit(V, REST_Units::Voltage, 1.);
AddUnit(kV, REST_Units::Voltage, 1.e-3);
 
// magnetic field unit multiplier
AddUnit(mT, REST_Units::MagneticField, 1.e3);
AddUnit(T, REST_Units::MagneticField, 1.);
AddUnit(G, REST_Units::MagneticField, 1.e4);
 
// pressure field unit multiplier
AddUnit(bar, REST_Units::Pressure, 1.);
AddUnit(mbar, REST_Units::Pressure, 1.e3);
AddUnit(atm, REST_Units::Pressure, 1.013);
AddUnit(torr, REST_Units::Pressure, 760);
AddUnit(MPa, REST_Units::Pressure, 0.101325);
AddUnit(kPa, REST_Units::Pressure, 101.325);
AddUnit(Pa, REST_Units::Pressure, 101325);
AddUnit(mPa, REST_Units::Pressure, 10132500);
 
// angle unit multiplier
AddUnit(rad, REST_Units::Angle, 1.);
AddUnit(radian, REST_Units::Angle, 1.);
AddUnit(radians, REST_Units::Angle, 1.);
AddUnit(deg, REST_Units::Angle, TMath::RadToDeg());
AddUnit(degree, REST_Units::Angle, TMath::RadToDeg());
AddUnit(degrees, REST_Units::Angle, TMath::RadToDeg());
AddUnit(arcmin, REST_Units::Angle, TMath::RadToDeg() * 60.);
AddUnit(arcsec, REST_Units::Angle, TMath::RadToDeg() * 3600.);
}  // namespace REST_Units
 
typedef REST_Units::TRestSystemOfUnits units;
 
#endif