www.mooseframework.org: MooseVariableFE< OutputType

Definition at line 835 of file MooseVariableFE.h.

 {
   return _element_data->adDofValues();
 }

◆ adDofValuesNeighbor()

template<typename OutputType >

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

inlineoverridevirtual

Return the AD neignbor dof values.

Definition at line 842 of file MooseVariableFE.h.

 {
   return _neighbor_data->adDofValues();
 }

◆ addSolution()

template<typename OutputType >

void MooseVariableFE< OutputType >::addSolution ( const DenseVector< Number > & v )

Add passed in local DOF values onto the current solution.

Definition at line 228 of file MooseVariableFE.C.

Referenced by ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), ArrayKernel::computeResidual(), and ArrayIntegratedBC::computeResidual().

 {
   _element_data->addSolution(this->_sys.solution(), v);
 }

◆ addSolutionNeighbor()

template<typename OutputType >

void MooseVariableFE< OutputType >::addSolutionNeighbor ( const DenseVector< Number > & v )

Add passed in local neighbor DOF values onto the current solution.

Definition at line 235 of file MooseVariableFE.C.

 {
   _neighbor_data->addSolution(this->_sys.solution(), v);
 }

◆ adGradPhi()

template<typename OutputType>

const ADTemplateVariableTestGradient<OutputShape>& MooseVariableFE< OutputType >::adGradPhi ( ) const

inline

Definition at line 248 of file MooseVariableFE.h.

   {
     return _element_data->adGradPhi();
   }

◆ adGradPhiFace()

template<typename OutputType>

const ADTemplateVariableTestGradient<OutputShape>& MooseVariableFE< OutputType >::adGradPhiFace ( ) const

inline

Definition at line 253 of file MooseVariableFE.h.

   {
     return _element_data->adGradPhiFace();
   }

◆ adGradPhiFaceNeighbor()

template<typename OutputType>

const ADTemplateVariableTestGradient<OutputShape>& MooseVariableFE< OutputType >::adGradPhiFaceNeighbor ( ) const

inline

Definition at line 258 of file MooseVariableFE.h.

   {
     return _neighbor_data->adGradPhiFace();
   }

◆ adGradSln()

template<typename OutputType>

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

inlineoverridevirtual

AD grad solution getter.

Definition at line 342 of file MooseVariableFE.h.

   {
     return _element_data->adGradSln();
   }

◆ adGradSlnDot()

template<typename OutputType>

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

inlineoverridevirtual

AD grad of time derivative solution getter.

Definition at line 358 of file MooseVariableFE.h.

   {
     return _element_data->adGradSlnDot();
   }

◆ adGradSlnNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

AD grad neighbor solution getter.

Definition at line 368 of file MooseVariableFE.h.

   {
     return _neighbor_data->adGradSln();
   }

◆ adGradSlnNeighborDot()

template<typename OutputType>

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

inlineoverridevirtual

AD grad of time derivative neighbor solution getter.

Definition at line 384 of file MooseVariableFE.h.

   {
     return _neighbor_data->adGradSlnDot();
   }

◆ adNodalValue()

template<typename OutputType >

const Moose::ADType< OutputType >::type & MooseVariableFE< OutputType >::adNodalValue ( ) const

inline

Definition at line 849 of file MooseVariableFE.h.

 {
   return _element_data->adNodalValue();
 }

◆ adSecondSln()

template<typename OutputType>

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

inlineoverridevirtual

AD second solution getter.

Definition at line 346 of file MooseVariableFE.h.

   {
     return _element_data->adSecondSln();
   }

◆ adSecondSlnNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

AD second neighbor solution getter.

Definition at line 372 of file MooseVariableFE.h.

   {
     return _neighbor_data->adSecondSln();
   }

◆ adSln()

template<typename OutputType>

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

inlineoverridevirtual

AD.

Definition at line 337 of file MooseVariableFE.h.

   {
     return _element_data->adSln();
   }

◆ adSlnLower()

template<typename OutputType>

const ADTemplateVariableValue<OutputType>& MooseVariableFE< OutputType >::adSlnLower ( ) const

inline

lower-d element solution

Definition at line 492 of file MooseVariableFE.h.

492 { return _lower_data->adSln(); }

std::unique_ptr< MooseVariableData< OutputType > > _lower_data

Holder for all the data associated with the lower dimeensional element.

Definition: MooseVariableFE.h:723

◆ adSlnNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

neighbor AD

Definition at line 364 of file MooseVariableFE.h.

   {
     return _neighbor_data->adSln();
   }

◆ adUDot()

template<typename OutputType>

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

inlineoverridevirtual

AD time derivative getter.

Definition at line 350 of file MooseVariableFE.h.

   {
     return _element_data->adUDot();
   }

◆ adUDotDot()

template<typename OutputType>

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

inlineoverridevirtual

AD second time derivative getter.

Definition at line 354 of file MooseVariableFE.h.

   {
     return _element_data->adUDotDot();
   }

◆ adUDotDotNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

AD neighbor second time derivative getter.

Definition at line 380 of file MooseVariableFE.h.

   {
     return _neighbor_data->adUDotDot();
   }

◆ adUDotNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

AD neighbor time derivative getter.

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

Definition at line 376 of file MooseVariableFE.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 153 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.");
 }

◆ arrayGradPhi()

template<typename OutputType>

const MappedArrayVariablePhiGradient& MooseVariableFE< OutputType >::arrayGradPhi ( ) const

inline

Definition at line 195 of file MooseVariableFE.h.

   {
     return _element_data->arrayGradPhi();
   }

◆ arrayGradPhiFace()

template<typename OutputType>

const MappedArrayVariablePhiGradient& MooseVariableFE< OutputType >::arrayGradPhiFace ( ) const

inline

Definition at line 208 of file MooseVariableFE.h.

   {
     return _element_data->arrayGradPhiFace();
   }

◆ arrayGradPhiFaceNeighbor()

template<typename OutputType>

const MappedArrayVariablePhiGradient& MooseVariableFE< OutputType >::arrayGradPhiFaceNeighbor ( ) const

inline

Definition at line 237 of file MooseVariableFE.h.

   {
     return _neighbor_data->arrayGradPhiFace();
   }

◆ arrayGradPhiNeighbor()

template<typename OutputType>

const MappedArrayVariablePhiGradient& MooseVariableFE< OutputType >::arrayGradPhiNeighbor ( ) const

inline

Definition at line 221 of file MooseVariableFE.h.

   {
     return _neighbor_data->arrayGradPhi();
   }

◆ arrayScalingFactor()

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

inlineinherited

Definition at line 96 of file MooseVariableBase.h.

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

96 { return _scaling_factor; }

MooseVariableBase::_scaling_factor

std::vector< Real > _scaling_factor

scaling factor for this variable

Definition: MooseVariableBase.h:234

◆ 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 190 of file BlockRestrictable.C.

Referenced by FunctorMaterial::addFunctorProperty(), DiracKernelBase::addPoint(), DiracKernelBase::addPointWithValidId(), NodalPatchRecoveryAuxBase::blockRestrictElements(), MooseMesh::cacheFaceInfoVariableOwnership(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), BlockRestrictable::getBlockCoordSystem(), MaterialBase::getGenericZeroMaterialPropertyByName(), BlockRestrictable::hasBlockMaterialPropertyHelper(), SubdomainsDivision::initialize(), ElementCentroidPositions::initialize(), MooseVariableBase::MooseVariableBase(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), MaterialBase::registerPropName(), and FVPointValueConstraint::setMyElem().

 {
   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 178 of file BlockRestrictable.C.

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

 {
   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 184 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 360 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()

void MooseBase::callMooseError	(	std::string	msg,
		const bool	with_prefix
	)		const

inherited

Calls moose error with the message msg.

Will prefix the message with the subapp name if one exists.

If with_prefix, then add the prefix from errorPrefix() to the error.

Definition at line 33 of file MooseBase.C.

Referenced by InputParameters::callMooseErrorHelper(), MooseBaseErrorInterface::mooseDocumentedError(), MooseBaseErrorInterface::mooseError(), MooseBaseErrorInterface::mooseErrorNonPrefixed(), and MooseBaseParameterInterface::paramError().

 {
   _app.getOutputWarehouse().mooseConsole();
   const std::string prefix = _app.isUltimateMaster() ? "" : _app.name();
   if (with_prefix)
     msg = errorPrefix("error") + msg;
   moose::internal::mooseErrorRaw(msg, prefix);
 }

◆ checkFace()

FaceArg 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 723 of file MooseFunctor.h.

 {
   const Elem * const elem = face.face_side;
   const FaceInfo * const fi = face.fi;
   mooseAssert(fi, "face info should be non-null");
   auto ret_face = face;
   bool check_elem_def = false;
   bool check_neighbor_def = false;
   if (!elem)
   {
     if (!hasFaceSide(*fi, true))
     {
       ret_face.face_side = fi->neighborPtr();
       check_neighbor_def = true;
     }
     else if (!hasFaceSide(*fi, false))
     {
       ret_face.face_side = fi->elemPtr();
       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);
   }
 
   return ret_face;
 }

◆ 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 333 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 (variable.activeSubdomains().count(Moose::INTERNAL_SIDE_LOWERD_ID) > 0)
     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 MooseVariableFE< OutputType >::clearAllDofIndices ( )

finalvirtual

Reimplemented from MooseVariableBase.

Definition at line 852 of file MooseVariableFE.C.

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

◆ clearDofIndices()

template<typename OutputType >

void MooseVariableFE< 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 85 of file MooseVariableFE.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 171 of file MooseVariableBase.C.

Referenced by Assembly::addJacobianBlock(), Assembly::cacheJacobianBlock(), 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()

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("Component index must be less than the number of components of variable ",
                _var_name);
   if (isArray())
     return this->_subproblem.arrayVariableComponent(_var_name, comp);
   else
     return _var_name;
 }

◆ computeElemValues()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeElemValues ( )

overridevirtual

Actually compute variable values from the solution vectors.

Implements MooseVariableFieldBase.

Reimplemented in MooseVariableConstMonomial.

Definition at line 397 of file MooseVariableFE.C.

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

◆ computeElemValuesFace()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeElemValuesFace ( )

overridevirtual

Compute values at facial quadrature points.

Implements MooseVariableFieldBase.

Reimplemented in MooseVariableConstMonomial.

Definition at line 405 of file MooseVariableFE.C.

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

◆ computeFaceValues()

virtual void MooseVariableFieldBase::computeFaceValues ( const FaceInfo & )

inlinevirtualinherited

Compute values at face quadrature points for the element+neighbor (both sides of the face).

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

Definition at line 136 of file MooseVariableFieldBase.h.

136 { mooseError("not implemented"); }

MooseBaseErrorInterface::mooseError

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

Emits an error prefixed with object name and type.

Definition: MooseBaseErrorInterface.h:29

◆ computeIncrementAtNode()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeIncrementAtNode ( const NumericVector< Number > & increment_vec )

Compute and store incremental change at the current node based on increment_vec.

Definition at line 444 of file MooseVariableFE.C.

 {
   _element_data->computeIncrementAtNode(increment_vec);
 }

◆ computeIncrementAtQps()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeIncrementAtQps ( const NumericVector< Number > & increment_vec )

Compute and store incremental change in solution at QPs based on increment_vec.

Definition at line 437 of file MooseVariableFE.C.

 {
   _element_data->computeIncrementAtQps(increment_vec);
 }

◆ computeLowerDValues()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeLowerDValues ( )

overridevirtual

compute values at quadrature points on the lower dimensional element

Implements MooseVariableFieldBase.

Definition at line 429 of file MooseVariableFE.C.

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

◆ computeNeighborValues()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeNeighborValues ( )

overridevirtual

Compute values at quadrature points for the neighbor.

Implements MooseVariableFieldBase.

Reimplemented in MooseVariableConstMonomial.

Definition at line 421 of file MooseVariableFE.C.

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

◆ computeNeighborValuesFace()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeNeighborValuesFace ( )

overridevirtual

Compute values at facial quadrature points for the neighbor.

Implements MooseVariableFieldBase.

Reimplemented in MooseVariableConstMonomial.

Definition at line 413 of file MooseVariableFE.C.

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

◆ computeNodalNeighborValues()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeNodalNeighborValues ( )

overridevirtual

Compute nodal values of this variable in the neighbor.

Implements MooseVariableFieldBase.

Definition at line 672 of file MooseVariableFE.C.

 {
   _neighbor_data->computeNodalValues();
 }

◆ computeNodalValues()

template<typename OutputType >

void MooseVariableFE< OutputType >::computeNodalValues ( )

overridevirtual

Compute nodal values of this variable.

Implements MooseVariableFieldBase.

Definition at line 665 of file MooseVariableFE.C.

 {
   _element_data->computeNodalValues();
 }

◆ computeSolution()

template<typename OutputType >

template<typename Shapes , typename Solution , typename GradShapes , typename GradSolution >

void MooseVariableFE< OutputType >::computeSolution	(	const Elem *	elem,
		unsigned int	n_qp,
		const StateArg &	state,
		const Shapes &	phi,
		Solution &	local_soln,
		const GradShapes &	grad_phi,
		GradSolution &	grad_local_soln,
		Solution &	dot_local_soln,
		GradSolution &	grad_dot_local_soln
	)		const

private

Compute the solution, gradient, time derivative, and gradient of the time derivative with provided shape functions.

Definition at line 914 of file MooseVariableFE.C.

 {
   std::vector<dof_id_type> dof_indices;
   this->_dof_map.dof_indices(elem, dof_indices, _var_num);
   std::vector<ADReal> dof_values;
   std::vector<ADReal> dof_values_dot;
   dof_values.reserve(dof_indices.size());
 
   const bool computing_dot = _time_integrator && _time_integrator->dt();
   if (computing_dot)
     dof_values_dot.reserve(dof_indices.size());
 
   const bool do_derivatives = Moose::doDerivatives(_subproblem, _sys);
   const auto & global_soln = getSolution(state);
   for (const auto dof_index : dof_indices)
   {
     dof_values.push_back(ADReal(global_soln(dof_index)));
     if (do_derivatives && state.state == 0)
       Moose::derivInsert(dof_values.back().derivatives(), dof_index, 1.);
     if (computing_dot)
     {
       if (_var_kind == Moose::VAR_SOLVER)
       {
         dof_values_dot.push_back(dof_values.back());
         _time_integrator->computeADTimeDerivatives(
             dof_values_dot.back(), dof_index, _ad_real_dummy);
       }
       else
         dof_values_dot.push_back((*this->_sys.solutionUDot())(dof_index));
     }
   }
 
   local_soln.resize(n_qp);
   grad_local_soln.resize(n_qp);
   if (computing_dot)
   {
     dot_local_soln.resize(n_qp);
     grad_dot_local_soln.resize(n_qp);
   }
 
   for (const auto qp : make_range(n_qp))
   {
     local_soln[qp] = 0;
     grad_local_soln[qp] = 0;
     if (computing_dot)
     {
       dot_local_soln[qp] = 0;
       grad_dot_local_soln[qp] = GradientType{};
     }
     for (const auto i : index_range(dof_indices))
     {
       local_soln[qp] += dof_values[i] * phi[i][qp];
       grad_local_soln[qp] += dof_values[i] * grad_phi[i][qp];
       if (computing_dot)
       {
         dot_local_soln[qp] += dof_values_dot[i] * phi[i][qp];
         grad_dot_local_soln[qp] += dof_values_dot[i] * grad_phi[i][qp];
       }
     }
   }
 }

◆ computingCurl()

template<typename OutputType >

bool MooseVariableFE< OutputType >::computingCurl ( ) const

finaloverridevirtual

Whether or not this variable is computing the curl.

Definition at line 813 of file MooseVariableFE.C.

 {
   return _element_data->computingCurl();
 }

◆ computingDiv()

template<typename OutputType >

bool MooseVariableFE< OutputType >::computingDiv ( ) const

finaloverridevirtual

Whether or not this variable is computing the divergence.

Definition at line 820 of file MooseVariableFE.C.

 {
   return _element_data->computingDiv();
 }

◆ computingSecond()

template<typename OutputType>

bool MooseVariableFE< OutputType >::computingSecond ( ) const

inlinefinaloverridevirtual

Whether or not this variable is computing any second derivatives.

MooseVariableFE::usesSecondPhi

Definition at line 135 of file MooseVariableFE.h.

135 { return usesSecondPhi(); }

bool usesSecondPhi() const

Whether or not this variable is computing any second derivatives.

Definition: MooseVariableFE.C:799

◆ connectControllableParams()

void MooseBaseParameterInterface::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 33 of file MooseBaseParameterInterface.C.

 {
   MooseObjectParameterName primary_name(uniqueName(), parameter);
   const auto base_type = _factory.getValidParams(object_type).get<std::string>("_moose_base");
   MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
   _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
       primary_name, secondary_name);
 
   const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
   for (const auto & tag : tags)
   {
     if (!tag.empty())
     {
       MooseObjectParameterName tagged_name(tag, _moose_base.name(), parameter);
       _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
           tagged_name, secondary_name);
     }
   }
 }

