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]                          *
 *                                                                              *
 *    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 "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