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 class	ResidualTagType { NonReference , 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)
	TaggingInterface (const TaggingInterface &object, const Moose::Kokkos::FunctorCopy &key)
	Special constructor used for Kokkos functor copy during parallel dispatch.
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.
void	prepareVectorTag (Assembly &assembly, unsigned int ivar, ResidualTagType tag_type)
	Prepare vector tags in a reference residual problem context.
void	prepareVectorTagNeighbor (Assembly &assembly, unsigned int ivar)
	Prepare data for computing element residual the according to active tags for DG and interface kernels.
void	prepareVectorTagLower (Assembly &assembly, unsigned int ivar)
	Prepare data for computing the residual according to active tags for mortar constraints.
void	prepareMatrixTag (Assembly &assembly, unsigned int ivar, unsigned int jvar)
	Prepare data for computing element jacobian according to the active tags.
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.
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.
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.
void	accumulateTaggedLocalResidual ()
	Local residual blocks will be appended by adding the current local kernel residual.
void	assignTaggedLocalResidual ()
	Local residual blocks will assigned as the current local kernel residual.
void	accumulateTaggedLocalMatrix ()
	Local Jacobian blocks will be appended by adding the current local kernel Jacobian.
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.
void	assignTaggedLocalMatrix ()
	Local Jacobian blocks will assigned as the current local kernel Jacobian.
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.
template<typename Residuals , typename Indices >
void	addResiduals (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, const std::vector< Real > &scaling_factors)
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.
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.
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.
template<typename Residuals , typename Indices >
void	addJacobian (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, const std::vector< Real > &scaling_factors)
	Add the provided residual derivatives into the Jacobian for the provided dof indices.
void	addResiduals (Assembly &assembly, const ADResidualsPacket &packet)
	Add the provided incoming residuals corresponding to the provided dof indices.
void	addResidualsAndJacobian (Assembly &assembly, const ADResidualsPacket &packet)
	Add the provided incoming residuals and derivatives for the Jacobian, corresponding to the provided dof indices.
