This class uses implementations of CompositeSeriesBasisInterface to generate a function based on convolved function series. More...

#include <FunctionSeries.h>

Inheritance diagram for FunctionSeries:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

typedef FunctorBase< Real >	FunctorType

typedef Real	ValueType

typedef typename FunctorReturnType< Real, FunctorEvaluationKind::Gradient >::type	GradientType

typedef ValueType	DotType

Public Member Functions
	FunctionSeries (const InputParameters &parameters)

virtual Real	evaluateValue (Real t, const Point &p) override
	Used in derived classes, equivalent to Function::value()

Real	expand ()
	Expand the function series at the current location and with the current coefficients.

Real	expand (const std::vector< Real > &coefficients)
	Expand the function using the provided coefficients at the current location.

std::size_t	getNumberOfTerms () const
	Returns the number of terms (coefficients) in the underlying function series.

Real	getStandardizedFunctionVolume () const
	Returns the volume of evaluation in the functional series standardized space.

const std::vector< std::size_t > &	getOrders () const
	Returns a vector of the functional orders in the underlying functional series.

const std::vector< Real > &	getGeneration ()
	Returns a vector of the generation-evaluated functional series at the current location.

const std::vector< Real > &	getExpansion ()
	Returns a vector of the expansion-evaluated functional series at the current location.

bool	isInPhysicalBounds (const Point &point) const
	Returns true if the provided point is within the set physical boundaries.

void	setLocation (const Point &point)
	Set the current evaluation location.

virtual void	meshChanged () override

void	useCache (bool use)
	Enable/disable the cache.

virtual Real	value (Real time, const Point &point) const final

virtual ADReal	value (const ADReal &time, const ADPoint &point) const final

virtual Real	value (Real t, const Point &p) const

virtual ADReal	value (const ADReal &t, const ADPoint &p) const

ChainedReal	value (const ChainedReal &t) const

auto	value (const U &t) const

auto	value (const U &t, const U &x, const U &y=0, const U &z=0) const

ChainedReal	value (const ChainedReal &t) const

auto	value (const U &t) const

auto	value (const U &t, const U &x, const U &y=0, const U &z=0) const

virtual RealVectorValue	vectorValue (Real t, const Point &p) const

virtual RealVectorValue	curl (Real t, const Point &p) const

virtual Real	div (Real t, const Point &p) const

virtual RealGradient	gradient (Real t, const Point &p) const

GradientType	gradient (const ElemArg &elem, const StateArg &state) const

GradientType	gradient (const FaceArg &face, const StateArg &state) const

