TaggingInterface Class Reference

#include <TaggingInterface.h>

Inheritance diagram for TaggingInterface:

Classes
class	MatrixTagsKey
	Class that is used as a parameter to some of our matrix tag APIs that allows only blessed framework classes to call them. More...
class	VectorTagsKey
	Class that is used as a parameter to some of our vector tag APIs that allows only blessed framework classes to call them. More...

Public Types
enum	ResidualTagType { ResidualTagType::NonReference, ResidualTagType::Reference }
	Enumerate whether a (residual) vector tag is to be of a non-reference or reference tag type. More...

Public Member Functions
	TaggingInterface (const MooseObject *moose_object)
virtual	~TaggingInterface ()
void	useVectorTag (const TagName &tag_name, VectorTagsKey)
void	useMatrixTag (const TagName &tag_name, MatrixTagsKey)
void	useVectorTag (TagID tag_id, VectorTagsKey)
void	useMatrixTag (TagID tag_id, MatrixTagsKey)
bool	isVectorTagged ()
bool	isMatrixTagged ()
bool	hasVectorTags () const
const std::set< TagID > &	getVectorTags (VectorTagsKey) const
const std::set< TagID > &	getMatrixTags (MatrixTagsKey) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
void	prepareVectorTag (Assembly &assembly, unsigned int ivar)
	Prepare data for computing element residual according to active tags. More...
void	prepareVectorTag (Assembly &assembly, unsigned int ivar, ResidualTagType tag_type)
	Prepare vector tags in a reference residual problem context. More...
void	prepareVectorTagNeighbor (Assembly &assembly, unsigned int ivar)
	Prepare data for computing element residual the according to active tags for DG and interface kernels. More...
void	prepareVectorTagLower (Assembly &assembly, unsigned int ivar)
	Prepare data for computing the residual according to active tags for mortar constraints. More...
void	prepareMatrixTag (Assembly &assembly, unsigned int ivar, unsigned int jvar)
	Prepare data for computing element jacobian according to the active tags. More...
void	prepareMatrixTag (Assembly &assembly, unsigned int ivar, unsigned int jvar, DenseMatrix< Number > &k) const
void	prepareMatrixTagNonlocal (Assembly &assembly, unsigned int ivar, unsigned int jvar)
	Prepare data for computing nonlocal element jacobian according to the active tags. More...
void	prepareMatrixTagNeighbor (Assembly &assembly, unsigned int ivar, unsigned int jvar, Moose::DGJacobianType type)
	Prepare data for computing element jacobian according to the active tags for DG and interface kernels. More...
void	prepareMatrixTagNeighbor (Assembly &assembly, unsigned int ivar, unsigned int jvar, Moose::DGJacobianType type, DenseMatrix< Number > &k) const
void	prepareMatrixTagLower (Assembly &assembly, unsigned int ivar, unsigned int jvar, Moose::ConstraintJacobianType type)
	Prepare data for computing the jacobian according to the active tags for mortar. More...
void	accumulateTaggedLocalResidual ()
	Local residual blocks will be appended by adding the current local kernel residual. More...
void	assignTaggedLocalResidual ()
	Local residual blocks will assigned as the current local kernel residual. More...
void	accumulateTaggedLocalMatrix ()
	Local Jacobian blocks will be appended by adding the current local kernel Jacobian. More...
void	accumulateTaggedLocalMatrix (Assembly &assembly, unsigned int ivar, unsigned int jvar, const DenseMatrix< Number > &k)
void	accumulateTaggedLocalMatrix (Assembly &assembly, unsigned int ivar, unsigned int jvar, Moose::DGJacobianType type, const DenseMatrix< Number > &k)
void	accumulateTaggedNonlocalMatrix ()
	Nonlocal Jacobian blocks will be appended by adding the current nonlocal kernel Jacobian. More...
void	assignTaggedLocalMatrix ()
	Local Jacobian blocks will assigned as the current local kernel Jacobian. More...
template<typename Residuals , typename Indices >
void	addResiduals (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)
	Add the provided incoming residuals corresponding to the provided dof indices. More...
template<typename T , typename Indices >
void	addResiduals (Assembly &assembly, const DenseVector< T > &residuals, const Indices &dof_indices, Real scaling_factor)
	Add the provided incoming residuals corresponding to the provided dof indices. More...
template<typename Residuals , typename Indices >
void	addResidualsAndJacobian (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)
	Add the provided incoming residuals and derivatives for the Jacobian, corresponding to the provided dof indices. More...
template<typename Residuals , typename Indices >
void	addJacobian (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)
	Add the provided residual derivatives into the Jacobian for the provided dof indices. More...
template<typename Residuals , typename Indices >
void	addResidualsWithoutConstraints (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)
	Add the provided incoming residuals corresponding to the provided dof indices. More...
template<typename Residuals , typename Indices >
void	addResidualsAndJacobianWithoutConstraints (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)
	Add the provided incoming residuals and derivatives for the Jacobian, corresponding to the provided dof indices. More...
template<typename Residuals , typename Indices >
void	addJacobianWithoutConstraints (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)
	Add the provided residual derivatives into the Jacobian for the provided dof indices. More...
void	addJacobianElement (Assembly &assembly, Real value, dof_id_type row_index, dof_id_type column_index, Real scaling_factor)
	Add into a single Jacobian element. More...
void	addJacobian (Assembly &assembly, DenseMatrix< Real > &local_k, const std::vector< dof_id_type > &row_indices, const std::vector< dof_id_type > &column_indices, Real scaling_factor)
	Add a local Jacobian matrix. More...
template<typename T >
void	setResidual (SystemBase &sys, const T &residual, MooseVariableFE< T > &var)
	Set residual using the variables' insertion API. More...
void	setResidual (SystemBase &sys, Real residual, dof_id_type dof_index)
	Set residual at a specified degree of freedom index. More...
template<typename SetResidualFunctor >
void	setResidual (SystemBase &sys, SetResidualFunctor set_residual_functor)
	Set residuals using the provided functor. More...

Protected Attributes
SubProblem &	_subproblem
	SubProblem that contains tag info. More...
DenseVector< Number >	_local_re
	Holds local residual entries as they are accumulated by this Kernel. More...
DenseMatrix< Number >	_local_ke
	Holds local Jacobian entries as they are accumulated by this Kernel. More...
DenseMatrix< Number >	_nonlocal_ke
	Holds nonlocal Jacobian entries as they are accumulated by this Kernel. More...

Private Member Functions
void	prepareVectorTagInternal (Assembly &assembly, unsigned int ivar, const std::set< TagID > &vector_tags, const std::set< TagID > &absolute_value_vector_tags)
	Prepare data for computing element residual according to the specified tags Residual blocks for different tags will be extracted from Assembly. More...

Private Attributes
std::set< TagID >	_vector_tags
	The residual tag ids this Kernel will contribute to. More...
std::set< TagID >	_abs_vector_tags
	The absolute value residual tag ids. More...
std::set< TagID >	_matrix_tags
	The matrices this Kernel will contribute to. More...
std::set< TagID >	_non_ref_vector_tags
	A set to hold vector tags excluding the reference residual tag. More...
std::set< TagID >	_non_ref_abs_vector_tags
	A set to hold absolute value vector tags excluding the reference residual tag. More...
