symbolic_function.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2022 by Luca Heltai
//
// This file is part of the FSI-suite platform, based on the deal.II library.
//
// The FSI-suite platform is free software; you can use it, redistribute it,
// and/or modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3.0 of the License,
// or (at your option) any later version. The full text of the license can be
// found in the file LICENSE at the top level of the FSI-suite platform
// distribution.
//
// ---------------------------------------------------------------------
 
#ifndef parsed_tools__symbolic_function_h
#define parsed_tools__symbolic_function_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_SYMENGINE
 
#  include <deal.II/base/parameter_acceptor.h>
#  include <deal.II/base/symbolic_function.h>
 
namespace dealii
{
  namespace Patterns
  {
    namespace Tools
    {
      template <>
      struct Convert<Differentiation::SD::Expression>
      {
        using T = Differentiation::SD::Expression;
 
        static std::unique_ptr<dealii::Patterns::PatternBase>
        to_pattern()
        {
          return Patterns::Anything().clone();
        }
 
        static std::string
        to_string(const T                             &t,
                  const dealii::Patterns::PatternBase &pattern = *to_pattern())
        {
          std::stringstream ss;
          ss << t;
          AssertThrow(
            pattern.match(ss.str()),
            ExcMessage(
              "The expression does not satisfy the requirements of the "
              "pattern."));
          return ss.str();
        }
 
        static T
        to_value(const std::string                   &s,
                 const dealii::Patterns::PatternBase &pattern = *to_pattern())
        {
          AssertThrow(pattern.match(s), ExcMessage("Invalid string."));
          return T(s, true);
        }
      };
 
      namespace internal
      {
        // Rank of SymbolicFunction
        template <int dim>
        struct RankInfo<
          std::unique_ptr<dealii::Functions::SymbolicFunction<dim>>>
        {
          static constexpr int list_rank = 1;
          static constexpr int map_rank  = 0;
        };
      } // namespace internal
 
      template <int dim>
      struct Convert<std::unique_ptr<dealii::Functions::SymbolicFunction<dim>>>
      {
        using T = std::unique_ptr<dealii::Functions::SymbolicFunction<dim>>;
 
        static std::unique_ptr<dealii::Patterns::PatternBase>
        to_pattern()
        {
          return Patterns::List(Patterns::Anything(),
                                0,
                                dealii::Patterns::List::max_int_value,
                                ";")
            .clone();
        }
 
        static std::string
        to_string(const T                             &t,
                  const dealii::Patterns::PatternBase &pattern =
                    *Convert<T>::to_pattern())
        {
          auto expr = t->get_symbolic_function_expressions();
          return Convert<decltype(expr)>::to_string(expr, pattern);
        }
 
        static T
        to_value(const std::string                   &s,
                 const dealii::Patterns::PatternBase &pattern =
                   *Convert<T>::to_pattern())
        {
          AssertThrow(pattern.match(s), ExcMessage("Invalid string."));
          return std::make_unique<dealii::Functions::SymbolicFunction<dim>>(s);
        }
      };
    } // namespace Tools
  }   // namespace Patterns
} // namespace dealii
 
 
 
namespace ParsedTools
{
  template <int dim>
  class SymbolicFunction : public dealii::ParameterAcceptor
  {
  public:
    SymbolicFunction(
      const std::string &section_name         = "",
      const std::string &expression           = "",
      const std::string &function_description = "Function expression");
 
    operator dealii::Functions::SymbolicFunction<dim> &()
    {
      return *symbolic_function;
    }
 
    dealii::Functions::SymbolicFunction<dim> &
    operator()()
    {
      return *symbolic_function;
    }
 
  private:
    std::unique_ptr<dealii::Functions::SymbolicFunction<dim>> symbolic_function;
 
    const unsigned int n_components;
  };
} // namespace ParsedTools
#endif
#endif