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 "TBTK/TBTK.h"
#include "TBTK/Quantity/Constant.h"
#include "TBTK/Quantity/Derived.h"
#include "TBTK/TBTKMacros.h"

#include <cmath>
#include <map>
#include <string>
#include <utility>
#include <vector>

#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:
    static double getConstantInBaseUnits(const std::string &name);

    static double getConstantInNaturalUnits(const std::string &name);

    static void setScales(const std::vector<std::string> &scales);

    template<typename Quantity>
    static double convertNaturalToBase(double value);

    template<typename Quantity>
    static double convertBaseToNatural(double value);

    template<typename Quantity>
    static typename std::enable_if<
        Quantity::IsBaseQuantity::value,
        double
    >::type convertArbitraryToBase(
        double value,
        typename Quantity::Unit unit
    );
    template<typename Quantity>
    static typename std::enable_if<
        !Quantity::IsBaseQuantity::value,
        double
    >::type convertArbitraryToBase(
        double value,
        typename Quantity::Unit unit
    );
    template<typename Quantity>
    static typename std::enable_if<
        Quantity::IsBaseQuantity::value,
        double
    >::type convertBaseToArbitrary(
        double value,
        typename Quantity::Unit unit
    );
    template<typename Quantity>
    static typename std::enable_if<
        !Quantity::IsBaseQuantity::value,
        double
    >::type convertBaseToArbitrary(
        double value,
        typename Quantity::Unit unit
    );
    template<typename Quantity>
    static typename std::enable_if<
        Quantity::IsBaseQuantity::value,
        double
    >::type convertArbitraryToNatural(
        double value,
        typename Quantity::Unit unit
    );
    template<typename Quantity>
    static typename std::enable_if<
        !Quantity::IsBaseQuantity::value,
        double
    >::type convertArbitraryToNatural(
        double value,
        typename Quantity::Unit unit
    );
    template<typename Quantity>
    static typename std::enable_if<
        Quantity::IsBaseQuantity::value,
        double
    >::type convertNaturalToArbitrary(
        double value,
        typename Quantity::Unit unit
    );
    template<typename Quantity>
    static typename std::enable_if<
        !Quantity::IsBaseQuantity::value,
        double
    >::type convertNaturalToArbitrary(
        double value,
        typename Quantity::Unit unit
    );
    template<typename Quantity>
    static typename std::enable_if<
        Quantity::IsBaseQuantity::value,
        std::string
    >::type getUnitString();
    template<typename Quantity>
    static typename std::enable_if<
        !Quantity::IsBaseQuantity::value,
        std::string
    >::type getUnitString();
    static std::string getUnitString(const std::string &constantName);
private:
    static std::map<
        std::string,
        Quantity::Constant
    > constantsDefaultUnits;

    static std::map<std::string, double> constantsBaseUnits;

    static std::tuple<
        Quantity::Angle::Unit,
        Quantity::Charge::Unit,
        Quantity::Count::Unit,
        Quantity::Energy::Unit,
        Quantity::Length::Unit,
        Quantity::Temperature::Unit,
        Quantity::Time::Unit
    > units;

    static std::tuple<
        double,
        double,
        double,
        double,
        double,
        double,
        double
    > scales;

    template<typename Quantity>
    static void setUnit(typename Quantity::Unit unit);

    template<typename Quantity>
    static typename std::enable_if<
        Quantity::IsBaseQuantity::value,
        typename Quantity::Unit&
    >::type getUnit();

    template<typename Quantity>
    static void setScale(double scale);

    template<typename Quantity>
    static double& getScale();

    template<typename Quantity>
    static void setScale(double scale, typename Quantity::Unit unit);

    template<typename Quantity>
    static void setScale(const std::string &scale);

    static void updateConstants();

    template<typename Quantity>
    static double getConversionFactor();

    template<typename Quantity>
    static double getConversionFactor(typename Quantity::Unit unit);

    template<typename Quantity>
    static typename Quantity::Unit getUnit(const std::string &unit);

    static std::string getUnitString(
        int angleExponent,
        int chargeExponent,
        int countExponent,
        int energyExponent,
        int lengthExponent,
        int temperatureExponent,
        int timeExponent
    );

    template<typename Quantity>
    static typename std::enable_if<
        Quantity::IsBaseQuantity::value,
        std::string
    >::type getUnitString(int exponent);

    static void initialize();

    friend void Initialize();
};