◆ 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 108 of file MooseVariableBase.h.

Referenced by Assembly::addJacobianBlock(), EigenProblem::adjustEigenVector(), ArrayBodyForce::ArrayBodyForce(), ArrayConstantIC::ArrayConstantIC(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayFunctionIC::ArrayFunctionIC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), BuildArrayVariableAux::BuildArrayVariableAux(), Assembly::cacheJacobianBlock(), 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().

108 { return _count; }

MooseVariableBase::_count

const unsigned int _count

Number of variables in the array.

Definition: MooseVariableBase.h:231

◆ curlPhi()

template<typename OutputType >

const MooseVariableFE< OutputType >::FieldVariablePhiCurl & MooseVariableFE< OutputType >::curlPhi ( ) const

finaloverridevirtual

Curl of the shape functions.

Definition at line 722 of file MooseVariableFE.C.

 {
   return _element_data->curlPhi();
 }

◆ curlPhiFace()

template<typename OutputType >

const MooseVariableFE< OutputType >::FieldVariablePhiCurl & MooseVariableFE< OutputType >::curlPhiFace ( ) const

Definition at line 743 of file MooseVariableFE.C.

 {
   return _element_data->curlPhiFace();
 }

◆ curlPhiFaceNeighbor()

template<typename OutputType >

const MooseVariableFE< OutputType >::FieldVariablePhiCurl & MooseVariableFE< OutputType >::curlPhiFaceNeighbor ( ) const

Definition at line 785 of file MooseVariableFE.C.

 {
   return _neighbor_data->curlPhiFace();
 }

◆ curlPhiNeighbor()

template<typename OutputType >

const MooseVariableFE< OutputType >::FieldVariablePhiCurl & MooseVariableFE< OutputType >::curlPhiNeighbor ( ) const

Definition at line 764 of file MooseVariableFE.C.

 {
   return _neighbor_data->curlPhi();
 }

◆ curlSln()

template<typename OutputType>

const FieldVariableCurl& MooseVariableFE< OutputType >::curlSln ( ) const

inline

element curls

Definition at line 324 of file MooseVariableFE.h.

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

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

Definition: MooseTypes.h:223

◆ curlSlnNeighbor()

template<typename OutputType>

const FieldVariableCurl& MooseVariableFE< OutputType >::curlSlnNeighbor ( ) const

inline

neighbor solution curls

Definition at line 456 of file MooseVariableFE.h.

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

◆ curlSlnOld()

template<typename OutputType>

const FieldVariableCurl& MooseVariableFE< OutputType >::curlSlnOld ( ) const

inline

Definition at line 325 of file MooseVariableFE.h.

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

Definition: MooseTypes.h:224

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ curlSlnOlder()

template<typename OutputType>

const FieldVariableCurl& MooseVariableFE< OutputType >::curlSlnOlder ( ) const

inline

Definition at line 326 of file MooseVariableFE.h.

326 { return _element_data->curlSln(Moose::Older); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

Moose::Older

Definition: MooseTypes.h:225

◆ curlSlnOlderNeighbor()

template<typename OutputType>

const FieldVariableCurl& MooseVariableFE< OutputType >::curlSlnOlderNeighbor ( ) const

inline

Definition at line 464 of file MooseVariableFE.h.

   {
     return _neighbor_data->curlSln(Moose::Older);
   }

◆ curlSlnOldNeighbor()

template<typename OutputType>

const FieldVariableCurl& MooseVariableFE< OutputType >::curlSlnOldNeighbor ( ) const

inline

Definition at line 460 of file MooseVariableFE.h.

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

◆ currentElem()

template<typename OutputType>

const Elem* const& MooseVariableFE< OutputType >::currentElem ( ) const

inlineoverridevirtual

Current element this variable is evaluated at.

Implements MooseVariableFieldBase.

Definition at line 161 of file MooseVariableFE.h.

161 { return _element_data->currentElem(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ currentSide()

template<typename OutputType>

const unsigned int& MooseVariableFE< OutputType >::currentSide ( ) const

inline

Current side this variable is being evaluated on.

Definition at line 166 of file MooseVariableFE.h.

166 { return _element_data->currentSide(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ 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 832 of file MooseFunctor.h.

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

◆ divPhi()

template<typename OutputType >

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

finaloverridevirtual

Divergence of the shape functions.

Definition at line 729 of file MooseVariableFE.C.

 {
   return _element_data->divPhi();
 }

◆ divPhiFace()

template<typename OutputType >

const MooseVariableFE< OutputType >::FieldVariablePhiDivergence & MooseVariableFE< OutputType >::divPhiFace ( ) const

Definition at line 750 of file MooseVariableFE.C.

 {
   return _element_data->divPhiFace();
 }

◆ divPhiFaceNeighbor()

template<typename OutputType >

const MooseVariableFE< OutputType >::FieldVariablePhiDivergence & MooseVariableFE< OutputType >::divPhiFaceNeighbor ( ) const

Definition at line 792 of file MooseVariableFE.C.

 {
   return _neighbor_data->divPhiFace();
 }

◆ divPhiNeighbor()

template<typename OutputType >

const MooseVariableFE< OutputType >::FieldVariablePhiDivergence & MooseVariableFE< OutputType >::divPhiNeighbor ( ) const

Definition at line 771 of file MooseVariableFE.C.

 {
   return _neighbor_data->divPhi();
 }

◆ divSln()

template<typename OutputType>

const FieldVariableDivergence& MooseVariableFE< OutputType >::divSln ( ) const

inline

element divergence

Definition at line 329 of file MooseVariableFE.h.

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

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

Definition: MooseTypes.h:223

◆ divSlnNeighbor()

template<typename OutputType>

const FieldVariableDivergence& MooseVariableFE< OutputType >::divSlnNeighbor ( ) const

inline

neighbor solution divergence

Definition at line 470 of file MooseVariableFE.h.

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

◆ divSlnOld()

template<typename OutputType>

const FieldVariableDivergence& MooseVariableFE< OutputType >::divSlnOld ( ) const

inline

Definition at line 330 of file MooseVariableFE.h.

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

Definition: MooseTypes.h:224

Referenced by ADDGKernel::computeElemNeighJacobian(), VectorNodalBC::computeJacobian(), NonlocalIntegratedBC::computeJacobian(), NonlocalKernel::computeJacobian(), NodalConstraint::computeJacobian(), NonlocalKernel::computeNonlocalJacobian(), NonlocalIntegratedBC::computeNonlocalJacobian(), ADDGKernel::computeOffDiagElemNeighJacobian(), VectorNodalBC::computeOffDiagJacobian(), KernelScalarBase::computeOffDiagJacobianScalarLocal(), VectorNodalBC::computeResidual(), NodalConstraint::computeResidual(), and ADKernelTempl< T >::dofIndices().

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ divSlnOlder()

template<typename OutputType>

const FieldVariableDivergence& MooseVariableFE< OutputType >::divSlnOlder ( ) const

inline

Definition at line 331 of file MooseVariableFE.h.

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

◆ divSlnOlderNeighbor()

template<typename OutputType>

const FieldVariableDivergence& MooseVariableFE< OutputType >::divSlnOlderNeighbor ( ) const

inline

Definition at line 478 of file MooseVariableFE.h.

   {
     return _neighbor_data->divSln(Moose::Older);
   }

◆ divSlnOldNeighbor()

template<typename OutputType>

const FieldVariableDivergence& MooseVariableFE< OutputType >::divSlnOldNeighbor ( ) const

inline

Definition at line 474 of file MooseVariableFE.h.

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

◆ doDerivatives()

bool MooseVariableBase::doDerivatives ( ) const

protectedinherited

Returns: whether we should insert derivatives

◆ dofIndices()

template<typename OutputType>

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

inlinefinalvirtual

Get local DoF indices.

Reimplemented from MooseVariableBase.

Definition at line 175 of file MooseVariableFE.h.

175 { return _element_data->dofIndices(); }

MooseVariableBase::_dof_map

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ dofIndicesLower()

template<typename OutputType>

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

inlinefinalvirtual

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 181 of file MooseVariableFE.h.

Referenced by ADMortarConstraint::computeJacobian(), MortarConstraint::computeJacobian(), and MortarScalarBase::computeOffDiagJacobianScalar().

   {
     return _lower_data->dofIndices();
   }

◆ dofIndicesNeighbor()

template<typename OutputType>

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

inlinefinalvirtual

Get neighbor DOF indices for currently selected element.

Returns: the neighbor degree of freedom indices

Implements MooseVariableFieldBase.

Definition at line 177 of file MooseVariableFE.h.

Referenced by ADDGKernel::computeElemNeighJacobian(), NodalConstraint::computeJacobian(), ADDGKernel::computeOffDiagElemNeighJacobian(), and NodalConstraint::computeResidual().

   {
     return _neighbor_data->dofIndices();
   }

◆ dofMap()

const DofMap& MooseVariableBase::dofMap ( ) const

inlineinherited

The DofMap associated with the system this variable is in.

Definition at line 130 of file MooseVariableBase.h.

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

130 { return _dof_map; }

const DofMap & _dof_map

DOF map.

Definition: MooseVariableBase.h:219

◆ dofValue()

template<typename OutputType >

const MooseVariableFE< OutputType >::DoFValue & MooseVariableFE< OutputType >::dofValue ( ) const

Definition at line 242 of file MooseVariableFE.C.

 {
   mooseDeprecated("Use dofValues instead of dofValue");
   return dofValues();
 }

◆ dofValues()

template<typename OutputType >

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

overridevirtual

dof values getters

Definition at line 250 of file MooseVariableFE.C.

Referenced by InternalSideIndicator::finalize().

 {
   return _element_data->dofValues();
 }

◆ dofValuesDot()

template<typename OutputType >

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

overridevirtual

Definition at line 306 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesDot();
 }

◆ dofValuesDotDot()

template<typename OutputType >

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

overridevirtual

Definition at line 313 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesDotDot();
 }

◆ dofValuesDotDotNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 341 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValuesDotDot();
 }

◆ dofValuesDotDotNeighborResidual()

template<typename OutputType>

const DoFValue& MooseVariableFE< OutputType >::dofValuesDotDotNeighborResidual ( ) const

◆ dofValuesDotDotOld()

template<typename OutputType >

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

overridevirtual

Definition at line 327 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesDotDotOld();
 }

◆ dofValuesDotDotOldNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 355 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValuesDotDotOld();
 }

