TRestSystemOfUnits.cxx

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see http://gifna.unizar.es/trex                  *
 *                                                                       *
 * REST is free software: you can redistribute it and/or modify          *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * REST is distributed in the hope that it will be useful,               *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          *
 * GNU General Public License for more details.                          *
 *                                                                       *
 * You should have a copy of the GNU General Public License along with   *
 * REST in $REST_PATH/LICENSE.                                           *
 * If not, see http://www.gnu.org/licenses/.                             *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
#include <iostream>
#include <limits>
 
#include "TRestStringHelper.h"
 
using namespace std;
 
namespace REST_Units {
struct UnitsStruct {
    UnitsStruct() {
        name = "";
        type = -1;
        scale = 1;
    }
    UnitsStruct(string _name, int _type, double _scale) {
        name = _name;
        type = _type;
        scale = _scale;
    }
 
    string name = "";
    int type = -1;
    double scale = 1;
 
    bool operator>(const UnitsStruct& compare) const { return name > compare.name; }
 
    bool operator<(const UnitsStruct& compare) const { return name < compare.name; }
 
    bool operator==(const UnitsStruct& compare) const { return name == compare.name; }
};
 
map<string, pair<int, double>> __ListOfRESTUnits;  // name, {type, scale}
}  // namespace REST_Units
#define REST_UnitsAdd_Caller
 
#include "TRestSystemOfUnits.h"
 