template<typename Quantity>
void UnitHandler::setUnit(typename Quantity::Unit unit){
    double oldConversionFactor = getConversionFactor<Quantity>();
    getUnit<Quantity>() = unit;
    double newConversionFactor = getConversionFactor<Quantity>();
    getScale<Quantity>() *= newConversionFactor/oldConversionFactor;
    updateConstants();
}

template<>
inline Quantity::Angle::Unit& UnitHandler::getUnit<Quantity::Angle>(
){
    return std::get<0>(units);
}

template<>
inline Quantity::Charge::Unit& UnitHandler::getUnit<Quantity::Charge>(
){
    return std::get<1>(units);
}

template<>
inline Quantity::Count::Unit& UnitHandler::getUnit<Quantity::Count>(
){
    return std::get<2>(units);
}

template<>
inline Quantity::Energy::Unit& UnitHandler::getUnit<Quantity::Energy>(
){
    return std::get<3>(units);
}

template<>
inline Quantity::Length::Unit& UnitHandler::getUnit<Quantity::Length>(
){
    return std::get<4>(units);
}

template<>
inline Quantity::Temperature::Unit& UnitHandler::getUnit<
    Quantity::Temperature
>(){
    return std::get<5>(units);
}

template<>
inline Quantity::Time::Unit& UnitHandler::getUnit<Quantity::Time>(
){
    return std::get<6>(units);
}

template <typename Quantity>
void UnitHandler::setScale(double scale, typename Quantity::Unit unit){
    setUnit<Quantity>(unit);
    setScale<Quantity>(scale);
}

inline void UnitHandler::setScales(const std::vector<std::string> &scales){
    TBTKAssert(
        scales.size() == 7,
        "UnitHandler::setScales()",
        "'scales' must contain seven strings.",
        ""
    );

    setScale<Quantity::Angle>(scales[0]);
    setScale<Quantity::Charge>(scales[1]);
    setScale<Quantity::Count>(scales[2]);
    setScale<Quantity::Energy>(scales[3]);
    setScale<Quantity::Length>(scales[4]);
    setScale<Quantity::Temperature>(scales[5]);
    setScale<Quantity::Time>(scales[6]);
    updateConstants();
}

template<typename Quantity>
double UnitHandler::convertNaturalToBase(double value){
    return value*getScale<Quantity>();
}

template<typename Quantity>
double UnitHandler::convertBaseToNatural(double value){
    return value/getScale<Quantity>();
}

template<typename Quantity>
typename std::enable_if<
    Quantity::IsBaseQuantity::value,
    double
>::type UnitHandler::convertArbitraryToBase(
    double value,
    typename Quantity::Unit unit
){
    return value*getConversionFactor<Quantity>(
    )/getConversionFactor<Quantity>(unit);
}

template<typename Quantity>
typename std::enable_if<
    !Quantity::IsBaseQuantity::value,
    double
>::type UnitHandler::convertArbitraryToBase(
    double value,
    typename Quantity::Unit unit
){
    return value*Quantity::getConversionFactor(
        getUnit<TBTK::Quantity::Angle>(),
        getUnit<TBTK::Quantity::Charge>(),
        getUnit<TBTK::Quantity::Count>(),
        getUnit<TBTK::Quantity::Energy>(),
        getUnit<TBTK::Quantity::Length>(),
        getUnit<TBTK::Quantity::Temperature>(),
        getUnit<TBTK::Quantity::Time>()
    )/Quantity::getConversionFactor(unit);
}

template<typename Quantity>
typename std::enable_if<
    Quantity::IsBaseQuantity::value,
    double
>::type UnitHandler::convertBaseToArbitrary(
    double value,
    typename Quantity::Unit unit
){
    return value*getConversionFactor<Quantity>(
        unit
    )/getConversionFactor<Quantity>();
}

template<typename Quantity>
typename std::enable_if<
    !Quantity::IsBaseQuantity::value,
    double
>::type UnitHandler::convertBaseToArbitrary(
    double value,
    typename Quantity::Unit unit
){
    return value*Quantity::getConversionFactor(
        unit
    )/Quantity::getConversionFactor(
        getUnit<TBTK::Quantity::Angle>(),
        getUnit<TBTK::Quantity::Charge>(),
        getUnit<TBTK::Quantity::Count>(),
        getUnit<TBTK::Quantity::Energy>(),
        getUnit<TBTK::Quantity::Length>(),
        getUnit<TBTK::Quantity::Temperature>(),
        getUnit<TBTK::Quantity::Time>()
    );
}