◆ dofValuesDotNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 334 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValuesDot();
 }

◆ dofValuesDotNeighborResidual()

template<typename OutputType>

const DoFValue& MooseVariableFE< OutputType >::dofValuesDotNeighborResidual ( ) const

◆ dofValuesDotOld()

template<typename OutputType >

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

overridevirtual

Definition at line 320 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesDotOld();
 }

◆ dofValuesDotOldNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 348 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValuesDotOld();
 }

◆ dofValuesDuDotDotDu()

template<typename OutputType >

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

overridevirtual

Definition at line 369 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesDuDotDotDu();
 }

◆ dofValuesDuDotDotDuNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 383 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValuesDuDotDotDu();
 }

◆ dofValuesDuDotDu()

template<typename OutputType >

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

overridevirtual

Definition at line 362 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesDuDotDu();
 }

◆ dofValuesDuDotDuNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 376 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValuesDuDotDu();
 }

◆ dofValuesNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 278 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValues();
 }

◆ dofValuesOld()

template<typename OutputType >

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

overridevirtual

Definition at line 257 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesOld();
 }

◆ dofValuesOlder()

template<typename OutputType >

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

overridevirtual

Definition at line 264 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesOlder();
 }

◆ dofValuesOlderNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 292 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValuesOlder();
 }

◆ dofValuesOldNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 285 of file MooseVariableFE.C.

 {
   return _neighbor_data->dofValuesOld();
 }

◆ dofValuesPreviousNL()

template<typename OutputType >

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

overridevirtual

Definition at line 271 of file MooseVariableFE.C.

 {
   return _element_data->dofValuesPreviousNL();
 }

◆ dofValuesPreviousNLNeighbor()

template<typename OutputType >

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

overridevirtual

