SDDSParser.h

Go to the documentation of this file.

//
// Class SDDSParser
//   This class writes column entries of SDDS files.
//
// Copyright (c) 2015, Christof Metzger-Kraus, Helmholtz-Zentrum Berlin
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL 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.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
 
#include "SDDSParser/array.hpp"
#include "SDDSParser/associate.hpp"
#include "SDDSParser/ast.hpp"
#include "SDDSParser/column.hpp"
#include "SDDSParser/data.hpp"
#include "SDDSParser/description.hpp"
#include "SDDSParser/file.hpp"
#include "SDDSParser/include.hpp"
#include "SDDSParser/parameter.hpp"
#include "SDDSParser/simple_parser.hpp"
 
#include "SDDSParser/SDDSParserException.h"
 
#include <fstream>
#include <iostream>
#include <map>
#include <string>
 
#ifndef __SDDSPARSER_H__
#define __SDDSPARSER_H__
 
namespace SDDS {
 
    class SDDSParser {
    private:
        std::string readFile();
        static void fixCaseSensitivity(std::string& for_string);
        static std::string fixCaseSensitivity(const std::string& for_string) {
            std::string retval(for_string);
            fixCaseSensitivity(retval);
            return retval;
        }
        std::string sddsFileName_m;
 
        std::map<std::string, int> paramNameToID_m;
        std::map<std::string, int> columnNameToID_m;
 
        SDDS::file sddsData_m;
 
    public:
        SDDSParser();
        SDDSParser(const std::string& input);
        void setInput(const std::string& input);
        file run();
 
        file getData();
        ast::columnData_t getColumnData(const std::string& columnName);
 
        ast::datatype getColumnType(const std::string& col_name) {
            int index = getColumnIndex(col_name);
            return *sddsData_m.sddsColumns_m[index].type_m;
        }
 
        template <typename T>
        void getValue(int t, std::string column_name, T& nval) {
            fixCaseSensitivity(column_name);
 
            int col_idx = getColumnIndex(column_name);
 
            // round timestep to last if not in range
            size_t row_idx  = 0;
            size_t num_rows = sddsData_m.sddsColumns_m[col_idx].values_m.size();
            if (t <= 0 || static_cast<size_t>(t) > num_rows)
                row_idx = num_rows - 1;
            else
                row_idx = static_cast<size_t>(t) - 1;
 
            ast::variant_t val = sddsData_m.sddsColumns_m[col_idx].values_m[row_idx];
            nval               = getBoostVariantValue<T>(val, (int)getColumnType(column_name));
        }
 
        template <typename T>
        void getInterpolatedValue(
                std::string ref_name, double ref_val, std::string col_name, T& nval) {
            T value_before          = 0;
            T value_after           = 0;
            double value_before_ref = 0;
            double value_after_ref  = 0;
 
            size_t col_idx_ref            = getColumnIndex(ref_name);
            ast::columnData_t& ref_values = sddsData_m.sddsColumns_m[col_idx_ref].values_m;
            int index                     = getColumnIndex(col_name);
            ast::columnData_t& col_values = sddsData_m.sddsColumns_m[index].values_m;
 
            size_t this_row = 0;
            size_t num_rows = ref_values.size();
            int datatype    = (int)getColumnType(col_name);
            for (this_row = 0; this_row < num_rows; this_row++) {
                value_after_ref = std::get<double>(ref_values[this_row]);
 
                if (ref_val < value_after_ref) {
                    size_t prev_row = 0;
                    if (this_row > 0) prev_row = this_row - 1;
 
                    value_before = getBoostVariantValue<T>(col_values[prev_row], datatype);
                    value_after  = getBoostVariantValue<T>(col_values[this_row], datatype);
 
                    value_before_ref = std::get<double>(ref_values[prev_row]);
                    value_after_ref  = std::get<double>(ref_values[this_row]);
 
                    break;
                }
            }
 
            if (this_row == num_rows)
                throw SDDSParserException(
                        "SDDSParser::getInterpolatedValue",
                        "all values < specified reference value");
 
            // simple linear interpolation
            if (ref_val - value_before_ref < 1e-8)
                nval = value_before;
            else
                nval = value_before
                       + (ref_val - value_before_ref) * (value_after - value_before)
                                 / (value_after_ref - value_before_ref);
 
            // Check for NaN or Inf using a simple approach
            double dval = static_cast<double>(nval);
            if (dval != dval || (dval == dval * 2.0 && dval != 0.0))
                throw SDDSParserException(
                        "SDDSParser::getInterpolatedValue",
                        "Interpolated value either NaN or Inf.");
        }
 
        template <typename T>
        void getInterpolatedValue(double spos, std::string col_name, T& nval) {
            getInterpolatedValue("s", spos, col_name, nval);
        }
 
        template <typename T>
        void getParameterValue(std::string parameter_name, T& nval) {
            fixCaseSensitivity(parameter_name);
 
            if (paramNameToID_m.count(parameter_name) > 0) {
                size_t id  = paramNameToID_m[parameter_name];
                auto value = sddsData_m.sddsParameters_m[id].value_m;
                nval       = std::get<T>(value);
            } else {
                throw SDDSParserException(
                        "SDDSParser::getParameterValue",
                        "unknown parameter name: '" + parameter_name + "'!");
            }
        }
 
        // use integer instead of ast::datatype enum since otherwise std::variant has ambigious
        // overloads
        template <typename T>
        T getBoostVariantValue(const ast::variant_t& val, int datatype) const {
            T value;
            try {
                switch (datatype) {
                    case ast::FLOAT:
                        value = std::get<float>(val);
                        break;
                    case ast::DOUBLE:
                        value = std::get<double>(val);
                        break;
                    case ast::SHORT:
                        value = std::get<short>(val);
                        break;
                    case ast::LONG:
                        value = std::get<long>(val);
                        break;
                    default:
                        throw SDDSParserException(
                                "SDDSParser::getBoostVariantValue",
                                "can't convert value to type T");
                }
            } catch (...) {
                throw SDDSParserException(
                        "SDDSParser::getBoostVariantValue", "can't convert value");
            }
            return value;
        }
 
    private:
        int getColumnIndex(std::string col_name) const;
    };
 
    inline file SDDSParser::getData() { return sddsData_m; }
}  // namespace SDDS
 
#endif