mu_parser_internal.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2019 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_mu_parser_internal_h
#define dealii_mu_parser_internal_h
 
// This file contains functions used internally by the FunctionParser
// and the TensorFunctionParser class.
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/array_view.h>
#include <deal.II/base/point.h>
#include <deal.II/base/thread_local_storage.h>
 
#include <memory>
#include <string>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
namespace internal
{
  namespace FunctionParser
  {
    int
    mu_round(double val);
 
    double
    mu_if(double condition, double thenvalue, double elsevalue);
 
    double
    mu_or(double left, double right);
 
    double
    mu_and(double left, double right);
 
    double
    mu_int(double value);
 
    double
    mu_ceil(double value);
 
    double
    mu_floor(double value);
 
    double
    mu_cot(double value);
 
    double
    mu_csc(double value);
 
    double
    mu_sec(double value);
 
    double
    mu_log(double value);
 
    double
    mu_pow(double a, double b);
 
    double
    mu_erf(double value);
 
    double
    mu_erfc(double value);
 
    // returns a random value in the range [0,1] initializing the generator
    // with the given seed
    double
    mu_rand_seed(double seed);
 
    // returns a random value in the range [0,1]
    double
    mu_rand();
 
    std::vector<std::string>
    get_function_names();
 
    DeclException2(ExcParseError,
                   int,
                   std::string,
                   << "Parsing Error at Column " << arg1
                   << ". The parser said: " << arg2);
 
    class muParserBase
    {
    public:
      virtual ~muParserBase() = default;
    };
 
    struct ParserData
    {
      ParserData() = default;
 
      ParserData(const ParserData &) = delete;
 
      std::vector<double> vars;
 
      std::vector<std::unique_ptr<muParserBase>> parsers;
    };
 
    template <int dim, typename Number>
    class ParserImplementation
    {
    public:
      ParserImplementation();
 
      virtual ~ParserImplementation() = default;
 
      virtual void
      initialize(const std::string                   &vars,
                 const std::vector<std::string>      &expressions,
                 const std::map<std::string, double> &constants,
                 const bool                           time_dependent = false);
 
      void
      init_muparser() const;
 
      Number
      do_value(const Point<dim> &p,
               const double      time,
               unsigned int      component) const;
 
      void
      do_all_values(const Point<dim>  &p,
                    const double       time,
                    ArrayView<Number> &values) const;
 
      std::vector<std::string> expressions;
 
    private:
      mutable Threads::ThreadLocalStorage<internal::FunctionParser::ParserData>
        parser_data;
 
      std::map<std::string, double> constants;
 
      std::vector<std::string> var_names;
 
      bool initialized;
 
      unsigned int n_vars;
    };
  } // namespace FunctionParser
} // namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif