UnitHandler.h

Go to the documentation of this file.

/* Copyright 2016 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef COM_DAFER45_TBTK_UNIT_HANDLER
#define COM_DAFER45_TBTK_UNIT_HANDLER

#include <string>
#include <math.h>

#ifdef M_E  //Avoid name clash with math.h macro M_E
    #define M_E_temp M_E
    #undef M_E
#endif

namespace TBTK{

class UnitHandler{
public:
    enum class TemperatureUnit {kK, K, mK, uK, nK};

    /* Time units (base unit):<br/>
     *  s - second<br/>
     *  ms - millisecond<br/>
     *  us - microsecond<br/>
     *  ns - nanosecond<br/>
     *  ps - picosecond<br/>
     *  fs - femtosecond<br/>
     *  as - attosecond */
    enum class TimeUnit {s, ms, us, ns, ps, fs, as};

    enum class LengthUnit{m, mm, um, nm, pm, fm, am, Ao};

    enum class EnergyUnit{GeV, MeV, keV, eV, meV, ueV, J};

    enum class ChargeUnit{
        kC, C, mC, uC, nC, pC, fC, aC, Te, Ge, Me, ke, e
    };

    enum class CountUnit{pcs, mol};

    enum class MassUnit{kg, g, mg, ug, ng, pg, fg, ag, u};

    enum class MagneticFieldUnit{
        MT, kT, T, mT, uT, nT, GG, MG, kG, G, mG, uG
    };

    static double getHbarB();

    static double getHbarN();

    static double getK_bB();

    static double getK_bN();

    static double getEB();

    static double getEN();

    static double getCB();

    static double getCN();

    static double getN_aB();

    static double getN_aN();

    static double getM_eB();

    static double getM_eN();

    static double getM_pB();

    static double getM_pN();

    static double getMu_bB();

    static double getMu_bN();

    static double getMu_nB();

    static double getMu_nN();

    static double getMu_0B();

    static double getMu_0N();

    static double getEpsilon_0B();

    static double getEpsilon_0N();

    static void setTemperatureUnit(TemperatureUnit unit);

    static void setTimeUnit(TimeUnit unit);

    static void setLengthUnit(LengthUnit unit);

    static void setEnergyUnit(EnergyUnit unit);

    static void setChargeUnit(ChargeUnit unit);

    static void setCountUnit(CountUnit unit);

    static void setTemperatureScale(double scale);

    static void setTimeScale(double scale);

    static void setLengthScale(double scale);

    static void setEnergyScale(double scale);

    static void setChargeScale(double scale);

    static void setCountScale(double scale);

    static double convertTemperatureNtB(double temperature);

    static double convertTimeNtB(double time);

    static double convertLengthNtB(double length);

    static double convertEnergyNtB(double energy);

    static double convertChargeNtB(double charge);

    static double convertCountNtB(double count);

    static double convertTemperatureBtN(double temperature);

    static double convertTimeBtN(double time);

    static double convertLengthBtN(double length);

    static double convertEnergyBtN(double energy);

    static double convertChargeBtN(double charge);

    static double convertCountBtN(double count);

    static double convertMassDtB(double mass, MassUnit unit);

    static double convertMassBtD(double mass, MassUnit unit);

    static double convertMassDtN(double mass, MassUnit unit);

    static double convertMassNtD(double mass, MassUnit unit);

    static double convertMagneticFieldDtB(
        double field,
        MagneticFieldUnit unit
    );

    static double convertMagneticFieldBtD(
        double field,
        MagneticFieldUnit unit
    );

    static double convertMagneticFieldDtN(
        double field,
        MagneticFieldUnit unit
    );

    static double convertMagneticFieldNtD(
        double field,
        MagneticFieldUnit unit
    );

    static std::string getTemperatureUnitString();

    static std::string getTimeUnitString();

    static std::string getLengthUnitString();

    static std::string getEnergyUnitString();

    static std::string getChargeUnitString();

    static std::string getCountUnitString();

    static std::string getMassUnitString();

    static std::string getMagneticFieldUnitString();

    static std::string getHBARUnitString();

    static std::string getK_BUnitString();

    static std::string getEUnitString();

    static std::string getCUnitString();

    static std::string getN_aUnitString();

    static std::string getM_eUnitString();

    static std::string getM_pUnitString();

    static std::string getMu_bUnitString();

    static std::string getMu_nUnitString();

    static std::string getMu_0UnitString();

    static std::string getEpsilon_0UnitString();
