Moose::VectorCompositeFunctor< T > Class Template Reference

A functor that returns a vector composed of its component functor evaluations. More...

#include <VectorCompositeFunctor.h>

Inheritance diagram for Moose::VectorCompositeFunctor< T >:

Public Types
template<typename U >
using	FunctorBase = FunctorBase< U >
using	FunctorType = FunctorBase< VectorValue< T > >
using	ValueType = VectorValue< T >
using	GradientType = typename FunctorReturnType< VectorValue< T >, FunctorEvaluationKind::Gradient >::type
	This rigmarole makes it so that a user can create functors that return containers (std::vector, std::array).
using	DotType = ValueType

Public Member Functions
	VectorCompositeFunctor (const MooseFunctorName &name, const FunctorBase< T > &x_comp, const FunctorBase< T > &y_comp, const FunctorBase< T > &z_comp)
	From xyz component constructor.
	VectorCompositeFunctor (const MooseFunctorName &name, const FunctorBase< T > &x_comp, const FunctorBase< T > &y_comp)
	From xy component constructor.
	VectorCompositeFunctor (const MooseFunctorName &name, const FunctorBase< T > &x_comp)
	From x component constructor.
virtual bool	hasBlocks (SubdomainID sub_id) const override
	Returns whether the functor is defined on this block.
bool	supportsFaceArg () const override
	Whether this functor supports evaluation with FaceArg.
bool	supportsElemSideQpArg () const override
	Whether this functor supports evaluation with ElemSideQpArg.
FunctorReturnType< VectorValue< T >, FET >::type	genericEvaluate (const Space &r, const State &state) const
	Perform a generic evaluation based on the supplied template argument FET and supplied spatial and temporal arguments.
const MooseFunctorName &	functorName () const
	Return the functor name.
virtual void	residualSetup () override
virtual void	jacobianSetup () override
virtual void	timestepSetup () override
virtual void	customSetup (const ExecFlagType &exec_type) override
void	setCacheClearanceSchedule (const std::set< ExecFlagType > &clearance_schedule)
	Set how often to clear the functor evaluation cache.
virtual bool	isExtrapolatedBoundaryFace (const FaceInfo &, const Elem *, const StateArg &) const
	Returns whether this (sided) face is an extrapolated boundary face for this functor.
bool	isInternalFace (const FaceInfo &) const
	Returns true if the face is an internal face.
virtual bool	isConstant () const
	Returns true if this functor is a constant.
virtual bool	hasFaceSide (const FaceInfo &fi, const bool fi_elem_side) const override
void	checkFace (const Moose::FaceArg &face) const
	Examines the incoming face argument.
ValueType	operator() (const ElemArg &elem, const StateArg &state) const
	Same as their evaluate overloads with the same arguments but allows for caching implementation.
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
GradientType	gradient (const ElemArg &elem, const StateArg &state) const
	Same as their evaluateGradient overloads with the same arguments but allows for caching implementation.
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
DotType	dot (const ElemArg &elem, const StateArg &state) const
	Same as their evaluateDot overloads with the same arguments but allows for caching implementation.
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
	Same as their evaluateGradDot overloads with the same arguments but allows for caching implementation.
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

Protected Member Functions
Functor evaluation routines
These methods are all for evaluating functors with different kinds of spatial arguments. Each of these methods also takes a state argument. For a description of the state argument, please see the StateArg doxygen
virtual GradientType	evaluateGradient (const FaceArg &, const StateArg &) const
virtual GradientType	evaluateGradient (const ElemQpArg &, const StateArg &) const
virtual GradientType	evaluateGradient (const ElemSideQpArg &, const StateArg &) const
virtual GradientType	evaluateGradient (const ElemPointArg &, const StateArg &) const
	Evaluate the functor gradient with a given element and point.
virtual GradientType	evaluateGradient (const NodeArg &, const StateArg &) const
virtual DotType	evaluateDot (const ElemQpArg &, const StateArg &) const
virtual DotType	evaluateDot (const ElemSideQpArg &, const StateArg &) const
virtual DotType	evaluateDot (const ElemPointArg &, const StateArg &) const
	Evaluate the functor time derivative with a given element and point.
virtual DotType	evaluateDot (const NodeArg &, const StateArg &) const
virtual GradientType	evaluateGradDot (const ElemArg &, const StateArg &) const
	Evaluate the functor gradient-dot with a given element.
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
	Evaluate the functor gradient-dot with a given element and point.
virtual GradientType	evaluateGradDot (const NodeArg &, const StateArg &) const

Private Member Functions
ValueType	evaluate (const ElemArg &elem_arg, const StateArg &state) const override
	Evaluate the functor with a given element.
ValueType	evaluate (const FaceArg &face, const StateArg &state) const override
ValueType	evaluate (const ElemQpArg &elem_qp, const StateArg &state) const override
ValueType	evaluate (const ElemSideQpArg &elem_side_qp, const StateArg &state) const override
ValueType	evaluate (const ElemPointArg &elem_point_arg, const StateArg &state) const override
	Evaluate the functor with a given element and point.
ValueType	evaluate (const NodeArg &node_arg, const StateArg &state) const override
GradientType	evaluateGradient (const ElemArg &elem_arg, const StateArg &state) const override
	Evaluate the functor gradient with a given element.
DotType	evaluateDot (const FaceArg &face_arg, const StateArg &state) const override
DotType	evaluateDot (const ElemArg &elem_arg, const StateArg &state) const override
	Evaluate the functor time derivative with a given element.
void	clearCacheData ()
	clear cache data
ValueType	queryQpCache (unsigned int qp, const libMesh::QBase &qrule, std::vector< std::pair< bool, VectorValue< T > > > &qp_cache_data, const SpaceArg &space, const StateArg &state) const
	check a qp cache and if invalid then evaluate