void	addJacobian (Assembly &assembly, const ADResidualsPacket &packet)
	Add the provided residual derivatives into the Jacobian for the provided dof indices.
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.
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.
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.
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.
void	addJacobian (Assembly &assembly, const 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.
template<typename T >
void	setResidual (SystemBase &sys, const T &residual, MooseVariableFE< T > &var)
	Set residual using the variables' insertion API.
void	setResidual (SystemBase &sys, Real residual, dof_id_type dof_index)
	Set residual at a specified degree of freedom index.
template<typename SetResidualFunctor >
void	setResidual (SystemBase &sys, SetResidualFunctor set_residual_functor)
	Set residuals using the provided functor.

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

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.
void	checkForNans () const
	Checks _local_re for NaNs/Infs and returns an error if found.

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

Friends
class	NonlinearSystemBase

Detailed Description

Definition at line 57 of file TaggingInterface.h.

Member Enumeration Documentation

ResidualTagType

enum class 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 118 of file TaggingInterface.h.

  {
    NonReference,
    Reference
  };

Constructor & Destructor Documentation

TaggingInterface() [1/2]

TaggingInterface::TaggingInterface

(

const MooseObject *

moose_object

)

Definition at line 56 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");
 
  for (const auto & conv : fe_problem->getConvergenceObjects())
  {
    const auto * const ref_conv = dynamic_cast<const ReferenceResidualConvergence *>(conv.get());
    if (ref_conv)
    {
      const auto reference_tag = ref_conv->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() [2/2]

TaggingInterface::TaggingInterface	(	const TaggingInterface &	object,
		const Moose::Kokkos::FunctorCopy &	key
	)

Special constructor used for Kokkos functor copy during parallel dispatch.

Definition at line 160 of file TaggingInterface.C.

  : _subproblem(object._subproblem),
    _moose_object(object._moose_object),
    _tag_params(object._tag_params)
{
}

~TaggingInterface()

TaggingInterface::~TaggingInterface ( )

virtual

Definition at line 504 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 407 of file TaggingInterface.C.

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

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

accumulateTaggedLocalMatrix() [2/3]

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

protected

Definition at line 414 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 431 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 377 of file TaggingInterface.C.

{
#ifndef NDEBUG
  if (_subproblem.checkResidualForNans())
    checkForNans();
#endif
 
  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));
}

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

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 450 of file TaggingInterface.C.

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

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

addJacobian() [1/4]

void TaggingInterface::addJacobian ( Assembly &  assembly, const ADResidualsPacket &  packet  )

protected

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

Definition at line 476 of file TaggingInterface.C.

{
  addJacobian(assembly, packet.residuals, packet.dof_indices, packet.scaling_factor);
}

addJacobian() [2/4]

void TaggingInterface::addJacobian ( Assembly &  assembly, const 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 650 of file TaggingInterface.h.

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

addJacobian() [3/4]

template<typename Residuals , typename Indices >

void TaggingInterface::addJacobian ( Assembly &  assembly, const Residuals &  residuals, const Indices &  dof_indices, const std::vector< Real > &  scaling_factors  )

protected

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

This overload is meant for array variables because it takes an array of scaling factors

Definition at line 597 of file TaggingInterface.h.

{
  const auto count = scaling_factors.size();
  mooseAssert(dof_indices.size() % count == 0,
              "The number of dof indices should be divided cleanly by the variable count");
  const auto nshapes = dof_indices.size() / count;
 
  for (const auto j : make_range(count))
    // The Residuals type may not offer operator[] (e.g. eigen vectors) but more commonly it
    // should offer data()
    addJacobian(assembly,
                Moose::makeSpan(residuals, j * nshapes, nshapes),
                Moose::makeSpan(dof_indices, j * nshapes, nshapes),
                scaling_factors[j]);
}

addJacobian() [4/4]

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 586 of file TaggingInterface.h.

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

Referenced by addJacobian(), addJacobian(), addResidualsAndJacobian(), ADScalarKernel::computeADJacobian(), ADDGKernel::computeElemNeighJacobian(), BoundaryIntegralValueConstraint::computeFieldScalarJacobian(), ADDiracKernel::computeFullJacobian(), DiffusionLHDGDirichletBC::computeJacobian(), DiffusionLHDGPrescribedGradientBC::computeJacobian(), ElementAndTraceScalarHDGBC::computeJacobian(), ADNodeElemConstraint::computeJacobian(), FVElementalKernel::computeJacobian(), DiffusionLHDGKernel::computeJacobian(), ElementAndTraceScalarHDGKernel::computeJacobian(), ADArrayKernel::computeJacobian(), ADArrayNodalKernel::computeJacobian(), ADNodalKernel::computeJacobian(), NodalConstraint::computeJacobian(), DiffusionLHDGKernel::computeJacobianOnSide(), ElementAndTraceScalarHDGKernel::computeJacobianOnSide(), ADDGKernel::computeOffDiagElemNeighJacobian(), FVScalarLagrangeMultiplierConstraint::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), KernelScalarBase::computeOffDiagJacobianScalarLocal(), BoundaryIntegralValueConstraint::computeScalarFieldJacobian(), BoundaryIntegralValueConstraint::computeScalarJacobian(), MortarScalarBase::computeScalarJacobian(), KernelScalarBase::computeScalarJacobian(), MortarScalarBase::computeScalarOffDiagJacobian(), KernelScalarBase::computeScalarOffDiagJacobian(), MortarScalarBase::computeScalarOffDiagJacobianScalar(), and KernelScalarBase::computeScalarOffDiagJacobianScalar().

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 639 of file TaggingInterface.h.

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

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

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 629 of file TaggingInterface.h.

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

Referenced by addResidualsAndJacobianWithoutConstraints().

addResiduals() [1/4]

void TaggingInterface::addResiduals ( Assembly &  assembly, const ADResidualsPacket &  packet  )

protected

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

Definition at line 464 of file TaggingInterface.C.

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

addResiduals() [2/4]

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 542 of file TaggingInterface.h.

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

addResiduals() [3/4]

template<typename Residuals , typename Indices >

void TaggingInterface::addResiduals ( Assembly &  assembly, const Residuals &  residuals, const Indices &  dof_indices, const std::vector< Real > &  scaling_factors  )

protected

Definition at line 521 of file TaggingInterface.h.

{
  const auto count = scaling_factors.size();
  mooseAssert(dof_indices.size() % count == 0,
              "The number of dof indices should be divided cleanly by the variable count");
  const auto nshapes = dof_indices.size() / count;
 
  for (const auto j : make_range(count))
    // The Residuals type may not offer operator[] (e.g. eigen vectors) but more commonly it
    // should offer data()
    addResiduals(assembly,
                 Moose::makeSpan(residuals, j * nshapes, nshapes),
                 Moose::makeSpan(dof_indices, j * nshapes, nshapes),
                 scaling_factors[j]);
}

addResiduals() [4/4]

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 498 of file TaggingInterface.h.

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

Referenced by addResiduals(), addResiduals(), addResiduals(), addResidualsAndJacobian(), DiffusionLHDGDirichletBC::computeResidual(), DiffusionLHDGPrescribedGradientBC::computeResidual(), ElementAndTraceScalarHDGBC::computeResidual(), ADMortarScalarBase::computeResidual(), ADNodeElemConstraint::computeResidual(), MortarScalarBase::computeResidual(), DiffusionLHDGKernel::computeResidual(), ElementAndTraceScalarHDGKernel::computeResidual(), ADKernelScalarBase::computeResidual(), ADArrayNodalKernel::computeResidual(), ADNodalKernel::computeResidual(), ArrayNodalKernel::computeResidual(), NodalKernel::computeResidual(), FVScalarLagrangeMultiplierConstraint::computeResidual(), FVBoundaryScalarLagrangeMultiplierConstraint::computeResidual(), FVScalarLagrangeMultiplierInterface::computeResidual(), NodalConstraint::computeResidual(), DiffusionLHDGKernel::computeResidualOnSide(), ElementAndTraceScalarHDGKernel::computeResidualOnSide(), BoundaryIntegralValueConstraint::computeScalarResidual(), KernelScalarBase::computeScalarResidual(), and MortarConstraintBase::zeroInactiveLMDofs().

addResidualsAndJacobian() [1/2]

void TaggingInterface::addResidualsAndJacobian ( Assembly &  assembly, const ADResidualsPacket &  packet  )

protected

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

Definition at line 470 of file TaggingInterface.C.

{
  addResidualsAndJacobian(assembly, packet.residuals, packet.dof_indices, packet.scaling_factor);
}

addResidualsAndJacobian() [2/2]

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 575 of file TaggingInterface.h.

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

Referenced by addResidualsAndJacobian(), ADKernelScalarBase::computeJacobian(), FVFluxBC::computeJacobian(), FVInterfaceKernel::computeJacobian(), FVFluxKernel::computeJacobian(), FVBoundaryScalarLagrangeMultiplierConstraint::computeJacobian(), FVScalarLagrangeMultiplierInterface::computeJacobian(), ElementAndTraceScalarHDGBC::computeResidualAndJacobian(), ADDiracKernel::computeResidualAndJacobian(), FVElementalKernel::computeResidualAndJacobian(), ElementAndTraceScalarHDGKernel::computeResidualAndJacobian(), ADKernelScalarBase::computeResidualAndJacobian(), FVScalarLagrangeMultiplierConstraint::computeResidualAndJacobian(), and ElementAndTraceScalarHDGKernel::computeResidualAndJacobianOnSide().

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 618 of file TaggingInterface.h.

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

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

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 552 of file TaggingInterface.h.

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

Referenced by addResidualsAndJacobianWithoutConstraints().

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 457 of file TaggingInterface.C.

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

Referenced by NodalEqualValueConstraint::computeJacobian().

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 392 of file TaggingInterface.C.

{
#ifndef NDEBUG
  if (_subproblem.checkResidualForNans())
    checkForNans();
#endif
 
  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));
}

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

