https://mooseframework.inl.gov
TaggingInterface.h
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #pragma once
11 
12 #include "DenseMatrix.h"
13 #include "MooseTypes.h"
14 #include "MultiMooseEnum.h"
15 #include "Assembly.h"
16 #include "MooseVariableFE.h"
17 #include "SystemBase.h"
18 
19 #include "libmesh/dense_vector.h"
20 #include "metaphysicl/raw_type.h"
21 
22 #include <vector>
23 
24 // Forward declarations
25 class InputParameters;
26 class MooseObject;
27 class SubProblem;
28 class Assembly;
29 
30 #ifdef MOOSE_KOKKOS_ENABLED
31 namespace Moose::Kokkos
32 {
33 class ResidualObject;
34 }
35 #endif
36 
37 template <typename T>
39 
49 {
50  const DenseVector<ADReal> & residuals;
51  const std::vector<dof_id_type> & dof_indices;
53 };
54 
56 {
57 public:
58  TaggingInterface(const MooseObject * moose_object);
59 
60 #ifdef MOOSE_KOKKOS_ENABLED
61 
65 #endif
66 
67  virtual ~TaggingInterface();
68 
70 
76  {
77  friend class AttribVectorTags;
78  friend class NonlinearEigenSystem;
80  template <typename>
82 #ifdef MOOSE_KOKKOS_ENABLED
84 #endif
85 
88  };
89 
95  {
96  friend class AttribMatrixTags;
97  friend class NonlinearEigenSystem;
99  template <typename>
101 #ifdef MOOSE_KOKKOS_ENABLED
103 #endif
104 
107  };
108 
112  enum class ResidualTagType
113  {
114  NonReference,
115  Reference
116  };
117 
118  void useVectorTag(const TagName & tag_name, VectorTagsKey);
119 
120  void useMatrixTag(const TagName & tag_name, MatrixTagsKey);
121 
122  void useVectorTag(TagID tag_id, VectorTagsKey);
123 
124  void useMatrixTag(TagID tag_id, MatrixTagsKey);
125 
126  bool isVectorTagged() { return _vector_tags.size() > 0; }
127 
128  bool isMatrixTagged() { return _matrix_tags.size() > 0; }
129 
130  bool hasVectorTags() const { return !_vector_tags.empty(); }
131 
132  const std::set<TagID> & getVectorTags(VectorTagsKey) const { return _vector_tags; }
133 
134  const std::set<TagID> & getMatrixTags(MatrixTagsKey) const { return _matrix_tags; }
135 
136 protected:
143  void prepareVectorTag(Assembly & assembly, unsigned int ivar);
144 
152  void prepareVectorTag(Assembly & assembly, unsigned int ivar, ResidualTagType tag_type);
153 
161  void prepareVectorTagNeighbor(Assembly & assembly, unsigned int ivar);
162 
168  void prepareVectorTagLower(Assembly & assembly, unsigned int ivar);
169 
176  void prepareMatrixTag(Assembly & assembly, unsigned int ivar, unsigned int jvar);
177 
178  void prepareMatrixTag(Assembly & assembly,
179  unsigned int ivar,
180  unsigned int jvar,
181  DenseMatrix<Number> & k) const;
182 
189  void prepareMatrixTagNonlocal(Assembly & assembly, unsigned int ivar, unsigned int jvar);
190 
198  void prepareMatrixTagNeighbor(Assembly & assembly,
199  unsigned int ivar,
200  unsigned int jvar,
201  Moose::DGJacobianType type);
202 
203  void prepareMatrixTagNeighbor(Assembly & assembly,
204  unsigned int ivar,
205  unsigned int jvar,
207  DenseMatrix<Number> & k) const;
208 
214  void prepareMatrixTagLower(Assembly & assembly,
215  unsigned int ivar,
216  unsigned int jvar,
218 
224 
230 
236 
237  void accumulateTaggedLocalMatrix(Assembly & assembly,
238  unsigned int ivar,
239  unsigned int jvar,
240  const DenseMatrix<Number> & k);
241 
242  void accumulateTaggedLocalMatrix(Assembly & assembly,
243  unsigned int ivar,
244  unsigned int jvar,
246  const DenseMatrix<Number> & k);
247 
253 
259 
263  template <typename Residuals, typename Indices>
264  void addResiduals(Assembly & assembly,
265  const Residuals & residuals,
266  const Indices & dof_indices,
267  Real scaling_factor);
268 
272  template <typename T, typename Indices>
273  void addResiduals(Assembly & assembly,
274  const DenseVector<T> & residuals,
275  const Indices & dof_indices,
276  Real scaling_factor);
277 
282  template <typename Residuals, typename Indices>
283  void addResidualsAndJacobian(Assembly & assembly,
284  const Residuals & residuals,
285  const Indices & dof_indices,
286  Real scaling_factor);
287 
291  template <typename Residuals, typename Indices>
292  void addJacobian(Assembly & assembly,
293  const Residuals & residuals,
294  const Indices & dof_indices,
295  Real scaling_factor);
296 
300  void addResiduals(Assembly & assembly, const ADResidualsPacket & packet);
301 
306  void addResidualsAndJacobian(Assembly & assembly, const ADResidualsPacket & packet);
307 
311  void addJacobian(Assembly & assembly, const ADResidualsPacket & packet);
312 
318  template <typename Residuals, typename Indices>
320  const Residuals & residuals,
321  const Indices & dof_indices,
322  Real scaling_factor);
323 
329  template <typename Residuals, typename Indices>
331  const Residuals & residuals,
332  const Indices & dof_indices,
333  Real scaling_factor);
334 
340  template <typename Residuals, typename Indices>
341  void addJacobianWithoutConstraints(Assembly & assembly,
342  const Residuals & residuals,
343  const Indices & dof_indices,
344  Real scaling_factor);
345 
349  void addJacobianElement(Assembly & assembly,
350  Real value,
351  dof_id_type row_index,
352  dof_id_type column_index,
353  Real scaling_factor);
354 
358  void addJacobian(Assembly & assembly,
359  DenseMatrix<Real> & local_k,
360  const std::vector<dof_id_type> & row_indices,
361  const std::vector<dof_id_type> & column_indices,
362  Real scaling_factor);
363 
367  template <typename T>
368  void setResidual(SystemBase & sys, const T & residual, MooseVariableFE<T> & var);
369 
373  void setResidual(SystemBase & sys, Real residual, dof_id_type dof_index);
374 
378  template <typename SetResidualFunctor>
379  void setResidual(SystemBase & sys, SetResidualFunctor set_residual_functor);
380 
383 
386 
389 
392 
393 private:
400  void prepareVectorTagInternal(Assembly & assembly,
401  unsigned int ivar,
402  const std::set<TagID> & vector_tags,
403  const std::set<TagID> & absolute_value_vector_tags);
404 
406  std::set<TagID> _vector_tags;
407 
409  std::set<TagID> _abs_vector_tags;
410 
412  std::set<TagID> _matrix_tags;
413 
416  std::set<TagID> _non_ref_vector_tags;
417 
420  std::set<TagID> _non_ref_abs_vector_tags;
421 
425  std::set<TagID> _ref_vector_tags;
426 
430  std::set<TagID> _ref_abs_vector_tags;
431 
434 
437 
439  std::vector<DenseVector<Number> *> _re_blocks;
440 
442  std::vector<DenseVector<Number> *> _absre_blocks;
443 
445  std::vector<DenseMatrix<Number> *> _ke_blocks;
446 
449  std::vector<Real> _absolute_residuals;
450 
451  friend class NonlinearSystemBase;
452 };
453 
454 #define usingTaggingInterfaceMembers \
455  using TaggingInterface::_subproblem; \
456  using TaggingInterface::accumulateTaggedLocalResidual; \
457  using TaggingInterface::accumulateTaggedLocalMatrix; \
458  using TaggingInterface::prepareVectorTag; \
459  using TaggingInterface::prepareMatrixTag; \
460  using TaggingInterface::prepareVectorTagNeighbor; \
461  using TaggingInterface::_local_re; \
462  using TaggingInterface::prepareVectorTagLower; \
463  using TaggingInterface::prepareMatrixTagNeighbor; \
464  using TaggingInterface::prepareMatrixTagLower; \
465  using TaggingInterface::_local_ke
466 
467 template <typename Residuals, typename Indices>
468 void
470  const Residuals & residuals,
471  const Indices & dof_indices,
472  const Real scaling_factor)
473 {
474  assembly.cacheResiduals(
475  residuals, dof_indices, scaling_factor, Assembly::LocalDataKey{}, _vector_tags);
476  if (!_abs_vector_tags.empty())
477  {
478  _absolute_residuals.resize(residuals.size());
479  for (const auto i : index_range(residuals))
481 
483  dof_indices,
484  scaling_factor,
487  }
488 }
489 
490 template <typename T, typename Indices>
491 void
493  const DenseVector<T> & residuals,
494  const Indices & dof_indices,
495  const Real scaling_factor)
496 {
497  addResiduals(assembly, residuals.get_values(), dof_indices, scaling_factor);
498 }
499 
500 template <typename Residuals, typename Indices>
501 void
503  const Residuals & residuals,
504  const Indices & dof_indices,
505  const Real scaling_factor)
506 {
508  residuals, dof_indices, scaling_factor, Assembly::LocalDataKey{}, _vector_tags);
509  if (!_abs_vector_tags.empty())
510  {
511  _absolute_residuals.resize(residuals.size());
512  for (const auto i : index_range(residuals))
514 
516  dof_indices,
517  scaling_factor,
520  }
521 }
522 
523 template <typename Residuals, typename Indices>
524 void
526  const Residuals & residuals,
527  const Indices & dof_indices,
528  Real scaling_factor)
529 {
530  addResiduals(assembly, residuals, dof_indices, scaling_factor);
531  addJacobian(assembly, residuals, dof_indices, scaling_factor);
532 }
533 
534 template <typename Residuals, typename Indices>
535 void
537  const Residuals & residuals,
538  const Indices & dof_indices,
539  Real scaling_factor)
540 {
541  assembly.cacheJacobian(
542  residuals, dof_indices, scaling_factor, Assembly::LocalDataKey{}, _matrix_tags);
543 }
544 
545 template <typename Residuals, typename Indices>
546 void
548  const Residuals & residuals,
549  const Indices & dof_indices,
550  Real scaling_factor)
551 {
552  addResidualsWithoutConstraints(assembly, residuals, dof_indices, scaling_factor);
553  addJacobianWithoutConstraints(assembly, residuals, dof_indices, scaling_factor);
554 }
555 
556 template <typename Residuals, typename Indices>
557 void
559  const Residuals & residuals,
560  const Indices & dof_indices,
561  Real scaling_factor)
562 {
564  residuals, dof_indices, scaling_factor, Assembly::LocalDataKey{}, _matrix_tags);
565 }
566 
567 inline void
569  const Real value,
570  const dof_id_type row_index,
571  const dof_id_type column_index,
572  const Real scaling_factor)
573 {
574  assembly.cacheJacobian(
575  row_index, column_index, value * scaling_factor, Assembly::LocalDataKey{}, _matrix_tags);
576 }
577 
578 inline void
580  DenseMatrix<Real> & local_k,
581  const std::vector<dof_id_type> & row_indices,
582  const std::vector<dof_id_type> & column_indices,
583  const Real scaling_factor)
584 {
585  for (const auto matrix_tag : _matrix_tags)
586  assembly.cacheJacobianBlock(
587  local_k, row_indices, column_indices, scaling_factor, Assembly::LocalDataKey{}, matrix_tag);
588 }
589 
590 template <typename T>
591 void
593 {
594  for (const auto tag_id : _vector_tags)
595  if (sys.hasVector(tag_id))
596  var.insertNodalValue(sys.getVector(tag_id), residual);
597 }
598 
599 inline void
600 TaggingInterface::setResidual(SystemBase & sys, const Real residual, const dof_id_type dof_index)
601 {
602  for (const auto tag_id : _vector_tags)
603  if (sys.hasVector(tag_id))
604  sys.getVector(tag_id).set(dof_index, residual);
605 }
606 
607 template <typename SetResidualFunctor>
608 void
609 TaggingInterface::setResidual(SystemBase & sys, const SetResidualFunctor set_residual_functor)
610 {
611  for (const auto tag_id : _vector_tags)
612  if (sys.hasVector(tag_id))
613  set_residual_functor(sys.getVector(tag_id));
614 }
615 
616 inline void
618 {
619  addResiduals(assembly, packet.residuals, packet.dof_indices, packet.scaling_factor);
620 }
621 
622 inline void
624 {
625  addResidualsAndJacobian(assembly, packet.residuals, packet.dof_indices, packet.scaling_factor);
626 }
627 
628 inline void
630 {
631  addJacobian(assembly, packet.residuals, packet.dof_indices, packet.scaling_factor);
632 }
Nonlinear eigenvalue system to be solved.
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:42
void accumulateTaggedNonlocalMatrix()
Nonlocal Jacobian blocks will be appended by adding the current nonlocal kernel Jacobian.
std::set< TagID > _ref_abs_vector_tags
A set of either size 1 or 0.
SubProblem & _subproblem
SubProblem that contains tag info.
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 d...
const InputParameters & _tag_params
Parameters from moose object.
void accumulateTaggedLocalResidual()
Local residual blocks will be appended by adding the current local kernel residual.
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
Definition: SystemBase.C:924
bool hasVectorTags() const
Keeps track of stuff related to assembling.
Definition: Assembly.h:109
unsigned int TagID
Definition: MooseTypes.h:210
const std::vector< dof_id_type > & dof_indices
void assignTaggedLocalMatrix()
Local Jacobian blocks will assigned as the current local kernel Jacobian.
Class that is used as a parameter to some of our matrix tag APIs that allows only blessed framework c...
MatrixTagsKey(const MatrixTagsKey &)
VectorTagsKey(const VectorTagsKey &)
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.
void assignTaggedLocalResidual()
Local residual blocks will assigned as the current local kernel residual.
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73
std::vector< DenseVector< Number > * > _absre_blocks
Residual blocks for absolute value residual tags.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
The base class for Kokkos residual objects.
const Real scaling_factor
ResidualTagType
Enumerate whether a (residual) vector tag is to be of a non-reference or reference tag type...
std::vector< DenseVector< Number > * > _re_blocks
Residual blocks Vectors For each Tag.
const DenseVector< ADReal > & residuals
std::set< TagID > _ref_vector_tags
A set of either size 1 or 0.
Base class for a system (of equations)
Definition: SystemBase.h:84
DenseMatrix< Number > _local_ke
Holds local Jacobian entries as they are accumulated by this Kernel.
std::set< TagID > _abs_vector_tags
The absolute value residual tag ids.
void cacheJacobian(GlobalDataKey)
Takes the values that are currently in _sub_Kee and appends them to the cached values.
Definition: Assembly.C:4060
Nonlinear system to be solved.
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...
TaggingInterface(const MooseObject *moose_object)
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.
InputParameters validParams()
std::set< TagID > _non_ref_abs_vector_tags
A set to hold absolute value vector tags excluding the reference residual tag.
void prepareMatrixTagNonlocal(Assembly &assembly, unsigned int ivar, unsigned int jvar)
Prepare data for computing nonlocal element jacobian according to the active tags.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:27
std::set< TagID > _matrix_tags
The matrices this Kernel will contribute to.
void cacheJacobianWithoutConstraints(const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &matrix_tags)
Process the derivatives() data of a vector of ADReals.
Definition: Assembly.h:3177
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 d...
std::set< TagID > _non_ref_vector_tags
A set to hold vector tags excluding the reference residual tag.
std::set< TagID > _vector_tags
The vector tag ids this Kernel will contribute to.
void accumulateTaggedLocalMatrix()
Local Jacobian blocks will be appended by adding the current local kernel Jacobian.
Utility structure for packaging up all of the residual object&#39;s information needed to add into the sy...
A storage container for MooseObjects that inherit from SetupInterface.
void cacheResiduals(const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &vector_tags)
Process the supplied residual values.
Definition: Assembly.h:3057
void useMatrixTag(const TagName &tag_name, MatrixTagsKey)
void insertNodalValue(libMesh::NumericVector< libMesh::Number > &residual, const OutputData &v)
Write a nodal value to the passed-in solution vector.
DGJacobianType
Definition: MooseTypes.h:750
void prepareVectorTagNeighbor(Assembly &assembly, unsigned int ivar)
Prepare data for computing element residual the according to active tags for DG and interface kernels...
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
This is the common base class for objects that give residual contributions.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
This is the common base class for objects that give contributions to a linear system.
ConstraintJacobianType
Definition: MooseTypes.h:797
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.
DenseVector< Number > _local_re
Holds local residual entries as they are accumulated by this Kernel.
const MooseObject & _moose_object
Moose objct this tag works on.
const std::set< TagID > & getMatrixTags(MatrixTagsKey) const
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.
virtual ~TaggingInterface()
virtual void set(const numeric_index_type i, const Number value)=0
void cacheJacobianBlock(DenseMatrix< Number > &jac_block, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, Real scaling_factor, LocalDataKey, TagID tag)
Cache a local Jacobian block with the provided rows (idof_indices) and columns (jdof_indices) for eve...
std::vector< DenseMatrix< Number > * > _ke_blocks
Kernel blocks Vectors For each Tag.
void prepareVectorTagLower(Assembly &assembly, unsigned int ivar)
Prepare data for computing the residual according to active tags for mortar constraints.
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 diffe...
void prepareVectorTag(Assembly &assembly, unsigned int ivar)
Prepare data for computing element residual according to active tags.
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 prepareMatrixTag(Assembly &assembly, unsigned int ivar, unsigned int jvar)
Prepare data for computing element jacobian according to the active tags.
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.
DenseMatrix< Number > _nonlocal_ke
Holds nonlocal Jacobian entries as they are accumulated by this Kernel.
static InputParameters validParams()
void setResidual(SystemBase &sys, const T &residual, MooseVariableFE< T > &var)
Set residual using the variables&#39; insertion API.
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
Definition: SystemBase.C:933
auto index_range(const T &sizable)
std::vector< Real > _absolute_residuals
A container to hold absolute values of residuals passed into addResiduals.
Key structure for APIs adding/caching local element residuals/Jacobians.
Definition: Assembly.h:862
void useVectorTag(const TagName &tag_name, VectorTagsKey)
Class that is used as a parameter to some of our vector tag APIs that allows only blessed framework c...
void cacheResidualsWithoutConstraints(const Residuals &residuals, const Indices &row_indices, Real scaling_factor, LocalDataKey, const std::set< TagID > &vector_tags)
Process the supplied residual values.
Definition: Assembly.h:3097
uint8_t dof_id_type
const std::set< TagID > & getVectorTags(VectorTagsKey) const