private:
    static constexpr double HBAR    = 6.582119514e-16;

    static constexpr double K_B = 8.6173324e-5;

    static constexpr double E   = 1.6021766208e-19;

    static constexpr double C   = 2.99792458e8;

    static constexpr double N_A = 6.022140857e23;

    static constexpr double M_E = 5.109989461e5/(C*C);

    static constexpr double M_P = 9.38272046e8/(C*C);

    static constexpr double MU_B    = E*HBAR/(2.*M_E);

    static constexpr double MU_N    = E*HBAR/(2*M_P);

    static constexpr double MU_0 = 4*M_PI*1e-7/1.602176565e-19;

    static constexpr double EPSILON_0 = 8.854187817620e-12*1.602176565e-19;

    static double hbar;

    static double k_b;

    static double e;

    static double c;

    static double n_a;

    static double m_e;

    static double m_p;

    static double mu_b;

    static double mu_n;

    static double mu_0;

    static double epsilon_0;

    static constexpr double J_per_eV    = 1.602176565e-19;

    static constexpr double eV_per_J    = 1./J_per_eV;

    static constexpr double kg_per_baseMass = 1.602176565e-19;

    static constexpr double baseMass_per_kg = 1./kg_per_baseMass;

    static constexpr double u_per_baseMass = 9.31494095e8/(C*C);

    static constexpr double baseMass_per_u = 1./u_per_baseMass;

    static constexpr double T_per_baseMagneticField = 1.602176565e-19;

    static constexpr double baseMagneticField_per_T = 1./T_per_baseMagneticField;

    static TemperatureUnit temperatureUnit;

    static TimeUnit timeUnit;

    static LengthUnit lengthUnit;

    static EnergyUnit energyUnit;

    static ChargeUnit chargeUnit;

    static CountUnit countUnit;

    static double temperatureScale;

    static double timeScale;

    static double lengthScale;

    static double energyScale;

    static double chargeScale;

    static double countScale;

    static void updateHbar();

    static void updateK_b();

    static void updateE();

    static void updateC();

    static void updateN_a();

    static void updateM_e();

    static void updateM_p();

    static void updateMu_b();

    static void updateMu_n();

    static void updateMu_0();

    static void updateEpsilon_0();

    static double getTemperatureConversionFactor();

    static double getTimeConversionFactor();

    static double getLengthConversionFactor();

    static double getEnergyConversionFactor();

    static double getChargeConversionFactor();

    static double getCountConversionFactor();

    static double getMassConversionFactor(MassUnit unit);

    static double getMagneticFieldConversionFactor(MagneticFieldUnit unit);
};

inline double UnitHandler::getHbarB(){
    return hbar;
}

inline double UnitHandler::getHbarN(){
    return hbar/(energyScale*timeScale);
}

inline double UnitHandler::getK_bB(){
    return k_b;
}

inline double UnitHandler::getK_bN(){
    return k_b*temperatureScale/energyScale;
}

inline double UnitHandler::getEB(){
    return e;
}

inline double UnitHandler::getEN(){
    return e/chargeScale;
}

inline double UnitHandler::getCB(){
    return c;
}

inline double UnitHandler::getCN(){
    return c*timeScale/lengthScale;
}

inline double UnitHandler::getN_aB(){
    return n_a;
}

inline double UnitHandler::getN_aN(){
    return n_a/countScale;
}

inline double UnitHandler::getM_eB(){
    return m_e;
}

inline double UnitHandler::getM_eN(){
    return m_e*lengthScale*lengthScale/(energyScale*timeScale*timeScale);
}

inline double UnitHandler::getM_pB(){
    return m_p;
}

inline double UnitHandler::getM_pN(){
    return m_p*lengthScale*lengthScale/(energyScale*timeScale*timeScale);
}

inline double UnitHandler::getMu_bB(){
    return mu_b;
}

inline double UnitHandler::getMu_bN(){
    return mu_b*timeScale/(chargeScale*lengthScale*lengthScale);
}

inline double UnitHandler::getMu_nB(){
    return mu_n;
}

inline double UnitHandler::getMu_nN(){
    return mu_n*timeScale/(chargeScale*lengthScale*lengthScale);
}

inline double UnitHandler::getMu_0B(){
    return mu_0;
}

inline double UnitHandler::getMu_0N(){
    return mu_0*chargeScale*chargeScale*lengthScale/(energyScale*timeScale*timeScale);
}

inline double UnitHandler::getEpsilon_0B(){
    return epsilon_0;
}

inline double UnitHandler::getEpsilon_0N(){
    return epsilon_0*energyScale*lengthScale/(chargeScale*chargeScale);
}

inline double UnitHandler::convertTemperatureNtB(double temperature){
    return temperature*temperatureScale;
}

inline double UnitHandler::convertTimeNtB(double time){
    return time*timeScale;
}

inline double UnitHandler::convertLengthNtB(double length){
    return length*lengthScale;
}

inline double UnitHandler::convertEnergyNtB(double energy){
    return energy*energyScale;
}

inline double UnitHandler::convertChargeNtB(double charge){
    return charge*chargeScale;
}

inline double UnitHandler::convertCountNtB(double count){
    return count*countScale;
}

inline double UnitHandler::convertTemperatureBtN(double temperature){
    return temperature/temperatureScale;
}

inline double UnitHandler::convertTimeBtN(double time){
    return time/timeScale;
}

inline double UnitHandler::convertLengthBtN(double length){
    return length/lengthScale;
}

inline double UnitHandler::convertEnergyBtN(double energy){
    return energy/energyScale;
}

inline double UnitHandler::convertChargeBtN(double charge){
    return charge/chargeScale;
}

inline double UnitHandler::convertCountBtN(double count){
    return count/countScale;
}

};

#ifdef M_E_temp //Avoid name clash with math.h macro M_E
    #define M_E M_E_temp
    #undef M_E_temp
#endif

#endif