// ------------------------------------------------------------------------ // // SPDX-License-Identifier: LGPL-2.1-or-later // Copyright (C) 2020 - 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_symbolic_function_templates_h #define dealii_symbolic_function_templates_h #include #include DEAL_II_NAMESPACE_OPEN namespace Functions { #ifdef DEAL_II_WITH_SYMENGINE namespace internal { inline std::vector to_expressions(const std::vector &strings) { std::vector ret(strings.size()); for (unsigned int i = 0; i < strings.size(); ++i) ret[i] = Differentiation::SD::Expression(strings[i], true); return ret; } } // namespace internal template SymbolicFunction::SymbolicFunction( const std::vector &functions, const Tensor<1, dim, Differentiation::SD::Expression> &argument, const Differentiation::SD::Expression &time, const Differentiation::SD::types::substitution_map &user_substitution_map) : Function(functions.size(), 0.0) , user_function(functions) , user_substitution_map(user_substitution_map) , coordinate_symbols(argument) , time_symbol(time) {} template SymbolicFunction::SymbolicFunction( const std::string &expressions) : Function( Utilities::split_string_list(expressions, ';').size(), 0.0) , user_function(internal::to_expressions( Utilities::split_string_list(expressions, ';'))) , coordinate_symbols(get_default_coordinate_symbols()) , time_symbol(Differentiation::SD::make_symbol("t")) {} template void SymbolicFunction::update_values() const { // This is only necessary if the function vector is empty. A call to // update_user_substitution_map() will clear all internal vectors. if (function.empty()) { function.resize(user_function.size()); for (unsigned int i = 0; i < user_function.size(); ++i) { function[i] = user_function[i].substitute(user_substitution_map); } } } template void SymbolicFunction::update_first_derivatives() const { // This is only necessary if the gradient vector is empty. A call to // update_user_substitution_map() will clear all internal vectors. if (function_gradient.empty()) { update_values(); function_gradient.resize(user_function.size()); for (unsigned int i = 0; i < user_function.size(); ++i) { function_gradient[i] = Differentiation::SD::differentiate(function[i], coordinate_symbols); } } } template void SymbolicFunction::update_second_derivatives() const { // This is only necessary if the gradient vector is empty. A call to // update_user_substitution_map() will clear all internal vectors. if (function_hessian.empty()) { update_first_derivatives(); function_hessian.resize(user_function.size()); function_laplacian.resize(user_function.size()); for (unsigned int i = 0; i < user_function.size(); ++i) { function_hessian[i] = Differentiation::SD::differentiate(function_gradient[i], coordinate_symbols); function_laplacian[i] = trace(function_hessian[i]); } } } template void SymbolicFunction::update_user_substitution_map( const Differentiation::SD::types::substitution_map &substitutions) { user_substitution_map = substitutions; // Now reset all internal vectors. function.resize(0); function_gradient.resize(0); function_hessian.resize(0); function_laplacian.resize(0); } template void SymbolicFunction::set_additional_function_arguments( const Differentiation::SD::types::substitution_map &arguments) { additional_function_arguments = arguments; } template Tensor<1, dim, Differentiation::SD::Expression> SymbolicFunction::get_default_coordinate_symbols() { static_assert(dim <= 3, "Not implemented yet."); const std::vector names = {"x", "y", "z"}; Tensor<1, dim, Differentiation::SD::Expression> x; for (unsigned int i = 0; i < dim; ++i) x[i] = Differentiation::SD::make_symbol(names[i]); return x; } template const Tensor<1, dim, Differentiation::SD::Expression> & SymbolicFunction::get_coordinate_symbols() const { return coordinate_symbols; } template const Differentiation::SD::Expression & SymbolicFunction::get_time_symbol() const { return time_symbol; } template const std::vector & SymbolicFunction::get_symbolic_function_expressions() const { return user_function; } template const Differentiation::SD::types::substitution_map & SymbolicFunction::get_user_substitution_map() const { return user_substitution_map; } template SymbolicFunction SymbolicFunction::time_derivative() const { std::vector df_dt(user_function.size()); for (unsigned int i = 0; i < user_function.size(); ++i) df_dt[i] = user_function[i].differentiate(time_symbol); return SymbolicFunction(df_dt, coordinate_symbols, time_symbol, user_substitution_map); } template RangeNumberType SymbolicFunction::value( const Point &p, const unsigned int component) const { update_values(); AssertIndexRange(component, function.size()); return Differentiation::SD::substitute_and_evaluate( function[component], create_evaluation_substitution_map(p)); } template Tensor<1, dim, RangeNumberType> SymbolicFunction::gradient( const Point &p, const unsigned int component) const { update_first_derivatives(); AssertIndexRange(component, function.size()); return Differentiation::SD::substitute_and_evaluate( function_gradient[component], create_evaluation_substitution_map(p)); } template RangeNumberType SymbolicFunction::laplacian( const Point &p, const unsigned int component) const { update_second_derivatives(); AssertIndexRange(component, function.size()); return Differentiation::SD::substitute_and_evaluate( function_laplacian[component], create_evaluation_substitution_map(p)); } template SymmetricTensor<2, dim, RangeNumberType> SymbolicFunction::hessian( const Point &p, const unsigned int component) const { update_second_derivatives(); AssertIndexRange(component, function.size()); return SymmetricTensor<2, dim, RangeNumberType>( Differentiation::SD::substitute_and_evaluate( function_hessian[component], create_evaluation_substitution_map(p))); } template Differentiation::SD::types::substitution_map SymbolicFunction::create_evaluation_substitution_map( const Point &p) const { auto map = additional_function_arguments; Differentiation::SD::add_to_substitution_map( map, std::make_pair(time_symbol, this->get_time()), std::make_pair(coordinate_symbols, p)); return map; } #endif } // namespace Functions DEAL_II_NAMESPACE_CLOSE #endif