https://mooseframework.inl.gov: MooseVariableFV< OutputType

Definition at line 340 of file MooseVariableFV.h.

   {
     mooseError("We don't currently implement curl for FV");
   }

◆ adCurlSlnNeighbor()

template<typename OutputType>

const ADTemplateVariableCurl<OutputType>& MooseVariableFV< OutputType >::adCurlSlnNeighbor ( ) const

inlineoverridevirtual

AD curl neighbor solution getter.

Definition at line 370 of file MooseVariableFV.h.

   {
     mooseError("We don't currently implement curl for FV");
   }

◆ add()

template<typename OutputType>

void MooseVariableFV< OutputType >::add ( libMesh::NumericVector< libMesh::Number > & vector )

overridevirtual

Add the currently cached degree of freedom values into the provided vector.

Implements MooseVariableFieldBase.

Definition at line 155 of file MooseVariableFV.C.

 {
   _element_data->add(residual);
 }

◆ adDofValues()

template<typename OutputType >

const MooseArray< ADReal > & MooseVariableFV< OutputType >::adDofValues ( ) const

inlineoverridevirtual

Return the AD dof values.

Definition at line 750 of file MooseVariableFV.h.

 {
   return _element_data->adDofValues();
 }

◆ adDofValuesDot()

template<typename OutputType >

const MooseArray< ADReal > & MooseVariableFV< OutputType >::adDofValuesDot ( ) const

inlineoverridevirtual

Return the AD time derivatives at dofs.

Definition at line 764 of file MooseVariableFV.h.

 {
   return _element_data->adDofValuesDot();
 }

◆ adDofValuesNeighbor()

template<typename OutputType >

const MooseArray< ADReal > & MooseVariableFV< OutputType >::adDofValuesNeighbor ( ) const

inlineoverridevirtual

Return the AD neighbor dof values.

Definition at line 757 of file MooseVariableFV.h.

 {
   return _neighbor_data->adDofValues();
 }

◆ adGradSln() [1/3]

template<typename OutputType>

const ADTemplateVariableGradient<OutputType>& MooseVariableFV< OutputType >::adGradSln ( ) const

inlineoverridevirtual

AD grad solution getter.

Definition at line 266 of file MooseVariableFV.h.

Referenced by LayeredSideDiffusiveFluxAverage::computeQpIntegral(), FVOneVarDiffusionInterface::computeQpResidual(), FVAnisotropicDiffusion::computeQpResidual(), and Moose::FV::gradUDotNormal().

   {
     return _element_data->adGradSln();
   }

◆ adGradSln() [2/3]

template<typename OutputType >

const VectorValue< ADReal > & MooseVariableFV< OutputType >::adGradSln	(	const Elem *const	elem,
		const StateArg &	state,
		const bool	correct_skewness = `false`
	)		const

virtual

Retrieve (or potentially compute) the gradient on the provided element.

Overriders of this method cannot call getBoundaryFaceValue because that method itself may lead to a call to adGradSln(const Elem * const) resulting in infinite recursion

Parameters

elem	The element for which to retrieve the gradient
state	State argument which describes at what time / solution iteration state we want to evaluate the variable
correct_skewness	Whether to perform skew corrections

Returns: The gradient at the element centroid

Definition at line 584 of file MooseVariableFV.C.

 {
   // We ensure that no caching takes place when we compute skewness-corrected
   // quantities.
   if (_cache_cell_gradients && !correct_skewness && state.state == 0)
   {
     auto it = _elem_to_grad.find(elem);
 
     if (it != _elem_to_grad.end())
       return it->second;
   }
 
   auto grad = FV::greenGaussGradient(
       ElemArg({elem, correct_skewness}), state, *this, _two_term_boundary_expansion, this->_mesh);
 
   if (_cache_cell_gradients && !correct_skewness && state.state == 0)
   {
     auto pr = _elem_to_grad.emplace(elem, std::move(grad));
     mooseAssert(pr.second, "Insertion should have just happened.");
     return pr.first->second;
   }
   else
   {
     _temp_cell_gradient = std::move(grad);
     return _temp_cell_gradient;
   }
 }

◆ adGradSln() [3/3]

template<typename OutputType >

VectorValue< ADReal > MooseVariableFV< OutputType >::adGradSln	(	const FaceInfo &	fi,
		const StateArg &	state,
		const bool	correct_skewness = `false`
	)		const

virtual

Retrieve (or potentially compute) a cross-diffusion-corrected gradient on the provided face.

"Correcting" the face gradient involves weighting the gradient stencil more heavily on the solution values on the face-neighbor cells than a linear interpolation between cell center gradients does

Parameters

face	The face for which to retrieve the gradient.
state	State argument which describes at what time / solution iteration state we want to evaluate the variable
correct_skewness	Whether to perform skew corrections

Definition at line 642 of file MooseVariableFV.C.

 {
   const bool var_defined_on_elem = this->hasBlocks(fi.elem().subdomain_id());
   const Elem * const elem = &fi.elem();
   const Elem * const neighbor = fi.neighborPtr();
 
   const bool is_internal_face = this->isInternalFace(fi);
 
   const ADReal side_one_value = (!is_internal_face && !var_defined_on_elem)
                                     ? getBoundaryFaceValue(fi, state, correct_skewness)
                                     : getElemValue(elem, state);
   const ADReal side_two_value = (var_defined_on_elem && !is_internal_face)
                                     ? getBoundaryFaceValue(fi, state, correct_skewness)
                                     : getElemValue(neighbor, state);
 
   const auto delta =
       this->isInternalFace(fi)
           ? fi.dCNMag()
           : (fi.faceCentroid() - (var_defined_on_elem ? fi.elemCentroid() : fi.neighborCentroid()))
                 .norm();
 
   // This is the component of the gradient which is parallel to the line connecting
   // the cell centers. Therefore, we can use our second order, central difference
   // scheme to approximate it.
   auto face_grad = ((side_two_value - side_one_value) / delta) * fi.eCN();
 
   // We only need non-orthogonal correctors in 2+ dimensions
   if (this->_mesh.dimension() > 1)
   {
     // We are using an orthogonal approach for the non-orthogonal correction, for more information
     // see Hrvoje Jasak's PhD Thesis (Imperial College, 1996)
     const auto & interpolated_gradient = uncorrectedAdGradSln(fi, state, correct_skewness);
     face_grad += interpolated_gradient - (interpolated_gradient * fi.eCN()) * fi.eCN();
   }
 
   return face_grad;
 }

◆ adGradSlnDot()

template<typename OutputType>

const ADTemplateVariableGradient<OutputType>& MooseVariableFV< OutputType >::adGradSlnDot ( ) const

inlineoverridevirtual

AD grad of time derivative solution getter.

Definition at line 336 of file MooseVariableFV.h.

   {
     return _element_data->adGradSlnDot();
   }

◆ adGradSlnNeighbor()

template<typename OutputType>

const ADTemplateVariableGradient<OutputType>& MooseVariableFV< OutputType >::adGradSlnNeighbor ( ) const

inlineoverridevirtual

AD grad neighbor solution getter.

Definition at line 350 of file MooseVariableFV.h.

   {
     return _neighbor_data->adGradSln();
   }

◆ adGradSlnNeighborDot()

template<typename OutputType>

const ADTemplateVariableGradient<OutputType>& MooseVariableFV< OutputType >::adGradSlnNeighborDot ( ) const

inlineoverridevirtual

AD grad of time derivative neighbor solution getter.

Definition at line 366 of file MooseVariableFV.h.

   {
     return _neighbor_data->adGradSlnDot();
   }

◆ adSecondSln()

template<typename OutputType>

const ADTemplateVariableSecond<OutputType>& MooseVariableFV< OutputType >::adSecondSln ( ) const

inlineoverridevirtual

AD second solution getter.

Definition at line 324 of file MooseVariableFV.h.

   {
     return _element_data->adSecondSln();
   }

◆ adSecondSlnNeighbor()

template<typename OutputType>

const ADTemplateVariableSecond<OutputType>& MooseVariableFV< OutputType >::adSecondSlnNeighbor ( ) const

inlineoverridevirtual

AD second neighbor solution getter.

Definition at line 354 of file MooseVariableFV.h.

   {
     return _neighbor_data->adSecondSln();
   }

◆ adSln()

template<typename OutputType>

const ADTemplateVariableValue<OutputType>& MooseVariableFV< OutputType >::adSln ( ) const

inlineoverridevirtual

AD.

Definition at line 262 of file MooseVariableFV.h.

   {
     return _element_data->adSln();
   }

◆ adSlnNeighbor()

template<typename OutputType>

const ADTemplateVariableValue<OutputType>& MooseVariableFV< OutputType >::adSlnNeighbor ( ) const

inlineoverridevirtual

neighbor AD

Definition at line 346 of file MooseVariableFV.h.

   {
     return _neighbor_data->adSln();
   }

◆ adUDot()

template<typename OutputType>

const ADTemplateVariableValue<OutputType>& MooseVariableFV< OutputType >::adUDot ( ) const

inlineoverridevirtual

AD time derivative getter.

Definition at line 328 of file MooseVariableFV.h.

   {
     return _element_data->adUDot();
   }

◆ adUDotDot()

template<typename OutputType>

const ADTemplateVariableValue<OutputType>& MooseVariableFV< OutputType >::adUDotDot ( ) const

inlineoverridevirtual

AD second time derivative getter.

Definition at line 332 of file MooseVariableFV.h.

   {
     return _element_data->adUDotDot();
   }

◆ adUDotDotNeighbor()

template<typename OutputType>

const ADTemplateVariableValue<OutputType>& MooseVariableFV< OutputType >::adUDotDotNeighbor ( ) const

inlineoverridevirtual

AD neighbor second time derivative getter.

Definition at line 362 of file MooseVariableFV.h.

   {
     return _neighbor_data->adUDotDot();
   }

◆ adUDotNeighbor()

template<typename OutputType>

const ADTemplateVariableValue<OutputType>& MooseVariableFV< OutputType >::adUDotNeighbor ( ) const

inlineoverridevirtual

AD neighbor time derivative getter.

Referenced by FEProblemBase::addJacobianBlockTags(), Assembly::addJacobianNonlocal(), Assembly::cacheJacobianNonlocal(), NonlocalKernel::computeNonlocalJacobian(), NonlocalIntegratedBC::computeNonlocalJacobian(), NonlocalKernel::computeNonlocalOffDiagJacobian(), NonlocalIntegratedBC::computeNonlocalOffDiagJacobian(), Assembly::prepareNonlocal(), Assembly::prepareVariableNonlocal(), and MooseVariableBase::totalVarDofs().

Definition at line 358 of file MooseVariableFV.h.

   {
     return _neighbor_data->adUDot();
   }

◆ allDofIndices()

const std::vector< dof_id_type > & MooseVariableBase::allDofIndices ( ) const

inherited

Get all global dofindices for the variable.

Definition at line 197 of file MooseVariableBase.C.

 {
   const auto it = _sys.subproblem()._var_dof_map.find(name());
   if (it != _sys.subproblem()._var_dof_map.end())
     return it->second;
   else
     mooseError("VariableAllDoFMap not prepared for ",
                name(),
                " . Check nonlocal coupling requirement for the variable.");
 }

◆ arrayScalingFactor()

const std::vector<Real>& MooseVariableBase::arrayScalingFactor ( ) const

inlineinherited

Definition at line 101 of file MooseVariableBase.h.

Referenced by Assembly::addJacobianBlock(), Assembly::addJacobianBlockNonlocal(), and Assembly::cacheJacobianBlockNonzero().

101 { return _scaling_factor; }

MooseVariableBase::_scaling_factor

std::vector< Real > _scaling_factor

scaling factor for this variable

Definition: MooseVariableBase.h:247

◆ arrayVariableComponent()

const std::string & MooseVariableBase::arrayVariableComponent ( const unsigned int i ) const

inherited

Returns the variable name of a component of an array variable.

Definition at line 188 of file MooseVariableBase.C.

Referenced by MooseVariableFieldBase::componentName(), AdvancedOutput::initAvailableLists(), and AdvancedOutput::initShowHideLists().

 {
   mooseAssert(
       i < _array_var_component_names.size(),
       "Requested array variable component number is greater than the number of component names.");
   return _array_var_component_names[i];
 }

◆ blockIDs()

const std::set< SubdomainID > & BlockRestrictable::blockIDs ( ) const

virtualinherited

Return the block subdomain ids for this object Note, if this is not block restricted, this function returns all mesh subdomain ids.

Returns: a set of SubdomainIDs that are valid for this object

Definition at line 194 of file BlockRestrictable.C.

Referenced by FunctorMaterial::addFunctorProperty(), DiracKernelBase::addPoint(), DiracKernelBase::addPointWithValidId(), NodalPatchRecoveryAuxBase::blockRestrictElements(), ComboMarker::ComboMarker(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), BlockRestrictable::getBlockCoordSystem(), MaterialBase::getGenericZeroMaterialPropertyByName(), FunctorIC::gradient(), BlockRestrictable::hasBlockMaterialPropertyHelper(), IndicatorMarker::IndicatorMarker(), SubdomainsDivision::initialize(), ElementCentroidPositions::initialize(), QuadraturePointsPositions::initialize(), FunctorExtremaPositions::initialize(), MooseVariableBase::MooseVariableBase(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), MaterialBase::registerPropName(), FVPointValueConstraint::setMyElem(), and FunctorIC::value().

 {
   if (_blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
     return _blk_mesh->meshSubdomains();
   else
     return _blk_ids;
 }

◆ blockRestricted()

bool BlockRestrictable::blockRestricted ( ) const

virtualinherited

Returns true if this object has been restricted to a block.

See also: MooseObject

Definition at line 182 of file BlockRestrictable.C.

Referenced by NodalPatchRecoveryAuxBase::blockRestrictElements(), BlockRestrictable::checkVariable(), SubdomainsDivision::divisionIndex(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), BlockRestrictable::getBlockCoordSystem(), FunctorIC::gradient(), BlockRestrictable::hasBlockMaterialPropertyHelper(), SubdomainsDivision::initialize(), ElementCentroidPositions::initialize(), QuadraturePointsPositions::initialize(), BlockRestrictable::initializeBlockRestrictable(), SolutionIC::initialSetup(), MooseVariableBase::MooseVariableBase(), FVPointValueConstraint::setMyElem(), and FunctorIC::value().

 {
   return _blk_ids.find(Moose::ANY_BLOCK_ID) == _blk_ids.end();
 }

◆ blocks()

const std::vector< SubdomainName > & BlockRestrictable::blocks ( ) const

inherited

Return the block names for this object.

Note, if the 'blocks' input parameter was not utilized this will return an empty vector.

Returns: vector of SubdomainNames that are valid for this object

Definition at line 188 of file BlockRestrictable.C.

Referenced by MaterialOutputAction::getParams(), SubdomainsDivision::initialize(), and SolutionIC::initialSetup().

 {
   return _blocks;
 }

◆ blocksMaxDimension()

unsigned int BlockRestrictable::blocksMaxDimension ( ) const

inherited

Return the largest mesh dimension of the elements in the blocks for this object.

Definition at line 371 of file BlockRestrictable.C.

 {
   mooseAssert(_blk_dim != libMesh::invalid_uint, "Block restriction not initialized");
   return _blk_dim;
 }

◆ buildOutputHideVariableList()

void OutputInterface::buildOutputHideVariableList ( std::set< std::string > variable_names )

inherited

Builds hide lists for output objects NOT listed in the 'outputs' parameter.

Parameters

variable_names A set of variables for which the 'outputs' parameter controls

By default this is called by the constructor and passes the block name as the list of variables. This needs to be called explicitly if the build_list flag is set to False in the constructor. The latter cases is needed by the Material object to work correctly with the automatic material output capability.

Definition at line 61 of file OutputInterface.C.

Referenced by ReporterTransferInterface::hideVariableHelper(), and OutputInterface::OutputInterface().

 {
   // Set of available names
   const std::set<OutputName> & avail = _oi_output_warehouse.getOutputNames();
 
   // Check for 'none'; hide variables on all outputs
   if (_oi_outputs.find("none") != _oi_outputs.end())
     for (const auto & name : avail)
       _oi_output_warehouse.addInterfaceHideVariables(name, variable_names);
 
   // Check for empty and 'all' in 'outputs' parameter; do not perform any variable restrictions in
   // these cases
   else if (_oi_outputs.empty() || _oi_outputs.find("all") != _oi_outputs.end())
     return;
 
   // Limit the variable output to Output objects listed
   else
   {
     // Create a list of outputs where the variable should be hidden
     std::set<OutputName> hide;
     std::set_difference(avail.begin(),
                         avail.end(),
                         _oi_outputs.begin(),
                         _oi_outputs.end(),
                         std::inserter(hide, hide.begin()));
 
     // If 'outputs' is specified add the object name to the list of items to hide
     for (const auto & name : hide)
       _oi_output_warehouse.addInterfaceHideVariables(name, variable_names);
   }
 }

◆ callMooseError() [1/2]

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

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix

Definition at line 102 of file MooseBase.C.

Referenced by InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

 {
   callMooseError(&_app, _pars, msg, with_prefix, node);
 }

◆ callMooseError() [2/2]

void MooseBase::callMooseError	(	MooseApp *const	app,
		const InputParameters &	params,
		std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node
	)

staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters

app	The app pointer (if available); adds multiapp context and clears the console
params	The parameters, needed to obtain object information
msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix

Definition at line 110 of file MooseBase.C.

 {
   if (!node)
     node = MooseBase::getHitNode(params);
 
   std::string multiapp_prefix = "";
   if (app)
   {
     if (!app->isUltimateMaster())
       multiapp_prefix = app->name();
     app->getOutputWarehouse().mooseConsole();
   }
 
   if (with_prefix)
     // False here because the hit context will get processed by the node
     msg = messagePrefix(params, false) + msg;
 
   moose::internal::mooseErrorRaw(msg, multiapp_prefix, node);
 }

◆ checkFace()

void Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 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 732 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
 }

