https://mooseframework.inl.gov
ParsedAux.C
Go to the documentation of this file.
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 
16 {
19  params.addClassDescription(
20  "Sets a field variable value to the evaluation of a parsed expression.");
21 
22  params.addRequiredCustomTypeParam<std::string>(
23  "function", "FunctionExpression", "Parsed function expression to compute");
24  params.deprecateParam("function", "expression", "02/07/2024");
25  params.addCoupledVar("args", "Vector of coupled variable names");
26  params.deprecateCoupledVar("args", "coupled_variables", "02/07/2024");
27 
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");
32 
33  params.addParam<bool>(
34  "use_xyzt",
35  false,
36  "Make coordinate (x,y,z) and time (t) variables available in the function expression.");
37  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  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  params.addParam<std::vector<MooseFunctorName>>(
46  "functor_names", {}, "Functors to use in the parsed expression");
47  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  params.addParam<bool>(
53  "evaluate_functors_on_qp",
54  true,
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.");
59  return params;
60 }
61 
63  : AuxKernel(parameters),
64  FunctionParserUtils(parameters),
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"))
78 {
79 
80  for (const auto i : make_range(_nargs))
81  _coupled_variable_names.push_back(getFieldVar("coupled_variables", i)->name());
82 
83  // sanity checks
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.");
88 
89  validateFunctorSymbols();
90  validateFunctorNames();
91  // We need the FaceInfo generated
92  if (_bnd && !_use_qp_functor_arguments)
93  _subproblem.needFV();
94 
95  // build variables argument
96  std::string variables;
97 
98  // coupled field variables
99  for (const auto i : index_range(_coupled_variable_names))
100  variables += (i == 0 ? "" : ",") + _coupled_variable_names[i];
101 
102  // adding functors to the expression
103  if (_functor_symbols.size())
104  for (const auto & symbol : _functor_symbols)
105  variables += (variables.empty() ? "" : ",") + symbol;
106  else
107  for (const auto & name : _functor_names)
108  variables += (variables.empty() ? "" : ",") + name;
109 
110  // material properties
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.");
118 
119  // positions and time
120  if (_use_xyzt)
121  for (auto & v : _xyzt)
122  variables += (variables.empty() ? "" : ",") + v;
123 
124  // Create parsed function
125  _func_F = std::make_shared<SymFunction>();
126  parsedFunctionSetup(_func_F,
127  _function,
128  variables,
129  getParam<std::vector<std::string>>("constant_names"),
130  getParam<std::vector<std::string>>("constant_expressions"),
131  comm());
132 
133  // reserve storage for parameter passing buffer
134  _func_params.resize(_nargs + _n_functors + _n_matprops + _n_ad_matprops + (_use_xyzt ? 4 : 0));
135 
136  // keep pointers to the material properties
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));
141 
142  // keep pointers to the functors
143  for (const auto & name : _functor_names)
144  _functors.push_back(&getFunctor<Real>(name));
145 }
146 
147 Real
149 {
150  // Variables
151  for (const auto j : make_range(_nargs))
152  _func_params[j] = (*_args[j])[_qp];
153 
154  // Functors
155  const auto & state = determineState();
156  if (isNodal())
157  {
158  const Moose::NodeArg node_arg = {_current_node,
160  for (const auto i : index_range(_functors))
161  _func_params[_nargs + i] = (*_functors[i])(node_arg, state);
162  }
163  else if (_bnd && _use_qp_functor_arguments)
164  {
165  const Moose::ElemSideQpArg side_qp_arg = {
167  for (const auto i : index_range(_functors))
168  _func_params[_nargs + i] = (*_functors[i])(side_qp_arg, state);
169  }
170  else if (_bnd)
171  {
174  /*elem_is_upwind*/ true,
175  /*correct skewness*/ true,
176  /*face_side*/ nullptr,
177  /*state_limiter*/ nullptr};
178  for (const auto i : index_range(_functors))
179  _func_params[_nargs + i] = (*_functors[i])(face_arg, state);
180  }
181  else if (_use_qp_functor_arguments)
182  {
183  const Moose::ElemQpArg qp_arg = {_current_elem, _qp, _qrule, _q_point[_qp]};
184  for (const auto i : index_range(_functors))
185  _func_params[_nargs + i] = (*_functors[i])(qp_arg, state);
186  }
187  else
188  {
189  const Moose::ElemArg elem_arg = {_current_elem, /*correct skewness*/ true};
190  for (const auto i : index_range(_functors))
191  _func_params[_nargs + i] = (*_functors[i])(elem_arg, state);
192  }
193 
194  // Material properties
195  for (const auto j : make_range(_n_matprops))
196  _func_params[_nargs + _n_functors + j] = (*_matprops[j])[_qp];
197  for (const auto j : make_range(_n_ad_matprops))
198  _func_params[_nargs + _n_functors + _n_matprops + j] = (*_ad_matprops[j])[_qp].value();
199 
200  // Positions and time
201  if (_use_xyzt)
202  {
203  for (const auto j : make_range(Moose::dim))
205  isNodal() ? (*_current_node)(j) : _q_point[_qp](j);
207  }
208 
209  return evaluate(_func_F);
210 }
211 
212 void
214 {
215  validateGenericVectorNames(_functor_symbols, "functor_symbols");
216 }
217 
218 void
220 {
221  validateGenericVectorNames(_functor_names, "functor_names");
222 }
std::string name(const ElemQuality q)
void validateFunctorNames()
Function to validate the names in _functor_names.
Definition: ParsedAux.C:219
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
Definition: AuxKernel.h:206
MooseMesh & _mesh
Mesh this kernel is active on.
Definition: AuxKernel.h:188
const unsigned int _nargs
coupled variables
Definition: ParsedAux.h:47
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
const Node *const & _current_node
Current node (valid only for nodal kernels)
Definition: AuxKernel.h:214
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.
Definition: ParsedAux.h:79
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:159
const bool _use_xyzt
import coordinates and time
Definition: ParsedAux.h:59
const std::vector< MooseFunctorName > & _functor_names
Functors to use in the parsed expression.
Definition: ParsedAux.h:70
std::vector< const ADMaterialProperty< Real > * > _ad_matprops
Definition: ParsedAux.h:56
bool _bnd
true if the kernel is boundary kernel, false if it is interior kernels
Definition: AuxKernel.h:186
AuxKernel that evaluates a parsed function expression.
Definition: ParsedAux.h:18
SymFunctionPtr _func_F
function parser object to compute the local value of the aux-variable
Definition: ParsedAux.h:65
const std::vector< const FaceInfo * > & faceInfo() const
Accessor for local FaceInfo objects.
Definition: MooseMesh.h:2216
const bool _use_qp_functor_arguments
Whether to use qp-functor arguments.
Definition: ParsedAux.h:82
const std::vector< std::string > _functor_symbols
Symbolic name to use for each functor.
Definition: ParsedAux.h:76
void deprecateParam(const std::string &old_name, const std::string &new_name, const std::string &removal_date)
A structure defining a "face" evaluation calling argument for Moose functors.
const unsigned int _n_matprops
Definition: ParsedAux.h:53
const unsigned int _n_functors
Number of functors.
Definition: ParsedAux.h:73
void deprecateCoupledVar(const std::string &old_name, const std::string &new_name, const std::string &removal_date)
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
Definition: ParsedAux.h:55
registerMooseObject("MooseApp", ParsedAux)
void addCoupledVar(const std::string &name, const std::string &doc_string)
This method adds a coupled variable name pair.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const QBase *const & _qrule
Quadrature rule being used.
Definition: AuxKernel.h:198
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)
Definition: AuxKernel.h:204
unsigned int _qp
Quadrature point index.
Definition: AuxKernel.h:230
const std::vector< const VariableValue * > _args
Definition: ParsedAux.h:48
void addRequiredCustomTypeParam(const std::string &name, const std::string &custom_type, const std::string &doc_string)
These methods add an option parameter and with a customer type to the InputParameters object...
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...
static InputParameters validParams()
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
static InputParameters validParams()
Definition: AuxKernel.C:27
static InputParameters validParams()
Definition: ParsedAux.C:15
void validateGenericVectorNames(const std::vector< T > &names_vec, const std::string &param_name)
Function to ensure vector entries (names) do not overlap with xyzt or coupled variable names...
Definition: ParsedAux.h:90
const unsigned int _n_ad_matprops
Definition: ParsedAux.h:54
ParsedAux(const InputParameters &parameters)
Definition: ParsedAux.C:62
virtual Real computeValue() override
Compute and return the value of the aux variable.
Definition: ParsedAux.C:148
const MooseArray< Point > & _q_point
Active quadrature points.
Definition: AuxKernel.h:196
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.
Definition: ParsedAux.C:213
bool isNodal() const
Nodal or elemental kernel?
Definition: AuxKernel.h:86