tkmeasure.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 "tkmeasure.h"
 
namespace tkn {
}
 
using namespace tkn;
 
tkmeasure::tkmeasure(double _value, const tkunit_manager::units_keys &_unit, double _err)
{
    fValue.set_value(_value, _unit);
    fError.set_value(_err, _unit);
    fErrorLow.set_unit(_unit);
    fErrorHigh.set_unit(_unit);
}
 
tkmeasure::tkmeasure(double _value, const tkunit_manager::units_keys &_unit, double _errlow, double _errhigh)
{
    fValue.set_value(_value, _unit);
    fError.set_unit(_unit);
    fErrorLow.set_value(_errlow, _unit);
    fErrorHigh.set_value(_errhigh, _unit);
 
    fAsymError = true;
}
 
void tkmeasure::set_info_tag(const tkstring &_tag)
{
    finfo_tag = _tag;
 
    if(_tag.is_empty()) return;
    if(_tag.contains(";ERR=?")) {
        set_info(kUncertain);
        finfo_tag.remove_all(";ERR=?");
    }
    if(_tag.contains(";ERR=CA")) {
        set_info(kTheo);
        finfo_tag.remove_all(";ERR=CA");
    }
    if(_tag.contains(";ERR=AP")) {
        set_info(kAbout);
        finfo_tag.remove_all(";ERR=AP");
    }
    if(_tag.contains(";ERR=SY")) {
        set_info(kSystematic);
        finfo_tag.remove_all(";ERR=SY");
    }
    if(_tag.contains(";VAL=()")) {
        set_info(kTentative);
        finfo_tag.remove_all(";VAL=()");
    }
    if(_tag.contains(";ERR=LT") || _tag.contains(";ERR=GT") || _tag.contains(";ERR=LE") || _tag.contains(";ERR=GE")) {
        set_info(kLimit);
    }
    if(_tag.contains(";ERR=CONV")) {
        set_converted();
        finfo_tag.remove_all(";ERR=CONV");
    }
}
 
void tkmeasure::set(const double &_val, const tkstring &_unit)
{
    if(_unit != "" ) set_unit(_unit);
    fValue.set_value(_val);
}
 
void tkmeasure::set(const double &_val, const tkunit_manager::units_keys &_unit)
{
    set_unit(_unit);
    fValue.set_value(_val,_unit);
}
 
bool tkmeasure::set_unit(const tkunit_manager::units_keys &_unit)
{
    // when we change the unit type, the error is not trivial as an error conversion
    if(fValue.get_unit_key() && gunits->get_type(fValue.get_unit_key()) != gunits->get_type(_unit) ) {
        double value = fValue.get_value();
        double value_low = value-fError.get_value();
        if(fAsymError) value_low = value-fErrorLow.get_value();
        double value_high = value+fError.get_value();
        if(fAsymError) value_high = value+fErrorHigh.get_value();
 
        if(!fValue.set_unit(_unit)) return false;
        fErrorLow.set_value(value_low);
        fErrorLow.set_unit(_unit);
        value_low = fErrorLow.get_value();
 
        fErrorHigh.set_value(value_high);
        fErrorHigh.set_unit(_unit);
        value_high = fErrorHigh.get_value();
 
        if(value_low>value_high) {
            double tmp = value_high;
            value_high = value_low;
            value_low = tmp;
        }
        value_low = fValue.get_value() - value_low;
        value_high = value_high-fValue.get_value();
        if(value_low != value_high) {
            fError.set_value(-1);
            fErrorLow.set_value(value_low);
            fErrorHigh.set_value(value_high);
            fAsymError = true;
        }
        else {
            fError.set_value(value_low);
            fErrorLow.set_value(-1);
            fErrorHigh.set_value(-1);
            fAsymError = false;
        }
    }
    else {
        if(!fValue.set_unit(_unit)) return false;
        fError.set_unit(_unit);
        fErrorLow.set_unit(_unit);
        fErrorHigh.set_unit(_unit);
    }
 
    return true;
}
 
double tkmeasure::get_value(const tkunit_manager::units_keys &_unit)
{
    auto oldunit = get_unit_key();
    if(oldunit==_unit) return get_value();
    set_unit(_unit);
    double val = get_value();
    set_unit(oldunit);
    return val;
}
 
double tkmeasure::get_error() const
{
    if(fAsymError) {
        glog << warning_o << "The measure contains assymetric errors, the return value is the largest one" << do_endl;
        return std::max(fErrorLow.get_value(),fErrorHigh.get_value());
    }
    return fError.get_value();
}
 
double tkmeasure::get_error(const tkunit_manager::units_keys &_unit)
{
    auto oldunit = get_unit_key();
    set_unit(_unit);
    double val = get_error();
    set_unit(oldunit);
    return val;
}
 
double tkmeasure::get_error_low() const
{
    if(!fAsymError) {
        return fError.get_value();
    }
    return fErrorLow.get_value();
}
 
double tkmeasure::get_error_low(const tkunit_manager::units_keys &_unit)
{
    auto oldunit = get_unit_key();
    set_unit(_unit);
    double val = get_error_low();
    set_unit(oldunit);
    return val;
}
 
double tkmeasure::get_error_high() const
{
    if(!fAsymError) {
        return fError.get_value();
    }
    return fErrorHigh.get_value();
}
 
double tkmeasure::get_error_high(const tkunit_manager::units_keys &_unit)
{
    auto oldunit = get_unit_key();
    set_unit(_unit);
    double val = get_error_high();
    set_unit(oldunit);
    return val;
}
 
#ifdef HAS_ROOT
ClassImp(tkmeasure);
#endif