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