namespace REST_Units {
 
bool IsUnit(string unitsStr) { return !TRestSystemOfUnits(unitsStr).IsZombie(); }
 
bool IsBasicUnit(string unitsStr) { return (__ListOfRESTUnits.count(unitsStr) == 1); }
 
double GetScaleToStandardUnit(string unitsdef) { return 1 * TRestSystemOfUnits(unitsdef); }
 
string GetStandardUnitDefinition(string unitsdef) { return units(unitsdef).ToStandardDefinition(); }
 
string FindRESTUnitsInString(string s) {
    size_t l = RemoveUnitsFromString(s).length();
    string unitDef = s.substr(l, -1);
 
    if (IsUnit(unitDef)) {
        return unitDef;
    }
    return "";
}
 
string RemoveUnitsFromString(string s) {
    string valstr1 = s.substr(0, s.find_first_not_of("1234567890(),.-eE/: "));
 
    if (valstr1.size() == 0) {
        return "";
    }
 
    // if e turns out to be the last character, we shall also strip it
    if (valstr1[valstr1.size() - 1] == 'e' || valstr1[valstr1.size() - 1] == 'E') {
        return valstr1.substr(0, valstr1.size() - 1);
    }
 
    return valstr1;
}
 
Double_t GetDblValueInString(string in) {
    string units = FindRESTUnitsInString(in);
    double val = StringToDouble(RemoveUnitsFromString(in));
    return ConvertValueToRESTUnits(val, units);
}
 
Double_t GetValueInRESTUnits(string in) { return GetDblValueInString(in); }
 
Double_t GetDblValueInRESTUnits(string in) { return GetDblValueInString(in); }
 
TVector2 Get2DVectorValueInString(string in) {
    string unit = FindRESTUnitsInString(in);
    TVector2 value = StringTo2DVector(RemoveUnitsFromString(in));
    Double_t valueX = REST_Units::ConvertValueToRESTUnits(value.X(), unit);
    Double_t valueY = REST_Units::ConvertValueToRESTUnits(value.Y(), unit);
    return TVector2(valueX, valueY);
}
 
TVector2 Get2DVectorInRESTUnits(string in) { return Get2DVectorValueInString(in); }
 
TVector3 Get3DVectorValueInString(string in) {
    string unit = FindRESTUnitsInString(in);
    TVector3 value = StringTo3DVector(RemoveUnitsFromString(in));
    Double_t valueX = REST_Units::ConvertValueToRESTUnits(value.X(), unit);
    Double_t valueY = REST_Units::ConvertValueToRESTUnits(value.Y(), unit);
    Double_t valueZ = REST_Units::ConvertValueToRESTUnits(value.Z(), unit);
    return TVector3(valueX, valueY, valueZ);
}
 
TVector3 Get3DVectorInRESTUnits(string in) { return Get3DVectorValueInString(in); }
 
Double_t ConvertValueToRESTUnits(Double_t value, string unitsStr) {
    return value / TRestSystemOfUnits((string)unitsStr);
}
 
Double_t ConvertRESTUnitsValueToCustomUnits(Double_t value, string unitsStr) {
    return value * TRestSystemOfUnits((string)unitsStr);
}
 
double _AddUnit(string name, int type, double scale) {
    __ListOfRESTUnits[name] = {type, scale};
    return scale;
}
 
TRestSystemOfUnits::TRestSystemOfUnits(string unitsStr) {
    unitsStr = Trim(unitsStr);
 
    // We skip for the moment parameters/fields that contain elements {,,,}.
    if (unitsStr.find("{") != string::npos || unitsStr.find("}") != string::npos) {
        fZombie = true;
        return;
    }
 
    if (unitsStr == "") {
        fZombie = true;
        return;
    }
    fScaleCombined = 1;
 
    for (size_t pos = 0; pos >= 0 && pos < unitsStr.size();) {
        if (isalpha(unitsStr[pos])) {
            size_t pos1 = pos;
            while (pos < unitsStr.size() && isalpha(unitsStr[pos])) {
                pos++;
            }
            size_t pos2 = pos;
            string singleunit = unitsStr.substr(pos1, pos2 - pos1);
 
            if (IsBasicUnit(singleunit)) {
                int orderprefix = 1;
                if (pos1 > 0) {
                    if (unitsStr[pos1 - 1] == '/') {
                        orderprefix = -1;
                    } else if (unitsStr[pos1 - 1] == '-' || unitsStr[pos1 - 1] == '*') {
                    } else {
                        RESTWarning << "illegal unit combiner \"" << unitsStr[pos1 - 1] << "\"" << RESTendl;
                    }
                }
 
                double ordernum = 1;
                if (pos2 < unitsStr.size() - 1) {
                    if (unitsStr[pos2] == '^') {
                        int pos3 = unitsStr.find_first_not_of("-0123456789.", pos2 + 1);
                        string orderstr = unitsStr.substr(pos2 + 1, pos3 - pos2 - 1);
                        ordernum = StringToDouble(orderstr);
                        pos = pos3;
                    }
                }
 
                int _type = GetUnitType(singleunit);
                double _scale = GetUnitScale(singleunit);
                double _order = ordernum * orderprefix;
 
                fComponents.push_back(_type);
                fComponentOrder.push_back(_order);
 
                fScaleCombined *= pow(_scale, _order);
            } else {
                fZombie = true;
                return;
                // warning << "not a unit \"" << singleunit << "\"" << endl;
            }
 
        } else {
            if (pos == unitsStr.size() - 1) {
                RESTWarning << "Last character inside \"" << unitsStr << "\" \"" << unitsStr[pos]
                            << "\" unrecognized in unit definition!" << RESTendl;
 
                std::string lastChar = unitsStr.substr(pos, 1);
 
                if (isANumber(lastChar)) {
                    std::string tmpStr = unitsStr;
                    tmpStr.insert(pos, "^");
                    RESTWarning << "Perhaps you meant: " << tmpStr << RESTendl;
                }
            }
 
            pos++;
        }
    }
    if (fComponents.size() == 0) {
        fZombie = true;
    } else {
        fZombie = false;
    }
}
 
int TRestSystemOfUnits::GetUnitType(string singleUnit) {
    if (IsBasicUnit(singleUnit)) {
        return __ListOfRESTUnits[singleUnit].first;
    }
    return -1;
}
 
double TRestSystemOfUnits::GetUnitScale(string singleUnit) {
    if (IsBasicUnit(singleUnit)) {
        return __ListOfRESTUnits[singleUnit].second;
    }
    return 1;
}
 
string TRestSystemOfUnits::ToStandardDefinition() {
    string result = "";
    for (unsigned int i = 0; i < fComponents.size(); i++) {
        if (fComponentOrder[i] < 0) {
            result += "/";
        } else if (i > 0) {
            result += "-";
        }
 
        for (auto iter : __ListOfRESTUnits) {
            if (iter.second.first == fComponents[i] && iter.second.second == 1) {
                result += iter.first;
            }
        }
 
        if (abs(fComponentOrder[i]) != 1) {
            result += "^" + ToString(abs(fComponentOrder[i]));
        }
    }
 
    return result;
}
 
}  // namespace REST_Units