GradientType	gradient (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradient (const NodeArg &node, const StateArg &state) const

GradientType	gradient (const ElemArg &elem, const StateArg &state) const

GradientType	gradient (const FaceArg &face, const StateArg &state) const

GradientType	gradient (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradient (const NodeArg &node, const StateArg &state) const

GradientType	gradient (const ElemArg &elem, const StateArg &state) const

GradientType	gradient (const FaceArg &face, const StateArg &state) const

GradientType	gradient (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradient (const NodeArg &node, const StateArg &state) const

virtual Real	timeDerivative (Real t, const Point &p) const

auto	timeDerivative (const U &t) const

auto	timeDerivative (const U &t, const U &x, const U &y=0, const U &z=0) const

auto	timeDerivative (const U &t) const

auto	timeDerivative (const U &t, const U &x, const U &y=0, const U &z=0) const

virtual Real	integral () const

virtual Real	average () const

virtual Real	timeIntegral (Real t1, Real t2, const Point &p) const

void	timestepSetup () override

void	residualSetup () override final

void	jacobianSetup () override final

void	customSetup (const ExecFlagType &exec_type) override final

bool	hasBlocks (SubdomainID) const override

bool	supportsFaceArg () const override final

bool	supportsElemSideQpArg () const override final

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

virtual void	initialSetup ()

virtual void	subdomainSetup ()

const ExecFlagEnum &	getExecuteOnEnum () const

bool	isImplicit ()

Moose::StateArg	determineState () const

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessorByName (const PostprocessorName &name) const

std::size_t	coupledPostprocessors (const std::string &param_name) const

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

const std::vector< MooseVariableScalar * > &	getCoupledMooseScalarVars ()

const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const

const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const

FunctorReturnType< Real, FET >::type	genericEvaluate (const Space &r, const State &state) const

const MooseFunctorName &	functorName () const

void	setCacheClearanceSchedule (const std::set< ExecFlagType > &clearance_schedule)

virtual bool	isExtrapolatedBoundaryFace (const FaceInfo &, const Elem *, const StateArg &) const

virtual bool	isExtrapolatedBoundaryFace (const FaceInfo &, const Elem *, const StateArg &) const

bool	isInternalFace (const FaceInfo &) const

virtual bool	isConstant () const

virtual bool	hasFaceSide (const FaceInfo &fi, const bool fi_elem_side) const override

void	checkFace (const Moose::FaceArg &face) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

ValueType	operator() (const ElemArg &elem, const StateArg &state) const

ValueType	operator() (const FaceArg &face, const StateArg &state) const

ValueType	operator() (const ElemQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemSideQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemPointArg &elem_point, const StateArg &state) const

ValueType	operator() (const NodeArg &node, const StateArg &state) const

ValueType	operator() (const ElemArg &elem, const StateArg &state) const

ValueType	operator() (const FaceArg &face, const StateArg &state) const

ValueType	operator() (const ElemQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemSideQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemPointArg &elem_point, const StateArg &state) const

ValueType	operator() (const NodeArg &node, const StateArg &state) const

ValueType	operator() (const ElemArg &elem, const StateArg &state) const

ValueType	operator() (const FaceArg &face, const StateArg &state) const

ValueType	operator() (const ElemQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemSideQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemPointArg &elem_point, const StateArg &state) const

ValueType	operator() (const NodeArg &node, const StateArg &state) const

DotType	dot (const ElemArg &elem, const StateArg &state) const

DotType	dot (const FaceArg &face, const StateArg &state) const

DotType	dot (const ElemQpArg &qp, const StateArg &state) const

DotType	dot (const ElemSideQpArg &qp, const StateArg &state) const

DotType	dot (const ElemPointArg &elem_point, const StateArg &state) const

DotType	dot (const NodeArg &node, const StateArg &state) const

DotType	dot (const ElemArg &elem, const StateArg &state) const

DotType	dot (const FaceArg &face, const StateArg &state) const

DotType	dot (const ElemQpArg &qp, const StateArg &state) const

DotType	dot (const ElemSideQpArg &qp, const StateArg &state) const

DotType	dot (const ElemPointArg &elem_point, const StateArg &state) const

DotType	dot (const NodeArg &node, const StateArg &state) const

DotType	dot (const ElemArg &elem, const StateArg &state) const

DotType	dot (const FaceArg &face, const StateArg &state) const

DotType	dot (const ElemQpArg &qp, const StateArg &state) const

DotType	dot (const ElemSideQpArg &qp, const StateArg &state) const

DotType	dot (const ElemPointArg &elem_point, const StateArg &state) const

DotType	dot (const NodeArg &node, const StateArg &state) const

GradientType	gradDot (const ElemArg &elem, const StateArg &state) const

GradientType	gradDot (const FaceArg &face, const StateArg &state) const

GradientType	gradDot (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradDot (const NodeArg &node, const StateArg &state) const

GradientType	gradDot (const ElemArg &elem, const StateArg &state) const

GradientType	gradDot (const FaceArg &face, const StateArg &state) const

GradientType	gradDot (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradDot (const NodeArg &node, const StateArg &state) const

GradientType	gradDot (const ElemArg &elem, const StateArg &state) const

GradientType	gradDot (const FaceArg &face, const StateArg &state) const

GradientType	gradDot (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradDot (const NodeArg &node, const StateArg &state) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Real	operator[] (std::size_t index) const
	Get the value of the coefficient at the corresponding index.

const std::vector< std::size_t > &	getCharacteristics () const
	Get a reference to the characteristics array.

const std::vector< Real > &	getCoefficients () const
	Get a read-only reference to the vector of coefficients.

std::vector< Real > &	getCoefficients ()
	Get a writeable reference to the vector of coefficients.

std::string	getCoefficientsTable () const
	Get a formatted string of the coefficients.

std::size_t	getSize () const
	Get the size, aka number of coefficients.

bool	isCompatibleWith (const MutableCoefficientsInterface &other) const
	Checks to see if another instance is compatible.

bool	isSizeEnforced () const
	Returns true if the size of the coefficient array is fixed and enforced.

void	enforceSize (bool enforce)
	Toggle whether the size of the coefficient array can be changed.

void	importCoefficients (const MutableCoefficientsInterface &other)
	Import the coefficients from another instance.

void	resize (std::size_t size, Real fill=0.0, bool fill_out_to_size=true)
	Resize the array, using the value for fill if the new size is larger.

void	setCharacteristics (const std::vector< std::size_t > &new_characteristics)
	Sets the characteristics array.

void	setCoefficients (const std::vector< Real > &new_coefficients)
	Set the coefficients using a copy operation.

void	setCoefficients (std::vector< Real > &&dropin_coefficients)
	Set the coefficients using a move operation (only works with temp objects)

Static Public Member Functions
static InputParameters	validParams ()

static FunctionSeries &	checkAndConvertFunction (const Function &function, const std::string &typeName, const std::string &objectName)
	Static function to cast a Function to SeriesFunction.

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

Protected Member Functions
virtual void	coefficientsChanged () override
	Called when the coefficients have been changed.

void	invalidateCache ()
	Called by derived classes to invalidate the cache, perhaps due to a state change.

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

virtual void	addUserObjectDependencyHelper (const UserObjectBase &) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const

unsigned int	coupledScalarComponents (const std::string &var_name) const

unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const

libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const

const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const

virtual GradientType	evaluateGradDot (const ElemArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const NodeArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const NodeArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const NodeArg &, const StateArg &) const

const Function &	getFunction (const std::string &name) const

const Function &	getFunctionByName (const FunctionName &name) const

bool	hasFunction (const std::string &param_name) const

bool	hasFunctionByName (const FunctionName &name) const

Moose::Kokkos::Function	getKokkosFunction (const std::string &name) const

const T &	getKokkosFunction (const std::string &name) const

Moose::Kokkos::Function	getKokkosFunctionByName (const FunctionName &name) const

const T &	getKokkosFunctionByName (const FunctionName &name) const

bool	hasKokkosFunction (const std::string &param_name) const

bool	hasKokkosFunctionByName (const FunctionName &name) const

Protected Attributes
const std::vector< std::size_t >	_orders
	The vector holding the orders of each single series.

const std::vector< Real >	_physical_bounds
	The physical bounds of the function series.

std::unique_ptr< CompositeSeriesBasisInterface >	_series_type
	Stores a pointer to the functional series object.

const MooseEnum &	_series_type_name
	Stores the name of the current functional series type.

const MooseEnum &	_x
	Stores the name of the single function series to use in the x direction.

const MooseEnum &	_y
	Stores the name of the single function series to use in the y direction.

const MooseEnum &	_z
	Stores the name of the single function series to use in the z direction.

const MooseEnum &	_disc
	Stores the name of the single function series to use for a unit disc.

const MooseEnum &	_expansion_type
	The normalization type for expansion.

const MooseEnum &	_generation_type
	The normalization type for generation.

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

const InputParameters &	_ti_params

FEProblemBase &	_ti_feproblem

bool	_is_implicit

Real &	_t

const Real &	_t_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_is_transient

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

const Parallel::Communicator &	_communicator

std::vector< std::size_t > &	_characteristics
	An array of integer characteristics that can be used to check compatibility.

std::vector< Real > &	_coefficients
	The coefficient array.

bool	_enforce_size
	Boolean that locks or allows resizing of the coefficient array.

const bool	_print_coefficients
	Boolean to flag if the coefficients should be printed when set.

Private Types
typedef Moose::ElemArg	ElemArg

typedef Moose::ElemQpArg	ElemQpArg

typedef Moose::ElemSideQpArg	ElemSideQpArg

typedef Moose::FaceArg	FaceArg

typedef Moose::ElemPointArg	ElemPointArg

typedef Moose::NodeArg	NodeArg

Private Member Functions
ValueType	evaluateHelper (const R &r, const Moose::StateArg &state) const

ValueType	evaluate (const ElemArg &elem, const Moose::StateArg &state) const override final

ValueType	evaluate (const FaceArg &face, const Moose::StateArg &state) const override final

ValueType	evaluate (const ElemQpArg &qp, const Moose::StateArg &state) const override final

ValueType	evaluate (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

ValueType	evaluate (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final

ValueType	evaluate (const NodeArg &node, const Moose::StateArg &state) const override final

GradientType	evaluateGradientHelper (const R &r, const Moose::StateArg &state) const

GradientType	evaluateGradient (const ElemArg &elem, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const FaceArg &face, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemQpArg &qp, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const NodeArg &node, const Moose::StateArg &state) const override final

DotType	evaluateDotHelper (const R &r, const Moose::StateArg &state) const

DotType	evaluateDot (const ElemArg &elem, const Moose::StateArg &state) const override final

DotType	evaluateDot (const FaceArg &face, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemQpArg &qp, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final

DotType	evaluateDot (const NodeArg &node, const Moose::StateArg &state) const override final

const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const

bool	postprocessorsAdded () const

const UserObjectBase &	getUserObjectFromFEProblem (const UserObjectName &object_name, const THREAD_ID tid=0) const

const T &	castUserObject (const UserObjectBase &uo_base, const std::string &param_name="") const

void	mooseObjectError (const std::string &param_name, std::stringstream &oss) const

const std::string &	userObjectType (const UserObjectBase &uo) const

const std::string &	userObjectName (const UserObjectBase &uo) const

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const

const VariableValue *	getDefaultValue (const std::string &var_name) const

const ADVariableValue *	getADDefaultValue (const std::string &var_name) const

void	checkVar (const std::string &var_name) const

void	validateExecutionerType (const std::string &name, const std::string &fn_name) const

void	clearCacheData ()

ValueType	queryQpCache (unsigned int qp, const libMesh::QBase &qrule, std::vector< std::pair< bool, Real > > &qp_cache_data, const SpaceArg &space, const StateArg &state) const

ValueType	queryFVArgCache (std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

const Moose::FunctionBase *	getKokkosFunctionByNameHelper (const FunctionName &name) const

Static Private Member Functions
static std::vector< std::size_t >	convertOrders (const std::vector< unsigned int > &orders)
	Static function to convert an array of `unsigned int` to `std::size_t`.

static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
std::unordered_map< hashing::HashValue, Real >	_cache
	Cached evaluations for each point.

Real	_current_time
	Stores the time evaluation of the cache.

bool	_enable_cache
	Flag for whether to cache values.

bool	_respect_time
	Flag for whether changes in time invalidate the cache.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

const std::string	_ti_name

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values

const MooseObject &	_uoi_moose_object

const FEProblemBase &	_uoi_feproblem

const THREAD_ID	_uoi_tid

const RestartableDataMapName	_metaname

std::string	_restartable_name

const InputParameters &	_sc_parameters

const std::string &	_sc_name

const bool	_sc_is_implicit

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_coupled_scalar_vars

std::unordered_map< std::string, std::unique_ptr< VariableValue > >	_default_value

std::unordered_map< std::string, std::unique_ptr< ADVariableValue > >	_dual_default_value

std::vector< MooseVariableScalar * >	_coupled_moose_scalar_vars

std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > >	_sc_coupled_vars

std::set< TagID >	_sc_coupleable_vector_tags

std::set< TagID >	_sc_coupleable_matrix_tags

std::set< ExecFlagType >	_clearance_schedule

bool	_always_evaluate

dof_id_type	_current_qp_map_key

std::vector< std::pair< bool, ValueType > > *	_current_qp_map_value

std::unordered_map< dof_id_type, std::vector< std::pair< bool, ValueType > > >	_qp_to_value

dof_id_type	_current_side_qp_map_key

std::vector< std::vector< std::pair< bool, ValueType > > > *	_current_side_qp_map_value

std::unordered_map< dof_id_type, std::vector< std::vector< std::pair< bool, ValueType > > > >	_side_qp_to_value

std::map< ElemArg, ValueType >	_elem_arg_to_value

std::map< FaceArg, ValueType >	_face_arg_to_value

std::map< NodeArg, ValueType >	_node_arg_to_value

MooseFunctorName	_functor_name

const MooseObject &	_fni_object

const InputParameters &	_fni_params

FEProblemBase &	_fni_feproblem

const THREAD_ID	_fni_tid

Friends
std::ostream &	operator<< (std::ostream &stream, const FunctionSeries &me)
	Returns a tabularized text stream of the currently stored coefficients.

Detailed Description

This class uses implementations of CompositeSeriesBasisInterface to generate a function based on convolved function series.

Its inheritance tree includes MutableCoefficientsInterface, which enables easy MultiApp transfers of coefficients.

Definition at line 20 of file FunctionSeries.h.

Constructor & Destructor Documentation

◆ FunctionSeries()

FunctionSeries::FunctionSeries ( const InputParameters & parameters )

Definition at line 74 of file FunctionSeries.C.

  : MutableCoefficientsFunctionInterface(this, parameters),
    _orders(convertOrders(getParam<std::vector<unsigned int>>("orders"))),
    _physical_bounds(getParam<std::vector<Real>>("physical_bounds")),
    _series_type_name(getParam<MooseEnum>("series_type")),
    _x(getParam<MooseEnum>("x")),
    _y(getParam<MooseEnum>("y")),
    _z(getParam<MooseEnum>("z")),
    _disc(getParam<MooseEnum>("disc")),
    _expansion_type(getParam<MooseEnum>("expansion_type")),
    _generation_type(getParam<MooseEnum>("generation_type"))
{
  std::vector<MooseEnum> domains;
  std::vector<MooseEnum> types;
 
  if (_series_type_name == "Cartesian")
  {
    /*
     * For Cartesian series, at least one of 'x', 'y', and 'z' must be specified.
     *
     * The individual series are always stored in x, y, z order (independent of the order in which
     * they appear in the input file). Hence, the 'orders' and 'physical_bounds' vectors must always
     * be specified in x, y, z order.
     */
    if (isParamValid("x"))
    {
      domains.push_back(FunctionalBasisInterface::_domain_options = "x");
      types.push_back(_x);
    }
    if (isParamValid("y"))
    {
      domains.push_back(FunctionalBasisInterface::_domain_options = "y");
      types.push_back(_y);
    }
    if (isParamValid("z"))
    {
      domains.push_back(FunctionalBasisInterface::_domain_options = "z");
      types.push_back(_z);
    }
    if (types.size() == 0)
      mooseError("Must specify one of 'x', 'y', or 'z' for 'Cartesian' series!");
    _series_type = std::make_unique<Cartesian>(
        domains, _orders, types, name(), _expansion_type, _generation_type);
  }
  else if (_series_type_name == "CylindricalDuo")
  {
    /*
     * CylindricalDuo represents a disc-axial expansion, where the disc is described by a single
     * series, such as Zernike (as opposed to a series individually representing r and a second
     * series independently representing theta. For CylindricalDuo series, the series are always
     * stored in the axial, planar order, independent of which order the series appear in the input
     * file. Therefore, the _orders and _physical_bounds vectors must always appear in axial, planar
     * order. The first entry in _domains is interpreted as the axial direction, and the following
     * two as the planar.
     */
    if (isParamValid("x"))
    {
      domains = {FunctionalBasisInterface::_domain_options = "x",
                 FunctionalBasisInterface::_domain_options = "y",
                 FunctionalBasisInterface::_domain_options = "z"};
      types.push_back(_x);
    }
    if (isParamValid("y"))
    {
      domains = {FunctionalBasisInterface::_domain_options = "y",
                 FunctionalBasisInterface::_domain_options = "x",
                 FunctionalBasisInterface::_domain_options = "z"};
      types.push_back(_y);
    }
    if (isParamValid("z"))
    {
      domains = {FunctionalBasisInterface::_domain_options = "z",
                 FunctionalBasisInterface::_domain_options = "x",
                 FunctionalBasisInterface::_domain_options = "y"};
      types.push_back(_z);
    }
 
    if (types.size() == 0)
      mooseError("Must specify one of 'x', 'y', or 'z' for 'CylindricalDuo' series!");
 
    if (types.size() > 1)
      mooseError("Cannot specify more than one of 'x', 'y', or 'z' for 'CylindricalDuo' series!");
 
    types.push_back(_disc);
    _series_type = std::make_unique<CylindricalDuo>(
        domains, _orders, types, name(), _expansion_type, _generation_type);
  }
  else
    mooseError("Unknown functional series type \"", _series_type_name, "\"");
 
  // Set the physical bounds of each of the single series if defined
  if (isParamValid("physical_bounds"))
    _series_type->setPhysicalBounds(_physical_bounds);
 
  // Resize the coefficient array as needed
  enforceSize(false), resize(getNumberOfTerms(), 0.0), enforceSize(true);
  setCharacteristics(_orders);
}

Member Function Documentation

◆ checkAndConvertFunction()

FunctionSeries & FunctionSeries::checkAndConvertFunction	(	const Function &	function,
		const std::string &	typeName,
		const std::string &	objectName
	)

static

Static function to cast a Function to SeriesFunction.

Definition at line 174 of file FunctionSeries.C.

{
  const FunctionSeries * test = dynamic_cast<const FunctionSeries *>(&function);
  if (!test)
    ::mooseError("In ",
                 typeName,
                 "-type object \"",
                 objectName,
                 "\": the named Function \"",
                 function.name(),
                 "\" must be a FunctionSeries-type object.");
 
  return *const_cast<FunctionSeries *>(test);
}

Referenced by FunctionSeriesToAux::FunctionSeriesToAux(), FXFluxBC::FXFluxBC(), FXValueBC::FXValueBC(), and FXValuePenaltyBC::FXValuePenaltyBC().

◆ coefficientsChanged()

void MutableCoefficientsFunctionInterface::coefficientsChanged ( )

overrideprotectedvirtualinherited

Called when the coefficients have been changed.

Reimplemented from MutableCoefficientsInterface.

Definition at line 38 of file MutableCoefficientsFunctionInterface.C.

{
  // The coefficients have changed, which invalidates the cache
  invalidateCache();
}

◆ convertOrders()

std::vector< std::size_t > FunctionSeries::convertOrders ( const std::vector< unsigned int > & orders )

staticprivate

Static function to convert an array of unsigned int to std::size_t.

The MOOSE parser has issues reading a list of integers in as std::size_t (unsigned long), so this workaround is required in order to set _orders in the constructor initializer list.

Definition at line 289 of file FunctionSeries.C.

{
  return std::vector<std::size_t>(orders.begin(), orders.end());
}

◆ enforceSize()

void MutableCoefficientsInterface::enforceSize ( bool enforce )

inherited

Toggle whether the size of the coefficient array can be changed.

Definition at line 111 of file MutableCoefficientsInterface.C.

{
  _enforce_size = enforce;
}

Referenced by FunctionSeries(), and MutableCoefficientsFunctionInterface::MutableCoefficientsFunctionInterface().

◆ evaluateValue()

Real FunctionSeries::evaluateValue	(	Real	time,
		const Point &	point
	)

overridevirtual

Used in derived classes, equivalent to Function::value()

Implements MemoizedFunctionInterface.

Definition at line 249 of file FunctionSeries.C.

{
  // Check that the point is within the physical bounds of the series
  if (!isInPhysicalBounds(point))
    return 0.0;
 
  // Set the location at which to evaluate the series
  setLocation(point);
 
  return expand();
}

◆ expand() [1/2]

Real FunctionSeries::expand ( )

Expand the function series at the current location and with the current coefficients.

Definition at line 262 of file FunctionSeries.C.

{
  return expand(_coefficients);
}

Referenced by evaluateValue(), and expand().

◆ expand() [2/2]

Real FunctionSeries::expand ( const std::vector< Real > & coefficients )

Expand the function using the provided coefficients at the current location.

Definition at line 268 of file FunctionSeries.C.

{
  // Evaluate all of the terms in the series
  const std::vector<Real> & terms = getExpansion();
 
  return std::inner_product(terms.begin(), terms.end(), coefficients.begin(), 0.0);
}

◆ getCharacteristics()

const std::vector< std::size_t > & MutableCoefficientsInterface::getCharacteristics ( ) const

inherited

Get a reference to the characteristics array.

Definition at line 51 of file MutableCoefficientsInterface.C.

{
  return _characteristics;
}

◆ getCoefficients() [1/2]

std::vector< Real > & MutableCoefficientsInterface::getCoefficients ( )

inherited

Get a writeable reference to the vector of coefficients.

Definition at line 63 of file MutableCoefficientsInterface.C.

{
  return _coefficients;
}

◆ getCoefficients() [2/2]

const std::vector< Real > & MutableCoefficientsInterface::getCoefficients ( ) const

inherited

Get a read-only reference to the vector of coefficients.

Definition at line 57 of file MutableCoefficientsInterface.C.

{
  return _coefficients;
}

◆ getCoefficientsTable()

std::string MutableCoefficientsInterface::getCoefficientsTable ( ) const

inherited

Get a formatted string of the coefficients.

Definition at line 69 of file MutableCoefficientsInterface.C.

{
  std::stringbuf string;
  std::ostream table(&string);
 
  table << *this;
 
  return string.str();
}

◆ getExpansion()

const std::vector< Real > & FunctionSeries::getExpansion ( )

Returns a vector of the expansion-evaluated functional series at the current location.

Definition at line 226 of file FunctionSeries.C.

{
  return _series_type->getAllExpansion();
}

Referenced by expand().

◆ getGeneration()

const std::vector< Real > & FunctionSeries::getGeneration ( )

Returns a vector of the generation-evaluated functional series at the current location.

Definition at line 215 of file FunctionSeries.C.

{
  return _series_type->getAllGeneration();
}

◆ getNumberOfTerms()

std::size_t FunctionSeries::getNumberOfTerms ( ) const

Returns the number of terms (coefficients) in the underlying function series.

Definition at line 198 of file FunctionSeries.C.

{
  return _series_type->getNumberOfTerms();
}

Referenced by FunctionSeries(), and FXIntegralBaseUserObject< IntegralBaseVariableUserObject >::FXIntegralBaseUserObject().

◆ getOrders()

const std::vector< size_t > & FunctionSeries::getOrders ( ) const

Returns a vector of the functional orders in the underlying functional series.

Definition at line 204 of file FunctionSeries.C.

{
  return _orders;
}

Referenced by FXIntegralBaseUserObject< IntegralBaseVariableUserObject >::FXIntegralBaseUserObject().

◆ getSize()

std::size_t MutableCoefficientsInterface::getSize ( ) const

inherited

Get the size, aka number of coefficients.

Definition at line 80 of file MutableCoefficientsInterface.C.

{
  return _coefficients.size();
}

Referenced by MutableCoefficientsInterface::isCompatibleWith().

◆ getStandardizedFunctionVolume()

Real FunctionSeries::getStandardizedFunctionVolume ( ) const

Returns the volume of evaluation in the functional series standardized space.

Definition at line 192 of file FunctionSeries.C.

{
  return _series_type->getStandardizedFunctionVolume();
}

◆ importCoefficients()

void MutableCoefficientsInterface::importCoefficients ( const MutableCoefficientsInterface & other )

inherited

Import the coefficients from another instance.

Definition at line 117 of file MutableCoefficientsInterface.C.

{
  if (!isCompatibleWith(other))
    mooseError("Cannot import coefficients from incompatible MutableCoefficientsInterface");
 
  _coefficients = other._coefficients;
 
  if (_print_coefficients)
    _console << *this;
 
  coefficientsChanged();
}

Referenced by MultiAppFXTransfer::execute().

◆ invalidateCache()

void MemoizedFunctionInterface::invalidateCache ( )

protectedinherited

Called by derived classes to invalidate the cache, perhaps due to a state change.

Definition at line 89 of file MemoizedFunctionInterface.C.

{
  _cache.clear();
}

Referenced by MutableCoefficientsFunctionInterface::coefficientsChanged(), MemoizedFunctionInterface::meshChanged(), MemoizedFunctionInterface::useCache(), and MemoizedFunctionInterface::value().

◆ isCompatibleWith()

bool MutableCoefficientsInterface::isCompatibleWith ( const MutableCoefficientsInterface & other ) const

inherited

Checks to see if another instance is compatible.

Definition at line 86 of file MutableCoefficientsInterface.C.

{
  // Check the coefficient sizes if requested
  if ((_enforce_size && other._enforce_size) && getSize() != other.getSize())
    return false;
 
  // Check the size of the characteristics array
  if (_characteristics.size() != other._characteristics.size())
    return false;
 
  // Check the values of the characteristics array
  for (std::size_t i = 0; i < _characteristics.size(); ++i)
    if (_characteristics[i] != other._characteristics[i])
      return false;
 
  return true;
}

Referenced by MultiAppFXTransfer::execute(), and MutableCoefficientsInterface::importCoefficients().

◆ isInPhysicalBounds()

bool FunctionSeries::isInPhysicalBounds ( const Point & point ) const

Returns true if the provided point is within the set physical boundaries.

Definition at line 237 of file FunctionSeries.C.

{
  return _series_type->isInPhysicalBounds(point);
}

Referenced by evaluateValue().

◆ isSizeEnforced()

bool MutableCoefficientsInterface::isSizeEnforced ( ) const

inherited

Returns true if the size of the coefficient array is fixed and enforced.

Definition at line 105 of file MutableCoefficientsInterface.C.

{
  return _enforce_size;
}

◆ meshChanged()

void MemoizedFunctionInterface::meshChanged ( )

overridevirtualinherited

Reimplemented from Function.

Definition at line 39 of file MemoizedFunctionInterface.C.

{
  // The mesh has changed, which invalidates the cache
  invalidateCache();
}

◆ operator[]()

Real MutableCoefficientsInterface::operator[] ( std::size_t index ) const

inherited

Get the value of the coefficient at the corresponding index.

Definition at line 45 of file MutableCoefficientsInterface.C.

{
  return _coefficients[index];
}

◆ resize()

void MutableCoefficientsInterface::resize	(	std::size_t	size,
		Real	fill = `0.0`,
		bool	fill_out_to_size = `true`
	)

inherited

Resize the array, using the value for fill if the new size is larger.

Definition at line 131 of file MutableCoefficientsInterface.C.

{
  if (size != _coefficients.size())
  {
    if (_enforce_size &&
        (size > _coefficients.size() || (size < _coefficients.size() && !fill_out_to_size)))
      mooseError("Cannot resize coefficient array with size enforcement enabled.");
 
    _coefficients.resize(size, fill);
 
    if (_print_coefficients)
      _console << *this;
 
    coefficientsChanged();
  }
}

Referenced by FunctionSeries(), and FXIntegralBaseUserObject< IntegralBaseVariableUserObject >::FXIntegralBaseUserObject().

◆ setCharacteristics()

void MutableCoefficientsInterface::setCharacteristics ( const std::vector< std::size_t > & new_characteristics )

inherited

Sets the characteristics array.

Definition at line 149 of file MutableCoefficientsInterface.C.

{
  _characteristics = new_characteristics;
}

Referenced by FunctionSeries().

◆ setCoefficients() [1/2]

void MutableCoefficientsInterface::setCoefficients ( const std::vector< Real > & new_coefficients )

inherited

Set the coefficients using a copy operation.

Definition at line 156 of file MutableCoefficientsInterface.C.

{
  if (_enforce_size && new_coefficients.size() != _coefficients.size())
    mooseError("Cannon assigned a coefficient array with differing size when size enforcement is "
               "enabled.");
 
  _coefficients = new_coefficients;
 
  if (_print_coefficients)
    _console << *this;
 
  coefficientsChanged();
}

Referenced by MutableCoefficientsFunctionInterface::MutableCoefficientsFunctionInterface().

◆ setCoefficients() [2/2]

void MutableCoefficientsInterface::setCoefficients ( std::vector< Real > && dropin_coefficients )

inherited

Set the coefficients using a move operation (only works with temp objects)

Definition at line 171 of file MutableCoefficientsInterface.C.

{
  if (_enforce_size && dropin_coefficients.size() != _coefficients.size())
    mooseError("Cannon assigned a coefficient array with differing size when size enforcement is "
               "enabled.");
 
  _coefficients = dropin_coefficients;
 
  if (_print_coefficients)
    _console << *this;
 
  coefficientsChanged();
}

◆ setLocation()

void FunctionSeries::setLocation ( const Point & point )

Set the current evaluation location.

Definition at line 243 of file FunctionSeries.C.

{
  _series_type->setLocation(point);
}

Referenced by evaluateValue().

◆ useCache()

void MemoizedFunctionInterface::useCache ( bool use )

inherited

Enable/disable the cache.

Definition at line 80 of file MemoizedFunctionInterface.C.

{
  _enable_cache = use;
 
  if (!_enable_cache)
    invalidateCache();
}

Referenced by FXFluxBC::FXFluxBC(), FXValueBC::FXValueBC(), and FXValuePenaltyBC::FXValuePenaltyBC().

◆ validParams()

InputParameters FunctionSeries::validParams ( )

static

Definition at line 20 of file FunctionSeries.C.

{
  InputParameters params = MutableCoefficientsFunctionInterface::validParams();
 
  params.addClassDescription("This function uses a convolution of functional series (functional "
                             "expansion or FX) to create a 1D, 2D, or 3D function");
 
  // The available composite series types.
  //   Cartesian:      1D, 2D, or 3D, depending on which of x, y, and z are present
  //   CylindricalDuo: planar disc expansion and axial expansion
  MooseEnum series_types("Cartesian CylindricalDuo");
  MooseEnum single_series_types_1D("Legendre");
  MooseEnum single_series_types_2D("Zernike");
 
  params.addRequiredParam<MooseEnum>(
      "series_type", series_types, "The type of function series to construct.");
 
  /*
   * This needs to use `unsigned int` instead of `std::size_t` because otherwise MOOSE errors at
   * runtime
   */
  params.addRequiredParam<std::vector<unsigned int>>("orders",
                                                     "The order of each series. These must be "
                                                     "defined as \"x y z\" for Cartesian, and \"z "
                                                     "disc\" for CylindricalDuo.");
 
  params.addParam<std::vector<Real>>("physical_bounds",
                                     "The physical bounds of the function series. These must be "
                                     "defined as \"x_min x_max y_min y_max z_min z_max\" for "
                                     "Cartesian, and \"axial_min axial_max disc_center1 "
                                     "disc_center2 radius\" for CylindricalDuo");
 
  params.addParam<MooseEnum>("x", single_series_types_1D, "The series to use for the x-direction.");
  params.addParam<MooseEnum>("y", single_series_types_1D, "The series to use for the y-direction.");
  params.addParam<MooseEnum>("z", single_series_types_1D, "The series to use for the z-direction.");
 
  params.addParam<MooseEnum>("disc",
                             single_series_types_2D,
                             "The series to use for the disc. Its direction is determined by "
                             "orthogonality to the declared direction of the axis.");
 
  std::string normalization_types = "orthonormal sqrt_mu standard";
  MooseEnum expansion_type(normalization_types, "standard");
  MooseEnum generation_type(normalization_types, "orthonormal");
  params.addParam<MooseEnum>("expansion_type",
                             expansion_type,
                             "The normalization used for expansion of the basis functions");
  params.addParam<MooseEnum>(
      "generation_type",
      generation_type,
      "The normalization used for generation of the basis function coefficients");
  return params;
}

◆ value() [1/10]

virtual ADReal Function::value	(	const ADReal &	t,
		const ADPoint &	p
	)		const

virtualinherited

Reimplemented from Function.

◆ value() [2/10]

ADReal MemoizedFunctionInterface::value	(	const ADReal &	time,
		const ADPoint &	point
	)		const

finalvirtualinherited

Reimplemented from Function.

Definition at line 74 of file MemoizedFunctionInterface.C.

{
  mooseError("Not implemented");
}

◆ value() [3/10]

ChainedReal Function::value ( const ChainedReal & t ) const

inherited

◆ value() [4/10]

ChainedReal Function::value ( const ChainedReal & t ) const

inherited

◆ value() [5/10]

auto Function::value ( const U & t ) const

inherited

◆ value() [6/10]

auto Function::value ( const U & t ) const

inherited

◆ value() [7/10]

auto Function::value	(	const U &	t,
		const U &	x,
		const U &	y = `0`,
		const U &	z = `0`
	)		const

inherited

◆ value() [8/10]

auto Function::value	(	const U &	t,
		const U &	x,
		const U &	y = `0`,
		const U &	z = `0`
	)		const

inherited

◆ value() [9/10]

virtual Real Function::value	(	Real	t,
		const Point &	p
	)		const

virtualinherited

Reimplemented from Function.

◆ value() [10/10]

Real MemoizedFunctionInterface::value	(	Real	time,
		const Point &	point
	)		const

finalvirtualinherited

Reimplemented from Function.

Definition at line 46 of file MemoizedFunctionInterface.C.

{
  MemoizedFunctionInterface * ptr = const_cast<MemoizedFunctionInterface *>(this);
 
  if (_enable_cache)
  {
    // Start the cache over if we are at a new time step
    if (_respect_time && time != _current_time)
    {
      _current_time = time;
      ptr->invalidateCache();
    }
 
    // Try to insert a new value into the cache
    auto result = _cache.insert({hashing::hashCombine(time, point), 0.0});
 
    // Evaluate and apply if the insertion worked, i.e. the element didn't exist
    if (result.second)
      result.first->second = ptr->evaluateValue(time, point);
 
    // Return the cached value
    return result.first->second;
  }
 
  return ptr->evaluateValue(time, point);
}

Friends And Related Symbol Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	stream,
		const FunctionSeries &	me
	)

friend

Returns a tabularized text stream of the currently stored coefficients.

Definition at line 276 of file FunctionSeries.C.

{
  stream << "\n\n"
         << "FunctionSeries: " << me.name() << "\n"
         << "         Terms: " << me.getNumberOfTerms() << "\n";
  me._series_type->formatCoefficients(stream, me._coefficients);
  stream << "\n\n" << std::flush;
 
  return stream;
}