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  "expression", "FunctionExpression", "Parsed function expression to compute");
24  params.addCoupledVar("coupled_variables", "Vector of coupled variable names");
25 
26  params.addParam<std::vector<MaterialPropertyName>>(
27  "material_properties", {}, "Material properties (Real-valued) in the expression");
28  params.addParam<std::vector<MaterialPropertyName>>(
29  "ad_material_properties", {}, "AD material properties (ADReal-valued) in the expression");
30 
31  params.addParam<bool>(
32  "use_xyzt",
33  false,
34  "Make coordinate (x,y,z) and time (t) variables available in the function expression.");
35  params.addParam<std::vector<std::string>>(
36  "constant_names",
37  {},
38  "Vector of constants used in the parsed function (use this for kB etc.)");
39  params.addParam<std::vector<std::string>>(
40  "constant_expressions",
41  {},
42  "Vector of values for the constants in constant_names (can be an FParser expression)");
43  params.addParam<std::vector<MooseFunctorName>>(
44  "functor_names", {}, "Functors to use in the parsed expression");
45  params.addParam<std::vector<std::string>>(
46  "functor_symbols",
47  {},
48  "Symbolic name to use for each functor in 'functor_names' in the parsed expression. If not "
49  "provided, then the actual functor names will be used in the parsed expression.");
50  params.addParam<bool>(
51  "evaluate_functors_on_qp",
52  true,
53  "Whether to evaluate functors using the ElemQpArg/ElemSideQpArg or the ElemArg/FaceArg "
54  "functor arguments. The behavior of a functor for each argument is implementation-defined by "
55  "the functor. But for most functors, the former two use the quadrature rule points as "
56  "evaluation locations, while the latter two use the element centroid/face centroid.");
57  return params;
58 }
59 
61  : AuxKernel(parameters),
62  FunctionParserUtils(parameters),
63  _function(getParam<std::string>("expression")),
64  _nargs(coupledComponents("coupled_variables")),
65  _args(coupledValues("coupled_variables")),
66  _matprop_names(getParam<std::vector<MaterialPropertyName>>("material_properties")),
67  _ad_matprop_names(getParam<std::vector<MaterialPropertyName>>("ad_material_properties")),
68  _n_matprops(_matprop_names.size()),
69  _n_ad_matprops(_ad_matprop_names.size()),
70  _use_xyzt(getParam<bool>("use_xyzt")),
71  _xyzt({"x", "y", "z", "t"}),
72  _functor_names(getParam<std::vector<MooseFunctorName>>("functor_names")),
73  _n_functors(_functor_names.size()),
74  _functor_symbols(getParam<std::vector<std::string>>("functor_symbols")),
75  _use_qp_functor_arguments(getParam<bool>("evaluate_functors_on_qp"))
76 {
77 
78  for (const auto i : make_range(_nargs))
79  _coupled_variable_names.push_back(getFieldVar("coupled_variables", i)->name());
80 
81  // sanity checks
82  if (!_functor_symbols.empty() && (_functor_symbols.size() != _n_functors))
83  paramError("functor_symbols", "functor_symbols must be the same length as functor_names.");
84  if (isNodal() && _use_qp_functor_arguments && isParamSetByUser("evaluate_functors_on_qp"))
85  paramError("evaluate_functors_on_qp", "QPs are not used for computing variable nodal values.");
86 
87  validateFunctorSymbols();
88  validateFunctorNames();
89  // We need the FaceInfo generated
90  if (_bnd && !_use_qp_functor_arguments)
91  _subproblem.needFV();
92 
93  // build variables argument
94  std::string variables;
95 
96  // coupled field variables
97  for (const auto i : index_range(_coupled_variable_names))
98  variables += (i == 0 ? "" : ",") + _coupled_variable_names[i];
99 
100  // adding functors to the expression
101  if (_functor_symbols.size())
102  for (const auto & symbol : _functor_symbols)
103  variables += (variables.empty() ? "" : ",") + symbol;
104  else
105  for (const auto & name : _functor_names)
106  variables += (variables.empty() ? "" : ",") + name;
107 
108  // material properties
109  for (const auto & matprop : _matprop_names)
110  variables += (variables.empty() ? "" : ",") + matprop;
111  for (const auto & matprop : _ad_matprop_names)
112  variables += (variables.empty() ? "" : ",") + matprop;
113  if (isNodal() && (_matprop_names.size() || _ad_matprop_names.size()))
114  mooseError("Material properties cannot be retrieved in a nodal auxkernel. Use a different "
115  "auxiliary variable family.");
116 
117  // positions and time
118  if (_use_xyzt)
119  for (auto & v : _xyzt)
120  variables += (variables.empty() ? "" : ",") + v;
121 
122  // Create parsed function
123  _func_F = std::make_shared<SymFunction>();
124  parsedFunctionSetup(_func_F,
125  _function,
126  variables,
127  getParam<std::vector<std::string>>("constant_names"),
128  getParam<std::vector<std::string>>("constant_expressions"),
129  comm());
130 
131  // reserve storage for parameter passing buffer
132  _func_params.resize(_nargs + _n_functors + _n_matprops + _n_ad_matprops + (_use_xyzt ? 4 : 0));
133 
134  // keep pointers to the material properties
135  for (const auto & name : _matprop_names)
136  _matprops.push_back(&getMaterialProperty<Real>(name));
137  for (const auto & name : _ad_matprop_names)
138  _ad_matprops.push_back(&getADMaterialProperty<Real>(name));
139 
140  // keep pointers to the functors
141  for (const auto & name : _functor_names)
142  _functors.push_back(&getFunctor<Real>(name));
143 }
144 
145 Real
147 {
148  // Variables
149  for (const auto j : make_range(_nargs))
150  _func_params[j] = (*_args[j])[_qp];
151 
152  // Functors
153  const auto & state = determineState();
154  if (isNodal())
155  {
156  const Moose::NodeArg node_arg = {_current_node,
158  for (const auto i : index_range(_functors))
159  _func_params[_nargs + i] = (*_functors[i])(node_arg, state);
160  }
161  else if (_bnd && _use_qp_functor_arguments)
162  {
163  const Moose::ElemSideQpArg side_qp_arg = {
165  for (const auto i : index_range(_functors))
166  _func_params[_nargs + i] = (*_functors[i])(side_qp_arg, state);
167  }
168  else if (_bnd)
169  {
172  /*elem_is_upwind*/ true,
173  /*correct skewness*/ true,
174  /*face_side*/ nullptr,
175  /*state_limiter*/ nullptr};
176  for (const auto i : index_range(_functors))
177  _func_params[_nargs + i] = (*_functors[i])(face_arg, state);
178  }
179  else if (_use_qp_functor_arguments)
180  {
181  const Moose::ElemQpArg qp_arg = {_current_elem, _qp, _qrule, _q_point[_qp]};
182  for (const auto i : index_range(_functors))
183  _func_params[_nargs + i] = (*_functors[i])(qp_arg, state);
184  }
185  else
186  {
187  const Moose::ElemArg elem_arg = {_current_elem, /*correct skewness*/ true};
188  for (const auto i : index_range(_functors))
189  _func_params[_nargs + i] = (*_functors[i])(elem_arg, state);
190  }
191 
192  // Material properties
193  for (const auto j : make_range(_n_matprops))
194  _func_params[_nargs + _n_functors + j] = (*_matprops[j])[_qp];
195  for (const auto j : make_range(_n_ad_matprops))
196  _func_params[_nargs + _n_functors + _n_matprops + j] = (*_ad_matprops[j])[_qp].value();
197 
198  // Positions and time
199  if (_use_xyzt)
200  {
201  for (const auto j : make_range(Moose::dim))
203  isNodal() ? (*_current_node)(j) : _q_point[_qp](j);
205  }
206 
207  return evaluate(_func_F);
208 }
209 
210 void
212 {
213  validateGenericVectorNames(_functor_symbols, "functor_symbols");
214 }
215 
216 void
218 {
219  validateGenericVectorNames(_functor_names, "functor_names");
220 }
std::string name(const ElemQuality q)
void validateFunctorNames()
Function to validate the names in _functor_names.
Definition: ParsedAux.C:217
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:125
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:133
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:162
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
MooseMesh & _mesh
Mesh this kernel is active on.
const bool _bnd
true if the kernel is boundary kernel, false if it is interior kernels
Definition: AuxKernelBase.h:88
std::vector< const ADMaterialProperty< Real > * > _ad_matprops
Definition: ParsedAux.h:56
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:2208
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
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
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:117
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:123
unsigned int _qp
Quadrature point index.
Definition: AuxKernel.h:145
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:60
virtual Real computeValue() override
Compute and return the value of the aux variable.
Definition: ParsedAux.C:146
const MooseArray< Point > & _q_point
Active quadrature points.
Definition: AuxKernel.h:115
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:211
bool isNodal() const
Nodal or elemental kernel?
Definition: AuxKernel.h:43