template<typename Quantity>
typename std::enable_if<
    Quantity::IsBaseQuantity::value,
    double
>::type UnitHandler::convertArbitraryToNatural(
    double value,
    typename Quantity::Unit unit
){
    return value*getConversionFactor<Quantity>(
    )/(getConversionFactor<Quantity>(unit)*getScale<Quantity>());
}

template<typename Quantity>
typename std::enable_if<
    !Quantity::IsBaseQuantity::value,
    double
>::type UnitHandler::convertArbitraryToNatural(
    double value,
    typename Quantity::Unit unit
){
    double result = value*Quantity::getConversionFactor(
        getUnit<TBTK::Quantity::Angle>(),
        getUnit<TBTK::Quantity::Charge>(),
        getUnit<TBTK::Quantity::Count>(),
        getUnit<TBTK::Quantity::Energy>(),
        getUnit<TBTK::Quantity::Length>(),
        getUnit<TBTK::Quantity::Temperature>(),
        getUnit<TBTK::Quantity::Time>()
    )/Quantity::getConversionFactor(unit);

    result /= pow(
        getScale<TBTK::Quantity::Angle>(),
        Quantity::getExponent(TBTK::Quantity::Angle())
    );
    result /= pow(
        getScale<TBTK::Quantity::Charge>(),
        Quantity::getExponent(TBTK::Quantity::Charge())
    );
    result /= pow(
        getScale<TBTK::Quantity::Count>(),
        Quantity::getExponent(TBTK::Quantity::Count())
    );
    result /= pow(
        getScale<TBTK::Quantity::Energy>(),
        Quantity::getExponent(TBTK::Quantity::Energy())
    );
    result /= pow(
        getScale<TBTK::Quantity::Length>(),
        Quantity::getExponent(TBTK::Quantity::Length())
    );
    result /= pow(
        getScale<TBTK::Quantity::Temperature>(),
        Quantity::getExponent(TBTK::Quantity::Temperature())
    );
    result /= pow(
        getScale<TBTK::Quantity::Time>(),
        Quantity::getExponent(TBTK::Quantity::Time())
    );

    return result;
}

template<typename Quantity>
typename std::enable_if<
    Quantity::IsBaseQuantity::value,
    double
>::type UnitHandler::convertNaturalToArbitrary(
    double value,
    typename Quantity::Unit unit
){
    return value*getScale<Quantity>()*getConversionFactor<Quantity>(
        unit
    )/getConversionFactor<Quantity>();
}

template<typename Quantity>
typename std::enable_if<
    !Quantity::IsBaseQuantity::value,
    double
>::type UnitHandler::convertNaturalToArbitrary(
    double value,
    typename Quantity::Unit unit
){
    double result = value*Quantity::getConversionFactor(
        unit
    )/Quantity::getConversionFactor(
        getUnit<TBTK::Quantity::Angle>(),
        getUnit<TBTK::Quantity::Charge>(),
        getUnit<TBTK::Quantity::Count>(),
        getUnit<TBTK::Quantity::Energy>(),
        getUnit<TBTK::Quantity::Length>(),
        getUnit<TBTK::Quantity::Temperature>(),
        getUnit<TBTK::Quantity::Time>()
    );

    result *= pow(
        getScale<TBTK::Quantity::Angle>(),
        Quantity::getExponent(TBTK::Quantity::Angle())
    );
    result *= pow(
        getScale<TBTK::Quantity::Charge>(),
        Quantity::getExponent(TBTK::Quantity::Charge())
    );
    result *= pow(
        getScale<TBTK::Quantity::Count>(),
        Quantity::getExponent(TBTK::Quantity::Count())
    );
    result *= pow(
        getScale<TBTK::Quantity::Energy>(),
        Quantity::getExponent(TBTK::Quantity::Energy())
    );
    result *= pow(
        getScale<TBTK::Quantity::Length>(),
        Quantity::getExponent(TBTK::Quantity::Length())
    );
    result *= pow(
        getScale<TBTK::Quantity::Temperature>(),
        Quantity::getExponent(TBTK::Quantity::Temperature())
    );
    result *= pow(
        getScale<TBTK::Quantity::Time>(),
        Quantity::getExponent(TBTK::Quantity::Time())
    );

    return result;
}

