tkunit.cpp

/********************************************************************************
 *   Copyright (c) : Université de Lyon 1, CNRS/IN2P3, UMR5822,                 *
 *                   IP2I, F-69622 Villeurbanne Cedex, France                   *
 *                   Normandie Université, ENSICAEN, UNICAEN, CNRS/IN2P3,       *
 *                   LPC Caen, F-14000 Caen, France                             *
 *   Contibutor(s) :                                                            *
 *      Jérémie Dudouet jeremie.dudouet@cnrs.fr [2020]                          *
 *      Diego Gruyer    diego.gruyer@cnrs.fr    [2020]                          *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *   
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
 
#include "tkunit.h"
#include "tklog.h"
#include <cmath>
 
namespace tkn {
}
 
using namespace std;
using namespace tkn;
 
const std::vector<std::tuple<tkstring, tkunit_manager::units_type, double>> tkunit_manager::funits_properties = {
    {"Undefined",   kUndef_type,    0.        },  // undefined
    {"eV",          kEnergy,        1e-3      },  // energy
    {"keV",         kEnergy,        1.        },
    {"MeV",         kEnergy,        1e3       },
    {"GeV",         kEnergy,        1e6       },
    {"TeV",         kEnergy,        1e9       },
    {"as",          kTime,          1e-18     },  // time
    {"fs",          kTime,          1e-15     },
    {"ps",          kTime,          1e-12     },
    {"ns",          kTime,          1e-9      },
    {"us",          kTime,          1e-6      },
    {"ms",          kTime,          1e-3      },
    {"s",           kTime,          1.        },
    {"min",         kTime,          60.       },
    {"h",           kTime,          3600.     },
    {"d",           kTime,          86400.    },
    {"y",           kTime,          31556926. },
    {"am",          kLenght,        1e-18     },  // lenght
    {"fm",          kLenght,        1e-15     },
    {"pm",          kLenght,        1e-12     },
    {"nm",          kLenght,        1e-9      },
    {"um",          kLenght,        1e-6      },
    {"mm",          kLenght,        1e-3      },
    {"cm",          kLenght,        1e-2      },
    {"m",           kLenght,        1.        },
    {"K",           kNoConvUnits,   1.        },  // units without conversions: Kelvin
    {"C",           kNoConvUnits,   1.        },  // Celcius
    {"F",           kNoConvUnits,   1.        },  // Farenheit
    {"u",           kNoConvUnits,   1.        },  // atomic mass unit
    {"",            kNoConvUnits,   1.        },  // no unit
    {"%",           kNoConvUnits,   1.        },  // percentage
};
 
tkunit_manager::tkunit_manager() {
    for(size_t i= 0 ;  i<funits_properties.size() ; i++) {
        funits_map_id_to_string[(units_keys)i] = std::get<0>(funits_properties.at(i));
        funits_map_string_to_id[std::get<0>(funits_properties.at(i))] = (units_keys)i;
        funits_map_string_to_id_low[std::get<0>(funits_properties.at(i)).copy().to_lower()] = (units_keys)i;
        funits_map_conv_coeffs[(units_keys)i] = std::get<2>(funits_properties.at(i));
        funits_map_types[(units_keys)i] = std::get<1>(funits_properties.at(i));
    }
}
 
tkunit_manager *tkunit_manager::the_unit_manager()
{
    static tkunit_manager *instance = new tkunit_manager();
    return instance;
}
 
tkunit::tkunit(double _value, const tkunit_manager::units_keys &_unit) :
    fUnit_key(_unit),
    fFactor(gunits->get_factor(fUnit_key)),
    fValue(fFactor == 0. ? std::nan("0") : _value*fFactor)
{
 
}
 
void tkunit::set_value(const double &_val, const tkstring &_unit)
{
    if(_unit.is_empty()) {
        set_value(_val,fUnit_key);
    }
    else {
        set_value(_val,gunits->get_key(_unit));
    }
}
 
void tkunit::set_value(const double &_val, const tkunit_manager::units_keys &_unit) {
    fUnit_key = _unit;
    fFactor = gunits->get_factor(fUnit_key);
    fValue = fFactor == 0. ? std::nan("0") : _val*fFactor;
}
 
bool tkunit::set_unit(const tkstring &_unit) {
    return set_unit(gunits->get_key(_unit));
}
 
bool tkunit::set_unit(const tkunit_manager::units_keys &_unit) {
    if(_unit == gunits->Undef_unit) return false;
    if (_unit == fUnit_key) return true;
 
    const auto current_type = gunits->get_type(fUnit_key);
    const auto requested_type = gunits->get_type(_unit);
 
    // An uninitialised tkunit may acquire any valid unit.  Its numeric value
    // is set separately by the owning tkmeasure.
    if (current_type == gunits->kUndef_type) {
        fUnit_key = _unit;
        fFactor = gunits->get_factor(fUnit_key);
        return true;
    }
 
    // case where the unit type (energy, time...) does not change => easy mode, juste change the coeff
    if(requested_type == current_type && current_type != gunits->kNoConvUnits) {
        fUnit_key = _unit;
        fFactor = gunits->get_factor(fUnit_key);
    }
    else {
        // case Energy to time, or time to Energy
        if( ((current_type == gunits->kEnergy) && (requested_type == gunits->kTime)) ||
            ((current_type == gunits->kTime) && (requested_type == gunits->kEnergy))) {
            if (!std::isfinite(fValue) || fValue <= 0.) {
                glog << warning_o << " cannot convert a non-positive or non-finite "
                     << gunits->get_name(fUnit_key) << " value to " << gunits->get_name(_unit) << do_endl;
                return false;
            }
            // ev to s
            // E x tau = hbar
            // tau = hbar / E = 1.054571818×10−34 (Jxs) / E (keV)
            // 1J = 6.2415091e+18 eV
            // tau (s) = (1.054571818e−34*6.2415091e+15 (keVxs) / E (keV)
            // T (s) = (1.054571818e−34*6.2415091e+15*ln(2) (keVxs) / E (keV)
            // fFactor = (1.054571818e-34*6.2415091e+15)*ln(2); // ~ 4.5e-19 s
            fUnit_key = _unit;
            constexpr double hbar_ln2_keV_s = (1.054571818e-34*6.2415091e+15)*0.69314718055994530942;
            fValue = hbar_ln2_keV_s / fValue;
            fFactor = gunits->get_factor(fUnit_key);
        }
        else {
            glog << warning_o << " sorry, unit conversion from " << gunits->get_name(fUnit_key) << " to " << gunits->get_name(_unit) << " not handle by TkN for the moment" << do_endl;
            return false;
        }
    }
    return true;
}
 
#ifdef HAS_ROOT
ClassImp(tkunit);
#endif