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]                          *
 *                                                                              *
 *    This software is governed by the CeCILL-B license under French law and    *
 *    abiding by the  rules of distribution of free  software.  You can use,    *
 *    modify  and/ or  redistribute  the  software under  the  terms of  the    *
 *    CeCILL-B license as circulated by CEA, CNRS and INRIA at the following    *
 *    URL \"http://www.cecill.info\".                                           *
 *                                                                              *
 *    As a counterpart to the access  to the source code and rights to copy,    *
 *    modify  and redistribute granted  by the  license, users  are provided    *
 *    only with a limited warranty  and the software's author, the holder of    *
 *    the economic  rights, and the  successive licensors have  only limited    *
 *    liability.                                                                *
 *                                                                              *
 *    In this respect, the user's attention is drawn to the risks associated    *
 *    with loading,  using, modifying  and/or developing or  reproducing the    *
 *    software by the user in light of its specific status of free software,    *
 *    that  may mean that  it is  complicated to  manipulate, and  that also    *
 *    therefore  means that it  is reserved  for developers  and experienced    *
 *    professionals having in-depth  computer knowledge. Users are therefore    *
 *    encouraged  to load  and test  the software's  suitability  as regards    *
 *    their  requirements  in  conditions  enabling the  security  of  their    *
 *    systems  and/or data to  be ensured  and, more  generally, to  use and    *
 *    operate it in the same conditions as regards security.                    *
 *                                                                              *
 *    The fact that  you are presently reading this means  that you have had    *
 *    knowledge of the CeCILL-B license and that you accept its terms.          *
 ********************************************************************************/
 
#include "tkunit.h"
#include "tklog.h"
#include <cmath>
 
namespace tkn {
}
 
using namespace std;
using namespace tkn;
 
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::g_unit_manager = nullptr;
 
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));
    }
    g_unit_manager = this;
}
 
tkunit_manager *tkunit_manager::the_unit_manager()
{
    if ( g_unit_manager == nullptr ) {
        g_unit_manager = new tkunit_manager();
    }
 
    return g_unit_manager;
}
 
tkunit::tkunit(double _value, const tkunit_manager::units_keys &_unit) :
    fUnit_key(_unit),
    fFactor(gunits->get_factor(fUnit_key)),
    fValue(_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 = _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(gunits->get_type(fUnit_key) == gunits->kNoConvUnits) {
    //        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;
    //    }
    // case where the unit type (energy, time...) does not change => easy mode, juste change the coeff
    if((gunits->get_type(fUnit_key) == gunits->kUndef_type) || (gunits->get_type(_unit) == gunits->get_type(fUnit_key))) {
        fUnit_key = _unit;
        fFactor = gunits->get_factor(fUnit_key);
    }
    else {
        // case Energy to time, or time to Energy
        if( ((gunits->get_type(fUnit_key) == gunits->kEnergy) && (gunits->get_type(_unit) == gunits->kTime)) ||
            ((gunits->get_type(fUnit_key) == gunits->kTime) && (gunits->get_type(_unit) == gunits->kEnergy))) {
            // 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;
            fValue = (1.054571818e-34*6.2415091e+15)*log(2) / 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