1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2005 - 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.
//
// ------------------------------------------------------------------------
#include <deal.II/base/function_parser.h>
#include <deal.II/base/mu_parser_internal.h>
#include <deal.II/base/patterns.h>
#include <deal.II/base/utilities.h>
#include <deal.II/lac/vector.h>
#include <map>
DEAL_II_NAMESPACE_OPEN
template <int dim>
const std::vector<std::string> &
FunctionParser<dim>::get_expressions() const
{
return this->expressions;
}
template <int dim>
FunctionParser<dim>::FunctionParser(const unsigned int n_components,
const double initial_time,
const double h)
: AutoDerivativeFunction<dim>(h, n_components, initial_time)
{}
template <int dim>
FunctionParser<dim>::FunctionParser(const std::string &expression,
const std::string &constants,
const std::string &variable_names,
const double h)
: AutoDerivativeFunction<dim>(
h,
Utilities::split_string_list(expression, ';').size())
{
auto constants_map = Patterns::Tools::Convert<ConstMap>::to_value(
constants,
Patterns::Map(Patterns::Anything(),
Patterns::Double(),
0,
Patterns::Map::max_int_value,
",",
"="));
initialize(variable_names,
expression,
constants_map,
Utilities::split_string_list(variable_names, ",").size() ==
dim + 1);
}
template <int dim>
void
FunctionParser<dim>::initialize(const std::string &variables,
const std::vector<std::string> &expressions,
const std::map<std::string, double> &constants,
const bool time_dependent)
{
AssertThrow(this->n_components == expressions.size(),
ExcInvalidExpressionSize(this->n_components, expressions.size()));
internal::FunctionParser::ParserImplementation<dim, double>::initialize(
variables, expressions, constants, time_dependent);
}
template <int dim>
void
FunctionParser<dim>::initialize(const std::string &vars,
const std::string &expression,
const std::map<std::string, double> &constants,
const bool time_dependent)
{
initialize(vars,
Utilities::split_string_list(expression, ';'),
constants,
time_dependent);
}
template <int dim>
double
FunctionParser<dim>::value(const Point<dim> &p,
const unsigned int component) const
{
return this->do_value(p, this->get_time(), component);
}
// Explicit Instantiations.
template class FunctionParser<1>;
template class FunctionParser<2>;
template class FunctionParser<3>;
DEAL_II_NAMESPACE_CLOSE
|
