https://mooseframework.inl.gov
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
MooseParsedFunctionBase Class Reference

Adds user facing parameters for parsed function. More...

#include <MooseParsedFunctionBase.h>

Inheritance diagram for MooseParsedFunctionBase:
[legend]

Public Member Functions

 MooseParsedFunctionBase (const InputParameters &parameters)
 
virtual ~MooseParsedFunctionBase ()
 Class destructor. More...
 

Static Public Member Functions

static InputParameters validParams ()
 Class constructor for the interface. More...
 

Protected Member Functions

const std::string verifyFunction (const std::string &function_str)
 A helper method to check if the function value contains quotes. More...
 

Protected Attributes

FEProblemBase_pfb_feproblem
 Reference to the FEProblemBase class for this object. More...
 
const std::vector< std::string > _vars
 Variables passed to libMesh::ParsedFunction. More...
 
const std::vector< std::string > _vals
 Values passed by the user, they may be Reals for Postprocessors. More...
 
std::unique_ptr< MooseParsedFunctionWrapper_function_ptr
 Pointer to the Parsed function wrapper object for the scalar. More...
 

Detailed Description

Adds user facing parameters for parsed function.

See also
ParsedFunction ParsedVectorFunction ParsedGradFunction

Definition at line 37 of file MooseParsedFunctionBase.h.

Constructor & Destructor Documentation

◆ MooseParsedFunctionBase()

MooseParsedFunctionBase::MooseParsedFunctionBase ( const InputParameters parameters)

Definition at line 42 of file MooseParsedFunctionBase.C.

43  : _pfb_feproblem(*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
44  _vars(parameters.isParamValid("vars")
45  ? parameters.get<std::vector<std::string>>("vars")
46  : parameters.get<std::vector<std::string>>("symbol_names")),
47  _vals(parameters.isParamValid("vals")
48  ? parameters.get<std::vector<std::string>>("vals")
49  : parameters.get<std::vector<std::string>>("symbol_values"))
50 {
51  if (_vars.size() != _vals.size())
52  mooseError("Number of symbol_names must match the number of symbol_values!");
53 
54  // Loop through the variables assigned by the user and give an error if x,y,z,t are used
55  for (const auto & var : _vars)
56  if (var.find_first_of("xyzt") != std::string::npos && var.size() == 1)
57  mooseError("The variables \"x, y, z, and t\" in the ParsedFunction are pre-declared for use "
58  "and must not be declared in \"vars\"");
59 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
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.
T getCheckedPointerParam(const std::string &name, const std::string &error_string="") const
Verifies that the requested parameter exists and is not NULL and returns it to the caller...
FEProblemBase & _pfb_feproblem
Reference to the FEProblemBase class for this object.
const std::vector< std::string > _vals
Values passed by the user, they may be Reals for Postprocessors.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const std::vector< std::string > _vars
Variables passed to libMesh::ParsedFunction.
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ ~MooseParsedFunctionBase()

MooseParsedFunctionBase::~MooseParsedFunctionBase ( )
virtual

Class destructor.

Definition at line 61 of file MooseParsedFunctionBase.C.

61 {}

Member Function Documentation

◆ validParams()

InputParameters MooseParsedFunctionBase::validParams ( )
static

Class constructor for the interface.

The first parameter, 'name' is not currently used.

Parameters
parametersInput parameters from the object, it must contain '_fe_problem'

Definition at line 18 of file MooseParsedFunctionBase.C.

Referenced by ParsedChainControl::validParams(), MooseParsedVectorFunction::validParams(), MooseParsedGradFunction::validParams(), and MooseParsedFunction::validParams().

19 {
21  params.addDeprecatedParam<std::vector<std::string>>(
22  "vars",
23  "Variables (excluding t,x,y,z) that are bound to the values provided by the corresponding "
24  "items in the vals vector.",
25  "Use 'symbol_names' instead.");
26  params.addDeprecatedParam<std::vector<std::string>>(
27  "vals",
28  "Constant numeric values, postprocessor names, "
29  "function names, and scalar variables for vars.",
30  "Use 'symbol_values' instead.");
31  params.addParam<std::vector<std::string>>(
32  "symbol_names",
33  "Symbols (excluding t,x,y,z) that are bound to the values provided by the corresponding "
34  "items in the vals vector.");
35  params.addParam<std::vector<std::string>>("symbol_values",
36  "Constant numeric values, postprocessor names, "
37  "function names, and scalar variables corresponding to"
38  " the symbols in symbol_names.");
39  return params;
40 }
void addDeprecatedParam(const std::string &name, const T &value, const std::string &doc_string, const std::string &deprecation_message)
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
InputParameters emptyInputParameters()
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...

◆ verifyFunction()

const std::string MooseParsedFunctionBase::verifyFunction ( const std::string &  function_str)
protected

A helper method to check if the function value contains quotes.

This method should be called from within the initialization list of the object inheriting the MooseParsedFunctionInterface

Parameters
function_strThe name of the ParsedFunction
Returns
The vector of strings, if the input function is valid
See also
ParsedFunction

Definition at line 64 of file MooseParsedFunctionBase.C.

65 {
66  // Throws an error if quotes are found
67  if (function_str.find("\"") != std::string::npos)
68  mooseError("The expression in ParsedFunction contains quotes which cannot be properly parsed");
69 
70  // Return the input equation (no error)
71  return function_str;
72 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302

Member Data Documentation

◆ _function_ptr

std::unique_ptr<MooseParsedFunctionWrapper> MooseParsedFunctionBase::_function_ptr
protected

◆ _pfb_feproblem

FEProblemBase& MooseParsedFunctionBase::_pfb_feproblem
protected

◆ _vals

const std::vector<std::string> MooseParsedFunctionBase::_vals
protected

◆ _vars

const std::vector<std::string> MooseParsedFunctionBase::_vars
protected

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