◆ checkVariable()

void BlockRestrictable::checkVariable ( const MooseVariableFieldBase & variable ) const

virtualinherited

Helper for checking that the ids for this object are in agreement with the variables on the supplied variable.

Parameters

variable The variable to check against.

Reimplemented in DomainUserObject.

Definition at line 343 of file BlockRestrictable.C.

Referenced by DomainUserObject::checkVariable().

 {
   // a variable defined on all internal sides does not need this check because
   // it can be coupled with other variables in DG kernels
   if (!_blk_mesh->interiorLowerDBlocks().empty() &&
       variable.activeOnSubdomains(_blk_mesh->interiorLowerDBlocks()))
     return;
 
   if (!isBlockSubset(variable.activeSubdomains()))
   {
     std::string var_ids = Moose::stringify(variable.activeSubdomains(), ", ");
     std::string obj_ids = Moose::stringify(blockRestricted() ? _blk_ids : meshBlockIDs(), ", ");
     mooseError("The 'block' parameter of the object '",
                _blk_name,
                "' must be a subset of the 'block' parameter of the variable '",
                variable.name(),
                "':\n    Object '",
                _blk_name,
                "': ",
                obj_ids,
                "\n    Variable '",
                variable.name(),
                "': ",
                var_ids);
   }
 }

◆ clearAllDofIndices()

template<typename OutputType >

void MooseVariableFV< OutputType >::clearAllDofIndices ( )

finalvirtual

Reimplemented from MooseVariableBase.

Definition at line 720 of file MooseVariableFV.C.

 {
   _element_data->clearDofIndices();
   _neighbor_data->clearDofIndices();
 }

◆ clearCaches()

template<typename OutputType >

void MooseVariableFV< OutputType >::clearCaches ( )

protected

clear finite volume caches

Definition at line 703 of file MooseVariableFV.C.

 {
   _elem_to_grad.clear();
 }

◆ clearDofIndices()

template<typename OutputType >

void MooseVariableFV< OutputType >::clearDofIndices ( )

overridevirtual

Clear out the dof indices.

We do this in case this variable is not going to be prepared at all...

Implements MooseVariableFieldBase.

Definition at line 113 of file MooseVariableFV.C.

 {
   _element_data->clearDofIndices();
 }

◆ componentDofIndices()

std::vector< dof_id_type > MooseVariableBase::componentDofIndices	(	const std::vector< dof_id_type > &	dof_indices,
		unsigned int	component
	)		const

inherited

Obtain DoF indices of a component with the indices of the 0th component.

Definition at line 215 of file MooseVariableBase.C.

Referenced by Assembly::addJacobianBlock(), and Assembly::cacheJacobianBlockNonzero().

 {
   std::vector<dof_id_type> new_dof_indices(dof_indices);
   if (component != 0)
   {
     if (isNodal())
       for (auto & id : new_dof_indices)
         id += component;
     else
     {
       unsigned int n = dof_indices.size();
       for (auto & id : new_dof_indices)
         id += component * n;
     }
   }
   return new_dof_indices;
 }

◆ componentName()

const std::string & MooseVariableFieldBase::componentName ( const unsigned int comp ) const

inherited

Get the variable name of a component in libMesh.

Definition at line 27 of file MooseVariableFieldBase.C.

 {
   if (comp >= _count)
     mooseError("componentName(): Component index is not less than the number of components");
   if (isArray())
     return this->arrayVariableComponent(comp);
   else
     return name();
 }

◆ computeElemValues()

template<typename OutputType >

void MooseVariableFV< OutputType >::computeElemValues ( )

overridevirtual

Initializes/computes variable values from the solution vectors for the current element being operated on in assembly.

This must be called every time the current element (as defined by the assembly data structure changes in order for objects that bind to sln, adSln, uDot, etc. to be updated/correct.

Implements MooseVariableFieldBase.

Definition at line 309 of file MooseVariableFV.C.

 {
   _element_data->setGeometry(Moose::Volume);
   _element_data->computeValues();
 }

◆ computeElemValuesFace()

template<typename OutputType >

void MooseVariableFV< OutputType >::computeElemValuesFace ( )

overridevirtual

Compute values at facial quadrature points.

Implements MooseVariableFieldBase.

Definition at line 317 of file MooseVariableFV.C.

 {
   _element_data->setGeometry(Moose::Face);
   _element_data->computeValues();
 }

◆ computeFaceValues()

template<typename OutputType >

void MooseVariableFV< OutputType >::computeFaceValues ( const FaceInfo & fi )

overridevirtual

Initializes/computes variable values from the solution vectors for the face represented by fi.

This includes initializing data for elements on both sides of the face (elem and neighbor) and handles the case where there is no element on one side of the face gracefully - i.e. you call this uniformly for every face regardless of whether you are on a boundary or not - or whether the variable is only defined on one side of the face or not.

Reimplemented from MooseVariableFieldBase.

Definition at line 341 of file MooseVariableFV.C.

 {
   _element_data->setGeometry(Moose::Face);
   _neighbor_data->setGeometry(Moose::Face);
 
   const auto facetype = fi.faceType(std::make_pair(this->number(), this->sys().number()));
   if (facetype == FaceInfo::VarFaceNeighbors::NEITHER)
     return;
   else if (facetype == FaceInfo::VarFaceNeighbors::BOTH)
   {
     _element_data->computeValuesFace(fi);
     _neighbor_data->computeValuesFace(fi);
   }
   else if (facetype == FaceInfo::VarFaceNeighbors::ELEM)
     _element_data->computeValuesFace(fi);
   else if (facetype == FaceInfo::VarFaceNeighbors::NEIGHBOR)
     _neighbor_data->computeValuesFace(fi);
   else
     mooseError("robert wrote broken MooseVariableFV code");
 }

◆ computeLowerDValues()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::computeLowerDValues ( )

inlinefinaloverridevirtual

compute values at quadrature points on the lower dimensional element

Implements MooseVariableFieldBase.

Definition at line 135 of file MooseVariableFV.h.

   {
     // mooseError("computeLowerDValues not supported by MooseVariableFVBase");
   }

◆ computeNeighborValues()

template<typename OutputType >

void MooseVariableFV< OutputType >::computeNeighborValues ( )

overridevirtual

Compute values at quadrature points for the neighbor.

Implements MooseVariableFieldBase.

Definition at line 333 of file MooseVariableFV.C.

 {
   _neighbor_data->setGeometry(Moose::Volume);
   _neighbor_data->computeValues();
 }

◆ computeNeighborValuesFace()

template<typename OutputType >

void MooseVariableFV< OutputType >::computeNeighborValuesFace ( )

overridevirtual

Compute values at facial quadrature points for the neighbor.

Implements MooseVariableFieldBase.

Definition at line 325 of file MooseVariableFV.C.

 {
   _neighbor_data->setGeometry(Moose::Face);
   _neighbor_data->computeValues();
 }

◆ computeNodalNeighborValues()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::computeNodalNeighborValues ( )

inlinefinaloverridevirtual

Compute nodal values of this variable in the neighbor.

Implements MooseVariableFieldBase.

Definition at line 139 of file MooseVariableFV.h.

   {
     // mooseError("computeNodalNeighborValues not supported by MooseVariableFVBase");
   }

◆ computeNodalValues()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::computeNodalValues ( )

inlinefinaloverridevirtual

Compute nodal values of this variable.

Implements MooseVariableFieldBase.

Definition at line 143 of file MooseVariableFV.h.

   {
     // mooseError("computeNodalValues not supported by MooseVariableFVBase");
   }

◆ computingCurl()

template<typename OutputType>

bool MooseVariableFV< OutputType >::computingCurl ( ) const

inlinefinaloverridevirtual

Whether or not this variable is computing any curl quantities.

Definition at line 596 of file MooseVariableFV.h.

596 { return false; }

◆ computingDiv()

template<typename OutputType>

bool MooseVariableFV< OutputType >::computingDiv ( ) const

inlinefinaloverridevirtual

Whether or not this variable is computing any divergence quantities.

Definition at line 597 of file MooseVariableFV.h.

597 { return false; }

◆ computingSecond()

template<typename OutputType>

bool MooseVariableFV< OutputType >::computingSecond ( ) const

inlinefinaloverridevirtual

Whether or not this variable is computing any second derivatives.

Referenced by Assembly::addJacobianBlock(), EigenProblem::adjustEigenVector(), ArrayBodyForce::ArrayBodyForce(), ArrayConstantIC::ArrayConstantIC(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayFunctionIC::ArrayFunctionIC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayVarReductionAux::ArrayVarReductionAux(), BuildArrayVariableAux::BuildArrayVariableAux(), Assembly::cacheJacobianBlockNonzero(), TagAuxBase< AuxKernel >::checkCoupledVariable(), BuildArrayVariableAux::compute(), ArrayNodalBC::computeJacobian(), ArrayHFEMDirichletBC::computeLowerDQpOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDQpOffDiagJacobian(), ArrayDGLowerDKernel::computeLowerDQpOffDiagJacobian(), ArrayNodalBC::computeOffDiagJacobian(), ArrayTimeDerivative::computeQpJacobian(), ArrayReaction::computeQpJacobian(), ArrayDiffusion::computeQpJacobian(), ArrayCoupledTimeDerivative::computeQpJacobian(), EigenArrayDirichletBC::computeQpJacobian(), ArrayIntegratedBC::computeQpJacobian(), ArrayKernel::computeQpJacobian(), ArrayNodalBC::computeQpJacobian(), ArrayCoupledTimeDerivative::computeQpOffDiagJacobian(), EigenArrayDirichletBC::computeQpOffDiagJacobian(), ArrayIntegratedBC::computeQpOffDiagJacobian(), ArrayKernel::computeQpOffDiagJacobian(), ArrayNodalBC::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), Kernel::computeQpOffDiagJacobianArray(), ArrayIntegratedBC::computeQpOffDiagJacobianScalar(), ArrayKernel::computeQpOffDiagJacobianScalar(), ArrayTimeDerivative::computeQpResidual(), ArrayReaction::computeQpResidual(), ArrayCoupledTimeDerivative::computeQpResidual(), FunctionArrayAux::computeValue(), ArrayParsedAux::computeValue(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FunctionArrayAux::FunctionArrayAux(), ArrayFunctionIC::gradient(), AdvancedOutput::initAvailableLists(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), ArrayDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), Assembly::prepareJacobianBlock(), Assembly::prepareLowerD(), Assembly::prepareNeighbor(), Assembly::prepareNonlocal(), Assembly::prepareVariable(), Assembly::prepareVariableNonlocal(), MultiAppDofCopyTransfer::transfer(), MultiAppDofCopyTransfer::transferDofObject(), and ArrayFunctionIC::value().

Definition at line 595 of file MooseVariableFV.h.

595 { return false; }

◆ connectControllableParams()

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

inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 74 of file MooseBase.C.

 {
   auto & factory = _app.getFactory();
   auto & ip_warehouse = _app.getInputParameterWarehouse();
 
   MooseObjectParameterName primary_name(uniqueName(), parameter);
   const auto base_type = factory.getValidParams(object_type).getBase();
   MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
   ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
 
   const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
   for (const auto & tag : tags)
   {
     if (!tag.empty())
     {
       // Only adds the parameter with the different control tags if the derived class
       // properly registers the parameter to its own syntax
       MooseObjectParameterName tagged_name(tag, name(), parameter);
       ip_warehouse.addControllableParameterConnection(
           tagged_name, secondary_name, /*error_on_empty=*/false);
     }
   }
 }

◆ count()

unsigned int MooseVariableBase::count ( ) const

inlineinherited

Get the number of components Note: For standard and vector variables, the number is one.

Definition at line 113 of file MooseVariableBase.h.

113 { return _count; }

MooseVariableBase::_count

const unsigned int _count

Number of variables in the array.

Definition: MooseVariableBase.h:244

◆ curlPhi()

template<typename OutputType>

const FieldVariablePhiValue& MooseVariableFV< OutputType >::curlPhi ( ) const

inlinefinaloverridevirtual

Curl of the shape functions.

Definition at line 606 of file MooseVariableFV.h.

   {
     mooseError("We don't currently implement curl for FV");
   }

◆ currentElem()

template<typename OutputType>

virtual const Elem* const& MooseVariableFV< OutputType >::currentElem ( ) const

inlineoverridevirtual

Current element this variable is evaluated at.

Implements MooseVariableFieldBase.

Definition at line 175 of file MooseVariableFV.h.

175 { return _element_data->currentElem(); }

std::unique_ptr< MooseVariableDataFV< OutputType > > _element_data

Holder for all the data associated with the "main" element.

Definition: MooseVariableFV.h:688

◆ customSetup() [1/2]

virtual void SetupInterface::customSetup ( const ExecFlagType & )

inlinevirtualinherited

Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain.

Reimplemented in Function.

Definition at line 61 of file SetupInterface.h.

61 {}

◆ customSetup() [2/2]

void Moose::FunctorBase< Moose::ADType< OutputType >::type >::customSetup ( const ExecFlagType & exec_type )

overridevirtualinherited

Implements Moose::FunctorAbstract.

Definition at line 839 of file MooseFunctor.h.

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

◆ determineBoundaryToDirichletBCMap()

template<typename OutputType >

void MooseVariableFV< OutputType >::determineBoundaryToDirichletBCMap ( )

private

Setup the boundary to Dirichlet BC map.

Definition at line 859 of file MooseVariableFV.C.

 {
   mooseAssert(!Threads::in_threads,
               "This routine has not been implemented for threads. Please query this routine before "
               "a threaded region or contact a MOOSE developer to discuss.");
 
   _boundary_id_to_dirichlet_bc.clear();
   std::vector<FVDirichletBCBase *> bcs;
 
   // I believe because query() returns by value but condition returns by reference that binding to a
   // const lvalue reference results in the query() getting destructed and us holding onto a dangling
   // reference. I think that condition returned by value we would be able to bind to a const lvalue
   // reference here. But as it is we'll bind to a regular lvalue
   const auto base_query = this->_subproblem.getMooseApp()
                               .theWarehouse()
                               .query()
                               .template condition<AttribSystem>("FVDirichletBC")
                               .template condition<AttribThread>(_tid)
                               .template condition<AttribVar>(_var_num)
                               .template condition<AttribSysNum>(this->_sys.number());
 
   for (const auto bnd_id : this->_mesh.getBoundaryIDs())
   {
     auto base_query_copy = base_query;
     base_query_copy.template condition<AttribBoundaries>(std::set<BoundaryID>({bnd_id}))
         .queryInto(bcs);
     mooseAssert(bcs.size() <= 1, "cannot have multiple dirichlet BCs on the same boundary");
     if (!bcs.empty())
       _boundary_id_to_dirichlet_bc.emplace(bnd_id, bcs[0]);
   }
 
   _dirichlet_map_setup = true;
 }

◆ determineBoundaryToFluxBCMap()

template<typename OutputType >

void MooseVariableFV< OutputType >::determineBoundaryToFluxBCMap ( )

private

Setup the boundary to Flux BC map.

Definition at line 895 of file MooseVariableFV.C.

 {
   mooseAssert(!Threads::in_threads,
               "This routine has not been implemented for threads. Please query this routine before "
               "a threaded region or contact a MOOSE developer to discuss.");
 
   _boundary_id_to_flux_bc.clear();
   std::vector<const FVFluxBC *> bcs;
 
   // I believe because query() returns by value but condition returns by reference that binding to a
   // const lvalue reference results in the query() getting destructed and us holding onto a dangling
   // reference. I think that condition returned by value we would be able to bind to a const lvalue
   // reference here. But as it is we'll bind to a regular lvalue
   const auto base_query = this->_subproblem.getMooseApp()
                               .theWarehouse()
                               .query()
                               .template condition<AttribSystem>("FVFluxBC")
                               .template condition<AttribThread>(_tid)
                               .template condition<AttribVar>(_var_num)
                               .template condition<AttribSysNum>(this->_sys.number());
 
   for (const auto bnd_id : this->_mesh.getBoundaryIDs())
   {
     auto base_query_copy = base_query;
     base_query_copy.template condition<AttribBoundaries>(std::set<BoundaryID>({bnd_id}))
         .queryInto(bcs);
     if (!bcs.empty())
       _boundary_id_to_flux_bc.emplace(bnd_id, bcs);
   }
 
   _flux_map_setup = true;
 }

◆ divPhi()

template<typename OutputType>

const FieldVariablePhiDivergence& MooseVariableFV< OutputType >::divPhi ( ) const

inlinefinaloverridevirtual

Divergence of the shape functions.

Referenced by FVScalarLagrangeMultiplierInterface::computeJacobian(), FVBoundaryScalarLagrangeMultiplierConstraint::computeJacobian(), FVFluxBC::computeJacobian(), FVElementalKernel::computeJacobian(), FVFluxKernel::computeJacobian(), FVInterfaceKernel::computeJacobian(), FVScalarLagrangeMultiplierConstraint::computeOffDiagJacobian(), FVScalarLagrangeMultiplierConstraint::computeResidualAndJacobian(), and FVElementalKernel::computeResidualAndJacobian().

Definition at line 610 of file MooseVariableFV.h.

   {
     mooseError("We don't currently implement divergence for FV");
   }

◆ doDerivatives()

bool MooseVariableBase::doDerivatives ( ) const

protectedinherited

Returns: whether we should insert derivatives

◆ dofIndices()

template<typename OutputType>

virtual const std::vector<dof_id_type>& MooseVariableFV< OutputType >::dofIndices ( ) const

inlinefinalvirtual

Get local DoF indices.

Reimplemented from MooseVariableBase.

Definition at line 183 of file MooseVariableFV.h.

   {
     return _element_data->dofIndices();
   }

◆ dofIndicesLower()

template<typename OutputType >

const std::vector< dof_id_type > & MooseVariableFV< OutputType >::dofIndicesLower ( ) const

finaloverridevirtual

Get dof indices for the current lower dimensional element (this is meaningful when performing mortar FEM)

Returns: the lower dimensional element's dofs

Implements MooseVariableFieldBase.

Definition at line 841 of file MooseVariableFV.h.

 {
   static const std::vector<dof_id_type> empty;
   return empty;
 }

◆ dofIndicesNeighbor()

template<typename OutputType>

virtual const std::vector<dof_id_type>& MooseVariableFV< OutputType >::dofIndicesNeighbor ( ) const

inlinefinalvirtual

Get neighbor DOF indices for currently selected element.

Returns: the neighbor degree of freedom indices

Implements MooseVariableFieldBase.

Definition at line 187 of file MooseVariableFV.h.

Referenced by FVScalarLagrangeMultiplierInterface::computeJacobian(), FVBoundaryScalarLagrangeMultiplierConstraint::computeJacobian(), FVFluxBC::computeJacobian(), FVFluxKernel::computeJacobian(), and FVInterfaceKernel::computeJacobian().

   {
     return _neighbor_data->dofIndices();
   }

◆ dofMap()

const libMesh::DofMap& MooseVariableBase::dofMap ( ) const

inlineinherited

The DofMap associated with the system this variable is in.

Definition at line 138 of file MooseVariableBase.h.

Referenced by AuxScalarKernel::compute(), ScalarVariable::execute(), and DiscreteVariableResidualNorm::execute().

138 { return _dof_map; }

MooseVariableBase::_dof_map

const libMesh::DofMap & _dof_map

DOF map.

Definition: MooseVariableBase.h:232

◆ dofValues()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValues ( ) const

overridevirtual

dof values getters

Definition at line 162 of file MooseVariableFV.C.

 {
   return _element_data->dofValues();
 }

◆ dofValuesDot()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesDot ( ) const

overridevirtual

Definition at line 218 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesDot();
 }

