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()),
36 _c_is_implicit(_c_parameters.have_parameter<bool>(
"implicit")
37 ? _c_parameters.get<bool>(
"implicit")
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")
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")
58 _coupleable_max_qps(
Moose::constMaxQpsPerElem),
61 _writable_coupled_variables(_c_fe_problem.numThreads())
66 unsigned int optional_var_index_counter = 0;
71 std::string name = *iter;
76 for (
const auto & coupled_var_name :
vars)
87 if (
auto * tmp_var =
dynamic_cast<MooseVariable *
>(moose_var))
98 _obj->
paramError(name,
"provided c++ type for variable parameter is not supported");
107 _obj->
paramError(name,
"coupled variable '", coupled_var_name,
"' was not found");
115 std::numeric_limits<unsigned int>::max() - optional_var_index_counter;
116 ++optional_var_index_counter;
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),
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),
148 _writable_coupled_variables(object._writable_coupled_variables)
160 return (i < it->second.size());
166 ": The coupled variable \"",
168 "\" was never added to this object's "
169 "InputParameters, please double-check your "
190 var_name <<
" must not actually be coupled!");
206 const std::string & var_name)
208 if (bound > 0 && comp >= bound)
210 var_name,
"component ", comp,
" is out of range for this variable (max ", bound - 1,
")");
228 "' uses older variable values that are unavailable with explicit schemes");
236 unsigned int comp_bound)
const
243 for (
auto jt : it->second)
244 cvars +=
" " + jt->name();
249 "' to a scalar variable (",
251 ") where field variable is expected");
259 mooseError(
_c_name,
": Trying to get a coupled var ", var_name,
" that doesn't exist");
261 const auto & vars_vector = vars_vector_it->second;
263 auto bound = comp_bound ? comp_bound : vars_vector.size();
267 const auto * var = vars_vector[comp];
271 ": We did all our checks for the existence of a var, yet we still don't have a var!?");
278 if (!var->isFV() &&
_is_fv)
279 mooseError(
"Attempting to couple non-FV variable ",
281 " into an FV object ",
283 ". This is not currently supported");
295 mooseDeprecated(
"Coupleable::getFEVar is deprecated. Please use Coupleable::getFieldVar instead. "
296 "Note that this method could potentially return a finite volume variable");
303 return getVarHelper<MooseVariableFieldBase>(var_name, comp);
309 return getVarHelper<MooseVariableFieldBase>(var_name, comp);
312std::vector<const MooseVariableFieldBase *>
315 return getVarsHelper<MooseVariableFieldBase>(var_name);
321 return const_cast<MooseVariable *
>(getVarHelper<MooseVariable>(var_name, comp));
330 if (
_c_nodal && var && var->feType().family != LAGRANGE_VEC)
331 mooseError(
_c_name,
": Only LAGRANGE_VEC vector variables are defined at nodes");
339 return const_cast<ArrayMooseVariable *
>(getVarHelper<ArrayMooseVariable>(var_name, comp));
345 return getVarHelper<MooseVariable>(var_name, comp);
351 const auto *
const var = getVarHelper<VectorMooseVariable>(var_name, comp);
353 if (
_c_nodal && var && var->feType().family != LAGRANGE_VEC)
354 mooseError(
_c_name,
": Only LAGRANGE_VEC vector variables are defined at nodes");
362 return getVarHelper<ArrayMooseVariable>(var_name, comp);
374 _default_value[var_name].emplace_back(std::make_unique<VariableValue>(
377 _default_value[var_name].emplace_back(std::make_unique<VariableValue>(
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)
387 " is equal to or greater than the number of default values ",
389 return default_value_vec[comp].get();
399 bool already_warned =
false;
407 catch (
const std::out_of_range &)
411 "You supplied less than 3 arguments for the default vector value for variable ",
413 ". Did you accidently leave something off? We are going to assign 0s, assuming "
416 already_warned =
true;
424 return default_value_it->second.get();
437 (*value)[qp].resize(n);
438 for (
unsigned int i = 0; i < n; ++i)
445 return default_value_it->second.get();
453 return *default_variable_value->data();
457const RealVectorValue &
458Coupleable::getDefaultNodalValue<RealVectorValue>(
const std::string & var_name,
unsigned int)
const
461 return *default_variable_value->data();
465const RealEigenVector &
466Coupleable::getDefaultNodalValue<RealEigenVector>(
const std::string & var_name,
unsigned int)
const
469 return *default_variable_value->data();
479 "optional var index for " << var_name <<
" does not exist!");
492 return var->number();
496 return std::numeric_limits<unsigned int>::max() - var->number();
501Coupleable::coupledGenericValue<false>(
const std::string & var_name,
unsigned int comp)
const
508Coupleable::coupledGenericValue<true>(
const std::string & var_name,
unsigned int comp)
const
515Coupleable::coupledGenericVectorValue<false>(
const std::string & var_name,
unsigned int comp)
const
522Coupleable::coupledGenericVectorValue<true>(
const std::string & var_name,
unsigned int comp)
const
530 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
545 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
547 return (
_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
555 const unsigned int index)
const
557 const auto *
const var = getVarHelper<MooseVariableField<T>>(var_names, index);
559 mooseError(var_names,
": invalid variable name for coupledVectorTagValue");
563 mooseError(
"Attempting to couple to vector tag with ID ",
567 ", but a vector tag with that ID does not exist");
572 return var->nodalVectorTagValue(tag);
574 return var->vectorTagValue(tag);
580 const TagName & tag_name,
581 const unsigned int comp)
586 mooseError(var_name,
": invalid variable name for tag coupling");
588 auto & var_sys = var->sys();
590 var_sys.needSolutionState(1);
592 var_sys.needSolutionState(2);
598 const std::string & tag_param_name,
599 const unsigned int index)
const
602 mooseError(
"Tag name parameter '", tag_param_name,
"' is invalid");
609 const_cast<Coupleable *
>(
this)->requestStates<T>(var_names, tag_name, index);
612 mooseError(
"Tagged vector with tag name '", tag_name,
"' does not exist");
615 return vectorTagValueHelper<T>(var_names, tag, index);
620Coupleable::coupledGenericDofValue<false>(
const std::string & var_name,
unsigned int comp)
const
627Coupleable::coupledGenericDofValue<true>(
const std::string & var_name,
unsigned int comp)
const
635 const auto * var =
getVar(var_name, comp);
641 mooseError(
_c_name,
":coupledValueLower cannot be called in a coupleable neighbor object");
652 unsigned int index)
const
654 return vectorTagValueHelper<Real>(var_names, tag, index);
659 const std::string & tag_name,
660 unsigned int index)
const
662 return vectorTagValueHelper<Real>(var_names, tag_name, index);
668 unsigned int index)
const
670 return vectorTagValueHelper<RealEigenVector>(var_names, tag, index);
675 const std::string & tag_name,
676 unsigned int index)
const
678 return vectorTagValueHelper<RealEigenVector>(var_names, tag_name, index);
684 unsigned int index)
const
686 const auto * var =
getVar(var_names, index);
688 mooseError(var_names,
": invalid variable name for coupledVectorTagGradient");
692 mooseError(
"Attempting to couple to vector tag with ID ",
696 ", but a vector tag with that ID does not exist");
700 return var->vectorTagGradient(tag);
705 const std::string & tag_name,
706 unsigned int index)
const
709 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
713 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
722 unsigned int index)
const
726 mooseError(var_names,
": invalid variable name for coupledVectorTagArrayGradient");
730 mooseError(
"Attempting to couple to vector tag with ID ",
734 ", but a vector tag with that ID does not exist");
738 return var->vectorTagGradient(tag);
743 const std::string & tag_name,
744 unsigned int index)
const
747 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
751 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
761 const unsigned int comp)
const
763 const auto * var = getVarHelper<MooseVariableField<T>>(var_name, comp);
765 mooseError(var_name,
": invalid variable name for coupledVectorTagDofValue");
770 return var->vectorTagDofValue(tag);
776 const std::string & tag_param_name,
777 const unsigned int comp)
const
780 mooseError(
"Tag name parameter '", tag_param_name,
"' is invalid");
787 const_cast<Coupleable *
>(
this)->requestStates<T>(var_name, tag_name, comp);
790 mooseError(
"Tagged vector with tag name '", tag_name,
"' does not exist");
794 return vectorTagDofValueHelper<T>(var_name, tag, comp);
800 unsigned int comp)
const
802 return vectorTagDofValueHelper<Real>(var_name, tag, comp);
807 const std::string & tag_name,
808 unsigned int comp)
const
810 return vectorTagDofValueHelper<Real>(var_name, tag_name, comp);
815 const std::string & tag_name,
816 unsigned int comp)
const
818 return vectorTagDofValueHelper<RealEigenVector>(var_name, tag_name, comp);
824 unsigned int index)
const
826 const auto * var = getVarHelper<MooseVariableField<Real>>(var_names, index);
828 mooseError(var_names,
": invalid variable name for coupledMatrixTagValue");
834 return var->nodalMatrixTagValue(tag);
835 return var->matrixTagValue(tag);
840 const std::string & tag_name,
841 unsigned int index)
const
844 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
848 mooseError(
"Matrix tag name '", tagname,
"' does not exist");
865 return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
873 return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
875 return _c_is_implicit ? var->slnNeighbor() : var->slnOldNeighbor();
896 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
897 return (
_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
901std::vector<const ArrayVariableValue *>
904 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledArrayValue(var_name, comp); };
905 return coupledVectorHelper<const ArrayVariableValue *>(var_name, func);
923 return var->adSlnNeighbor();
926std::vector<const ADArrayVariableValue *>
929 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledArrayValue(var_name, comp); };
930 return coupledVectorHelper<const ADArrayVariableValue *>(var_name, func);
936 auto * var = getVarHelper<MooseWritableVariable>(var_name, comp);
938 const auto * aux =
dynamic_cast<const AuxKernel *
>(
this);
943 const auto * mat =
dynamic_cast<const Material *
>(
this);
945 if (!aux && !euo && !nuo && !nfc && !nec && !mat)
946 mooseError(
"writableVariable() can only be called from AuxKernels, ElementUserObjects, "
947 "NodalUserObjects, NodeFaceConstraints, NodeElemConstraints or Materials. '",
949 "' is none of those.");
951 if (aux && !aux->isNodal() && var->isNodal())
954 "' cannot obtain a writable reference to the nodal variable '",
957 if (euo && var->isNodal())
960 "' cannot obtain a writable reference to the nodal variable '",
973 mooseDeprecated(
"Coupleable::writableCoupledValue is deprecated, please use "
974 "Coupleable::writableVariable instead. ");
977 auto *
const var =
getVar(var_name, comp);
980 "Unable to create a writable reference for '", var_name,
"', is it a constant expression?");
985 "'", var->name(),
"' must be an auxiliary variable in Coupleable::writableCoupledValue");
988 const auto * aux =
dynamic_cast<const AuxKernel *
>(
this);
991 mooseError(
"writableCoupledValue() can only be called from AuxKernels, but '",
993 "' is not an AuxKernel.");
995 if (!aux->isNodal() && var->isNodal())
998 "' cannot obtain a writable reference to the nodal variable '",
1014 const auto * mat =
dynamic_cast<const Material *
>(
this);
1016 if (br && !var->
hasBlocks(br->blockIDs()))
1019 "' must be defined on all blocks '",
1021 "' is defined on.");
1023 if (nfc && !var->
hasBlocks(nfc->getSecondaryConnectedBlocks()))
1026 " must be defined on all blocks '",
1028 "'s secondary surface is defined on.");
1032 if (ci !=
this && ci->_writable_coupled_variables[
_c_tid].count(var))
1037 if (br && br_other && br->blockRestricted() && br_other->blockRestricted() &&
1038 !MooseUtils::setsIntersect(br->blockIDs(), br_other->blockIDs()))
1048 "' already obtained a writable reference to '",
1050 "'. Only one object can obtain such a reference per variable and subdomain in a "
1064 const auto * var =
getVar(var_name, comp);
1072 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1078 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1079 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1086 const auto * var =
getVar(var_name, comp);
1094 return var->dofValuesOlder();
1095 return var->slnOlder();
1100 return var->dofValuesOlderNeighbor();
1101 return var->slnOlderNeighbor();
1108 const auto * var =
getVar(var_name, comp);
1117 return var->dofValuesPreviousNL();
1118 return var->slnPreviousNL();
1123 return var->dofValuesPreviousNLNeighbor();
1124 return var->slnPreviousNLNeighbor();
1137 return (
_c_is_implicit) ? var->nodalValueOldArray() : var->nodalValueOlderArray();
1140 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1152 return var->slnOlder();
1153 return var->slnOlderNeighbor();
1167 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1173 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1174 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1189 return var->dofValuesOlder();
1190 return var->slnOlder();
1195 return var->dofValuesOlderNeighbor();
1196 return var->slnOlderNeighbor();
1203 const auto * var =
getVar(var_name, comp);
1214 return var->dofValuesDot();
1220 return var->dofValuesDotNeighbor();
1221 return var->uDotNeighbor();
1228 const auto * var =
getVar(var_name, comp);
1239 return var->dofValuesDotDot();
1240 return var->uDotDot();
1245 return var->dofValuesDotDotNeighbor();
1246 return var->uDotDotNeighbor();
1252Coupleable::coupledGenericDotDot<false>(
const std::string & var_name,
unsigned int comp)
const
1259Coupleable::coupledGenericDotDot<true>(
const std::string & var_name,
unsigned int comp)
const
1267 const auto * var =
getVar(var_name, comp);
1278 return var->dofValuesDotOld();
1279 return var->uDotOld();
1284 return var->dofValuesDotOldNeighbor();
1285 return var->uDotOldNeighbor();
1292 const auto * var =
getVar(var_name, comp);
1303 return var->dofValuesDotDotOld();
1304 return var->uDotDotOld();
1309 return var->dofValuesDotDotOldNeighbor();
1310 return var->uDotDotOldNeighbor();
1327 return var->uDotNeighbor();
1342 return var->uDotDot();
1343 return var->uDotDotNeighbor();
1358 return var->uDotOld();
1359 return var->uDotOldNeighbor();
1374 return var->uDotDotOld();
1375 return var->uDotDotOldNeighbor();
1390 return var->duDotDu();
1391 return var->duDotDuNeighbor();
1406 return var->duDotDotDu();
1407 return var->duDotDotDuNeighbor();
1421 return var->dofValuesDot();
1427 return var->dofValuesDotNeighbor();
1428 return var->uDotNeighbor();
1443 return var->dofValuesDotDot();
1444 return var->uDotDot();
1449 return var->dofValuesDotDotNeighbor();
1450 return var->uDotDotNeighbor();
1466 return var->adUDot();
1467 return var->adUDotNeighbor();
1482 return var->adUDotDot();
1483 return var->adUDotDotNeighbor();
1497 return var->dofValuesDotOld();
1498 return var->uDotOld();
1503 return var->dofValuesDotOldNeighbor();
1504 return var->uDotOldNeighbor();
1519 return var->dofValuesDotDotOld();
1520 return var->uDotDotOld();
1525 return var->dofValuesDotDotOldNeighbor();
1526 return var->uDotDotOldNeighbor();
1533 const auto * var =
getVar(var_name, comp);
1544 return var->dofValuesDuDotDu();
1545 return var->duDotDu();
1550 return var->dofValuesDuDotDuNeighbor();
1551 return var->duDotDuNeighbor();
1558 const auto * var =
getVar(var_name, comp);
1569 return var->dofValuesDuDotDotDu();
1570 return var->duDotDotDu();
1575 return var->dofValuesDuDotDotDuNeighbor();
1576 return var->duDotDotDuNeighbor();
1583 const auto *
const var =
getArrayVar(var_name, comp);
1594 return var->dofValuesDuDotDu();
1595 return var->duDotDu();
1600 return var->dofValuesDuDotDuNeighbor();
1601 return var->duDotDuNeighbor();
1608 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
1618 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1624 const auto * var =
getVar(var_name, comp);
1633 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1634 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1640 const auto * var =
getVar(var_name, comp);
1649 return var->gradSlnOlder();
1650 return var->gradSlnOlderNeighbor();
1656 const auto * var =
getVar(var_name, comp);
1666 return var->gradSlnPreviousNL();
1667 return var->gradSlnPreviousNLNeighbor();
1673 const auto * var =
getVar(var_name, comp);
1682 return var->gradSlnDot();
1683 return var->gradSlnNeighborDot();
1689 const auto * var =
getVar(var_name, comp);
1698 return var->gradSlnDotDot();
1699 return var->gradSlnNeighborDotDot();
1715 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1730 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1731 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1746 return var->gradSlnOlder();
1747 return var->gradSlnOlderNeighbor();
1760 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1776 return var->adGradSlnNeighbor();
1779std::vector<const ADArrayVariableGradient *>
1782 auto func = [
this, &var_name](
unsigned int comp)
1784 return coupledVectorHelper<const ADArrayVariableGradient *>(var_name, func);
1796 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1797 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1809 return var->gradSlnOlder();
1810 return var->gradSlnOlderNeighbor();
1816 const auto *
const var =
getArrayVar(var_name, comp);
1822 return var->gradSlnDot();
1823 return var->gradSlnNeighborDot();
1839 return (
_c_is_implicit) ? var->curlSlnNeighbor() : var->curlSlnOldNeighbor();
1854 return (
_c_is_implicit) ? var->curlSlnOld() : var->curlSlnOlder();
1855 return (
_c_is_implicit) ? var->curlSlnOldNeighbor() : var->curlSlnOlderNeighbor();
1870 return var->curlSlnOlder();
1871 return var->curlSlnOlderNeighbor();
1887 return var->adCurlSln();
1888 return var->adCurlSlnNeighbor();
1904 return var->adDivSln();
1905 return var->adDivSlnNeighbor();
1921 return (
_c_is_implicit) ? var->divSlnNeighbor() : var->divSlnOldNeighbor();
1937 return (
_c_is_implicit) ? var->divSlnOldNeighbor() : var->divSlnOlderNeighbor();
1952 return var->divSlnOlder();
1953 return var->divSlnOlderNeighbor();
1959 const auto * var =
getVar(var_name, comp);
1968 return (
_c_is_implicit) ? var->secondSln() : var->secondSlnOlder();
1969 return (
_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOlderNeighbor();
1975 const auto * var =
getVar(var_name, comp);
1984 return (
_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder();
1985 return (
_c_is_implicit) ? var->secondSlnOldNeighbor() : var->secondSlnOlderNeighbor();
1991 const auto * var =
getVar(var_name, comp);
2000 return var->secondSlnOlder();
2001 return var->secondSlnOlderNeighbor();
2007 const auto * var =
getVar(var_name, comp);
2017 return var->secondSlnPreviousNL();
2018 return var->secondSlnPreviousNLNeighbor();
2021template <
typename T>
2025 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2027 return getDefaultNodalValue<T>(var_name, comp);
2030 if (!var->isNodal())
2032 ": Trying to get nodal values of variable '",
2034 "', but it is not nodal.");
2037 return (
_c_is_implicit) ? var->nodalValue() : var->nodalValueOld();
2038 return (
_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor();
2041template <
typename T>
2045 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2047 return getDefaultNodalValue<T>(var_name, comp);
2050 if (!var->isNodal())
2052 ": Trying to get old nodal values of variable '",
2054 "', but it is not nodal.");
2057 return (
_c_is_implicit) ? var->nodalValueOld() : var->nodalValueOlder();
2058 return (
_c_is_implicit) ? var->nodalValueOldNeighbor() : var->nodalValueOlderNeighbor();
2061template <
typename T>
2065 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2067 return getDefaultNodalValue<T>(var_name, comp);
2070 if (!var->isNodal())
2072 ": Trying to get older nodal values of variable '",
2074 "', but it is not nodal.");
2077 return var->nodalValueOlder();
2078 return var->nodalValueOlderNeighbor();
2081template <
typename T>
2085 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2087 return getDefaultNodalValue<T>(var_name, comp);
2093 return var->nodalValuePreviousNL();
2094 return var->nodalValuePreviousNLNeighbor();
2097template <
typename T>
2101 static const T zero = 0;
2102 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2108 return var->nodalValueDot();
2109 mooseError(
"Neighbor version not implemented");
2115 const auto * var =
getVar(var_name, comp);
2124 return var->dofValuesDotDot();
2125 return var->dofValuesDotDotNeighbor();
2131 const auto * var =
getVar(var_name, comp);
2140 return var->dofValuesDotOld();
2141 return var->dofValuesDotOldNeighbor();
2147 const auto * var =
getVar(var_name, comp);
2156 return var->dofValuesDotDotOld();
2157 return var->dofValuesDotDotOldNeighbor();
2163 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2169 return (
_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
2170 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
2173std::vector<const VariableValue *>
2176 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDofValues(var_name, comp); };
2178 return coupledVectorHelper<const VariableValue *>(var_name, func);
2184 const auto * var =
getVar(var_name, comp);
2190 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
2191 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
2194std::vector<const VariableValue *>
2197 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDofValuesOld(var_name, comp); };
2198 return coupledVectorHelper<const VariableValue *>(var_name, func);
2204 const auto * var =
getVar(var_name, comp);
2210 return var->dofValuesOlder();
2211 return var->dofValuesOlderNeighbor();
2214std::vector<const VariableValue *>
2217 auto func = [
this, &var_name](
unsigned int comp)
2219 return coupledVectorHelper<const VariableValue *>(var_name, func);
2231 return (
_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
2232 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
2238 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2248 return var->adDofValues();
2249 return var->adDofValuesNeighbor();
2259 "\" on variable \"",
2261 "\" when using a \"Steady\" executioner is not allowed. This value is available "
2262 "only in transient simulations.");
2265template <
typename T>
2274 mooseError(
"The adCoupledNodalValue method should only be called for nodal computing objects");
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.");
2280 mooseError(
"If you're going to use an explicit scheme, then use coupledNodalValue instead of "
2281 "adCoupledNodalValue");
2283 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2285 return var->adNodalValue();
2291 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2301 return var->adDofValues();
2304 return var->adSln();
2305 return var->adSlnNeighbor();
2311 auto var = getVarHelper<MooseVariableFE<Real>>(var_name, comp);
2318 mooseError(
"adCoupledLowerValue cannot be called in a coupleable neighbor object");
2321 return var->adDofValues();
2323 return var->adSlnLower();
2329 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2340 return var->adGradSlnNeighbor();
2346 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2355 "The AD gradient time derivative is not computed on element faces");
2358 return var->adGradSlnDot();
2359 return var->adGradSlnNeighborDot();
2365 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2375 return var->adSecondSln();
2377 return var->adSecondSlnNeighbor();
2383 mooseError(
"Automatic differentiation using second derivatives of vector variables is not "
2390 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2399 return var->adDofValuesDot();
2400 return var->adUDot();
2405 mooseError(
"AD neighbor nodal dof dot not implemented");
2406 return var->adUDotNeighbor();
2413 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2423 return var->adUDotDot();
2424 return var->adUDotDotNeighbor();
2439 return var->adUDot();
2440 return var->adUDotNeighbor();
2457 return var->adSln();
2458 return var->adSlnNeighbor();
2474 return var->adGradSlnNeighbor();
2485 default_value_it =
_ad_default_value.insert(std::make_pair(var_name, std::move(value))).first;
2488 return default_value_it->second.get();
2497 RealVectorValue default_vec;
2505 return default_value_it->second.get();
2515 ADRealEigenVector default_array(n);
2516 for (
const auto i : make_range(n))
2523 return default_value_it->second.get();
2534 ADArrayVariableGradient::value_type::Zero(n,
Moose::dim);
2536 default_gradient_it =
2540 return *default_gradient_it->second;
2550 const ADRealEigenVector zero = ADRealEigenVector::Zero(n);
2556 return *default_value_it->second;
2597 mooseDeprecated(
"Method adZeroValue() is deprecated. Use '_ad_zero' instead.");
2604 mooseDeprecated(
"Method adZeroGradient() is deprecated. Use '_ad_grad_zero' instead.");
2611 mooseDeprecated(
"Method adZeroSecond() is deprecated. Use '_ad_second_zero' instead.");
2617Coupleable::genericZeroValue<false>()
2624Coupleable::genericZeroValue<true>()
2631Coupleable::genericZeroGradient<false>()
2638Coupleable::genericZeroGradient<true>()
2645Coupleable::genericZeroSecond<false>()
2652Coupleable::genericZeroSecond<true>()
2659Coupleable::coupledGenericGradient<false>(
const std::string & var_name,
unsigned int comp)
const
2666Coupleable::coupledGenericGradient<true>(
const std::string & var_name,
unsigned int comp)
const
2671std::vector<unsigned int>
2674 auto func = [
this, &var_name](
unsigned int comp) {
return coupled(var_name, comp); };
2675 return coupledVectorHelper<unsigned int>(var_name, func);
2686 ": a variable name was queried but a constant was passed for parameter '",
2688 "Either pass a true variable or contact a developer to shield the call to "
2689 "'coupledName' with 'isCoupledConstant'");
2692 _c_name,
": Variable '", var_name,
"' does not exist, yet its coupled name is requested");
2695std::vector<VariableName>
2698 auto func = [
this, &var_name](
unsigned int comp) {
return coupledName(var_name, comp); };
2699 return coupledVectorHelper<VariableName>(var_name, func);
2702std::vector<const VariableValue *>
2705 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValue(var_name, comp); };
2706 return coupledVectorHelper<const VariableValue *>(var_name, func);
2709std::vector<const VectorVariableValue *>
2712 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledVectorValue(var_name, comp); };
2713 return coupledVectorHelper<const VectorVariableValue *>(var_name, func);
2717std::vector<const GenericVariableValue<false> *>
2718Coupleable::coupledGenericValues<false>(
const std::string & var_name)
const
2724std::vector<const GenericVariableValue<true> *>
2725Coupleable::coupledGenericValues<true>(
const std::string & var_name)
const
2730std::vector<const ADVariableValue *>
2733 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledValue(var_name, comp); };
2734 return coupledVectorHelper<const ADVariableValue *>(var_name, func);
2737std::vector<const ADVectorVariableValue *>
2740 auto func = [
this, &var_name](
unsigned int comp)
2742 return coupledVectorHelper<const ADVectorVariableValue *>(var_name, func);
2745std::vector<const VariableValue *>
2748 auto func = [
this, &var_names, &tag](
unsigned int comp)
2750 return coupledVectorHelper<const VariableValue *>(var_names, func);
2753std::vector<const VariableValue *>
2755 const std::string & tag_name)
const
2758 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2762 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2768std::vector<const ArrayVariableValue *>
2771 auto func = [
this, &var_names, &tag](
unsigned int index)
2773 return coupledVectorHelper<const ArrayVariableValue *>(var_names, func);
2776std::vector<const ArrayVariableValue *>
2778 const std::string & tag_name)
const
2781 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2785 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2791std::vector<const VariableGradient *>
2794 auto func = [
this, &var_names, &tag](
unsigned int index)
2796 return coupledVectorHelper<const VariableGradient *>(var_names, func);
2799std::vector<const VariableGradient *>
2801 const std::string & tag_name)
const
2804 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2808 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2814std::vector<const ArrayVariableGradient *>
2817 auto func = [
this, &var_names, &tag](
unsigned int index)
2819 return coupledVectorHelper<const ArrayVariableGradient *>(var_names, func);
2822std::vector<const ArrayVariableGradient *>
2824 const std::string & tag_name)
const
2827 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2831 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2837std::vector<const VariableValue *>
2840 auto func = [
this, &var_names, &tag](
unsigned int comp)
2842 return coupledVectorHelper<const VariableValue *>(var_names, func);
2845std::vector<const VariableValue *>
2847 const std::string & tag_name)
const
2850 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2854 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2860std::vector<const VariableValue *>
2863 auto func = [
this, &var_names, &tag](
unsigned int comp)
2865 return coupledVectorHelper<const VariableValue *>(var_names, func);
2868std::vector<const VariableValue *>
2870 const std::string & tag_name)
const
2873 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2877 mooseError(
"Matrix tag name '", tagname,
"' does not exist");
2883std::vector<const VariableValue *>
2886 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValueOld(var_name, comp); };
2887 return coupledVectorHelper<const VariableValue *>(var_name, func);
2890std::vector<const VariableValue *>
2893 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValueOlder(var_name, comp); };
2894 return coupledVectorHelper<const VariableValue *>(var_name, func);
2897std::vector<const VectorVariableValue *>
2900 auto func = [
this, &var_name](
unsigned int comp)
2902 return coupledVectorHelper<const VectorVariableValue *>(var_name, func);
2905std::vector<const VariableGradient *>
2908 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledGradient(var_name, comp); };
2909 return coupledVectorHelper<const VariableGradient *>(var_name, func);
2913std::vector<const GenericVariableGradient<false> *>
2914Coupleable::coupledGenericGradients<false>(
const std::string & var_name)
const
2920std::vector<const GenericVariableGradient<true> *>
2921Coupleable::coupledGenericGradients<true>(
const std::string & var_name)
const
2923 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledGradient(var_name, comp); };
2924 return coupledVectorHelper<const GenericVariableGradient<true> *>(var_name, func);
2927std::vector<const ADVariableGradient *>
2930 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledGradient(var_name, comp); };
2931 return coupledVectorHelper<const ADVariableGradient *>(var_name, func);
2934std::vector<const VariableGradient *>
2937 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledGradientOld(var_name, comp); };
2938 return coupledVectorHelper<const VariableGradient *>(var_name, func);
2941std::vector<const VariableValue *>
2944 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDot(var_name, comp); };
2945 return coupledVectorHelper<const VariableValue *>(var_name, func);
2948std::vector<const ADVariableValue *>
2951 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledDot(var_name, comp); };
2952 return coupledVectorHelper<const ADVariableValue *>(var_name, func);
2957Coupleable::coupledGenericDot<false>(
const std::string & var_name,
unsigned int comp)
const
2964Coupleable::coupledGenericDot<true>(
const std::string & var_name,
unsigned int comp)
const
2971template const Real & Coupleable::getDefaultNodalValue<Real>(
const std::string & var_name,
2972 unsigned int comp)
const;
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;
2979Coupleable::adCoupledNodalValue<RealVectorValue>(
const std::string & var_name,
2980 unsigned int comp)
const;
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)
const ADVectorVariableSecond & adCoupledVectorSecond(const std::string &, unsigned int)
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application.
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
OutputTools< RealVectorValue >::VariableCurl VectorVariableCurl
OutputTools< Real >::VariableGradient VariableGradient
OutputTools< RealEigenVector >::VariableValue ArrayVariableValue
Moose::GenericType< VariableValue, is_ad > GenericVariableValue
Moose::GenericType< VectorVariableValue, is_ad > GenericVectorVariableValue
Moose::GenericType< VariableSecond, is_ad > GenericVariableSecond
OutputTools< Real >::VariableValue VariableValue
OutputTools< RealVectorValue >::VariableDivergence VectorVariableDivergence
Moose::GenericType< VariableGradient, is_ad > GenericVariableGradient
OutputTools< RealEigenVector >::VariableGradient ArrayVariableGradient
OutputTools< Real >::VariableSecond VariableSecond
OutputTools< RealVectorValue >::VariableGradient VectorVariableGradient
OutputTools< RealVectorValue >::VariableValue VectorVariableValue
An interface that restricts an object to subdomains via the 'blocks' input parameter.
Interface for objects that needs coupling capabilities.
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.
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.
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.
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.
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.
virtual const ArrayVariableValue & coupledArrayValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled array variable.
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)
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.
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.
virtual const VariableValue & coupledValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled variable.
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.
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.
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)
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.
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.
VectorMooseVariable * getVectorVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled vector variable.
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.
FEProblemBase & _c_fe_problem
const MooseVariableFieldBase * getFieldVar(const std::string &var_name, unsigned int comp) const
const MooseVariableFieldBase * getFEVar(const std::string &var_name, unsigned int comp) const
Deprecated method.
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.
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.
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
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.
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...
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.
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.
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...
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.
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.
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.
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 ...
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...
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.
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.
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.
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.
std::vector< const MooseVariableFieldBase * > getFieldVars(const std::string &var_name) const
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.
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.
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
Materials compute MaterialProperties.
void registerInterfaceObject(T &interface)
Registers an interface object for accessing with getInterfaceObjects.
const std::vector< T * > & getInterfaceObjects() const
Gets the registered interface objects for a given interface.
OutputGradient value_type
void resize(unsigned int size)
Change the number of elements the array can store.
const std::string & name() const
Get the name of the class.
void paramError(const std::string ¶m, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
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.
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.
virtual TagID getVectorTagID(const TagName &tag_name) const
Get a TagID from a TagName.
virtual TagID getMatrixTagID(const TagName &tag_name) const
Get a TagID from a TagName.
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.
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.
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)
unsigned int number() const
Gets the number of this system.
Moose::VarKindType varKind() const
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
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...
const TagName OLDER_SOLUTION_TAG
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
const TagName OLD_SOLUTION_TAG