ExprtkUtils.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <exprtk.hpp>
#include <map>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
#include "BaseLib/Error.h"
#include "MathLib/InterpolationAlgorithms/PiecewiseLinearInterpolation.h"
#include "SpatialPosition.h"
 
namespace ParameterLib
{

struct CurveWrapper : public exprtk::ifunction<double>
{
    explicit CurveWrapper(MathLib::PiecewiseLinearInterpolation const& curve)
        : exprtk::ifunction<double>(1), curve_(curve)
    {
        exprtk::disable_has_side_effects(*this);
    }
 
    double operator()(double const& t) override { return curve_.getValue(t); }
 
private:
    MathLib::PiecewiseLinearInterpolation const& curve_;
};

struct SymbolTableCache
{
    SymbolTableCache() = default;

    SymbolTableCache(exprtk::symbol_table<double>& symbol_table,
                     bool spatial_position_is_required);

    void reinitialize(exprtk::symbol_table<double>& symbol_table);

    void setTimeAndPosition(double t, SpatialPosition const& pos) const;
 
private:
    bool spatial_position_is_required_ = false;
    double* t_ptr = nullptr;
    double* x_ptr = nullptr;
    double* y_ptr = nullptr;
    double* z_ptr = nullptr;
};

template <typename T>
std::vector<exprtk::expression<T>> compileExpressions(
    exprtk::symbol_table<T>& symbol_table,
    std::vector<std::string> const& string_expressions)
{
    using settings_t = typename exprtk::parser<T>::settings_store;
    exprtk::parser<T> parser(settings_t::default_compile_all_opts +
                             settings_t::e_collect_assings);
 
    std::vector<exprtk::expression<T>> expressions(string_expressions.size());
    for (unsigned i = 0; i < string_expressions.size(); ++i)
    {
        expressions[i].register_symbol_table(symbol_table);
        if (!parser.compile(string_expressions[i], expressions[i]))
        {
            OGS_FATAL("Error: {:s}\tExpression: {:s}\n", parser.error(),
                      string_expressions[i]);
        }
 
        std::vector<
            typename exprtk::parser<T>::dependent_entity_collector::symbol_t>
            assignments;
        parser.dec().assignment_symbols(assignments);
        if (!assignments.empty())
        {
            std::string names;
            for (auto const& [name, type] : assignments)
            {
                if (!names.empty())
                {
                    names += ", ";
                }
                names += name;
            }
            OGS_FATAL(
                "Expression '{:s}' assigns to the already-defined symbol(s) "
                "'{:s}'. Assignment to the built-in variables (t, x, y, z), to "
                "MPL variables, curves or constants is not allowed because it "
                "would corrupt the shared evaluation state. Assignment to "
                "user-defined local 'var's is permitted.",
                string_expressions[i], names);
        }
    }
    return expressions;
}

bool isBuiltinSymbol(std::string_view name);

bool hasSpatialVariables(std::vector<std::string> const& variables);

exprtk::symbol_table<double> createBaseSymbolTable(
    bool spatial_position_is_required);

void registerCurveWrappers(
    exprtk::symbol_table<double>& symbol_table,
    std::vector<std::string> const& curve_names,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
        curves,
    std::map<std::string, CurveWrapper>& curve_wrappers);
 
extern template std::vector<exprtk::expression<double>>
compileExpressions<double>(exprtk::symbol_table<double>&,
                           std::vector<std::string> const&);

std::vector<std::string> collectVariables(
    std::vector<std::string> const& expression_strings);

std::vector<std::string> collectUsedCurveNames(
    std::vector<std::string> const& expression_symbol_names,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
        curves);
 
}  // namespace ParameterLib