https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
FunctionParserUtils< is_ad > Class Template Reference

#include <FunctionParserUtils.h>

Inheritance diagram for FunctionParserUtils< is_ad >:
[legend]

Public Types

typedef GenericSymFunction< is_ad > SymFunction
 Shorthand for an autodiff function parser object. More...
 
typedef std::shared_ptr< SymFunctionSymFunctionPtr
 Shorthand for an smart pointer to an autodiff function parser object. More...
 

Public Member Functions

 FunctionParserUtils (const InputParameters &parameters)
 
void setParserFeatureFlags (SymFunctionPtr &) const
 apply input parameters to internal feature flags of the parser object More...
 

Static Public Member Functions

static InputParameters validParams ()
 

Protected Types

enum  FailureMethod { FailureMethod::nan, FailureMethod::nan_warning, FailureMethod::error, FailureMethod::exception }
 Enum for failure method. More...
 

Protected Member Functions

GenericReal< is_ad > evaluate (SymFunctionPtr &, const std::string &object_name="")
 Evaluate FParser object and check EvalError. More...
 
GenericReal< is_ad > evaluate (SymFunctionPtr &, const std::vector< GenericReal< is_ad >> &, const std::string &object_name="")
 Evaluate FParser object and check EvalError. More...
 
void addFParserConstants (SymFunctionPtr &parser, const std::vector< std::string > &constant_names, const std::vector< std::string > &constant_expressions) const
 add constants (which can be complex expressions) to the parser object More...
 
virtual void functionsOptimize (SymFunctionPtr &parsed_function)
 run FPOptimizer on the parsed function More...
 
void parsedFunctionSetup (SymFunctionPtr &function, const std::string &expression, const std::string &variables, const std::vector< std::string > &constant_names, const std::vector< std::string > &constant_expressions, const libMesh::Parallel::Communicator &comm) const
 Performs setup steps on a SymFunction. More...
 
template<>
void functionsOptimize (SymFunctionPtr &parsed_function)
 
template<>
void functionsOptimize (SymFunctionPtr &parsed_function)
 

Protected Attributes

enum FunctionParserUtils::FailureMethod _evalerror_behavior
 
const Real _quiet_nan
 appropriate not a number value to return More...
 
std::vector< GenericReal< is_ad > > _func_params
 Array to stage the parameters passed to the functions when calling Eval. More...
 
const Real _epsilon
 fuzzy comparison tolerance More...
 
bool _enable_jit
 feature flags More...
 
bool _enable_ad_cache
 
bool _disable_fpoptimizer
 
bool _enable_auto_optimize
 

Static Protected Attributes

static const char * _eval_error_msg []
 table of FParser eval error codes More...
 

Detailed Description

template<bool is_ad = false>
class FunctionParserUtils< is_ad >

Definition at line 54 of file FunctionParserUtils.h.

Member Typedef Documentation

◆ SymFunction

template<bool is_ad = false>
typedef GenericSymFunction<is_ad> FunctionParserUtils< is_ad >::SymFunction

Shorthand for an autodiff function parser object.

Definition at line 62 of file FunctionParserUtils.h.

◆ SymFunctionPtr

template<bool is_ad = false>
typedef std::shared_ptr<SymFunction> FunctionParserUtils< is_ad >::SymFunctionPtr

Shorthand for an smart pointer to an autodiff function parser object.

Definition at line 65 of file FunctionParserUtils.h.

Member Enumeration Documentation

◆ FailureMethod

template<bool is_ad = false>
enum FunctionParserUtils::FailureMethod
strongprotected

Enum for failure method.

Enumerator
nan 
nan_warning 
error 
exception 

Definition at line 116 of file FunctionParserUtils.h.

116 { nan, nan_warning, error, exception } _evalerror_behavior;
enum FunctionParserUtils::FailureMethod _evalerror_behavior

Constructor & Destructor Documentation

◆ FunctionParserUtils()

template<bool is_ad>
FunctionParserUtils< is_ad >::FunctionParserUtils ( const InputParameters parameters)

Definition at line 59 of file FunctionParserUtils.C.