◆ dofValuesDotDot()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesDotDot ( ) const

overridevirtual

Definition at line 225 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesDotDot();
 }

◆ dofValuesDotDotNeighbor()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesDotDotNeighbor ( ) const

overridevirtual

Definition at line 253 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesDotDot();
 }

◆ dofValuesDotDotOld()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesDotDotOld ( ) const

overridevirtual

Definition at line 239 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesDotDotOld();
 }

◆ dofValuesDotDotOldNeighbor()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesDotDotOldNeighbor ( ) const

overridevirtual

Definition at line 267 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesDotDotOld();
 }

◆ dofValuesDotNeighbor()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesDotNeighbor ( ) const

overridevirtual

Definition at line 246 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesDot();
 }

◆ dofValuesDotOld()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesDotOld ( ) const

overridevirtual

Definition at line 232 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesDotOld();
 }

◆ dofValuesDotOldNeighbor()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesDotOldNeighbor ( ) const

overridevirtual

Definition at line 260 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesDotOld();
 }

◆ dofValuesDuDotDotDu()

template<typename OutputType >

const MooseArray< Number > & MooseVariableFV< OutputType >::dofValuesDuDotDotDu ( ) const

overridevirtual

Definition at line 281 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesDuDotDotDu();
 }

◆ dofValuesDuDotDotDuNeighbor()

template<typename OutputType >

const MooseArray< Number > & MooseVariableFV< OutputType >::dofValuesDuDotDotDuNeighbor ( ) const

overridevirtual

Definition at line 295 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesDuDotDotDu();
 }

◆ dofValuesDuDotDu()

template<typename OutputType >

const MooseArray< Number > & MooseVariableFV< OutputType >::dofValuesDuDotDu ( ) const

overridevirtual

Definition at line 274 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesDuDotDu();
 }

◆ dofValuesDuDotDuNeighbor()

template<typename OutputType >

const MooseArray< Number > & MooseVariableFV< OutputType >::dofValuesDuDotDuNeighbor ( ) const

overridevirtual

Definition at line 288 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesDuDotDu();
 }

◆ dofValuesNeighbor()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesNeighbor ( ) const

overridevirtual

Definition at line 190 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValues();
 }

◆ dofValuesOld()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesOld ( ) const

overridevirtual

Definition at line 169 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesOld();
 }

◆ dofValuesOlder()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesOlder ( ) const

overridevirtual

Definition at line 176 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesOlder();
 }

◆ dofValuesOlderNeighbor()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesOlderNeighbor ( ) const

overridevirtual

Definition at line 204 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesOlder();
 }

◆ dofValuesOldNeighbor()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesOldNeighbor ( ) const

overridevirtual

Definition at line 197 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesOld();
 }

◆ dofValuesPreviousNL()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesPreviousNL ( ) const

overridevirtual

Definition at line 183 of file MooseVariableFV.C.

 {
   return _element_data->dofValuesPreviousNL();
 }

◆ dofValuesPreviousNLNeighbor()

template<typename OutputType >

const MooseVariableFV< OutputType >::DoFValue & MooseVariableFV< OutputType >::dofValuesPreviousNLNeighbor ( ) const

overridevirtual

Definition at line 211 of file MooseVariableFV.C.

 {
   return _neighbor_data->dofValuesPreviousNL();
 }

◆ dot() [1/6]

FunctorBase< Moose::ADType< OutputType >::type >::DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 890 of file MooseFunctor.h.

 {
   return evaluateDot(elem, state);
 }

◆ dot() [2/6]

FunctorBase< Moose::ADType< OutputType >::type >::DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::dot	(	const FaceArg &	face,
		const StateArg &	state
	)		const

inherited

Definition at line 897 of file MooseFunctor.h.

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

◆ dot() [3/6]

FunctorBase< Moose::ADType< OutputType >::type >::DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::dot	(	const ElemQpArg &	qp,
		const StateArg &	state
	)		const

inherited

Definition at line 905 of file MooseFunctor.h.

 {
   return evaluateDot(elem_qp, state);
 }

◆ dot() [4/6]

FunctorBase< Moose::ADType< OutputType >::type >::DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::dot	(	const ElemSideQpArg &	qp,
		const StateArg &	state
	)		const

inherited

Definition at line 912 of file MooseFunctor.h.

 {
   return evaluateDot(elem_side_qp, state);
 }

◆ dot() [5/6]

FunctorBase< Moose::ADType< OutputType >::type >::DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::dot	(	const ElemPointArg &	elem_point,
		const StateArg &	state
	)		const

inherited

Definition at line 919 of file MooseFunctor.h.

 {
   return evaluateDot(elem_point, state);
 }

◆ dot() [6/6]

FunctorBase< Moose::ADType< OutputType >::type >::DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::dot	(	const NodeArg &	node,
		const StateArg &	state
	)		const

inherited

Definition at line 926 of file MooseFunctor.h.

 {
   return evaluateDot(node, state);
 }

◆ duDotDotDu()

template<typename OutputType>

const VariableValue& MooseVariableFV< OutputType >::duDotDotDu ( ) const

inline

Definition at line 257 of file MooseVariableFV.h.

257 { return _element_data->duDotDotDu(); }

MooseVariableFV::_neighbor_data

std::unique_ptr< MooseVariableDataFV< OutputType > > _element_data

Holder for all the data associated with the "main" element.

Definition: MooseVariableFV.h:688

◆ duDotDotDuNeighbor()

template<typename OutputType>

const VariableValue& MooseVariableFV< OutputType >::duDotDotDuNeighbor ( ) const

inline

Definition at line 259 of file MooseVariableFV.h.

259 { return _neighbor_data->duDotDotDu(); }

std::unique_ptr< MooseVariableDataFV< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFV.h:691

◆ duDotDu()

template<typename OutputType>

const VariableValue& MooseVariableFV< OutputType >::duDotDu ( ) const

inline

Definition at line 256 of file MooseVariableFV.h.

256 { return _element_data->duDotDu(); }

MooseVariableFV::_neighbor_data

std::unique_ptr< MooseVariableDataFV< OutputType > > _element_data

Holder for all the data associated with the "main" element.

Definition: MooseVariableFV.h:688

◆ duDotDuNeighbor()

template<typename OutputType>

const VariableValue& MooseVariableFV< OutputType >::duDotDuNeighbor ( ) const

inline

Definition at line 258 of file MooseVariableFV.h.

258 { return _neighbor_data->duDotDu(); }

std::unique_ptr< MooseVariableDataFV< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFV.h:691

◆ eigen() [1/2]

bool MooseVariableBase::eigen ( ) const

inlineinherited

Whether or not this variable operates on an eigen kernel.

Definition at line 165 of file MooseVariableBase.h.

Referenced by EigenProblem::adjustEigenVector().

165 { return _is_eigen; }

MooseVariableBase::_is_eigen

bool _is_eigen

Whether or not this variable operates on eigen kernels.

Definition: MooseVariableBase.h:217

◆ eigen() [2/2]

void MooseVariableBase::eigen ( bool eigen )

inlineinherited

Mark this variable as an eigen var or non-eigen var.

Definition at line 170 of file MooseVariableBase.h.

Referenced by MooseVariableBase::eigen().

170 { _is_eigen = eigen; }

MooseVariableBase::eigen

bool eigen() const

Whether or not this variable operates on an eigen kernel.

Definition: MooseVariableBase.h:165

MooseVariableBase::_is_eigen

bool _is_eigen

Whether or not this variable operates on eigen kernels.

Definition: MooseVariableBase.h:217

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 39 of file MooseObject.h.

Referenced by EigenKernel::enabled().

39 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition: MooseObject.h:50

◆ errorPrefix()

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

inlineinherited

Deprecated message prefix; the error type is no longer used.

Definition at line 260 of file MooseBase.h.

260 { return messagePrefix(); }

MooseBase::messagePrefix

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

Definition: MooseBase.h:252

◆ evaluate() [1/6]

template<typename OutputType >

MooseVariableFV< OutputType >::ValueType MooseVariableFV< OutputType >::evaluate	(	const ElemArg &	elem,
		const StateArg &	state
	)		const

finaloverrideprivatevirtual

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< Moose::ADType< OutputType >::type >.

Definition at line 771 of file MooseVariableFV.h.

 {
   return getElemValue(elem_arg.elem, state);
 }

◆ evaluate() [2/6]

template<typename OutputType >

MooseVariableFV< OutputType >::ValueType MooseVariableFV< OutputType >::evaluate	(	const FaceArg &	face,
		const StateArg &	state
	)		const

finaloverrideprivatevirtual

Parameters

face	See the `FaceArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor evaluated at the requested state and space

Implements Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 728 of file MooseVariableFV.C.

 {
   const FaceInfo * const fi = face.fi;
   mooseAssert(fi, "The face information must be non-null");
   if (isDirichletBoundaryFace(*fi, face.face_side, state))
     return getDirichletBoundaryFaceValue(*fi, face.face_side, state);
   else if (isExtrapolatedBoundaryFace(*fi, face.face_side, state))
   {
     bool two_term_boundary_expansion = _two_term_boundary_expansion;
     if (face.limiter_type == Moose::FV::LimiterType::Upwind)
       if ((face.elem_is_upwind && face.face_side == fi->elemPtr()) ||
           (!face.elem_is_upwind && face.face_side == fi->neighborPtr()))
         two_term_boundary_expansion = false;
     return getExtrapolatedBoundaryFaceValue(
         *fi, two_term_boundary_expansion, face.correct_skewness, face.face_side, state);
   }
   else
   {
     mooseAssert(this->isInternalFace(*fi),
                 "We must be either Dirichlet, extrapolated, or internal");
     return Moose::FV::interpolate(*this, face, state);
   }
 }

◆ evaluate() [3/6]

template<typename OutputType >

MooseVariableFV< OutputType >::ValueType MooseVariableFV< OutputType >::evaluate	(	const NodeArg &	node,
		const StateArg &	state
	)		const

finaloverrideprivatevirtual

Implements Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 754 of file MooseVariableFV.C.

 {
   const auto & node_to_elem_map = this->_mesh.nodeToElemMap();
   const auto & elem_ids = libmesh_map_find(node_to_elem_map, node_arg.node->id());
   ValueType sum = 0;
   Real total_weight = 0;
   mooseAssert(elem_ids.size(), "There should always be at least one element connected to a node");
   for (const auto elem_id : elem_ids)
   {
     const Elem * const elem = this->_mesh.queryElemPtr(elem_id);
     mooseAssert(elem, "We should have this element available");
     if (!this->hasBlocks(elem->subdomain_id()))
       continue;
     const ElemPointArg elem_point{
         elem, *node_arg.node, _face_interp_method == Moose::FV::InterpMethod::SkewCorrectedAverage};
     const auto weight = 1 / (*node_arg.node - elem->vertex_average()).norm();
     sum += weight * (*this)(elem_point, state);
     total_weight += weight;
   }
   return sum / total_weight;
 }

◆ evaluate() [4/6]

template<typename OutputType >

MooseVariableFV< OutputType >::ValueType MooseVariableFV< OutputType >::evaluate	(	const ElemPointArg &	elem_point,
		const StateArg &	state
	)		const

finaloverrideprivatevirtual

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< Moose::ADType< OutputType >::type >.

Definition at line 778 of file MooseVariableFV.h.

 {
   return (*this)(elem_point.makeElem(), state) +
          (elem_point.point - elem_point.elem->vertex_average()) *
              this->gradient(elem_point.makeElem(), state);
 }

◆ evaluate() [5/6]

template<typename OutputType >

MooseVariableFV< OutputType >::ValueType MooseVariableFV< OutputType >::evaluate	(	const ElemQpArg &	qp,
		const StateArg &	state
	)		const

finaloverrideprivatevirtual

Parameters

qp	See the `ElemQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor evaluated at the requested state and space

Implements Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 787 of file MooseVariableFV.h.

 {
   return (*this)(ElemPointArg{elem_qp.elem,
                               elem_qp.point,
                               _face_interp_method == Moose::FV::InterpMethod::SkewCorrectedAverage},
                  state);
 }

◆ evaluate() [6/6]

template<typename OutputType >

MooseVariableFV< OutputType >::ValueType MooseVariableFV< OutputType >::evaluate	(	const ElemSideQpArg &	side_qp,
		const StateArg &	state
	)		const

finaloverrideprivatevirtual

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< Moose::ADType< OutputType >::type >.

Definition at line 797 of file MooseVariableFV.h.

 {
   return (*this)(ElemPointArg{elem_side_qp.elem,
                               elem_side_qp.point,
                               _face_interp_method == Moose::FV::InterpMethod::SkewCorrectedAverage},
                  state);
 }

◆ evaluateDot() [1/6]

virtual DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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

Reimplemented in MooseVariableFE< OutputType >, and MooseVariableFE< VectorValue< Real > >.

Definition at line 416 of file MooseFunctor.h.

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

◆ evaluateDot() [2/6]

virtual DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::evaluateDot	(	const ElemPointArg &	,
		const StateArg &
	)		const

inlineprotectedvirtualinherited

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

Definition at line 425 of file MooseFunctor.h.

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

◆ evaluateDot() [3/6]

virtual DotType Moose::FunctorBase< Moose::ADType< OutputType >::type >::evaluateDot	(	const NodeArg &	,
		const StateArg &
	)		const

inlineprotectedvirtualinherited

Definition at line 430 of file MooseFunctor.h.

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

◆ evaluateDot() [4/6]

template<typename OutputType >

MooseVariableFV< OutputType >::DotType MooseVariableFV< OutputType >::evaluateDot	(	const ElemArg &	,
		const StateArg &
	)		const

finaloverrideprivatevirtual

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< Moose::ADType< OutputType >::type >.

Definition at line 778 of file MooseVariableFV.C.

 {
   mooseError("evaluateDot not implemented for this class of finite volume variables");
 }

◆ evaluateDot() [5/6]

template<typename OutputType>

DotType MooseVariableFV< OutputType >::evaluateDot	(	const FaceArg &	,
		const StateArg &
	)		const

finaloverrideprivatevirtual

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< Moose::ADType< OutputType >::type >.

◆ evaluateDot() [6/6]

template<typename OutputType>

DotType MooseVariableFV< OutputType >::evaluateDot	(	const ElemQpArg &	,
		const StateArg &
	)		const

finaloverrideprivatevirtual

Parameters

qp	See the `ElemQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor time derivative evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< Moose::ADType< OutputType >::type >.

◆ evaluateGradDot() [1/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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

Reimplemented in MooseVariableFE< OutputType >, and MooseVariableFE< VectorValue< Real > >.

Definition at line 439 of file MooseFunctor.h.

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

◆ evaluateGradDot() [2/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 449 of file MooseFunctor.h.

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

◆ evaluateGradDot() [3/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 459 of file MooseFunctor.h.

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

◆ evaluateGradDot() [4/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 470 of file MooseFunctor.h.

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

◆ evaluateGradDot() [5/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::evaluateGradDot	(	const ElemPointArg &	,
		const StateArg &
	)		const

inlineprotectedvirtualinherited

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

Definition at line 479 of file MooseFunctor.h.

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

◆ evaluateGradDot() [6/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::evaluateGradDot	(	const NodeArg &	,
		const StateArg &
	)		const

inlineprotectedvirtualinherited

Definition at line 484 of file MooseFunctor.h.

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

◆ evaluateGradient() [1/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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

Reimplemented in MooseVariableFE< OutputType >, and MooseVariableFE< VectorValue< Real > >.

Definition at line 362 of file MooseFunctor.h.

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

◆ evaluateGradient() [2/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::evaluateGradient	(	const ElemPointArg &	,
		const StateArg &
	)		const

inlineprotectedvirtualinherited

Evaluate the functor gradient with a given element and point.

Definition at line 371 of file MooseFunctor.h.

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

◆ evaluateGradient() [3/6]

virtual GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::evaluateGradient	(	const NodeArg &	,
		const StateArg &
	)		const

inlineprotectedvirtualinherited

Definition at line 376 of file MooseFunctor.h.

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

◆ evaluateGradient() [4/6]

template<typename OutputType >

MooseVariableFV< OutputType >::GradientType MooseVariableFV< OutputType >::evaluateGradient	(	const ElemQpArg &	,
		const StateArg &
	)		const

finaloverrideprivatevirtual

Parameters

qp	See the `ElemQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor gradient evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 808 of file MooseVariableFV.h.

 {
   return adGradSln(
       qp_arg.elem, state, _face_interp_method == Moose::FV::InterpMethod::SkewCorrectedAverage);
 }