Definition at line 299 of file MooseVariableFE.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 882 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 889 of file MooseFunctor.h.

 {
   return evaluateDot(checkFace(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 896 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 903 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 910 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 917 of file MooseFunctor.h.

 {
   return evaluateDot(node, state);
 }

◆ duDotDotDu()

template<typename OutputType>

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

inline

Definition at line 395 of file MooseVariableFE.h.

395 { return _element_data->duDotDotDu(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ duDotDotDuNeighbor()

template<typename OutputType>

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

inline

Definition at line 489 of file MooseVariableFE.h.

489 { return _neighbor_data->duDotDotDu(); }

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ duDotDu()

template<typename OutputType>

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

inline

Definition at line 394 of file MooseVariableFE.h.

394 { return _element_data->duDotDu(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ duDotDuNeighbor()

template<typename OutputType>

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

inline

Definition at line 488 of file MooseVariableFE.h.

488 { return _neighbor_data->duDotDu(); }

MooseVariableBase::_is_eigen

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ eigen() [1/2]

bool MooseVariableBase::eigen ( ) const

inlineinherited

Whether or not this variable operates on an eigen kernel.

Definition at line 157 of file MooseVariableBase.h.

Referenced by EigenProblem::adjustEigenVector().

157 { return _is_eigen; }

bool _is_eigen

Whether or not this variable operates on eigen kernels.

Definition: MooseVariableBase.h:204

◆ eigen() [2/2]

void MooseVariableBase::eigen ( bool eigen )

inlineinherited

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

Definition at line 162 of file MooseVariableBase.h.

Referenced by MooseVariableBase::eigen().

162 { _is_eigen = eigen; }

MooseVariableBase::eigen

bool eigen() const

Whether or not this variable operates on an eigen kernel.

Definition: MooseVariableBase.h:157

MooseVariableBase::_is_eigen

bool _is_eigen

Whether or not this variable operates on eigen kernels.

Definition: MooseVariableBase.h:204

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 50 of file MooseObject.h.

Referenced by EigenKernel::enabled().

50 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition: MooseObject.h:61

◆ errorPrefix()

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

inherited

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

Definition at line 43 of file MooseBase.C.

Referenced by MooseBase::callMooseError(), MooseBaseErrorInterface::mooseWarning(), and MooseBaseParameterInterface::paramErrorMsg().

 {
   std::stringstream oss;
   if (const auto node = _params.getHitNode())
     if (!node->isRoot())
       oss << node->fileLocation() << ":\n";
   oss << "The following " << error_type << " occurred in the ";
   if (const auto base_ptr = _params.getBase())
     oss << *base_ptr;
   else
     oss << "object";
   oss << " '" << name() << "' of type " << type() << ".\n\n";
   return oss.str();
 }

◆ evaluate() [1/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 1036 of file MooseVariableFE.C.

 {
   evaluateOnElement(elem_qp, state, /*query_cache=*/true);
   const auto qp = elem_qp.qp;
   mooseAssert(qp < _current_elem_qp_functor_sln.size(),
               "The requested " << qp << " is outside our solution size");
   return _current_elem_qp_functor_sln[qp];
 }

◆ evaluate() [2/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 1241 of file MooseVariableFE.C.

 {
   evaluateOnElementSide(elem_side_qp, state, true);
   const auto qp = elem_side_qp.qp;
   mooseAssert(qp < _current_elem_side_qp_functor_sln.size(),
               "The requested " << qp << " is outside our solution size");
   return _current_elem_side_qp_functor_sln[qp];
 }

◆ evaluate() [3/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 1047 of file MooseVariableFE.C.

 {
   const QMonomial qrule(elem_arg.elem->dim(), CONSTANT);
   // We can use whatever we want for the point argument since it won't be used
   const ElemQpArg elem_qp_arg{elem_arg.elem, /*qp=*/0, &qrule, Point(0, 0, 0)};
   evaluateOnElement(elem_qp_arg, state, /*cache_eligible=*/false);
   return _current_elem_qp_functor_sln[0];
 }

◆ evaluate() [4/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 1104 of file MooseVariableFE.C.

 {
   mooseAssert(elem_point_arg.elem, "We need an Elem");
   const Elem & elem = *elem_point_arg.elem;
   const auto dim = elem.dim();
   ArbitraryQuadrature qrule(dim);
   const std::vector<Point> ref_point = {FEMap::inverse_map(dim, &elem, elem_point_arg.point)};
   qrule.setPoints(ref_point);
   // We can use whatever we want for the point argument since it won't be used
   const ElemQpArg elem_qp_arg{elem_point_arg.elem, /*qp=*/0, &qrule, elem_point_arg.point};
   evaluateOnElement(elem_qp_arg, state, /*cache_eligible=*/false);
   return _current_elem_qp_functor_sln[0];
 }

◆ evaluate() [5/6]

template<typename OutputType >

MooseVariableFE< OutputType >::ValueType MooseVariableFE< OutputType >::evaluate	(	const NodeArg &	node_arg,
		const StateArg &	state
	)		const

finaloverrideprotectedvirtual

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

Definition at line 861 of file MooseVariableFE.C.

 {
   mooseAssert(node_arg.node, "Must have a node");
   mooseAssert(this->hasBlocks(node_arg.subdomain_id),
               "Our variable should be defined on the requested subdomain ID");
   const Node & node = *node_arg.node;
   mooseAssert(node.n_dofs(this->_sys.number(), this->number()),
               "Our variable must have dofs on the requested node");
   const auto & soln = this->getSolution(state);
   if constexpr (std::is_same<OutputType, Real>::value)
   {
     const auto dof_number = node.dof_number(this->_sys.number(), this->number(), 0);
     ValueType ret = soln(dof_number);
     if (Moose::doDerivatives(_subproblem, _sys))
       Moose::derivInsert(ret.derivatives(), dof_number, 1);
     return ret;
   }
   else if constexpr (std::is_same<OutputType, RealVectorValue>::value)
   {
     ValueType ret;
     const auto do_derivatives = Moose::doDerivatives(_subproblem, _sys);
     for (const auto d : make_range(this->_mesh.dimension()))
     {
       const auto dof_number = node.dof_number(this->_sys.number(), this->number(), d);
       auto & component = ret(d);
       component = soln(dof_number);
       if (do_derivatives)
         Moose::derivInsert(component.derivatives(), dof_number, 1);
     }
     return ret;
   }
   else
     mooseError("RealEigenVector not yet supported for functors");
 }

◆ evaluate() [6/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 1097 of file MooseVariableFE.C.

 {
   return faceEvaluate(face_arg, state, _current_elem_side_qp_functor_sln);
 }

◆ evaluateDot() [1/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 423 of file MooseFunctor.h.

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

◆ evaluateDot() [2/6]

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

inlineprotectedvirtualinherited

Definition at line 428 of file MooseFunctor.h.

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

◆ evaluateDot() [3/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 >.

Definition at line 1145 of file MooseVariableFE.C.

 {
   mooseAssert(_time_integrator && _time_integrator->dt(),
               "A time derivative is being requested but we do not have a time integrator so we'll "
               "have no idea how to compute it");
   evaluateOnElement(elem_qp, state, /*query_cache=*/true);
   const auto qp = elem_qp.qp;
   mooseAssert(qp < _current_elem_qp_functor_dot.size(),
               "The requested " << qp << " is outside our dot size");
   return _current_elem_qp_functor_dot[qp];
 }

◆ evaluateDot() [4/6]

template<typename OutputType >

MooseVariableFE< OutputType >::DotType MooseVariableFE< OutputType >::evaluateDot	(	const ElemSideQpArg &	,
		const StateArg &
	)		const

finaloverrideprotectedvirtual

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

Definition at line 1265 of file MooseVariableFE.C.

 {
   mooseAssert(_time_integrator && _time_integrator->dt(),
               "A time derivative is being requested but we do not have a time integrator so we'll "
               "have no idea how to compute it");
   evaluateOnElementSide(elem_side_qp, state, true);
   const auto qp = elem_side_qp.qp;
   mooseAssert(qp < _current_elem_side_qp_functor_dot.size(),
               "The requested " << qp << " is outside our dot size");
   return _current_elem_side_qp_functor_dot[qp];
 }

◆ evaluateDot() [5/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 1159 of file MooseVariableFE.C.

 {
   mooseAssert(_time_integrator && _time_integrator->dt(),
               "A time derivative is being requested but we do not have a time integrator so we'll "
               "have no idea how to compute it");
   const QMonomial qrule(elem_arg.elem->dim(), CONSTANT);
   // We can use whatever we want for the point argument since it won't be used
   const ElemQpArg elem_qp_arg{elem_arg.elem, /*qp=*/0, &qrule, Point(0, 0, 0)};
   evaluateOnElement(elem_qp_arg, state, /*cache_eligible=*/false);
   return _current_elem_qp_functor_dot[0];
 }

◆ evaluateDot() [6/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 >.

Definition at line 1280 of file MooseVariableFE.C.

 {
   mooseAssert(_time_integrator && _time_integrator->dt(),
               "A time derivative is being requested but we do not have a time integrator so we'll "
               "have no idea how to compute it");
   return faceEvaluate(face_arg, state, _current_elem_side_qp_functor_dot);
 }

◆ evaluateGradDot() [1/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 447 of file MooseFunctor.h.

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

◆ evaluateGradDot() [2/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 457 of file MooseFunctor.h.

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

◆ evaluateGradDot() [3/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 468 of file MooseFunctor.h.

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

◆ evaluateGradDot() [4/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 477 of file MooseFunctor.h.

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

◆ evaluateGradDot() [5/6]

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

inlineprotectedvirtualinherited

Definition at line 482 of file MooseFunctor.h.

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

◆ evaluateGradDot() [6/6]

template<typename OutputType >

MooseVariableFE< OutputType >::GradientType MooseVariableFE< OutputType >::evaluateGradDot	(	const ElemArg &	,
		const StateArg &
	)		const

finaloverrideprotectedvirtual

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

Definition at line 1173 of file MooseVariableFE.C.

 {
   mooseAssert(_time_integrator && _time_integrator->dt(),
               "A time derivative is being requested but we do not have a time integrator so we'll "
               "have no idea how to compute it");
   const QMonomial qrule(elem_arg.elem->dim(), CONSTANT);
   // We can use whatever we want for the point argument since it won't be used
   const ElemQpArg elem_qp_arg{elem_arg.elem, /*qp=*/0, &qrule, Point(0, 0, 0)};
   evaluateOnElement(elem_qp_arg, state, /*cache_eligible=*/false);
   return _current_elem_qp_functor_grad_dot[0];
 }

◆ evaluateGradient() [1/6]

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

inlineprotectedvirtualinherited

Parameters

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

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

Reimplemented in MooseVariableFV< OutputType >, and MooseLinearVariableFV< OutputType >.

Definition at line 340 of file MooseFunctor.h.

   {
     mooseError("Face 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 369 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 374 of file MooseFunctor.h.

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

◆ evaluateGradient() [4/6]

template<typename OutputType >

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

overrideprotectedvirtual

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 1121 of file MooseVariableFE.C.

 {
   evaluateOnElement(elem_qp, state, /*query_cache=*/true);
   const auto qp = elem_qp.qp;
   mooseAssert(qp < _current_elem_qp_functor_gradient.size(),
               "The requested " << qp << " is outside our gradient size");
   return _current_elem_qp_functor_gradient[qp];
 }

◆ evaluateGradient() [5/6]

template<typename OutputType >

MooseVariableFE< OutputType >::GradientType MooseVariableFE< OutputType >::evaluateGradient	(	const ElemSideQpArg &	,
		const StateArg &
	)		const

finaloverrideprotectedvirtual

Parameters

side_qp	See the `ElemSideQpArg` 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 1253 of file MooseVariableFE.C.

 {
   evaluateOnElementSide(elem_side_qp, state, true);
   const auto qp = elem_side_qp.qp;
   mooseAssert(qp < _current_elem_side_qp_functor_gradient.size(),
               "The requested " << qp << " is outside our gradient size");
   return _current_elem_side_qp_functor_gradient[qp];
 }

◆ evaluateGradient() [6/6]

template<typename OutputType >

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

finaloverrideprotectedvirtual

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 1133 of file MooseVariableFE.C.

 {
   const QMonomial qrule(elem_arg.elem->dim(), CONSTANT);
   // We can use whatever we want for the point argument since it won't be used
   const ElemQpArg elem_qp_arg{elem_arg.elem, /*qp=*/0, &qrule, Point(0, 0, 0)};
   evaluateOnElement(elem_qp_arg, state, /*cache_eligible=*/false);
   return _current_elem_qp_functor_gradient[0];
 }

◆ evaluateOnElement()

template<typename OutputType >

void MooseVariableFE< OutputType >::evaluateOnElement	(	const ElemQpArg &	elem_qp,
		const StateArg &	state,
		bool	cache_eligible
	)		const

private

Evaluate solution and gradient for the elem_qp argument.

Definition at line 986 of file MooseVariableFE.C.

 {
   mooseAssert(this->hasBlocks(elem_qp.elem->subdomain_id()),
               "Variable " + this->name() + " doesn't exist on block " +
                   std::to_string(elem_qp.elem->subdomain_id()));
 
   const Elem * const elem = elem_qp.elem;
   if (!cache_eligible || (elem != _current_elem_qp_functor_elem))
   {
     const QBase * const qrule_template = elem_qp.qrule;
 
     using FEBaseType = typename FEBaseHelper<OutputType>::type;
     std::unique_ptr<FEBaseType> fe(FEBaseType::build(elem->dim(), _fe_type));
     auto qrule = qrule_template->clone();
 
     const auto & phi = fe->get_phi();
     const auto & dphi = fe->get_dphi();
     fe->attach_quadrature_rule(qrule.get());
     fe->reinit(elem);
 
     computeSolution(elem,
                     qrule->n_points(),
                     state,
                     phi,
                     _current_elem_qp_functor_sln,
                     dphi,
                     _current_elem_qp_functor_gradient,
                     _current_elem_qp_functor_dot,
                     _current_elem_qp_functor_grad_dot);
   }
   if (cache_eligible)
     _current_elem_qp_functor_elem = elem;
   else
     // These evaluations are not eligible for caching, e.g. maybe this is a single point quadrature
     // rule evaluation at an arbitrary point and we don't want those evaluations to potentially be
     // re-used when this function is called with a standard quadrature rule or a different point
     _current_elem_qp_functor_elem = nullptr;
 }

◆ evaluateOnElementSide()

template<typename OutputType >

void MooseVariableFE< OutputType >::evaluateOnElementSide	(	const ElemSideQpArg &	elem_side_qp,
		const StateArg &	state,
		bool	cache_eligible
	)		const

private

Evaluate solution and gradient for the elem_side_qp argument.

Definition at line 1187 of file MooseVariableFE.C.

 {
   mooseAssert(this->hasBlocks(elem_side_qp.elem->subdomain_id()),
               "Variable " + this->name() + " doesn't exist on block " +
                   std::to_string(elem_side_qp.elem->subdomain_id()));
 
   const Elem * const elem = elem_side_qp.elem;
   const auto side = elem_side_qp.side;
   if (!cache_eligible || elem != _current_elem_side_qp_functor_elem_side.first ||
       side != _current_elem_side_qp_functor_elem_side.second)
   {
     const QBase * const qrule_template = elem_side_qp.qrule;
 
     using FEBaseType = typename FEBaseHelper<OutputType>::type;
     std::unique_ptr<FEBaseType> fe(FEBaseType::build(elem->dim(), _fe_type));
     auto qrule = qrule_template->clone();
 
     const auto & phi = fe->get_phi();
     const auto & dphi = fe->get_dphi();
     fe->attach_quadrature_rule(qrule.get());
     fe->reinit(elem, side);
 
     computeSolution(elem,
                     qrule->n_points(),
                     state,
                     phi,
                     _current_elem_side_qp_functor_sln,
                     dphi,
                     _current_elem_side_qp_functor_gradient,
                     _current_elem_side_qp_functor_dot,
                     _current_elem_side_qp_functor_grad_dot);
   }
   if (cache_eligible)
     _current_elem_side_qp_functor_elem_side = std::make_pair(elem, side);
   else
     // These evaluations are not eligible for caching, e.g. maybe this is a single point quadrature
     // rule evaluation at an arbitrary point and we don't want those evaluations to potentially be
     // re-used when this function is called with a standard quadrature rule or a different point
     _current_elem_side_qp_functor_elem_side = std::make_pair(nullptr, libMesh::invalid_uint);
 }

◆ faceEvaluate()

template<typename OutputType >

MooseVariableFE< OutputType >::ValueType MooseVariableFE< OutputType >::faceEvaluate	(	const FaceArg &	face_arg,
		const StateArg &	state,
		const std::vector< ValueType > &	cache_data
	)		const

protected

A common method that both evaluate(FaceArg) and evaluateDot(FaceArg) can call.

A value evaluation vs dot evaluation is delineated via the passed-in cache_data, e.g. if the passed-in cache data is the sln data member then this will return a value evaluation and if the cache data is the dot data member then this will return a dot evaluation

Definition at line 1058 of file MooseVariableFE.C.

 {
   const QMonomial qrule(face_arg.fi->elem().dim() - 1, CONSTANT);
   auto side_evaluate =
       [this, &qrule, &state, &cache_data](const Elem * const elem, const unsigned int side)
   {
     // We can use whatever we want for the point argument since it won't be used
     const ElemSideQpArg elem_side_qp_arg{elem, side, /*qp=*/0, &qrule, Point(0, 0, 0)};
     evaluateOnElementSide(elem_side_qp_arg, state, /*cache_eligible=*/false);
     return cache_data[0];
   };
 
   const auto continuity = this->getContinuity();
   const bool on_elem = !face_arg.face_side || (face_arg.face_side == face_arg.fi->elemPtr());
   const bool on_neighbor =
       !face_arg.face_side || (face_arg.face_side == face_arg.fi->neighborPtr());
   if (on_neighbor)
     mooseAssert(
         face_arg.fi->neighborPtr(),
         "If we are signaling we should evaluate on the neighbor, we better have a neighbor");
 
   // Only do multiple evaluations if we are not continuous and we are on an internal face
   if ((continuity != C_ZERO && continuity != C_ONE) && on_elem && on_neighbor)
     return (side_evaluate(face_arg.fi->elemPtr(), face_arg.fi->elemSideID()) +
             side_evaluate(face_arg.fi->neighborPtr(), face_arg.fi->neighborSideID())) /
            2;
   else if (on_elem)
     return side_evaluate(face_arg.fi->elemPtr(), face_arg.fi->elemSideID());
   else if (on_neighbor)
     return side_evaluate(face_arg.fi->neighborPtr(), face_arg.fi->neighborSideID());
   else
     mooseError(
         "Attempted to evaluate a moose finite element variable on a face where it is not defined");
 }

◆ feType()

const FEType& MooseVariableBase::feType ( ) const

inlineinherited

Get the type of finite element object.

Definition at line 54 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(), GapValueAux::computeValue(), CopyValueAux::CopyValueAux(), DGKernel::DGKernel(), MultiAppNearestNodeTransfer::execute(), moose::internal::incompatVarMsg(), AdvancedOutput::initAvailableLists(), MultiAppProjectionTransfer::initialSetup(), AdvancedOutput::initShowHideLists(), IntegratedBC::IntegratedBC(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), Kernel::Kernel(), MeshDivisionAux::MeshDivisionAux(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodalBC::NodalBC(), NodalKernel::NodalKernel(), SolutionUserObject::pointValueWrapper(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), MultiAppDofCopyTransfer::transfer(), and VectorNodalBC::VectorNodalBC().

54 { return _fe_type; }

MooseVariableBase::_fe_type

FEType _fe_type

The FEType associated with this variable.

Definition: MooseVariableBase.h:195

◆ fieldType()

template<typename OutputType >

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

overridevirtualinherited

Filed 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 168 of file MooseFunctor.h.

168 { return _functor_name; }

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

MooseFunctorName _functor_name

name of the functor

Definition: MooseFunctor.h:559

◆ 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 977 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);
 }

◆ 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 311 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;
 }

◆ getCheckedPointerParam()

template<typename T >

T MooseBaseParameterInterface::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 268 of file MooseBaseParameterInterface.h.

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

◆ getContinuity()

template<typename OutputType>

FEContinuity MooseVariableFE< OutputType >::getContinuity ( ) const

inlineoverridevirtual

Return the continuity of this variable.

Reimplemented from MooseVariableBase.

Definition at line 149 of file MooseVariableFE.h.

Referenced by ProjectionAux::computeValue().

149 { return _element_data->getContinuity(); };

Referenced by ReporterTransferInterface::checkHasReporterValue(), Coupleable::checkWritableVar(), MooseBaseParameterInterface::connectControllableParams(), Coupleable::Coupleable(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ getDataFileName()

std::string DataFileInterface< MooseObject >::getDataFileName ( const std::string & param ) const

inherited

Returns the path of a data file for a given FileName type parameter, searching (in the following order)

relative to the input file directory
relative to the running binary (assuming the application is installed)
relative to all registered data file directories

Definition at line 24 of file DataFileInterface.C.

 {
   // The path from the parameters, which has not been modified because it is a DataFileName
   const auto & value = _parent.template getParam<DataFileParameterType>(param);
   if (value.empty())
     _parent.paramInfo(param, "Data file name is empty");
 
   const std::filesystem::path value_path = std::filesystem::path(std::string(value));
 
   // If the file is absolute, we should reference that directly and don't need to add
   // any info beacuse this is not ambiguous
   if (value_path.is_absolute() && MooseUtils::checkFileReadable(value, false, false, false))
     return value;
 
   // Look relative to the input file
   const auto base = _parent.parameters().getParamFileBase(param);
   const std::string relative_to_context = std::filesystem::absolute(base / value_path).c_str();
   if (MooseUtils::checkFileReadable(relative_to_context, false, false, false))
   {
     _parent.paramInfo(param, "Data file '", value, "' found relative to the input file.");
     return relative_to_context;
   }
 
   // Isn't absolute and couldn't find relative to the input file, so search the data
   return getDataFileNameByName(value, &param);
 }

◆ getDataFileNameByName()

std::string DataFileInterface< MooseObject >::getDataFileNameByName	(	const std::string &	name,
		const std::string *	param = `nullptr`
	)		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. The optional param pointer can be used to turn the mooseErrors this function emits into paramErrors

relative to the running binary (assuming the application is installed)
relative to all registered data file directories

Definition at line 53 of file DataFileInterface.C.

 {
   const auto share_dir = MooseUtils::pathjoin(Moose::getExecutablePath(), "..", "share");
   if (MooseUtils::pathIsDirectory(share_dir))
   {
     const auto dirs = MooseUtils::listDir(share_dir, false);
     for (const auto & data_dir : dirs)
     {
       const auto path = MooseUtils::pathjoin(data_dir, "data", relative_path);
       if (MooseUtils::checkFileReadable(path, false, false, false))
       {
         if (param)
           _parent.paramInfo(
               *param, "Data file '", path, "' found in an installed app distribution.");
         else
           mooseInfo("Data file '", path, "' found in an installed app distribution.");
         return path;
       }
     }
   }
 
   for (const auto & data_dir : Registry::getRegistry().getDataFilePaths())
   {
     const auto path = MooseUtils::pathjoin(data_dir, relative_path);
     if (MooseUtils::checkFileReadable(path, false, false, false))
     {
       if (param)
         _parent.paramInfo(*param, "Data file '", path, "' found in a source repository.");
       else
         mooseInfo("Data file '", path, "' found in a source repository.");
       return path;
     }
   }
 
   mooseException(param ? _parent.parameters().inputLocation(*param) : _parent.name(),
                  ": Unable to find data file '",
                  relative_path,
                  "' anywhere");
 }

◆ getDofIndices()

template<typename OutputType >

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

overridevirtual

Reimplemented from MooseVariableBase.

Definition at line 157 of file MooseVariableFE.C.

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

◆ getElementalValue()

template<typename OutputType >

MooseVariableFE< OutputType >::OutputData MooseVariableFE< 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 186 of file MooseVariableFE.C.

Referenced by MortarConstraintBase::zeroInactiveLMDofs().

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

◆ getElementalValueOld()

template<typename OutputType >

MooseVariableFE< OutputType >::OutputData MooseVariableFE< 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 193 of file MooseVariableFE.C.

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

◆ getElementalValueOlder()

template<typename OutputType >

MooseVariableFE< OutputType >::OutputData MooseVariableFE< 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 200 of file MooseVariableFE.C.

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

◆ getExecuteOnEnum()

const ExecFlagEnum & SetupInterface::getExecuteOnEnum ( ) const

inherited

Return the execute on MultiMooseEnum for this object.

Definition at line 65 of file SetupInterface.C.

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

 {
   return _execute_enum;
 }

◆ getGradient()

template<typename OutputType>

OutputTools< OutputType >::OutputGradient MooseVariableFE< OutputType >::getGradient	(	const Elem *	elem,
		const std::vector< std::vector< typename OutputTools< OutputType >::OutputShapeGradient >> &	grad_phi
	)		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 512 of file MooseVariableFE.C.

 {
   std::vector<dof_id_type> dof_indices;
   this->_dof_map.dof_indices(elem, dof_indices, _var_num);
 
   typename OutputTools<OutputType>::OutputGradient value;
   if (isNodal())
   {
     for (unsigned int i = 0; i < dof_indices.size(); ++i)
     {
       // The zero index is because we only have one point that the phis are evaluated at
       value += grad_phi[i][0] * (*this->_sys.currentSolution())(dof_indices[i]);
     }
   }
   else
   {
     mooseAssert(dof_indices.size() == 1, "Wrong size for dof indices");
     value = 0.0;
   }
 
   return value;
 }

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

45 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:84

◆ getNodalValue()

template<typename OutputType >

MooseVariableFE< OutputType >::OutputData MooseVariableFE< OutputType >::getNodalValue ( const Node & node ) const

Get the value of this variable at given node.

Definition at line 165 of file MooseVariableFE.C.

Referenced by PenetrationAux::computeValue(), NodalVariableValue::execute(), and MortarConstraintBase::zeroInactiveLMDofs().

 {
   return _element_data->getNodalValue(node, Moose::Current);
 }

◆ getNodalValueOld()

template<typename OutputType >

MooseVariableFE< OutputType >::OutputData MooseVariableFE< OutputType >::getNodalValueOld ( const Node & node ) const

Get the old value of this variable at given node.

Definition at line 172 of file MooseVariableFE.C.

Referenced by VariableOldValueBounds::getBound().

 {
   return _element_data->getNodalValue(node, Moose::Old);
 }

◆ getNodalValueOlder()

template<typename OutputType >

MooseVariableFE< OutputType >::OutputData MooseVariableFE< OutputType >::getNodalValueOlder ( const Node & node ) const

Get the t-2 value of this variable at given node.

Definition at line 179 of file MooseVariableFE.C.

 {
   return _element_data->getNodalValue(node, Moose::Older);
 }

◆ 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 & MooseBaseParameterInterface::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 204 of file MooseBaseParameterInterface.h.

 {
   return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0), &_moose_base);
 }

◆ getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBaseParameterInterface::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 261 of file MooseBaseParameterInterface.h.

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

◆ getRenamedParam()

template<typename T >

const T & MooseBaseParameterInterface::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 211 of file MooseBaseParameterInterface.h.

 {
   // this enables having a default on the new parameter but bypassing it with the old one
   // Most important: accept new parameter
   if (isParamSetByUser(new_name) && !isParamValid(old_name))
     return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
   // Second most: accept old parameter
   else if (isParamValid(old_name) && !isParamSetByUser(new_name))
     return InputParameters::getParamHelper(old_name, _pars, static_cast<T *>(0), &_moose_base);
   // Third most: accept default for new parameter
   else if (isParamValid(new_name) && !isParamValid(old_name))
     return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
   // Refuse: no default, no value passed
   else if (!isParamValid(old_name) && !isParamValid(new_name))
     mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
                "' is being retrieved without being set.\n"
                "Did you misspell it?");
   // Refuse: both old and new parameters set by user
   else
     mooseError(_pars.blockFullpath() + ": 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 72 of file MooseObject.C.

 {
   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 85 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);
 }

◆ getValue()

template<typename OutputType >

OutputType MooseVariableFE< OutputType >::getValue	(	const Elem *	elem,
		const std::vector< std::vector< OutputShape >> &	phi
	)		const

Compute the variable 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 value

Definition at line 451 of file MooseVariableFE.C.

Referenced by GapValueAux::computeValue(), and PenetrationThread::smoothNormal().

 {
   std::vector<dof_id_type> dof_indices;
   this->_dof_map.dof_indices(elem, dof_indices, _var_num);
 
   OutputType value = 0;
   if (isNodal())
   {
     mooseAssert(dof_indices.size() == phi.size(),
                 "The number of shapes does not match the number of dof indices on the elem");
 
     for (unsigned int i = 0; i < dof_indices.size(); ++i)
     {
       // The zero index is because we only have one point that the phis are evaluated at
       value += phi[i][0] * (*this->_sys.currentSolution())(dof_indices[i]);
     }
   }
   else
   {
     mooseAssert(dof_indices.size() == 1, "Wrong size for dof indices");
     value = (*this->_sys.currentSolution())(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 924 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 931 of file MooseFunctor.h.

 {
   return evaluateGradDot(checkFace(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 938 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 945 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 952 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 959 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 840 of file MooseFunctor.h.

Referenced by MooseVariableFV< Real >::evaluate().

 {
   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 847 of file MooseFunctor.h.

 {
   return evaluateGradient(checkFace(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 854 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 861 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 868 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 875 of file MooseFunctor.h.

 {
   return evaluateGradient(node, state);
 }

◆ gradPhi()

template<typename OutputType>

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

inlinefinaloverridevirtual

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

Definition at line 191 of file MooseVariableFE.h.

   {
     return _element_data->gradPhi();
   }

◆ gradPhiFace()

template<typename OutputType>

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

inlinefinaloverridevirtual

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

Definition at line 204 of file MooseVariableFE.h.

   {
     return _element_data->gradPhiFace();
   }

◆ gradPhiFaceNeighbor()

template<typename OutputType>

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

inlinefinaloverridevirtual

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

Definition at line 233 of file MooseVariableFE.h.

   {
     return _neighbor_data->gradPhiFace();
   }

◆ gradPhiLower()

template<typename OutputType>

const FieldVariablePhiGradient& MooseVariableFE< OutputType >::gradPhiLower ( ) const

inline

Definition at line 246 of file MooseVariableFE.h.

246 { return _lower_data->gradPhi(); }

std::unique_ptr< MooseVariableData< OutputType > > _lower_data

Holder for all the data associated with the lower dimeensional element.

Definition: MooseVariableFE.h:723

◆ gradPhiNeighbor()

template<typename OutputType>

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

inlinefinaloverridevirtual

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

Definition at line 217 of file MooseVariableFE.h.

   {
     return _neighbor_data->gradPhi();
   }

◆ gradSln()

template<typename OutputType>

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

inlineoverridevirtual

element gradients

Definition at line 290 of file MooseVariableFE.h.

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

◆ gradSlnDot()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::gradSlnDot ( ) const

inline

element gradient dots

Definition at line 308 of file MooseVariableFE.h.

308 { return _element_data->gradSlnDot(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ gradSlnDotDot()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::gradSlnDotDot ( ) const

inline

Definition at line 309 of file MooseVariableFE.h.

309 { return _element_data->gradSlnDotDot(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ gradSlnNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

neighbor solution gradients

Definition at line 413 of file MooseVariableFE.h.

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

◆ gradSlnNeighborDot()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::gradSlnNeighborDot ( ) const

inline

neighbor grad dots

Definition at line 431 of file MooseVariableFE.h.

431 { return _neighbor_data->gradSlnDot(); }

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ gradSlnNeighborDotDot()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::gradSlnNeighborDotDot ( ) const

inline

Definition at line 432 of file MooseVariableFE.h.

   {
     return _neighbor_data->gradSlnDotDot();
   }

◆ gradSlnOld()

template<typename OutputType>

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

inlineoverridevirtual

Definition at line 294 of file MooseVariableFE.h.

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

◆ gradSlnOlder()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::gradSlnOlder ( ) const

inline

Definition at line 298 of file MooseVariableFE.h.

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

◆ gradSlnOlderNeighbor()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::gradSlnOlderNeighbor ( ) const

inline

Definition at line 421 of file MooseVariableFE.h.

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

◆ gradSlnOldNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

Referenced by LinearFVFluxKernel::addMatrixContribution(), DiracKernelBase::addPoint(), LinearFVFluxKernel::addRightHandSideContribution(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), DomainUserObject::checkVariable(), ComputeJacobianThread::compute(), DomainUserObject::DomainUserObject(), ExtraIDIntegralVectorPostprocessor::execute(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), BlockRestrictable::hasBlocks(), MooseVariableField< Real >::hasBlocks(), FVFluxKernel::hasFaceSide(), and PointwiseRenormalizeVector::PointwiseRenormalizeVector().

Definition at line 417 of file MooseVariableFE.h.

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

◆ gradSlnPreviousNL()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::gradSlnPreviousNL ( ) const

inline

Definition at line 302 of file MooseVariableFE.h.

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

◆ gradSlnPreviousNLNeighbor()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::gradSlnPreviousNLNeighbor ( ) const

inline

Definition at line 425 of file MooseVariableFE.h.

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

◆ 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 264 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 275 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/5]

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 205 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/5]

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 215 of file BlockRestrictable.C.

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

◆ hasBlocks() [3/5]

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 230 of file BlockRestrictable.C.

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

◆ hasBlocks() [4/5]

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 237 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() [5/5]

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 382 of file MooseVariableField.h.

Referenced by Coupleable::checkWritableVar(), GradientJumpIndicator::computeQpIntegral(), ProjectionAux::computeValue(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), FVInterfaceKernel::FVInterfaceKernel(), and ComputeLinearFVGreenGaussGradientVolumeThread::operator()().

382 { 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:205

◆ hasDoFsOnNodes()

template<typename OutputType>

bool MooseVariableFE< OutputType >::hasDoFsOnNodes ( ) const

inlineoverridevirtual

Does this variable have DoFs on nodes.

Returns: true if it does, false if not.

Reimplemented from MooseVariableBase.

Definition at line 148 of file MooseVariableFE.h.

148 { return _element_data->hasDoFsOnNodes(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ hasFaceSide()

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

overridevirtualinherited

Implements FaceArgInterface.

Definition at line 966 of file MooseFunctor.h.

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

◆ increment()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::increment ( ) const

inline

Definition at line 264 of file MooseVariableFE.h.

264 { return _element_data->increment(); }

Referenced by ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), ComputeFullJacobianThread::computeOnInterface(), ComputeFullJacobianThread::computeOnInternalFace(), GradientJumpIndicator::computeQpIntegral(), InternalSideIndicator::finalize(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), and InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor().

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ 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 = ", ";
       }
       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()

void MooseVariableBase::initialSetup ( )

overridevirtualinherited

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

Reimplemented from SetupInterface.

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

Definition at line 199 of file MooseVariableBase.C.

Referenced by MooseLinearVariableFV< Real >::initialSetup().

 {
   // Currently the scaling vector is only used through AD residual computing objects
   if ((_var_kind == Moose::VAR_SOLVER) && _subproblem.haveADObjects() &&
       (_subproblem.automaticScaling() || (std::find_if(_scaling_factor.begin(),
                                                        _scaling_factor.end(),
                                                        [](const Real element) {
                                                          return !MooseUtils::absoluteFuzzyEqual(
                                                              element, 1.);
                                                        }) != _scaling_factor.end())))
 
     _sys.addScalingVector();
 }

◆ insert()

template<typename OutputType >

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

overridevirtual

Set the current local DOF values to the input vector.

Implements MooseVariableFieldBase.

Definition at line 207 of file MooseVariableFE.C.

 {
   _element_data->insert(vector);
 }

◆ insertLower()

template<typename OutputType >

void MooseVariableFE< OutputType >::insertLower ( NumericVector< 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 214 of file MooseVariableFE.C.

 {
   _lower_data->insert(vector);
 }

◆ insertNodalValue()

template<typename OutputType >

void MooseVariableFE< OutputType >::insertNodalValue	(	NumericVector< Number > &	residual,
		const OutputData &	v
	)

Write a nodal value to the passed-in solution vector.

Definition at line 707 of file MooseVariableFE.C.

Referenced by TaggingInterface::setResidual().

 {
   _element_data->insertNodalValue(residual, v);
 }

◆ isArray()

template<typename OutputType >

bool MooseVariableField< OutputType >::isArray ( ) const

overridevirtualinherited

Returns: true if this is an array variable, false otherwise.

Implements MooseVariableFieldBase.

Definition at line 86 of file MooseVariableField.C.

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

◆ 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 246 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 262 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 258 of file MooseFunctor.h.

258 { return false; }

◆ isExtrapolatedBoundaryFace()

virtual bool Moose::FunctorBase< Moose::ADType< OutputType >::type >::isExtrapolatedBoundaryFace	(	const FaceInfo &	,
		const Elem *	,
		const StateArg &
	)		const

inlinevirtualinherited

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

Reimplemented in MooseVariableFV< OutputType >, and MooseLinearVariableFV< OutputType >.

Definition at line 245 of file MooseFunctor.h.

   {
     mooseError("not implemented");
   }

◆ isFV()

virtual bool MooseVariableFieldBase::isFV ( ) const

inlinevirtualinherited

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

Definition at line 86 of file MooseVariableFieldBase.h.

86 { return false; }

◆ 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 564 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 183 of file MooseVariableBase.h.

183 { return _is_lower_d; }

MooseVariableBase::_is_lower_d

bool _is_lower_d

Whether this variable lives on lower dimensional blocks.

Definition: MooseVariableBase.h:246

◆ isNodal()

template<typename OutputType>

bool MooseVariableFE< OutputType >::isNodal ( ) const

inlineoverridevirtual

Is this variable nodal.

Returns: true if it nodal, otherwise false

Reimplemented from MooseVariableBase.

Definition at line 147 of file MooseVariableFE.h.

Referenced by ProjectionAux::computeValue(), and MortarConstraintBase::zeroInactiveLMDofs().

147 { return _element_data->isNodal(); }

Referenced by ArrayNodalBC::computeJacobian(), NodalBC::computeJacobian(), ADNodalKernel::computeJacobian(), NodalKernel::computeJacobian(), ArrayNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), NodalKernel::computeOffDiagJacobian(), ArrayNodalBC::computeResidual(), TimeNodalKernel::computeResidual(), NodalBC::computeResidual(), NodalKernel::computeResidual(), ADNodalKernel::computeResidual(), and DirichletBCBase::computeValue().

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ isNodalDefined()

template<typename OutputType >

bool MooseVariableFE< OutputType >::isNodalDefined ( ) const

overridevirtual

Is this variable defined at nodes.

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

Implements MooseVariableFieldBase.

Definition at line 827 of file MooseVariableFE.C.

 {
   return _element_data->isNodalDefined();
 }

◆ isNodalNeighborDefined()

template<typename OutputType >

bool MooseVariableFE< OutputType >::isNodalNeighborDefined ( ) const

Definition at line 834 of file MooseVariableFE.C.

 {
   return _neighbor_data->isNodalDefined();
 }

◆ isParamSetByUser()

bool MooseBaseParameterInterface::isParamSetByUser ( const std::string & nm ) const

inlineinherited

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

Parameters

nm	The name of the parameter to test

Definition at line 117 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), SetAdaptivityOptionsAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), PhysicsBase::checkSecondParamSetOnlyIfFirstOneTrue(), LibtorchNeuralNetControl::conditionalParameterError(), FixedPointSolve::FixedPointSolve(), MooseBaseParameterInterface::getRenamedParam(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObject::readXda(), and SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator().

117 { return _pars.isParamSetByUser(nm); }

InputParameters::isParamSetByUser

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

Method returns true if the parameter was by the user.

Definition: InputParameters.C:1074

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:162

◆ isParamValid()

bool MooseBaseParameterInterface::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 111 of file MooseBaseParameterInterface.h.

111 { return _pars.isParamValid(name); }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:162

InputParameters::isParamValid

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:376

◆ 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 93 of file MooseVariableField.C.

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

◆ jacobianSetup()

template<typename OutputType >

void MooseVariableFE< OutputType >::jacobianSetup ( )

overridevirtual

Reimplemented from MooseVariableField< OutputType >.

Definition at line 1357 of file MooseVariableFE.C.

 {
   _current_elem_qp_functor_elem = nullptr;
   _current_elem_side_qp_functor_elem_side = std::make_pair(nullptr, libMesh::invalid_uint);
   MooseVariableField<OutputType>::jacobianSetup();
 }

◆ kind()

Moose::VarKindType MooseVariableBase::kind ( ) const

inlineinherited

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

Definition at line 85 of file MooseVariableBase.h.

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

85 { return _var_kind; }

MooseVariableBase::_var_kind

Moose::VarKindType _var_kind

Variable type (see MooseTypes.h)

Definition: MooseVariableBase.h:207

◆ matrixTagValue()

template<typename OutputType>

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

inlineoverridevirtual

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), Executioner::augmentedPicardConvergenceCheck(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), FEProblemBase::computeResidual(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), Executioner::picardSolve(), ReferenceResidualProblem::ReferenceResidualProblem(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), and UserForcingFunction::UserForcingFunction().

Definition at line 278 of file MooseVariableFE.h.

   {
     return _element_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 269 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 MooseVariableFE< OutputType >::meshChanged ( )

overridevirtual

Called on this object when the mesh changes.

Reimplemented from MeshChangedInterface.

Definition at line 1339 of file MooseVariableFE.C.

 {
   _current_elem_qp_functor_elem = nullptr;
   _current_elem_side_qp_functor_elem_side = std::make_pair(nullptr, libMesh::invalid_uint);
   MooseVariableField<OutputType>::meshChanged();
 }

◆ mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 91 of file MooseBaseErrorInterface.h.

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

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Emits a documented error with object name and type.

Documented errors are errors that have an issue associated with them.

The repository name repo_name links a named repository to a URL and should be registered at the application level with registerRepository(). See Moose.C for an example of the "moose" repository registration.

Parameters

repo_name	The repository name where the issue resides
issue_num	The number of the issue
args	The error message to be combined

Definition at line 61 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     const auto msg = moose::internal::formatMooseDocumentedError(repo_name, issue_num, oss.str());
     _moose_base.callMooseError(msg, /* with_prefix = */ true);
   }

◆ mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type.

Definition at line 29 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     _moose_base.callMooseError(oss.str(), /* with_prefix = */ true);
   }

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 40 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     _moose_base.callMooseError(oss.str(), /* with_prefix = */ false);
   }

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 97 of file MooseBaseErrorInterface.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ProjectionAux::ProjectionAux(), ReferenceResidualProblem::ReferenceResidualProblem(), FEProblemBase::setRestartFile(), and SymmetryTransformGenerator::SymmetryTransformGenerator().

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

◆ mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 75 of file MooseBaseErrorInterface.h.

Referenced by AddKernelAction::act(), SetupMeshAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), BoundsBase::BoundsBase(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), PhysicsBase::checkRequiredTasks(), OversampleOutput::cloneMesh(), GapValueAux::computeValue(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), Positions::getNearestPositionIndex(), LineValueSampler::getValue(), Terminator::handleMessage(), CartesianGridDivision::initialize(), SphericalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), CylindricalGridDivision::initialize(), ReferenceResidualProblem::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

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

◆ mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 85 of file MooseBaseErrorInterface.h.

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

◆ name()

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

inlineoverridevirtualinherited

Get the variable name.

Reimplemented from MooseBase.

Definition at line 69 of file MooseVariableBase.h.

Referenced by SetupResidualDebugAction::act(), InitialConditionWarehouse::addObject(), MooseLinearVariableFV< Real >::adError(), MooseVariableBase::allDofIndices(), ArrayParsedAux::ArrayParsedAux(), DomainUserObject::checkVariable(), BlockRestrictable::checkVariable(), Coupleable::checkWritableVar(), Coupleable::coupledName(), GreaterThanLessThanPostprocessor::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), FunctionArrayAux::FunctionArrayAux(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), GapValueAux::GapValueAux(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), DerivativeMaterialInterface< MortarScalarBase >::isNotObjectVariable(), MooseLinearVariableFV< Real >::lowerDError(), MooseLinearVariableFV< Real >::nodalError(), ParsedAux::ParsedAux(), ParsedODEKernel::ParsedODEKernel(), ConstraintWarehouse::subdomainsCovered(), MooseLinearVariableFV< Real >::timeIntegratorError(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), FVFluxBC::uOnGhost(), and FVFluxBC::uOnUSub().

69 { return _var_name; }

MooseVariableBase::_var_name

std::string _var_name

Variable name.

Definition: MooseVariableBase.h:237

◆ 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 125 of file MooseVariableFieldBase.h.

125 { return false; }

◆ neighbor()

template<typename OutputType>

const Elem* const& MooseVariableFE< OutputType >::neighbor ( ) const

inline

Current neighboring element.

Definition at line 171 of file MooseVariableFE.h.

171 { return _neighbor_data->currentElem(); }

Referenced by InternalSideIndicator::computeIndicator(), ArrayNodalBC::computeJacobian(), NodalBC::computeJacobian(), ADNodalKernel::computeJacobian(), NodalKernel::computeJacobian(), NodeFaceConstraint::computeJacobian(), ArrayNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), NodalKernel::computeOffDiagJacobian(), NodeFaceConstraint::computeOffDiagJacobian(), TimeNodalKernel::computeResidual(), NodalKernel::computeResidual(), ADNodalKernel::computeResidual(), NodeElemConstraint::computeSecondaryValue(), NodeFaceConstraint::computeSecondaryValue(), DirichletBCBase::computeValue(), and InternalSideIndicator::finalize().

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ nodalDofIndex()

template<typename OutputType>

const dof_id_type& MooseVariableFE< OutputType >::nodalDofIndex ( ) const

inlineoverridevirtual

Implements MooseVariableFieldBase.

Definition at line 151 of file MooseVariableFE.h.

151 { return _element_data->nodalDofIndex(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ nodalDofIndexNeighbor()

template<typename OutputType>

const dof_id_type& MooseVariableFE< OutputType >::nodalDofIndexNeighbor ( ) const

inlineoverridevirtual

Implements MooseVariableFieldBase.

Definition at line 155 of file MooseVariableFE.h.

Referenced by InternalSideIndicator::computeIndicator().

   {
     return _neighbor_data->nodalDofIndex();
   }

◆ nodalMatrixTagValue()

template<typename OutputType >

const MooseVariableFE< OutputType >::DoFValue & MooseVariableFE< OutputType >::nodalMatrixTagValue ( TagID tag ) const

overridevirtual

Definition at line 588 of file MooseVariableFE.C.

 {
   return _element_data->nodalMatrixTagValue(tag);
 }

◆ nodalValue()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValue ( ) const

Methods for retrieving values of variables at the nodes.

Definition at line 567 of file MooseVariableFE.C.

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

◆ nodalValueArray()

template<typename OutputType>

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

inlineoverridevirtual

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

Definition at line 681 of file MooseVariableFE.h.

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

◆ nodalValueDot()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueDot ( ) const

Definition at line 637 of file MooseVariableFE.C.

 {
   return _element_data->nodalValueDot();
 }

◆ nodalValueDotDot()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueDotDot ( ) const

Definition at line 644 of file MooseVariableFE.C.

 {
   return _element_data->nodalValueDotDot();
 }

◆ nodalValueDotDotNeighbor()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDotDotNeighbor ( ) const

◆ nodalValueDotDotNeighborResidual()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDotDotNeighborResidual ( ) const

◆ nodalValueDotDotOld()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueDotDotOld ( ) const

Definition at line 658 of file MooseVariableFE.C.

 {
   return _element_data->nodalValueDotDotOld();
 }

◆ nodalValueDotDotOldNeighbor()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDotDotOldNeighbor ( ) const

◆ nodalValueDotNeighbor()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDotNeighbor ( ) const

◆ nodalValueDotNeighborResidual()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDotNeighborResidual ( ) const

◆ nodalValueDotOld()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueDotOld ( ) const

Definition at line 651 of file MooseVariableFE.C.

 {
   return _element_data->nodalValueDotOld();
 }

◆ nodalValueDotOldNeighbor()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDotOldNeighbor ( ) const

◆ nodalValueDuDotDotDu()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDuDotDotDu ( ) const

◆ nodalValueDuDotDotDuNeighbor()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDuDotDotDuNeighbor ( ) const

◆ nodalValueDuDotDu()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDuDotDu ( ) const

◆ nodalValueDuDotDuNeighbor()

template<typename OutputType>

const OutputType& MooseVariableFE< OutputType >::nodalValueDuDotDuNeighbor ( ) const

◆ nodalValueNeighbor()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueNeighbor ( ) const

Definition at line 574 of file MooseVariableFE.C.

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

◆ nodalValueOld()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueOld ( ) const

Definition at line 595 of file MooseVariableFE.C.

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

◆ nodalValueOldArray()

template<typename OutputType>

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

inlineoverridevirtual

Definition at line 685 of file MooseVariableFE.h.

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

◆ nodalValueOlder()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueOlder ( ) const

Definition at line 609 of file MooseVariableFE.C.

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

◆ nodalValueOlderArray()

template<typename OutputType>

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

inlineoverridevirtual

Definition at line 689 of file MooseVariableFE.h.

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

◆ nodalValueOlderNeighbor()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueOlderNeighbor ( ) const

Definition at line 616 of file MooseVariableFE.C.

 {
   return _neighbor_data->nodalValue(Moose::Older);
 }

◆ nodalValueOldNeighbor()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValueOldNeighbor ( ) const

Definition at line 602 of file MooseVariableFE.C.

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

◆ nodalValuePreviousNL()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValuePreviousNL ( ) const

Definition at line 623 of file MooseVariableFE.C.

 {
   return _element_data->nodalValue(Moose::PreviousNL);
 }

◆ nodalValuePreviousNLNeighbor()

template<typename OutputType >

const OutputType & MooseVariableFE< OutputType >::nodalValuePreviousNLNeighbor ( ) const

Definition at line 630 of file MooseVariableFE.C.

 {
   return _neighbor_data->nodalValue(Moose::PreviousNL);
 }

◆ nodalVectorTagValue()

template<typename OutputType >

const MooseVariableFE< OutputType >::DoFValue & MooseVariableFE< OutputType >::nodalVectorTagValue ( TagID tag ) const

overridevirtual

Definition at line 581 of file MooseVariableFE.C.

 {
   return _element_data->nodalVectorTagValue(tag);
 }

◆ node()

template<typename OutputType>

const Node* const& MooseVariableFE< OutputType >::node ( ) const

inline

Definition at line 150 of file MooseVariableFE.h.

150 { return _element_data->node(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ nodeNeighbor()

template<typename OutputType>

const Node* const& MooseVariableFE< OutputType >::nodeNeighbor ( ) const

inline

Definition at line 154 of file MooseVariableFE.h.

154 { return _neighbor_data->node(); }

MooseVariableBase::_var_num

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ number()

unsigned int MooseVariableBase::number ( ) const

inlineinherited

Get variable number coming from libMesh.

Returns: the libmesh variable number

Definition at line 49 of file MooseVariableBase.h.

49 { return _var_num; }

unsigned int _var_num

variable number (from libMesh)

Definition: MooseVariableBase.h:198

◆ numberOfDofs()

template<typename OutputType>

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

inlinefinalvirtual

Get the number of local DoFs.

Reimplemented from MooseVariableBase.

Definition at line 176 of file MooseVariableFE.h.

176 { return _element_data->numberOfDofs(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ numberOfDofsNeighbor()

template<typename OutputType>

unsigned int MooseVariableFE< OutputType >::numberOfDofsNeighbor ( )

inlineoverridevirtual

Implements MooseVariableFieldBase.

Definition at line 188 of file MooseVariableFE.h.

188 { return _neighbor_data->dofIndices().size(); }

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(), FVBoundaryScalarLagrangeMultiplierConstraint::computeResidual(), FVScalarLagrangeMultiplierConstraint::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(), ScalarComponentIC::ScalarComponentIC(), and MooseVariableBase::validParams().

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ numBlocks()

unsigned int BlockRestrictable::numBlocks ( ) const

inherited

Return the number of blocks for this object.

Returns: The number of subdomains

Definition at line 199 of file BlockRestrictable.C.

Referenced by ElementCentroidPositions::initialize().

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

◆ oldestSolutionStateRequested()

template<typename OutputType >

unsigned int MooseVariableFE< 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 841 of file MooseVariableFE.C.

 {
   unsigned int state = 0;
   state = std::max(state, _element_data->oldestSolutionStateRequested());
   state = std::max(state, _neighbor_data->oldestSolutionStateRequested());
   state = std::max(state, _lower_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 592 of file MooseFunctor.h.

 {
   if (_clearance_schedule.count(EXEC_ALWAYS))
     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 605 of file MooseFunctor.h.

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

◆ 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 651 of file MooseFunctor.h.

 {
   if (_clearance_schedule.count(EXEC_ALWAYS))
     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 672 of file MooseFunctor.h.

 {
   if (_clearance_schedule.count(EXEC_ALWAYS))
     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 702 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 716 of file MooseFunctor.h.

 {
   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 165 of file MooseVariableBase.C.

 {
   return _fe_type.order;
 }

◆ paramError()

template<typename... Args>

void MooseBaseParameterInterface::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 237 of file MooseBaseParameterInterface.h.

 {
   Moose::show_trace = false;
   _moose_base.callMooseError(paramErrorMsg(param, std::forward<Args>(args)...),
                              /* with_prefix = */ false);
   Moose::show_trace = true;
 }

◆ parameters()

const InputParameters& MooseBaseParameterInterface::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 62 of file MooseBaseParameterInterface.h.

62 { return _pars; }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:162

◆ paramInfo()

template<typename... Args>

void MooseBaseParameterInterface::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 254 of file MooseBaseParameterInterface.h.

Referenced by TransientMultiApp::TransientMultiApp().

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

◆ paramWarning()

template<typename... Args>

void MooseBaseParameterInterface::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 247 of file MooseBaseParameterInterface.h.

Referenced by MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), FixedPointSolve::FixedPointSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), and MooseMesh::MooseMesh().

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

◆ phi()

template<typename OutputType>

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

inlineoverridevirtual

Return the variable's elemental shape functions.

Definition at line 190 of file MooseVariableFE.h.

190 { return _element_data->phi(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ phiFace()

template<typename OutputType>

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

inlinefinaloverridevirtual

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

Definition at line 203 of file MooseVariableFE.h.

Referenced by MortarConstraint::computeJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), and MortarScalarBase::computeScalarOffDiagJacobian().

203 { return _element_data->phiFace(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ phiFaceNeighbor()

template<typename OutputType>

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

inlinefinaloverridevirtual

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

Definition at line 229 of file MooseVariableFE.h.

   {
     return _neighbor_data->phiFace();
   }

◆ phiFaceNeighborSize()

template<typename OutputType>

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

inlinefinalvirtual

Return phiFaceNeighbor size.

Implements MooseVariableFieldBase.

Definition at line 651 of file MooseVariableFE.h.

651 { return _neighbor_data->phiFaceSize(); }

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ phiFaceSize()

template<typename OutputType>

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

inlinefinalvirtual

Return phiFace size.

Implements MooseVariableFieldBase.

Definition at line 643 of file MooseVariableFE.h.

643 { return _element_data->phiFaceSize(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ phiLower()

template<typename OutputType>

virtual const FieldVariablePhiValue& MooseVariableFE< OutputType >::phiLower ( ) const

inlineoverridevirtual

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

Definition at line 245 of file MooseVariableFE.h.

Referenced by LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), DGLowerDKernel::computeOffDiagLowerDJacobian(), and ArrayDGLowerDKernel::computeOffDiagLowerDJacobian().

245 { return _lower_data->phi(); }

std::unique_ptr< MooseVariableData< OutputType > > _lower_data

Holder for all the data associated with the lower dimeensional element.

Definition: MooseVariableFE.h:723

◆ phiLowerSize()

template<typename OutputType>

std::size_t MooseVariableFE< OutputType >::phiLowerSize ( ) const

inlinefinalvirtual

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

Implements MooseVariableFieldBase.

Definition at line 653 of file MooseVariableFE.h.

653 { return _lower_data->phiSize(); }

std::unique_ptr< MooseVariableData< OutputType > > _lower_data

Holder for all the data associated with the lower dimeensional element.

Definition: MooseVariableFE.h:723

◆ phiNeighbor()

template<typename OutputType>

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

inlinefinaloverridevirtual

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

Definition at line 216 of file MooseVariableFE.h.

216 { return _neighbor_data->phi(); }

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ phiNeighborSize()

template<typename OutputType>

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

inlinefinalvirtual

Return phiNeighbor size.

Implements MooseVariableFieldBase.

Definition at line 647 of file MooseVariableFE.h.

647 { return _neighbor_data->phiSize(); }

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ phiSize()

template<typename OutputType>

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

inlinefinalvirtual

Return phi size.

Implements MooseVariableFieldBase.

Definition at line 639 of file MooseVariableFE.h.

639 { return _element_data->phiSize(); }

MooseVariableBase::_scaling_factor

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ prepare()

template<typename OutputType >

void MooseVariableFE< OutputType >::prepare ( )

overridevirtual

Prepare the elemental degrees of freedom.

Implements MooseVariableFieldBase.

Definition at line 92 of file MooseVariableFE.C.

 {
   _element_data->prepare();
 }

◆ prepareAux()

template<typename OutputType >

void MooseVariableFE< OutputType >::prepareAux ( )

overridevirtual

Implements MooseVariableFieldBase.

Definition at line 113 of file MooseVariableFE.C.

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

◆ prepareIC()

template<typename OutputType >

void MooseVariableFE< OutputType >::prepareIC ( )

overridevirtual

Prepare the initial condition.

Implements MooseVariableFieldBase.

Definition at line 390 of file MooseVariableFE.C.

 {
   _element_data->prepareIC();
 }

◆ prepareLowerD()

template<typename OutputType >

void MooseVariableFE< OutputType >::prepareLowerD ( )

overridevirtual

Prepare a lower dimensional element's degrees of freedom.

Implements MooseVariableFieldBase.

Definition at line 106 of file MooseVariableFE.C.

 {
   _lower_data->prepare();
 }

◆ prepareNeighbor()

template<typename OutputType >

void MooseVariableFE< OutputType >::prepareNeighbor ( )

overridevirtual

Prepare the neighbor element degrees of freedom.

Implements MooseVariableFieldBase.

Definition at line 99 of file MooseVariableFE.C.

 {
   _neighbor_data->prepare();
 }

◆ reinitAux()

template<typename OutputType >

void MooseVariableFE< OutputType >::reinitAux ( )

overridevirtual

Implements MooseVariableFieldBase.

Definition at line 129 of file MooseVariableFE.C.

 {
   _element_data->reinitAux();
 }

◆ reinitAuxNeighbor()

template<typename OutputType >

void MooseVariableFE< OutputType >::reinitAuxNeighbor ( )

overridevirtual

Implements MooseVariableFieldBase.

Definition at line 136 of file MooseVariableFE.C.

 {
   _neighbor_data->reinitAux();
 }

◆ reinitNode()

template<typename OutputType >

void MooseVariableFE< OutputType >::reinitNode ( )

overridevirtual

Implements MooseVariableFieldBase.

Definition at line 122 of file MooseVariableFE.C.

 {
   _element_data->reinitNode();
 }

◆ reinitNodes()

template<typename OutputType >

void MooseVariableFE< OutputType >::reinitNodes ( const std::vector< dof_id_type > & nodes )

overridevirtual

Implements MooseVariableFieldBase.

Definition at line 143 of file MooseVariableFE.C.

 {
   _element_data->reinitNodes(nodes);
 }

◆ reinitNodesNeighbor()

template<typename OutputType >

void MooseVariableFE< OutputType >::reinitNodesNeighbor ( const std::vector< dof_id_type > & nodes )

overridevirtual

Implements MooseVariableFieldBase.

Definition at line 150 of file MooseVariableFE.C.

 {
   _neighbor_data->reinitNodes(nodes);
 }

◆ residualSetup()

template<typename OutputType >

void MooseVariableFE< OutputType >::residualSetup ( )

overridevirtual

Reimplemented from MooseVariableField< OutputType >.

Definition at line 1348 of file MooseVariableFE.C.

 {
   _current_elem_qp_functor_elem = nullptr;
   _current_elem_side_qp_functor_elem_side = std::make_pair(nullptr, libMesh::invalid_uint);
   MooseVariableField<OutputType>::residualSetup();
 }

◆ scalingFactor() [1/2]

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

inherited

Set the scaling factor for this variable.

Definition at line 191 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 95 of file MooseVariableBase.h.

Referenced by MooseVariableBase::MooseVariableBase().

95 { return _scaling_factor[0]; }

std::vector< Real > _scaling_factor

scaling factor for this variable

Definition: MooseVariableBase.h:234

◆ secondPhi()

template<typename OutputType >

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

finaloverridevirtual

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

Definition at line 715 of file MooseVariableFE.C.

 {
   return _element_data->secondPhi();
 }

◆ secondPhiFace()

template<typename OutputType >

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

finaloverridevirtual

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

Definition at line 736 of file MooseVariableFE.C.

 {
   return _element_data->secondPhiFace();
 }

◆ secondPhiFaceNeighbor()

template<typename OutputType >

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

finaloverridevirtual

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

Definition at line 778 of file MooseVariableFE.C.

 {
   return _neighbor_data->secondPhiFace();
 }

◆ secondPhiNeighbor()

template<typename OutputType >

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

finaloverridevirtual

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

Definition at line 757 of file MooseVariableFE.C.

 {
   return _neighbor_data->secondPhi();
 }

◆ secondSln()

template<typename OutputType>

const FieldVariableSecond& MooseVariableFE< OutputType >::secondSln ( ) const

inline

element seconds

Definition at line 312 of file MooseVariableFE.h.

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

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

Definition: MooseTypes.h:223

◆ secondSlnNeighbor()

template<typename OutputType>

const FieldVariableSecond& MooseVariableFE< OutputType >::secondSlnNeighbor ( ) const

inline

neighbor solution seconds

Definition at line 438 of file MooseVariableFE.h.

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

◆ secondSlnOld()

template<typename OutputType>

const FieldVariableSecond& MooseVariableFE< OutputType >::secondSlnOld ( ) const

inline

Definition at line 313 of file MooseVariableFE.h.

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

Definition: MooseTypes.h:224

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ secondSlnOlder()

template<typename OutputType>

const FieldVariableSecond& MooseVariableFE< OutputType >::secondSlnOlder ( ) const

inline

Definition at line 314 of file MooseVariableFE.h.

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

◆ secondSlnOlderNeighbor()

template<typename OutputType>

const FieldVariableSecond& MooseVariableFE< OutputType >::secondSlnOlderNeighbor ( ) const

inline

Definition at line 446 of file MooseVariableFE.h.

   {
     return _neighbor_data->secondSln(Moose::Older);
   }

◆ secondSlnOldNeighbor()

template<typename OutputType>

const FieldVariableSecond& MooseVariableFE< OutputType >::secondSlnOldNeighbor ( ) const

inline

Definition at line 442 of file MooseVariableFE.h.

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

◆ secondSlnPreviousNL()

template<typename OutputType>

const FieldVariableSecond& MooseVariableFE< OutputType >::secondSlnPreviousNL ( ) const

inline

Definition at line 318 of file MooseVariableFE.h.

   {
     return _element_data->secondSln(Moose::PreviousNL);
   }

◆ secondSlnPreviousNLNeighbor()

template<typename OutputType>

const FieldVariableSecond& MooseVariableFE< OutputType >::secondSlnPreviousNLNeighbor ( ) const

inline

Definition at line 450 of file MooseVariableFE.h.

   {
     return _neighbor_data->secondSln(Moose::PreviousNL);
   }

◆ setActiveTags()

template<typename OutputType >

void MooseVariableFE< 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 856 of file MooseVariableFE.h.

 {
   _element_data->setActiveTags(vtags);
   _neighbor_data->setActiveTags(vtags);
   _lower_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 709 of file MooseFunctor.h.

 {
   _clearance_schedule = clearance_schedule;
 }

◆ setDofValue()

template<typename OutputType >

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

overridevirtual

Degree of freedom value setters.

Definition at line 686 of file MooseVariableFE.C.

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

◆ setDofValues()

template<typename OutputType >

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

overridevirtual

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

Definition at line 693 of file MooseVariableFE.C.

 {
   _element_data->setDofValues(values);
 }

◆ setLowerDofValues()

template<typename OutputType >

void MooseVariableFE< 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 700 of file MooseVariableFE.C.

 {
   _lower_data->setDofValues(values);
 }

◆ setNodalValue()

template<typename OutputType>

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

overridevirtual

Definition at line 679 of file MooseVariableFE.C.

Referenced by ElementIntegralIndicator::computeIndicator(), and Marker::computeMarker().

 {
   _element_data->setNodalValue(value, idx);
 }

◆ sln()

template<typename OutputType>

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

inlineoverridevirtual

element solutions

Definition at line 284 of file MooseVariableFE.h.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute(), and FindValueOnLine::getValueAtPoint().

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

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

Definition: MooseTypes.h:223

◆ slnLower()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::slnLower ( ) const

inline

Definition at line 493 of file MooseVariableFE.h.

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

std::unique_ptr< MooseVariableData< OutputType > > _lower_data

Holder for all the data associated with the lower dimeensional element.

Definition: MooseVariableFE.h:723

Definition: MooseTypes.h:223

◆ slnLowerOld()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::slnLowerOld ( ) const

inline

Definition at line 494 of file MooseVariableFE.h.

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

std::unique_ptr< MooseVariableData< OutputType > > _lower_data

Holder for all the data associated with the lower dimeensional element.

Definition: MooseVariableFE.h:723

Definition: MooseTypes.h:224

◆ slnNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

neighbor solutions

Definition at line 398 of file MooseVariableFE.h.

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

◆ slnOld()

template<typename OutputType>

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

inlineoverridevirtual

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

Definition at line 285 of file MooseVariableFE.h.

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

Definition: MooseTypes.h:224

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ slnOlder()

template<typename OutputType>

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

inlineoverridevirtual

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

Definition at line 286 of file MooseVariableFE.h.

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

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

Moose::Older

Definition: MooseTypes.h:225

◆ slnOlderNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::slnOlderNeighbor ( ) const

inline

Definition at line 406 of file MooseVariableFE.h.

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

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

Moose::Older

Definition: MooseTypes.h:225

◆ slnOldNeighbor()

template<typename OutputType>

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

inlineoverridevirtual

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

Definition at line 402 of file MooseVariableFE.h.

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

◆ slnPreviousNL()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::slnPreviousNL ( ) const

inline

Definition at line 287 of file MooseVariableFE.h.

287 { return _element_data->sln(Moose::PreviousNL); }

Moose::PreviousNL

Definition: MooseTypes.h:226

MooseVariableBase::allDofIndices

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ slnPreviousNLNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::slnPreviousNLNeighbor ( ) const

inline

Definition at line 407 of file MooseVariableFE.h.

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

◆ 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, NodalUserObject, GeneralUserObject, Constraint, and ThreadedGeneralUserObject.

Definition at line 60 of file SetupInterface.C.

61 {

62 }

◆ supportsElemSideQpArg()

template<typename OutputType>

bool MooseVariableFE< OutputType >::supportsElemSideQpArg ( ) const

inlinefinaloverridevirtual

Whether this functor supports evaluation with ElemSideQpArg.

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

Definition at line 711 of file MooseVariableFE.h.

711 { return true; }

◆ supportsFaceArg()

template<typename OutputType>

bool MooseVariableFE< OutputType >::supportsFaceArg ( ) const

inlinefinaloverridevirtual

Whether this functor supports evaluation with FaceArg.

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

Definition at line 710 of file MooseVariableFE.h.

710 { return true; }

◆ sys() [1/2]

SystemBase& MooseVariableBase::sys ( )

inlineinherited

Get the system this variable is part of.

Definition at line 59 of file MooseVariableBase.h.

59 { return _sys; }

MooseVariableBase::_sys

SystemBase & _sys

System this variable is part of.

Definition: MooseVariableBase.h:192

◆ sys() [2/2]

const SystemBase& MooseVariableBase::sys ( ) const

inlineinherited

Get the system this variable is part of.

Definition at line 64 of file MooseVariableBase.h.

64 { return _sys; }

MooseVariableBase::_sys

SystemBase & _sys

System this variable is part of.

Definition: MooseVariableBase.h:192

◆ timestepSetup()

template<typename OutputType >

void MooseVariableField< OutputType >::timestepSetup ( )

overridevirtualinherited

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

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

Definition at line 52 of file MooseVariableField.C.

Referenced by MooseVariableFV< Real >::timestepSetup().

 {
   MooseVariableFieldBase::timestepSetup();
   FunctorBase<typename Moose::ADType<OutputType>::type>::timestepSetup();
 }

◆ totalVarDofs()

unsigned int MooseVariableBase::totalVarDofs ( )

inlineinherited

Definition at line 80 of file MooseVariableBase.h.

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

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

Get all global dofindices for the variable.

Definition: MooseVariableBase.C:153

◆ 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 51 of file MooseBase.h.

51 { return _type; }

MooseBase::_type

const std::string _type

The type of this class.

Definition: MooseBase.h:87

◆ 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 27 of file MooseBase.C.

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

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

◆ uDot()

template<typename OutputType>

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

inline

element dots

Definition at line 390 of file MooseVariableFE.h.

390 { return _element_data->uDot(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ uDotDot()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::uDotDot ( ) const

inline

Definition at line 391 of file MooseVariableFE.h.

391 { return _element_data->uDotDot(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ uDotDotNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::uDotDotNeighbor ( ) const

inline

Definition at line 485 of file MooseVariableFE.h.

485 { return _neighbor_data->uDotDot(); }

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ uDotDotOld()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::uDotDotOld ( ) const

inline

Definition at line 393 of file MooseVariableFE.h.

393 { return _element_data->uDotDotOld(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ uDotDotOldNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::uDotDotOldNeighbor ( ) const

inline

Definition at line 487 of file MooseVariableFE.h.

487 { return _neighbor_data->uDotDotOld(); }

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ uDotNeighbor()

template<typename OutputType>

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

inline

neighbor dots

Definition at line 484 of file MooseVariableFE.h.

484 { return _neighbor_data->uDot(); }

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ uDotOld()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::uDotOld ( ) const

inline

Definition at line 392 of file MooseVariableFE.h.

392 { return _element_data->uDotOld(); }

std::unique_ptr< MooseVariableData< OutputType > > _element_data

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

Definition: MooseVariableFE.h:717

◆ uDotOldNeighbor()

template<typename OutputType>

const FieldVariableValue& MooseVariableFE< OutputType >::uDotOldNeighbor ( ) const

inline

Definition at line 486 of file MooseVariableFE.h.

486 { return _neighbor_data->uDotOld(); }

MooseVariableBase::_use_dual

std::unique_ptr< MooseVariableData< OutputType > > _neighbor_data

Holder for all the data associated with the neighbor element.

Definition: MooseVariableFE.h:720

◆ uniqueName()

MooseObjectName MooseBaseParameterInterface::uniqueName ( ) const

inlineinherited

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

Definition at line 67 of file MooseBaseParameterInterface.h.

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

   {
     return MooseObjectName(_pars.get<std::string>("_unique_name"));
   }

◆ uniqueParameterName()

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

inlineinherited

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

Definition at line 52 of file MooseBaseParameterInterface.h.

   {
     return MooseObjectParameterName(
         _pars.get<std::string>("_moose_base"), _moose_base.name(), parameter_name);
   }

◆ useDual()

bool MooseVariableBase::useDual ( ) const

inlineinherited

Get dual mortar option.

Definition at line 74 of file MooseVariableBase.h.

Referenced by MortarConstraintBase::MortarConstraintBase().

74 { return _use_dual; }

bool _use_dual

If dual mortar approach is used.

Definition: MooseVariableBase.h:240

◆ usesGradPhi()

template<typename OutputType>

bool MooseVariableFE< OutputType >::usesGradPhi ( ) const

inline

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 119 of file MooseVariableFE.h.

119 { return true; }

◆ 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 329 of file MooseVariableField.h.

Referenced by Assembly::copyNeighborShapes().

329 { return true; }

◆ usesPhi()

template<typename OutputType>

bool MooseVariableFE< OutputType >::usesPhi ( ) const

inline

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 113 of file MooseVariableFE.h.

113 { 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 322 of file MooseVariableField.h.

Referenced by Assembly::copyNeighborShapes().

322 { return true; }

◆ usesSecondPhi()

template<typename OutputType >

bool MooseVariableFE< OutputType >::usesSecondPhi ( ) const

Whether or not this variable is computing any second derivatives.

Definition at line 799 of file MooseVariableFE.C.

Referenced by MooseVariableFE< Real >::computingSecond().

 {
   return _element_data->usesSecondPhi();
 }

◆ usesSecondPhiNeighbor()

template<typename OutputType >

bool MooseVariableFE< OutputType >::usesSecondPhiNeighbor ( ) const

finaloverridevirtual

Whether or not this variable is actually using the shape function second derivative on a neighbor.

Definition at line 806 of file MooseVariableFE.C.

 {
   return _neighbor_data->usesSecondPhi();
 }

◆ validParams()

template<typename OutputType>

static InputParameters MooseVariableFE< OutputType >::validParams ( )

static

◆ vectorTagDofValue()

template<typename OutputType>

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

inlineoverridevirtual

Definition at line 274 of file MooseVariableFE.h.

   {
     return _element_data->vectorTagDofValue(tag);
   }

◆ vectorTagGradient()

template<typename OutputType>

const FieldVariableGradient& MooseVariableFE< OutputType >::vectorTagGradient ( TagID tag ) const

inline

Definition at line 270 of file MooseVariableFE.h.

   {
     return _element_data->vectorTagGradient(tag);
   }

◆ vectorTagValue()

template<typename OutputType>

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

inlineoverridevirtual

tag values getters