60  : _enable_jit(parameters.isParamValid("enable_jit") && parameters.get<bool>("enable_jit")),
61  _enable_ad_cache(parameters.get<bool>("enable_ad_cache")),
62  _disable_fpoptimizer(parameters.get<bool>("disable_fpoptimizer")),
63  _enable_auto_optimize(parameters.get<bool>("enable_auto_optimize") && !_disable_fpoptimizer),
64  _evalerror_behavior(parameters.get<MooseEnum>("evalerror_behavior").getEnum<FailureMethod>()),
65  _quiet_nan(std::numeric_limits<Real>::quiet_NaN()),
66  _epsilon(parameters.get<Real>("epsilon"))
67 {
68 #ifndef LIBMESH_HAVE_FPARSER_JIT
69  if (_enable_jit)
70  {
71  mooseWarning("Tried to enable FParser JIT but libmesh does not have it compiled in.");
72  _enable_jit = false;
73  }
74 #endif
75 }
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:336
T getEnum() const
get the current value cast to the enum type T
Definition: MooseEnum.h:151
bool _enable_jit
feature flags
enum FunctionParserUtils::FailureMethod _evalerror_behavior
FailureMethod
Enum for failure method.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
const Real _quiet_nan
appropriate not a number value to return
const Real _epsilon
fuzzy comparison tolerance
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

Member Function Documentation

◆ addFParserConstants()

template<bool is_ad>
void FunctionParserUtils< is_ad >::addFParserConstants ( SymFunctionPtr parser,
const std::vector< std::string > &  constant_names,
const std::vector< std::string > &  constant_expressions 
) const
protected

add constants (which can be complex expressions) to the parser object

Definition at line 151 of file FunctionParserUtils.C.