checkForNans()

void TaggingInterface::checkForNans ( ) const

private

Checks _local_re for NaNs/Infs and returns an error if found.

Definition at line 483 of file TaggingInterface.C.

{
  for (const auto i : index_range(_local_re))
    if (!std::isfinite(_local_re(i)))
    {
      std::stringstream ss;
      ss << "NaN or Inf detected in '" << _moose_object.name() << "'.\n";
      ss << "To further troubleshoot this value in this residual object, add the following lines "
            "before returning the value in the computeQpResidual() (or similar) method in the "
            "source file for the class of '"
         << _moose_object.name() << "':\n\n";
      ss << "  if (!std::isfinite(<return value>))\n";
      ss << "    mooseError(\"Found NaN or Inf\");\n\n";
      ss << "Then you can use a breakpoint in a debugger to troubleshoot the origin of the NaN or "
            "Inf value.";
 
      mooseError(ss.str());
    }
}

Referenced by accumulateTaggedLocalResidual(), and assignTaggedLocalResidual().

getMatrixTags()

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

inline

Definition at line 140 of file TaggingInterface.h.

{ return _matrix_tags; }

getVectorTags()

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

inline

Definition at line 138 of file TaggingInterface.h.

{ return _vector_tags; }

hasVectorTags()

bool TaggingInterface::hasVectorTags ( ) const