std::set< TagID >	_ref_vector_tags
	A set of either size 1 or 0. More...
std::set< TagID >	_ref_abs_vector_tags
	A set of either size 1 or 0. More...
const MooseObject &	_moose_object
	Moose objct this tag works on. More...
const InputParameters &	_tag_params
	Parameters from moose object. More...
std::vector< DenseVector< Number > * >	_re_blocks
	Residual blocks Vectors For each Tag. More...
std::vector< DenseVector< Number > * >	_absre_blocks
	Residual blocks for absolute value residual tags. More...
std::vector< DenseMatrix< Number > * >	_ke_blocks
	Kernel blocks Vectors For each Tag. More...
std::vector< Real >	_absolute_residuals
	A container to hold absolute values of residuals passed into addResiduals. More...

Friends
void	NonlinearSystemBase::constraintJacobians (bool)

Detailed Description

Definition at line 34 of file TaggingInterface.h.

Member Enumeration Documentation

ResidualTagType

enum TaggingInterface::ResidualTagType

strong

Enumerate whether a (residual) vector tag is to be of a non-reference or reference tag type.

Enumerator
NonReference
Reference

Definition at line 75 of file TaggingInterface.h.

  {
    NonReference,
    Reference
  };

Constructor & Destructor Documentation

TaggingInterface()

TaggingInterface::TaggingInterface

(

const MooseObject *

moose_object

)

Definition at line 54 of file TaggingInterface.C.

  : _subproblem(*moose_object->parameters().getCheckedPointerParam<SubProblem *>("_subproblem")),
    _moose_object(*moose_object),
    _tag_params(_moose_object.parameters())
{
  auto & vector_tag_names = _tag_params.get<MultiMooseEnum>("vector_tags");

  if (!vector_tag_names.isValid())
  {
    if (!_tag_params.get<bool>("matrix_only"))
      mooseError("MUST provide at least one vector_tag for Kernel: ", _moose_object.name());
  }
  else
  {
    for (auto & vector_tag_name : vector_tag_names)
    {
      const TagID vector_tag_id = _subproblem.getVectorTagID(vector_tag_name.name());
      if (_subproblem.vectorTagType(vector_tag_id) != Moose::VECTOR_TAG_RESIDUAL)
        mooseError("Vector tag '",
                   vector_tag_name.name(),
                   "' for Kernel '",
                   _moose_object.name(),
                   "' is not a residual vector tag");
      _vector_tags.insert(vector_tag_id);
    }
  }

  // Add extra vector tags. These tags should be created in the System already, otherwise
  // we can not add the extra tags
  auto & extra_vector_tags = _tag_params.get<std::vector<TagName>>("extra_vector_tags");

  for (auto & vector_tag_name : extra_vector_tags)
  {
    const TagID vector_tag_id = _subproblem.getVectorTagID(vector_tag_name);
    if (_subproblem.vectorTagType(vector_tag_id) != Moose::VECTOR_TAG_RESIDUAL)
      mooseError("Extra vector tag '",
                 vector_tag_name,
                 "' for Kernel '",
                 _moose_object.name(),
                 "' is not a residual vector tag");
    _vector_tags.insert(vector_tag_id);
  }

  // Add absolue value vector tags. These tags should be created in the System already, otherwise
  // we can not add the extra tags
  auto & abs_vector_tags = _tag_params.get<std::vector<TagName>>("absolute_value_vector_tags");

  for (auto & vector_tag_name : abs_vector_tags)
  {
    const TagID vector_tag_id = _subproblem.getVectorTagID(vector_tag_name);
    if (_subproblem.vectorTagType(vector_tag_id) != Moose::VECTOR_TAG_RESIDUAL)
      mooseError("Absolute value vector tag '",
                 vector_tag_name,
                 "' for Kernel '",
                 _moose_object.name(),
                 "' is not a residual vector tag");
    _abs_vector_tags.insert(vector_tag_id);
  }

  auto & matrix_tag_names = _tag_params.get<MultiMooseEnum>("matrix_tags");

  if (matrix_tag_names.isValid())
    for (auto & matrix_tag_name : matrix_tag_names)
      _matrix_tags.insert(_subproblem.getMatrixTagID(matrix_tag_name.name()));

  auto & extra_matrix_tags = _tag_params.get<std::vector<TagName>>("extra_matrix_tags");

  for (auto & matrix_tag_name : extra_matrix_tags)
    _matrix_tags.insert(_subproblem.getMatrixTagID(matrix_tag_name));

  _re_blocks.resize(_vector_tags.size());
  _absre_blocks.resize(_abs_vector_tags.size());
  _ke_blocks.resize(_matrix_tags.size());

  const auto * const fe_problem =
      moose_object->parameters().getCheckedPointerParam<FEProblemBase *>("_fe_problem_base");
  if (const auto * const ref_problem = dynamic_cast<const ReferenceResidualProblem *>(fe_problem))
  {
    const auto reference_tag = ref_problem->referenceVectorTagID({});
    auto create_tags_split =
        [reference_tag](const auto & tags, auto & non_ref_tags, auto & ref_tags)
    {
      for (const auto tag : tags)
        if (tag == reference_tag)
          ref_tags.insert(tag);
        else
          non_ref_tags.insert(tag);
    };
    create_tags_split(_vector_tags, _non_ref_vector_tags, _ref_vector_tags);
    create_tags_split(_abs_vector_tags, _non_ref_abs_vector_tags, _ref_abs_vector_tags);
  }
  else
  {
    _non_ref_vector_tags = _vector_tags;
    _non_ref_abs_vector_tags = _abs_vector_tags;
  }
}

~TaggingInterface()

TaggingInterface::~TaggingInterface ( )

virtual

Definition at line 436 of file TaggingInterface.C.

{}

Member Function Documentation

accumulateTaggedLocalMatrix() [1/3]

void TaggingInterface::accumulateTaggedLocalMatrix ( )

protected

Local Jacobian blocks will be appended by adding the current local kernel Jacobian.

It should be called after the local element matrix has been computed.

Definition at line 380 of file TaggingInterface.C.

Referenced by DGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), MassLumpedTimeDerivative::computeJacobian(), TimeDerivative::computeJacobian(), VectorTimeDerivative::computeJacobian(), ScalarKernel::computeJacobian(), Kernel::computeJacobian(), ODEKernel::computeJacobian(), VectorKernel::computeJacobian(), ArrayKernel::computeJacobian(), IntegratedBC::computeJacobian(), VectorIntegratedBC::computeJacobian(), EigenKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), NonlocalIntegratedBC::computeJacobian(), KernelGrad::computeJacobian(), KernelValue::computeJacobian(), NonlocalKernel::computeJacobian(), MortarConstraint::computeJacobian(), NodeElemConstraint::computeJacobian(), NodeFaceConstraint::computeJacobian(), LowerDIntegratedBC::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDJacobian(), DGLowerDKernel::computeLowerDJacobian(), ArrayDGLowerDKernel::computeLowerDJacobian(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), Kernel::computeOffDiagJacobian(), VectorKernel::computeOffDiagJacobian(), EigenKernel::computeOffDiagJacobian(), ArrayKernel::computeOffDiagJacobian(), VectorIntegratedBC::computeOffDiagJacobian(), IntegratedBC::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), NonlocalKernel::computeOffDiagJacobian(), NonlocalIntegratedBC::computeOffDiagJacobian(), KernelGrad::computeOffDiagJacobian(), KernelValue::computeOffDiagJacobian(), NodeElemConstraint::computeOffDiagJacobian(), NodeFaceConstraint::computeOffDiagJacobian(), ODEKernel::computeOffDiagJacobianScalar(), VectorKernel::computeOffDiagJacobianScalar(), ArrayKernel::computeOffDiagJacobianScalar(), IntegratedBC::computeOffDiagJacobianScalar(), VectorIntegratedBC::computeOffDiagJacobianScalar(), Kernel::computeOffDiagJacobianScalar(), ArrayIntegratedBC::computeOffDiagJacobianScalar(), ScalarLagrangeMultiplier::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), and ConservativeAdvection::fullUpwind().

