tkunit.h

/********************************************************************************
 *   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                                               *
 ********************************************************************************/
 
#ifndef tkunit_H
#define tkunit_H
 
#include "tkn_config.h"
 
#include <map>
#include <cmath>
#include <mutex>
#include <shared_mutex>
 
#ifdef HAS_ROOT
#include "TClass.h"
#endif
 
#include "tkstring.h"
#include "tklog.h"
 
namespace tkn {
 
class tkunit_manager
{
    friend class tkunit;
 
public:

    enum units_type { kUndef_type,
                      kEnergy,
                      kTime,
                      kLenght,
                      kNoConvUnits
    };

    enum units_keys { Undef_unit,
                      eV, keV, MeV, GeV, TeV,                    // energy
                      as, fs, ps, ns, us, ms, s, min, h, d, y,   // time
                      am, fm, pm, nm, um, mm, cm, m,             // lenght
    };
 
    static const std::vector<std::tuple<tkstring, units_type, double>> funits_properties;
 
protected:
    static std::shared_mutex &get_mutex() {
        static std::shared_mutex mutex;
        return mutex;
    }
 
    static std::vector<tkstring>   funits_name;
    static std::vector<units_type> funits_type;
    static std::vector<double>     fcoeffs;
 
    std::map<units_keys, tkstring>  funits_map_id_to_string;
    std::map<tkstring,units_keys>   funits_map_string_to_id;
    std::map<tkstring,units_keys>   funits_map_string_to_id_low;
    std::map<units_keys,double>     funits_map_conv_coeffs;
    std::map<units_keys,units_type> funits_map_types;
 
public:
    tkunit_manager();
    virtual ~tkunit_manager() = default;

    tkstring get_name(const units_keys &_key) {
        const auto index = static_cast<std::size_t>(_key);
        if (_key >= Undef_unit && index < funits_properties.size())
            return std::get<0>(funits_properties[index]);
        std::shared_lock<std::shared_mutex> lock(get_mutex());
        if(funits_map_id_to_string.count(_key)) return funits_map_id_to_string.at(_key);
        else glog << warning_o << "data_units_manager::get_name(" << _key << "): unkown key " << do_endl;
        return funits_map_id_to_string.at(Undef_unit);
    }

    units_keys get_key(const tkstring &_name) {
        tkstring tmp = _name.copy().to_lower();
        {
            std::shared_lock<std::shared_mutex> lock(get_mutex());
            const auto existing = funits_map_string_to_id_low.find(tmp);
            if(existing != funits_map_string_to_id_low.end()) return existing->second;
        }
 
        // Only an actual custom-unit insertion needs exclusive access.  Check
        // again after acquiring it because another thread may have inserted
        // the same name while this thread was waiting.
        std::unique_lock<std::shared_mutex> lock(get_mutex());
        const auto existing = funits_map_string_to_id_low.find(tmp);
        if(existing != funits_map_string_to_id_low.end()) return existing->second;
 
        const auto key = static_cast<units_keys>(funits_map_id_to_string.size());
        funits_map_id_to_string[key] = _name;
        funits_map_string_to_id[_name] = key;
        funits_map_string_to_id_low[tmp] = key;
        funits_map_conv_coeffs[key] = 1;
        funits_map_types[key] = kNoConvUnits;
        return key;
    }

    units_type get_type(const units_keys &_key) {
        const auto index = static_cast<std::size_t>(_key);
        if (_key >= Undef_unit && index < funits_properties.size())
            return std::get<1>(funits_properties[index]);
        std::shared_lock<std::shared_mutex> lock(get_mutex());
        if(funits_map_types.count(_key)) return funits_map_types.at(_key);
        else glog << warning_o << "data_units_manager::get_type(" << _key << "): unkown key " << do_endl;
        return funits_map_types.at(Undef_unit);
    }

    static tkunit_manager *the_unit_manager();
 
private:
    double get_factor(const units_keys &_key) {
        const auto index = static_cast<std::size_t>(_key);
        if (_key >= Undef_unit && index < funits_properties.size())
            return std::get<2>(funits_properties[index]);
        std::shared_lock<std::shared_mutex> lock(get_mutex());
        if(funits_map_conv_coeffs.count(_key)) return funits_map_conv_coeffs.at(_key);
        else glog << warning_o << "data_units_manager::get_factor(" << _key << "): unkown key " << do_endl;
        return funits_map_conv_coeffs.at(Undef_unit);
    }
 
#ifdef HAS_ROOT
    ClassDef(tkunit_manager,0);
#endif
};
 
#define gunits (tkn::tkunit_manager::the_unit_manager())
 
class tkunit
{
protected:
    tkunit_manager::units_keys fUnit_key = tkunit_manager::units_keys::Undef_unit;
    double fFactor = std::nan("0");
    double fValue  = -1.;
 
public:
    tkunit() {;}
    tkunit(double _value, const tkunit_manager::units_keys &_unit);
    tkunit(double _value, const tkstring &_unit) : tkunit(_value, gunits->get_key(_unit)) {}
 
    virtual ~tkunit() {}

    double get_value() const { return fValue/fFactor;}

    void set_value(const double &_val, const tkstring &_unit="");
    void set_value(const double &_val, const tkunit_manager::units_keys &_unit);

    bool set_unit(const tkstring &_unit);
    bool set_unit(const tkunit_manager::units_keys &_unit);

    tkstring get_unit_name() const { return gunits->get_name(fUnit_key);}
    tkunit_manager::units_keys get_unit_key() const { return fUnit_key;}

    void clear() { fValue  = 0.;}
 
#ifdef HAS_ROOT
    ClassDef(tkunit,0);
#endif
 
};
}
 
#endif