ValueType	queryFVArgCache (std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const
	check a finite volume spatial argument cache and if invalid then evaluate

Private Attributes
std::unique_ptr< ConstantFunctor< T > >	_y_constant
	Possible holder of constant-0 y-component functor.
std::unique_ptr< ConstantFunctor< T > >	_z_constant
	Possible holder of constant-0 z-component functor.
const FunctorBase< T > &	_x_comp
	The x-component functor.
const FunctorBase< T > &	_y_comp
	The y-component functor.
const FunctorBase< T > &	_z_comp
	The z-component functor.
const bool	_has_y
	Whether the user supplied a y-functor.
const bool	_has_z
	Whether the user supplied a z-functor.
std::set< ExecFlagType >	_clearance_schedule
	How often to clear the material property cache.
bool	_always_evaluate
	Boolean to check if we always need evaluation.
dof_id_type	_current_qp_map_key
	Current key for qp map cache.
std::vector< std::pair< bool, ValueType > > *	_current_qp_map_value
	Current value for qp map cache.
std::unordered_map< dof_id_type, std::vector< std::pair< bool, ValueType > > >	_qp_to_value
	Cached element quadrature point functor property evaluations.
dof_id_type	_current_side_qp_map_key
	Current key for side-qp map cache.
std::vector< std::vector< std::pair< bool, ValueType > > > *	_current_side_qp_map_value
	Current value for side-qp map cache.
std::unordered_map< dof_id_type, std::vector< std::vector< std::pair< bool, ValueType > > > >	_side_qp_to_value
	Cached element quadrature point functor property evaluations.
std::map< ElemArg, ValueType >	_elem_arg_to_value
	Map from element arguments to their cached evaluations.
std::map< FaceArg, ValueType >	_face_arg_to_value
	Map from face arguments to their cached evaluations.
std::map< NodeArg, ValueType >	_node_arg_to_value
	Map from nodal arguments to their cached evaluations.
MooseFunctorName	_functor_name
	name of the functor

Detailed Description

template<typename T>
class Moose::VectorCompositeFunctor< T >

A functor that returns a vector composed of its component functor evaluations.

Definition at line 23 of file VectorCompositeFunctor.h.

Member Typedef Documentation

DotType

using Moose::FunctorBase< VectorValue< T > >::DotType = ValueType

inherited

Definition at line 150 of file MooseFunctor.h.

FunctorBase

template<typename T >

template<typename U >

using Moose::VectorCompositeFunctor< T >::FunctorBase = FunctorBase<U>

Definition at line 27 of file VectorCompositeFunctor.h.

FunctorType

using Moose::FunctorBase< VectorValue< T > >::FunctorType = FunctorBase<VectorValue< T > >

inherited

Definition at line 140 of file MooseFunctor.h.

GradientType

using Moose::FunctorBase< VectorValue< T > >::GradientType = typename FunctorReturnType<VectorValue< T > , FunctorEvaluationKind::Gradient>::type

inherited

This rigmarole makes it so that a user can create functors that return containers (std::vector, std::array).

This logic will make it such that if a user requests a functor type T that is a container of algebraic types, for example Reals, then the GradientType will be a container of the gradients of those algebraic types, in this example VectorValue<Reals>. So if T is std::vector<Real>, then GradientType will be std::vector<VectorValue<Real>>. As another example: T = std::array<VectorValue<Real>, 1> -> GradientType = std::array<TensorValue<Real>, 1>

Definition at line 149 of file MooseFunctor.h.

ValueType

using Moose::FunctorBase< VectorValue< T > >::ValueType = VectorValue< T >

inherited

Definition at line 141 of file MooseFunctor.h.

Constructor & Destructor Documentation

VectorCompositeFunctor() [1/3]

template<typename T >

Moose::VectorCompositeFunctor< T >::VectorCompositeFunctor	(	const MooseFunctorName &	name,
		const FunctorBase< T > &	x_comp,
		const FunctorBase< T > &	y_comp,
		const FunctorBase< T > &	z_comp
	)

From xyz component constructor.

Definition at line 104 of file VectorCompositeFunctor.h.

  : FunctorBase<VectorValue<T>>(name),
    _x_comp(x_comp),
    _y_comp(y_comp),
    _z_comp(z_comp),
    _has_y(true),
    _has_z(true)
{
}

VectorCompositeFunctor() [2/3]

template<typename T >

Moose::VectorCompositeFunctor< T >::VectorCompositeFunctor	(	const MooseFunctorName &	name,
		const FunctorBase< T > &	x_comp,
		const FunctorBase< T > &	y_comp
	)

From xy component constructor.

Definition at line 118 of file VectorCompositeFunctor.h.

  : FunctorBase<VectorValue<T>>(name),
    _z_constant(std::make_unique<ConstantFunctor>(T(0))),
    _x_comp(x_comp),
    _y_comp(y_comp),
    _z_comp(*_z_constant),
    _has_y(true),
    _has_z(false)
{
}

VectorCompositeFunctor() [3/3]

template<typename T >

Moose::VectorCompositeFunctor< T >::VectorCompositeFunctor	(	const MooseFunctorName &	name,
		const FunctorBase< T > &	x_comp
	)

From x component constructor.

Definition at line 132 of file VectorCompositeFunctor.h.

  : FunctorBase<VectorValue<T>>(name),
    _y_constant(std::make_unique<ConstantFunctor>(T(0))),
    _z_constant(std::make_unique<ConstantFunctor>(T(0))),
    _x_comp(x_comp),
    _y_comp(*_y_constant),
    _z_comp(*_z_constant),
    _has_y(false),
    _has_z(false)
{
}

Member Function Documentation

checkFace()

void Moose::FunctorBase< VectorValue< T > >::checkFace ( const Moose::FaceArg &  face ) const

inherited

Examines the incoming face argument.

If the face argument producer (residual object, postprocessor, etc.) did not indicate a sidedness to the face, e.g. if the face_side member of the FaceArg is nullptr, then we may "modify" the sidedness of the argument if we are only defined on one side of the face. If the face argument producer \emph has indicated a sidedness and we are not defined on that side, then we will error

Parameters

face	The face argument created by the face argument producer, likely a residual object

Returns

A face with possibly changed sidedness depending on whether we aren't defined on both sides of the face

Definition at line 280 of file MooseFunctor.h.

{
#if DEBUG
  const Elem * const elem = face.face_side;
  const FaceInfo * const fi = face.fi;
  mooseAssert(fi, "face info should be non-null");
  bool check_elem_def = false;
  bool check_neighbor_def = false;
  // We check if the functor is defined on both sides of the face
  if (!elem)
  {
    if (!hasFaceSide(*fi, true))
      check_neighbor_def = true;
    else if (!hasFaceSide(*fi, false))
      check_elem_def = true;
  }
  else if (elem == fi->elemPtr())
    check_elem_def = true;
  else
  {
    mooseAssert(elem == fi->neighborPtr(), "This has to match something");
    check_neighbor_def = true;
  }
 
  if (check_elem_def && !hasFaceSide(*fi, true))
  {
    std::string additional_message = "It is not defined on the neighbor side either.";
    if (hasFaceSide(*fi, false))
      additional_message = "It is however defined on the neighbor side.";
    additional_message += " Face centroid: " + Moose::stringify(fi->faceCentroid());
    mooseError(_functor_name,
               " is not defined on the element side of the face information, but a face argument "
               "producer "
               "(e.g. residual object, postprocessor, etc.) has requested evaluation there.\n",
               additional_message);
  }
  if (check_neighbor_def && !hasFaceSide(*fi, false))
  {
    std::string additional_message = "It is not defined on the element side either.";
    if (hasFaceSide(*fi, true))
      additional_message = "It is however defined on the element side.";
    additional_message += " Face centroid: " + Moose::stringify(fi->faceCentroid());
    mooseError(
        _functor_name,
        " is not defined on the neighbor side of the face information, but a face argument "
        "producer (e.g. residual object, postprocessor, etc.) has requested evaluation there.\n",
        additional_message);
  }
#endif
}

clearCacheData()

void Moose::FunctorBase< VectorValue< T > >::clearCacheData ( )

privateinherited

clear cache data

Definition at line 500 of file MooseFunctor.h.

{
  for (auto & map_pr : _qp_to_value)
    for (auto & pr : map_pr.second)
      pr.first = false;
 
  for (auto & map_pr : _side_qp_to_value)
  {
    auto & side_vector = map_pr.second;
    for (auto & qp_vector : side_vector)
      for (auto & pr : qp_vector)
        pr.first = false;
  }
 
  _current_qp_map_key = libMesh::DofObject::invalid_id;
  _current_qp_map_value = nullptr;
  _current_side_qp_map_key = libMesh::DofObject::invalid_id;
  _current_side_qp_map_value = nullptr;
 
  _elem_arg_to_value.clear();
  _face_arg_to_value.clear();
  _node_arg_to_value.clear();
}

customSetup()

void Moose::FunctorBase< VectorValue< T > >::customSetup ( const ExecFlagType &  exec_type )

overridevirtualinherited

Implements Moose::FunctorAbstract.

Definition at line 233 of file MooseFunctor.h.

{
  if (_clearance_schedule.count(exec_type))
    clearCacheData();
}

dot() [1/6]

FunctorBase< VectorValue< T > >::DotType Moose::FunctorBase< VectorValue< T > >::dot ( const ElemArg &  elem, const StateArg &  state  ) const

inherited

Same as their evaluateDot overloads with the same arguments but allows for caching implementation.

These are the methods a user will call in their code

Definition at line 209 of file MooseFunctor.h.

{
  return evaluateDot(elem, state);
}

dot() [2/6]

FunctorBase< VectorValue< T > >::DotType Moose::FunctorBase< VectorValue< T > >::dot ( const ElemPointArg &  elem_point, const StateArg &  state  ) const

inherited

Definition at line 213 of file MooseFunctor.h.

{
  return evaluateDot(elem_point, state);
}

dot() [3/6]

FunctorBase< VectorValue< T > >::DotType Moose::FunctorBase< VectorValue< T > >::dot ( const ElemQpArg &  qp, const StateArg &  state  ) const

inherited

Definition at line 211 of file MooseFunctor.h.

{
  return evaluateDot(elem_qp, state);
}

dot() [4/6]

FunctorBase< VectorValue< T > >::DotType Moose::FunctorBase< VectorValue< T > >::dot ( const ElemSideQpArg &  qp, const StateArg &  state  ) const

inherited

Definition at line 212 of file MooseFunctor.h.

{
  return evaluateDot(elem_side_qp, state);
}

dot() [5/6]

FunctorBase< VectorValue< T > >::DotType Moose::FunctorBase< VectorValue< T > >::dot ( const FaceArg &  face, const StateArg &  state  ) const

inherited

Definition at line 210 of file MooseFunctor.h.

{
  checkFace(face);
  return evaluateDot(face, state);
}

dot() [6/6]

FunctorBase< VectorValue< T > >::DotType Moose::FunctorBase< VectorValue< T > >::dot ( const NodeArg &  node, const StateArg &  state  ) const

inherited

Definition at line 214 of file MooseFunctor.h.

{
  return evaluateDot(node, state);
}

evaluate() [1/6]

template<typename T >

VectorCompositeFunctor< T >::ValueType Moose::VectorCompositeFunctor< T >::evaluate ( const ElemArg &  elem, const StateArg &  state  ) const

overrideprivatevirtual

Evaluate the functor with a given element.

Some example implementations of this method could compute an element-average or evaluate at the element centroid

Implements Moose::FunctorBase< VectorValue< T > >.

Definition at line 173 of file VectorCompositeFunctor.h.

{
  return {_x_comp(elem_arg, state), _y_comp(elem_arg, state), _z_comp(elem_arg, state)};
}

evaluate() [2/6]

template<typename T >

VectorCompositeFunctor< T >::ValueType Moose::VectorCompositeFunctor< T >::evaluate ( const ElemPointArg &  elem_point, const StateArg &  state  ) const

overrideprivatevirtual

Evaluate the functor with a given element and point.

Some example implementations of this method could perform a two-term Taylor expansion using cell-centered value and gradient

Implements Moose::FunctorBase< VectorValue< T > >.

Definition at line 202 of file VectorCompositeFunctor.h.

{
  return {_x_comp(elem_point_arg, state),
          _y_comp(elem_point_arg, state),
          _z_comp(elem_point_arg, state)};
}

evaluate() [3/6]

template<typename T >

VectorCompositeFunctor< T >::ValueType Moose::VectorCompositeFunctor< T >::evaluate ( const ElemQpArg &  qp, const StateArg &  state  ) const

overrideprivatevirtual

Parameters

qp	See the ElemQpArg doxygen
state	See the StateArg doxygen

Returns

The functor evaluated at the requested state and space

Implements Moose::FunctorBase< VectorValue< T > >.

Definition at line 187 of file VectorCompositeFunctor.h.

{
  return {_x_comp(elem_qp, state), _y_comp(elem_qp, state), _z_comp(elem_qp, state)};
}

evaluate() [4/6]

template<typename T >

VectorCompositeFunctor< T >::ValueType Moose::VectorCompositeFunctor< T >::evaluate ( const ElemSideQpArg &  side_qp, const StateArg &  state  ) const

overrideprivatevirtual

Parameters

side_qp	See the ElemSideQpArg doxygen
state	See the StateArg doxygen

Returns

The functor evaluated at the requested state and space

Implements Moose::FunctorBase< VectorValue< T > >.

Definition at line 194 of file VectorCompositeFunctor.h.

{
  return {_x_comp(elem_side_qp, state), _y_comp(elem_side_qp, state), _z_comp(elem_side_qp, state)};
}

evaluate() [5/6]

template<typename T >

VectorCompositeFunctor< T >::ValueType Moose::VectorCompositeFunctor< T >::evaluate ( const FaceArg &  face, const StateArg &  state  ) const

overrideprivatevirtual

Parameters

face	See the FaceArg doxygen
state	See the StateArg doxygen

Returns

The functor evaluated at the requested state and space

Implements Moose::FunctorBase< VectorValue< T > >.

Definition at line 180 of file VectorCompositeFunctor.h.

{
  return {_x_comp(face, state), _y_comp(face, state), _z_comp(face, state)};
}

evaluate() [6/6]

template<typename T >

VectorCompositeFunctor< T >::ValueType Moose::VectorCompositeFunctor< T >::evaluate ( const NodeArg &  node_arg, const StateArg &  state  ) const

overrideprivatevirtual

Implements Moose::FunctorBase< VectorValue< T > >.

Definition at line 212 of file VectorCompositeFunctor.h.

{
  return {_x_comp(node_arg, state), _y_comp(node_arg, state), _z_comp(node_arg, state)};
}

evaluateDot() [1/6]

template<typename T >

VectorCompositeFunctor< T >::DotType Moose::VectorCompositeFunctor< T >::evaluateDot ( const ElemArg &  , const StateArg &    ) const

overrideprivatevirtual

Evaluate the functor time derivative with a given element.

Some example implementations of this method could compute an element-average or evaluate at the element centroid

Reimplemented from Moose::FunctorBase< VectorValue< T > >.

Definition at line 235 of file VectorCompositeFunctor.h.

{
  return {_x_comp.dot(elem_arg, state), _y_comp.dot(elem_arg, state), _z_comp.dot(elem_arg, state)};
}

evaluateDot() [2/6]

virtual DotType Moose::FunctorBase< VectorValue< T > >::evaluateDot ( const ElemPointArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Evaluate the functor time derivative with a given element and point.

Definition at line 431 of file MooseFunctor.h.

  {
    mooseError("Element-point time derivative not implemented for functor " + functorName());
  }

evaluateDot() [3/6]

virtual DotType Moose::FunctorBase< VectorValue< T > >::evaluateDot ( const ElemQpArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Parameters

qp	See the ElemQpArg doxygen
state	See the StateArg doxygen

Returns

The functor time derivative evaluated at the requested state and space

Definition at line 411 of file MooseFunctor.h.

  {
    mooseError("Element quadrature point time derivative not implemented for functor " +
               functorName());
  }

evaluateDot() [4/6]

virtual DotType Moose::FunctorBase< VectorValue< T > >::evaluateDot ( const ElemSideQpArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Parameters

side_qp	See the ElemSideQpArg doxygen
state	See the StateArg doxygen

Returns

The functor time derivative evaluated at the requested state and space

Definition at line 422 of file MooseFunctor.h.

  {
    mooseError("Element side quadrature point time derivative not implemented for functor " +
               functorName());
  }

evaluateDot() [5/6]

template<typename T >

VectorCompositeFunctor< T >::DotType Moose::VectorCompositeFunctor< T >::evaluateDot ( const FaceArg &  , const StateArg &    ) const

overrideprivatevirtual

Parameters

face	See the FaceArg doxygen
state	See the StateArg doxygen

Returns

The functor time derivative evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< VectorValue< T > >.

Definition at line 228 of file VectorCompositeFunctor.h.

{
  return {_x_comp.dot(face_arg, state), _y_comp.dot(face_arg, state), _z_comp.dot(face_arg, state)};
}

evaluateDot() [6/6]

virtual DotType Moose::FunctorBase< VectorValue< T > >::evaluateDot ( const NodeArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Definition at line 436 of file MooseFunctor.h.

  {
    mooseError("Time derivative at node not implemented for functor " + functorName());
  }

evaluateGradDot() [1/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradDot ( const ElemArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Evaluate the functor gradient-dot with a given element.

Some example implementations of this method could compute an element-average or evaluate at the element centroid

Definition at line 445 of file MooseFunctor.h.

  {
    mooseError("Element gradient-dot not implemented for functor " + functorName());
  }

evaluateGradDot() [2/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradDot ( const ElemPointArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Evaluate the functor gradient-dot with a given element and point.

Definition at line 485 of file MooseFunctor.h.

  {
    mooseError("Element-point gradient-dot not implemented for functor " + functorName());
  }

evaluateGradDot() [3/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradDot ( const ElemQpArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Parameters

qp	See the ElemQpArg doxygen
state	See the StateArg doxygen

Returns

The functor gradient-dot evaluated at the requested state and space

Definition at line 465 of file MooseFunctor.h.

  {
    mooseError("Element quadrature point gradient-dot not implemented for functor " +
               functorName());
  }

evaluateGradDot() [4/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradDot ( const ElemSideQpArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Parameters

side_qp	See the ElemSideQpArg doxygen
state	See the StateArg doxygen

Returns

The functor gradient-dot evaluated at the requested state and space

Definition at line 476 of file MooseFunctor.h.

  {
    mooseError("Element side quadrature point gradient-dot not implemented for functor " +
               functorName());
  }

evaluateGradDot() [5/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradDot ( const FaceArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Parameters

face	See the FaceArg doxygen
state	See the StateArg doxygen

Returns

The functor gradient-dot evaluated at the requested state and space

Definition at line 455 of file MooseFunctor.h.

  {
    mooseError("Face gradient-dot not implemented for functor " + functorName());
  }

evaluateGradDot() [6/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradDot ( const NodeArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Definition at line 490 of file MooseFunctor.h.

  {
    mooseError("Gradient-dot at node not implemented for functor " + functorName());
  }

evaluateGradient() [1/6]

template<typename T >

VectorCompositeFunctor< T >::GradientType Moose::VectorCompositeFunctor< T >::evaluateGradient ( const ElemArg &  , const StateArg &    ) const

overrideprivatevirtual

Evaluate the functor gradient with a given element.

Some example implementations of this method could compute an element-average or evaluate at the element centroid

Reimplemented from Moose::FunctorBase< VectorValue< T > >.

Definition at line 219 of file VectorCompositeFunctor.h.

{
  return {_x_comp.gradient(elem_arg, state),
          _y_comp.gradient(elem_arg, state),
          _z_comp.gradient(elem_arg, state)};
}

evaluateGradient() [2/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradient ( const ElemPointArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Evaluate the functor gradient with a given element and point.

Definition at line 377 of file MooseFunctor.h.

  {
    mooseError("Element-point gradient not implemented for functor " + functorName());
  }

evaluateGradient() [3/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradient ( const ElemQpArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Parameters

qp	See the ElemQpArg doxygen
state	See the StateArg doxygen

Returns

The functor gradient evaluated at the requested state and space

Definition at line 358 of file MooseFunctor.h.

  {
    mooseError("Element quadrature point gradient not implemented for functor " + functorName());
  }

evaluateGradient() [4/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradient ( const ElemSideQpArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Parameters

side_qp	See the ElemSideQpArg doxygen
state	See the StateArg doxygen

Returns

The functor gradient evaluated at the requested state and space

Definition at line 368 of file MooseFunctor.h.

  {
    mooseError("Element side quadrature point gradient not implemented for functor " +
               functorName());
  }

evaluateGradient() [5/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradient ( const FaceArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Parameters

face	See the FaceArg doxygen
state	See the StateArg doxygen

Returns

The functor gradient evaluated at the requested state and space

Definition at line 348 of file MooseFunctor.h.

  {
    mooseError("Face gradient not implemented for functor " + functorName());
  }

evaluateGradient() [6/6]

virtual GradientType Moose::FunctorBase< VectorValue< T > >::evaluateGradient ( const NodeArg &  , const StateArg &    ) const

inlineprotectedvirtualinherited

Definition at line 382 of file MooseFunctor.h.

  {
    mooseError("Gradient at node not implemented for functor " + functorName());
  }

functorName()

const MooseFunctorName & Moose::FunctorBase< VectorValue< T > >::functorName ( ) const

inlineinherited

Return the functor name.

Definition at line 176 of file MooseFunctor.h.

{ return _functor_name; }

genericEvaluate()

FunctorReturnType< VectorValue< T > , FET >::type Moose::FunctorBase< VectorValue< T > >::genericEvaluate ( const Space &  r, const State &  state  ) const

inherited

Perform a generic evaluation based on the supplied template argument FET and supplied spatial and temporal arguments.

Definition at line 172 of file MooseFunctor.h.

{
  if constexpr (FET == FunctorEvaluationKind::Value)
    return (*this)(r, state);
  else if constexpr (FET == FunctorEvaluationKind::Gradient)
    return gradient(r, state);
  else if constexpr (FET == FunctorEvaluationKind::Dot)
    return dot(r, state);
  else
    return gradDot(r, state);
}

gradDot() [1/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradDot ( const ElemArg &  elem, const StateArg &  state  ) const

inherited

Same as their evaluateGradDot overloads with the same arguments but allows for caching implementation.

These are the methods a user will call in their code

Definition at line 222 of file MooseFunctor.h.

{
  return evaluateGradDot(elem, state);
}

gradDot() [2/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradDot ( const ElemPointArg &  elem_point, const StateArg &  state  ) const

inherited

Definition at line 226 of file MooseFunctor.h.

{
  return evaluateGradDot(elem_point, state);
}

gradDot() [3/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradDot ( const ElemQpArg &  qp, const StateArg &  state  ) const

inherited

Definition at line 224 of file MooseFunctor.h.

{
  return evaluateGradDot(elem_qp, state);
}

gradDot() [4/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradDot ( const ElemSideQpArg &  qp, const StateArg &  state  ) const

inherited

Definition at line 225 of file MooseFunctor.h.

{
  return evaluateGradDot(elem_side_qp, state);
}

gradDot() [5/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradDot ( const FaceArg &  face, const StateArg &  state  ) const

inherited

Definition at line 223 of file MooseFunctor.h.

{
  checkFace(face);
  return evaluateGradDot(face, state);
}

gradDot() [6/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradDot ( const NodeArg &  node, const StateArg &  state  ) const

inherited

Definition at line 227 of file MooseFunctor.h.

{
  return evaluateGradDot(node, state);
}

gradient() [1/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradient ( const ElemArg &  elem, const StateArg &  state  ) const

inherited

Same as their evaluateGradient overloads with the same arguments but allows for caching implementation.

These are the methods a user will call in their code

Definition at line 196 of file MooseFunctor.h.

{
  return evaluateGradient(elem, state);
}

gradient() [2/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradient ( const ElemPointArg &  elem_point, const StateArg &  state  ) const

inherited

Definition at line 200 of file MooseFunctor.h.

{
  return evaluateGradient(elem_point, state);
}

gradient() [3/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradient ( const ElemQpArg &  qp, const StateArg &  state  ) const

inherited

Definition at line 198 of file MooseFunctor.h.

{
  return evaluateGradient(elem_qp, state);
}

gradient() [4/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradient ( const ElemSideQpArg &  qp, const StateArg &  state  ) const

inherited

Definition at line 199 of file MooseFunctor.h.

{
  return evaluateGradient(elem_side_qp, state);
}

gradient() [5/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradient ( const FaceArg &  face, const StateArg &  state  ) const

inherited

Definition at line 197 of file MooseFunctor.h.

{
  checkFace(face);
  return evaluateGradient(face, state);
}

gradient() [6/6]

FunctorBase< VectorValue< T > >::GradientType Moose::FunctorBase< VectorValue< T > >::gradient ( const NodeArg &  node, const StateArg &  state  ) const

inherited

Definition at line 201 of file MooseFunctor.h.

{
  return evaluateGradient(node, state);
}

hasBlocks()

template<typename T >

virtual bool Moose::VectorCompositeFunctor< T >::hasBlocks ( SubdomainID  ) const

inlineoverridevirtual

Returns whether the functor is defined on this block.

Reimplemented from Moose::FunctorBase< VectorValue< T > >.

Definition at line 53 of file VectorCompositeFunctor.h.

  {
    const bool ret = _x_comp.hasBlocks(sub_id);
    if (_has_y)
      mooseAssert(ret == _y_comp.hasBlocks(sub_id), "x and y block restriction don't agree");
    if (_has_z)
      mooseAssert(ret == _z_comp.hasBlocks(sub_id), "x and z block restriction don't agree");
    return ret;
  }

hasFaceSide()

bool Moose::FunctorBase< VectorValue< T > >::hasFaceSide ( const FaceInfo &  fi, const bool  fi_elem_side  ) const

overridevirtualinherited

Implements FaceArgInterface.

Definition at line 268 of file MooseFunctor.h.

{
  if (fi_elem_side)
    return hasBlocks(fi.elem().subdomain_id());
  else
    return fi.neighborPtr() && hasBlocks(fi.neighbor().subdomain_id());
}

isConstant()

virtual bool Moose::FunctorBase< VectorValue< T > >::isConstant ( ) const

inlinevirtualinherited

Returns true if this functor is a constant.

Definition at line 266 of file MooseFunctor.h.

{ return false; }

isExtrapolatedBoundaryFace()

virtual bool Moose::FunctorBase< VectorValue< T > >::isExtrapolatedBoundaryFace ( const FaceInfo &  , const Elem *  , const StateArg &    ) const

inlinevirtualinherited

Returns whether this (sided) face is an extrapolated boundary face for this functor.

Definition at line 253 of file MooseFunctor.h.

  {
    mooseError("not implemented");
  }

isInternalFace()

bool Moose::FunctorBase< VectorValue< T > >::isInternalFace ( const FaceInfo &  fi ) const

inherited

Returns true if the face is an internal face.

Definition at line 261 of file MooseFunctor.h.

{
  if (!fi.neighborPtr())
    return false;
 
  return hasBlocks(fi.elem().subdomain_id()) && hasBlocks(fi.neighborPtr()->subdomain_id());
}

jacobianSetup()

void Moose::FunctorBase< VectorValue< T > >::jacobianSetup ( )

overridevirtualinherited

Implements Moose::FunctorAbstract.

Definition at line 231 of file MooseFunctor.h.

{
  if (_clearance_schedule.count(EXEC_NONLINEAR))
    clearCacheData();
}

operator()() [1/6]

FunctorBase< VectorValue< T > >::ValueType Moose::FunctorBase< VectorValue< T > >::operator() ( const ElemArg &  elem, const StateArg &  state  ) const

inherited

Same as their evaluate overloads with the same arguments but allows for caching implementation.

These are the methods a user will call in their code

Definition at line 183 of file MooseFunctor.h.

{
  if (_always_evaluate)
    return evaluate(elem, state);
 
  mooseAssert(state.state == 0,
              "Cached evaluations are only currently supported for the current state.");
 
  return queryFVArgCache(_elem_arg_to_value, elem);
}

operator()() [2/6]

FunctorBase< VectorValue< T > >::ValueType Moose::FunctorBase< VectorValue< T > >::operator() ( const ElemPointArg &  elem_point, const StateArg &  state  ) const

inherited

Definition at line 187 of file MooseFunctor.h.

{
  return evaluate(elem_point, state);
}

operator()() [3/6]

FunctorBase< VectorValue< T > >::ValueType Moose::FunctorBase< VectorValue< T > >::operator() ( const ElemQpArg &  qp, const StateArg &  state  ) const

inherited

Definition at line 185 of file MooseFunctor.h.

{
  if (_always_evaluate)
    return evaluate(elem_qp, state);
 
  const auto elem_id = elem_qp.elem->id();
  if (elem_id != _current_qp_map_key)
  {
    _current_qp_map_key = elem_id;
    _current_qp_map_value = &_qp_to_value[elem_id];
  }
  auto & qp_data = *_current_qp_map_value;
  const auto qp = elem_qp.qp;
  const auto * const qrule = elem_qp.qrule;
  mooseAssert(qrule, "qrule must be non-null");
 
  return queryQpCache(qp, *qrule, qp_data, elem_qp, state);
}

operator()() [4/6]

FunctorBase< VectorValue< T > >::ValueType Moose::FunctorBase< VectorValue< T > >::operator() ( const ElemSideQpArg &  qp, const StateArg &  state  ) const

inherited

Definition at line 186 of file MooseFunctor.h.

{
  if (_always_evaluate)
    return evaluate(elem_side_qp, state);
 
  const Elem * const elem = elem_side_qp.elem;
  mooseAssert(elem, "elem must be non-null");
  const auto elem_id = elem->id();
  if (elem_id != _current_side_qp_map_key)
  {
    _current_side_qp_map_key = elem_id;
    _current_side_qp_map_value = &_side_qp_to_value[elem_id];
  }
  auto & side_qp_data = *_current_side_qp_map_value;
  const auto side = elem_side_qp.side;
  const auto qp = elem_side_qp.qp;
  const auto * const qrule = elem_side_qp.qrule;
  mooseAssert(qrule, "qrule must be non-null");
 
  // Check and see whether we even have sized for this side
  if (side >= side_qp_data.size())
    side_qp_data.resize(elem->n_sides());
 
  // Ok we were sized enough for our side
  auto & qp_data = side_qp_data[side];
  return queryQpCache(qp, *qrule, qp_data, elem_side_qp, state);
}

operator()() [5/6]

FunctorBase< VectorValue< T > >::ValueType Moose::FunctorBase< VectorValue< T > >::operator() ( const FaceArg &  face, const StateArg &  state  ) const

inherited

Definition at line 184 of file MooseFunctor.h.

{
  checkFace(face_in);
 
  if (_always_evaluate)
    return evaluate(face_in, state);
 
  mooseAssert(state.state == 0,
              "Cached evaluations are only currently supported for the current state.");
 
  return queryFVArgCache(_face_arg_to_value, face_in);
}

operator()() [6/6]

FunctorBase< VectorValue< T > >::ValueType Moose::FunctorBase< VectorValue< T > >::operator() ( const NodeArg &  node, const StateArg &  state  ) const

inherited

Definition at line 188 of file MooseFunctor.h.

{
  mooseAssert(node.subdomain_ids, "Subdomain IDs must be supplied to the node argument");
  return evaluate(node, state);
}

queryFVArgCache()

FunctorBase< VectorValue< T > >::ValueType Moose::FunctorBase< VectorValue< T > >::queryFVArgCache ( std::map< SpaceArg, ValueType > &  cache_data, const SpaceArg &  space  ) const

privateinherited

check a finite volume spatial argument cache and if invalid then evaluate

Definition at line 516 of file MooseFunctor.h.

{
  // We don't want to evaluate if the key already exists, so instead we value initialize
  auto [it, inserted] = cache_data.try_emplace(space, ValueType());
  auto & value = it->second;
 
  if (inserted)
    // value not ready to go
    // this function is only called from functions that assert we are in the current time state
    value = evaluate(space, currentState());
 
  return value;
}

queryQpCache()

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

privateinherited

check a qp cache and if invalid then evaluate

Definition at line 506 of file MooseFunctor.h.

{
  // Check and see whether we even have sized for this quadrature point. If we haven't then we
  // must evaluate
  if (qp >= qp_cache_data.size())
  {
    qp_cache_data.resize(qrule.n_points(), std::make_pair(false, ValueType()));
    auto & pr = qp_cache_data[qp];
    pr.second = evaluate(space, state);
    pr.first = true;
    return pr.second;
  }
 
  // We've already sized for this qp, so let's see whether we have a valid cache value
  auto & pr = qp_cache_data[qp];
  if (pr.first)
    return pr.second;
 
  // No valid cache value so evaluate
  pr.second = evaluate(space, state);
  pr.first = true;
  return pr.second;
}

residualSetup()

void Moose::FunctorBase< VectorValue< T > >::residualSetup ( )

overridevirtualinherited

Implements Moose::FunctorAbstract.

Definition at line 230 of file MooseFunctor.h.

{
  if (_clearance_schedule.count(EXEC_LINEAR))
    clearCacheData();
}

setCacheClearanceSchedule()

void Moose::FunctorBase< VectorValue< T > >::setCacheClearanceSchedule ( const std::set< ExecFlagType > &  clearance_schedule )

inherited

Set how often to clear the functor evaluation cache.

Definition at line 238 of file MooseFunctor.h.

{
  if (clearance_schedule.count(EXEC_ALWAYS))
    _always_evaluate = true;
 
  _clearance_schedule = clearance_schedule;
}

supportsElemSideQpArg()

template<typename T >

bool Moose::VectorCompositeFunctor< T >::supportsElemSideQpArg ( ) const

overridevirtual

Whether this functor supports evaluation with ElemSideQpArg.

Implements Moose::FunctorBase< VectorValue< T > >.

Definition at line 160 of file VectorCompositeFunctor.h.

{
  if (!_x_comp.supportsElemSideQpArg())
    return false;
  if (_has_y && !_y_comp.supportsElemSideQpArg())
    return false;
  if (_has_z && !_z_comp.supportsElemSideQpArg())
    return false;
  return true;
}

supportsFaceArg()

template<typename T >

bool Moose::VectorCompositeFunctor< T >::supportsFaceArg ( ) const

overridevirtual

Whether this functor supports evaluation with FaceArg.

Implements Moose::FunctorBase< VectorValue< T > >.

Definition at line 147 of file VectorCompositeFunctor.h.

{
  if (!_x_comp.supportsFaceArg())
    return false;
  if (_has_y && !_y_comp.supportsFaceArg())
    return false;
  if (_has_z && !_z_comp.supportsFaceArg())
    return false;
  return true;
}

timestepSetup()

void Moose::FunctorBase< VectorValue< T > >::timestepSetup ( )

overridevirtualinherited

Implements Moose::FunctorAbstract.

Definition at line 232 of file MooseFunctor.h.

{
  if (_clearance_schedule.count(EXEC_TIMESTEP_BEGIN))
    clearCacheData();
}

Member Data Documentation

_always_evaluate

bool Moose::FunctorBase< VectorValue< T > >::_always_evaluate

privateinherited

Boolean to check if we always need evaluation.

Definition at line 523 of file MooseFunctor.h.

_clearance_schedule

std::set<ExecFlagType> Moose::FunctorBase< VectorValue< T > >::_clearance_schedule

privateinherited

How often to clear the material property cache.

Definition at line 520 of file MooseFunctor.h.

_current_qp_map_key

dof_id_type Moose::FunctorBase< VectorValue< T > >::_current_qp_map_key

mutableprivateinherited

Current key for qp map cache.

Definition at line 529 of file MooseFunctor.h.

_current_qp_map_value

std::vector<std::pair<bool, ValueType> >* Moose::FunctorBase< VectorValue< T > >::_current_qp_map_value

mutableprivateinherited

Current value for qp map cache.

Definition at line 532 of file MooseFunctor.h.

_current_side_qp_map_key

dof_id_type Moose::FunctorBase< VectorValue< T > >::_current_side_qp_map_key

mutableprivateinherited

Current key for side-qp map cache.

Definition at line 545 of file MooseFunctor.h.

_current_side_qp_map_value

std::vector<std::vector<std::pair<bool, ValueType> > >* Moose::FunctorBase< VectorValue< T > >::_current_side_qp_map_value

mutableprivateinherited

Current value for side-qp map cache.

Definition at line 548 of file MooseFunctor.h.

_elem_arg_to_value

std::map<ElemArg, ValueType> Moose::FunctorBase< VectorValue< T > >::_elem_arg_to_value

mutableprivateinherited

Map from element arguments to their cached evaluations.

Definition at line 561 of file MooseFunctor.h.

_face_arg_to_value

std::map<FaceArg, ValueType> Moose::FunctorBase< VectorValue< T > >::_face_arg_to_value

mutableprivateinherited

Map from face arguments to their cached evaluations.

Definition at line 564 of file MooseFunctor.h.

_functor_name

MooseFunctorName Moose::FunctorBase< VectorValue< T > >::_functor_name

privateinherited

name of the functor

Definition at line 570 of file MooseFunctor.h.

_has_y

template<typename T >

const bool Moose::VectorCompositeFunctor< T >::_has_y

private

Whether the user supplied a y-functor.

Definition at line 97 of file VectorCompositeFunctor.h.

Referenced by Moose::VectorCompositeFunctor< T >::hasBlocks().

_has_z

template<typename T >

const bool Moose::VectorCompositeFunctor< T >::_has_z

private

Whether the user supplied a z-functor.

Definition at line 100 of file VectorCompositeFunctor.h.

Referenced by Moose::VectorCompositeFunctor< T >::hasBlocks().

_node_arg_to_value

std::map<NodeArg, ValueType> Moose::FunctorBase< VectorValue< T > >::_node_arg_to_value

mutableprivateinherited

Map from nodal arguments to their cached evaluations.

Definition at line 567 of file MooseFunctor.h.

_qp_to_value

std::unordered_map<dof_id_type, std::vector<std::pair<bool, ValueType> > > Moose::FunctorBase< VectorValue< T > >::_qp_to_value

mutableprivateinherited

Cached element quadrature point functor property evaluations.

The map key is the element id. The map values should have size corresponding to the number of quadrature points on the element. The vector elements are pairs. The first member of the pair indicates whether a cached value has been computed. The second member of the pair is the (cached) value. If the boolean is false, then the value cannot be trusted

Definition at line 539 of file MooseFunctor.h.

_side_qp_to_value

std::unordered_map<dof_id_type, std::vector<std::vector<std::pair<bool, ValueType> > > > Moose::FunctorBase< VectorValue< T > >::_side_qp_to_value

mutableprivateinherited

Cached element quadrature point functor property evaluations.

The map key is the element id. The map values are a multi-dimensional vector (or vector of vectors) with the first index corresponding to the side and the second index corresponding to the quadrature point index. The elements returned after double indexing are pairs. The first member of the pair indicates whether a cached value has been computed. The second member of the pair is the (cached) value. If the boolean is false, then the value cannot be trusted

Definition at line 558 of file MooseFunctor.h.

_x_comp

template<typename T >

const FunctorBase<T>& Moose::VectorCompositeFunctor< T >::_x_comp

private

The x-component functor.

Definition at line 90 of file VectorCompositeFunctor.h.

Referenced by Moose::VectorCompositeFunctor< T >::hasBlocks().

_y_comp

template<typename T >

const FunctorBase<T>& Moose::VectorCompositeFunctor< T >::_y_comp

private

The y-component functor.

Definition at line 92 of file VectorCompositeFunctor.h.

Referenced by Moose::VectorCompositeFunctor< T >::hasBlocks().

_y_constant

template<typename T >

std::unique_ptr<ConstantFunctor<T> > Moose::VectorCompositeFunctor< T >::_y_constant

private

Possible holder of constant-0 y-component functor.

This will be allocated if the user only supplies one component functor during construction

Definition at line 83 of file VectorCompositeFunctor.h.

_z_comp

template<typename T >

const FunctorBase<T>& Moose::VectorCompositeFunctor< T >::_z_comp

private

The z-component functor.

Definition at line 94 of file VectorCompositeFunctor.h.

Referenced by Moose::VectorCompositeFunctor< T >::hasBlocks().

_z_constant

template<typename T >

std::unique_ptr<ConstantFunctor<T> > Moose::VectorCompositeFunctor< T >::_z_constant

private

Possible holder of constant-0 z-component functor.

This will be allocated if the user only supplies two component functors during construction

Definition at line 87 of file VectorCompositeFunctor.h.

---

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

• include/utils/VectorCompositeFunctor.h