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

#include <MooseParsedFunctionBase.h>

Inheritance diagram for MooseParsedFunctionBase:

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.

   : _pfb_feproblem(*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
     _vars(parameters.isParamValid("vars")
               ? parameters.get<std::vector<std::string>>("vars")
               : parameters.get<std::vector<std::string>>("symbol_names")),
     _vals(parameters.isParamValid("vals")
               ? parameters.get<std::vector<std::string>>("vals")
               : parameters.get<std::vector<std::string>>("symbol_values"))
 {
   if (_vars.size() != _vals.size())
     mooseError("Number of symbol_names must match the number of symbol_values!");
 
   // Loop through the variables assigned by the user and give an error if x,y,z,t are used
   for (const auto & var : _vars)
     if (var.find_first_of("xyzt") != std::string::npos && var.size() == 1)
       mooseError("The variables \"x, y, z, and t\" in the ParsedFunction are pre-declared for use "
                  "and must not be declared in \"vars\"");
 }

◆ ~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

parameters Input 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().

 {
   InputParameters params = emptyInputParameters();
   params.addDeprecatedParam<std::vector<std::string>>(
       "vars",
       "Variables (excluding t,x,y,z) that are bound to the values provided by the corresponding "
       "items in the vals vector.",
       "Use 'symbol_names' instead.");
   params.addDeprecatedParam<std::vector<std::string>>(
       "vals",
       "Constant numeric values, postprocessor names, "
       "function names, and scalar variables for vars.",
       "Use 'symbol_values' instead.");
   params.addParam<std::vector<std::string>>(
       "symbol_names",
       "Symbols (excluding t,x,y,z) that are bound to the values provided by the corresponding "
       "items in the vals vector.");
   params.addParam<std::vector<std::string>>("symbol_values",
                                             "Constant numeric values, postprocessor names, "
                                             "function names, and scalar variables corresponding to"
                                             " the symbols in symbol_names.");
   return params;
 }

◆ 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_str The 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.

 {
   // Throws an error if quotes are found
   if (function_str.find("\"") != std::string::npos)
     mooseError("The expression in ParsedFunction contains quotes which cannot be properly parsed");
 
   // Return the input equation (no error)
   return function_str;
 }