https://mooseframework.inl.gov
TaggingInterface.C
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 #include "TaggingInterface.h"
11 #include "Conversion.h"
12 #include "FEProblem.h"
13 #include "Assembly.h"
16 
17 #include "libmesh/dense_vector.h"
18 
21 {
22 
24 
25  // These are the default names for tags, but users will be able to add their own
26  MultiMooseEnum vtags("nontime time", "nontime", true);
27  MultiMooseEnum mtags("nontime system", "system", true);
28 
29  params.addParam<bool>(
30  "matrix_only", false, "Whether this object is only doing assembly to matrices (no vectors)");
31 
32  params.addParam<MultiMooseEnum>(
33  "vector_tags", vtags, "The tag for the vectors this Kernel should fill");
34 
35  params.addParam<MultiMooseEnum>(
36  "matrix_tags", mtags, "The tag for the matrices this Kernel should fill");
37 
38  params.addParam<std::vector<TagName>>("extra_vector_tags",
39  "The extra tags for the vectors this Kernel should fill");
40 
41  params.addParam<std::vector<TagName>>(
42  "absolute_value_vector_tags",
43  "The tags for the vectors this residual object should fill with the "
44  "absolute value of the residual contribution");
45 
46  params.addParam<std::vector<TagName>>("extra_matrix_tags",
47  "The extra tags for the matrices this Kernel should fill");
48 
49  params.addParamNamesToGroup(
50  "vector_tags matrix_tags extra_vector_tags extra_matrix_tags absolute_value_vector_tags",
51  "Contribution to tagged field data");
52 
53  return params;
54 }
55 
57  : _subproblem(*moose_object->parameters().getCheckedPointerParam<SubProblem *>("_subproblem")),
58  _moose_object(*moose_object),
59  _tag_params(_moose_object.parameters())
60 {
61  auto & vector_tag_names = _tag_params.get<MultiMooseEnum>("vector_tags");
62 
63  if (!vector_tag_names.isValid())
64  {
65  if (!_tag_params.get<bool>("matrix_only"))
66  mooseError("MUST provide at least one vector_tag for Kernel: ", _moose_object.name());
67  }
68  else
69  {
70  for (auto & vector_tag_name : vector_tag_names)
71  {
72  const TagID vector_tag_id = _subproblem.getVectorTagID(vector_tag_name.name());
74  mooseError("Vector tag '",
75  vector_tag_name.name(),
76  "' for Kernel '",
78  "' is not a residual vector tag");
79  _vector_tags.insert(vector_tag_id);
80  }
81  }
82 
83  // Add extra vector tags. These tags should be created in the System already, otherwise
84  // we can not add the extra tags
85  auto & extra_vector_tags = _tag_params.get<std::vector<TagName>>("extra_vector_tags");
86 
87  for (auto & vector_tag_name : extra_vector_tags)
88  {
89  const TagID vector_tag_id = _subproblem.getVectorTagID(vector_tag_name);
91  mooseError("Extra vector tag '",
92  vector_tag_name,
93  "' for Kernel '",
95  "' is not a residual vector tag");
96  _vector_tags.insert(vector_tag_id);
97  }
98 
99  // Add absolue value vector tags. These tags should be created in the System already, otherwise
100  // we can not add the extra tags
101  auto & abs_vector_tags = _tag_params.get<std::vector<TagName>>("absolute_value_vector_tags");
102 
103  for (auto & vector_tag_name : abs_vector_tags)
104  {
105  const TagID vector_tag_id = _subproblem.getVectorTagID(vector_tag_name);
107  mooseError("Absolute value vector tag '",
108  vector_tag_name,
109  "' for Kernel '",
111  "' is not a residual vector tag");
112  _abs_vector_tags.insert(vector_tag_id);
113  }
114 
115  auto & matrix_tag_names = _tag_params.get<MultiMooseEnum>("matrix_tags");
116 
117  if (matrix_tag_names.isValid())
118  for (auto & matrix_tag_name : matrix_tag_names)
119  _matrix_tags.insert(_subproblem.getMatrixTagID(matrix_tag_name.name()));
120 
121  auto & extra_matrix_tags = _tag_params.get<std::vector<TagName>>("extra_matrix_tags");
122 
123  for (auto & matrix_tag_name : extra_matrix_tags)
124  _matrix_tags.insert(_subproblem.getMatrixTagID(matrix_tag_name));
125 
126  _re_blocks.resize(_vector_tags.size());
127  _absre_blocks.resize(_abs_vector_tags.size());
128  _ke_blocks.resize(_matrix_tags.size());
129 
130  const auto * const fe_problem =
131  moose_object->parameters().getCheckedPointerParam<FEProblemBase *>("_fe_problem_base");
132 
133  for (const auto & conv : fe_problem->getConvergenceObjects())
134  {
135  const auto * const ref_conv = dynamic_cast<const ReferenceResidualConvergence *>(conv.get());
136  if (ref_conv)
137  {
138  const auto reference_tag = ref_conv->referenceVectorTagID({});
139  auto create_tags_split =
140  [reference_tag](const auto & tags, auto & non_ref_tags, auto & ref_tags)
141  {
142  for (const auto tag : tags)
143  if (tag == reference_tag)
144  ref_tags.insert(tag);
145  else
146  non_ref_tags.insert(tag);
147  };
150  }
151  else
152  {
155  }
156  }
157 }
158 
159 void
161 {
162  if (!_subproblem.vectorTagExists(tag_name))
163  mooseError("Vector tag ", tag_name, " does not exist in system");
164 
165  _vector_tags.insert(_subproblem.getVectorTagID(tag_name));
166 }
167 
168 void
170 {
171  if (!_subproblem.matrixTagExists(tag_name))
172  mooseError("Matrix tag ", tag_name, " does not exist in system");
173 
174  _matrix_tags.insert(_subproblem.getMatrixTagID(tag_name));
175 }
176 
177 void
179 {
180  if (!_subproblem.vectorTagExists(tag_id))
181  mooseError("Vector tag ", tag_id, " does not exist in system");
182 
183  _vector_tags.insert(tag_id);
184 }
185 
186 void
188 {
189  if (!_subproblem.matrixTagExists(tag_id))
190  mooseError("Matrix tag ", tag_id, " does not exist in system");
191 
192  _matrix_tags.insert(tag_id);
193 }
194 
195 void
196 TaggingInterface::prepareVectorTag(Assembly & assembly, const unsigned int ivar)
197 {
199 }
200 
201 void
203  const unsigned int ivar,
204  const ResidualTagType tag_type)
205 {
206  if (tag_type == ResidualTagType::NonReference)
208  else
210 }
211 
212 void
214  const unsigned int ivar,
215  const std::set<TagID> & vector_tags,
216  const std::set<TagID> & absolute_value_vector_tags)
217 {
218  auto prepare = [this, ivar, &assembly](auto & re_blocks, const auto & tags)
219  {
220  re_blocks.clear();
221  re_blocks.reserve(tags.size());
222  for (const auto tag_id : tags)
223  {
224  const auto & tag = _subproblem.getVectorTag(tag_id);
225  re_blocks.push_back(&assembly.residualBlock(ivar, Assembly::LocalDataKey{}, tag._type_id));
226  }
227  };
228 
229  prepare(_re_blocks, vector_tags);
230  prepare(_absre_blocks, absolute_value_vector_tags);
231 
232  _local_re.resize(_re_blocks.empty()
233  ? (_absre_blocks.empty() ? std::size_t(0) : _absre_blocks[0]->size())
234  : _re_blocks[0]->size());
235 }
236 
237 void
239 {
240  _re_blocks.resize(_vector_tags.size());
241  mooseAssert(_vector_tags.size() >= 1, "we need at least one active tag");
242  auto vector_tag = _vector_tags.begin();
243  for (MooseIndex(_vector_tags) i = 0; i < _vector_tags.size(); i++, ++vector_tag)
244  {
245  const VectorTag & tag = _subproblem.getVectorTag(*vector_tag);
247  }
248  _local_re.resize(_re_blocks[0]->size());
249 
250  _absre_blocks.resize(_abs_vector_tags.size());
251  vector_tag = _abs_vector_tags.begin();
252  for (MooseIndex(_abs_vector_tags) i = 0; i < _abs_vector_tags.size(); i++, ++vector_tag)
253  {
254  const VectorTag & tag = _subproblem.getVectorTag(*vector_tag);
255  _absre_blocks[i] =
256  &assembly.residualBlockNeighbor(ivar, Assembly::LocalDataKey{}, tag._type_id);
257  }
258 }
259 
260 void
261 TaggingInterface::prepareVectorTagLower(Assembly & assembly, unsigned int ivar)
262 {
263  _re_blocks.resize(_vector_tags.size());
264  mooseAssert(_vector_tags.size() >= 1, "we need at least one active tag");
265  auto vector_tag = _vector_tags.begin();
266  for (MooseIndex(_vector_tags) i = 0; i < _vector_tags.size(); i++, ++vector_tag)
267  {
268  const VectorTag & tag = _subproblem.getVectorTag(*vector_tag);
269  _re_blocks[i] = &assembly.residualBlockLower(ivar, Assembly::LocalDataKey{}, tag._type_id);
270  }
271  _local_re.resize(_re_blocks[0]->size());
272 
273  _absre_blocks.resize(_abs_vector_tags.size());
274  vector_tag = _abs_vector_tags.begin();
275  for (MooseIndex(_abs_vector_tags) i = 0; i < _abs_vector_tags.size(); i++, ++vector_tag)
276  {
277  const VectorTag & tag = _subproblem.getVectorTag(*vector_tag);
279  }
280 }
281 
282 void
283 TaggingInterface::prepareMatrixTag(Assembly & assembly, unsigned int ivar, unsigned int jvar)
284 {
285  _ke_blocks.resize(_matrix_tags.size());
286  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
287  auto mat_vector = _matrix_tags.begin();
288  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
289  _ke_blocks[i] = &assembly.jacobianBlock(ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
290 
291  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
292 }
293 
294 void
296  unsigned int ivar,
297  unsigned int jvar,
298  DenseMatrix<Number> & k) const
299 {
300  mooseAssert(!_matrix_tags.empty(), "No matrix tags exist");
301  const auto & ij_mat =
302  assembly.jacobianBlock(ivar, jvar, Assembly::LocalDataKey{}, *_matrix_tags.begin());
303  k.resize(ij_mat.m(), ij_mat.n());
304 }
305 
306 void
308  unsigned int ivar,
309  unsigned int jvar)
310 {
311  _ke_blocks.resize(_matrix_tags.size());
312  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
313  auto mat_vector = _matrix_tags.begin();
314  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
315  _ke_blocks[i] =
316  &assembly.jacobianBlockNonlocal(ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
317 
318  _nonlocal_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
319 }
320 
321 void
323  unsigned int ivar,
324  unsigned int jvar,
326 {
327  _ke_blocks.resize(_matrix_tags.size());
328  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
329  auto mat_vector = _matrix_tags.begin();
330  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
331  _ke_blocks[i] =
332  &assembly.jacobianBlockNeighbor(type, ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
333 
334  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
335 }
336 
337 void
339  unsigned int ivar,
340  unsigned int jvar,
342  DenseMatrix<Number> & k) const
343 {
344  mooseAssert(!_matrix_tags.empty(), "No matrix tags exist");
345  const auto & ij_mat = assembly.jacobianBlockNeighbor(
346  type, ivar, jvar, Assembly::LocalDataKey{}, *_matrix_tags.begin());
347  k.resize(ij_mat.m(), ij_mat.n());
348 }
349 
350 void
352  unsigned int ivar,
353  unsigned int jvar,
355 {
356  _ke_blocks.resize(_matrix_tags.size());
357  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
358  auto mat_vector = _matrix_tags.begin();
359  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
360  _ke_blocks[i] =
361  &assembly.jacobianBlockMortar(type, ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
362 
363  _local_ke.resize(_ke_blocks[0]->m(), _ke_blocks[0]->n());
364 }
365 
366 void
368 {
369  for (auto & re : _re_blocks)
370  *re += _local_re;
371  for (auto & absre : _absre_blocks)
372  for (const auto i : index_range(_local_re))
373  (*absre)(i) += std::abs(_local_re(i));
374 }
375 
376 void
378 {
379  for (auto & re : _re_blocks)
380  *re = _local_re;
381  for (auto & absre : _absre_blocks)
382  for (const auto i : index_range(_local_re))
383  (*absre)(i) = std::abs(_local_re(i));
384 }
385 
386 void
388 {
389  for (auto & ke : _ke_blocks)
390  *ke += _local_ke;
391 }
392 
393 void
395  const unsigned int ivar,
396  const unsigned int jvar,
397  const DenseMatrix<Number> & k)
398 {
399  _ke_blocks.resize(_matrix_tags.size());
400  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
401  auto mat_vector = _matrix_tags.begin();
402  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
403  _ke_blocks[i] = &assembly.jacobianBlock(ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
404  mooseAssert(_ke_blocks[0]->m() == k.m() && _ke_blocks[0]->n() == k.n(),
405  "Passed-in k must match the blocks we are about to sum into");
406  for (auto & ke : _ke_blocks)
407  *ke += k;
408 }
409 
410 void
412  const unsigned int ivar,
413  const unsigned int jvar,
414  const Moose::DGJacobianType type,
415  const DenseMatrix<Number> & k)
416 {
417  _ke_blocks.resize(_matrix_tags.size());
418  mooseAssert(_matrix_tags.size() >= 1, "we need at least one active tag");
419  auto mat_vector = _matrix_tags.begin();
420  for (MooseIndex(_matrix_tags) i = 0; i < _matrix_tags.size(); i++, ++mat_vector)
421  _ke_blocks[i] =
422  &assembly.jacobianBlockNeighbor(type, ivar, jvar, Assembly::LocalDataKey{}, *mat_vector);
423  mooseAssert(_ke_blocks[0]->m() == k.m() && _ke_blocks[0]->n() == k.n(),
424  "Passed-in k must match the blocks we are about to sum into");
425  for (auto & ke : _ke_blocks)
426  *ke += k;
427 }
428 
429 void
431 {
432  for (auto & ke : _ke_blocks)
433  *ke += _nonlocal_ke;
434 }
435 
436 void
438 {
439  for (auto & ke : _ke_blocks)
440  *ke = _local_ke;
441 }
442 
virtual TagID getVectorTagID(const TagName &tag_name) const
Get a TagID from a TagName.
Definition: SubProblem.C:203
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.
const InputParameters & _tag_params
Parameters from moose object.
void accumulateTaggedLocalResidual()
Local residual blocks will be appended by adding the current local kernel residual.
Keeps track of stuff related to assembling.
Definition: Assembly.h:101
unsigned int TagID
Definition: MooseTypes.h:210
DenseMatrix< Number > & jacobianBlockNonlocal(unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
Get local Jacobian block from non-local contribution for a pair of variables and a tag...
Definition: Assembly.h:1124
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
DenseMatrix< Number > & jacobianBlockNeighbor(Moose::DGJacobianType type, unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
Get local Jacobian block of a DG Jacobian type for a pair of variables and a tag. ...
Definition: Assembly.C:3117
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...
void resize(const unsigned int n)
T getCheckedPointerParam(const std::string &name, const std::string &error_string="") const
Verifies that the requested parameter exists and is not NULL and returns it to the caller...
TagTypeID _type_id
The index for this tag into a vector that contains tags of only its type ordered by ID...
Definition: VectorTag.h:47
void assignTaggedLocalResidual()
Local residual blocks will assigned as the current local kernel residual.
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...
unsigned int m() const
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.
std::set< TagID > _ref_vector_tags
A set of either size 1 or 0.
DenseMatrix< Number > & jacobianBlock(unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
Get local Jacobian block for a pair of variables and a tag.
Definition: Assembly.h:1113
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
DenseMatrix< Number > _local_ke
Holds local Jacobian entries as they are accumulated by this Kernel.
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
std::set< TagID > _abs_vector_tags
The absolute value residual tag ids.
InputParameters emptyInputParameters()
DenseMatrix< Number > & jacobianBlockMortar(Moose::ConstraintJacobianType type, unsigned int ivar, unsigned int jvar, LocalDataKey, TagID tag)
Returns the jacobian block for the given mortar Jacobian type.
Definition: Assembly.C:3158
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)
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.
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:28
virtual TagID getMatrixTagID(const TagName &tag_name) const
Get a TagID from a TagName.
Definition: SubProblem.C:342
std::set< TagID > _matrix_tags
The matrices this Kernel will contribute to.
virtual Moose::VectorTagType vectorTagType(const TagID tag_id) const
Definition: SubProblem.C:231
DenseVector< Number > & residualBlockLower(unsigned int var_num, LocalDataKey, TagID tag_id)
Get residual block for lower.
Definition: Assembly.h:1104
TagID referenceVectorTagID(ReferenceVectorTagIDKey) const
Returns the tag ID associated with the reference vector tag ID key.
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.
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
void accumulateTaggedLocalMatrix()
Local Jacobian blocks will be appended by adding the current local kernel Jacobian.
void useMatrixTag(const TagName &tag_name, MatrixTagsKey)
Uses a reference residual to define relative convergence criteria.
DGJacobianType
Definition: MooseTypes.h:749
void prepareVectorTagNeighbor(Assembly &assembly, unsigned int ivar)
Prepare data for computing element residual the according to active tags for DG and interface kernels...
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
DenseVector< Number > & residualBlockNeighbor(unsigned int var_num, LocalDataKey, TagID tag_id)
Get local neighbor residual block for a variable and a tag.
Definition: Assembly.h:1095
DenseVector< Number > & residualBlock(unsigned int var_num, LocalDataKey, TagID tag_id)
Get local residual block for a variable and a tag.
Definition: Assembly.h:1086
ConstraintJacobianType
Definition: MooseTypes.h:796
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.
void resize(const unsigned int new_m, const unsigned int new_n)
virtual ~TaggingInterface()
const InputParameters & parameters() const
Get the parameters of the object.
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
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...
unsigned int n() const
void prepareVectorTag(Assembly &assembly, unsigned int ivar)
Prepare data for computing element residual according to active tags.
void prepareMatrixTag(Assembly &assembly, unsigned int ivar, unsigned int jvar)
Prepare data for computing element jacobian according to the active tags.
Storage for all of the information pretaining to a vector tag.
Definition: VectorTag.h:17
DenseMatrix< Number > _nonlocal_ke
Holds nonlocal Jacobian entries as they are accumulated by this Kernel.
static InputParameters validParams()
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
Definition: SubProblem.C:161
auto index_range(const T &sizable)
Key structure for APIs adding/caching local element residuals/Jacobians.
Definition: Assembly.h:833
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...
virtual bool matrixTagExists(const TagName &tag_name) const
Check to see if a particular Tag exists.
Definition: SubProblem.C:328
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...