{
  for (auto & ke : _ke_blocks)
    *ke += _local_ke;
}

accumulateTaggedLocalMatrix() [2/3]

void TaggingInterface::accumulateTaggedLocalMatrix ( Assembly &  assembly, unsigned int  ivar, unsigned int  jvar, const DenseMatrix< Number > &  k  )

protected

Definition at line 387 of file TaggingInterface.C.

{
  _ke_blocks.resize(_matrix_tags.size());
  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
  auto mat_vector = _matrix_tags.begin();
  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
    _ke_blocks[i] = &assembly.jacobianBlock(ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
  mooseAssert(_ke_blocks[0]->m() == k.m() && _ke_blocks[0]->n() == k.n(),
              "Passed-in k must match the blocks we are about to sum into");
  for (auto & ke : _ke_blocks)
    *ke += k;
}

accumulateTaggedLocalMatrix() [3/3]

void TaggingInterface::accumulateTaggedLocalMatrix ( Assembly &  assembly, unsigned int  ivar, unsigned int  jvar, Moose::DGJacobianType  type, const DenseMatrix< Number > &  k  )

protected

Definition at line 404 of file TaggingInterface.C.

{
  _ke_blocks.resize(_matrix_tags.size());
  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
  auto mat_vector = _matrix_tags.begin();
  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
    _ke_blocks[i] =
        &assembly.jacobianBlockNeighbor(type, ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
  mooseAssert(_ke_blocks[0]->m() == k.m() && _ke_blocks[0]->n() == k.n(),
              "Passed-in k must match the blocks we are about to sum into");
  for (auto & ke : _ke_blocks)
    *ke += k;
}

accumulateTaggedLocalResidual()

void TaggingInterface::accumulateTaggedLocalResidual ( )

protected

Local residual blocks will be appended by adding the current local kernel residual.

It should be called after the local element vector has been computed.

Definition at line 360 of file TaggingInterface.C.

Referenced by FVInterfaceKernel::addResidual(), ADDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), DGLowerDKernel::computeLowerDResidual(), ArrayDGLowerDKernel::computeLowerDResidual(), ScalarKernel::computeResidual(), Kernel::computeResidual(), VectorKernel::computeResidual(), ArrayKernel::computeResidual(), LowerDIntegratedBC::computeResidual(), ODETimeKernel::computeResidual(), ODEKernel::computeResidual(), TimeKernel::computeResidual(), ADScalarKernel::computeResidual(), VectorTimeKernel::computeResidual(), VectorIntegratedBC::computeResidual(), IntegratedBC::computeResidual(), ArrayLowerDIntegratedBC::computeResidual(), ArrayIntegratedBC::computeResidual(), EigenKernel::computeResidual(), ADMortarConstraint::computeResidual(), FVFluxBC::computeResidual(), FVBoundaryScalarLagrangeMultiplierConstraint::computeResidual(), FVScalarLagrangeMultiplierConstraint::computeResidual(), MortarConstraint::computeResidual(), KernelGrad::computeResidual(), KernelValue::computeResidual(), FVElementalKernel::computeResidual(), NodeElemConstraint::computeResidual(), FVFluxKernel::computeResidual(), NodeFaceConstraint::computeResidual(), and ConservativeAdvection::fullUpwind().

{
  for (auto & re : _re_blocks)
    *re += _local_re;
  for (auto & absre : _absre_blocks)
    for (const auto i : index_range(_local_re))
      (*absre)(i) += std::abs(_local_re(i));
}

accumulateTaggedNonlocalMatrix()

void TaggingInterface::accumulateTaggedNonlocalMatrix ( )

protected

Nonlocal Jacobian blocks will be appended by adding the current nonlocal kernel Jacobian.

It should be called after the nonlocal element matrix has been computed.

Definition at line 423 of file TaggingInterface.C.

Referenced by NonlocalIntegratedBC::computeNonlocalJacobian(), NonlocalKernel::computeNonlocalJacobian(), NonlocalKernel::computeNonlocalOffDiagJacobian(), and NonlocalIntegratedBC::computeNonlocalOffDiagJacobian().

{
  for (auto & ke : _ke_blocks)
    *ke += _nonlocal_ke;
}

addJacobian() [1/2]

template<typename Residuals , typename Indices >

void TaggingInterface::addJacobian ( Assembly &  assembly, const Residuals &  residuals, const Indices &  dof_indices, Real  scaling_factor  )

protected

Add the provided residual derivatives into the Jacobian for the provided dof indices.

Definition at line 483 of file TaggingInterface.h.

Referenced by addResidualsAndJacobian(), ADScalarKernel::computeADJacobian(), ADDGKernel::computeElemNeighJacobian(), FVElementalKernel::computeJacobian(), ADNodalKernel::computeJacobian(), NodalConstraint::computeJacobian(), ADDGKernel::computeOffDiagElemNeighJacobian(), FVScalarLagrangeMultiplierConstraint::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), KernelScalarBase::computeOffDiagJacobianScalarLocal(), MortarScalarBase::computeScalarJacobian(), KernelScalarBase::computeScalarJacobian(), MortarScalarBase::computeScalarOffDiagJacobian(), KernelScalarBase::computeScalarOffDiagJacobian(), KernelScalarBase::computeScalarOffDiagJacobianScalar(), and MortarScalarBase::computeScalarOffDiagJacobianScalar().

{
  assembly.cacheJacobian(
      residuals, dof_indices, scaling_factor, Assembly::LocalDataKey{}, _matrix_tags);
}

addJacobian() [2/2]

void TaggingInterface::addJacobian ( Assembly &  assembly, DenseMatrix< Real > &  local_k, const std::vector< dof_id_type > &  row_indices, const std::vector< dof_id_type > &  column_indices, Real  scaling_factor  )

inlineprotected

Add a local Jacobian matrix.

Definition at line 526 of file TaggingInterface.h.

{
  for (const auto matrix_tag : _matrix_tags)
    assembly.cacheJacobianBlock(
        local_k, row_indices, column_indices, scaling_factor, Assembly::LocalDataKey{}, matrix_tag);
}

addJacobianElement()

void TaggingInterface::addJacobianElement ( Assembly &  assembly, Real  value, dof_id_type  row_index, dof_id_type  column_index, Real  scaling_factor  )

inlineprotected

Add into a single Jacobian element.

Definition at line 515 of file TaggingInterface.h.

Referenced by ArrayNodalBC::computeJacobian(), VectorNodalBC::computeJacobian(), NodalBC::computeJacobian(), NodalKernel::computeJacobian(), NodalConstraint::computeJacobian(), ArrayNodalBC::computeOffDiagJacobian(), VectorNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), NodalKernel::computeOffDiagJacobian(), and MortarConstraintBase::zeroInactiveLMDofs().

{
  assembly.cacheJacobian(
      row_index, column_index, value * scaling_factor, Assembly::LocalDataKey{}, _matrix_tags);
}

addJacobianWithoutConstraints()

template<typename Residuals , typename Indices >

void TaggingInterface::addJacobianWithoutConstraints ( Assembly &  assembly, const Residuals &  residuals, const Indices &  dof_indices, Real  scaling_factor  )

protected

Add the provided residual derivatives into the Jacobian for the provided dof indices.

This API should only be used if the caller knows that no libMesh-level constraints (hanging nodes or periodic boundary conditions) apply to the provided dof indices

Definition at line 505 of file TaggingInterface.h.

Referenced by addResidualsAndJacobianWithoutConstraints().

{
  assembly.cacheJacobianWithoutConstraints(
      residuals, dof_indices, scaling_factor, Assembly::LocalDataKey{}, _matrix_tags);
}

addResiduals() [1/2]

template<typename Residuals , typename Indices >

void TaggingInterface::addResiduals ( Assembly &  assembly, const Residuals &  residuals, const Indices &  dof_indices, Real  scaling_factor  )

protected

Add the provided incoming residuals corresponding to the provided dof indices.

Definition at line 416 of file TaggingInterface.h.

Referenced by addResiduals(), addResidualsAndJacobian(), FVScalarLagrangeMultiplierInterface::computeResidual(), TimeNodalKernel::computeResidual(), FVScalarLagrangeMultiplierConstraint::computeResidual(), FVBoundaryScalarLagrangeMultiplierConstraint::computeResidual(), NodalKernel::computeResidual(), ADNodalKernel::computeResidual(), ADKernelScalarBase::computeResidual(), NodalConstraint::computeResidual(), ADMortarScalarBase::computeResidual(), MortarScalarBase::computeResidual(), KernelScalarBase::computeScalarResidual(), and MortarConstraintBase::zeroInactiveLMDofs().

{
  assembly.cacheResiduals(
      residuals, dof_indices, scaling_factor, Assembly::LocalDataKey{}, _vector_tags);
  if (!_abs_vector_tags.empty())
  {
    _absolute_residuals.resize(residuals.size());
    for (const auto i : index_range(residuals))
      _absolute_residuals[i] = std::abs(MetaPhysicL::raw_value(residuals[i]));

    assembly.cacheResiduals(_absolute_residuals,
                            dof_indices,
                            scaling_factor,
                            Assembly::LocalDataKey{},
                            _abs_vector_tags);
  }
}

addResiduals() [2/2]

template<typename T , typename Indices >

void TaggingInterface::addResiduals ( Assembly &  assembly, const DenseVector< T > &  residuals, const Indices &  dof_indices, Real  scaling_factor  )

protected

Add the provided incoming residuals corresponding to the provided dof indices.

Definition at line 439 of file TaggingInterface.h.

{
  addResiduals(assembly, residuals.get_values(), dof_indices, scaling_factor);
}

addResidualsAndJacobian()

template<typename Residuals , typename Indices >

void TaggingInterface::addResidualsAndJacobian ( Assembly &  assembly, const Residuals &  residuals, const Indices &  dof_indices, Real  scaling_factor  )

protected

Add the provided incoming residuals and derivatives for the Jacobian, corresponding to the provided dof indices.

Definition at line 472 of file TaggingInterface.h.

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

{
  addResiduals(assembly, residuals, dof_indices, scaling_factor);
  addJacobian(assembly, residuals, dof_indices, scaling_factor);
}

addResidualsAndJacobianWithoutConstraints()

template<typename Residuals , typename Indices >

void TaggingInterface::addResidualsAndJacobianWithoutConstraints ( Assembly &  assembly, const Residuals &  residuals, const Indices &  dof_indices, Real  scaling_factor  )

protected

Add the provided incoming residuals and derivatives for the Jacobian, corresponding to the provided dof indices.

This API should only be used if the caller knows that no libMesh-level constraints (hanging nodes or periodic boundary conditions) apply to the provided dof indices

Definition at line 494 of file TaggingInterface.h.

Referenced by ADMortarConstraint::computeJacobian(), and ADMortarScalarBase::computeJacobian().

{
  addResidualsWithoutConstraints(assembly, residuals, dof_indices, scaling_factor);
  addJacobianWithoutConstraints(assembly, residuals, dof_indices, scaling_factor);
}

addResidualsWithoutConstraints()

template<typename Residuals , typename Indices >

void TaggingInterface::addResidualsWithoutConstraints ( Assembly &  assembly, const Residuals &  residuals, const Indices &  dof_indices, Real  scaling_factor  )

protected

Add the provided incoming residuals corresponding to the provided dof indices.

This API should only be used if the caller knows that no libMesh-level constraints (hanging nodes or periodic boundary conditions) apply to the provided dof indices

Definition at line 449 of file TaggingInterface.h.

Referenced by addResidualsAndJacobianWithoutConstraints().

{
  assembly.cacheResidualsWithoutConstraints(
      residuals, dof_indices, scaling_factor, Assembly::LocalDataKey{}, _vector_tags);
  if (!_abs_vector_tags.empty())
  {
    _absolute_residuals.resize(residuals.size());
    for (const auto i : index_range(residuals))
      _absolute_residuals[i] = std::abs(MetaPhysicL::raw_value(residuals[i]));

    assembly.cacheResidualsWithoutConstraints(_absolute_residuals,
                                              dof_indices,
                                              scaling_factor,
                                              Assembly::LocalDataKey{},
                                              _abs_vector_tags);
  }
}

assignTaggedLocalMatrix()

void TaggingInterface::assignTaggedLocalMatrix ( )

protected

Local Jacobian blocks will assigned as the current local kernel Jacobian.

It should be called after the local element matrix has been computed.

Definition at line 430 of file TaggingInterface.C.

Referenced by NodalEqualValueConstraint::computeJacobian().

{
  for (auto & ke : _ke_blocks)
    *ke = _local_ke;
}

assignTaggedLocalResidual()

void TaggingInterface::assignTaggedLocalResidual ( )

protected

Local residual blocks will assigned as the current local kernel residual.

It should be called after the local element vector has been computed.

Definition at line 370 of file TaggingInterface.C.

Referenced by NodalEqualValueConstraint::computeResidual(), and NodeFaceConstraint::computeResidual().

{
  for (auto & re : _re_blocks)
    *re = _local_re;
  for (auto & absre : _absre_blocks)
    for (const auto i : index_range(_local_re))
      (*absre)(i) = std::abs(_local_re(i));
}

getMatrixTags()

const std::set<TagID>& TaggingInterface::getMatrixTags ( MatrixTagsKey  ) const

inline

Definition at line 97 of file TaggingInterface.h.

{ return _matrix_tags; }

getVectorTags()

const std::set<TagID>& TaggingInterface::getVectorTags ( VectorTagsKey  ) const

inline

Definition at line 95 of file TaggingInterface.h.

{ return _vector_tags; }

hasVectorTags()

bool TaggingInterface::hasVectorTags ( ) const

inline

Definition at line 93 of file TaggingInterface.h.

Referenced by Kernel::computeResidual().

{ return !_vector_tags.empty(); }

isMatrixTagged()

bool TaggingInterface::isMatrixTagged ( )

inline

Definition at line 91 of file TaggingInterface.h.

{ return _matrix_tags.size() > 0; }

isVectorTagged()

bool TaggingInterface::isVectorTagged ( )

inline

Definition at line 89 of file TaggingInterface.h.

{ return _vector_tags.size() > 0; }

prepareMatrixTag() [1/2]

void TaggingInterface::prepareMatrixTag ( Assembly &  assembly, unsigned int  ivar, unsigned int  jvar  )

protected

Prepare data for computing element jacobian according to the active tags.

Jacobian blocks for different tags will be extracted from Assembly. A local Jacobian will be zeroed. It should be called right before the local element matrix is computed.

Definition at line 276 of file TaggingInterface.C.

Referenced by DGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), VectorTimeDerivative::computeJacobian(), ScalarKernel::computeJacobian(), TimeDerivative::computeJacobian(), MassLumpedTimeDerivative::computeJacobian(), Kernel::computeJacobian(), VectorKernel::computeJacobian(), ODEKernel::computeJacobian(), ArrayKernel::computeJacobian(), VectorIntegratedBC::computeJacobian(), IntegratedBC::computeJacobian(), ArrayIntegratedBC::computeJacobian(), EigenKernel::computeJacobian(), NodalEqualValueConstraint::computeJacobian(), NonlocalIntegratedBC::computeJacobian(), KernelGrad::computeJacobian(), KernelValue::computeJacobian(), NonlocalKernel::computeJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), VectorKernel::computeOffDiagJacobian(), Kernel::computeOffDiagJacobian(), ArrayKernel::computeOffDiagJacobian(), EigenKernel::computeOffDiagJacobian(), VectorIntegratedBC::computeOffDiagJacobian(), IntegratedBC::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), NonlocalIntegratedBC::computeOffDiagJacobian(), NonlocalKernel::computeOffDiagJacobian(), KernelValue::computeOffDiagJacobian(), KernelGrad::computeOffDiagJacobian(), ODEKernel::computeOffDiagJacobianScalar(), VectorKernel::computeOffDiagJacobianScalar(), ArrayKernel::computeOffDiagJacobianScalar(), VectorIntegratedBC::computeOffDiagJacobianScalar(), IntegratedBC::computeOffDiagJacobianScalar(), Kernel::computeOffDiagJacobianScalar(), ArrayIntegratedBC::computeOffDiagJacobianScalar(), ScalarLagrangeMultiplier::computeOffDiagJacobianScalar(), and ConservativeAdvection::fullUpwind().

{
  _ke_blocks.resize(_matrix_tags.size());
  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
  auto mat_vector = _matrix_tags.begin();
  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
    _ke_blocks[i] = &assembly.jacobianBlock(ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);

  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
}

prepareMatrixTag() [2/2]

void TaggingInterface::prepareMatrixTag ( Assembly &  assembly, unsigned int  ivar, unsigned int  jvar, DenseMatrix< Number > &  k  ) const

protected

Definition at line 288 of file TaggingInterface.C.

{
  mooseAssert(!_matrix_tags.empty(), "No matrix tags exist");
  const auto & ij_mat =
      assembly.jacobianBlock(ivar, jvar, Assembly::LocalDataKey{}, *_matrix_tags.begin());
  k.resize(ij_mat.m(), ij_mat.n());
}

prepareMatrixTagLower()

void TaggingInterface::prepareMatrixTagLower ( Assembly &  assembly, unsigned int  ivar, unsigned int  jvar, Moose::ConstraintJacobianType  type  )

protected

Prepare data for computing the jacobian according to the active tags for mortar.

Jacobian blocks for different tags will be extracted from Assembly. A local Jacobian will be zeroed. It should be called right before the local element matrix is computed.

Definition at line 344 of file TaggingInterface.C.

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

{
  _ke_blocks.resize(_matrix_tags.size());
  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
  auto mat_vector = _matrix_tags.begin();
  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
    _ke_blocks[i] =
        &assembly.jacobianBlockMortar(type, ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);

  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
}

prepareMatrixTagNeighbor() [1/2]

void TaggingInterface::prepareMatrixTagNeighbor ( Assembly &  assembly, unsigned int  ivar, unsigned int  jvar, Moose::DGJacobianType  type  )

protected

Prepare data for computing element jacobian according to the active tags for DG and interface kernels.

Jacobian blocks for different tags will be extracted from Assembly. A local Jacobian will be zeroed. It should be called right before the local element matrix is computed.

Definition at line 315 of file TaggingInterface.C.

Referenced by DGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), NodeElemConstraint::computeJacobian(), NodeFaceConstraint::computeJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), NodeElemConstraint::computeOffDiagJacobian(), and NodeFaceConstraint::computeOffDiagJacobian().

{
  _ke_blocks.resize(_matrix_tags.size());
  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
  auto mat_vector = _matrix_tags.begin();
  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
    _ke_blocks[i] =
        &assembly.jacobianBlockNeighbor(type, ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);

  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
}

prepareMatrixTagNeighbor() [2/2]

void TaggingInterface::prepareMatrixTagNeighbor ( Assembly &  assembly, unsigned int  ivar, unsigned int  jvar, Moose::DGJacobianType  type, DenseMatrix< Number > &  k  ) const

protected

Definition at line 331 of file TaggingInterface.C.

{
  mooseAssert(!_matrix_tags.empty(), "No matrix tags exist");
  const auto & ij_mat = assembly.jacobianBlockNeighbor(
      type, ivar, jvar, Assembly::LocalDataKey{}, *_matrix_tags.begin());
  k.resize(ij_mat.m(), ij_mat.n());
}

prepareMatrixTagNonlocal()

void TaggingInterface::prepareMatrixTagNonlocal ( Assembly &  assembly, unsigned int  ivar, unsigned int  jvar  )

protected

Prepare data for computing nonlocal element jacobian according to the active tags.

Jacobian blocks for different tags will be extracted from Assembly. A nonlocal Jacobian will be zeroed. It should be called right before the nonlocal element matrix is computed.

Definition at line 300 of file TaggingInterface.C.

Referenced by NonlocalIntegratedBC::computeNonlocalJacobian(), NonlocalKernel::computeNonlocalJacobian(), NonlocalKernel::computeNonlocalOffDiagJacobian(), and NonlocalIntegratedBC::computeNonlocalOffDiagJacobian().

{
  _ke_blocks.resize(_matrix_tags.size());
  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
  auto mat_vector = _matrix_tags.begin();
  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
    _ke_blocks[i] =
        &assembly.jacobianBlockNonlocal(ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);

  _nonlocal_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
}

prepareVectorTag() [1/2]

void TaggingInterface::prepareVectorTag ( Assembly &  assembly, unsigned int  ivar  )

protected

Prepare data for computing element residual according to active tags.

Residual blocks for different tags will be extracted from Assembly. A local residual will be zeroed. It should be called right before the local element vector is computed.

Definition at line 189 of file TaggingInterface.C.

Referenced by FVInterfaceKernel::addResidual(), ADDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), ScalarKernel::computeResidual(), Kernel::computeResidual(), VectorKernel::computeResidual(), ArrayKernel::computeResidual(), TimeKernel::computeResidual(), ODETimeKernel::computeResidual(), ODEKernel::computeResidual(), ADScalarKernel::computeResidual(), VectorTimeKernel::computeResidual(), IntegratedBC::computeResidual(), VectorIntegratedBC::computeResidual(), EigenKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), NodalEqualValueConstraint::computeResidual(), ADMortarConstraint::computeResidual(), FVScalarLagrangeMultiplierConstraint::computeResidual(), FVFluxBC::computeResidual(), FVBoundaryScalarLagrangeMultiplierConstraint::computeResidual(), MortarConstraint::computeResidual(), KernelGrad::computeResidual(), KernelValue::computeResidual(), FVElementalKernel::computeResidual(), NodeElemConstraint::computeResidual(), FVFluxKernel::computeResidual(), NodeFaceConstraint::computeResidual(), and ConservativeAdvection::fullUpwind().

{
  prepareVectorTagInternal(assembly, ivar, _vector_tags, _abs_vector_tags);
}

prepareVectorTag() [2/2]

void TaggingInterface::prepareVectorTag ( Assembly &  assembly, unsigned int  ivar, ResidualTagType  tag_type  )

protected

Prepare vector tags in a reference residual problem context.

Parameters

Assembly	The assembly object that we obtain the local residual blocks from
ivar	The variable which we are retrieving the local residual blocks for
ref_problem	A pointer to a reference residual problem. This can be a nullptr
tag_type	What type of tags to prepare

Definition at line 195 of file TaggingInterface.C.

{
  if (tag_type == ResidualTagType::NonReference)
    prepareVectorTagInternal(assembly, ivar, _non_ref_vector_tags, _non_ref_abs_vector_tags);
  else
    prepareVectorTagInternal(assembly, ivar, _ref_vector_tags, _ref_abs_vector_tags);
}

prepareVectorTagInternal()

void TaggingInterface::prepareVectorTagInternal ( Assembly &  assembly, unsigned int  ivar, const std::set< TagID > &  vector_tags, const std::set< TagID > &  absolute_value_vector_tags  )

private

Prepare data for computing element residual according to the specified tags Residual blocks for different tags will be extracted from Assembly.

A local residual will be zeroed. It should be called right before the local element vector is computed.

Definition at line 206 of file TaggingInterface.C.

Referenced by prepareVectorTag().

{
  auto prepare = [this, ivar, &assembly](auto & re_blocks, const auto & tags)
  {
    re_blocks.clear();
    re_blocks.reserve(tags.size());
    for (const auto tag_id : tags)
    {
      const auto & tag = _subproblem.getVectorTag(tag_id);
      re_blocks.push_back(&assembly.residualBlock(ivar, Assembly::LocalDataKey{}, tag._type_id));
    }
  };

  prepare(_re_blocks, vector_tags);
  prepare(_absre_blocks, absolute_value_vector_tags);

  _local_re.resize(_re_blocks.empty()
                       ? (_absre_blocks.empty() ? std::size_t(0) : _absre_blocks[0]->size())
                       : _re_blocks[0]->size());
}

prepareVectorTagLower()

void TaggingInterface::prepareVectorTagLower ( Assembly &  assembly, unsigned int  ivar  )

protected

Prepare data for computing the residual according to active tags for mortar constraints.

Residual blocks for different tags will be extracted from Assembly. A local residual will be zeroed. It should be called right before the local element vector is computed.

Definition at line 254 of file TaggingInterface.C.

Referenced by DGLowerDKernel::computeLowerDResidual(), ArrayDGLowerDKernel::computeLowerDResidual(), LowerDIntegratedBC::computeResidual(), ArrayLowerDIntegratedBC::computeResidual(), ADMortarConstraint::computeResidual(), and MortarConstraint::computeResidual().

{
  _re_blocks.resize(_vector_tags.size());
  mooseAssert(_vector_tags.size() >= 1, "we need at least one active tag");
  auto vector_tag = _vector_tags.begin();
  for (MooseIndex(_vector_tags) i = 0; i < _vector_tags.size(); i++, ++vector_tag)
  {
    const VectorTag & tag = _subproblem.getVectorTag(*vector_tag);
    _re_blocks[i] = &assembly.residualBlockLower(ivar, Assembly::LocalDataKey{}, tag._type_id);
  }
  _local_re.resize(_re_blocks[0]->size());

  _absre_blocks.resize(_abs_vector_tags.size());
  vector_tag = _abs_vector_tags.begin();
  for (MooseIndex(_abs_vector_tags) i = 0; i < _abs_vector_tags.size(); i++, ++vector_tag)
  {
    const VectorTag & tag = _subproblem.getVectorTag(*vector_tag);
    _absre_blocks[i] = &assembly.residualBlockLower(ivar, Assembly::LocalDataKey{}, tag._type_id);
  }
}

prepareVectorTagNeighbor()

void TaggingInterface::prepareVectorTagNeighbor ( Assembly &  assembly, unsigned int  ivar  )

protected

Prepare data for computing element residual the according to active tags for DG and interface kernels.

Residual blocks for different tags will be extracted from Assembly. A local residual will be zeroed. It should be called right before the local element vector is computed.

Definition at line 231 of file TaggingInterface.C.

Referenced by FVInterfaceKernel::addResidual(), ADDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), ADMortarConstraint::computeResidual(), FVFluxBC::computeResidual(), MortarConstraint::computeResidual(), NodeElemConstraint::computeResidual(), FVFluxKernel::computeResidual(), and NodeFaceConstraint::computeResidual().

{
  _re_blocks.resize(_vector_tags.size());
  mooseAssert(_vector_tags.size() >= 1, "we need at least one active tag");
  auto vector_tag = _vector_tags.begin();
  for (MooseIndex(_vector_tags) i = 0; i < _vector_tags.size(); i++, ++vector_tag)
  {
    const VectorTag & tag = _subproblem.getVectorTag(*vector_tag);
    _re_blocks[i] = &assembly.residualBlockNeighbor(ivar, Assembly::LocalDataKey{}, tag._type_id);
  }
  _local_re.resize(_re_blocks[0]->size());

  _absre_blocks.resize(_abs_vector_tags.size());
  vector_tag = _abs_vector_tags.begin();
  for (MooseIndex(_abs_vector_tags) i = 0; i < _abs_vector_tags.size(); i++, ++vector_tag)
  {
    const VectorTag & tag = _subproblem.getVectorTag(*vector_tag);
    _absre_blocks[i] =
        &assembly.residualBlockNeighbor(ivar, Assembly::LocalDataKey{}, tag._type_id);
  }
}

setResidual() [1/3]

template<typename T >

void TaggingInterface::setResidual ( SystemBase &  sys, const T &  residual, MooseVariableFE< T > &  var  )

protected

Set residual using the variables' insertion API.

Definition at line 539 of file TaggingInterface.h.

Referenced by ArrayNodalBC::computeResidual(), VectorNodalBC::computeResidual(), and NodalBC::computeResidual().

{
  for (const auto tag_id : _vector_tags)
    if (sys.hasVector(tag_id))
      var.insertNodalValue(sys.getVector(tag_id), residual);
}

setResidual() [2/3]

void TaggingInterface::setResidual ( SystemBase &  sys, Real  residual, dof_id_type  dof_index  )

inlineprotected

Set residual at a specified degree of freedom index.

Definition at line 547 of file TaggingInterface.h.

{
  for (const auto tag_id : _vector_tags)
    if (sys.hasVector(tag_id))
      sys.getVector(tag_id).set(dof_index, residual);
}

setResidual() [3/3]

template<typename SetResidualFunctor >

void TaggingInterface::setResidual ( SystemBase &  sys, SetResidualFunctor  set_residual_functor  )

protected

Set residuals using the provided functor.

Definition at line 556 of file TaggingInterface.h.

{
  for (const auto tag_id : _vector_tags)
    if (sys.hasVector(tag_id))
      set_residual_functor(sys.getVector(tag_id));
}

useMatrixTag() [1/2]

void TaggingInterface::useMatrixTag	(	const TagName &	tag_name,
		MatrixTagsKey
	)

Definition at line 162 of file TaggingInterface.C.

{
  if (!_subproblem.matrixTagExists(tag_name))
    mooseError("Matrix tag ", tag_name, " does not exist in system");

  _matrix_tags.insert(_subproblem.getMatrixTagID(tag_name));
}

useMatrixTag() [2/2]

void TaggingInterface::useMatrixTag	(	TagID	tag_id,
		MatrixTagsKey
	)

Definition at line 180 of file TaggingInterface.C.

{
  if (!_subproblem.matrixTagExists(tag_id))
    mooseError("Matrix tag ", tag_id, " does not exist in system");

  _matrix_tags.insert(tag_id);
}

useVectorTag() [1/2]

void TaggingInterface::useVectorTag	(	const TagName &	tag_name,
		VectorTagsKey
	)

Definition at line 153 of file TaggingInterface.C.

{
  if (!_subproblem.vectorTagExists(tag_name))
    mooseError("Vector tag ", tag_name, " does not exist in system");

  _vector_tags.insert(_subproblem.getVectorTagID(tag_name));
}

useVectorTag() [2/2]

void TaggingInterface::useVectorTag	(	TagID	tag_id,
		VectorTagsKey
	)

Definition at line 171 of file TaggingInterface.C.

{
  if (!_subproblem.vectorTagExists(tag_id))
    mooseError("Vector tag ", tag_id, " does not exist in system");

  _vector_tags.insert(tag_id);
}

validParams()

InputParameters TaggingInterface::validParams ( )

static

Definition at line 19 of file TaggingInterface.C.

Referenced by LinearSystemContributionObject::validParams(), ResidualObject::validParams(), LinearFVBoundaryCondition::validParams(), FVBoundaryCondition::validParams(), and FVInterfaceKernel::validParams().

{

  InputParameters params = emptyInputParameters();

  // These are the default names for tags, but users will be able to add their own
  MultiMooseEnum vtags("nontime time", "nontime", true);
  MultiMooseEnum mtags("nontime system", "system", true);

  params.addPrivateParam<bool>("matrix_only", false);

  params.addParam<MultiMooseEnum>(
      "vector_tags", vtags, "The tag for the vectors this Kernel should fill");

  params.addParam<MultiMooseEnum>(
      "matrix_tags", mtags, "The tag for the matrices this Kernel should fill");

  params.addParam<std::vector<TagName>>("extra_vector_tags",
                                        "The extra tags for the vectors this Kernel should fill");

  params.addParam<std::vector<TagName>>(
      "absolute_value_vector_tags",
      "The tags for the vectors this residual object should fill with the "
      "absolute value of the residual contribution");

  params.addParam<std::vector<TagName>>("extra_matrix_tags",
                                        "The extra tags for the matrices this Kernel should fill");

  params.addParamNamesToGroup(
      "vector_tags matrix_tags extra_vector_tags extra_matrix_tags absolute_value_vector_tags",
      "Tagging");

  return params;
}

Friends And Related Function Documentation

NonlinearSystemBase::constraintJacobians

void NonlinearSystemBase::constraintJacobians ( bool  )

friend

Member Data Documentation

_abs_vector_tags

std::set<TagID> TaggingInterface::_abs_vector_tags

private

The absolute value residual tag ids.

Definition at line 356 of file TaggingInterface.h.

Referenced by addResiduals(), addResidualsWithoutConstraints(), prepareVectorTag(), prepareVectorTagLower(), prepareVectorTagNeighbor(), and TaggingInterface().

_absolute_residuals

std::vector<Real> TaggingInterface::_absolute_residuals

private

A container to hold absolute values of residuals passed into addResiduals.

We maintain this data member to avoid constant dynamic heap allocations

Definition at line 396 of file TaggingInterface.h.

Referenced by addResiduals(), and addResidualsWithoutConstraints().

_absre_blocks

std::vector<DenseVector<Number> *> TaggingInterface::_absre_blocks

private

Residual blocks for absolute value residual tags.

Definition at line 389 of file TaggingInterface.h.

Referenced by accumulateTaggedLocalResidual(), assignTaggedLocalResidual(), prepareVectorTagInternal(), prepareVectorTagLower(), prepareVectorTagNeighbor(), and TaggingInterface().

_ke_blocks

std::vector<DenseMatrix<Number> *> TaggingInterface::_ke_blocks

private

Kernel blocks Vectors For each Tag.

Definition at line 392 of file TaggingInterface.h.

Referenced by accumulateTaggedLocalMatrix(), accumulateTaggedNonlocalMatrix(), assignTaggedLocalMatrix(), prepareMatrixTag(), prepareMatrixTagLower(), prepareMatrixTagNeighbor(), prepareMatrixTagNonlocal(), and TaggingInterface().

_local_ke

DenseMatrix<Number> TaggingInterface::_local_ke

protected

Holds local Jacobian entries as they are accumulated by this Kernel.

Definition at line 335 of file TaggingInterface.h.

Referenced by accumulateTaggedLocalMatrix(), assignTaggedLocalMatrix(), ADDGKernel::computeElemNeighJacobian(), DGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), VectorTimeDerivative::computeJacobian(), ScalarKernel::computeJacobian(), MassLumpedTimeDerivative::computeJacobian(), TimeDerivative::computeJacobian(), VectorKernel::computeJacobian(), Kernel::computeJacobian(), ODEKernel::computeJacobian(), ArrayKernel::computeJacobian(), IntegratedBC::computeJacobian(), VectorIntegratedBC::computeJacobian(), EigenKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), NodalEqualValueConstraint::computeJacobian(), NonlocalIntegratedBC::computeJacobian(), KernelGrad::computeJacobian(), KernelValue::computeJacobian(), NonlocalKernel::computeJacobian(), MortarConstraint::computeJacobian(), NodeElemConstraint::computeJacobian(), NodeFaceConstraint::computeJacobian(), LowerDIntegratedBC::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDJacobian(), DGLowerDKernel::computeLowerDJacobian(), ArrayDGLowerDKernel::computeLowerDJacobian(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), Kernel::computeOffDiagJacobian(), VectorKernel::computeOffDiagJacobian(), ArrayKernel::computeOffDiagJacobian(), EigenKernel::computeOffDiagJacobian(), VectorIntegratedBC::computeOffDiagJacobian(), IntegratedBC::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), NonlocalKernel::computeOffDiagJacobian(), NonlocalIntegratedBC::computeOffDiagJacobian(), KernelValue::computeOffDiagJacobian(), KernelGrad::computeOffDiagJacobian(), NodeElemConstraint::computeOffDiagJacobian(), NodeFaceConstraint::computeOffDiagJacobian(), ODEKernel::computeOffDiagJacobianScalar(), VectorKernel::computeOffDiagJacobianScalar(), ArrayKernel::computeOffDiagJacobianScalar(), IntegratedBC::computeOffDiagJacobianScalar(), VectorIntegratedBC::computeOffDiagJacobianScalar(), Kernel::computeOffDiagJacobianScalar(), ArrayIntegratedBC::computeOffDiagJacobianScalar(), ScalarLagrangeMultiplier::computeOffDiagJacobianScalar(), MortarScalarBase::computeOffDiagJacobianScalar(), KernelScalarBase::computeOffDiagJacobianScalarLocal(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MortarScalarBase::computeScalarJacobian(), KernelScalarBase::computeScalarJacobian(), MortarScalarBase::computeScalarOffDiagJacobian(), KernelScalarBase::computeScalarOffDiagJacobian(), KernelScalarBase::computeScalarOffDiagJacobianScalar(), MortarScalarBase::computeScalarOffDiagJacobianScalar(), ConservativeAdvection::fullUpwind(), prepareMatrixTag(), prepareMatrixTagLower(), and prepareMatrixTagNeighbor().

_local_re

DenseVector<Number> TaggingInterface::_local_re

protected

Holds local residual entries as they are accumulated by this Kernel.

Definition at line 332 of file TaggingInterface.h.

Referenced by accumulateTaggedLocalResidual(), FVInterfaceKernel::addResidual(), assignTaggedLocalResidual(), ADDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), DGLowerDKernel::computeLowerDResidual(), ArrayDGLowerDKernel::computeLowerDResidual(), ScalarKernel::computeResidual(), VectorKernel::computeResidual(), Kernel::computeResidual(), LowerDIntegratedBC::computeResidual(), ArrayKernel::computeResidual(), TimeKernel::computeResidual(), ODEKernel::computeResidual(), ODETimeKernel::computeResidual(), VectorTimeKernel::computeResidual(), ADScalarKernel::computeResidual(), ArrayLowerDIntegratedBC::computeResidual(), VectorIntegratedBC::computeResidual(), IntegratedBC::computeResidual(), ArrayIntegratedBC::computeResidual(), EigenKernel::computeResidual(), NodalEqualValueConstraint::computeResidual(), ADMortarConstraint::computeResidual(), FVBoundaryScalarLagrangeMultiplierConstraint::computeResidual(), FVScalarLagrangeMultiplierConstraint::computeResidual(), FVFluxBC::computeResidual(), MortarConstraint::computeResidual(), KernelGrad::computeResidual(), KernelValue::computeResidual(), FVElementalKernel::computeResidual(), NodeElemConstraint::computeResidual(), FVFluxKernel::computeResidual(), NodeFaceConstraint::computeResidual(), ConservativeAdvection::fullUpwind(), prepareVectorTagInternal(), prepareVectorTagLower(), and prepareVectorTagNeighbor().

_matrix_tags

std::set<TagID> TaggingInterface::_matrix_tags

private

The matrices this Kernel will contribute to.

Definition at line 359 of file TaggingInterface.h.

Referenced by accumulateTaggedLocalMatrix(), addJacobian(), addJacobianElement(), addJacobianWithoutConstraints(), getMatrixTags(), isMatrixTagged(), prepareMatrixTag(), prepareMatrixTagLower(), prepareMatrixTagNeighbor(), prepareMatrixTagNonlocal(), TaggingInterface(), and useMatrixTag().

_moose_object

const MooseObject& TaggingInterface::_moose_object

private

Moose objct this tag works on.

Definition at line 380 of file TaggingInterface.h.

Referenced by TaggingInterface().

_non_ref_abs_vector_tags

std::set<TagID> TaggingInterface::_non_ref_abs_vector_tags

private

A set to hold absolute value vector tags excluding the reference residual tag.

If there is no reference residual problem, this container is the same as _abs_vector_tags;

Definition at line 367 of file TaggingInterface.h.

Referenced by prepareVectorTag(), and TaggingInterface().

_non_ref_vector_tags

std::set<TagID> TaggingInterface::_non_ref_vector_tags

private

A set to hold vector tags excluding the reference residual tag.

If there is no reference residual problem, this container is the same as _vector_tags;

Definition at line 363 of file TaggingInterface.h.

Referenced by prepareVectorTag(), and TaggingInterface().

_nonlocal_ke

DenseMatrix<Number> TaggingInterface::_nonlocal_ke

protected

Holds nonlocal Jacobian entries as they are accumulated by this Kernel.

Definition at line 338 of file TaggingInterface.h.

Referenced by accumulateTaggedNonlocalMatrix(), NonlocalIntegratedBC::computeNonlocalJacobian(), NonlocalKernel::computeNonlocalJacobian(), NonlocalIntegratedBC::computeNonlocalOffDiagJacobian(), NonlocalKernel::computeNonlocalOffDiagJacobian(), and prepareMatrixTagNonlocal().

_re_blocks

std::vector<DenseVector<Number> *> TaggingInterface::_re_blocks

private

Residual blocks Vectors For each Tag.

Definition at line 386 of file TaggingInterface.h.

Referenced by accumulateTaggedLocalResidual(), assignTaggedLocalResidual(), prepareVectorTagInternal(), prepareVectorTagLower(), prepareVectorTagNeighbor(), and TaggingInterface().

_ref_abs_vector_tags

std::set<TagID> TaggingInterface::_ref_abs_vector_tags

private

A set of either size 1 or 0.

If we have a reference residual problem and _abs_vector_tags holds the reference vector tag, then this set holds the reference vector tags, otherwise it holds nothing

Definition at line 377 of file TaggingInterface.h.

Referenced by prepareVectorTag(), and TaggingInterface().

_ref_vector_tags

std::set<TagID> TaggingInterface::_ref_vector_tags

private

A set of either size 1 or 0.

If we have a reference residual problem and _vector_tags holds the reference vector tag, then this set holds the reference vector tags, otherwise it holds nothing

Definition at line 372 of file TaggingInterface.h.

Referenced by prepareVectorTag(), and TaggingInterface().

_subproblem

SubProblem& TaggingInterface::_subproblem

protected

SubProblem that contains tag info.

Definition at line 329 of file TaggingInterface.h.

Referenced by prepareVectorTagInternal(), prepareVectorTagLower(), prepareVectorTagNeighbor(), TaggingInterface(), useMatrixTag(), and useVectorTag().

_tag_params

const InputParameters& TaggingInterface::_tag_params

private

Parameters from moose object.

Definition at line 383 of file TaggingInterface.h.

Referenced by TaggingInterface().

_vector_tags

std::set<TagID> TaggingInterface::_vector_tags

private

The residual tag ids this Kernel will contribute to.

Definition at line 353 of file TaggingInterface.h.

Referenced by addResiduals(), addResidualsWithoutConstraints(), getVectorTags(), hasVectorTags(), isVectorTagged(), prepareVectorTag(), prepareVectorTagLower(), prepareVectorTagNeighbor(), setResidual(), TaggingInterface(), and useVectorTag().

---

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

• include/interfaces/TaggingInterface.h
• src/interfaces/TaggingInterface.C