inline

Definition at line 136 of file TaggingInterface.h.

{ return !_vector_tags.empty(); }

Referenced by Kernel::computeResidual().

isMatrixTagged()

bool TaggingInterface::isMatrixTagged ( )

inline

Definition at line 134 of file TaggingInterface.h.

{ return _matrix_tags.size() > 0; }

isVectorTagged()

bool TaggingInterface::isVectorTagged ( )

inline

Definition at line 132 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 293 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);
 
  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
}

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

prepareMatrixTag() [2/2]

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

protected

Definition at line 305 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 361 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.jacobianBlockMortar(type, ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
 
  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
}

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

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 332 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);
 
  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
}

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

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 348 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 317 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.jacobianBlockNonlocal(ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
 
  _nonlocal_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
}

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

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 206 of file TaggingInterface.C.

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

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

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 212 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 223 of file TaggingInterface.C.

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

Referenced by prepareVectorTag(), and prepareVectorTag().

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 271 of file TaggingInterface.C.

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

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

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 248 of file TaggingInterface.C.

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

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

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 662 of file TaggingInterface.h.

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

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

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 670 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 679 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 179 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 197 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 170 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 188 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 20 of file TaggingInterface.C.

{
 
  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.addParam<bool>(
      "matrix_only", false, "Whether this object is only doing assembly to matrices (no vectors)");
 
  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 matrix_only",
                              "Contribution to tagged field data");
 
  return params;
}

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

Friends And Related Symbol Documentation

NonlinearSystemBase

friend class NonlinearSystemBase

friend

Definition at line 480 of file TaggingInterface.h.

Member Data Documentation

_abs_vector_tags

std::set<TagID> TaggingInterface::_abs_vector_tags

private

The absolute value residual tag ids.

Definition at line 438 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 478 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 471 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 474 of file TaggingInterface.h.

Referenced by accumulateTaggedLocalMatrix(), accumulateTaggedLocalMatrix(), accumulateTaggedLocalMatrix(), accumulateTaggedNonlocalMatrix(), FVInterfaceKernel::addJacobian(), assignTaggedLocalMatrix(), prepareMatrixTag(), prepareMatrixTagLower(), 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 410 of file TaggingInterface.h.

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

_local_re

DenseVector<Number> TaggingInterface::_local_re

protected

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

Definition at line 407 of file TaggingInterface.h.

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

_matrix_tags

std::set<TagID> TaggingInterface::_matrix_tags

private

The matrices this Kernel will contribute to.

Definition at line 441 of file TaggingInterface.h.

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

_moose_object

const MooseObject& TaggingInterface::_moose_object

private

Moose objct this tag works on.

Definition at line 462 of file TaggingInterface.h.

Referenced by checkForNans(), and 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 449 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 445 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 413 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 468 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 459 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 454 of file TaggingInterface.h.

Referenced by prepareVectorTag(), and TaggingInterface().

_subproblem

SubProblem& TaggingInterface::_subproblem

protected

SubProblem that contains tag info.

Definition at line 404 of file TaggingInterface.h.

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

_tag_params

const InputParameters& TaggingInterface::_tag_params

private

Parameters from moose object.

Definition at line 465 of file TaggingInterface.h.

Referenced by TaggingInterface().

_vector_tags

std::set<TagID> TaggingInterface::_vector_tags

private

The vector tag ids this Kernel will contribute to.

Definition at line 435 of file TaggingInterface.h.

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

---

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

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