template<typename Quantity>
double UnitHandler::getConversionFactor(){

    return Quantity::getConversionFactor(getUnit<Quantity>());
}

template<typename Quantity>
double UnitHandler::getConversionFactor(typename Quantity::Unit unit){
    return Quantity::getConversionFactor(unit);
}

template<typename Quantity>
inline void UnitHandler::setScale(double scale){
    getScale<Quantity>() = scale;
}

template<typename Quantity>
inline void UnitHandler::setScale(const std::string &scale){
    std::stringstream stream(scale);
    std::vector<std::string> components;
    std::string word;
    while(std::getline(stream, word, ' '))
        components.push_back(word);

    TBTKAssert(
        components.size() == 2,
        "UnitHandler::setScale()",
        "Invalid scale string '" << scale << "'.",
        "The string must be on the format '[scale] [unit]', e.g. '1 K'"
    );

    double value;
    try{
        value = stod(components[0]);
    }
    catch(const std::exception &e){
        TBTKExit(
            "UnitHandler::setScale()",
            "Unable to parse '" << components[0] << "' as a"
            << " double.",
            "The string has to be on the format '[scale] [unit]',"
            << " e.g. '1 K'."
        );
    }

    typename Quantity::Unit unit = getUnit<Quantity>(components[1]);

    setScale<Quantity>(value, unit);
}

template<>
inline double& UnitHandler::getScale<Quantity::Angle>(){
    return std::get<0>(scales);
}

template<>
inline double& UnitHandler::getScale<Quantity::Charge>(){
    return std::get<1>(scales);
}

template<>
inline double& UnitHandler::getScale<Quantity::Count>(){
    return std::get<2>(scales);
}

template<>
inline double& UnitHandler::getScale<Quantity::Energy>(){
    return std::get<3>(scales);
}

template<>
inline double& UnitHandler::getScale<Quantity::Length>(){
    return std::get<4>(scales);
}

template<>
inline double& UnitHandler::getScale<Quantity::Temperature>(){
    return std::get<5>(scales);
}

template<>
inline double& UnitHandler::getScale<Quantity::Time>(){
    return std::get<6>(scales);
}

template<typename Quantity>
inline typename std::enable_if<
    Quantity::IsBaseQuantity::value,
    std::string
>::type UnitHandler::getUnitString(){
    return Quantity::getUnitString(getUnit<Quantity>());
}

template<typename Quantity>
inline typename std::enable_if<
    !Quantity::IsBaseQuantity::value,
    std::string
>::type UnitHandler::getUnitString(){
    return getUnitString(
        static_cast<int>(Quantity::Exponent::Angle),
        static_cast<int>(Quantity::Exponent::Charge),
        static_cast<int>(Quantity::Exponent::Count),
        static_cast<int>(Quantity::Exponent::Energy),
        static_cast<int>(Quantity::Exponent::Length),
        static_cast<int>(Quantity::Exponent::Temperature),
        static_cast<int>(Quantity::Exponent::Time)
    );
}

template<typename Quantity>
typename Quantity::Unit UnitHandler::getUnit(const std::string &unit){
    return Quantity::getUnit(unit);
}

inline std::string UnitHandler::getUnitString(
    int angleExponent,
    int chargeExponent,
    int countExponent,
    int energyExponent,
    int lengthExponent,
    int temperatureExponent,
    int timeExponent
){
    std::string result;
    result += getUnitString<Quantity::Angle>(angleExponent);
    result += getUnitString<Quantity::Charge>(chargeExponent);
    result += getUnitString<Quantity::Count>(countExponent);
    result += getUnitString<Quantity::Energy>(energyExponent);
    result += getUnitString<Quantity::Length>(lengthExponent);
    result += getUnitString<Quantity::Temperature>(temperatureExponent);
    result += getUnitString<Quantity::Time>(timeExponent);

    if(result.size() != 0)
        result.pop_back();

    return result;
}

template<typename Quantity>
inline typename std::enable_if<
    Quantity::IsBaseQuantity::value,
    std::string
>::type UnitHandler::getUnitString(int exponent){
    std::string result;
    if(exponent != 0){
        result += getUnitString<Quantity>();
        if(exponent != 1)
            result += "^" + std::to_string(exponent);
        result += " ";
    }
    return result;
}

};

#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