155 {
156  // check constant vectors
157  unsigned int nconst = constant_expressions.size();
158  if (nconst != constant_names.size())
159  mooseError("The parameter vectors constant_names (size " +
160  std::to_string(constant_names.size()) + ") and constant_expressions (size " +
161  std::to_string(nconst) + ") must have equal length.");
162 
163  // previously evaluated constant_expressions may be used in following constant_expressions
164  std::vector<Real> constant_values(nconst);
165 
166  for (unsigned int i = 0; i < nconst; ++i)
167  {
168  // no need to use dual numbers for the constant expressions
169  auto expression = std::make_shared<FunctionParserADBase<Real>>();
170 
171  // add previously evaluated constants
172  for (unsigned int j = 0; j < i; ++j)
173  if (!expression->AddConstant(constant_names[j], constant_values[j]))
174  mooseError("Invalid constant name: ", constant_names[j], " and value ", constant_values[j]);
175 
176  // build the temporary constant expression function
177  if (expression->Parse(constant_expressions[i], "") >= 0)
178  mooseError("Invalid constant expression\n",
179  constant_expressions[i],
180  "\n in parsed function object.\n",
181  expression->ErrorMsg());
182 
183  constant_values[i] = expression->Eval(NULL);
184 
185  if (!parser->AddConstant(constant_names[i], constant_values[i]))
186  mooseError("Invalid constant name in parsed function object");
187  }
188 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302

◆ evaluate() [1/2]

template<bool is_ad>
GenericReal< is_ad > FunctionParserUtils< is_ad >::evaluate ( SymFunctionPtr parser,
const std::string &  object_name = "" 
)
protected

Evaluate FParser object and check EvalError.

Definition at line 87 of file FunctionParserUtils.C.

Referenced by ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl().

88 {
89  return evaluate(parser, _func_params, name);
90 }
GenericReal< is_ad > evaluate(SymFunctionPtr &, const std::string &object_name="")
Evaluate FParser object and check EvalError.
std::vector< GenericReal< is_ad > > _func_params
Array to stage the parameters passed to the functions when calling Eval.

◆ evaluate() [2/2]

template<bool is_ad>
GenericReal< is_ad > FunctionParserUtils< is_ad >::evaluate ( SymFunctionPtr parser,
const std::vector< GenericReal< is_ad >> &  func_params,
const std::string &  object_name = "" 
)
protected

Evaluate FParser object and check EvalError.

This version uses a supplied vector of function parameters, which is useful if an object uses more than one parsed function, which may have different function parameter values.

Definition at line 94 of file FunctionParserUtils.C.

97 {
98  // null pointer is a shortcut for vanishing derivatives, see functionsOptimize()
99  if (parser == NULL)
100  return 0.0;
101 
102  // set desired epsilon
103  auto tmp_eps = parser->epsilon();
104  parser->setEpsilon(_epsilon);
105 
106  // evaluate expression
107  auto result = parser->Eval(func_params.data());
108 
109  // restore epsilon
110  parser->setEpsilon(tmp_eps);
111 
112  // fetch fparser evaluation error (set to unknown if the JIT result is nan)
113  int error_code = _enable_jit ? (std::isnan(result) ? -1 : 0) : parser->EvalError();
114 
115  // no error
116  if (error_code == 0)
117  return result;
118 
119  // hard fail or return not a number
120  switch (_evalerror_behavior)
121  {
122  case FailureMethod::nan:
123  return _quiet_nan;
124 
126  mooseWarning("In ",
127  name,
128  ": Parsed function evaluation encountered an error: ",
129  _eval_error_msg[(error_code < 0 || error_code > 5) ? 0 : error_code]);
130  return _quiet_nan;
131 
133  mooseError("In ",
134  name,
135  ": Parsed function evaluation encountered an error: ",
136  _eval_error_msg[(error_code < 0 || error_code > 5) ? 0 : error_code]);
137 
139  mooseException("In ",
140  name,
141  ": Parsed function evaluation encountered an error: ",
142  _eval_error_msg[(error_code < 0 || error_code > 5) ? 0 : error_code],
143  "\n Cutting timestep");
144  }
145 
146  return _quiet_nan;
147 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:336
bool _enable_jit
feature flags
enum FunctionParserUtils::FailureMethod _evalerror_behavior
const Real _quiet_nan
appropriate not a number value to return
static const char * _eval_error_msg[]
table of FParser eval error codes
const Real _epsilon
fuzzy comparison tolerance

◆ functionsOptimize() [1/3]

template<bool is_ad = false>
virtual void FunctionParserUtils< is_ad >::functionsOptimize ( SymFunctionPtr parsed_function)
protectedvirtual

run FPOptimizer on the parsed function

Referenced by DerivativeParsedMaterialHelperTempl< is_ad >::functionsPostParse().

◆ functionsOptimize() [2/3]

template<>
void FunctionParserUtils< true >::functionsOptimize ( SymFunctionPtr parsed_function)
protected

◆ functionsOptimize() [3/3]

template<>
void FunctionParserUtils< true >::functionsOptimize ( SymFunctionPtr parsed_function)
protected

Definition at line 209 of file FunctionParserUtils.C.

210 {
211  // set desired epsilon for optimization!
212  auto tmp_eps = parsed_function->epsilon();
213  parsed_function->setEpsilon(_epsilon);
214 
215  // base function
217  parsed_function->Optimize();
218  if (!_enable_jit || !parsed_function->JITCompile())
219  mooseError("AD parsed objects require JIT compilation to be enabled and working.");
220 
221  parsed_function->setEpsilon(tmp_eps);
222 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
bool _enable_jit
feature flags
const Real _epsilon
fuzzy comparison tolerance

◆ parsedFunctionSetup()

template<bool is_ad>
void FunctionParserUtils< is_ad >::parsedFunctionSetup ( SymFunctionPtr function,
const std::string &  expression,
const std::string &  variables,
const std::vector< std::string > &  constant_names,
const std::vector< std::string > &  constant_expressions,
const libMesh::Parallel::Communicator comm 
) const
protected

Performs setup steps on a SymFunction.

Parameters
functionreference to pointer to the function to set up
expressionexpression to parse
variablescomma separated string holding all the variables of the expression
constant_namesvector of names (symbols) of constants in the expression
constant_expressionsvectors of expressions (=values) of constants in the expression
commcommunicator used to stagger JIT file creations

Definition at line 226 of file FunctionParserUtils.C.

233 {
234  // set FParser internal feature flags
235  setParserFeatureFlags(function);
236 
237  // add the constant expressions
238  addFParserConstants(function, constant_names, constant_expressions);
239 
240  // parse function
241  if (function->Parse(expression, variables) >= 0)
242  mooseError("Invalid function\n", expression, "\nError:\n", function->ErrorMsg());
243 
244  // optimize
246  function->Optimize();
247 
248  // just-in-time compile
249  if (_enable_jit)
250  {
251  // let rank 0 do the JIT compilation first
252  if (comm.rank() != 0)
253  comm.barrier();
254 
255  function->JITCompile();
256 
257  // wait for ranks > 0 to catch up
258  if (comm.rank() == 0)
259  comm.barrier();
260  }
261 }
void addFParserConstants(SymFunctionPtr &parser, const std::vector< std::string > &constant_names, const std::vector< std::string > &constant_expressions) const
add constants (which can be complex expressions) to the parser object
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
processor_id_type rank() const
bool _enable_jit
feature flags
void setParserFeatureFlags(SymFunctionPtr &) const
apply input parameters to internal feature flags of the parser object

◆ setParserFeatureFlags()

template<bool is_ad>
void FunctionParserUtils< is_ad >::setParserFeatureFlags ( SymFunctionPtr parser) const

apply input parameters to internal feature flags of the parser object

Definition at line 79 of file FunctionParserUtils.C.

80 {
81  parser->SetADFlags(SymFunction::ADCacheDerivatives, _enable_ad_cache);
82  parser->SetADFlags(SymFunction::ADAutoOptimize, _enable_auto_optimize);
83 }

◆ validParams()

template<bool is_ad>
InputParameters FunctionParserUtils< is_ad >::validParams ( )
static

Definition at line 18 of file FunctionParserUtils.C.

Referenced by ArrayParsedAux::validParams(), ParsedAux::validParams(), ParsedPostprocessor::validParams(), ParsedODEKernel::validParams(), ParsedVectorAux::validParams(), ParsedSubdomainGeneratorBase::validParams(), ParsedCurveGenerator::validParams(), ParsedFunctorMaterialTempl< is_ad >::validParams(), ParsedExtraElementIDGenerator::validParams(), ParsedGenerateNodeset::validParams(), ParsedConvergence::validParams(), SolutionUserObject::validParams(), ParsedNodeTransformGenerator::validParams(), CutMeshByLevelSetGeneratorBase::validParams(), ParsedGenerateSideset::validParams(), TransfiniteMeshGenerator::validParams(), ParsedDownSelectionPositions::validParams(), ParsedElementDeletionGenerator::validParams(), and ParsedMaterialHelper< is_ad >::validParams().

19 {
21 
22  params.addParam<bool>(
23  "enable_jit",
24 #ifdef LIBMESH_HAVE_FPARSER_JIT
25  true,
26 #else
27  false,
28 #endif
29  "Enable just-in-time compilation of function expressions for faster evaluation");
30  params.addParam<bool>(
31  "enable_ad_cache", true, "Enable caching of function derivatives for faster startup time");
32  params.addParam<bool>(
33  "enable_auto_optimize", true, "Enable automatic immediate optimization of derivatives");
34  params.addParam<bool>(
35  "disable_fpoptimizer", false, "Disable the function parser algebraic optimizer");
36  MooseEnum evalerror("nan nan_warning error exception", "nan");
37  params.addParam<MooseEnum>("evalerror_behavior",
38  evalerror,
39  "What to do if evaluation error occurs. Options are to pass a nan, "
40  "pass a nan with a warning, throw a error, or throw an exception");
41 
42  params.addParamNamesToGroup(
43  "enable_jit enable_ad_cache enable_auto_optimize disable_fpoptimizer evalerror_behavior",
44  "Parsed expression advanced");
45  params.addParam<Real>("epsilon", 0, "Fuzzy comparison tolerance");
46  return params;
47 }
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
InputParameters emptyInputParameters()
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
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...
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...

Member Data Documentation

◆ _disable_fpoptimizer

template<bool is_ad = false>
bool FunctionParserUtils< is_ad >::_disable_fpoptimizer
protected

Definition at line 111 of file FunctionParserUtils.h.

◆ _enable_ad_cache

template<bool is_ad = false>
bool FunctionParserUtils< is_ad >::_enable_ad_cache
protected

Definition at line 110 of file FunctionParserUtils.h.

◆ _enable_auto_optimize

template<bool is_ad = false>
bool FunctionParserUtils< is_ad >::_enable_auto_optimize
protected

Definition at line 112 of file FunctionParserUtils.h.

◆ _enable_jit

template<bool is_ad = false>
bool FunctionParserUtils< is_ad >::_enable_jit
protected

feature flags

Definition at line 109 of file FunctionParserUtils.h.

Referenced by FunctionParserUtils< false >::FunctionParserUtils().

◆ _epsilon

template<bool is_ad = false>
const Real FunctionParserUtils< is_ad >::_epsilon
protected

fuzzy comparison tolerance

Definition at line 128 of file FunctionParserUtils.h.

◆ _eval_error_msg

template<bool is_ad = false>
const char * FunctionParserUtils< is_ad >::_eval_error_msg
staticprotected
Initial value:
= {
"Unknown",
"Division by zero",
"Square root of a negative value",
"Logarithm of negative value",
"Trigonometric error (asin or acos of illegal value)",
"Maximum recursion level reached"}

table of FParser eval error codes

Definition at line 122 of file FunctionParserUtils.h.

◆ _evalerror_behavior

template<bool is_ad = false>
enum FunctionParserUtils::FailureMethod FunctionParserUtils< is_ad >::_evalerror_behavior
protected

◆ _func_params

template<bool is_ad = false>
std::vector<GenericReal<is_ad> > FunctionParserUtils< is_ad >::_func_params
protected

Array to stage the parameters passed to the functions when calling Eval.

Definition at line 125 of file FunctionParserUtils.h.

Referenced by ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl().

◆ _quiet_nan

template<bool is_ad = false>
const Real FunctionParserUtils< is_ad >::_quiet_nan
protected

appropriate not a number value to return

Definition at line 119 of file FunctionParserUtils.h.


The documentation for this class was generated from the following files: