24 #ifdef LIBMESH_HAVE_FPARSER_JIT 29 "Enable just-in-time compilation of function expressions for faster evaluation");
31 "enable_ad_cache",
true,
"Enable caching of function derivatives for faster startup time");
33 "enable_auto_optimize",
true,
"Enable automatic immediate optimization of derivatives");
35 "disable_fpoptimizer",
false,
"Disable the function parser algebraic optimizer");
36 MooseEnum evalerror(
"nan nan_warning error exception",
"nan");
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");
43 "enable_jit enable_ad_cache enable_auto_optimize disable_fpoptimizer evalerror_behavior",
53 "Square root of a negative value",
54 "Logarithm of negative value",
55 "Trigonometric error (asin or acos of illegal value)",
56 "Maximum recursion level reached"};
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),
65 _quiet_nan(
std::numeric_limits<
Real>::quiet_NaN())
67 #ifndef LIBMESH_HAVE_FPARSER_JIT 70 mooseWarning(
"Tried to enable FParser JIT but libmesh does not have it compiled in.");
80 parser->SetADFlags(SymFunction::ADCacheDerivatives, _enable_ad_cache);
81 parser->SetADFlags(SymFunction::ADAutoOptimize, _enable_auto_optimize);
93 auto result = parser->Eval(_func_params.data());
96 int error_code = _enable_jit ? (std::isnan(result) ? -1 : 0) : parser->EvalError();
103 switch (_evalerror_behavior)
105 case FailureMethod::nan:
108 case FailureMethod::nan_warning:
111 ": Parsed function evaluation encountered an error: ",
112 _eval_error_msg[(error_code < 0 || error_code > 5) ? 0 : error_code]);
115 case FailureMethod::error:
118 ": Parsed function evaluation encountered an error: ",
119 _eval_error_msg[(error_code < 0 || error_code > 5) ? 0 : error_code]);
121 case FailureMethod::exception:
122 mooseException(
"In ",
124 ": Parsed function evaluation encountered an error: ",
125 _eval_error_msg[(error_code < 0 || error_code > 5) ? 0 : error_code],
126 "\n Cutting timestep");
132 template <
bool is_ad>
136 const std::vector<std::string> & constant_names,
137 const std::vector<std::string> & constant_expressions)
140 unsigned int nconst = constant_expressions.size();
141 if (nconst != constant_names.size())
142 mooseError(
"The parameter vectors constant_names and constant_values must have equal length.");
145 std::vector<Real> constant_values(nconst);
147 for (
unsigned int i = 0; i < nconst; ++i)
150 auto expression = std::make_shared<FunctionParserADBase<Real>>();
153 for (
unsigned int j = 0; j < i; ++j)
154 if (!expression->AddConstant(constant_names[j], constant_values[j]))
155 mooseError(
"Invalid constant name in ParsedMaterialHelper");
158 if (expression->Parse(constant_expressions[i],
"") >= 0)
160 constant_expressions[i],
161 "\n in parsed function object.\n",
162 expression->ErrorMsg());
164 constant_values[i] = expression->Eval(NULL);
166 if (!parser->AddConstant(constant_names[i], constant_values[i]))
167 mooseError(
"Invalid constant name in parsed function object");
177 parsed_function->Optimize();
179 mooseInfo(
"Failed to JIT compile expression, falling back to byte code interpretation.");
187 if (!_disable_fpoptimizer)
188 parsed_function->Optimize();
189 if (!_enable_jit || !parsed_function->JITCompile())
190 mooseError(
"AD parsed objects require JIT compilation to be enabled and working.");
std::string name(const ElemQuality q)
GenericReal< is_ad > evaluate(SymFunctionPtr &, const std::string &object_name="")
Evaluate FParser object and check EvalError.
std::shared_ptr< SymFunction > SymFunctionPtr
Shorthand for an smart pointer to an autodiff function parser object.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
FunctionParserUtils(const InputParameters ¶meters)
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
virtual void functionsOptimize(SymFunctionPtr &parsed_function)
void addFParserConstants(SymFunctionPtr &parser, const std::vector< std::string > &constant_names, const std::vector< std::string > &constant_expressions)
add constants (which can be complex expressions) to the parser object
void mooseInfo(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
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...
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
bool _disable_fpoptimizer
static InputParameters validParams()
typename Moose::GenericType< Real, is_ad > GenericReal
void setParserFeatureFlags(SymFunctionPtr &)
apply input paramters to internal feature flags of the parser object