https://mooseframework.inl.gov
Coupleable.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 "Coupleable.h"
11 #include "Problem.h"
12 #include "SubProblem.h"
13 #include "FEProblem.h"
14 #include "MooseVariableScalar.h"
15 #include "MooseVariableFE.h"
16 #include "InputParameters.h"
17 #include "MooseObject.h"
18 #include "SystemBase.h"
19 #include "AuxiliarySystem.h"
20 
21 #include "AuxKernel.h"
22 #include "ElementUserObject.h"
23 #include "NodalUserObject.h"
24 #include "NodeFaceConstraint.h"
25 #include "NodeElemConstraintBase.h"
26 
27 Coupleable::Coupleable(const MooseObject * moose_object, bool nodal, bool is_fv)
28  : _c_parameters(moose_object->parameters()),
29  _c_name(moose_object->name()),
30  _c_type(moose_object->type()),
31  _c_fe_problem(*_c_parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
32  _c_sys(_c_parameters.isParamValid("_sys") ? _c_parameters.get<SystemBase *>("_sys") : nullptr),
33  _new_to_deprecated_coupled_vars(_c_parameters.getNewToDeprecatedVarMap()),
34  _c_nodal(nodal),
35  _c_is_implicit(_c_parameters.have_parameter<bool>("implicit")
36  ? _c_parameters.get<bool>("implicit")
37  : true),
38  _c_allow_element_to_nodal_coupling(
39  _c_parameters.have_parameter<bool>("_allow_nodal_to_elemental_coupling")
40  ? _c_parameters.get<bool>("_allow_nodal_to_elemental_coupling")
41  : false),
42  _c_tid(_c_parameters.get<THREAD_ID>("_tid")),
43  _zero(_c_fe_problem._zero[_c_tid]),
44  _phi_zero(_c_fe_problem._phi_zero[_c_tid]),
45  _ad_zero(_c_fe_problem._ad_zero[_c_tid]),
46  _grad_zero(_c_fe_problem._grad_zero[_c_tid]),
47  _ad_grad_zero(_c_fe_problem._ad_grad_zero[_c_tid]),
48  _grad_phi_zero(_c_fe_problem._grad_phi_zero[_c_tid]),
49  _second_zero(_c_fe_problem._second_zero[_c_tid]),
50  _ad_second_zero(_c_fe_problem._ad_second_zero[_c_tid]),
51  _second_phi_zero(_c_fe_problem._second_phi_zero[_c_tid]),
52  _vector_zero(_c_fe_problem._vector_zero[_c_tid]),
53  _vector_curl_zero(_c_fe_problem._vector_curl_zero[_c_tid]),
54  _coupleable_neighbor(_c_parameters.have_parameter<bool>("_neighbor")
55  ? _c_parameters.get<bool>("_neighbor")
56  : false),
57  _coupleable_max_qps(Moose::constMaxQpsPerElem),
58  _is_fv(is_fv),
59  _obj(moose_object),
60  _writable_coupled_variables(libMesh::n_threads())
61 {
62  SubProblem & problem = *_c_parameters.getCheckedPointerParam<SubProblem *>("_subproblem");
64 
65  unsigned int optional_var_index_counter = 0;
66 
67  // Coupling
68  for (auto iter = _c_parameters.coupledVarsBegin(); iter != _c_parameters.coupledVarsEnd(); ++iter)
69  {
70  std::string name = *iter;
71 
72  std::vector<std::string> vars = _c_parameters.getVecMooseType(name);
73  if (vars.size() > 0)
74  {
75  for (const auto & coupled_var_name : vars)
76  {
77  if (problem.hasVariable(coupled_var_name))
78  {
79  MooseVariableFieldBase * moose_var =
80  &problem.getVariable(_c_tid,
81  coupled_var_name,
84  _coupled_vars[name].push_back(moose_var);
85  _coupled_moose_vars.push_back(moose_var);
86  if (auto * tmp_var = dynamic_cast<MooseVariable *>(moose_var))
87  _coupled_standard_moose_vars.push_back(tmp_var);
88  else if (auto * tmp_var = dynamic_cast<VectorMooseVariable *>(moose_var))
89  _coupled_vector_moose_vars.push_back(tmp_var);
90  else if (auto * tmp_var = dynamic_cast<ArrayMooseVariable *>(moose_var))
91  _coupled_array_moose_vars.push_back(tmp_var);
92  else if (auto * tmp_var = dynamic_cast<MooseVariableFV<Real> *>(moose_var))
93  {
94  // We are using a finite volume variable through add*CoupledVar as opposed to getFunctor
95  // so we can be reasonably confident that the variable values will be obtained using
96  // traditional pre-evaluation and quadrature point indexing
97  tmp_var->requireQpComputations();
98  _coupled_fv_moose_vars.push_back(tmp_var);
99  }
100  else if (auto * tmp_var = dynamic_cast<MooseLinearVariableFV<Real> *>(moose_var))
101  _coupled_fv_moose_vars.push_back(tmp_var);
102  else
103  _obj->paramError(name, "provided c++ type for variable parameter is not supported");
104  }
105  else if (problem.hasScalarVariable(coupled_var_name))
106  {
107  MooseVariableScalar * moose_scalar_var =
108  &problem.getScalarVariable(_c_tid, coupled_var_name);
109  _c_coupled_scalar_vars[name].push_back(moose_scalar_var);
110  }
111  else
112  _obj->paramError(name, "coupled variable '", coupled_var_name, "' was not found");
113  }
114  }
115  else // This means it was optional coupling. Let's assign a unique id to this variable
116  {
118  for (unsigned int j = 0; j < _optional_var_index[name].size(); ++j)
120  std::numeric_limits<unsigned int>::max() - optional_var_index_counter;
121  ++optional_var_index_counter;
122  }
123  }
124 }
125 
126 #ifdef MOOSE_KOKKOS_ENABLED
128  : _c_parameters(object._c_parameters),
129  _c_name(object._c_name),
130  _c_type(object._c_type),
131  _c_fe_problem(object._c_fe_problem),
132  _c_sys(object._c_sys),
133  _new_to_deprecated_coupled_vars(object._new_to_deprecated_coupled_vars),
134  _c_nodal(object._c_nodal),
135  _c_is_implicit(object._c_is_implicit),
136  _c_allow_element_to_nodal_coupling(object._c_allow_element_to_nodal_coupling),
137  _c_tid(object._c_tid),
138  _zero(object._zero),
139  _phi_zero(object._phi_zero),
140  _ad_zero(object._ad_zero),
141  _grad_zero(object._grad_zero),
142  _ad_grad_zero(object._ad_grad_zero),
143  _grad_phi_zero(object._grad_phi_zero),
144  _second_zero(object._second_zero),
145  _ad_second_zero(object._ad_second_zero),
146  _second_phi_zero(object._second_phi_zero),
147  _vector_zero(object._vector_zero),
148  _vector_curl_zero(object._vector_curl_zero),
149  _coupleable_neighbor(object._coupleable_neighbor),
150  _coupleable_max_qps(object._coupleable_max_qps),
151  _is_fv(object._is_fv),
152  _obj(object._obj),
153  _writable_coupled_variables(object._writable_coupled_variables)
154 {
155 }
156 #endif
157 
158 bool
159 Coupleable::isCoupled(const std::string & var_name_in, unsigned int i) const
160 {
161  const auto var_name = _c_parameters.checkForRename(var_name_in);
162 
163  auto it = _coupled_vars.find(var_name);
164  if (it != _coupled_vars.end())
165  return (i < it->second.size());
166  else
167  {
168  // Make sure the user originally requested this value in the InputParameter syntax
169  if (!_c_parameters.hasCoupledValue(var_name))
171  ": The coupled variable \"",
172  var_name,
173  "\" was never added to this object's "
174  "InputParameters, please double-check your "
175  "spelling");
176 
177  return false;
178  }
179 }
180 
181 bool
182 Coupleable::isCoupledConstant(const std::string & var_name) const
183 {
184  return _c_parameters.hasDefaultCoupledValue(var_name);
185 }
186 
187 unsigned int
188 Coupleable::coupledComponents(const std::string & var_name_in) const
189 {
190  const auto var_name = _c_parameters.checkForRename(var_name_in);
191 
192  if (isCoupled(var_name))
193  {
194  mooseAssert(_coupled_vars.find(var_name) != _coupled_vars.end(),
195  var_name << " must not actually be coupled!");
196  return _coupled_vars.at(var_name).size();
197  }
198  else
199  {
201  return _c_parameters.numberDefaultCoupledValues(var_name);
202  else
203  return 0;
204  }
205 }
206 
207 void
209  unsigned int comp,
210  unsigned int bound,
211  const std::string & var_name)
212 {
213  if (bound > 0 && comp >= bound)
214  obj->paramError(
215  var_name, "component ", comp, " is out of range for this variable (max ", bound - 1, ")");
216 }
217 
218 // calls to this must go *after* get[bla]Var calls and (checking for nullptr
219 // return). Because checkFuncType calls coupledCallback which should only be
220 // called if the variables was actually coupled.
221 void
222 Coupleable::checkFuncType(const std::string var_name, VarType t, FuncAge age) const
223 {
224  if (t == VarType::Gradient && _c_nodal)
225  mooseError(_c_name, ": nodal variables do not have gradients at nodes");
226 
227  if (age == FuncAge::Old || age == FuncAge::Older || t == VarType::GradientDot ||
228  t == VarType::Dot)
229  validateExecutionerType(var_name, "coupled[Vector][Gradient/Dot]Old[er]");
230  if (age == FuncAge::Older && !_c_is_implicit)
231  mooseError("object '",
232  _c_name,
233  "' uses older variable values that are unavailable with explicit schemes");
234 
235  coupledCallback(var_name, age == FuncAge::Old || age == FuncAge::Older);
236 }
237 
238 bool
239 Coupleable::checkVar(const std::string & var_name_in,
240  unsigned int comp,
241  unsigned int comp_bound) const
242 {
243  const auto var_name = _c_parameters.checkForRename(var_name_in);
244  auto it = _c_coupled_scalar_vars.find(var_name);
245  if (it != _c_coupled_scalar_vars.end())
246  {
247  std::string cvars;
248  for (auto jt : it->second)
249  cvars += " " + jt->name();
250 
251  _obj->paramError(var_name,
252  "cannot couple '",
253  var_name,
254  "' to a scalar variable (",
255  cvars,
256  ") where field variable is expected");
257  }
258 
259  if (!isCoupled(var_name, comp))
260  return false; // return false since variable is *not* coupled
261 
262  auto vars_vector_it = _coupled_vars.find(var_name);
263  if (vars_vector_it == _coupled_vars.end())
264  mooseError(_c_name, ": Trying to get a coupled var ", var_name, " that doesn't exist");
265 
266  const auto & vars_vector = vars_vector_it->second;
267 
268  auto bound = comp_bound ? comp_bound : vars_vector.size();
269  checkComponent(_obj, comp, bound, var_name);
270 
271  // We should know we have a variable now
272  const auto * var = vars_vector[comp];
273  if (!var)
274  mooseError(
275  _c_name,
276  ": We did all our checks for the existence of a var, yet we still don't have a var!?");
277 
278  // Only perform the following checks for objects that feed into residuals/Jacobians, e.g. objects
279  // that inherit from the TaggingInterface
280  if (_c_parameters.have_parameter<MultiMooseEnum>("vector_tags"))
281  {
282  // Are we attempting to couple to a non-FV var in an FV object?
283  if (!var->isFV() && _is_fv)
284  mooseError("Attempting to couple non-FV variable ",
285  var->name(),
286  " into an FV object ",
287  _c_name,
288  ". This is not currently supported");
289  }
290 
291  if (!(vars_vector[comp])->isNodal() && _c_nodal && !_c_allow_element_to_nodal_coupling)
292  mooseError(_c_name, ": cannot couple elemental variables into nodal objects");
293 
294  return true;
295 }
296 
298 Coupleable::getFEVar(const std::string & var_name, unsigned int comp) const
299 {
300  mooseDeprecated("Coupleable::getFEVar is deprecated. Please use Coupleable::getFieldVar instead. "
301  "Note that this method could potentially return a finite volume variable");
302  return getFieldVar(var_name, comp);
303 }
304 
306 Coupleable::getFieldVar(const std::string & var_name, unsigned int comp)
307 {
308  return getVarHelper<MooseVariableFieldBase>(var_name, comp);
309 }
310 
312 Coupleable::getFieldVar(const std::string & var_name, unsigned int comp) const
313 {
314  return getVarHelper<MooseVariableFieldBase>(var_name, comp);
315 }
316 
318 Coupleable::getVar(const std::string & var_name, unsigned int comp)
319 {
320  return const_cast<MooseVariable *>(getVarHelper<MooseVariable>(var_name, comp));
321 }
322 
324 Coupleable::getVectorVar(const std::string & var_name, unsigned int comp)
325 {
326  auto * const var =
327  const_cast<VectorMooseVariable *>(getVarHelper<VectorMooseVariable>(var_name, comp));
328 
329  if (_c_nodal && var && var->feType().family != LAGRANGE_VEC)
330  mooseError(_c_name, ": Only LAGRANGE_VEC vector variables are defined at nodes");
331 
332  return var;
333 }
334 
336 Coupleable::getArrayVar(const std::string & var_name, unsigned int comp)
337 {
338  return const_cast<ArrayMooseVariable *>(getVarHelper<ArrayMooseVariable>(var_name, comp));
339 }
340 
341 const MooseVariable *
342 Coupleable::getVar(const std::string & var_name, unsigned int comp) const
343 {
344  return getVarHelper<MooseVariable>(var_name, comp);
345 }
346 
347 const VectorMooseVariable *
348 Coupleable::getVectorVar(const std::string & var_name, unsigned int comp) const
349 {
350  const auto * const var = getVarHelper<VectorMooseVariable>(var_name, comp);
351 
352  if (_c_nodal && var && var->feType().family != LAGRANGE_VEC)
353  mooseError(_c_name, ": Only LAGRANGE_VEC vector variables are defined at nodes");
354 
355  return var;
356 }
357 
358 const ArrayMooseVariable *
359 Coupleable::getArrayVar(const std::string & var_name, unsigned int comp) const
360 {
361  return getVarHelper<ArrayMooseVariable>(var_name, comp);
362 }
363 
364 const VariableValue *
365 Coupleable::getDefaultValue(const std::string & var_name, unsigned int comp) const
366 {
367  // make sure we don't access values that were not provided
368  checkComponent(_obj, comp, _c_parameters.numberDefaultCoupledValues(var_name), var_name);
369 
370  auto default_value_it = _default_value.find(var_name);
371  if (default_value_it == _default_value.end())
372  {
373  _default_value[var_name].emplace_back(std::make_unique<VariableValue>(
375  for (unsigned int j = 1; j < _c_parameters.numberDefaultCoupledValues(var_name); ++j)
376  _default_value[var_name].emplace_back(std::make_unique<VariableValue>(
378  default_value_it = _default_value.find(var_name);
379  }
380 
381  const auto & default_value_vec = default_value_it->second;
382  const auto n_default_vals = default_value_vec.size();
383  if (comp >= n_default_vals)
384  mooseError("Requested comp ",
385  comp,
386  " is equal to or greater than the number of default values ",
387  n_default_vals);
388  return default_value_vec[comp].get();
389 }
390 
391 const VectorVariableValue *
392 Coupleable::getDefaultVectorValue(const std::string & var_name) const
393 {
394  auto default_value_it = _default_vector_value.find(var_name);
395  if (default_value_it == _default_vector_value.end())
396  {
397  auto value = std::make_unique<VectorVariableValue>(_coupleable_max_qps, 0);
398  bool already_warned = false;
399  for (unsigned int qp = 0; qp < _coupleable_max_qps; ++qp)
400  for (const auto i : make_range(Moose::dim))
401  {
402  try
403  {
404  (*value)[qp](i) = _c_parameters.defaultCoupledValue(var_name, i);
405  }
406  catch (const std::out_of_range &)
407  {
408  if (!already_warned)
409  mooseWarning(
410  "You supplied less than 3 arguments for the default vector value for variable ",
411  var_name,
412  ". Did you accidently leave something off? We are going to assign 0s, assuming "
413  "this "
414  "was intentional.");
415  already_warned = true;
416  (*value)[qp](i) = 0;
417  }
418  }
419  default_value_it =
420  _default_vector_value.insert(std::make_pair(var_name, std::move(value))).first;
421  }
422 
423  return default_value_it->second.get();
424 }
425 
426 const ArrayVariableValue *
427 Coupleable::getDefaultArrayValue(const std::string & var_name) const
428 {
429  auto default_value_it = _default_array_value.find(var_name);
430  if (default_value_it == _default_array_value.end())
431  {
432  auto value = std::make_unique<ArrayVariableValue>(_coupleable_max_qps);
433  for (unsigned int qp = 0; qp < _coupleable_max_qps; ++qp)
434  {
435  auto n = _c_parameters.numberDefaultCoupledValues(var_name);
436  (*value)[qp].resize(n);
437  for (unsigned int i = 0; i < n; ++i)
438  (*value)[qp](i) = _c_parameters.defaultCoupledValue(var_name, i);
439  }
440  default_value_it =
441  _default_array_value.insert(std::make_pair(var_name, std::move(value))).first;
442  }
443 
444  return default_value_it->second.get();
445 }
446 
447 template <typename T>
448 const T &
449 Coupleable::getDefaultNodalValue(const std::string & var_name, unsigned int comp) const
450 {
451  auto && default_variable_value = getDefaultValue(var_name, comp);
452  return *default_variable_value->data();
453 }
454 
455 template <>
456 const RealVectorValue &
457 Coupleable::getDefaultNodalValue<RealVectorValue>(const std::string & var_name, unsigned int) const
458 {
459  auto && default_variable_value = getDefaultVectorValue(var_name);
460  return *default_variable_value->data();
461 }
462 
463 template <>
464 const RealEigenVector &
465 Coupleable::getDefaultNodalValue<RealEigenVector>(const std::string & var_name, unsigned int) const
466 {
467  auto && default_variable_value = getDefaultArrayValue(var_name);
468  return *default_variable_value->data();
469 }
470 
471 unsigned int
472 Coupleable::coupled(const std::string & var_name, unsigned int comp) const
473 {
474  const auto * var = getFieldVar(var_name, comp);
475  if (!var)
476  {
477  mooseAssert(_optional_var_index.find(var_name) != _optional_var_index.end(),
478  "optional var index for " << var_name << " does not exist!");
479  // make sure we don't try to access default var ids that were not provided
480  checkComponent(_obj, comp, _optional_var_index.at(var_name).size(), var_name);
481  return _optional_var_index.at(var_name)[comp];
482  }
484 
485  if (var->kind() == Moose::VAR_SOLVER &&
486  // are we not an object that feeds into the nonlinear system?
487  (!_c_sys || _c_sys->varKind() != Moose::VAR_SOLVER ||
488  // are we an object that impacts the nonlinear system and this variable is within our
489  // nonlinear system?
490  var->sys().number() == _c_sys->number()))
491  return var->number();
492  else
493  // Avoid registering coupling to variables outside of our system (e.g. avoid potentially
494  // creating bad Jacobians)
495  return std::numeric_limits<unsigned int>::max() - var->number();
496 }
497 
498 template <>
500 Coupleable::coupledGenericValue<false>(const std::string & var_name, unsigned int comp) const
501 {
502  return coupledValue(var_name, comp);
503 }
504 
505 template <>
507 Coupleable::coupledGenericValue<true>(const std::string & var_name, unsigned int comp) const
508 {
509  return adCoupledValue(var_name, comp);
510 }
511 
512 template <>
514 Coupleable::coupledGenericVectorValue<false>(const std::string & var_name, unsigned int comp) const
515 {
516  return coupledVectorValue(var_name, comp);
517 }
518 
519 template <>
521 Coupleable::coupledGenericVectorValue<true>(const std::string & var_name, unsigned int comp) const
522 {
523  return adCoupledVectorValue(var_name, comp);
524 }
525 
526 const VariableValue &
527 Coupleable::coupledValue(const std::string & var_name, unsigned int comp) const
528 {
529  const auto * const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
530  if (!var)
531  return *getDefaultValue(var_name, comp);
533 
535  {
536  if (_c_nodal)
537  return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
538  else
539  return (_c_is_implicit) ? var->sln() : var->slnOld();
540  }
541  else
542  {
543  if (_c_nodal)
544  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
545  else
546  return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
547  }
548 }
549 
550 template <typename T>
551 const typename OutputTools<T>::VariableValue &
552 Coupleable::vectorTagValueHelper(const std::string & var_names,
553  const TagID tag,
554  const unsigned int index) const
555 {
556  const auto * const var = getVarHelper<MooseVariableField<T>>(var_names, index);
557  if (!var)
558  mooseError(var_names, ": invalid variable name for coupledVectorTagValue");
560 
561  if (!_c_fe_problem.vectorTagExists(tag))
562  mooseError("Attempting to couple to vector tag with ID ",
563  tag,
564  "in ",
565  _c_name,
566  ", but a vector tag with that ID does not exist");
567 
568  const_cast<Coupleable *>(this)->addFEVariableCoupleableVectorTag(tag);
569 
570  if (_c_nodal)
571  return var->nodalVectorTagValue(tag);
572  else
573  return var->vectorTagValue(tag);
574 }
575 
576 template <typename T>
577 void
578 Coupleable::requestStates(const std::string & var_name,
579  const TagName & tag_name,
580  const unsigned int comp)
581 {
582  auto var =
583  const_cast<MooseVariableField<T> *>(getVarHelper<MooseVariableField<T>>(var_name, comp));
584  if (!var)
585  mooseError(var_name, ": invalid variable name for tag coupling");
586 
587  auto & var_sys = var->sys();
588  if (tag_name == Moose::OLD_SOLUTION_TAG)
589  var_sys.needSolutionState(1);
590  else if (tag_name == Moose::OLDER_SOLUTION_TAG)
591  var_sys.needSolutionState(2);
592 }
593 
594 template <typename T>
595 const typename OutputTools<T>::VariableValue &
596 Coupleable::vectorTagValueHelper(const std::string & var_names,
597  const std::string & tag_param_name,
598  const unsigned int index) const
599 {
600  if (!_c_parameters.isParamValid(tag_param_name))
601  mooseError("Tag name parameter '", tag_param_name, "' is invalid");
602 
603  const TagName tag_name = MooseUtils::toUpper(_c_parameters.get<TagName>(tag_param_name));
604 
605  const bool older_state_tag = _older_state_tags.count(tag_name);
606  if (older_state_tag)
607  // We may need to add solution states and create vector tags
608  const_cast<Coupleable *>(this)->requestStates<T>(var_names, tag_name, index);
609 
610  if (!_c_fe_problem.vectorTagExists(tag_name))
611  mooseError("Tagged vector with tag name '", tag_name, "' does not exist");
612 
613  TagID tag = _c_fe_problem.getVectorTagID(tag_name);
614  return vectorTagValueHelper<T>(var_names, tag, index);
615 }
616 
617 template <>
619 Coupleable::coupledGenericDofValue<false>(const std::string & var_name, unsigned int comp) const
620 {
621  return coupledDofValues(var_name, comp);
622 }
623 
624 template <>
626 Coupleable::coupledGenericDofValue<true>(const std::string & var_name, unsigned int comp) const
627 {
628  return adCoupledDofValues(var_name, comp);
629 }
630 
631 const VariableValue &
632 Coupleable::coupledValueLower(const std::string & var_name, const unsigned int comp) const
633 {
634  const auto * var = getVar(var_name, comp);
635  if (!var)
636  return *getDefaultValue(var_name, comp);
638 
640  mooseError(_c_name, ":coupledValueLower cannot be called in a coupleable neighbor object");
641 
642  if (_c_nodal)
643  return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
644  else
645  return (_c_is_implicit) ? var->slnLower() : var->slnLowerOld();
646 }
647 
648 const VariableValue &
649 Coupleable::coupledVectorTagValue(const std::string & var_names,
650  TagID tag,
651  unsigned int index) const
652 {
653  return vectorTagValueHelper<Real>(var_names, tag, index);
654 }
655 
656 const VariableValue &
657 Coupleable::coupledVectorTagValue(const std::string & var_names,
658  const std::string & tag_name,
659  unsigned int index) const
660 {
661  return vectorTagValueHelper<Real>(var_names, tag_name, index);
662 }
663 
664 const ArrayVariableValue &
665 Coupleable::coupledVectorTagArrayValue(const std::string & var_names,
666  TagID tag,
667  unsigned int index) const
668 {
669  return vectorTagValueHelper<RealEigenVector>(var_names, tag, index);
670 }
671 
672 const ArrayVariableValue &
673 Coupleable::coupledVectorTagArrayValue(const std::string & var_names,
674  const std::string & tag_name,
675  unsigned int index) const
676 {
677  return vectorTagValueHelper<RealEigenVector>(var_names, tag_name, index);
678 }
679 
680 const VariableGradient &
681 Coupleable::coupledVectorTagGradient(const std::string & var_names,
682  TagID tag,
683  unsigned int index) const
684 {
685  const auto * var = getVar(var_names, index);
686  if (!var)
687  mooseError(var_names, ": invalid variable name for coupledVectorTagGradient");
689 
690  if (!_c_fe_problem.vectorTagExists(tag))
691  mooseError("Attempting to couple to vector tag with ID ",
692  tag,
693  "in ",
694  _c_name,
695  ", but a vector tag with that ID does not exist");
696 
697  const_cast<Coupleable *>(this)->addFEVariableCoupleableVectorTag(tag);
698 
699  return var->vectorTagGradient(tag);
700 }
701 
702 const VariableGradient &
703 Coupleable::coupledVectorTagGradient(const std::string & var_names,
704  const std::string & tag_name,
705  unsigned int index) const
706 {
707  if (!_c_parameters.isParamValid(tag_name))
708  mooseError("Tag name parameter '", tag_name, "' is invalid");
709 
710  TagName tagname = _c_parameters.get<TagName>(tag_name);
711  if (!_c_fe_problem.vectorTagExists(tagname))
712  mooseError("Tagged vector with tag name '", tagname, "' does not exist");
713 
714  TagID tag = _c_fe_problem.getVectorTagID(tagname);
715  return coupledVectorTagGradient(var_names, tag, index);
716 }
717 
718 const ArrayVariableGradient &
719 Coupleable::coupledVectorTagArrayGradient(const std::string & var_names,
720  TagID tag,
721  unsigned int index) const
722 {
723  const auto * var = getArrayVar(var_names, index);
724  if (!var)
725  mooseError(var_names, ": invalid variable name for coupledVectorTagArrayGradient");
727 
728  if (!_c_fe_problem.vectorTagExists(tag))
729  mooseError("Attempting to couple to vector tag with ID ",
730  tag,
731  "in ",
732  _c_name,
733  ", but a vector tag with that ID does not exist");
734 
735  const_cast<Coupleable *>(this)->addFEVariableCoupleableVectorTag(tag);
736 
737  return var->vectorTagGradient(tag);
738 }
739 
740 const ArrayVariableGradient &
741 Coupleable::coupledVectorTagArrayGradient(const std::string & var_names,
742  const std::string & tag_name,
743  unsigned int index) const
744 {
745  if (!_c_parameters.isParamValid(tag_name))
746  mooseError("Tag name parameter '", tag_name, "' is invalid");
747 
748  TagName tagname = _c_parameters.get<TagName>(tag_name);
749  if (!_c_fe_problem.vectorTagExists(tagname))
750  mooseError("Tagged vector with tag name '", tagname, "' does not exist");
751 
752  TagID tag = _c_fe_problem.getVectorTagID(tagname);
753  return coupledVectorTagArrayGradient(var_names, tag, index);
754 }
755 
756 template <typename T>
757 const typename OutputTools<T>::VariableValue &
758 Coupleable::vectorTagDofValueHelper(const std::string & var_name,
759  const TagID tag,
760  const unsigned int comp) const
761 {
762  const auto * var = getVarHelper<MooseVariableField<T>>(var_name, comp);
763  if (!var)
764  mooseError(var_name, ": invalid variable name for coupledVectorTagDofValue");
766 
767  const_cast<Coupleable *>(this)->addFEVariableCoupleableVectorTag(tag);
768 
769  return var->vectorTagDofValue(tag);
770 }
771 
772 template <typename T>
773 const typename OutputTools<T>::VariableValue &
774 Coupleable::vectorTagDofValueHelper(const std::string & var_name,
775  const std::string & tag_param_name,
776  const unsigned int comp) const
777 {
778  if (!_c_parameters.isParamValid(tag_param_name))
779  mooseError("Tag name parameter '", tag_param_name, "' is invalid");
780 
781  const TagName tag_name = MooseUtils::toUpper(_c_parameters.get<TagName>(tag_param_name));
782 
783  const bool older_state_tag = _older_state_tags.count(tag_name);
784  if (older_state_tag)
785  // We may need to add solution states and create vector tags
786  const_cast<Coupleable *>(this)->requestStates<T>(var_name, tag_name, comp);
787 
788  if (!_c_fe_problem.vectorTagExists(tag_name))
789  mooseError("Tagged vector with tag name '", tag_name, "' does not exist");
790 
791  TagID tag = _c_fe_problem.getVectorTagID(tag_name);
792 
793  return vectorTagDofValueHelper<T>(var_name, tag, comp);
794 }
795 
796 const VariableValue &
797 Coupleable::coupledVectorTagDofValue(const std::string & var_name,
798  TagID tag,
799  unsigned int comp) const
800 {
801  return vectorTagDofValueHelper<Real>(var_name, tag, comp);
802 }
803 
804 const VariableValue &
805 Coupleable::coupledVectorTagDofValue(const std::string & var_name,
806  const std::string & tag_name,
807  unsigned int comp) const
808 {
809  return vectorTagDofValueHelper<Real>(var_name, tag_name, comp);
810 }
811 
812 const ArrayVariableValue &
813 Coupleable::coupledVectorTagArrayDofValue(const std::string & var_name,
814  const std::string & tag_name,
815  unsigned int comp) const
816 {
817  return vectorTagDofValueHelper<RealEigenVector>(var_name, tag_name, comp);
818 }
819 
820 const VariableValue &
821 Coupleable::coupledMatrixTagValue(const std::string & var_names,
822  TagID tag,
823  unsigned int index) const
824 {
825  const auto * var = getVarHelper<MooseVariableField<Real>>(var_names, index);
826  if (!var)
827  mooseError(var_names, ": invalid variable name for coupledMatrixTagValue");
829 
830  const_cast<Coupleable *>(this)->addFEVariableCoupleableMatrixTag(tag);
831 
832  if (_c_nodal)
833  return var->nodalMatrixTagValue(tag);
834  return var->matrixTagValue(tag);
835 }
836 
837 const VariableValue &
838 Coupleable::coupledMatrixTagValue(const std::string & var_names,
839  const std::string & tag_name,
840  unsigned int index) const
841 {
842  if (!_c_parameters.isParamValid(tag_name))
843  mooseError("Tag name parameter '", tag_name, "' is invalid");
844 
845  TagName tagname = _c_parameters.get<TagName>(tag_name);
846  if (!_c_fe_problem.matrixTagExists(tagname))
847  mooseError("Matrix tag name '", tagname, "' does not exist");
848 
849  TagID tag = _c_fe_problem.getMatrixTagID(tagname);
850  return coupledMatrixTagValue(var_names, tag, index);
851 }
852 
853 const VectorVariableValue &
854 Coupleable::coupledVectorValue(const std::string & var_name, unsigned int comp) const
855 {
856  const auto * var = getVectorVar(var_name, comp);
857  if (!var)
858  return *getDefaultVectorValue(var_name);
860 
862  {
863  if (_c_nodal)
864  return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
865  else
866  return _c_is_implicit ? var->sln() : var->slnOld();
867  }
868  else
869  {
870  if (_c_nodal)
871  // Since this is at a node, I don't feel like there should be any "neighbor" logic
872  return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
873  else
874  return _c_is_implicit ? var->slnNeighbor() : var->slnOldNeighbor();
875  }
876 }
877 
878 const ArrayVariableValue &
879 Coupleable::coupledArrayValue(const std::string & var_name, unsigned int comp) const
880 {
881  const auto * var = getArrayVar(var_name, comp);
882  if (!var)
883  return *getDefaultArrayValue(var_name);
885 
887  {
888  if (_c_nodal)
889  return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
890  return (_c_is_implicit) ? var->sln() : var->slnOld();
891  }
892  else
893  {
894  if (_c_nodal)
895  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
896  return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
897  }
898 }
899 
900 std::vector<const ArrayVariableValue *>
901 Coupleable::coupledArrayValues(const std::string & var_name) const
902 {
903  auto func = [this, &var_name](unsigned int comp) { return &coupledArrayValue(var_name, comp); };
904  return coupledVectorHelper<const ArrayVariableValue *>(var_name, func);
905 }
906 
908 Coupleable::writableVariable(const std::string & var_name, unsigned int comp)
909 {
910  auto * var = getVarHelper<MooseWritableVariable>(var_name, comp);
911 
912  const auto * aux = dynamic_cast<const AuxKernel *>(this);
913  const auto * euo = dynamic_cast<const ElementUserObject *>(this);
914  const auto * nuo = dynamic_cast<const NodalUserObject *>(this);
915  const auto * nfc = dynamic_cast<const NodeFaceConstraint *>(this);
916  const auto * nec = dynamic_cast<const NodeElemConstraintBase *>(this);
917 
918  if (!aux && !euo && !nuo && !nfc && !nec)
919  mooseError("writableVariable() can only be called from AuxKernels, ElementUserObjects, "
920  "NodalUserObjects, NodeFaceConstraints, or NodeElemConstraints. '",
921  _obj->name(),
922  "' is none of those.");
923 
924  if (aux && !aux->isNodal() && var->isNodal())
925  mooseError("The elemental AuxKernel '",
926  _obj->name(),
927  "' cannot obtain a writable reference to the nodal variable '",
928  var->name(),
929  "'.");
930  if (euo && var->isNodal())
931  mooseError("The ElementUserObject '",
932  _obj->name(),
933  "' cannot obtain a writable reference to the nodal variable '",
934  var->name(),
935  "'.");
936 
937  // make sure only one object can access a variable
938  checkWritableVar(var);
939 
940  return *var;
941 }
942 
944 Coupleable::writableCoupledValue(const std::string & var_name, unsigned int comp)
945 {
946  mooseDeprecated("Coupleable::writableCoupledValue is deprecated, please use "
947  "Coupleable::writableVariable instead. ");
948 
949  // check if the variable exists
950  auto * const var = getVar(var_name, comp);
951  if (!var)
952  mooseError(
953  "Unable to create a writable reference for '", var_name, "', is it a constant expression?");
954 
955  // is the requested variable an AuxiliaryVariable?
956  if (!_c_fe_problem.getAuxiliarySystem().hasVariable(var->name()))
957  mooseError(
958  "'", var->name(), "' must be an auxiliary variable in Coupleable::writableCoupledValue");
959 
960  // check that the variable type (elemental/nodal) is compatible with the object type
961  const auto * aux = dynamic_cast<const AuxKernel *>(this);
962 
963  if (!aux)
964  mooseError("writableCoupledValue() can only be called from AuxKernels, but '",
965  _obj->name(),
966  "' is not an AuxKernel.");
967 
968  if (!aux->isNodal() && var->isNodal())
969  mooseError("The elemental AuxKernel '",
970  _obj->name(),
971  "' cannot obtain a writable reference to the nodal variable '",
972  var->name(),
973  "'.");
974 
975  // make sure only one object can access a variable
976  checkWritableVar(var);
977 
978  return const_cast<VariableValue &>(coupledValue(var_name, comp));
979 }
980 
981 void
983 {
984  // check domain restrictions for compatibility
985  const auto * br = dynamic_cast<const BlockRestrictable *>(this);
986  const auto * nfc = dynamic_cast<const NodeFaceConstraint *>(this);
987 
988  if (br && !var->hasBlocks(br->blockIDs()))
989  mooseError("The variable '",
990  var->name(),
991  "' must be defined on all blocks '",
992  _obj->name(),
993  "' is defined on.");
994 
995  if (nfc && !var->hasBlocks(nfc->getSecondaryConnectedBlocks()))
996  mooseError("The variable '",
997  var->name(),
998  " must be defined on all blocks '",
999  _obj->name(),
1000  "'s secondary surface is defined on.");
1001 
1002  // make sure only one object can access a variable
1003  for (const auto & ci : _obj->getMooseApp().getInterfaceObjects<Coupleable>())
1004  if (ci != this && ci->_writable_coupled_variables[_c_tid].count(var))
1005  {
1006  // if both this and ci are block restrictable then we check if the block restrictions
1007  // are not overlapping. If they don't we permit the call.
1008  const auto * br_other = dynamic_cast<const BlockRestrictable *>(ci);
1009  if (br && br_other && br->blockRestricted() && br_other->blockRestricted() &&
1010  !MooseUtils::setsIntersect(br->blockIDs(), br_other->blockIDs()))
1011  continue;
1012  else if (nfc)
1013  continue;
1014 
1015  mooseError("'",
1016  ci->_obj->name(),
1017  "' already obtained a writable reference to '",
1018  var->name(),
1019  "'. Only one object can obtain such a reference per variable and subdomain in a "
1020  "simulation.");
1021  }
1022 
1023  // var is unique across threads, so we could forego having a separate set per thread, but we
1024  // need quick access to the list of all variables that need to be inserted into the solution
1025  // vector by a given thread.
1026 
1027  _writable_coupled_variables[_c_tid].insert(var);
1028 }
1029 
1030 const VariableValue &
1031 Coupleable::coupledValueOld(const std::string & var_name, unsigned int comp) const
1032 {
1033  const auto * var = getVar(var_name, comp);
1034  if (!var)
1035  return *getDefaultValue(var_name, comp);
1037 
1038  if (!_coupleable_neighbor)
1039  {
1040  if (_c_nodal)
1041  return (_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1042  return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
1043  }
1044  else
1045  {
1046  if (_c_nodal)
1047  return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1048  return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1049  }
1050 }
1051 
1052 const VariableValue &
1053 Coupleable::coupledValueOlder(const std::string & var_name, unsigned int comp) const
1054 {
1055  const auto * var = getVar(var_name, comp);
1056  if (!var)
1057  return *getDefaultValue(var_name, comp);
1059 
1060  if (!_coupleable_neighbor)
1061  {
1062  if (_c_nodal)
1063  return var->dofValuesOlder();
1064  return var->slnOlder();
1065  }
1066  else
1067  {
1068  if (_c_nodal)
1069  return var->dofValuesOlderNeighbor();
1070  return var->slnOlderNeighbor();
1071  }
1072 }
1073 
1074 const VariableValue &
1075 Coupleable::coupledValuePreviousNL(const std::string & var_name, unsigned int comp) const
1076 {
1077  const auto * var = getVar(var_name, comp);
1078  if (!var)
1079  return *getDefaultValue(var_name, comp);
1081 
1083  if (!_coupleable_neighbor)
1084  {
1085  if (_c_nodal)
1086  return var->dofValuesPreviousNL();
1087  return var->slnPreviousNL();
1088  }
1089  else
1090  {
1091  if (_c_nodal)
1092  return var->dofValuesPreviousNLNeighbor();
1093  return var->slnPreviousNLNeighbor();
1094  }
1095 }
1096 
1097 const VectorVariableValue &
1098 Coupleable::coupledVectorValueOld(const std::string & var_name, unsigned int comp) const
1099 {
1100  const auto * var = getVectorVar(var_name, comp);
1101  if (!var)
1102  return *getDefaultVectorValue(var_name);
1104 
1105  if (_c_nodal)
1106  return (_c_is_implicit) ? var->nodalValueOldArray() : var->nodalValueOlderArray();
1107  if (!_coupleable_neighbor)
1108  return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
1109  return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1110 }
1111 
1112 const VectorVariableValue &
1113 Coupleable::coupledVectorValueOlder(const std::string & var_name, unsigned int comp) const
1114 {
1115  const auto * var = getVectorVar(var_name, comp);
1116  if (!var)
1117  return *getDefaultVectorValue(var_name);
1119 
1120  if (!_coupleable_neighbor)
1121  return var->slnOlder();
1122  return var->slnOlderNeighbor();
1123 }
1124 
1125 const ArrayVariableValue &
1126 Coupleable::coupledArrayValueOld(const std::string & var_name, unsigned int comp) const
1127 {
1128  const auto * var = getArrayVar(var_name, comp);
1129  if (!var)
1130  return *getDefaultArrayValue(var_name);
1132 
1133  if (!_coupleable_neighbor)
1134  {
1135  if (_c_nodal)
1136  return (_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1137  return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
1138  }
1139  else
1140  {
1141  if (_c_nodal)
1142  return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1143  return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1144  }
1145 }
1146 
1147 const ArrayVariableValue &
1148 Coupleable::coupledArrayValueOlder(const std::string & var_name, unsigned int comp) const
1149 {
1150  const auto * var = getArrayVar(var_name, comp);
1151  if (!var)
1152  return *getDefaultArrayValue(var_name);
1154 
1155  if (!_coupleable_neighbor)
1156  {
1157  if (_c_nodal)
1158  return var->dofValuesOlder();
1159  return var->slnOlder();
1160  }
1161  else
1162  {
1163  if (_c_nodal)
1164  return var->dofValuesOlderNeighbor();
1165  return var->slnOlderNeighbor();
1166  }
1167 }
1168 
1169 const VariableValue &
1170 Coupleable::coupledDot(const std::string & var_name, unsigned int comp) const
1171 {
1172  const auto * var = getVar(var_name, comp);
1173  if (!var)
1174  {
1176  return _default_value_zero;
1177  }
1179 
1180  if (!_coupleable_neighbor)
1181  {
1182  if (_c_nodal)
1183  return var->dofValuesDot();
1184  return var->uDot();
1185  }
1186  else
1187  {
1188  if (_c_nodal)
1189  return var->dofValuesDotNeighbor();
1190  return var->uDotNeighbor();
1191  }
1192 }
1193 
1194 const VariableValue &
1195 Coupleable::coupledDotDot(const std::string & var_name, unsigned int comp) const
1196 {
1197  const auto * var = getVar(var_name, comp);
1198  if (!var)
1199  {
1201  return _default_value_zero;
1202  }
1204 
1205  if (!_coupleable_neighbor)
1206  {
1207  if (_c_nodal)
1208  return var->dofValuesDotDot();
1209  return var->uDotDot();
1210  }
1211  else
1212  {
1213  if (_c_nodal)
1214  return var->dofValuesDotDotNeighbor();
1215  return var->uDotDotNeighbor();
1216  }
1217 }
1218 
1219 template <>
1221 Coupleable::coupledGenericDotDot<false>(const std::string & var_name, unsigned int comp) const
1222 {
1223  return coupledDotDot(var_name, comp);
1224 }
1225 
1226 template <>
1228 Coupleable::coupledGenericDotDot<true>(const std::string & var_name, unsigned int comp) const
1229 {
1230  return adCoupledDotDot(var_name, comp);
1231 }
1232 
1233 const VariableValue &
1234 Coupleable::coupledDotOld(const std::string & var_name, unsigned int comp) const
1235 {
1236  const auto * var = getVar(var_name, comp);
1237  if (!var)
1238  {
1240  return _default_value_zero;
1241  }
1243 
1244  if (!_coupleable_neighbor)
1245  {
1246  if (_c_nodal)
1247  return var->dofValuesDotOld();
1248  return var->uDotOld();
1249  }
1250  else
1251  {
1252  if (_c_nodal)
1253  return var->dofValuesDotOldNeighbor();
1254  return var->uDotOldNeighbor();
1255  }
1256 }
1257 
1258 const VariableValue &
1259 Coupleable::coupledDotDotOld(const std::string & var_name, unsigned int comp) const
1260 {
1261  const auto * var = getVar(var_name, comp);
1262  if (!var)
1263  {
1265  return _default_value_zero;
1266  }
1268 
1269  if (!_coupleable_neighbor)
1270  {
1271  if (_c_nodal)
1272  return var->dofValuesDotDotOld();
1273  return var->uDotDotOld();
1274  }
1275  else
1276  {
1277  if (_c_nodal)
1278  return var->dofValuesDotDotOldNeighbor();
1279  return var->uDotDotOldNeighbor();
1280  }
1281 }
1282 
1283 const VectorVariableValue &
1284 Coupleable::coupledVectorDot(const std::string & var_name, unsigned int comp) const
1285 {
1286  const auto * var = getVectorVar(var_name, comp);
1287  if (!var)
1288  {
1291  }
1293 
1294  if (!_coupleable_neighbor)
1295  return var->uDot();
1296  return var->uDotNeighbor();
1297 }
1298 
1299 const VectorVariableValue &
1300 Coupleable::coupledVectorDotDot(const std::string & var_name, unsigned int comp) const
1301 {
1302  const auto * var = getVectorVar(var_name, comp);
1303  if (!var)
1304  {
1307  }
1309 
1310  if (!_coupleable_neighbor)
1311  return var->uDotDot();
1312  return var->uDotDotNeighbor();
1313 }
1314 
1315 const VectorVariableValue &
1316 Coupleable::coupledVectorDotOld(const std::string & var_name, unsigned int comp) const
1317 {
1318  const auto * var = getVectorVar(var_name, comp);
1319  if (!var)
1320  {
1323  }
1325 
1326  if (!_coupleable_neighbor)
1327  return var->uDotOld();
1328  return var->uDotOldNeighbor();
1329 }
1330 
1331 const VectorVariableValue &
1332 Coupleable::coupledVectorDotDotOld(const std::string & var_name, unsigned int comp) const
1333 {
1334  const auto * var = getVectorVar(var_name, comp);
1335  if (!var)
1336  {
1339  }
1341 
1342  if (!_coupleable_neighbor)
1343  return var->uDotDotOld();
1344  return var->uDotDotOldNeighbor();
1345 }
1346 
1347 const VariableValue &
1348 Coupleable::coupledVectorDotDu(const std::string & var_name, unsigned int comp) const
1349 {
1350  const auto * var = getVectorVar(var_name, comp);
1351  if (!var)
1352  {
1354  return _default_value_zero;
1355  }
1357 
1358  if (!_coupleable_neighbor)
1359  return var->duDotDu();
1360  return var->duDotDuNeighbor();
1361 }
1362 
1363 const VariableValue &
1364 Coupleable::coupledVectorDotDotDu(const std::string & var_name, unsigned int comp) const
1365 {
1366  const auto * var = getVectorVar(var_name, comp);
1367  if (!var)
1368  {
1370  return _default_value_zero;
1371  }
1373 
1374  if (!_coupleable_neighbor)
1375  return var->duDotDotDu();
1376  return var->duDotDotDuNeighbor();
1377 }
1378 
1379 const ArrayVariableValue &
1380 Coupleable::coupledArrayDot(const std::string & var_name, unsigned int comp) const
1381 {
1382  const auto * var = getArrayVar(var_name, comp);
1383  if (!var)
1386 
1387  if (!_coupleable_neighbor)
1388  {
1389  if (_c_nodal)
1390  return var->dofValuesDot();
1391  return var->uDot();
1392  }
1393  else
1394  {
1395  if (_c_nodal)
1396  return var->dofValuesDotNeighbor();
1397  return var->uDotNeighbor();
1398  }
1399 }
1400 
1401 const ArrayVariableValue &
1402 Coupleable::coupledArrayDotDot(const std::string & var_name, unsigned int comp) const
1403 {
1404  const auto * var = getArrayVar(var_name, comp);
1405  if (!var)
1408 
1409  if (!_coupleable_neighbor)
1410  {
1411  if (_c_nodal)
1412  return var->dofValuesDotDot();
1413  return var->uDotDot();
1414  }
1415  else
1416  {
1417  if (_c_nodal)
1418  return var->dofValuesDotDotNeighbor();
1419  return var->uDotDotNeighbor();
1420  }
1421 }
1422 
1423 const ArrayVariableValue &
1424 Coupleable::coupledArrayDotOld(const std::string & var_name, unsigned int comp) const
1425 {
1426  const auto * var = getArrayVar(var_name, comp);
1427  if (!var)
1430 
1431  if (!_coupleable_neighbor)
1432  {
1433  if (_c_nodal)
1434  return var->dofValuesDotOld();
1435  return var->uDotOld();
1436  }
1437  else
1438  {
1439  if (_c_nodal)
1440  return var->dofValuesDotOldNeighbor();
1441  return var->uDotOldNeighbor();
1442  }
1443 }
1444 
1445 const ArrayVariableValue &
1446 Coupleable::coupledArrayDotDotOld(const std::string & var_name, unsigned int comp) const
1447 {
1448  const auto * var = getArrayVar(var_name, comp);
1449  if (!var)
1452 
1453  if (!_coupleable_neighbor)
1454  {
1455  if (_c_nodal)
1456  return var->dofValuesDotDotOld();
1457  return var->uDotDotOld();
1458  }
1459  else
1460  {
1461  if (_c_nodal)
1462  return var->dofValuesDotDotOldNeighbor();
1463  return var->uDotDotOldNeighbor();
1464  }
1465 }
1466 
1467 const VariableValue &
1468 Coupleable::coupledDotDu(const std::string & var_name, unsigned int comp) const
1469 {
1470  const auto * var = getVar(var_name, comp);
1471  if (!var)
1472  {
1474  return _default_value_zero;
1475  }
1477 
1478  if (!_coupleable_neighbor)
1479  {
1480  if (_c_nodal)
1481  return var->dofValuesDuDotDu();
1482  return var->duDotDu();
1483  }
1484  else
1485  {
1486  if (_c_nodal)
1487  return var->dofValuesDuDotDuNeighbor();
1488  return var->duDotDuNeighbor();
1489  }
1490 }
1491 
1492 const VariableValue &
1493 Coupleable::coupledDotDotDu(const std::string & var_name, unsigned int comp) const
1494 {
1495  const auto * var = getVar(var_name, comp);
1496  if (!var)
1497  {
1499  return _default_value_zero;
1500  }
1502 
1503  if (!_coupleable_neighbor)
1504  {
1505  if (_c_nodal)
1506  return var->dofValuesDuDotDotDu();
1507  return var->duDotDotDu();
1508  }
1509  else
1510  {
1511  if (_c_nodal)
1512  return var->dofValuesDuDotDotDuNeighbor();
1513  return var->duDotDotDuNeighbor();
1514  }
1515 }
1516 
1517 const VariableValue &
1518 Coupleable::coupledArrayDotDu(const std::string & var_name, unsigned int comp) const
1519 {
1520  const auto * const var = getArrayVar(var_name, comp);
1521  if (!var)
1522  {
1524  return _default_value_zero;
1525  }
1527 
1528  if (!_coupleable_neighbor)
1529  {
1530  if (_c_nodal)
1531  return var->dofValuesDuDotDu();
1532  return var->duDotDu();
1533  }
1534  else
1535  {
1536  if (_c_nodal)
1537  return var->dofValuesDuDotDuNeighbor();
1538  return var->duDotDuNeighbor();
1539  }
1540 }
1541 
1542 const VariableGradient &
1543 Coupleable::coupledGradient(const std::string & var_name, unsigned int comp) const
1544 {
1545  const auto * const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
1546  if (!var)
1547  {
1549  return _default_gradient;
1550  }
1552 
1553  if (!_coupleable_neighbor)
1554  return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
1555  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1556 }
1557 
1558 const VariableGradient &
1559 Coupleable::coupledGradientOld(const std::string & var_name, unsigned int comp) const
1560 {
1561  const auto * var = getVar(var_name, comp);
1562  if (!var)
1563  {
1565  return _default_gradient;
1566  }
1568 
1569  if (!_coupleable_neighbor)
1570  return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1571  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1572 }
1573 
1574 const VariableGradient &
1575 Coupleable::coupledGradientOlder(const std::string & var_name, unsigned int comp) const
1576 {
1577  const auto * var = getVar(var_name, comp);
1578  if (!var)
1579  {
1581  return _default_gradient;
1582  }
1584 
1585  if (!_coupleable_neighbor)
1586  return var->gradSlnOlder();
1587  return var->gradSlnOlderNeighbor();
1588 }
1589 
1590 const VariableGradient &
1591 Coupleable::coupledGradientPreviousNL(const std::string & var_name, unsigned int comp) const
1592 {
1593  const auto * var = getVar(var_name, comp);
1595  if (!var)
1596  {
1598  return _default_gradient;
1599  }
1601 
1602  if (!_coupleable_neighbor)
1603  return var->gradSlnPreviousNL();
1604  return var->gradSlnPreviousNLNeighbor();
1605 }
1606 
1607 const VariableGradient &
1608 Coupleable::coupledGradientDot(const std::string & var_name, unsigned int comp) const
1609 {
1610  const auto * var = getVar(var_name, comp);
1611  if (!var)
1612  {
1614  return _default_gradient;
1615  }
1617 
1618  if (!_coupleable_neighbor)
1619  return var->gradSlnDot();
1620  return var->gradSlnNeighborDot();
1621 }
1622 
1623 const VariableGradient &
1624 Coupleable::coupledGradientDotDot(const std::string & var_name, unsigned int comp) const
1625 {
1626  const auto * var = getVar(var_name, comp);
1627  if (!var)
1628  {
1630  return _default_gradient;
1631  }
1633 
1634  if (!_coupleable_neighbor)
1635  return var->gradSlnDotDot();
1636  return var->gradSlnNeighborDotDot();
1637 }
1638 
1639 const VectorVariableGradient &
1640 Coupleable::coupledVectorGradient(const std::string & var_name, unsigned int comp) const
1641 {
1642  const auto * var = getVectorVar(var_name, comp);
1643  if (!var)
1644  {
1646  return _default_vector_gradient;
1647  }
1649 
1650  if (!_coupleable_neighbor)
1651  return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
1652  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1653 }
1654 
1655 const VectorVariableGradient &
1656 Coupleable::coupledVectorGradientOld(const std::string & var_name, unsigned int comp) const
1657 {
1658  const auto * var = getVectorVar(var_name, comp);
1659  if (!var)
1660  {
1662  return _default_vector_gradient;
1663  }
1665 
1666  if (!_coupleable_neighbor)
1667  return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1668  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1669 }
1670 
1671 const VectorVariableGradient &
1672 Coupleable::coupledVectorGradientOlder(const std::string & var_name, unsigned int comp) const
1673 {
1674  const auto * var = getVectorVar(var_name, comp);
1675  if (!var)
1676  {
1678  return _default_vector_gradient;
1679  }
1681 
1682  if (!_coupleable_neighbor)
1683  return var->gradSlnOlder();
1684  return var->gradSlnOlderNeighbor();
1685 }
1686 
1687 const ArrayVariableGradient &
1688 Coupleable::coupledArrayGradient(const std::string & var_name, unsigned int comp) const
1689 {
1690  const auto * var = getArrayVar(var_name, comp);
1691  if (!var)
1692  return _default_array_gradient;
1694 
1695  if (!_coupleable_neighbor)
1696  return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
1697  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1698 }
1699 
1700 const ArrayVariableGradient &
1701 Coupleable::coupledArrayGradientOld(const std::string & var_name, unsigned int comp) const
1702 {
1703  const auto * var = getArrayVar(var_name, comp);
1704  if (!var)
1705  return _default_array_gradient;
1707 
1708  if (!_coupleable_neighbor)
1709  return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1710  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1711 }
1712 
1713 const ArrayVariableGradient &
1714 Coupleable::coupledArrayGradientOlder(const std::string & var_name, unsigned int comp) const
1715 {
1716  const auto * var = getArrayVar(var_name, comp);
1717  if (!var)
1718  return _default_array_gradient;
1720 
1721  if (!_coupleable_neighbor)
1722  return var->gradSlnOlder();
1723  return var->gradSlnOlderNeighbor();
1724 }
1725 
1726 const ArrayVariableGradient &
1727 Coupleable::coupledArrayGradientDot(const std::string & var_name, unsigned int comp) const
1728 {
1729  const auto * const var = getArrayVar(var_name, comp);
1730  if (!var)
1731  return _default_array_gradient;
1733 
1734  if (!_coupleable_neighbor)
1735  return var->gradSlnDot();
1736  return var->gradSlnNeighborDot();
1737 }
1738 
1739 const VectorVariableCurl &
1740 Coupleable::coupledCurl(const std::string & var_name, unsigned int comp) const
1741 {
1742  const auto * var = getVectorVar(var_name, comp);
1743  if (!var)
1744  {
1746  return _default_vector_curl;
1747  }
1749 
1750  if (!_coupleable_neighbor)
1751  return (_c_is_implicit) ? var->curlSln() : var->curlSlnOld();
1752  return (_c_is_implicit) ? var->curlSlnNeighbor() : var->curlSlnOldNeighbor();
1753 }
1754 
1755 const VectorVariableCurl &
1756 Coupleable::coupledCurlOld(const std::string & var_name, unsigned int comp) const
1757 {
1758  const auto * var = getVectorVar(var_name, comp);
1759  if (!var)
1760  {
1762  return _default_vector_curl;
1763  }
1765 
1766  if (!_coupleable_neighbor)
1767  return (_c_is_implicit) ? var->curlSlnOld() : var->curlSlnOlder();
1768  return (_c_is_implicit) ? var->curlSlnOldNeighbor() : var->curlSlnOlderNeighbor();
1769 }
1770 
1771 const VectorVariableCurl &
1772 Coupleable::coupledCurlOlder(const std::string & var_name, unsigned int comp) const
1773 {
1774  const auto * var = getVectorVar(var_name, comp);
1775  if (!var)
1776  {
1778  return _default_vector_curl;
1779  }
1781 
1782  if (!_coupleable_neighbor)
1783  return var->curlSlnOlder();
1784  return var->curlSlnOlderNeighbor();
1785 }
1786 
1787 const ADVectorVariableCurl &
1788 Coupleable::adCoupledCurl(const std::string & var_name, unsigned int comp) const
1789 {
1790  const auto * var = getVectorVar(var_name, comp);
1791 
1792  if (!var)
1793  return getADDefaultCurl();
1795 
1796  if (!_c_is_implicit)
1797  mooseError("Not implemented");
1798 
1799  if (!_coupleable_neighbor)
1800  return var->adCurlSln();
1801  return var->adCurlSlnNeighbor();
1802 }
1803 
1805 Coupleable::coupledDiv(const std::string & var_name, unsigned int comp) const
1806 {
1807  const auto * var = getVectorVar(var_name, comp);
1808  if (!var)
1809  {
1811  return _default_div;
1812  }
1814 
1815  if (!_coupleable_neighbor)
1816  return (_c_is_implicit) ? var->divSln() : var->divSlnOld();
1817  return (_c_is_implicit) ? var->divSlnNeighbor() : var->divSlnOldNeighbor();
1818 }
1819 
1821 Coupleable::coupledDivOld(const std::string & var_name, unsigned int comp) const
1822 {
1823  const auto * var = getVectorVar(var_name, comp);
1824  if (!var)
1825  {
1827  return _default_div;
1828  }
1830 
1831  if (!_coupleable_neighbor)
1832  return (_c_is_implicit) ? var->divSlnOld() : var->divSlnOlder();
1833  return (_c_is_implicit) ? var->divSlnOldNeighbor() : var->divSlnOlderNeighbor();
1834 }
1835 
1837 Coupleable::coupledDivOlder(const std::string & var_name, unsigned int comp) const
1838 {
1839  const auto * var = getVectorVar(var_name, comp);
1840  if (!var)
1841  {
1843  return _default_div;
1844  }
1846 
1847  if (!_coupleable_neighbor)
1848  return var->divSlnOlder();
1849  return var->divSlnOlderNeighbor();
1850 }
1851 
1852 const VariableSecond &
1853 Coupleable::coupledSecond(const std::string & var_name, unsigned int comp) const
1854 {
1855  const auto * var = getVar(var_name, comp);
1856  if (!var)
1857  {
1859  return _default_second;
1860  }
1862 
1863  if (!_coupleable_neighbor)
1864  return (_c_is_implicit) ? var->secondSln() : var->secondSlnOlder();
1865  return (_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOlderNeighbor();
1866 }
1867 
1868 const VariableSecond &
1869 Coupleable::coupledSecondOld(const std::string & var_name, unsigned int comp) const
1870 {
1871  const auto * var = getVar(var_name, comp);
1872  if (!var)
1873  {
1875  return _default_second;
1876  }
1878 
1879  if (!_coupleable_neighbor)
1880  return (_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder();
1881  return (_c_is_implicit) ? var->secondSlnOldNeighbor() : var->secondSlnOlderNeighbor();
1882 }
1883 
1884 const VariableSecond &
1885 Coupleable::coupledSecondOlder(const std::string & var_name, unsigned int comp) const
1886 {
1887  const auto * var = getVar(var_name, comp);
1888  if (!var)
1889  {
1891  return _default_second;
1892  }
1894 
1895  if (!_coupleable_neighbor)
1896  return var->secondSlnOlder();
1897  return var->secondSlnOlderNeighbor();
1898 }
1899 
1900 const VariableSecond &
1901 Coupleable::coupledSecondPreviousNL(const std::string & var_name, unsigned int comp) const
1902 {
1903  const auto * var = getVar(var_name, comp);
1905  if (!var)
1906  {
1908  return _default_second;
1909  }
1911 
1912  if (!_coupleable_neighbor)
1913  return var->secondSlnPreviousNL();
1914  return var->secondSlnPreviousNLNeighbor();
1915 }
1916 
1917 template <typename T>
1918 const T &
1919 Coupleable::coupledNodalValue(const std::string & var_name, unsigned int comp) const
1920 {
1921  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1922  if (!var)
1923  return getDefaultNodalValue<T>(var_name, comp);
1925 
1926  if (!var->isNodal())
1928  ": Trying to get nodal values of variable '",
1929  var->name(),
1930  "', but it is not nodal.");
1931 
1932  if (!_coupleable_neighbor)
1933  return (_c_is_implicit) ? var->nodalValue() : var->nodalValueOld();
1934  return (_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor();
1935 }
1936 
1937 template <typename T>
1938 const T &
1939 Coupleable::coupledNodalValueOld(const std::string & var_name, unsigned int comp) const
1940 {
1941  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1942  if (!var)
1943  return getDefaultNodalValue<T>(var_name, comp);
1945 
1946  if (!var->isNodal())
1948  ": Trying to get old nodal values of variable '",
1949  var->name(),
1950  "', but it is not nodal.");
1951 
1952  if (!_coupleable_neighbor)
1953  return (_c_is_implicit) ? var->nodalValueOld() : var->nodalValueOlder();
1954  return (_c_is_implicit) ? var->nodalValueOldNeighbor() : var->nodalValueOlderNeighbor();
1955 }
1956 
1957 template <typename T>
1958 const T &
1959 Coupleable::coupledNodalValueOlder(const std::string & var_name, unsigned int comp) const
1960 {
1961  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1962  if (!var)
1963  return getDefaultNodalValue<T>(var_name, comp);
1965 
1966  if (!var->isNodal())
1968  ": Trying to get older nodal values of variable '",
1969  var->name(),
1970  "', but it is not nodal.");
1971 
1972  if (!_coupleable_neighbor)
1973  return var->nodalValueOlder();
1974  return var->nodalValueOlderNeighbor();
1975 }
1976 
1977 template <typename T>
1978 const T &
1979 Coupleable::coupledNodalValuePreviousNL(const std::string & var_name, unsigned int comp) const
1980 {
1981  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1982  if (!var)
1983  return getDefaultNodalValue<T>(var_name, comp);
1985 
1987 
1988  if (!_coupleable_neighbor)
1989  return var->nodalValuePreviousNL();
1990  return var->nodalValuePreviousNLNeighbor();
1991 }
1992 
1993 template <typename T>
1994 const T &
1995 Coupleable::coupledNodalDot(const std::string & var_name, unsigned int comp) const
1996 {
1997  static const T zero = 0;
1998  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1999  if (!var)
2000  return zero;
2002 
2003  if (!_coupleable_neighbor)
2004  return var->nodalValueDot();
2005  mooseError("Neighbor version not implemented");
2006 }
2007 
2008 const VariableValue &
2009 Coupleable::coupledNodalDotDot(const std::string & var_name, unsigned int comp) const
2010 {
2011  const auto * var = getVar(var_name, comp);
2012  if (!var)
2013  {
2015  return _default_value_zero;
2016  }
2018 
2019  if (!_coupleable_neighbor)
2020  return var->dofValuesDotDot();
2021  return var->dofValuesDotDotNeighbor();
2022 }
2023 
2024 const VariableValue &
2025 Coupleable::coupledNodalDotOld(const std::string & var_name, unsigned int comp) const
2026 {
2027  const auto * var = getVar(var_name, comp);
2028  if (!var)
2029  {
2031  return _default_value_zero;
2032  }
2034 
2035  if (!_coupleable_neighbor)
2036  return var->dofValuesDotOld();
2037  return var->dofValuesDotOldNeighbor();
2038 }
2039 
2040 const VariableValue &
2041 Coupleable::coupledNodalDotDotOld(const std::string & var_name, unsigned int comp) const
2042 {
2043  const auto * var = getVar(var_name, comp);
2044  if (!var)
2045  {
2047  return _default_value_zero;
2048  }
2050 
2051  if (!_coupleable_neighbor)
2052  return var->dofValuesDotDotOld();
2053  return var->dofValuesDotDotOldNeighbor();
2054 }
2055 
2056 const VariableValue &
2057 Coupleable::coupledDofValues(const std::string & var_name, unsigned int comp) const
2058 {
2059  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2060  if (!var)
2061  return *getDefaultValue(var_name, comp);
2063 
2064  if (!_coupleable_neighbor)
2065  return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
2066  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
2067 }
2068 
2069 std::vector<const VariableValue *>
2070 Coupleable::coupledAllDofValues(const std::string & var_name) const
2071 {
2072  auto func = [this, &var_name](unsigned int comp) { return &coupledDofValues(var_name, comp); };
2073  return coupledVectorHelper<const VariableValue *>(var_name, func);
2074 }
2075 
2076 const VariableValue &
2077 Coupleable::coupledDofValuesOld(const std::string & var_name, unsigned int comp) const
2078 {
2079  const auto * var = getVar(var_name, comp);
2080  if (!var)
2081  return *getDefaultValue(var_name, comp);
2083 
2084  if (!_coupleable_neighbor)
2085  return (_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
2086  return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
2087 }
2088 
2089 std::vector<const VariableValue *>
2090 Coupleable::coupledAllDofValuesOld(const std::string & var_name) const
2091 {
2092  auto func = [this, &var_name](unsigned int comp) { return &coupledDofValuesOld(var_name, comp); };
2093  return coupledVectorHelper<const VariableValue *>(var_name, func);
2094 }
2095 
2096 const VariableValue &
2097 Coupleable::coupledDofValuesOlder(const std::string & var_name, unsigned int comp) const
2098 {
2099  const auto * var = getVar(var_name, comp);
2100  if (!var)
2101  return *getDefaultValue(var_name, comp);
2103 
2104  if (!_coupleable_neighbor)
2105  return var->dofValuesOlder();
2106  return var->dofValuesOlderNeighbor();
2107 }
2108 
2109 std::vector<const VariableValue *>
2110 Coupleable::coupledAllDofValuesOlder(const std::string & var_name) const
2111 {
2112  auto func = [this, &var_name](unsigned int comp)
2113  { return &coupledDofValuesOlder(var_name, comp); };
2114  return coupledVectorHelper<const VariableValue *>(var_name, func);
2115 }
2116 
2117 const ArrayVariableValue &
2118 Coupleable::coupledArrayDofValues(const std::string & var_name, unsigned int comp) const
2119 {
2120  const auto * var = getArrayVar(var_name, comp);
2121  if (!var)
2122  return *getDefaultArrayValue(var_name);
2124 
2125  if (!_coupleable_neighbor)
2126  return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
2127  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
2128 }
2129 
2130 const ADVariableValue &
2131 Coupleable::adCoupledDofValues(const std::string & var_name, unsigned int comp) const
2132 {
2133  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2134 
2135  if (!var)
2136  return *getADDefaultValue(var_name);
2138 
2139  if (!_c_is_implicit)
2140  mooseError("Not implemented");
2141 
2142  if (!_coupleable_neighbor)
2143  return var->adDofValues();
2144  return var->adDofValuesNeighbor();
2145 }
2146 
2147 void
2148 Coupleable::validateExecutionerType(const std::string & name, const std::string & fn_name) const
2149 {
2150  if (!_c_fe_problem.isTransient())
2152  ": Calling \"",
2153  fn_name,
2154  "\" on variable \"",
2155  name,
2156  "\" when using a \"Steady\" executioner is not allowed. This value is available "
2157  "only in transient simulations.");
2158 }
2159 
2160 template <typename T>
2161 const typename Moose::ADType<T>::type &
2162 Coupleable::adCoupledNodalValue(const std::string & var_name, unsigned int comp) const
2163 {
2164  static const typename Moose::ADType<T>::type zero = 0;
2165  if (!isCoupled(var_name))
2166  return zero;
2167 
2168  if (!_c_nodal)
2169  mooseError("The adCoupledNodalValue method should only be called for nodal computing objects");
2171  mooseError(
2172  "The adCoupledNodalValue method shouldn't be called for neighbor computing objects. I "
2173  "don't even know what that would mean, although maybe someone could explain it to me.");
2174  if (!_c_is_implicit)
2175  mooseError("If you're going to use an explicit scheme, then use coupledNodalValue instead of "
2176  "adCoupledNodalValue");
2177 
2178  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2179 
2180  return var->adNodalValue();
2181 }
2182 
2183 const ADVariableValue &
2184 Coupleable::adCoupledValue(const std::string & var_name, unsigned int comp) const
2185 {
2186  const auto * const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2187 
2188  if (!var)
2189  return *getADDefaultValue(var_name);
2191 
2192  if (!_c_is_implicit)
2193  mooseError("Not implemented");
2194 
2195  if (_c_nodal)
2196  return var->adDofValues();
2197 
2198  if (!_coupleable_neighbor)
2199  return var->adSln();
2200  return var->adSlnNeighbor();
2201 }
2202 
2203 const ADVariableValue &
2204 Coupleable::adCoupledLowerValue(const std::string & var_name, unsigned int comp) const
2205 {
2206  auto var = getVarHelper<MooseVariableFE<Real>>(var_name, comp);
2207 
2208  if (!var)
2209  return *getADDefaultValue(var_name);
2211 
2212  if (!_c_is_implicit)
2213  mooseError("adCoupledLowerValue cannot be called in a coupleable neighbor object");
2214 
2215  if (_c_nodal)
2216  return var->adDofValues();
2217  else
2218  return var->adSlnLower();
2219 }
2220 
2221 const ADVariableGradient &
2222 Coupleable::adCoupledGradient(const std::string & var_name, unsigned int comp) const
2223 {
2224  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2225 
2226  if (!var)
2227  return getADDefaultGradient();
2229 
2230  if (!_c_is_implicit)
2231  mooseError("Not implemented");
2232 
2233  if (!_coupleable_neighbor)
2234  return var->adGradSln();
2235  return var->adGradSlnNeighbor();
2236 }
2237 
2238 const ADVariableGradient &
2239 Coupleable::adCoupledGradientDot(const std::string & var_name, unsigned int comp) const
2240 {
2241  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2242 
2243  if (!var)
2244  return getADDefaultGradient();
2246 
2247  if (!_c_is_implicit)
2248  mooseError("Not implemented");
2249 
2250  if (!_coupleable_neighbor)
2251  return var->adGradSlnDot();
2252  return var->adGradSlnNeighborDot();
2253 }
2254 
2255 const ADVariableSecond &
2256 Coupleable::adCoupledSecond(const std::string & var_name, unsigned int comp) const
2257 {
2258  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2259 
2260  if (!var)
2261  return getADDefaultSecond();
2263 
2264  if (!_c_is_implicit)
2265  mooseError("Not implemented");
2266 
2267  if (!_coupleable_neighbor)
2268  return var->adSecondSln();
2269  else
2270  return var->adSecondSlnNeighbor();
2271 }
2272 
2273 const ADVectorVariableSecond &
2274 adCoupledVectorSecond(const std::string & /*var_name*/, unsigned int /*comp = 0*/)
2275 {
2276  mooseError("Automatic differentiation using second derivatives of vector variables is not "
2277  "implemented.");
2278 }
2279 
2280 const ADVariableValue &
2281 Coupleable::adCoupledDot(const std::string & var_name, unsigned int comp) const
2282 {
2283  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2284 
2285  if (!var)
2286  return *getADDefaultValue(var_name);
2288 
2289  if (!_coupleable_neighbor)
2290  {
2291  if (_c_nodal)
2292  return var->adDofValuesDot();
2293  return var->adUDot();
2294  }
2295  else
2296  {
2297  if (_c_nodal)
2298  mooseError("AD neighbor nodal dof dot not implemented");
2299  return var->adUDotNeighbor();
2300  }
2301 }
2302 
2303 const ADVariableValue &
2304 Coupleable::adCoupledDotDot(const std::string & var_name, unsigned int comp) const
2305 {
2306  const auto * const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2307 
2308  if (!var)
2309  return *getADDefaultValue(var_name);
2311 
2312  if (_c_nodal)
2313  mooseError("Not implemented");
2314 
2315  if (!_coupleable_neighbor)
2316  return var->adUDotDot();
2317  return var->adUDotDotNeighbor();
2318 }
2319 
2320 const ADVectorVariableValue &
2321 Coupleable::adCoupledVectorDot(const std::string & var_name, unsigned int comp) const
2322 {
2323  const auto * var = getVectorVar(var_name, comp);
2324  if (!var)
2325  return *getADDefaultVectorValue(var_name);
2327 
2328  if (_c_nodal)
2329  mooseError("Not implemented");
2330 
2331  if (!_coupleable_neighbor)
2332  return var->adUDot();
2333  return var->adUDotNeighbor();
2334 }
2335 
2336 const ADVectorVariableValue &
2337 Coupleable::adCoupledVectorValue(const std::string & var_name, unsigned int comp) const
2338 {
2339  const auto * var = getVectorVar(var_name, comp);
2340  if (!var)
2341  return *getADDefaultVectorValue(var_name);
2343 
2344  if (_c_nodal)
2345  mooseError("Not implemented");
2346  if (!_c_is_implicit)
2347  mooseError("Not implemented");
2348 
2349  if (!_coupleable_neighbor)
2350  return var->adSln();
2351  return var->adSlnNeighbor();
2352 }
2353 
2355 Coupleable::adCoupledVectorGradient(const std::string & var_name, unsigned int comp) const
2356 {
2357  const auto * var = getVectorVar(var_name, comp);
2358  if (!var)
2359  return getADDefaultVectorGradient();
2361 
2362  if (!_c_is_implicit)
2363  mooseError("Not implemented");
2364 
2365  if (!_coupleable_neighbor)
2366  return var->adGradSln();
2367  return var->adGradSlnNeighbor();
2368 }
2369 
2370 const ADVariableValue *
2371 Coupleable::getADDefaultValue(const std::string & var_name) const
2372 {
2373  auto default_value_it = _ad_default_value.find(var_name);
2374  if (default_value_it == _ad_default_value.end())
2375  {
2376  auto value = std::make_unique<ADVariableValue>(_coupleable_max_qps,
2378  default_value_it = _ad_default_value.insert(std::make_pair(var_name, std::move(value))).first;
2379  }
2380 
2381  return default_value_it->second.get();
2382 }
2383 
2384 const ADVectorVariableValue *
2385 Coupleable::getADDefaultVectorValue(const std::string & var_name) const
2386 {
2387  auto default_value_it = _ad_default_vector_value.find(var_name);
2388  if (default_value_it == _ad_default_vector_value.end())
2389  {
2390  RealVectorValue default_vec;
2391  for (unsigned int i = 0; i < _c_parameters.numberDefaultCoupledValues(var_name); ++i)
2392  default_vec(i) = _c_parameters.defaultCoupledValue(var_name, i);
2393  auto value = std::make_unique<ADVectorVariableValue>(_coupleable_max_qps, default_vec);
2394  default_value_it =
2395  _ad_default_vector_value.insert(std::make_pair(var_name, std::move(value))).first;
2396  }
2397 
2398  return default_value_it->second.get();
2399 }
2400 
2401 const ADVariableGradient &
2403 {
2405  return _ad_default_gradient;
2406 }
2407 
2410 {
2413 }
2414 
2415 const ADVariableSecond &
2417 {
2419  return _ad_default_second;
2420 }
2421 
2422 const ADVectorVariableCurl &
2424 {
2426  return _ad_default_curl;
2427 }
2428 
2429 const ADVariableValue &
2431 {
2432  mooseDeprecated("Method adZeroValue() is deprecated. Use '_ad_zero' instead.");
2433  return _ad_zero;
2434 }
2435 
2436 const ADVariableGradient &
2438 {
2439  mooseDeprecated("Method adZeroGradient() is deprecated. Use '_ad_grad_zero' instead.");
2440  return _ad_grad_zero;
2441 }
2442 
2443 const ADVariableSecond &
2445 {
2446  mooseDeprecated("Method adZeroSecond() is deprecated. Use '_ad_second_zero' instead.");
2447  return _ad_second_zero;
2448 }
2449 
2450 template <>
2452 Coupleable::genericZeroValue<false>()
2453 {
2454  return _zero;
2455 }
2456 
2457 template <>
2459 Coupleable::genericZeroValue<true>()
2460 {
2461  return _ad_zero;
2462 }
2463 
2464 template <>
2466 Coupleable::genericZeroGradient<false>()
2467 {
2468  return _grad_zero;
2469 }
2470 
2471 template <>
2473 Coupleable::genericZeroGradient<true>()
2474 {
2475  return _ad_grad_zero;
2476 }
2477 
2478 template <>
2480 Coupleable::genericZeroSecond<false>()
2481 {
2482  return _second_zero;
2483 }
2484 
2485 template <>
2487 Coupleable::genericZeroSecond<true>()
2488 {
2489  return _ad_second_zero;
2490 }
2491 
2492 template <>
2494 Coupleable::coupledGenericGradient<false>(const std::string & var_name, unsigned int comp) const
2495 {
2496  return coupledGradient(var_name, comp);
2497 }
2498 
2499 template <>
2501 Coupleable::coupledGenericGradient<true>(const std::string & var_name, unsigned int comp) const
2502 {
2503  return adCoupledGradient(var_name, comp);
2504 }
2505 
2506 std::vector<unsigned int>
2507 Coupleable::coupledIndices(const std::string & var_name) const
2508 {
2509  auto func = [this, &var_name](unsigned int comp) { return coupled(var_name, comp); };
2510  return coupledVectorHelper<unsigned int>(var_name, func);
2511 }
2512 
2513 VariableName
2514 Coupleable::coupledName(const std::string & var_name, unsigned int comp) const
2515 {
2516  if (getFieldVar(var_name, comp))
2517  return getFieldVar(var_name, comp)->name();
2518  // Detect if we are in the case where a constant was passed in lieu of a variable
2519  else if (isCoupledConstant(var_name))
2521  ": a variable name was queried but a constant was passed for parameter '",
2522  var_name,
2523  "Either pass a true variable or contact a developer to shield the call to "
2524  "'coupledName' with 'isCoupledConstant'");
2525  else
2526  mooseError(
2527  _c_name, ": Variable '", var_name, "' does not exist, yet its coupled name is requested");
2528 }
2529 
2530 std::vector<VariableName>
2531 Coupleable::coupledNames(const std::string & var_name) const
2532 {
2533  auto func = [this, &var_name](unsigned int comp) { return coupledName(var_name, comp); };
2534  return coupledVectorHelper<VariableName>(var_name, func);
2535 }
2536 
2537 std::vector<const VariableValue *>
2538 Coupleable::coupledValues(const std::string & var_name) const
2539 {
2540  auto func = [this, &var_name](unsigned int comp) { return &coupledValue(var_name, comp); };
2541  return coupledVectorHelper<const VariableValue *>(var_name, func);
2542 }
2543 
2544 std::vector<const VectorVariableValue *>
2545 Coupleable::coupledVectorValues(const std::string & var_name) const
2546 {
2547  auto func = [this, &var_name](unsigned int comp) { return &coupledVectorValue(var_name, comp); };
2548  return coupledVectorHelper<const VectorVariableValue *>(var_name, func);
2549 }
2550 
2551 template <>
2552 std::vector<const GenericVariableValue<false> *>
2553 Coupleable::coupledGenericValues<false>(const std::string & var_name) const
2554 {
2555  return coupledValues(var_name);
2556 }
2557 
2558 template <>
2559 std::vector<const GenericVariableValue<true> *>
2560 Coupleable::coupledGenericValues<true>(const std::string & var_name) const
2561 {
2562  return adCoupledValues(var_name);
2563 }
2564 
2565 std::vector<const ADVariableValue *>
2566 Coupleable::adCoupledValues(const std::string & var_name) const
2567 {
2568  auto func = [this, &var_name](unsigned int comp) { return &adCoupledValue(var_name, comp); };
2569  return coupledVectorHelper<const ADVariableValue *>(var_name, func);
2570 }
2571 
2572 std::vector<const ADVectorVariableValue *>
2573 Coupleable::adCoupledVectorValues(const std::string & var_name) const
2574 {
2575  auto func = [this, &var_name](unsigned int comp)
2576  { return &adCoupledVectorValue(var_name, comp); };
2577  return coupledVectorHelper<const ADVectorVariableValue *>(var_name, func);
2578 }
2579 
2580 std::vector<const VariableValue *>
2581 Coupleable::coupledVectorTagValues(const std::string & var_names, TagID tag) const
2582 {
2583  auto func = [this, &var_names, &tag](unsigned int comp)
2584  { return &coupledVectorTagValue(var_names, tag, comp); };
2585  return coupledVectorHelper<const VariableValue *>(var_names, func);
2586 }
2587 
2588 std::vector<const VariableValue *>
2589 Coupleable::coupledVectorTagValues(const std::string & var_names,
2590  const std::string & tag_name) const
2591 {
2592  if (!_c_parameters.isParamValid(tag_name))
2593  mooseError("Tag name parameter '", tag_name, "' is invalid");
2594 
2595  TagName tagname = _c_parameters.get<TagName>(tag_name);
2596  if (!_c_fe_problem.vectorTagExists(tagname))
2597  mooseError("Tagged vector with tag name '", tagname, "' does not exist");
2598 
2599  TagID tag = _c_fe_problem.getVectorTagID(tagname);
2600  return coupledVectorTagValues(var_names, tag);
2601 }
2602 
2603 std::vector<const ArrayVariableValue *>
2604 Coupleable::coupledVectorTagArrayValues(const std::string & var_names, TagID tag) const
2605 {
2606  auto func = [this, &var_names, &tag](unsigned int index)
2607  { return &coupledVectorTagArrayValue(var_names, tag, index); };
2608  return coupledVectorHelper<const ArrayVariableValue *>(var_names, func);
2609 }
2610 
2611 std::vector<const ArrayVariableValue *>
2612 Coupleable::coupledVectorTagArrayValues(const std::string & var_names,
2613  const std::string & tag_name) const
2614 {
2615  if (!_c_parameters.isParamValid(tag_name))
2616  mooseError("Tag name parameter '", tag_name, "' is invalid");
2617 
2618  TagName tagname = _c_parameters.get<TagName>(tag_name);
2619  if (!_c_fe_problem.vectorTagExists(tagname))
2620  mooseError("Tagged vector with tag name '", tagname, "' does not exist");
2621 
2622  TagID tag = _c_fe_problem.getVectorTagID(tagname);
2623  return coupledVectorTagArrayValues(var_names, tag);
2624 }
2625 
2626 std::vector<const VariableGradient *>
2627 Coupleable::coupledVectorTagGradients(const std::string & var_names, TagID tag) const
2628 {
2629  auto func = [this, &var_names, &tag](unsigned int index)
2630  { return &coupledVectorTagGradient(var_names, tag, index); };
2631  return coupledVectorHelper<const VariableGradient *>(var_names, func);
2632 }
2633 
2634 std::vector<const VariableGradient *>
2635 Coupleable::coupledVectorTagGradients(const std::string & var_names,
2636  const std::string & tag_name) const
2637 {
2638  if (!_c_parameters.isParamValid(tag_name))
2639  mooseError("Tag name parameter '", tag_name, "' is invalid");
2640 
2641  TagName tagname = _c_parameters.get<TagName>(tag_name);
2642  if (!_c_fe_problem.vectorTagExists(tagname))
2643  mooseError("Tagged vector with tag name '", tagname, "' does not exist");
2644 
2645  TagID tag = _c_fe_problem.getVectorTagID(tagname);
2646  return coupledVectorTagGradients(var_names, tag);
2647 }
2648 
2649 std::vector<const ArrayVariableGradient *>
2650 Coupleable::coupledVectorTagArrayGradients(const std::string & var_names, TagID tag) const
2651 {
2652  auto func = [this, &var_names, &tag](unsigned int index)
2653  { return &coupledVectorTagArrayGradient(var_names, tag, index); };
2654  return coupledVectorHelper<const ArrayVariableGradient *>(var_names, func);
2655 }
2656 
2657 std::vector<const ArrayVariableGradient *>
2658 Coupleable::coupledVectorTagArrayGradients(const std::string & var_names,
2659  const std::string & tag_name) const
2660 {
2661  if (!_c_parameters.isParamValid(tag_name))
2662  mooseError("Tag name parameter '", tag_name, "' is invalid");
2663 
2664  TagName tagname = _c_parameters.get<TagName>(tag_name);
2665  if (!_c_fe_problem.vectorTagExists(tagname))
2666  mooseError("Tagged vector with tag name '", tagname, "' does not exist");
2667 
2668  TagID tag = _c_fe_problem.getVectorTagID(tagname);
2669  return coupledVectorTagArrayGradients(var_names, tag);
2670 }
2671 
2672 std::vector<const VariableValue *>
2673 Coupleable::coupledVectorTagDofValues(const std::string & var_names, TagID tag) const
2674 {
2675  auto func = [this, &var_names, &tag](unsigned int comp)
2676  { return &coupledVectorTagDofValue(var_names, tag, comp); };
2677  return coupledVectorHelper<const VariableValue *>(var_names, func);
2678 }
2679 
2680 std::vector<const VariableValue *>
2681 Coupleable::coupledVectorTagDofValues(const std::string & var_names,
2682  const std::string & tag_name) const
2683 {
2684  if (!_c_parameters.isParamValid(tag_name))
2685  mooseError("Tag name parameter '", tag_name, "' is invalid");
2686 
2687  TagName tagname = _c_parameters.get<TagName>(tag_name);
2688  if (!_c_fe_problem.vectorTagExists(tagname))
2689  mooseError("Tagged vector with tag name '", tagname, "' does not exist");
2690 
2691  TagID tag = _c_fe_problem.getVectorTagID(tagname);
2692  return coupledVectorTagDofValues(var_names, tag);
2693 }
2694 
2695 std::vector<const VariableValue *>
2696 Coupleable::coupledMatrixTagValues(const std::string & var_names, TagID tag) const
2697 {
2698  auto func = [this, &var_names, &tag](unsigned int comp)
2699  { return &coupledMatrixTagValue(var_names, tag, comp); };
2700  return coupledVectorHelper<const VariableValue *>(var_names, func);
2701 }
2702 
2703 std::vector<const VariableValue *>
2704 Coupleable::coupledMatrixTagValues(const std::string & var_names,
2705  const std::string & tag_name) const
2706 {
2707  if (!_c_parameters.isParamValid(tag_name))
2708  mooseError("Tag name parameter '", tag_name, "' is invalid");
2709 
2710  TagName tagname = _c_parameters.get<TagName>(tag_name);
2711  if (!_c_fe_problem.matrixTagExists(tagname))
2712  mooseError("Matrix tag name '", tagname, "' does not exist");
2713 
2714  TagID tag = _c_fe_problem.getMatrixTagID(tagname);
2715  return coupledMatrixTagValues(var_names, tag);
2716 }
2717 
2718 std::vector<const VariableValue *>
2719 Coupleable::coupledValuesOld(const std::string & var_name) const
2720 {
2721  auto func = [this, &var_name](unsigned int comp) { return &coupledValueOld(var_name, comp); };
2722  return coupledVectorHelper<const VariableValue *>(var_name, func);
2723 }
2724 
2725 std::vector<const VariableValue *>
2726 Coupleable::coupledValuesOlder(const std::string & var_name) const
2727 {
2728  auto func = [this, &var_name](unsigned int comp) { return &coupledValueOlder(var_name, comp); };
2729  return coupledVectorHelper<const VariableValue *>(var_name, func);
2730 }
2731 
2732 std::vector<const VectorVariableValue *>
2733 Coupleable::coupledVectorValuesOld(const std::string & var_name) const
2734 {
2735  auto func = [this, &var_name](unsigned int comp)
2736  { return &coupledVectorValueOld(var_name, comp); };
2737  return coupledVectorHelper<const VectorVariableValue *>(var_name, func);
2738 }
2739 
2740 std::vector<const VariableGradient *>
2741 Coupleable::coupledGradients(const std::string & var_name) const
2742 {
2743  auto func = [this, &var_name](unsigned int comp) { return &coupledGradient(var_name, comp); };
2744  return coupledVectorHelper<const VariableGradient *>(var_name, func);
2745 }
2746 
2747 template <>
2748 std::vector<const GenericVariableGradient<false> *>
2749 Coupleable::coupledGenericGradients<false>(const std::string & var_name) const
2750 {
2751  return coupledGradients(var_name);
2752 }
2753 
2754 template <>
2755 std::vector<const GenericVariableGradient<true> *>
2756 Coupleable::coupledGenericGradients<true>(const std::string & var_name) const
2757 {
2758  auto func = [this, &var_name](unsigned int comp) { return &adCoupledGradient(var_name, comp); };
2759  return coupledVectorHelper<const GenericVariableGradient<true> *>(var_name, func);
2760 }
2761 
2762 std::vector<const ADVariableGradient *>
2763 Coupleable::adCoupledGradients(const std::string & var_name) const
2764 {
2765  auto func = [this, &var_name](unsigned int comp) { return &adCoupledGradient(var_name, comp); };
2766  return coupledVectorHelper<const ADVariableGradient *>(var_name, func);
2767 }
2768 
2769 std::vector<const VariableGradient *>
2770 Coupleable::coupledGradientsOld(const std::string & var_name) const
2771 {
2772  auto func = [this, &var_name](unsigned int comp) { return &coupledGradientOld(var_name, comp); };
2773  return coupledVectorHelper<const VariableGradient *>(var_name, func);
2774 }
2775 
2776 std::vector<const VariableValue *>
2777 Coupleable::coupledDots(const std::string & var_name) const
2778 {
2779  auto func = [this, &var_name](unsigned int comp) { return &coupledDot(var_name, comp); };
2780  return coupledVectorHelper<const VariableValue *>(var_name, func);
2781 }
2782 
2783 std::vector<const ADVariableValue *>
2784 Coupleable::adCoupledDots(const std::string & var_name) const
2785 {
2786  auto func = [this, &var_name](unsigned int comp) { return &adCoupledDot(var_name, comp); };
2787  return coupledVectorHelper<const ADVariableValue *>(var_name, func);
2788 }
2789 
2790 template <>
2792 Coupleable::coupledGenericDot<false>(const std::string & var_name, unsigned int comp) const
2793 {
2794  return coupledDot(var_name, comp);
2795 }
2796 
2797 template <>
2799 Coupleable::coupledGenericDot<true>(const std::string & var_name, unsigned int comp) const
2800 {
2801  return adCoupledDot(var_name, comp);
2802 }
2803 
2804 // Explicit instantiations
2805 
2806 template const Real & Coupleable::getDefaultNodalValue<Real>(const std::string & var_name,
2807  unsigned int comp) const;
2808 
2809 template const Real & Coupleable::coupledNodalValue<Real>(const std::string & var_name,
2810  unsigned int comp) const;
2811 template const ADReal & Coupleable::adCoupledNodalValue<Real>(const std::string & var_name,
2812  unsigned int comp) const;
2813 template const ADRealVectorValue &
2814 Coupleable::adCoupledNodalValue<RealVectorValue>(const std::string & var_name,
2815  unsigned int comp) const;
2816 
2817 template const RealVectorValue &
2818 Coupleable::coupledNodalValue<RealVectorValue>(const std::string & var_name,
2819  unsigned int comp) const;
2820 template const Real & Coupleable::coupledNodalValueOld<Real>(const std::string & var_name,
2821  unsigned int comp) const;
2822 template const RealVectorValue &
2823 Coupleable::coupledNodalValueOld<RealVectorValue>(const std::string & var_name,
2824  unsigned int comp) const;
2825 template const Real & Coupleable::coupledNodalValueOlder<Real>(const std::string & var_name,
2826  unsigned int comp) const;
2827 template const RealVectorValue &
2828 Coupleable::coupledNodalValueOlder<RealVectorValue>(const std::string & var_name,
2829  unsigned int comp) const;
2830 template const Real & Coupleable::coupledNodalValuePreviousNL<Real>(const std::string & var_name,
2831  unsigned int comp) const;
2832 template const RealVectorValue &
2833 Coupleable::coupledNodalValuePreviousNL<RealVectorValue>(const std::string & var_name,
2834  unsigned int comp) const;
2835 template const Real & Coupleable::coupledNodalDot<Real>(const std::string & var_name,
2836  unsigned int comp) const;
2837 template const RealVectorValue &
2838 Coupleable::coupledNodalDot<RealVectorValue>(const std::string & var_name, unsigned int comp) const;
virtual const ArrayVariableValue & coupledArrayDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled array variable.
Definition: Coupleable.C:1446
std::string name(const ElemQuality q)
virtual const VariableValue & coupledDofValues(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the current solution vector of a coupled variable for the local element.
Definition: Coupleable.C:2057
virtual const VariableValue & coupledVectorTagValue(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns value of a coupled variable for a given tag.
Definition: Coupleable.C:649
virtual const VariableGradient & coupledVectorTagGradient(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns gradient of a coupled variable for a given tag.
Definition: Coupleable.C:681
virtual const ArrayVariableValue & coupledArrayValueOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old value from two time steps previous of a coupled array variable.
Definition: Coupleable.C:1148
OutputTools< Real >::VariableGradient VariableGradient
Definition: MooseTypes.h:316
const T & coupledNodalDot(const std::string &var_name, unsigned int comp=0) const
Nodal values of time derivative of a coupled variable.
Definition: Coupleable.C:1995
virtual TagID getVectorTagID(const TagName &tag_name) const
Get a TagID from a TagName.
Definition: SubProblem.C:203
OutputTools< RealVectorValue >::VariableDivergence VectorVariableDivergence
Definition: MooseTypes.h:336
void validateExecutionerType(const std::string &name, const std::string &fn_name) const
Checks to make sure that the current Executioner has set "_is_transient" when old/older values are co...
Definition: Coupleable.C:2148
virtual bool isCoupled(const std::string &var_name, unsigned int i=0) const
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:159
virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid, const std::string &var_name)=0
Returns the scalar variable reference from whichever system contains it.
virtual const VectorVariableGradient & coupledVectorGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled vector variable.
Definition: Coupleable.C:1640
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:1441
void checkFuncType(const std::string var_name, VarType t, FuncAge age) const
Definition: Coupleable.C:222
VectorVariableCurl _default_vector_curl
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1526
Moose::GenericType< VectorVariableValue, is_ad > GenericVectorVariableValue
Definition: MooseTypes.h:665
VectorMooseVariable * getVectorVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled vector variable.
Definition: Coupleable.C:324
virtual unsigned int coupled(const std::string &var_name, unsigned int comp=0) const
Returns the index for a coupled variable by name.
Definition: Coupleable.C:472
virtual const VectorVariableValue & coupledVectorDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled vector variable.
Definition: Coupleable.C:1300
virtual const VariableSecond & coupledSecondPreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns second derivative of a coupled variable for the previous Newton iterate.
Definition: Coupleable.C:1901
std::unordered_map< std::string, std::unique_ptr< MooseArray< ADRealVectorValue > > > _ad_default_vector_value
Will hold the default value for optional vector coupled variables for automatic differentiation.
Definition: Coupleable.h:1468
const ArrayVariableValue * getDefaultArrayValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for an uncoupled array variable...
Definition: Coupleable.C:427
bool hasCoupledValue(const std::string &coupling_name) const
Return whether or not the coupled variable exists.
std::vector< const VariableValue * > coupledValuesOlder(const std::string &var_name) const
Returns the older values for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2726
const ADVariableSecond & adZeroSecond() const
Retrieve a zero second for automatic differentiation.
Definition: Coupleable.C:2444
const ADVectorVariableValue * getADDefaultVectorValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default vector value for Automatic Differentiat...
Definition: Coupleable.C:2385
virtual const VariableSecond & coupledSecond(const std::string &var_name, unsigned int comp=0) const
Returns second spatial derivatives of a coupled variable.
Definition: Coupleable.C:1853
unsigned int n_threads()
virtual bool isCoupledConstant(const std::string &var_name) const
Returns true if a variable passed as a coupled value is really a constant.
Definition: Coupleable.C:182
virtual const VariableValue & coupledDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled variable.
Definition: Coupleable.C:1234
LAGRANGE_VEC
virtual const VectorVariableValue & coupledVectorValueOld(const std::string &var_name, unsigned int comp=0) const
Returns an old value from previous time step of a coupled vector variable.
Definition: Coupleable.C:1098
std::vector< const ArrayVariableValue * > coupledArrayValues(const std::string &var_name) const
Returns the values for all of a coupled array variable&#39;s components.
Definition: Coupleable.C:901
std::vector< const VariableValue * > coupledDots(const std::string &var_name) const
Returns the time derivatives for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2777
virtual const ArrayVariableValue & coupledArrayValueOld(const std::string &var_name, unsigned int comp=0) const
Returns an old value from previous time step of a coupled array variable.
Definition: Coupleable.C:1126
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition: MooseBase.h:439
unsigned int TagID
Definition: MooseTypes.h:210
VariableName coupledName(const std::string &var_name, unsigned int comp=0) const
Names of the variable in the Coupleable interface.
Definition: Coupleable.C:2514
virtual const VectorVariableGradient & coupledVectorGradientOld(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from previous time step of a coupled vector variable.
Definition: Coupleable.C:1656
std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > > _coupled_vars
Coupled vars whose values we provide.
Definition: Coupleable.h:1420
const MooseArray< ADRealVectorValue > & _ad_grad_zero
Definition: Coupleable.h:1501
virtual const VectorVariableValue & coupledVectorDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled vector variable.
Definition: Coupleable.C:1284
virtual const VariableValue & coupledDotDotDu(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled variable with respect to the coefficients.
Definition: Coupleable.C:1493
void checkWritableVar(MooseWritableVariable *var)
Checks that the passed in variable is only accessed writable by one object in a given subdomain...
Definition: Coupleable.C:982
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
const bool _is_fv
Whether the MooseObject is a finite volume object.
Definition: Coupleable.h:1812
virtual const VariableValue & coupledDofValuesOld(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the old solution vector of a coupled variable for the local element.
Definition: Coupleable.C:2077
const TagName OLDER_SOLUTION_TAG
Definition: MooseTypes.C:27
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.
std::vector< ArrayMooseVariable * > _coupled_array_moose_vars
Vector of array coupled variables.
Definition: Coupleable.h:1432
const ArrayVariableValue & coupledVectorTagArrayDofValue(const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const
Returns evaluations of a tagged vector at the requested variable&#39;s degree of freedom indices...
Definition: Coupleable.C:813
std::vector< const VectorVariableValue * > coupledVectorValuesOld(const std::string &var_name) const
Returns the old values for all of a coupled vector variable&#39;s components.
Definition: Coupleable.C:2733
constexpr std::size_t constMaxQpsPerElem
This is used for places where we initialize some qp-sized data structures that would end up being siz...
Definition: MooseTypes.h:230
const T & coupledNodalValue(const std::string &var_name, unsigned int comp=0) const
Returns nodal values of a coupled variable.
Definition: Coupleable.C:1919
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:357
char ** vars
virtual const VariableValue & coupledVectorTagDofValue(const std::string &var_name, TagID tag, unsigned int index=0) const
Returns dof value of a coupled variable for a given tag.
Definition: Coupleable.C:797
OutputTools< RealVectorValue >::VariableValue VectorVariableValue
Definition: MooseTypes.h:332
const ADVariableGradient & adCoupledGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable for use in Automatic Differentiation.
Definition: Coupleable.C:2222
VectorVariableDivergence _default_div
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1529
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
Definition: MooseUtils.h:1133
const bool _c_allow_element_to_nodal_coupling
Definition: Coupleable.h:1447
std::vector< const ArrayVariableValue * > coupledVectorTagArrayValues(const std::string &var_names, TagID tag) const
Returns the values for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2604
virtual const ArrayVariableValue & coupledArrayDofValues(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the current solution vector of a coupled array variable for the local element...
Definition: Coupleable.C:2118
std::vector< const VariableGradient * > coupledVectorTagGradients(const std::string &var_names, TagID tag) const
Returns gradients for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2627
MooseArray< ADRealVectorValue > _ad_default_curl
This will always be zero because the default values for optionally coupled vector variables is always...
Definition: Coupleable.h:1492
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...
bool setsIntersect(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2)
This method detects whether two sets intersect without building a result set.
Definition: MooseUtils.h:1158
virtual const VariableValue & coupledDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled variable.
Definition: Coupleable.C:1170
THREAD_ID _c_tid
Thread ID of the thread using this object.
Definition: Coupleable.h:1450
const ADVariableValue & adCoupledValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled variable for use in Automatic Differentiation.
Definition: Coupleable.C:2184
virtual const VariableValue & coupledNodalDotDot(const std::string &var_name, unsigned int comp=0) const
Nodal values of second time derivative of a coupled variable.
Definition: Coupleable.C:2009
const ADVariableGradient & getADDefaultGradient() const
Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation ...
Definition: Coupleable.C:2402
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:159
const VectorVariableValue * getDefaultVectorValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for an uncoupled vector variable...
Definition: Coupleable.C:392
std::set< std::string >::const_iterator coupledVarsBegin() const
Methods returning iterators to the coupled variables names stored in this InputParameters object...
std::vector< std::set< MooseWritableVariable * > > _writable_coupled_variables
keep a set of allocated writable variable references to make sure only one object can obtain them per...
Definition: Coupleable.h:1821
virtual const VariableGradient & coupledGradientDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of the gradient of a coupled variable.
Definition: Coupleable.C:1624
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1474
std::unordered_map< std::string, std::vector< MooseVariableScalar * > > _c_coupled_scalar_vars
Scalar variables coupled into this object (for error checking)
Definition: Coupleable.h:1805
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:318
const ADVectorVariableCurl & getADDefaultCurl() const
Helper method to return (and insert if necessary) the default curl value for Automatic Differentiatio...
Definition: Coupleable.C:2423
OutputTools< RealVectorValue >::VariableCurl VectorVariableCurl
Definition: MooseTypes.h:335
virtual const ArrayVariableValue & coupledArrayDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled array variable.
Definition: Coupleable.C:1424
virtual const VariableValue & coupledValueOld(const std::string &var_name, unsigned int comp=0) const
Returns an old value from previous time step of a coupled variable.
Definition: Coupleable.C:1031
This class provides an interface for common operations on field variables of both FE and FV types wit...
virtual const ArrayVariableValue & coupledArrayDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled array variable.
Definition: Coupleable.C:1380
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
virtual const VariableValue & coupledMatrixTagValue(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns value of a coupled variable for a given tag.
Definition: Coupleable.C:821
virtual void coupledCallback(const std::string &, bool) const
A call-back function provided by the derived object for actions before coupling a variable with funct...
Definition: Coupleable.h:146
const ADVariableGradient & adZeroGradient() const
method that returns _grad_zero to RESIDUAL computing objects and _ad_grad_zero to JACOBIAN computing ...
Definition: Coupleable.C:2437
const Number zero
MooseWritableVariable & writableVariable(const std::string &var_name, unsigned int comp=0)
Returns a writable MooseVariable object for a nodal or elemental variable.
Definition: Coupleable.C:908
Base class for a system (of equations)
Definition: SystemBase.h:84
virtual const VectorVariableDivergence & coupledDivOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old divergence from two time steps previous of a coupled variable.
Definition: Coupleable.C:1837
std::unordered_map< std::string, std::unique_ptr< VectorVariableValue > > _default_vector_value
Will hold the default value for optional vector coupled variables.
Definition: Coupleable.h:1461
virtual VariableValue & writableCoupledValue(const std::string &var_name, unsigned int comp=0)
Returns a writable reference to a coupled variable for writing to multiple AuxVariables from a single...
Definition: Coupleable.C:944
DualNumber< Real, DNDerivativeType, true > ADReal
Definition: ADRealForward.h:46
std::vector< VariableName > coupledNames(const std::string &var_name) const
Names of the variables in the Coupleable interface.
Definition: Coupleable.C:2531
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
virtual const VariableGradient & coupledGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable.
Definition: Coupleable.C:1543
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:87
const T & coupledNodalValuePreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns nodal values of a coupled variable for previous Newton iterate.
Definition: Coupleable.C:1979
auto max(const L &left, const R &right)
std::vector< const ADVariableValue * > adCoupledValues(const std::string &var_name) const
Returns the values for all of a coupled variable&#39;s components for use in Automatic Differentiation...
Definition: Coupleable.C:2566
virtual const VariableValue & coupledValueOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old value from two time steps previous of a coupled variable.
Definition: Coupleable.C:1053
std::vector< MooseVariable * > _coupled_standard_moose_vars
Vector of standard coupled variables.
Definition: Coupleable.h:1426
unsigned int numberDefaultCoupledValues(const std::string &coupling_name) const
Get the number of defaulted coupled value entries.
const ADVariableValue & adCoupledDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled variable for ad simulations.
Definition: Coupleable.C:2304
const SystemBase *const _c_sys
Pointer to the system object if the moose object this is an interface for has one.
Definition: Coupleable.h:1417
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:1414
virtual const ArrayVariableValue & coupledVectorTagArrayValue(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns value of a coupled array variable for a given tag.
Definition: Coupleable.C:665
std::string toUpper(std::string name)
Convert supplied string to upper case.
virtual const VariableSecond & coupledSecondOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old second derivative from two time steps previous of a coupled variable.
Definition: Coupleable.C:1885
A user object that runs over all the nodes and does an aggregation step to compute a single value...
const OutputTools< T >::VariableValue & vectorTagDofValueHelper(const std::string &var_name, TagID tag, unsigned int comp=0) const
Generic helper method to get vector tag degree of freedom values based on tag ID. ...
Definition: Coupleable.C:758
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:1444
virtual const VariableValue & coupledValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled variable.
Definition: Coupleable.C:527
const ADVariableValue & adCoupledLowerValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled lower-dimensional variable for use in Automatic Differentiation.
Definition: Coupleable.C:2204
virtual const VectorVariableValue & coupledVectorValueOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old value from two time steps previous of a coupled vector variable.
Definition: Coupleable.C:1113
std::vector< VectorMooseVariable * > _coupled_vector_moose_vars
Vector of vector coupled variables.
Definition: Coupleable.h:1429
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
void requestStates(const std::string &var_name, const TagName &tag_name, const unsigned int comp)
Method that may request additional solution states from the variable&#39;s system depending on the value ...
Definition: Coupleable.C:578
virtual const VariableValue & coupledValueLower(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled lower-dimensional variable.
Definition: Coupleable.C:632
Coupleable(const MooseObject *moose_object, bool nodal, bool is_fv=false)
Constructing the object.
Definition: Coupleable.C:27
virtual const VariableGradient & coupledGradientOld(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from previous time step of a coupled variable.
Definition: Coupleable.C:1559
std::vector< const VariableValue * > coupledVectorTagDofValues(const std::string &var_names, TagID tag) const
Returns the dof values for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2673
OutputTools< RealEigenVector >::VariableValue ArrayVariableValue
Definition: MooseTypes.h:349
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
virtual const VariableValue & coupledVectorDotDu(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled vector variable with respect to the coefficients.
Definition: Coupleable.C:1348
void addFEVariableCoupleableVectorTag(TagID tag)
Definition: Coupleable.h:113
virtual const VariableSecond & coupledSecondOld(const std::string &var_name, unsigned int comp=0) const
Returns an old second spatial derivatives from previous time step of a coupled variable.
Definition: Coupleable.C:1869
std::set< std::string >::const_iterator coupledVarsEnd() const
Moose::GenericType< VariableValue, is_ad > GenericVariableValue
Definition: MooseTypes.h:663
const TagName OLD_SOLUTION_TAG
Definition: MooseTypes.C:26
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:27
virtual TagID getMatrixTagID(const TagName &tag_name) const
Get a TagID from a TagName.
Definition: SubProblem.C:342
Moose::GenericType< VariableGradient, is_ad > GenericVariableGradient
Definition: MooseTypes.h:667
virtual const ArrayVariableValue & coupledArrayValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled array variable.
Definition: Coupleable.C:879
bool hasDefaultCoupledValue(const std::string &coupling_name) const
Return whether or not the requested parameter has a default coupled value.
const OutputTools< T >::VariableValue & vectorTagValueHelper(const std::string &var_names, TagID tag, unsigned int index=0) const
Generic helper method to get vector tag values based on tag ID.
Definition: Coupleable.C:552
std::vector< const VariableGradient * > coupledGradientsOld(const std::string &var_name) const
Returns the old gradients for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2770
virtual const ArrayVariableGradient & coupledVectorTagArrayGradient(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns gradient of a coupled array variable for a given tag.
Definition: Coupleable.C:719
A NodeFaceConstraint is used when you need to create constraints between two surfaces in a mesh...
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1477
Real defaultCoupledValue(const std::string &coupling_name, unsigned int i=0) const
Get the default value for an optionally coupled variable.
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1486
std::unordered_map< std::string, std::unique_ptr< MooseArray< ADReal > > > _ad_default_value
Will hold the default value for optional coupled variables for automatic differentiation.
Definition: Coupleable.h:1457
const VariableValue * getDefaultValue(const std::string &var_name, unsigned int comp) const
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:365
std::vector< const ADVariableValue * > adCoupledDots(const std::string &var_name) const
Returns the time derivatives for all of a coupled variable&#39;s components for ad simulations.
Definition: Coupleable.C:2784
void needsPreviousNewtonIteration(bool state)
Set a flag that indicated that user required values for the previous Newton iterate.
virtual const VariableGradient & coupledGradientDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of the gradient of a coupled variable.
Definition: Coupleable.C:1608
virtual bool hasScalarVariable(const std::string &var_name) const =0
Returns a Boolean indicating whether any system contains a variable with the name provided...
const ADVariableValue * getADDefaultValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for Automatic Differentiation for...
Definition: Coupleable.C:2371
const ADVariableValue & adCoupledDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled variable for ad simulations.
Definition: Coupleable.C:2281
const std::string & _c_name
The name of the object this interface is part of.
Definition: Coupleable.h:1409
virtual const VectorVariableCurl & coupledCurlOld(const std::string &var_name, unsigned int comp=0) const
Returns an old curl from previous time step of a coupled variable.
Definition: Coupleable.C:1756
virtual const ADVariableValue & adCoupledDofValues(const std::string &var_name, unsigned int comp=0) const
Returns DOF value of a coupled variable for use in Automatic Differentiation.
Definition: Coupleable.C:2131
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:374
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
virtual const VariableValue & coupledNodalDotDotOld(const std::string &var_name, unsigned int comp=0) const
Nodal values of old second time derivative of a coupled variable.
Definition: Coupleable.C:2041
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< const VariableValue * > coupledAllDofValuesOld(const std::string &var_name) const
Returns DoFs in the old solution vector of all of a coupled variable&#39;s components for the local eleme...
Definition: Coupleable.C:2090
std::vector< const VariableGradient * > coupledGradients(const std::string &var_name) const
Returns the gradients for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2741
virtual const MooseVariableFieldBase & getVariable(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const =0
Returns the variable reference for requested variable which must be of the expected_var_type (Nonline...
std::vector< const VariableValue * > coupledAllDofValuesOlder(const std::string &var_name) const
Returns DoFs in the older solution vector of all of a coupled variable&#39;s components for the local ele...
Definition: Coupleable.C:2110
AuxiliarySystem & getAuxiliarySystem()
const ADVectorVariableValue & adCoupledVectorDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a vector coupled variable for ad simulations.
Definition: Coupleable.C:2321
virtual bool hasVariable(const std::string &var_name) const =0
Whether or not this problem has the variable.
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
Definition: SystemBase.C:851
virtual const VariableValue & coupledDofValuesOlder(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the older solution vector of a coupled variable for the local element.
Definition: Coupleable.C:2097
const ADVectorVariableGradient & getADDefaultVectorGradient() const
Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation ...
Definition: Coupleable.C:2409
const ADVariableValue & adZeroValue() const
method that returns _zero to RESIDUAL computing objects and _ad_zero to JACOBIAN computing objects ...
Definition: Coupleable.C:2430
std::vector< unsigned int > coupledIndices(const std::string &var_name) const
Returns the indices for a coupled variable&#39;s components.
Definition: Coupleable.C:2507
const T & coupledNodalValueOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old nodal value from two time steps previous of a coupled variable.
Definition: Coupleable.C:1959
const MooseObject *const _obj
Definition: Coupleable.h:1814
VectorVariableGradient _default_vector_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1523
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::vector< MooseVariableFieldBase * > _coupled_moose_vars
Vector of all coupled variables.
Definition: Coupleable.h:1423
virtual const VectorVariableCurl & coupledCurl(const std::string &var_name, unsigned int comp=0) const
Returns curl of a coupled variable.
Definition: Coupleable.C:1740
OutputTools< Real >::VariableValue VariableValue
Definition: MooseTypes.h:315
virtual const ArrayVariableGradient & coupledArrayGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled array variable.
Definition: Coupleable.C:1688
virtual const VariableValue & coupledDotDu(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled variable with respect to the coefficients.
Definition: Coupleable.C:1468
unsigned int coupledComponents(const std::string &var_name) const
Number of coupled components.
Definition: Coupleable.C:188
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:1713
virtual const ArrayVariableGradient & coupledArrayGradientOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from two time steps previous of a coupled array variable. ...
Definition: Coupleable.C:1714
virtual const VariableValue & coupledVectorDotDotDu(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled vector variable with respect to the coefficients.
Definition: Coupleable.C:1364
void checkComponent(const MooseObject *obj, unsigned int comp, unsigned int bound, const std::string &var_name)
Definition: Coupleable.C:208
std::vector< const ADVariableGradient * > adCoupledGradients(const std::string &var_name) const
Returns the gradients for all of a coupled variable&#39;s components for use in Automatic Differentiation...
Definition: Coupleable.C:2763
Interface for objects that needs coupling capabilities.
Definition: Coupleable.h:49
forward declarations
std::vector< MooseVariableField< Real > * > _coupled_fv_moose_vars
Vector of all finite volume coupled variables.
Definition: Coupleable.h:1435
std::vector< const VariableValue * > coupledValues(const std::string &var_name) const
Returns the values for all of a coupled variable components.
Definition: Coupleable.C:2538
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::vector< const ArrayVariableGradient * > coupledVectorTagArrayGradients(const std::string &var_names, TagID tag) const
Returns gradients for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2650
const T & getDefaultNodalValue(const std::string &var_name, unsigned int comp=0) const
Get nodal default value.
Definition: Coupleable.C:449
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
virtual const VectorVariableGradient & coupledVectorGradientOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from two time steps previous of a coupled vector variable.
Definition: Coupleable.C:1672
const MooseArray< ADRealTensorValue > & _ad_second_zero
Definition: Coupleable.h:1508
VectorVariableValue _default_vector_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1520
bool checkVar(const std::string &var_name, unsigned int comp=0, unsigned int comp_bound=0) const
Check that the right kind of variable is being coupled in.
Definition: Coupleable.C:239
virtual const VariableValue & coupledValuePreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns value of previous Newton iterate of a coupled variable.
Definition: Coupleable.C:1075
bool hasBlocks(const SubdomainID id) const override
Returns whether the functor is defined on this block.
MooseArray< ADRealTensorValue > _ad_default_vector_gradient
This will always be zero because the default values for optionally coupled vector variables is always...
Definition: Coupleable.h:1483
virtual const VectorVariableValue & coupledVectorValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled vector variable.
Definition: Coupleable.C:854
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
virtual const VariableValue & coupledDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled variable.
Definition: Coupleable.C:1259
MooseArray< ADRealTensorValue > _ad_default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1489
const VariableValue & coupledArrayDotDu(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled array variable with respect to the coefficients.
Definition: Coupleable.C:1518
std::vector< const VariableValue * > coupledVectorTagValues(const std::string &var_names, TagID tag) const
Returns the values for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2581
ArrayMooseVariable * getArrayVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled array variable.
Definition: Coupleable.C:336
virtual const ArrayVariableValue & coupledArrayDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled array variable.
Definition: Coupleable.C:1402
An interface that restricts an object to subdomains via the &#39;blocks&#39; input parameter.
Class for scalar variables (they are different).
IntRange< T > make_range(T beg, T end)
void resize(unsigned int size)
Change the number of elements the array can store.
Definition: MooseArray.h:216
const ADVectorVariableGradient & adCoupledVectorGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled vector variable for use in Automatic Differentiation.
Definition: Coupleable.C:2355
std::unordered_map< std::string, std::vector< unsigned int > > _optional_var_index
Unique indices for optionally coupled vars that weren&#39;t provided.
Definition: Coupleable.h:1802
const MooseVariableFieldBase * getFEVar(const std::string &var_name, unsigned int comp) const
Deprecated method.
Definition: Coupleable.C:298
std::unordered_map< std::string, std::vector< std::unique_ptr< VariableValue > > > _default_value
Will hold the default value for optional coupled variables.
Definition: Coupleable.h:1454
std::vector< const VariableValue * > coupledMatrixTagValues(const std::string &var_names, TagID tag) const
Returns the diagonal matrix values for all the coupled variables desired for a given tag...
Definition: Coupleable.C:2696
Moose::GenericType< VariableSecond, is_ad > GenericVariableSecond
Definition: MooseTypes.h:669
const InputParameters & _c_parameters
Definition: Coupleable.h:1406
OutputTools< Real >::VariableSecond VariableSecond
Definition: MooseTypes.h:317
const MooseArray< ADReal > & _ad_zero
Definition: Coupleable.h:1497
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
Definition: MooseTypes.h:146
virtual const ArrayVariableGradient & coupledArrayGradientOld(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from previous time step of a coupled array variable.
Definition: Coupleable.C:1701
const std::vector< T * > & getInterfaceObjects() const
Gets the registered interface objects for a given interface.
Definition: MooseApp.h:1678
const Moose::ADType< T >::type & adCoupledNodalValue(const std::string &var_name, unsigned int comp=0) const
Returns AD nodal values of a coupled variable.
Definition: Coupleable.C:2162
virtual const VariableValue & coupledNodalDotOld(const std::string &var_name, unsigned int comp=0) const
Nodal values of old time derivative of a coupled variable.
Definition: Coupleable.C:2025
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
std::unordered_map< std::string, std::unique_ptr< ArrayVariableValue > > _default_array_value
Will hold the default value for optional array coupled variables.
Definition: Coupleable.h:1464
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
OutputTools< RealVectorValue >::VariableGradient VectorVariableGradient
Definition: MooseTypes.h:333
ArrayVariableGradient _default_array_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1538
virtual bool isTransient() const override
const ADVariableSecond & getADDefaultSecond() const
Helper method to return (and insert if necessary) the default second derivatives for Automatic Differ...
Definition: Coupleable.C:2416
const std::set< std::string > _older_state_tags
vector tag names for which we need to request older solution states from the system ...
Definition: Coupleable.h:1817
virtual const VectorVariableCurl & coupledCurlOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old curl from two time steps previous of a coupled variable.
Definition: Coupleable.C:1772
virtual const VectorVariableDivergence & coupledDiv(const std::string &var_name, unsigned int comp=0) const
Returns divergence of a coupled variable.
Definition: Coupleable.C:1805
virtual const VariableGradient & coupledGradientPreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable for previous Newton iterate.
Definition: Coupleable.C:1591
ArrayVariableValue _default_array_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1535
unsigned int _coupleable_max_qps
Maximum qps for any element in this system.
Definition: Coupleable.h:1799
OutputTools< RealEigenVector >::VariableGradient ArrayVariableGradient
Definition: MooseTypes.h:350
void addFEVariableCoupleableMatrixTag(TagID tag)
Definition: Coupleable.h:115
A NodeElemConstraintBase is used when you need to create constraints between a secondary node and a p...
Moose::VarKindType varKind() const
Definition: SystemBase.h:924
std::vector< std::string > getVecMooseType(const std::string &name) const
std::vector< const ADVectorVariableValue * > adCoupledVectorValues(const std::string &var_name) const
Returns the values for all of a coupled vector variable&#39;s components for use in Automatic Differentia...
Definition: Coupleable.C:2573
const ADVectorVariableSecond & adCoupledVectorSecond(const std::string &, unsigned int)
Definition: Coupleable.C:2274
std::vector< const VectorVariableValue * > coupledVectorValues(const std::string &var_name) const
Returns the values for all of a coupled vector variable&#39;s components.
Definition: Coupleable.C:2545
virtual const VariableValue & coupledDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled variable.
Definition: Coupleable.C:1195
virtual const ArrayVariableGradient & coupledArrayGradientDot(const std::string &var_name, unsigned int comp=0) const
Retun a gradient of a coupled array variable&#39;s time derivative.
Definition: Coupleable.C:1727
virtual const VectorVariableValue & coupledVectorDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled vector variable.
Definition: Coupleable.C:1316
const ADVariableGradient & adCoupledGradientDot(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable&#39;s time derivative for use in Automatic Differentiation.
Definition: Coupleable.C:2239
void ErrorVector unsigned int
const ADVariableSecond & adCoupledSecond(const std::string &var_name, unsigned int comp=0) const
Returns second derivatives of a coupled variable for use in Automatic Differentiation.
Definition: Coupleable.C:2256
virtual const VectorVariableValue & coupledVectorDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled vector variable.
Definition: Coupleable.C:1332
const ADVectorVariableCurl & adCoupledCurl(const std::string &var_name, unsigned int comp=0) const
Returns curl of a coupled variable for use in objects utilizing Automatic Differentiation.
Definition: Coupleable.C:1788
virtual bool matrixTagExists(const TagName &tag_name) const
Check to see if a particular Tag exists.
Definition: SubProblem.C:328
void registerInterfaceObject(T &interface)
Registers an interface object for accessing with getInterfaceObjects.
Definition: MooseApp.h:1656
const ADVectorVariableValue & adCoupledVectorValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled vector variable for use in Automatic Differentiation.
Definition: Coupleable.C:2337
const T & coupledNodalValueOld(const std::string &var_name, unsigned int comp=0) const
Returns an old nodal value from previous time step of a coupled variable.
Definition: Coupleable.C:1939
MooseArray< ADRealVectorValue > _ad_default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1480
std::vector< const VariableValue * > coupledValuesOld(const std::string &var_name) const
Returns the old values for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2719
virtual const VariableGradient & coupledGradientOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from two time steps previous of a coupled variable.
Definition: Coupleable.C:1575
unsigned int THREAD_ID
Definition: MooseTypes.h:209
std::vector< const VariableValue * > coupledAllDofValues(const std::string &var_name) const
Returns DoFs in the current solution vector of all of a coupled variable&#39;s components for the local e...
Definition: Coupleable.C:2070
const MooseVariableFieldBase * getFieldVar(const std::string &var_name, unsigned int comp) const
Definition: Coupleable.C:312
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.
virtual const VectorVariableDivergence & coupledDivOld(const std::string &var_name, unsigned int comp=0) const
Returns an old divergence from previous time step of a coupled variable.
Definition: Coupleable.C:1821