20 "Sets a field variable value to the evaluation of a parsed expression.");
23 "function",
"FunctionExpression",
"Parsed function expression to compute");
25 params.
addCoupledVar(
"args",
"Vector of coupled variable names");
28 params.
addParam<std::vector<MaterialPropertyName>>(
29 "material_properties", {},
"Material properties (Real-valued) in the expression");
30 params.
addParam<std::vector<MaterialPropertyName>>(
31 "ad_material_properties", {},
"AD material properties (ADReal-valued) in the expression");
36 "Make coordinate (x,y,z) and time (t) variables available in the function expression.");
37 params.
addParam<std::vector<std::string>>(
40 "Vector of constants used in the parsed function (use this for kB etc.)");
41 params.
addParam<std::vector<std::string>>(
42 "constant_expressions",
44 "Vector of values for the constants in constant_names (can be an FParser expression)");
45 params.
addParam<std::vector<MooseFunctorName>>(
46 "functor_names", {},
"Functors to use in the parsed expression");
47 params.
addParam<std::vector<std::string>>(
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.");
53 "evaluate_functors_on_qp",
55 "Whether to evaluate functors using the ElemQpArg/ElemSideQpArg or the ElemArg/FaceArg " 56 "functor arguments. The behavior of a functor for each argument is implementation-defined by " 57 "the functor. But for most functors, the former two use the quadrature rule points as " 58 "evaluation locations, while the latter two use the element centroid/face centroid.");
65 _function(getParam<
std::string>(
"expression")),
66 _nargs(coupledComponents(
"coupled_variables")),
67 _args(coupledValues(
"coupled_variables")),
68 _matprop_names(getParam<
std::vector<MaterialPropertyName>>(
"material_properties")),
69 _ad_matprop_names(getParam<
std::vector<MaterialPropertyName>>(
"ad_material_properties")),
70 _n_matprops(_matprop_names.size()),
71 _n_ad_matprops(_ad_matprop_names.size()),
72 _use_xyzt(getParam<bool>(
"use_xyzt")),
73 _xyzt({
"x",
"y",
"z",
"t"}),
74 _functor_names(getParam<std::vector<MooseFunctorName>>(
"functor_names")),
75 _n_functors(_functor_names.size()),
76 _functor_symbols(getParam<std::vector<std::string>>(
"functor_symbols")),
77 _use_qp_functor_arguments(getParam<bool>(
"evaluate_functors_on_qp"))
81 _coupled_variable_names.push_back(getFieldVar(
"coupled_variables", i)->
name());
84 if (!_functor_symbols.empty() && (_functor_symbols.size() != _n_functors))
85 paramError(
"functor_symbols",
"functor_symbols must be the same length as functor_names.");
86 if (isNodal() && _use_qp_functor_arguments && isParamSetByUser(
"evaluate_functors_on_qp"))
87 paramError(
"evaluate_functors_on_qp",
"QPs are not used for computing variable nodal values.");
89 validateFunctorSymbols();
90 validateFunctorNames();
92 if (_bnd && !_use_qp_functor_arguments)
96 std::string variables;
99 for (
const auto i :
index_range(_coupled_variable_names))
100 variables += (i == 0 ?
"" :
",") + _coupled_variable_names[i];
103 if (_functor_symbols.size())
104 for (
const auto & symbol : _functor_symbols)
105 variables += (variables.empty() ?
"" :
",") + symbol;
107 for (
const auto & name : _functor_names)
108 variables += (variables.empty() ?
"" :
",") + name;
111 for (
const auto & matprop : _matprop_names)
112 variables += (variables.empty() ?
"" :
",") + matprop;
113 for (
const auto & matprop : _ad_matprop_names)
114 variables += (variables.empty() ?
"" :
",") + matprop;
115 if (isNodal() && (_matprop_names.size() || _ad_matprop_names.size()))
116 mooseError(
"Material properties cannot be retrieved in a nodal auxkernel. Use a different " 117 "auxiliary variable family.");
121 for (
auto & v : _xyzt)
122 variables += (variables.empty() ?
"" :
",") + v;
125 _func_F = std::make_shared<SymFunction>();
126 parsedFunctionSetup(_func_F,
129 getParam<std::vector<std::string>>(
"constant_names"),
130 getParam<std::vector<std::string>>(
"constant_expressions"),
134 _func_params.resize(_nargs + _n_functors + _n_matprops + _n_ad_matprops + (_use_xyzt ? 4 : 0));
137 for (
const auto & name : _matprop_names)
138 _matprops.push_back(&getMaterialProperty<Real>(name));
139 for (
const auto & name : _ad_matprop_names)
140 _ad_matprops.push_back(&getADMaterialProperty<Real>(name));
143 for (
const auto & name : _functor_names)
144 _functors.push_back(&getFunctor<Real>(name));
std::string name(const ElemQuality q)
void validateFunctorNames()
Function to validate the names in _functor_names.
GenericReal< is_ad > evaluate(SymFunctionPtr &, const std::string &object_name="")
Evaluate FParser object and check EvalError.
static const std::set< SubdomainID > undefined_subdomain_connection
A static member that can be used when the connection of a node to subdomains is unknown.
const unsigned int & _current_side
current side of the current element
MooseMesh & _mesh
Mesh this kernel is active on.
const unsigned int _nargs
coupled variables
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
const Node *const & _current_node
Current node (valid only for nodal kernels)
Moose::StateArg determineState() const
Create a functor state argument that corresponds to the implicit state of this object.
std::vector< const Moose::Functor< Real > * > _functors
Vector of pointers to functors.
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
const bool _use_xyzt
import coordinates and time
const std::vector< MooseFunctorName > & _functor_names
Functors to use in the parsed expression.
std::vector< const ADMaterialProperty< Real > * > _ad_matprops
bool _bnd
true if the kernel is boundary kernel, false if it is interior kernels
AuxKernel that evaluates a parsed function expression.
SymFunctionPtr _func_F
function parser object to compute the local value of the aux-variable
const std::vector< const FaceInfo * > & faceInfo() const
Accessor for local FaceInfo objects.
const bool _use_qp_functor_arguments
Whether to use qp-functor arguments.
const std::vector< std::string > _functor_symbols
Symbolic name to use for each functor.
A structure defining a "face" evaluation calling argument for Moose functors.
const unsigned int _n_matprops
const unsigned int _n_functors
Number of functors.
A structure that is used to evaluate Moose functors logically at an element/cell center.
Argument for requesting functor evaluation at a quadrature point location in an element.
std::vector< const MaterialProperty< Real > * > _matprops
registerMooseObject("MooseApp", ParsedAux)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const QBase *const & _qrule
Quadrature rule being used.
std::vector< GenericReal< is_ad > > _func_params
Array to stage the parameters passed to the functions when calling Eval.
IntRange< T > make_range(T beg, T end)
const Elem *const & _current_elem
Current element (valid only for elemental kernels)
unsigned int _qp
Quadrature point index.
const std::vector< const VariableValue * > _args
static InputParameters validParams()
static InputParameters validParams()
static InputParameters validParams()
void validateGenericVectorNames(const std::vector< T > &names_vec, const std::string ¶m_name)
Function to ensure vector entries (names) do not overlap with xyzt or coupled variable names...
const unsigned int _n_ad_matprops
ParsedAux(const InputParameters ¶meters)
virtual Real computeValue() override
Compute and return the value of the aux variable.
const MooseArray< Point > & _q_point
Active quadrature points.
auto index_range(const T &sizable)
Argument for requesting functor evaluation at quadrature point locations on an element side...
void validateFunctorSymbols()
Function to validate the symbols in _functor_symbols.
bool isNodal() const
Nodal or elemental kernel?