Line data Source code
1 : //* This file is part of the MOOSE framework
2 : //* https://mooseframework.inl.gov
3 : //*
4 : //* All rights reserved, see COPYRIGHT for full restrictions
5 : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 : //*
7 : //* Licensed under LGPL 2.1, please see LICENSE for details
8 : //* https://www.gnu.org/licenses/lgpl-2.1.html
9 :
10 : #include "ParsedAux.h"
11 :
12 : registerMooseObject("MooseApp", ParsedAux);
13 :
14 : InputParameters
15 16946 : ParsedAux::validParams()
16 : {
17 16946 : InputParameters params = AuxKernel::validParams();
18 16946 : params += FunctionParserUtils<false>::validParams();
19 16946 : params.addClassDescription(
20 : "Sets a field variable value to the evaluation of a parsed expression.");
21 :
22 16946 : params.addRequiredCustomTypeParam<std::string>(
23 : "function", "FunctionExpression", "Parsed function expression to compute");
24 16946 : params.deprecateParam("function", "expression", "02/07/2024");
25 16946 : params.addCoupledVar("args", "Vector of coupled variable names");
26 16946 : params.deprecateCoupledVar("args", "coupled_variables", "02/07/2024");
27 :
28 16946 : params.addParam<std::vector<MaterialPropertyName>>(
29 : "material_properties", {}, "Material properties (Real-valued) in the expression");
30 16946 : params.addParam<std::vector<MaterialPropertyName>>(
31 : "ad_material_properties", {}, "AD material properties (ADReal-valued) in the expression");
32 :
33 50838 : params.addParam<bool>(
34 : "use_xyzt",
35 33892 : false,
36 : "Make coordinate (x,y,z) and time (t) variables available in the function expression.");
37 16946 : params.addParam<std::vector<std::string>>(
38 : "constant_names",
39 : {},
40 : "Vector of constants used in the parsed function (use this for kB etc.)");
41 16946 : params.addParam<std::vector<std::string>>(
42 : "constant_expressions",
43 : {},
44 : "Vector of values for the constants in constant_names (can be an FParser expression)");
45 16946 : params.addParam<std::vector<MooseFunctorName>>(
46 : "functor_names", {}, "Functors to use in the parsed expression");
47 16946 : params.addParam<std::vector<std::string>>(
48 : "functor_symbols",
49 : {},
50 : "Symbolic name to use for each functor in 'functor_names' in the parsed expression. If not "
51 : "provided, then the actual functor names will be used in the parsed expression.");
52 :
53 16946 : return params;
54 0 : }
55 :
56 1401 : ParsedAux::ParsedAux(const InputParameters & parameters)
57 : : AuxKernel(parameters),
58 : FunctionParserUtils(parameters),
59 1397 : _function(getParam<std::string>("expression")),
60 1397 : _nargs(coupledComponents("coupled_variables")),
61 1397 : _args(coupledValues("coupled_variables")),
62 1397 : _matprop_names(getParam<std::vector<MaterialPropertyName>>("material_properties")),
63 1397 : _ad_matprop_names(getParam<std::vector<MaterialPropertyName>>("ad_material_properties")),
64 1397 : _n_matprops(_matprop_names.size()),
65 1397 : _n_ad_matprops(_ad_matprop_names.size()),
66 1397 : _use_xyzt(getParam<bool>("use_xyzt")),
67 8382 : _xyzt({"x", "y", "z", "t"}),
68 1397 : _functor_names(getParam<std::vector<MooseFunctorName>>("functor_names")),
69 1397 : _n_functors(_functor_names.size()),
70 5592 : _functor_symbols(getParam<std::vector<std::string>>("functor_symbols"))
71 : {
72 :
73 2074 : for (const auto i : make_range(_nargs))
74 677 : _coupled_variable_names.push_back(getFieldVar("coupled_variables", i)->name());
75 :
76 : // sanity checks
77 1397 : if (!_functor_symbols.empty() && (_functor_symbols.size() != _n_functors))
78 4 : paramError("functor_symbols", "functor_symbols must be the same length as functor_names.");
79 :
80 1393 : validateFunctorSymbols();
81 1385 : validateFunctorNames();
82 :
83 : // build variables argument
84 1377 : std::string variables;
85 :
86 : // coupled field variables
87 2038 : for (const auto i : index_range(_coupled_variable_names))
88 661 : variables += (i == 0 ? "" : ",") + _coupled_variable_names[i];
89 :
90 : // adding functors to the expression
91 1377 : if (_functor_symbols.size())
92 212 : for (const auto & symbol : _functor_symbols)
93 115 : variables += (variables.empty() ? "" : ",") + symbol;
94 : else
95 1280 : for (const auto & name : _functor_names)
96 0 : variables += (variables.empty() ? "" : ",") + name;
97 :
98 : // material properties
99 1405 : for (const auto & matprop : _matprop_names)
100 28 : variables += (variables.empty() ? "" : ",") + matprop;
101 1405 : for (const auto & matprop : _ad_matprop_names)
102 28 : variables += (variables.empty() ? "" : ",") + matprop;
103 1377 : if (isNodal() && (_matprop_names.size() || _ad_matprop_names.size()))
104 0 : mooseError("Material properties cannot be retrieved in a nodal auxkernel. Use a different "
105 : "auxiliary variable family.");
106 :
107 : // positions and time
108 1377 : if (_use_xyzt)
109 4145 : for (auto & v : _xyzt)
110 3316 : variables += (variables.empty() ? "" : ",") + v;
111 :
112 : // Create parsed function
113 1377 : _func_F = std::make_shared<SymFunction>();
114 2750 : parsedFunctionSetup(_func_F,
115 1377 : _function,
116 : variables,
117 : getParam<std::vector<std::string>>("constant_names"),
118 : getParam<std::vector<std::string>>("constant_expressions"),
119 : comm());
120 :
121 : // reserve storage for parameter passing buffer
122 1373 : _func_params.resize(_nargs + _n_functors + _n_matprops + _n_ad_matprops + (_use_xyzt ? 4 : 0));
123 :
124 : // keep pointers to the material properties
125 1401 : for (const auto & name : _matprop_names)
126 28 : _matprops.push_back(&getMaterialProperty<Real>(name));
127 1401 : for (const auto & name : _ad_matprop_names)
128 28 : _ad_matprops.push_back(&getADMaterialProperty<Real>(name));
129 :
130 : // keep pointers to the functors
131 1480 : for (const auto & name : _functor_names)
132 107 : _functors.push_back(&getFunctor<Real>(name));
133 4167 : }
134 :
135 : Real
136 4774732 : ParsedAux::computeValue()
137 : {
138 : // Variables
139 5458614 : for (const auto j : make_range(_nargs))
140 683882 : _func_params[j] = (*_args[j])[_qp];
141 :
142 : // Functors
143 4774732 : const auto & state = determineState();
144 4774732 : if (isNodal())
145 : {
146 1554918 : const Moose::NodeArg node_arg = {_current_node,
147 1554918 : &Moose::NodeArg::undefined_subdomain_connection};
148 1641185 : for (const auto i : index_range(_functors))
149 86267 : _func_params[_nargs + i] = (*_functors[i])(node_arg, state);
150 : }
151 : else
152 : {
153 3219814 : const Moose::ElemQpArg qp_arg = {_current_elem, _qp, _qrule, _q_point[_qp]};
154 3219814 : for (const auto i : index_range(_functors))
155 0 : _func_params[_nargs + i] = (*_functors[i])(qp_arg, state);
156 : }
157 :
158 : // Material properties
159 4991532 : for (const auto j : make_range(_n_matprops))
160 216800 : _func_params[_nargs + _n_functors + j] = (*_matprops[j])[_qp];
161 4991532 : for (const auto j : make_range(_n_ad_matprops))
162 216800 : _func_params[_nargs + _n_functors + _n_matprops + j] = (*_ad_matprops[j])[_qp].value();
163 :
164 : // Positions and time
165 4774732 : if (_use_xyzt)
166 : {
167 15897132 : for (const auto j : make_range(Moose::dim))
168 11922849 : _func_params[_nargs + _n_functors + _n_matprops + _n_ad_matprops + j] =
169 11922849 : isNodal() ? (*_current_node)(j) : _q_point[_qp](j);
170 3974283 : _func_params[_nargs + _n_functors + _n_matprops + _n_ad_matprops + 3] = _t;
171 : }
172 :
173 4774732 : return evaluate(_func_F);
174 : }
175 :
176 : void
177 1393 : ParsedAux::validateFunctorSymbols()
178 : {
179 1393 : validateGenericVectorNames(_functor_symbols, "functor_symbols");
180 1385 : }
181 :
182 : void
183 1385 : ParsedAux::validateFunctorNames()
184 : {
185 1385 : validateGenericVectorNames(_functor_names, "functor_names");
186 1377 : }
|