◆ evaluateGradient() [5/6]

template<typename OutputType >

MooseVariableFV< OutputType >::GradientType MooseVariableFV< OutputType >::evaluateGradient	(	const ElemArg &	,
		const StateArg &
	)		const

finaloverrideprivatevirtual

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< Moose::ADType< OutputType >::type >.

Definition at line 817 of file MooseVariableFV.h.

 {
   return adGradSln(elem_arg.elem, state, elem_arg.correct_skewness);
 }

◆ evaluateGradient() [6/6]

template<typename OutputType >

MooseVariableFV< OutputType >::GradientType MooseVariableFV< OutputType >::evaluateGradient	(	const FaceArg &	,
		const StateArg &
	)		const

finaloverrideprivatevirtual

Parameters

face	See the `FaceArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor gradient evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 825 of file MooseVariableFV.h.

 {
   mooseAssert(face.fi, "We must have a non-null face information");
   return adGradSln(*face.fi, state, face.correct_skewness);
 }

◆ faceInterpolationMethod()

template<typename OutputType>

Moose::FV::InterpMethod MooseVariableFV< OutputType >::faceInterpolationMethod ( ) const

inline

Definition at line 192 of file MooseVariableFV.h.

192 { return _face_interp_method; }

MooseVariableFV::_face_interp_method

Moose::FV::InterpMethod _face_interp_method

Decides if an average or skewed corrected average is used for the face interpolation.

Definition: MooseVariableFV.h:743

◆ feType()

const libMesh::FEType& MooseVariableBase::feType ( ) const

inlineinherited

Get the type of finite element object.

Definition at line 64 of file MooseVariableBase.h.

Referenced by SetupResidualDebugAction::act(), ADDGKernel::ADDGKernel(), Assembly::adGradPhi(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ArrayDGKernel::ArrayDGKernel(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), AuxKernelTempl< Real >::AuxKernelTempl(), BoundsBase::BoundsBase(), BuildArrayVariableAux::BuildArrayVariableAux(), TagAuxBase< AuxKernel >::checkCoupledVariable(), SamplerBase::checkForStandardFieldVariableType(), GapValueAux::computeValue(), CopyValueAux::CopyValueAux(), DGKernel::DGKernel(), MultiAppNearestNodeTransfer::execute(), moose::internal::incompatVarMsg(), AdvancedOutput::initAvailableLists(), MultiAppProjectionTransfer::initialSetup(), AdvancedOutput::initShowHideLists(), IntegratedBC::IntegratedBC(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InternalSideIndicatorBase::InternalSideIndicatorBase(), Kernel::Kernel(), MeshDivisionAux::MeshDivisionAux(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodalBC::NodalBC(), NodalKernel::NodalKernel(), SolutionUserObjectBase::pointValueWrapper(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), MultiAppDofCopyTransfer::transfer(), and VectorNodalBC::VectorNodalBC().

64 { return _fe_type; }

MooseVariableBase::_fe_type

libMesh::FEType _fe_type

The FEType associated with this variable.

Definition: MooseVariableBase.h:208

◆ fieldType()

template<typename OutputType >

Moose::VarFieldType MooseVariableField< OutputType >::fieldType ( ) const

overridevirtualinherited

Field type of this variable.

Implements MooseVariableFieldBase.

Definition at line 72 of file MooseVariableField.C.

 {
   if (std::is_same<OutputType, Real>::value)
     return Moose::VarFieldType::VAR_FIELD_STANDARD;
   else if (std::is_same<OutputType, RealVectorValue>::value)
     return Moose::VarFieldType::VAR_FIELD_VECTOR;
   else if (std::is_same<OutputType, RealEigenVector>::value)
     return Moose::VarFieldType::VAR_FIELD_ARRAY;
   else
     mooseError("Unknown variable field type");
 }

◆ functorName()

const MooseFunctorName& Moose::FunctorBase< Moose::ADType< OutputType >::type >::functorName ( ) const

inlineinherited

Return the functor name.

Definition at line 170 of file MooseFunctor.h.

170 { return _functor_name; }

Moose::FunctorBase< Moose::ADType< OutputType >::type >::_functor_name

MooseFunctorName _functor_name

name of the functor

Definition: MooseFunctor.h:564

◆ genericDofValues()

template<typename OutputType >

template<bool is_ad>

const MooseArray< GenericReal< is_ad > > & MooseVariableField< OutputType >::genericDofValues ( ) const

inherited

Definition at line 428 of file MooseVariableField.h.

 {
   return adDofValues();
 }

◆ genericEvaluate()

FunctorReturnType< Moose::ADType< OutputType >::type , FET >::type Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 987 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);
 }

◆ getBase()

const std::string& MooseBase::getBase ( ) const

inlineinherited

Returns: The registered base for this object (set via InputParameters::registerBase())

Definition at line 143 of file MooseBase.h.

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

143 { return _pars.getBase(); }

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

InputParameters::getBase

const std::string & getBase() const

Definition: InputParameters.C:497

◆ getBlockCoordSystem()

Moose::CoordinateSystemType BlockRestrictable::getBlockCoordSystem ( )

protectedinherited

Check if the blocks this object operates on all have the same coordinate system, and if so return it.

Definition at line 321 of file BlockRestrictable.C.

 {
   if (!_blk_mesh)
     mooseError("No mesh available in BlockRestrictable::checkCoordSystem()");
   if (!_blk_feproblem)
     mooseError("No problem available in BlockRestrictable::checkCoordSystem()");
 
   const auto & subdomains = blockRestricted() ? blockIDs() : meshBlockIDs();
 
   if (subdomains.empty())
     mooseError("No subdomains found in the problem.");
 
   // make sure all subdomains are using the same coordinate system
   auto coord_system = _blk_feproblem->getCoordSystem(*subdomains.begin());
   for (auto subdomain : subdomains)
     if (_blk_feproblem->getCoordSystem(subdomain) != coord_system)
       mooseError("This object requires all subdomains to have the same coordinate system.");
 
   return coord_system;
 }

◆ getBoundaryFaceValue()

template<typename OutputType >

ADReal MooseVariableFV< OutputType >::getBoundaryFaceValue	(	const FaceInfo &	fi,
		const StateArg &	state,
		bool	correct_skewness = `false`
	)		const

Retrieve the solution value at a boundary face.

If we're using a one term Taylor series expansion we'll simply return the ajacent element centroid value. If we're doing two terms, then we will compute the gradient if necessary to help us interpolate from the element centroid value to the face

Definition at line 566 of file MooseVariableFV.C.

Referenced by SideIntegralVariableUserObject::computeQpIntegral(), InterfaceIntegralVariableValuePostprocessor::computeQpIntegral(), and FVTwoVarContinuityConstraint::computeQpResidual().

 {
   mooseAssert(!this->isInternalFace(fi),
               "A boundary face value has been requested on an internal face.");
 
   if (isDirichletBoundaryFace(fi, nullptr, state))
     return getDirichletBoundaryFaceValue(fi, nullptr, state);
   else if (isExtrapolatedBoundaryFace(fi, nullptr, state))
     return getExtrapolatedBoundaryFaceValue(
         fi, _two_term_boundary_expansion, correct_skewness, nullptr, state);
 
   mooseError("Unknown boundary face type!");
 }

◆ getCheckedPointerParam()

template<typename T >

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

inherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 428 of file MooseBase.h.

 {
   return _pars.getCheckedPointerParam<T>(name, error_string);
 }

◆ getContinuity()

template<typename OutputType>

libMesh::FEContinuity MooseVariableFV< OutputType >::getContinuity ( ) const

inlinefinaloverridevirtual

Return the continuity of this variable.

Reimplemented from MooseVariableBase.

Definition at line 160 of file MooseVariableFV.h.

   {
     return _element_data->getContinuity();
   };

◆ getDataFileName()

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

inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

 {
   _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
                           "within the InputParameters.\nUse getParam<DataFileName>(\"",
                           param,
                           "\") instead.");
   return _parent.getParam<DataFileName>(param);
 }

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

 {
   _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
                           relative_path,
                           "\") instead.");
   return getDataFilePath(relative_path);
 }

◆ getDataFilePath()

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

inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

Referenced by DataFileInterface::getDataFileNameByName().

 {
   // This should only ever be used with relative paths. There is no point to
   // use this search path with an absolute path.
   if (std::filesystem::path(relative_path).is_absolute())
     _parent.mooseWarning("While using getDataFilePath(\"",
                          relative_path,
                          "\"): This API should not be used for absolute paths.");
 
   // Throw on error so that if getPath() fails, we can throw an error
   // with the context of _parent.mooseError()
   const auto throw_on_error_before = Moose::_throw_on_error;
   Moose::_throw_on_error = true;
   std::optional<std::string> error;
 
   // This will search the data paths for this relative path
   Moose::DataFileUtils::Path found_path;
   try
   {
     found_path = Moose::DataFileUtils::getPath(relative_path);
   }
   catch (std::exception & e)
   {
     error = e.what();
   }
 
   Moose::_throw_on_error = throw_on_error_before;
   if (error)
     _parent.mooseError(*error);
 
   mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
               "Should only ever obtain data");
   mooseAssert(found_path.data_name, "Should be set");
 
   const std::string msg =
       "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
   _parent.mooseInfo(msg);
 
   return found_path.path;
 }

◆ getDirichletBC()

template<typename OutputType >

std::pair< bool, const FVDirichletBCBase * > MooseVariableFV< OutputType >::getDirichletBC ( const FaceInfo & fi ) const

Definition at line 409 of file MooseVariableFV.C.

Referenced by FVFluxKernel::skipForBoundary().

 {
   for (const auto bnd_id : fi.boundaryIDs())
     if (auto it = _boundary_id_to_dirichlet_bc.find(bnd_id);
         it != _boundary_id_to_dirichlet_bc.end())
       return {true, it->second};
 
   return {false, nullptr};
 }

◆ getDirichletBoundaryFaceValue()

template<typename OutputType>

ADReal MooseVariableFV< OutputType >::getDirichletBoundaryFaceValue	(	const FaceInfo &	fi,
		const Elem *	elem,
		const Moose::StateArg &	state
	)		const

protectedvirtual

Retrieves a Dirichlet boundary value for the provided face.

Callers of this method should be sure that isDirichletBoundaryFace returns true. In the base implementation we only inspect the face information object for the Dirichlet value. However, derived classes may allow discontinuities between + and - side face values, e.g. one side may have a Dirichlet condition and the other side may perform extrapolation to determine its value. This is the reason for the existence of the elem parameter, to indicate sidedness

Parameters

fi	The face information object
elem	An element that can be used to indicate sidedness of the face
state	State argument which describes at what time / solution iteration state we want to evaluate the variable

Returns: The Dirichlet value on the boundary face associated with fi (and potentially elem)

Definition at line 485 of file MooseVariableFV.C.

 {
   mooseAssert(isDirichletBoundaryFace(fi, elem, state),
               "This function should only be called on Dirichlet boundary faces.");
 
   const auto & diri_pr = getDirichletBC(fi);
 
   mooseAssert(diri_pr.first,
               "This functor should only be called if we are on a Dirichlet boundary face.");
 
   const FVDirichletBCBase & bc = *diri_pr.second;
 
   return ADReal(bc.boundaryValue(fi, state));
 }

◆ getDofIndices()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::getDofIndices	(	const Elem *	elem,
		std::vector< dof_id_type > &	dof_indices
	)		const

inlineoverridevirtual

Reimplemented from MooseVariableBase.

Definition at line 177 of file MooseVariableFV.h.

   {
     return _element_data->getDofIndices(elem, dof_indices);
   }

◆ getElementalValue()

template<typename OutputType >

MooseVariableFV< OutputType >::OutputData MooseVariableFV< OutputType >::getElementalValue	(	const Elem *	elem,
		unsigned int	idx = `0`
	)		const

Get the current value of this variable on an element.

Parameters

[in]	elem	Element at which to get value
[in]	idx	Local index of this variable's element DoFs

Returns: Variable value

Definition at line 120 of file MooseVariableFV.C.

 {
   return _element_data->getElementalValue(elem, Moose::Current, idx);
 }

◆ getElementalValueOld()

template<typename OutputType >

MooseVariableFV< OutputType >::OutputData MooseVariableFV< OutputType >::getElementalValueOld	(	const Elem *	elem,
		unsigned int	idx = `0`
	)		const

Get the old value of this variable on an element.

Parameters

[in]	elem	Element at which to get value
[in]	idx	Local index of this variable's element DoFs

Returns: Variable value

Definition at line 127 of file MooseVariableFV.C.

 {
   return _element_data->getElementalValue(elem, Moose::Old, idx);
 }

◆ getElementalValueOlder()

template<typename OutputType >

MooseVariableFV< OutputType >::OutputData MooseVariableFV< OutputType >::getElementalValueOlder	(	const Elem *	elem,
		unsigned int	idx = `0`
	)		const

Get the older value of this variable on an element.

Parameters

[in]	elem	Element at which to get value
[in]	idx	Local index of this variable's element DoFs

Returns: Variable value

Definition at line 134 of file MooseVariableFV.C.

 {
   return _element_data->getElementalValue(elem, Moose::Older, idx);
 }

◆ getElemValue()

template<typename OutputType >

ADReal MooseVariableFV< OutputType >::getElemValue	(	const Elem *	elem,
		const StateArg &	state
	)		const

Get the solution value for the provided element and seed the derivative for the corresponding dof index.

Parameters

elem	The element to retrieive the solution value for
state	State argument which describes at what time / solution iteration state we want to evaluate the variable

Definition at line 432 of file MooseVariableFV.C.

Referenced by FVDiffusionInterface::computeQpResidual().

 {
   mooseAssert(elem,
               "The elem shall exist! This typically occurs when the "
               "user wants to evaluate non-existing elements (nullptr) at physical boundaries.");
   mooseAssert(
       this->hasBlocks(elem->subdomain_id()),
       "The variable should be defined on the element's subdomain! This typically occurs when the "
       "user wants to evaluate the elements right next to the boundary of two variables (block "
       "boundary). The subdomain which is queried: " +
           Moose::stringify(this->activeSubdomains()) + " the subdomain of the element " +
           std::to_string(elem->subdomain_id()));
 
   Moose::initDofIndices(const_cast<MooseVariableFV<OutputType> &>(*this), *elem);
 
   mooseAssert(
       this->_dof_indices.size() == 1,
       "There should only be one dof-index for a constant monomial variable on any given element");
 
   const dof_id_type index = this->_dof_indices[0];
 
   // It's not safe to use solutionState(0) because it returns the libMesh System solution member
   // which is wrong during things like finite difference Jacobian evaluation, e.g. when PETSc
   // perturbs the solution vector we feed these perturbations into the current_local_solution
   // while the libMesh solution is frozen in the non-perturbed state
   const auto & global_soln =
       (state.state == 0)
           ? *this->_sys.currentSolution()
           : std::as_const(this->_sys).solutionState(state.state, state.iteration_type);
 
   ADReal value = global_soln(index);
 
   if (ADReal::do_derivatives && state.state == 0 &&
       this->_sys.number() == this->_subproblem.currentNlSysNum())
     Moose::derivInsert(value.derivatives(), index, 1.);
 
   return value;
 }

◆ getExecuteOnEnum()

const ExecFlagEnum & SetupInterface::getExecuteOnEnum ( ) const

inherited

Return the execute on MultiMooseEnum for this object.

Definition at line 66 of file SetupInterface.C.

Referenced by MultiAppTransfer::checkMultiAppExecuteOn(), EigenProblem::checkProblemIntegrity(), Control::Control(), EigenExecutionerBase::init(), MultiAppConservativeTransfer::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), Terminator::initialSetup(), Exodus::outputSetup(), NodalReporter::shouldStore(), ElementReporter::shouldStore(), and GeneralReporter::shouldStore().

 {
   return _execute_enum;
 }

◆ getExtrapolatedBoundaryFaceValue()

template<typename OutputType >

ADReal MooseVariableFV< OutputType >::getExtrapolatedBoundaryFaceValue	(	const FaceInfo &	fi,
		bool	two_term_expansion,
		bool	correct_skewness,
		const Elem *	elem_side_to_extrapolate_from,
		const StateArg &	state
	)		const

virtual

Retrieves an extrapolated boundary value for the provided face.

Callers of this method should be sure that isExtrapolatedBoundaryFace returns true. In the base implementation we only inspect the face information object for the extrapolated value. However, derived classes may allow discontinuities between + and - side face values, e.g. one side may have a Dirichlet condition and the other side may perform extrapolation to determine its value. This is the reason for the existence of the elem parameter, to indicate sidedness

Parameters

fi	The face information object
two_term_expansion	Whether to use the cell gradient in addition to the cell center value to compute the extrapolated boundary face value. If this is false, then the cell center value will be used
correct_skewness	Whether to perform skew corrections. This is relevant when performing two term expansions as the gradient evaluation may involve evaluating face values on internal skewed faces
elem_side_to_extrapolate_from	An element that can be used to indicate sidedness of the face
state	State argument which describes at what time / solution iteration state we want to evaluate the variable

Returns: The extrapolated value on the boundary face associated with fi (and potentially elem_side_to_extrapolate_from)

Definition at line 516 of file MooseVariableFV.C.

 {
   mooseAssert(
       isExtrapolatedBoundaryFace(fi, elem_to_extrapolate_from, state) || !two_term_expansion,
       "We allow Dirichlet boundary conditions to call this method. However, the only way to "
       "ensure we don't have infinite recursion, with Green Gauss gradients calling back to the "
       "Dirichlet boundary condition calling back to this method, is to do a one term expansion");
 
   ADReal boundary_value;
   bool elem_to_extrapolate_from_is_fi_elem;
   std::tie(elem_to_extrapolate_from, elem_to_extrapolate_from_is_fi_elem) =
       [this, &fi, elem_to_extrapolate_from]() -> std::pair<const Elem *, bool>
   {
     if (elem_to_extrapolate_from)
       // Somebody already specified the element to extropolate from
       return {elem_to_extrapolate_from, elem_to_extrapolate_from == fi.elemPtr()};
     else
     {
       const auto [elem_guaranteed_to_have_dofs,
                   other_elem,
                   elem_guaranteed_to_have_dofs_is_fi_elem] =
           Moose::FV::determineElemOneAndTwo(fi, *this);
       // We only care about the element guaranteed to have degrees of freedom and current C++
       // doesn't allow us to not assign one of the returned items like python does
       libmesh_ignore(other_elem);
       // We will extrapolate from the element guaranteed to have degrees of freedom
       return {elem_guaranteed_to_have_dofs, elem_guaranteed_to_have_dofs_is_fi_elem};
     }
   }();
 
   if (two_term_expansion)
   {
     const Point vector_to_face = elem_to_extrapolate_from_is_fi_elem
                                      ? (fi.faceCentroid() - fi.elemCentroid())
                                      : (fi.faceCentroid() - fi.neighborCentroid());
     boundary_value = adGradSln(elem_to_extrapolate_from, state, correct_skewness) * vector_to_face +
                      getElemValue(elem_to_extrapolate_from, state);
   }
   else
     boundary_value = getElemValue(elem_to_extrapolate_from, state);
 
   return boundary_value;
 }

◆ getFluxBCs()

template<typename OutputType >

std::pair< bool, std::vector< const FVFluxBC * > > MooseVariableFV< OutputType >::getFluxBCs ( const FaceInfo & fi ) const

Definition at line 421 of file MooseVariableFV.C.

Referenced by FVFluxKernel::skipForBoundary().

 {
   for (const auto bnd_id : fi.boundaryIDs())
     if (auto it = _boundary_id_to_flux_bc.find(bnd_id); it != _boundary_id_to_flux_bc.end())
       return {true, it->second};
 
   return std::make_pair(false, std::vector<const FVFluxBC *>());
 }

◆ getGradient()

template<typename OutputType >

OutputTools< OutputType >::OutputGradient MooseVariableFV< OutputType >::getGradient ( const Elem * elem ) const

Compute the variable gradient value at a point on an element.

Parameters

elem	The element we are computing on
phi	Evaluated shape functions at a point

Returns: The variable gradient value

Definition at line 374 of file MooseVariableFV.C.

 {
   return {};
 }

◆ getHitNode()

const hit::Node* MooseBase::getHitNode ( ) const

inlineinherited

Returns: The block-level hit node for this object, if any

Definition at line 132 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

132 { return getHitNode(_pars); }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), DefaultConvergenceBase::getSharedExecutionerParam(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

MooseBase::getHitNode

const hit::Node * getHitNode() const

Definition: MooseBase.h:132

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 83 of file MooseBase.h.

83 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:353

◆ getOutputs()

const std::set< OutputName > & OutputInterface::getOutputs ( )

inherited

Get the list of output objects that this class is restricted.

Returns: A set of OutputNames

Definition at line 94 of file OutputInterface.C.

 {
   return _oi_outputs;
 }

◆ getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 384 of file MooseBase.h.

 {
   return InputParameters::getParamHelper<T>(name, _pars);
 }

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters

param1	The name of first parameter
param2	The name of second parameter

Returns: Vector of pairs of first and second parameters

Definition at line 421 of file MooseBase.h.

 {
   return _pars.get<T1, T2>(param1, param2);
 }

◆ getRenamedParam()

template<typename T >

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

inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters

old_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 398 of file MooseBase.h.

 {
   // Most important: accept new parameter
   if (isParamSetByUser(new_name) && !isParamValid(old_name))
     return getParam<T>(new_name);
   // Second most: accept old parameter
   if (isParamValid(old_name) && !isParamSetByUser(new_name))
     return getParam<T>(old_name);
   // Third most: accept default for new parameter
   if (isParamValid(new_name) && !isParamValid(old_name))
     return getParam<T>(new_name);
   // Refuse: no default, no value passed
   if (!isParamValid(old_name) && !isParamValid(new_name))
     mooseError("parameter '" + new_name +
                "' is being retrieved without being set.\nDid you misspell it?");
   // Refuse: both old and new parameters set by user
   else
     mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
                old_name + "'");
 }

◆ getSharedPtr() [1/2]

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

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 61 of file MooseObject.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), and MFEMProblem::addMFEMSolver().

 {
   try
   {
     return shared_from_this();
   }
   catch (std::bad_weak_ptr &)
   {
     mooseError(not_shared_error);
   }
 }

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 74 of file MooseObject.C.

 {
   try
   {
     return shared_from_this();
   }
   catch (std::bad_weak_ptr &)
   {
     mooseError(not_shared_error);
   }
 }

◆ getSolution()

template<typename OutputType >

const NumericVector< Number > & MooseVariableField< OutputType >::getSolution ( const Moose::StateArg & state ) const

protectedinherited

Get the solution corresponding to the provided state.

Definition at line 60 of file MooseVariableField.C.

 {
   // It's not safe to use solutionState(0) because it returns the libMesh System solution member
   // which is wrong during things like finite difference Jacobian evaluation, e.g. when PETSc
   // perturbs the solution vector we feed these perturbations into the current_local_solution
   // while the libMesh solution is frozen in the non-perturbed state
   return (state.state == 0) ? *this->_sys.currentSolution()
                             : this->_sys.solutionState(state.state, state.iteration_type);
 }

◆ getTwoTermBoundaryExpansion()

template<typename OutputType>

const bool& MooseVariableFV< OutputType >::getTwoTermBoundaryExpansion ( ) const

inline

Function to get wether two term boundary expansion is used for the variable.

Definition at line 677 of file MooseVariableFV.h.

677 { return _two_term_boundary_expansion; }

MooseVariableFV::_two_term_boundary_expansion

bool _two_term_boundary_expansion

Whether to use a two term expansion for computing boundary face values.

Definition: MooseVariableFV.h:731

◆ getValue()

template<typename OutputType >

OutputType MooseVariableFV< OutputType >::getValue ( const Elem * elem ) const

Note: const monomial is always the case - higher order solns are reconstructed - so this is simpler func than FE equivalent.

Definition at line 364 of file MooseVariableFV.C.

 {
   Moose::initDofIndices(const_cast<MooseVariableFV<OutputType> &>(*this), *elem);
   mooseAssert(this->_dof_indices.size() == 1, "Wrong size for dof indices");
   OutputType value = (*this->_sys.currentSolution())(this->_dof_indices[0]);
   return value;
 }

◆ gradDot() [1/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 933 of file MooseFunctor.h.

 {
   return evaluateGradDot(elem, state);
 }

◆ gradDot() [2/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradDot	(	const FaceArg &	face,
		const StateArg &	state
	)		const

inherited

Definition at line 940 of file MooseFunctor.h.

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

◆ gradDot() [3/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradDot	(	const ElemQpArg &	qp,
		const StateArg &	state
	)		const

inherited

Definition at line 948 of file MooseFunctor.h.

 {
   return evaluateGradDot(elem_qp, state);
 }

◆ gradDot() [4/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradDot	(	const ElemSideQpArg &	qp,
		const StateArg &	state
	)		const

inherited

Definition at line 955 of file MooseFunctor.h.

 {
   return evaluateGradDot(elem_side_qp, state);
 }

◆ gradDot() [5/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradDot	(	const ElemPointArg &	elem_point,
		const StateArg &	state
	)		const

inherited

Definition at line 962 of file MooseFunctor.h.

 {
   return evaluateGradDot(elem_point, state);
 }

◆ gradDot() [6/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradDot	(	const NodeArg &	node,
		const StateArg &	state
	)		const

inherited

Definition at line 969 of file MooseFunctor.h.

 {
   return evaluateGradDot(node, state);
 }

◆ gradient() [1/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 847 of file MooseFunctor.h.

 {
   return evaluateGradient(elem, state);
 }

◆ gradient() [2/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradient	(	const FaceArg &	face,
		const StateArg &	state
	)		const

inherited

Definition at line 854 of file MooseFunctor.h.

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

◆ gradient() [3/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradient	(	const ElemQpArg &	qp,
		const StateArg &	state
	)		const

inherited

Definition at line 862 of file MooseFunctor.h.

 {
   return evaluateGradient(elem_qp, state);
 }

◆ gradient() [4/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradient	(	const ElemSideQpArg &	qp,
		const StateArg &	state
	)		const

inherited

Definition at line 869 of file MooseFunctor.h.

 {
   return evaluateGradient(elem_side_qp, state);
 }

◆ gradient() [5/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradient	(	const ElemPointArg &	elem_point,
		const StateArg &	state
	)		const

inherited

Definition at line 876 of file MooseFunctor.h.

 {
   return evaluateGradient(elem_point, state);
 }

◆ gradient() [6/6]

FunctorBase< Moose::ADType< OutputType >::type >::GradientType Moose::FunctorBase< Moose::ADType< OutputType >::type >::gradient	(	const NodeArg &	node,
		const StateArg &	state
	)		const

inherited

Definition at line 883 of file MooseFunctor.h.

 {
   return evaluateGradient(node, state);
 }

◆ gradPhi()

template<typename OutputType>

const FieldVariablePhiGradient& MooseVariableFV< OutputType >::gradPhi ( ) const

inlinefinaloverridevirtual

Return the gradients of the variable's elemental shape functions.

MooseVariableFV::_grad_phi

Definition at line 601 of file MooseVariableFV.h.

601 { return _grad_phi; }

const FieldVariablePhiGradient & _grad_phi

Definition: MooseVariableFV.h:701

◆ gradPhiFace()

template<typename OutputType>

const FieldVariablePhiGradient& MooseVariableFV< OutputType >::gradPhiFace ( ) const

inlinefinaloverridevirtual

Return the gradients of the variable's shape functions on an element face.

MooseVariableFV::_grad_phi_face

Definition at line 616 of file MooseVariableFV.h.

616 { return _grad_phi_face; }

const FieldVariablePhiGradient & _grad_phi_face

Definition: MooseVariableFV.h:703

◆ gradPhiFaceNeighbor()

template<typename OutputType>

const FieldVariablePhiGradient& MooseVariableFV< OutputType >::gradPhiFaceNeighbor ( ) const

inlinefinaloverridevirtual

Return the gradients of the variable's shape functions on a neighboring element face.

Definition at line 626 of file MooseVariableFV.h.

   {
     return _grad_phi_face_neighbor;
   }

◆ gradPhiNeighbor()

template<typename OutputType>

const FieldVariablePhiGradient& MooseVariableFV< OutputType >::gradPhiNeighbor ( ) const

inlinefinaloverridevirtual

Return the gradients of the variable's shape functions on a neighboring element.

Definition at line 636 of file MooseVariableFV.h.

   {
     return _grad_phi_neighbor;
   }

◆ gradSln()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFV< OutputType >::gradSln ( ) const

inlineoverridevirtual

element gradients

Definition at line 230 of file MooseVariableFV.h.

   {
     return _element_data->gradSln(Moose::Current);
   }

◆ gradSlnNeighbor()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFV< OutputType >::gradSlnNeighbor ( ) const

inlineoverridevirtual

neighbor solution gradients

Definition at line 247 of file MooseVariableFV.h.

   {
     return _neighbor_data->gradSln(Moose::Current);
   }

◆ gradSlnOld()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFV< OutputType >::gradSlnOld ( ) const

inlineoverridevirtual

Definition at line 234 of file MooseVariableFV.h.

   {
     return _element_data->gradSln(Moose::Old);
   }

◆ gradSlnOldNeighbor()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFV< OutputType >::gradSlnOldNeighbor ( ) const

inlineoverridevirtual

Definition at line 251 of file MooseVariableFV.h.

   {
     return _neighbor_data->gradSln(Moose::Old);
   }

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns: Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 138 of file MooseBase.h.

138 { return _pars.hasBase(); }

Referenced by LinearFVFluxKernel::addMatrixContribution(), DiracKernelBase::addPoint(), LinearFVFluxKernel::addRightHandSideContribution(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), DomainUserObject::checkVariable(), ComputeJacobianThread::compute(), ComboMarker::computeElementMarker(), GradientJumpIndicator::computeQpIntegral(), ProjectionAux::computeValue(), DomainUserObject::DomainUserObject(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MeshDivisionFunctorReductionVectorPostprocessor::hasBlocks(), BlockRestrictable::hasBlocks(), MooseVariableField< Real >::hasBlocks(), FVFluxKernel::hasFaceSide(), IndicatorMarker::IndicatorMarker(), NodePositions::initialize(), ParsedDownSelectionPositions::initialize(), UpdateErrorVectorsThread::onElement(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), and BlockRestrictionDebugOutput::printBlockRestrictionMap().

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

InputParameters::hasBase

bool hasBase() const

Definition: InputParameters.C:491

◆ hasBlockMaterialProperty()

template<typename T , bool is_ad>

bool BlockRestrictable::hasBlockMaterialProperty ( const std::string & prop_name )

inherited

Check if a material property is valid for all blocks of this object.

This method returns true if the supplied property name has been declared in a Material object on the block ids for this object.

Template Parameters

T	The type of material property

Parameters

prop_name the name of the property to query

Returns: true if the property exists for all block ids of the object, otherwise false

See also: Material::hasBlockMaterialProperty

Definition at line 271 of file BlockRestrictable.h.

 {
   mooseAssert(_blk_material_data != NULL, "MaterialData pointer is not defined");
   return hasBlockMaterialPropertyHelper(prop_name) &&
          _blk_material_data->haveGenericProperty<T, is_ad>(prop_name);
 }

◆ hasBlockMaterialPropertyHelper()

bool BlockRestrictable::hasBlockMaterialPropertyHelper ( const std::string & prop_name )

protectedvirtualinherited

A helper method to allow the Material object to specialize the behavior of hasBlockMaterialProperty.

It also avoid circular #include problems.

See also: hasBlockMaterialProperty

Definition at line 285 of file BlockRestrictable.C.

Referenced by BlockRestrictable::hasBlockMaterialProperty().

 {
 
   // Reference to MaterialWarehouse for testing and retrieving block ids
   const MaterialWarehouse & warehouse = _blk_feproblem->getMaterialWarehouse();
 
   // Complete set of ids that this object is active
   const std::set<SubdomainID> & ids = blockRestricted() ? blockIDs() : meshBlockIDs();
 
   // Loop over each id for this object
   for (const auto & id : ids)
   {
     // Storage of material properties that have been DECLARED on this id
     std::set<std::string> declared_props;
 
     // If block materials exist, populated the set of properties that were declared
     if (warehouse.hasActiveBlockObjects(id))
     {
       const std::vector<std::shared_ptr<MaterialBase>> & mats = warehouse.getActiveBlockObjects(id);
       for (const auto & mat : mats)
       {
         const std::set<std::string> & mat_props = mat->getSuppliedItems();
         declared_props.insert(mat_props.begin(), mat_props.end());
       }
     }
 
     // If the supplied property is not in the list of properties on the current id, return false
     if (declared_props.find(prop_name) == declared_props.end())
       return false;
   }
 
   // If you get here the supplied property is defined on all blocks
   return true;
 }

◆ hasBlocks() [1/6]

bool BlockRestrictable::hasBlocks ( const SubdomainName & name ) const

inherited

Test if the supplied block name is valid for this object.

Parameters

name	A SubdomainName to check

Returns: True if the given id is valid for this object

Definition at line 209 of file BlockRestrictable.C.

 {
   // Create a vector and utilize the getSubdomainIDs function, which
   // handles the ANY_BLOCK_ID (getSubdomainID does not)
   std::vector<SubdomainName> names(1);
   names[0] = name;
   return hasBlocks(_blk_mesh->getSubdomainIDs(names));
 }

◆ hasBlocks() [2/6]

bool BlockRestrictable::hasBlocks ( const std::vector< SubdomainName > & names ) const

inherited

Test if the supplied vector of block names are valid for this object.

Parameters

names A vector of SubdomainNames to check

Returns: True if the given ids are valid for this object

Definition at line 219 of file BlockRestrictable.C.

 {
   return hasBlocks(_blk_mesh->getSubdomainIDs(names));
 }

◆ hasBlocks() [3/6]

bool BlockRestrictable::hasBlocks ( const std::set< SubdomainName > & names ) const

inherited

Test if the supplied set of block names are valid for this object.

Parameters

names A set of SubdomainNames to check

Returns: True if the given ids are valid for this object

Definition at line 225 of file BlockRestrictable.C.

 {
   return hasBlocks(_blk_mesh->getSubdomainIDs(names));
 }

◆ hasBlocks() [4/6]

bool BlockRestrictable::hasBlocks ( const std::vector< SubdomainID > & ids ) const

inherited

Test if the supplied vector block ids are valid for this object.

Parameters

ids	A vector of SubdomainIDs ids to check

Returns: True if all of the given ids are found within the ids for this object

Definition at line 240 of file BlockRestrictable.C.

 {
   std::set<SubdomainID> ids_set(ids.begin(), ids.end());
   return hasBlocks(ids_set);
 }

◆ hasBlocks() [5/6]

bool BlockRestrictable::hasBlocks ( const std::set< SubdomainID > & ids ) const

inherited

Test if the supplied set of block ids are valid for this object.

Parameters

ids	A std::set of SubdomainIDs to check

Returns: True if all of the given ids are found within the ids for this object

See also: isSubset

Definition at line 247 of file BlockRestrictable.C.

 {
   if (_blk_ids.empty() || _blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
     return true;
   else
     return std::includes(_blk_ids.begin(), _blk_ids.end(), ids.begin(), ids.end());
 }

◆ hasBlocks() [6/6]

template<typename OutputType>

bool MooseVariableField< OutputType >::hasBlocks ( const SubdomainID ) const

inlineoverridevirtualinherited

Returns whether the functor is defined on this block.

Reimplemented from Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 400 of file MooseVariableField.h.

Referenced by Coupleable::checkWritableVar(), InternalSideIndicatorBase::computeIndicator(), GradientJumpIndicator::computeQpIntegral(), FVInterfaceKernel::FVInterfaceKernel(), ComputeLinearFVGreenGaussGradientVolumeThread::operator()(), and FVInterfaceKernel::singleSidedFaceArg().

400 { return BlockRestrictable::hasBlocks(id); }

BlockRestrictable::hasBlocks

bool hasBlocks(const SubdomainName &name) const

Test if the supplied block name is valid for this object.

Definition: BlockRestrictable.C:209

◆ hasDirichletBC()

template<typename OutputType>

bool MooseVariableFV< OutputType >::hasDirichletBC ( ) const

inline

Returns true if a Dirichlet BC exists on the current face.

This only works if the variable has been initialized on a face with computeFaceValues. Its return value is nonsense if initialized on a single element via computeElemValues.

Definition at line 455 of file MooseVariableFV.h.

   {
     return _element_data->hasDirichletBC() || _neighbor_data->hasDirichletBC();
   }

◆ hasDoFsOnNodes()

template<typename OutputType>

bool MooseVariableFV< OutputType >::hasDoFsOnNodes ( ) const

inlinefinaloverridevirtual

Does this variable have DoFs on nodes.

Returns: true if it does, false if not.

Reimplemented from MooseVariableBase.

Definition at line 158 of file MooseVariableFV.h.

158 { return false; }

◆ hasFaceSide()

bool Moose::FunctorBase< Moose::ADType< OutputType >::type >::hasFaceSide	(	const FaceInfo &	fi,
		const bool	fi_elem_side
	)		const

overridevirtualinherited

Implements FaceArgInterface.

Definition at line 976 of file MooseFunctor.h.

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

◆ initializeBlockRestrictable()

void BlockRestrictable::initializeBlockRestrictable ( const MooseObject * moose_object )

protectedinherited

An initialization routine needed for dual constructors.

Definition at line 74 of file BlockRestrictable.C.

Referenced by BlockRestrictable::BlockRestrictable().

 {
   // If the mesh pointer is not defined, but FEProblemBase is, get it from there
   if (_blk_feproblem != NULL && _blk_mesh == NULL)
     _blk_mesh = &_blk_feproblem->mesh();
 
   // Check that the mesh pointer was defined, it is required for this class to operate
   if (_blk_mesh == NULL)
     mooseError("The input parameters must contain a pointer to FEProblem via '_fe_problem' or a "
                "pointer to the MooseMesh via '_mesh'");
 
   // Populate the MaterialData pointer
   if (_blk_feproblem != NULL)
     _blk_material_data = &_blk_feproblem->getMaterialData(Moose::BLOCK_MATERIAL_DATA, _blk_tid);
 
   // The 'block' input is defined
   if (moose_object->isParamValid("block"))
   {
     // Extract the blocks from the input
     _blocks = moose_object->getParam<std::vector<SubdomainName>>("block");
 
     // Store the IDs in a set, handling ANY_BLOCK_ID if supplied
     if (std::find(_blocks.begin(), _blocks.end(), "ANY_BLOCK_ID") != _blocks.end())
       _blk_ids.insert(Moose::ANY_BLOCK_ID);
     else
     {
       // Get the IDs from the supplied names
       _vec_ids = _blk_mesh->getSubdomainIDs(_blocks);
       _blk_ids.insert(_vec_ids.begin(), _vec_ids.end());
     }
   }
 
   // When 'blocks' is not set and there is a "variable", use the blocks from the variable
   else if (moose_object->isParamValid("variable"))
   {
     std::string variable_name = moose_object->parameters().getMooseType("variable");
     if (!variable_name.empty())
       _blk_ids = _blk_feproblem
                      ->getVariable(_blk_tid,
                                    variable_name,
                                    Moose::VarKindType::VAR_ANY,
                                    Moose::VarFieldType::VAR_FIELD_ANY)
                      .activeSubdomains();
   }
 
   // Produce error if the object is not allowed to be both block and boundary restricted
   if (!_blk_dual_restrictable && !_boundary_ids.empty() && !_boundary_ids.empty())
     if (!_boundary_ids.empty() && _boundary_ids.find(Moose::ANY_BOUNDARY_ID) == _boundary_ids.end())
       moose_object->paramError("block",
                                "Attempted to restrict the object '",
                                _blk_name,
                                "' to a block, but the object is already restricted by boundary");
 
   // If no blocks were defined above, specify that it is valid on all blocks
   if (_blk_ids.empty() && !moose_object->isParamValid("boundary"))
   {
     _blk_ids.insert(Moose::ANY_BLOCK_ID);
     _blocks = {"ANY_BLOCK_ID"};
   }
 
   // If this object is block restricted, check that defined blocks exist on the mesh
   if (_blk_ids.find(Moose::ANY_BLOCK_ID) == _blk_ids.end())
   {
     const std::set<SubdomainID> & valid_ids = _blk_mesh->meshSubdomains();
     std::vector<SubdomainID> diff;
 
     std::set_difference(_blk_ids.begin(),
                         _blk_ids.end(),
                         valid_ids.begin(),
                         valid_ids.end(),
                         std::back_inserter(diff));
 
     if (!diff.empty())
     {
       std::ostringstream msg;
       auto sep = " ";
       msg << "the following blocks (ids) do not exist on the mesh:";
       for (const auto & id : diff)
       {
         if (_blk_name.size() > 0)
         {
           auto & name =
               _blocks.at(std::find(_vec_ids.begin(), _vec_ids.end(), id) - _vec_ids.begin());
           if (std::to_string(id) != name)
             msg << sep << name << " (" << id << ")";
           else
             msg << sep << id;
         }
         else
           msg << sep << id;
         sep = ", ";
       }
       std::vector<SubdomainID> valid_ids_vec(valid_ids.begin(), valid_ids.end());
       auto valid_names = _blk_mesh->getSubdomainNames(valid_ids_vec);
       msg << "\nBlocks names (resp. ids) that do exist: " << Moose::stringify(valid_names) << " ("
           << Moose::stringify(valid_ids) << ")";
       moose_object->paramError("block", msg.str());
     }
   }
 
   // Get the mesh dimension for the blocks
   if (blockRestricted())
     _blk_dim = _blk_mesh->getBlocksMaxDimension(_blocks);
   else
     _blk_dim = _blk_mesh->dimension();
 }

◆ initialSetup()

template<typename OutputType >

void MooseVariableFV< OutputType >::initialSetup ( )

overridevirtual

Gets called at the beginning of the simulation before this object is asked to do its job.

Reimplemented from MooseVariableBase.

Definition at line 849 of file MooseVariableFV.h.

 {
   determineBoundaryToDirichletBCMap();
   determineBoundaryToFluxBCMap();
   MooseVariableField<OutputType>::initialSetup();
 }

◆ insert()

template<typename OutputType>

void MooseVariableFV< OutputType >::insert ( libMesh::NumericVector< libMesh::Number > & vector )

overridevirtual

Insert the currently cached degree of freedom values into the provided vector.

Implements MooseVariableFieldBase.

Definition at line 141 of file MooseVariableFV.C.

 {
   _element_data->insert(residual);
 }

◆ insertLower()

template<typename OutputType>

void MooseVariableFV< OutputType >::insertLower ( libMesh::NumericVector< libMesh::Number > & vector )

overridevirtual

Insert the currently cached degree of freedom values for a lower-dimensional element into the provided vector.

Implements MooseVariableFieldBase.

Definition at line 148 of file MooseVariableFV.C.

 {
   lowerDError();
 }

◆ isArray()

template<typename OutputType >

bool MooseVariableField< OutputType >::isArray ( ) const

overridevirtualinherited

Returns: whether this is an array variable

Reimplemented from MooseVariableBase.

Definition at line 86 of file MooseVariableField.C.

 {
   const auto is_array = MooseVariableBase::isArray();
   if (std::is_same<OutputType, RealEigenVector>::value != is_array)
     mooseError("A variable is marked as an array variable in a base class, but in a derived class "
                "the output type is not consistent.");
   return is_array;
 }

◆ isBlockSubset() [1/2]

bool BlockRestrictable::isBlockSubset ( const std::set< SubdomainID > & ids ) const

inherited

Test if the class block ids are a subset of the supplied objects.

Parameters

ids	A std::set of Subdomains to check

Returns: True if all of the block ids for this class are found within the given ids (opposite of hasBlocks)

See also: hasBlocks

Definition at line 256 of file BlockRestrictable.C.

Referenced by BlockRestrictable::checkVariable(), BlockRestrictable::isBlockSubset(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), and ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux().

 {
   // An empty input is assumed to be ANY_BLOCK_ID
   if (ids.empty() || ids.find(Moose::ANY_BLOCK_ID) != ids.end())
     return true;
 
   if (_blk_ids.find(Moose::ANY_BLOCK_ID) != _blk_ids.end())
     return std::includes(ids.begin(),
                          ids.end(),
                          _blk_mesh->meshSubdomains().begin(),
                          _blk_mesh->meshSubdomains().end());
   else
     return std::includes(ids.begin(), ids.end(), _blk_ids.begin(), _blk_ids.end());
 }

◆ isBlockSubset() [2/2]

bool BlockRestrictable::isBlockSubset ( const std::vector< SubdomainID > & ids ) const

inherited

Test if the class block ids are a subset of the supplied objects.

Parameters

ids	A std::vector of Subdomains to check

Returns: True if all of the block ids for this class are found within the given ids (opposite of hasBlocks)

See also: hasBlocks

Definition at line 272 of file BlockRestrictable.C.

 {
   std::set<SubdomainID> ids_set(ids.begin(), ids.end());
   return isBlockSubset(ids_set);
 }

◆ isConstant()

virtual bool Moose::FunctorBase< Moose::ADType< OutputType >::type >::isConstant ( ) const

inlinevirtualinherited

Returns true if this functor is a constant.

Definition at line 260 of file MooseFunctor.h.

260 { return false; }

◆ isDirichletBoundaryFace()

template<typename OutputType >

bool MooseVariableFV< OutputType >::isDirichletBoundaryFace	(	const FaceInfo &	fi,
		const Elem *	elem,
		const Moose::StateArg &	state
	)		const

virtual

Determine whether a specified face side is a Dirichlet boundary face.

In the base implementation we only inspect the face information object for whether there are Dirichlet conditions. However, derived classes may allow discontinuities between + and - side face values, e.g. one side may have a Dirichlet condition and the other side may perform extrapolation to determine its value

Parameters

fi	The face information object
elem	An element that can be used to indicate sidedness of the face
state	The state at which to determine whether the face is a Dirichlet face or not

Returns: Whether the potentially sided (as indicated by elem) fi is a Dirichlet boundary face for this variable

Definition at line 473 of file MooseVariableFV.C.

 {
   const auto & pr = getDirichletBC(fi);
 
   // First member of this pair indicates whether we have a DirichletBC
   return pr.first;
 }

◆ isExtrapolatedBoundaryFace()

template<typename OutputType >

bool MooseVariableFV< OutputType >::isExtrapolatedBoundaryFace	(	const FaceInfo &	fi,
		const Elem *	elem,
		const Moose::StateArg &	state
	)		const

overrideprotectedvirtual

Returns whether this is an extrapolated boundary face.

An extrapolated boundary face is boundary face for which is not a corresponding Dirichlet condition, e.g. we need to compute some approximation for the boundary face value using the adjacent cell centroid information. In the base implementation we only inspect the face information object for whether we should perform extrapolation. However, derived classes may allow discontinuities between + and - side face values, e.g. one side may have a Dirichlet condition and the other side may perform extrapolation to determine its value

Parameters

fi	The face information object
elem	An element that can be used to indicate sidedness of the face
state	The state at which to determine whether the face is extrapolated or not

Returns: Whether the potentially sided (as indicated by elem) fi is an extrapolated boundary face for this variable

Reimplemented from Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 504 of file MooseVariableFV.C.

 {
   if (isDirichletBoundaryFace(fi, elem, state))
     return false;
   else
     return !this->isInternalFace(fi);
 }

◆ isFV()

template<typename OutputType>

virtual bool MooseVariableFV< OutputType >::isFV ( ) const

inlineoverridevirtual

Reimplemented from MooseVariableFieldBase.

Definition at line 94 of file MooseVariableFV.h.

94 { return true; }

◆ isInternalFace()

bool Moose::FunctorBase< Moose::ADType< OutputType >::type >::isInternalFace ( const FaceInfo & fi ) const

inherited

Returns true if the face is an internal face.

Definition at line 569 of file MooseFunctor.h.

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

◆ isLowerD()

bool MooseVariableBase::isLowerD ( ) const

inlineinherited

Returns: whether this variable lives on lower dimensional blocks

Definition at line 191 of file MooseVariableBase.h.

191 { return _is_lower_d; }

MooseVariableBase::_is_lower_d

bool _is_lower_d

Whether this variable lives on lower dimensional blocks.

Definition: MooseVariableBase.h:253

◆ isNodal()

template<typename OutputType>

virtual bool MooseVariableFV< OutputType >::isNodal ( ) const

inlinefinaloverridevirtual

Is this variable nodal.

Returns: true if it nodal, otherwise false

Reimplemented from MooseVariableBase.

Definition at line 156 of file MooseVariableFV.h.

156 { return false; }

◆ isNodalDefined()

template<typename OutputType>

virtual bool MooseVariableFV< OutputType >::isNodalDefined ( ) const

inlinefinaloverridevirtual

Is this variable defined at nodes.

Returns: true if it the variable is defined at nodes, otherwise false

Implements MooseVariableFieldBase.

Definition at line 165 of file MooseVariableFV.h.

165 { return false; }

◆ isParamSetByUser()

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

inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters

name	The name of the parameter to test

Definition at line 201 of file MooseBase.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), LibtorchNeuralNetControl::conditionalParameterError(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), ElementSubdomainModifierBase::ElementSubdomainModifierBase(), MooseApp::errorCheck(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::runInputFile(), MooseApp::runInputs(), MFEMSolverBase::setPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

   {
     return _pars.isParamSetByUser(name);
   }

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 195 of file MooseBase.h.

195 { return _pars.isParamValid(name); }

InputParameters::isParamValid

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

MooseBase::name

const std::string & name() const

Get the name of the class.

Definition: MooseBase.h:99

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

This method returns parameters that have been initialized in one fashion or another, i.e.

Definition: InputParameters.C:386

◆ isVector()

template<typename OutputType >

bool MooseVariableField< OutputType >::isVector ( ) const

overridevirtualinherited

Returns: true if this is a vector-valued element, false otherwise.

Implements MooseVariableFieldBase.

Definition at line 97 of file MooseVariableField.C.

 {
   return std::is_same<OutputType, RealVectorValue>::value;
 }

◆ jacobianSetup()

template<typename OutputType >

void MooseVariableFV< OutputType >::jacobianSetup ( )

overridevirtual

Reimplemented from MooseVariableField< OutputType >.

Definition at line 696 of file MooseVariableFV.C.

 {
   clearCaches();
 }

◆ kind()

Moose::VarKindType MooseVariableBase::kind ( ) const

inlineinherited

Kind of the variable (Nonlinear, Auxiliary, ...)

Definition at line 90 of file MooseVariableBase.h.

Referenced by ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), FVFluxBC::FVFluxBC(), MooseVariableInterface< Real >::MooseVariableInterface(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), and PeriodicSegmentalConstraint::PeriodicSegmentalConstraint().

90 { return _var_kind; }

MooseVariableBase::_var_kind

Moose::VarKindType _var_kind

Variable type (see MooseTypes.h)

Definition: MooseVariableBase.h:220

◆ lowerDError()

template<typename OutputType >

void MooseVariableFV< OutputType >::lowerDError ( ) const

private

Emit an error message for unsupported lower-d ops.

Definition at line 884 of file MooseVariableFV.h.

 {
   mooseError("Lower dimensional element support not implemented for finite volume variables");
 }

◆ matrixTagValue()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::matrixTagValue ( TagID tag ) const

inlineoverridevirtual

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), MooseApp::getRecoverFileBase(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MooseApp::hasRecoverFileBase(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), MooseApp::setupOptions(), UserForcingFunction::UserForcingFunction(), and VariableResidual::VariableResidual().

Definition at line 213 of file MooseVariableFV.h.

   {
     return _element_data->matrixTagValue(tag);
   }

◆ matrixTagValueNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::matrixTagValueNeighbor ( TagID tag )

inline

Definition at line 221 of file MooseVariableFV.h.

   {
     return _neighbor_data->matrixTagValue(tag);
   }

◆ meshBlockIDs()

const std::set< SubdomainID > & BlockRestrictable::meshBlockIDs ( ) const

inherited

Return all of the SubdomainIDs for the mesh.

Returns: A set of all subdomians for the entire mesh

Definition at line 279 of file BlockRestrictable.C.

Referenced by BlockRestrictable::checkVariable(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), BlockRestrictable::getBlockCoordSystem(), BlockRestrictable::hasBlockMaterialPropertyHelper(), and SolutionIC::initialSetup().

 {
   return _blk_mesh->meshSubdomains();
 }

◆ meshChanged()

template<typename OutputType >

void MooseVariableFV< OutputType >::meshChanged ( )

overridevirtual

Called on this object when the mesh changes.

Reimplemented from MeshChangedInterface.

Definition at line 858 of file MooseVariableFV.h.

 {
   _prev_elem = nullptr;
   _dirichlet_map_setup = false;
   _flux_map_setup = false;
   MooseVariableField<OutputType>::meshChanged();
 }

◆ messagePrefix()

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

inlineinherited

Returns: A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 252 of file MooseBase.h.

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

   {
     return messagePrefix(_pars, hit_prefix);
   }

◆ mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 310 of file MooseBase.h.

   {
     moose::internal::mooseDeprecatedStream(
         _console, false, true, messagePrefix(true), std::forward<Args>(args)...);
   }

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 273 of file MooseBase.h.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

   {
     callMooseError(moose::internal::formatMooseDocumentedError(
                        repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                    /* with_prefix = */ true);
   }

◆ mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 267 of file MooseBase.h.

   {
     callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
   }

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 286 of file MooseBase.h.

   {
     callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
   }

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 317 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MFEMScalarFESpace::getFECName(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

   {
     moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
   }

◆ mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 295 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::addFunction(), MooseMesh::addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), DataFileInterface::getDataFilePath(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), CylindricalGridDivision::initialize(), CartesianGridDivision::initialize(), SphericalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseApp::loadLibraryAndDependencies(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramWarning(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

   {
     moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
   }

◆ mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 304 of file MooseBase.h.

   {
     moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
   }

◆ name()

const std::string& MooseBase::name ( ) const

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 99 of file MooseBase.h.

   {
     mooseAssert(_name.size(), "Empty name");
     return _name;
   }

◆ needsGradientVectorStorage()

virtual bool MooseVariableFieldBase::needsGradientVectorStorage ( ) const

inlinevirtualinherited

Check if this variable needs a raw vector of gradients at dof-values.

This is mainly used for finite volume variables.

Reimplemented in MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, and MooseLinearVariableFV< Real >.

Definition at line 120 of file MooseVariableFieldBase.h.

120 { return false; }

◆ nodalDofIndex()

template<typename OutputType>

virtual const dof_id_type& MooseVariableFV< OutputType >::nodalDofIndex ( ) const

inlinefinaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 112 of file MooseVariableFV.h.

   {
     mooseError("nodalDofIndex not supported by MooseVariableFVBase");
   }

◆ nodalDofIndexNeighbor()

template<typename OutputType>

virtual const dof_id_type& MooseVariableFV< OutputType >::nodalDofIndexNeighbor ( ) const

inlinefinaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 116 of file MooseVariableFV.h.

   {
     mooseError("nodalDofIndexNeighbor not supported by MooseVariableFVBase");
   }

◆ nodalMatrixTagValue()

template<typename OutputType>

const DoFValue& MooseVariableFV< OutputType >::nodalMatrixTagValue ( TagID ) const

inlineoverridevirtual

Definition at line 200 of file MooseVariableFV.h.

   {
     mooseError("nodalMatrixTagValue not implemented for finite volume variables.");
   }

◆ nodalValueArray()

template<typename OutputType>

const MooseArray<OutputType>& MooseVariableFV< OutputType >::nodalValueArray ( ) const

inlineoverridevirtual

Methods for retrieving values of variables at the nodes in a MooseArray for AuxKernelBase.

Definition at line 582 of file MooseVariableFV.h.

   {
     mooseError("Finite volume variables do not have defined values at nodes.");
   }

◆ nodalValueOldArray()

template<typename OutputType>

const MooseArray<OutputType>& MooseVariableFV< OutputType >::nodalValueOldArray ( ) const

inlineoverridevirtual

Definition at line 586 of file MooseVariableFV.h.

   {
     mooseError("Finite volume variables do not have defined values at nodes.");
   }

◆ nodalValueOlderArray()

template<typename OutputType>

const MooseArray<OutputType>& MooseVariableFV< OutputType >::nodalValueOlderArray ( ) const

inlineoverridevirtual

Definition at line 590 of file MooseVariableFV.h.

   {
     mooseError("Finite volume variables do not have defined values at nodes.");
   }

◆ nodalVectorTagValue()

template<typename OutputType>

const DoFValue& MooseVariableFV< OutputType >::nodalVectorTagValue ( TagID ) const

inlineoverridevirtual

MooseVariableBase::_var_num

Definition at line 196 of file MooseVariableFV.h.

   {
     mooseError("nodalVectorTagValue not implemented for finite volume variables.");
   }

◆ number()

unsigned int MooseVariableBase::number ( ) const

inlineinherited

Get variable number coming from libMesh.

Returns: the libmesh variable number

Definition at line 59 of file MooseVariableBase.h.

59 { return _var_num; }

unsigned int _var_num

variable number (from libMesh)

Definition: MooseVariableBase.h:211

◆ numberOfDofs()

template<typename OutputType>

unsigned int MooseVariableFV< OutputType >::numberOfDofs ( ) const

inlinefinaloverridevirtual

Get the number of local DoFs.

Reimplemented from MooseVariableBase.

Definition at line 149 of file MooseVariableFV.h.

149 { return _element_data->numberOfDofs(); }

Referenced by FEProblemBase::checkDisplacementOrders(), AuxScalarKernel::compute(), ScalarInitialCondition::compute(), ADScalarKernel::computeADJacobian(), ODEKernel::computeJacobian(), FVBoundaryScalarLagrangeMultiplierConstraint::computeJacobian(), FVScalarLagrangeMultiplierConstraint::computeOffDiagJacobian(), ODEKernel::computeOffDiagJacobianScalar(), Kernel::computeOffDiagJacobianScalar(), ScalarLagrangeMultiplier::computeOffDiagJacobianScalar(), MortarScalarBase::computeOffDiagJacobianScalar(), KernelScalarBase::computeOffDiagJacobianScalarLocal(), ArrayDGDiffusion::computeQpJacobian(), DGDiffusion::computeQpJacobian(), DGFunctionDiffusionDirichletBC::computeQpJacobian(), ArrayIntegratedBC::computeQpOffDiagJacobianScalar(), ArrayKernel::computeQpOffDiagJacobianScalar(), ADDGDiffusion::computeQpResidual(), DGDiffusion::computeQpResidual(), DGFunctionDiffusionDirichletBC::computeQpResidual(), ScalarKernel::computeResidual(), ADScalarKernel::computeResidual(), ODETimeKernel::computeResidual(), ODEKernel::computeResidual(), FVScalarLagrangeMultiplierConstraint::computeResidual(), FVBoundaryScalarLagrangeMultiplierConstraint::computeResidual(), KernelScalarBase::computeScalarOffDiagJacobianScalar(), MortarScalarBase::computeScalarOffDiagJacobianScalar(), ProjectionAux::computeValue(), ScalarCoupleable::coupledScalarOrder(), MultiAppPostprocessorToAuxScalarTransfer::execute(), FunctionScalarAux::FunctionScalarAux(), GapValueAux::GapValueAux(), ArrayDGDiffusion::initQpResidual(), NodalPatchRecovery::NodalPatchRecovery(), FEProblemBase::projectInitialConditionOnCustomRange(), ProjectionAux::ProjectionAux(), FEProblemBase::projectSolution(), and ScalarComponentIC::ScalarComponentIC().

std::unique_ptr< MooseVariableDataFV< OutputType > > _element_data

Holder for all the data associated with the "main" element.

Definition: MooseVariableFV.h:688

◆ numberOfDofsNeighbor()

template<typename OutputType>

virtual unsigned int MooseVariableFV< OutputType >::numberOfDofsNeighbor ( )

inlinefinaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 151 of file MooseVariableFV.h.

   {
     mooseError("numberOfDofsNeighbor not supported by MooseVariableFVBase");
   }

◆ numBlocks()

unsigned int BlockRestrictable::numBlocks ( ) const

inherited

Return the number of blocks for this object.

Returns: The number of subdomains

Definition at line 203 of file BlockRestrictable.C.

Referenced by ElementCentroidPositions::initialize(), and QuadraturePointsPositions::initialize().

 {
   return (unsigned int)_blk_ids.size();
 }

◆ oldestSolutionStateRequested()

template<typename OutputType >

unsigned int MooseVariableFV< OutputType >::oldestSolutionStateRequested ( ) const

finaloverridevirtual

The oldest solution state that is requested for this variable (0 = current, 1 = old, 2 = older, etc).

Implements MooseVariableFieldBase.

Definition at line 710 of file MooseVariableFV.C.

 {
   unsigned int state = 0;
   state = std::max(state, _element_data->oldestSolutionStateRequested());
   state = std::max(state, _neighbor_data->oldestSolutionStateRequested());
   return state;
 }

◆ operator()() [1/6]

FunctorBase< Moose::ADType< OutputType >::type >::ValueType Moose::FunctorBase< Moose::ADType< OutputType >::type >::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 597 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< Moose::ADType< OutputType >::type >::ValueType Moose::FunctorBase< Moose::ADType< OutputType >::type >::operator()	(	const FaceArg &	face,
		const StateArg &	state
	)		const

inherited

Definition at line 610 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()() [3/6]

FunctorBase< Moose::ADType< OutputType >::type >::ValueType Moose::FunctorBase< Moose::ADType< OutputType >::type >::operator()	(	const ElemQpArg &	qp,
		const StateArg &	state
	)		const

inherited

Definition at line 656 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< Moose::ADType< OutputType >::type >::ValueType Moose::FunctorBase< Moose::ADType< OutputType >::type >::operator()	(	const ElemSideQpArg &	qp,
		const StateArg &	state
	)		const

inherited

Definition at line 677 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< Moose::ADType< OutputType >::type >::ValueType Moose::FunctorBase< Moose::ADType< OutputType >::type >::operator()	(	const ElemPointArg &	elem_point,
		const StateArg &	state
	)		const

inherited

Definition at line 707 of file MooseFunctor.h.

 {
   return evaluate(elem_point, state);
 }

◆ operator()() [6/6]

FunctorBase< Moose::ADType< OutputType >::type >::ValueType Moose::FunctorBase< Moose::ADType< OutputType >::type >::operator()	(	const NodeArg &	node,
		const StateArg &	state
	)		const

inherited

Definition at line 724 of file MooseFunctor.h.

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

◆ order()

Order MooseVariableBase::order ( ) const

inherited

Get the order of this variable Note: Order enum can be implicitly converted to unsigned int.

Definition at line 209 of file MooseVariableBase.C.

 {
   return _fe_type.order;
 }

◆ paramError()

template<typename... Args>

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

inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 435 of file MooseBase.h.

 {
   _pars.paramError(param, std::forward<Args>(args)...);
 }

◆ parameters()

const InputParameters& MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 127 of file MooseBase.h.

127 { return _pars; }

Referenced by GridPartitioner::_do_partition(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), CombinerGenerator::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

◆ paramInfo()

template<typename... Args>

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

inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 449 of file MooseBase.h.

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

 {
   mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
 }

◆ paramWarning()

template<typename... Args>

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

inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 442 of file MooseBase.h.

 {
   mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
 }

◆ phi()

template<typename OutputType>

const FieldVariablePhiValue& MooseVariableFV< OutputType >::phi ( ) const

inlinefinaloverridevirtual

Return the variable's elemental shape functions.

Definition at line 600 of file MooseVariableFV.h.

600 { return _phi; }

MooseVariableFV::_phi

const FieldVariablePhiValue & _phi

Shape functions.

Definition: MooseVariableFV.h:700

◆ phiFace()

template<typename OutputType>

const FieldVariablePhiValue& MooseVariableFV< OutputType >::phiFace ( ) const

inlinefinaloverridevirtual

Return the variable's shape functions on an element face.

MooseVariableFV::_phi_face

Definition at line 615 of file MooseVariableFV.h.

615 { return _phi_face; }

const FieldVariablePhiValue & _phi_face

Definition: MooseVariableFV.h:702

◆ phiFaceNeighbor()

template<typename OutputType>

const FieldVariablePhiValue& MooseVariableFV< OutputType >::phiFaceNeighbor ( ) const

inlinefinaloverridevirtual

Return the variable's shape functions on a neighboring element face.

MooseVariableFV::_phi_face

Definition at line 622 of file MooseVariableFV.h.

   {
     return _phi_face_neighbor;
   }

◆ phiFaceNeighborSize()

template<typename OutputType>

virtual std::size_t MooseVariableFV< OutputType >::phiFaceNeighborSize ( ) const

inlinefinaloverridevirtual

Return phiFaceNeighbor size.

Implements MooseVariableFieldBase.

Definition at line 123 of file MooseVariableFV.h.

   {
     return _phi_face_neighbor.size();
   }

◆ phiFaceSize()

template<typename OutputType>

virtual std::size_t MooseVariableFV< OutputType >::phiFaceSize ( ) const

inlinefinaloverridevirtual

Return phiFace size.

Implements MooseVariableFieldBase.

Definition at line 121 of file MooseVariableFV.h.

121 { return _phi_face.size(); }

MooseArray::size

unsigned int size() const

The number of elements that can currently be stored in the array.

Definition: MooseArray.h:259

const FieldVariablePhiValue & _phi_face

Definition: MooseVariableFV.h:702

◆ phiLower()

template<typename OutputType >

const MooseVariableFV< OutputType >::FieldVariablePhiValue & MooseVariableFV< OutputType >::phiLower ( ) const

overridevirtual

Return the variable's shape functions on a lower-dimensional element.

Definition at line 877 of file MooseVariableFV.h.

 {
   lowerDError();
 }

◆ phiLowerSize()

template<typename OutputType>

virtual std::size_t MooseVariableFV< OutputType >::phiLowerSize ( ) const

inlinefinaloverridevirtual

Return the number of shape functions on the lower dimensional element for this variable.

Implements MooseVariableFieldBase.

Definition at line 127 of file MooseVariableFV.h.

   {
     mooseError("phiLowerSize not supported by MooseVariableFVBase");
   }

◆ phiNeighbor()

template<typename OutputType>

const FieldVariablePhiValue& MooseVariableFV< OutputType >::phiNeighbor ( ) const

inlinefinaloverridevirtual

Return the variable's shape functions on a neighboring element.

MooseVariableFV::_phi_neighbor

Definition at line 635 of file MooseVariableFV.h.

635 { return _phi_neighbor; }

const FieldVariablePhiValue & _phi_neighbor

Definition: MooseVariableFV.h:706

◆ phiNeighborSize()

template<typename OutputType>

virtual std::size_t MooseVariableFV< OutputType >::phiNeighborSize ( ) const

inlinefinaloverridevirtual

Return phiNeighbor size.

Implements MooseVariableFieldBase.

Definition at line 122 of file MooseVariableFV.h.

122 { return _phi_neighbor.size(); }

MooseArray::size

unsigned int size() const

The number of elements that can currently be stored in the array.

Definition: MooseArray.h:259

MooseVariableFV::_phi_neighbor

const FieldVariablePhiValue & _phi_neighbor

Definition: MooseVariableFV.h:706

◆ phiSize()

template<typename OutputType>

virtual std::size_t MooseVariableFV< OutputType >::phiSize ( ) const

inlinefinaloverridevirtual

Return phi size.

Implements MooseVariableFieldBase.

Definition at line 120 of file MooseVariableFV.h.

120 { return _phi.size(); }

MooseArray::size

unsigned int size() const

The number of elements that can currently be stored in the array.

Definition: MooseArray.h:259

MooseVariableFV::_phi

const FieldVariablePhiValue & _phi

Shape functions.

Definition: MooseVariableFV.h:700

◆ prepare()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::prepare ( )

inlinefinaloverridevirtual

Prepare the elemental degrees of freedom.

Implements MooseVariableFieldBase.

Definition at line 102 of file MooseVariableFV.h.

102 {}

◆ prepareAux()

template<typename OutputType >

void MooseVariableFV< OutputType >::prepareAux ( )

finaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 851 of file MooseVariableFV.C.

 {
   _element_data->prepareAux();
   _neighbor_data->prepareAux();
 }

◆ prepareIC()

template<typename OutputType >

void MooseVariableFV< OutputType >::prepareIC ( )

overridevirtual

Prepare the initial condition.

Implements MooseVariableFieldBase.

Definition at line 302 of file MooseVariableFV.C.

 {
   _element_data->prepareIC();
 }

◆ prepareLowerD()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::prepareLowerD ( )

inlinefinaloverridevirtual

Prepare a lower dimensional element's degrees of freedom.

Implements MooseVariableFieldBase.

Definition at line 110 of file MooseVariableFV.h.

110 {}

◆ prepareNeighbor()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::prepareNeighbor ( )

inlinefinaloverridevirtual

Prepare the neighbor element degrees of freedom.

Implements MooseVariableFieldBase.

Definition at line 103 of file MooseVariableFV.h.

103 {}

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

If the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns: A pointer to the parameter value, if it exists

Definition at line 391 of file MooseBase.h.

 {
   return isParamValid(name) ? &getParam<T>(name) : nullptr;
 }

◆ reinitAux()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::reinitAux ( )

inlinefinaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 108 of file MooseVariableFV.h.

108 {}

◆ reinitAuxNeighbor()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::reinitAuxNeighbor ( )

inlinefinaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 109 of file MooseVariableFV.h.

109 {}

◆ reinitNode()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::reinitNode ( )

inlinefinaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 105 of file MooseVariableFV.h.

105 {}

◆ reinitNodes()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::reinitNodes ( const std::vector< dof_id_type > & )

inlinefinaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 106 of file MooseVariableFV.h.

106 {}

◆ reinitNodesNeighbor()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::reinitNodesNeighbor ( const std::vector< dof_id_type > & )

inlinefinaloverridevirtual

Implements MooseVariableFieldBase.

Definition at line 107 of file MooseVariableFV.h.

107 {}

◆ requireQpComputations()

template<typename OutputType>

virtual void MooseVariableFV< OutputType >::requireQpComputations ( ) const

inlinevirtual

Request that quadrature point data be (pre)computed.

Quadrature point data is (pre)computed by default for this base class but derived variable classes may choose not to unless this API is called

Definition at line 486 of file MooseVariableFV.h.

Referenced by FVTimeKernel::FVTimeKernel().

486 {}

◆ residualSetup()

template<typename OutputType >

void MooseVariableFV< OutputType >::residualSetup ( )

overridevirtual

Reimplemented from MooseVariableField< OutputType >.

Definition at line 684 of file MooseVariableFV.C.

 {
   if (!_dirichlet_map_setup)
     determineBoundaryToDirichletBCMap();
   if (!_flux_map_setup)
     determineBoundaryToFluxBCMap();
 
   clearCaches();
 }

◆ scalingFactor() [1/2]

void MooseVariableBase::scalingFactor ( const std::vector< Real > & factor )

inherited

Set the scaling factor for this variable.

Definition at line 235 of file MooseVariableBase.C.

 {
   mooseAssert(factor.size() == _count, "Inconsistent scaling factor size");
   for (const auto i : make_range(_count))
     _scaling_factor[i] = factor[i];
 }

◆ scalingFactor() [2/2]

Real MooseVariableBase::scalingFactor ( ) const

inlineinherited

Get the scaling factor for this variable.

Definition at line 100 of file MooseVariableBase.h.

Referenced by MooseVariableBase::MooseVariableBase().

100 { return _scaling_factor[0]; }

MooseVariableBase::_scaling_factor

std::vector< Real > _scaling_factor

scaling factor for this variable

Definition: MooseVariableBase.h:247

◆ secondPhi()

template<typename OutputType>

const FieldVariablePhiSecond& MooseVariableFV< OutputType >::secondPhi ( ) const

inlinefinaloverridevirtual

Return the rank-2 tensor of second derivatives of the variable's elemental shape functions.

Definition at line 602 of file MooseVariableFV.h.

   {
     mooseError("We don't currently implement second derivatives for FV");
   }

◆ secondPhiFace()

template<typename OutputType>

const FieldVariablePhiSecond& MooseVariableFV< OutputType >::secondPhiFace ( ) const

inlinefinaloverridevirtual

Return the rank-2 tensor of second derivatives of the variable's shape functions on an element face.

Definition at line 617 of file MooseVariableFV.h.

   {
     mooseError("We don't currently implement second derivatives for FV");
   }

◆ secondPhiFaceNeighbor()

template<typename OutputType>

const FieldVariablePhiSecond& MooseVariableFV< OutputType >::secondPhiFaceNeighbor ( ) const

inlinefinaloverridevirtual

Return the rank-2 tensor of second derivatives of the variable's shape functions on a neighboring element face.

Definition at line 630 of file MooseVariableFV.h.

   {
     mooseError("We don't currently implement second derivatives for FV");
   }

◆ secondPhiNeighbor()

template<typename OutputType>

const FieldVariablePhiSecond& MooseVariableFV< OutputType >::secondPhiNeighbor ( ) const

inlinefinaloverridevirtual

Return the rank-2 tensor of second derivatives of the variable's shape functions on a neighboring element.

Definition at line 640 of file MooseVariableFV.h.

   {
     mooseError("We don't currently implement second derivatives for FV");
   }

◆ setActiveTags()

template<typename OutputType >

void MooseVariableFV< OutputType >::setActiveTags ( const std::set< TagID > & vtags )

overridevirtual

Set the active vector tags.

Parameters

vtags Additional vector tags that this variable will need to query at dof indices for, in addition to our own required solution tags

Reimplemented from MooseVariableBase.

Definition at line 833 of file MooseVariableFV.h.

 {
   _element_data->setActiveTags(vtags);
   _neighbor_data->setActiveTags(vtags);
 }

◆ setCacheClearanceSchedule()

void Moose::FunctorBase< Moose::ADType< OutputType >::type >::setCacheClearanceSchedule ( const std::set< ExecFlagType > & clearance_schedule )

inherited

Set how often to clear the functor evaluation cache.

Definition at line 714 of file MooseFunctor.h.

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

◆ setDofValue()

template<typename OutputType >

void MooseVariableFV< OutputType >::setDofValue	(	const OutputData &	value,
		unsigned int	index
	)

overridevirtual

Degree of freedom value setters.

Definition at line 388 of file MooseVariableFV.C.

 {
   _element_data->setDofValue(value, index);
 }

◆ setDofValues()

template<typename OutputType >

void MooseVariableFV< OutputType >::setDofValues ( const DenseVector< OutputData > & values )

overridevirtual

Set local DOF values and evaluate the values on quadrature points.

Definition at line 395 of file MooseVariableFV.C.

 {
   _element_data->setDofValues(values);
 }

◆ setLowerDofValues()

template<typename OutputType >

void MooseVariableFV< OutputType >::setLowerDofValues ( const DenseVector< OutputData > & values )

overridevirtual

Set local DOF values for a lower dimensional element and evaluate the values on quadrature points.

Definition at line 402 of file MooseVariableFV.C.

 {
   lowerDError();
 }

◆ setNodalValue()

template<typename OutputType>

void MooseVariableFV< OutputType >::setNodalValue	(	const OutputType &	value,
		unsigned int	idx = `0`
	)

overridevirtual

Definition at line 381 of file MooseVariableFV.C.

 {
   mooseError("FV variables do not support setNodalValue");
 }

◆ sizeMatrixTagData()

template<typename OutputType >

void MooseVariableFV< OutputType >::sizeMatrixTagData ( )

overridevirtual

Size data structures related to matrix tagging.

Reimplemented from MooseVariableBase.

Definition at line 930 of file MooseVariableFV.C.

 {
   _element_data->sizeMatrixTagData();
   _neighbor_data->sizeMatrixTagData();
 }

◆ sln()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::sln ( ) const

inlineoverridevirtual

Returns: the current elemental solution

Definition at line 227 of file MooseVariableFV.h.

227 { return _element_data->sln(Moose::Current); }

std::unique_ptr< MooseVariableDataFV< OutputType > > _element_data

Holder for all the data associated with the "main" element.

Definition: MooseVariableFV.h:688

Moose::Current

Definition: MooseTypes.h:235

◆ slnNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::slnNeighbor ( ) const

inlineoverridevirtual

Returns: the current neighbor solution

Definition at line 239 of file MooseVariableFV.h.

   {
     return _neighbor_data->sln(Moose::Current);
   }

◆ slnOld()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::slnOld ( ) const

inlineoverridevirtual

Returns: the old elemental solution, e.g. that of the previous timestep

Definition at line 228 of file MooseVariableFV.h.

228 { return _element_data->sln(Moose::Old); }

std::unique_ptr< MooseVariableDataFV< OutputType > > _element_data

Holder for all the data associated with the "main" element.

Definition: MooseVariableFV.h:688

Moose::Old

Definition: MooseTypes.h:236

◆ slnOlder()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::slnOlder ( ) const

inlineoverridevirtual

Returns: the older elemental solution, e.g. that of two timesteps ago

Definition at line 229 of file MooseVariableFV.h.

229 { return _element_data->sln(Moose::Older); }

std::unique_ptr< MooseVariableDataFV< OutputType > > _element_data

Holder for all the data associated with the "main" element.

Definition: MooseVariableFV.h:688

Moose::Older

Definition: MooseTypes.h:237

◆ slnOldNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::slnOldNeighbor ( ) const

inlineoverridevirtual

Returns: the old neighbor solution, e.g. that of the previous timestep

MooseVariableBase::allDofIndices

Definition at line 243 of file MooseVariableFV.h.

   {
     return _neighbor_data->sln(Moose::Old);
   }

◆ subdomainSetup()

void SetupInterface::subdomainSetup ( )

virtualinherited

Gets called when the subdomain changes (i.e.

in a Jacobian or residual loop) and before this object is asked to do its job

Reimplemented in MaterialBase, Material, GeneralUserObject, NodalUserObject, Constraint, and ThreadedGeneralUserObject.

Definition at line 61 of file SetupInterface.C.

62 {

63 }

◆ supportsElemSideQpArg()

template<typename OutputType>

bool MooseVariableFV< OutputType >::supportsElemSideQpArg ( ) const

inlinefinaloverridevirtual

Whether this functor supports evaluation with ElemSideQpArg.

Implements Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 505 of file MooseVariableFV.h.

505 { return true; }

◆ supportsFaceArg()

template<typename OutputType>

bool MooseVariableFV< OutputType >::supportsFaceArg ( ) const

inlinefinaloverridevirtual

Whether this functor supports evaluation with FaceArg.

Implements Moose::FunctorBase< Moose::ADType< OutputType >::type >.

Definition at line 504 of file MooseVariableFV.h.

504 { return true; }

◆ sys() [1/2]

SystemBase& MooseVariableBase::sys ( )

inlineinherited

Get the system this variable is part of.

Definition at line 69 of file MooseVariableBase.h.

69 { return _sys; }

MooseVariableBase::_sys

SystemBase & _sys

System this variable is part of.

Definition: MooseVariableBase.h:205

◆ sys() [2/2]

const SystemBase& MooseVariableBase::sys ( ) const

inlineinherited

Get the system this variable is part of.

Definition at line 74 of file MooseVariableBase.h.

74 { return _sys; }

MooseVariableBase::_sys

SystemBase & _sys

System this variable is part of.

Definition: MooseVariableBase.h:205

◆ timestepSetup()

template<typename OutputType >

void MooseVariableFV< OutputType >::timestepSetup ( )

overridevirtual

Reimplemented from MooseVariableField< OutputType >.

Definition at line 868 of file MooseVariableFV.h.

 {
   _dirichlet_map_setup = false;
   _flux_map_setup = false;
   MooseVariableField<OutputType>::timestepSetup();
 }

◆ totalVarDofs()

unsigned int MooseVariableBase::totalVarDofs ( )

inlineinherited

Definition at line 85 of file MooseVariableBase.h.

85 { return allDofIndices().size(); }

const std::vector< dof_id_type > & allDofIndices() const

Get all global dofindices for the variable.

Definition: MooseVariableBase.C:197

◆ type()

const std::string& MooseBase::type ( ) const

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 89 of file MooseBase.h.

   {
     mooseAssert(_type.size(), "Empty type");
     return _type;
   }

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns: The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 54 of file MooseBase.C.

Referenced by FEProblemBase::addPostprocessor(), MaterialPropertyStorage::addProperty(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

 {
   return type() + std::string(" \"") + name() + std::string("\"");
 }

◆ uDot()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::uDot ( ) const

inline

Definition at line 226 of file MooseVariableFV.h.

226 { return _element_data->uDot(); }

MooseVariableFV::_neighbor_data

std::unique_ptr< MooseVariableDataFV< OutputType > > _element_data

Holder for all the data associated with the "main" element.

Definition: MooseVariableFV.h:688

◆ uDotNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::uDotNeighbor ( ) const

inline

Definition at line 238 of file MooseVariableFV.h.

238 { return _neighbor_data->uDot(); }

std::unique_ptr< MooseVariableDataFV< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFV.h:691

◆ uncorrectedAdGradSln()

template<typename OutputType >

VectorValue< ADReal > MooseVariableFV< OutputType >::uncorrectedAdGradSln	(	const FaceInfo &	fi,
		const StateArg &	state,
		const bool	correct_skewness = `false`
	)		const

virtual

Retrieve (or potentially compute) the uncorrected gradient on the provided face.

This uncorrected gradient is a simple linear interpolation between cell gradients computed at the centers of the two neighboring cells. "Correcting" the face gradient involves weighting the gradient stencil more heavily on the solution values on the face-neighbor cells than the linear interpolation process does. This is commonly known as a cross-diffusion correction. Correction is done in adGradSln(const FaceInfo & fi)

Parameters

face	The face for which to retrieve the gradient
state	State argument which describes at what time / solution iteration state we want to evaluate the variable
correct_skewness	Whether to perform skew corrections

Definition at line 616 of file MooseVariableFV.C.

 {
   const bool var_defined_on_elem = this->hasBlocks(fi.elem().subdomain_id());
   const Elem * const elem_one = var_defined_on_elem ? &fi.elem() : fi.neighborPtr();
   const Elem * const elem_two = var_defined_on_elem ? fi.neighborPtr() : &fi.elem();
 
   const VectorValue<ADReal> elem_one_grad = adGradSln(elem_one, state, correct_skewness);
 
   // If we have a neighbor then we interpolate between the two to the face. If we do not, then we
   // apply a zero Hessian assumption and use the element centroid gradient as the uncorrected face
   // gradient
   if (elem_two && this->hasBlocks(elem_two->subdomain_id()))
   {
     const VectorValue<ADReal> & elem_two_grad = adGradSln(elem_two, state, correct_skewness);
 
     // Uncorrected gradient value
     return Moose::FV::linearInterpolation(elem_one_grad, elem_two_grad, fi, var_defined_on_elem);
   }
   else
     return elem_one_grad;
 }

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns: The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 66 of file MooseBase.C.

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

 {
   if (!_pars.have_parameter<std::string>(unique_name_param))
     mooseError("uniqueName(): Object does not have a unique name");
   return MooseObjectName(_pars.get<std::string>(unique_name_param));
 }

◆ uniqueParameterName()

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

inherited

Returns: The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 60 of file MooseBase.C.

 {
   return MooseObjectParameterName(getBase(), name(), parameter_name);
 }

◆ useDual()

bool MooseVariableBase::useDual ( ) const

inlineinherited

Get dual mortar option.

Definition at line 79 of file MooseVariableBase.h.

Referenced by MortarConstraintBase::MortarConstraintBase().

79 { return _use_dual; }

MooseVariableBase::_use_dual

bool _use_dual

If dual mortar approach is used.

Definition: MooseVariableBase.h:250

◆ usesGradPhiNeighbor()

template<typename OutputType>

bool MooseVariableField< OutputType >::usesGradPhiNeighbor ( ) const

inlineinherited

Whether or not this variable is actually using the shape function gradient.

Currently hardcoded to true because we always compute the value.

Definition at line 344 of file MooseVariableField.h.

Referenced by Assembly::copyNeighborShapes().

344 { return true; }

◆ usesPhiNeighbor()

template<typename OutputType>

bool MooseVariableField< OutputType >::usesPhiNeighbor ( ) const

inlineinherited

Whether or not this variable is actually using the shape function value.

Currently hardcoded to true because we always compute the value.

Definition at line 337 of file MooseVariableField.h.

Referenced by Assembly::copyNeighborShapes().

337 { return true; }

◆ usesSecondPhiNeighbor()

template<typename OutputType>

bool MooseVariableFV< OutputType >::usesSecondPhiNeighbor ( ) const

inlinefinaloverridevirtual

Whether or not this variable is actually using the shape function second derivatives.

Definition at line 598 of file MooseVariableFV.h.

598 { return false; }

◆ validParams()

template<typename OutputType >

InputParameters MooseVariableFV< OutputType >::validParams ( )

static

Definition at line 34 of file MooseVariableFV.C.

 {
   InputParameters params = MooseVariableField<OutputType>::validParams();
   params.set<bool>("fv") = true;
   params.set<MooseEnum>("family") = "MONOMIAL";
   params.set<MooseEnum>("order") = "CONSTANT";
   params.template addParam<bool>(
       "two_term_boundary_expansion",
       true,
       "Whether to use a two-term Taylor expansion to calculate boundary face values. "
       "If the two-term expansion is used, then the boundary face value depends on the "
       "adjoining cell center gradient, which itself depends on the boundary face value. "
       "Consequently an implicit solve is used to simultaneously solve for the adjoining cell "
       "center gradient and boundary face value(s).");
   MooseEnum face_interp_method("average skewness-corrected", "average");
   params.template addParam<MooseEnum>("face_interp_method",
                                       face_interp_method,
                                       "Switch that can select between face interpolation methods.");
   params.template addParam<bool>(
       "cache_cell_gradients", true, "Whether to cache cell gradients or re-compute them.");
 
   // Depending on the face interpolation we might have to do more than one layer ghosting.
   params.addRelationshipManager(
       "ElementSideNeighborLayers",
       Moose::RelationshipManagerType::GEOMETRIC | Moose::RelationshipManagerType::ALGEBRAIC |
           Moose::RelationshipManagerType::COUPLING,
       [](const InputParameters & obj_params, InputParameters & rm_params)
       {
         unsigned short layers = 1;
         if (obj_params.get<MooseEnum>("face_interp_method") == "skewness-corrected")
           layers = 2;
 
         rm_params.set<unsigned short>("layers") = layers;
       });
   return params;
 }

◆ vectorTagDofValue()

template<typename OutputType>

const DoFValue& MooseVariableFV< OutputType >::vectorTagDofValue ( TagID tag ) const

inlineoverridevirtual

Definition at line 209 of file MooseVariableFV.h.

   {
     return _element_data->vectorTagDofValue(tag);
   }

◆ vectorTagValue()

template<typename OutputType>

const FieldVariableValue& MooseVariableFV< OutputType >::vectorTagValue ( TagID tag ) const

inlineoverridevirtual

tag values getters