28 : _c_parameters(moose_object->parameters()),
29 _c_name(moose_object->
name()),
30 _c_type(moose_object->type()),
31 _c_fe_problem(*_c_parameters.getCheckedPointerParam<
FEProblemBase *>(
"_fe_problem_base")),
32 _c_sys(_c_parameters.isParamValid(
"_sys") ? _c_parameters.
get<
SystemBase *>(
"_sys") : nullptr),
33 _new_to_deprecated_coupled_vars(_c_parameters.getNewToDeprecatedVarMap()),
35 _c_is_implicit(_c_parameters.have_parameter<bool>(
"implicit")
36 ? _c_parameters.
get<bool>(
"implicit")
38 _c_allow_element_to_nodal_coupling(
39 _c_parameters.have_parameter<bool>(
"_allow_nodal_to_elemental_coupling")
40 ? _c_parameters.
get<bool>(
"_allow_nodal_to_elemental_coupling")
43 _zero(_c_fe_problem._zero[_c_tid]),
44 _phi_zero(_c_fe_problem._phi_zero[_c_tid]),
45 _ad_zero(_c_fe_problem._ad_zero[_c_tid]),
46 _grad_zero(_c_fe_problem._grad_zero[_c_tid]),
47 _ad_grad_zero(_c_fe_problem._ad_grad_zero[_c_tid]),
48 _grad_phi_zero(_c_fe_problem._grad_phi_zero[_c_tid]),
49 _second_zero(_c_fe_problem._second_zero[_c_tid]),
50 _ad_second_zero(_c_fe_problem._ad_second_zero[_c_tid]),
51 _second_phi_zero(_c_fe_problem._second_phi_zero[_c_tid]),
52 _vector_zero(_c_fe_problem._vector_zero[_c_tid]),
53 _vector_curl_zero(_c_fe_problem._vector_curl_zero[_c_tid]),
54 _coupleable_neighbor(_c_parameters.have_parameter<bool>(
"_neighbor")
55 ? _c_parameters.
get<bool>(
"_neighbor")
65 unsigned int optional_var_index_counter = 0;
70 std::string
name = *iter;
75 for (
const auto & coupled_var_name :
vars)
86 if (
auto * tmp_var = dynamic_cast<MooseVariable *>(moose_var))
88 else if (
auto * tmp_var = dynamic_cast<VectorMooseVariable *>(moose_var))
90 else if (
auto * tmp_var = dynamic_cast<ArrayMooseVariable *>(moose_var))
97 tmp_var->requireQpComputations();
121 ++optional_var_index_counter;
126 #ifdef MOOSE_KOKKOS_ENABLED 128 : _c_parameters(object._c_parameters),
129 _c_name(object._c_name),
130 _c_type(object._c_type),
131 _c_fe_problem(object._c_fe_problem),
132 _c_sys(object._c_sys),
133 _new_to_deprecated_coupled_vars(object._new_to_deprecated_coupled_vars),
134 _c_nodal(object._c_nodal),
135 _c_is_implicit(object._c_is_implicit),
136 _c_allow_element_to_nodal_coupling(object._c_allow_element_to_nodal_coupling),
137 _c_tid(object._c_tid),
139 _phi_zero(object._phi_zero),
140 _ad_zero(object._ad_zero),
141 _grad_zero(object._grad_zero),
142 _ad_grad_zero(object._ad_grad_zero),
143 _grad_phi_zero(object._grad_phi_zero),
144 _second_zero(object._second_zero),
145 _ad_second_zero(object._ad_second_zero),
146 _second_phi_zero(object._second_phi_zero),
147 _vector_zero(object._vector_zero),
148 _vector_curl_zero(object._vector_curl_zero),
149 _coupleable_neighbor(object._coupleable_neighbor),
150 _coupleable_max_qps(object._coupleable_max_qps),
151 _is_fv(object._is_fv),
153 _writable_coupled_variables(object._writable_coupled_variables)
165 return (i < it->second.size());
171 ": The coupled variable \"",
173 "\" was never added to this object's " 174 "InputParameters, please double-check your " 195 var_name <<
" must not actually be coupled!");
211 const std::string & var_name)
213 if (bound > 0 && comp >= bound)
215 var_name,
"component ", comp,
" is out of range for this variable (max ", bound - 1,
")");
233 "' uses older variable values that are unavailable with explicit schemes");
241 unsigned int comp_bound)
const 248 for (
auto jt : it->second)
249 cvars +=
" " + jt->name();
254 "' to a scalar variable (",
256 ") where field variable is expected");
264 mooseError(
_c_name,
": Trying to get a coupled var ", var_name,
" that doesn't exist");
266 const auto & vars_vector = vars_vector_it->second;
268 auto bound = comp_bound ? comp_bound : vars_vector.size();
272 const auto * var = vars_vector[comp];
276 ": We did all our checks for the existence of a var, yet we still don't have a var!?");
283 if (!var->isFV() &&
_is_fv)
284 mooseError(
"Attempting to couple non-FV variable ",
286 " into an FV object ",
288 ". This is not currently supported");
300 mooseDeprecated(
"Coupleable::getFEVar is deprecated. Please use Coupleable::getFieldVar instead. " 301 "Note that this method could potentially return a finite volume variable");
308 return getVarHelper<MooseVariableFieldBase>(var_name, comp);
314 return getVarHelper<MooseVariableFieldBase>(var_name, comp);
320 return const_cast<MooseVariable *
>(getVarHelper<MooseVariable>(var_name, comp));
330 mooseError(
_c_name,
": Only LAGRANGE_VEC vector variables are defined at nodes");
338 return const_cast<ArrayMooseVariable *
>(getVarHelper<ArrayMooseVariable>(var_name, comp));
344 return getVarHelper<MooseVariable>(var_name, comp);
350 const auto *
const var = getVarHelper<VectorMooseVariable>(var_name, comp);
353 mooseError(
_c_name,
": Only LAGRANGE_VEC vector variables are defined at nodes");
361 return getVarHelper<ArrayMooseVariable>(var_name, comp);
373 _default_value[var_name].emplace_back(std::make_unique<VariableValue>(
376 _default_value[var_name].emplace_back(std::make_unique<VariableValue>(
381 const auto & default_value_vec = default_value_it->second;
382 const auto n_default_vals = default_value_vec.size();
383 if (comp >= n_default_vals)
386 " is equal to or greater than the number of default values ",
388 return default_value_vec[comp].get();
398 bool already_warned =
false;
406 catch (
const std::out_of_range &)
410 "You supplied less than 3 arguments for the default vector value for variable ",
412 ". Did you accidently leave something off? We are going to assign 0s, assuming " 415 already_warned =
true;
423 return default_value_it->second.get();
436 (*value)[qp].resize(n);
437 for (
unsigned int i = 0; i < n; ++i)
444 return default_value_it->second.get();
447 template <
typename T>
452 return *default_variable_value->data();
457 Coupleable::getDefaultNodalValue<RealVectorValue>(
const std::string & var_name,
unsigned int)
const 459 auto && default_variable_value = getDefaultVectorValue(var_name);
460 return *default_variable_value->data();
465 Coupleable::getDefaultNodalValue<RealEigenVector>(
const std::string & var_name,
unsigned int)
const 467 auto && default_variable_value = getDefaultArrayValue(var_name);
468 return *default_variable_value->data();
478 "optional var index for " << var_name <<
" does not exist!");
491 return var->number();
500 Coupleable::coupledGenericValue<false>(
const std::string & var_name,
unsigned int comp)
const 502 return coupledValue(var_name, comp);
507 Coupleable::coupledGenericValue<true>(
const std::string & var_name,
unsigned int comp)
const 509 return adCoupledValue(var_name, comp);
514 Coupleable::coupledGenericVectorValue<false>(
const std::string & var_name,
unsigned int comp)
const 516 return coupledVectorValue(var_name, comp);
521 Coupleable::coupledGenericVectorValue<true>(
const std::string & var_name,
unsigned int comp)
const 523 return adCoupledVectorValue(var_name, comp);
529 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
544 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
546 return (
_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
550 template <
typename T>
554 const unsigned int index)
const 556 const auto *
const var = getVarHelper<MooseVariableField<T>>(var_names, index);
558 mooseError(var_names,
": invalid variable name for coupledVectorTagValue");
562 mooseError(
"Attempting to couple to vector tag with ID ",
566 ", but a vector tag with that ID does not exist");
571 return var->nodalVectorTagValue(tag);
573 return var->vectorTagValue(tag);
576 template <
typename T>
579 const TagName & tag_name,
580 const unsigned int comp)
585 mooseError(var_name,
": invalid variable name for tag coupling");
587 auto & var_sys = var->sys();
589 var_sys.needSolutionState(1);
591 var_sys.needSolutionState(2);
594 template <
typename T>
597 const std::string & tag_param_name,
598 const unsigned int index)
const 601 mooseError(
"Tag name parameter '", tag_param_name,
"' is invalid");
608 const_cast<Coupleable *
>(
this)->requestStates<T>(var_names, tag_name, index);
611 mooseError(
"Tagged vector with tag name '", tag_name,
"' does not exist");
614 return vectorTagValueHelper<T>(var_names, tag, index);
619 Coupleable::coupledGenericDofValue<false>(
const std::string & var_name,
unsigned int comp)
const 621 return coupledDofValues(var_name, comp);
626 Coupleable::coupledGenericDofValue<true>(
const std::string & var_name,
unsigned int comp)
const 628 return adCoupledDofValues(var_name, comp);
634 const auto * var =
getVar(var_name, comp);
640 mooseError(
_c_name,
":coupledValueLower cannot be called in a coupleable neighbor object");
651 unsigned int index)
const 653 return vectorTagValueHelper<Real>(var_names, tag, index);
658 const std::string & tag_name,
659 unsigned int index)
const 661 return vectorTagValueHelper<Real>(var_names, tag_name, index);
667 unsigned int index)
const 669 return vectorTagValueHelper<RealEigenVector>(var_names, tag, index);
674 const std::string & tag_name,
675 unsigned int index)
const 677 return vectorTagValueHelper<RealEigenVector>(var_names, tag_name, index);
683 unsigned int index)
const 685 const auto * var =
getVar(var_names, index);
687 mooseError(var_names,
": invalid variable name for coupledVectorTagGradient");
691 mooseError(
"Attempting to couple to vector tag with ID ",
695 ", but a vector tag with that ID does not exist");
699 return var->vectorTagGradient(tag);
704 const std::string & tag_name,
705 unsigned int index)
const 708 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
712 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
721 unsigned int index)
const 725 mooseError(var_names,
": invalid variable name for coupledVectorTagArrayGradient");
729 mooseError(
"Attempting to couple to vector tag with ID ",
733 ", but a vector tag with that ID does not exist");
737 return var->vectorTagGradient(tag);
742 const std::string & tag_name,
743 unsigned int index)
const 746 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
750 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
756 template <
typename T>
760 const unsigned int comp)
const 762 const auto * var = getVarHelper<MooseVariableField<T>>(var_name, comp);
764 mooseError(var_name,
": invalid variable name for coupledVectorTagDofValue");
769 return var->vectorTagDofValue(tag);
772 template <
typename T>
775 const std::string & tag_param_name,
776 const unsigned int comp)
const 779 mooseError(
"Tag name parameter '", tag_param_name,
"' is invalid");
786 const_cast<Coupleable *
>(
this)->requestStates<T>(var_name, tag_name, comp);
789 mooseError(
"Tagged vector with tag name '", tag_name,
"' does not exist");
793 return vectorTagDofValueHelper<T>(var_name, tag, comp);
799 unsigned int comp)
const 801 return vectorTagDofValueHelper<Real>(var_name, tag, comp);
806 const std::string & tag_name,
807 unsigned int comp)
const 809 return vectorTagDofValueHelper<Real>(var_name, tag_name, comp);
814 const std::string & tag_name,
815 unsigned int comp)
const 817 return vectorTagDofValueHelper<RealEigenVector>(var_name, tag_name, comp);
823 unsigned int index)
const 825 const auto * var = getVarHelper<MooseVariableField<Real>>(var_names, index);
827 mooseError(var_names,
": invalid variable name for coupledMatrixTagValue");
833 return var->nodalMatrixTagValue(tag);
834 return var->matrixTagValue(tag);
839 const std::string & tag_name,
840 unsigned int index)
const 843 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
847 mooseError(
"Matrix tag name '", tagname,
"' does not exist");
864 return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
872 return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
874 return _c_is_implicit ? var->slnNeighbor() : var->slnOldNeighbor();
895 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
896 return (
_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
900 std::vector<const ArrayVariableValue *>
903 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledArrayValue(var_name, comp); };
904 return coupledVectorHelper<const ArrayVariableValue *>(var_name, func);
910 auto * var = getVarHelper<MooseWritableVariable>(var_name, comp);
912 const auto * aux =
dynamic_cast<const AuxKernel *
>(
this);
918 if (!aux && !euo && !nuo && !nfc && !nec)
919 mooseError(
"writableVariable() can only be called from AuxKernels, ElementUserObjects, " 920 "NodalUserObjects, NodeFaceConstraints, or NodeElemConstraints. '",
922 "' is none of those.");
924 if (aux && !aux->isNodal() && var->isNodal())
927 "' cannot obtain a writable reference to the nodal variable '",
930 if (euo && var->isNodal())
933 "' cannot obtain a writable reference to the nodal variable '",
946 mooseDeprecated(
"Coupleable::writableCoupledValue is deprecated, please use " 947 "Coupleable::writableVariable instead. ");
950 auto *
const var =
getVar(var_name, comp);
953 "Unable to create a writable reference for '", var_name,
"', is it a constant expression?");
958 "'", var->name(),
"' must be an auxiliary variable in Coupleable::writableCoupledValue");
961 const auto * aux =
dynamic_cast<const AuxKernel *
>(
this);
964 mooseError(
"writableCoupledValue() can only be called from AuxKernels, but '",
966 "' is not an AuxKernel.");
968 if (!aux->isNodal() && var->isNodal())
971 "' cannot obtain a writable reference to the nodal variable '",
988 if (br && !var->
hasBlocks(br->blockIDs()))
991 "' must be defined on all blocks '",
995 if (nfc && !var->
hasBlocks(nfc->getSecondaryConnectedBlocks()))
998 " must be defined on all blocks '",
1000 "'s secondary surface is defined on.");
1004 if (ci !=
this && ci->_writable_coupled_variables[
_c_tid].count(var))
1009 if (br && br_other && br->blockRestricted() && br_other->blockRestricted() &&
1017 "' already obtained a writable reference to '",
1019 "'. Only one object can obtain such a reference per variable and subdomain in a " 1033 const auto * var =
getVar(var_name, comp);
1041 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1047 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1048 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1055 const auto * var =
getVar(var_name, comp);
1063 return var->dofValuesOlder();
1064 return var->slnOlder();
1069 return var->dofValuesOlderNeighbor();
1070 return var->slnOlderNeighbor();
1077 const auto * var =
getVar(var_name, comp);
1086 return var->dofValuesPreviousNL();
1087 return var->slnPreviousNL();
1092 return var->dofValuesPreviousNLNeighbor();
1093 return var->slnPreviousNLNeighbor();
1106 return (
_c_is_implicit) ? var->nodalValueOldArray() : var->nodalValueOlderArray();
1109 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1121 return var->slnOlder();
1122 return var->slnOlderNeighbor();
1136 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1142 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1143 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1158 return var->dofValuesOlder();
1159 return var->slnOlder();
1164 return var->dofValuesOlderNeighbor();
1165 return var->slnOlderNeighbor();
1172 const auto * var =
getVar(var_name, comp);
1183 return var->dofValuesDot();
1189 return var->dofValuesDotNeighbor();
1190 return var->uDotNeighbor();
1197 const auto * var =
getVar(var_name, comp);
1208 return var->dofValuesDotDot();
1209 return var->uDotDot();
1214 return var->dofValuesDotDotNeighbor();
1215 return var->uDotDotNeighbor();
1221 Coupleable::coupledGenericDotDot<false>(
const std::string & var_name,
unsigned int comp)
const 1223 return coupledDotDot(var_name, comp);
1228 Coupleable::coupledGenericDotDot<true>(
const std::string & var_name,
unsigned int comp)
const 1230 return adCoupledDotDot(var_name, comp);
1236 const auto * var =
getVar(var_name, comp);
1247 return var->dofValuesDotOld();
1248 return var->uDotOld();
1253 return var->dofValuesDotOldNeighbor();
1254 return var->uDotOldNeighbor();
1261 const auto * var =
getVar(var_name, comp);
1272 return var->dofValuesDotDotOld();
1273 return var->uDotDotOld();
1278 return var->dofValuesDotDotOldNeighbor();
1279 return var->uDotDotOldNeighbor();
1296 return var->uDotNeighbor();
1311 return var->uDotDot();
1312 return var->uDotDotNeighbor();
1327 return var->uDotOld();
1328 return var->uDotOldNeighbor();
1343 return var->uDotDotOld();
1344 return var->uDotDotOldNeighbor();
1359 return var->duDotDu();
1360 return var->duDotDuNeighbor();
1375 return var->duDotDotDu();
1376 return var->duDotDotDuNeighbor();
1390 return var->dofValuesDot();
1396 return var->dofValuesDotNeighbor();
1397 return var->uDotNeighbor();
1412 return var->dofValuesDotDot();
1413 return var->uDotDot();
1418 return var->dofValuesDotDotNeighbor();
1419 return var->uDotDotNeighbor();
1434 return var->dofValuesDotOld();
1435 return var->uDotOld();
1440 return var->dofValuesDotOldNeighbor();
1441 return var->uDotOldNeighbor();
1456 return var->dofValuesDotDotOld();
1457 return var->uDotDotOld();
1462 return var->dofValuesDotDotOldNeighbor();
1463 return var->uDotDotOldNeighbor();
1470 const auto * var =
getVar(var_name, comp);
1481 return var->dofValuesDuDotDu();
1482 return var->duDotDu();
1487 return var->dofValuesDuDotDuNeighbor();
1488 return var->duDotDuNeighbor();
1495 const auto * var =
getVar(var_name, comp);
1506 return var->dofValuesDuDotDotDu();
1507 return var->duDotDotDu();
1512 return var->dofValuesDuDotDotDuNeighbor();
1513 return var->duDotDotDuNeighbor();
1520 const auto *
const var =
getArrayVar(var_name, comp);
1531 return var->dofValuesDuDotDu();
1532 return var->duDotDu();
1537 return var->dofValuesDuDotDuNeighbor();
1538 return var->duDotDuNeighbor();
1545 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
1555 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1561 const auto * var =
getVar(var_name, comp);
1570 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1571 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1577 const auto * var =
getVar(var_name, comp);
1586 return var->gradSlnOlder();
1587 return var->gradSlnOlderNeighbor();
1593 const auto * var =
getVar(var_name, comp);
1603 return var->gradSlnPreviousNL();
1604 return var->gradSlnPreviousNLNeighbor();
1610 const auto * var =
getVar(var_name, comp);
1619 return var->gradSlnDot();
1620 return var->gradSlnNeighborDot();
1626 const auto * var =
getVar(var_name, comp);
1635 return var->gradSlnDotDot();
1636 return var->gradSlnNeighborDotDot();
1652 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1667 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1668 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1683 return var->gradSlnOlder();
1684 return var->gradSlnOlderNeighbor();
1697 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1709 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1710 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1722 return var->gradSlnOlder();
1723 return var->gradSlnOlderNeighbor();
1729 const auto *
const var =
getArrayVar(var_name, comp);
1735 return var->gradSlnDot();
1736 return var->gradSlnNeighborDot();
1752 return (
_c_is_implicit) ? var->curlSlnNeighbor() : var->curlSlnOldNeighbor();
1767 return (
_c_is_implicit) ? var->curlSlnOld() : var->curlSlnOlder();
1768 return (
_c_is_implicit) ? var->curlSlnOldNeighbor() : var->curlSlnOlderNeighbor();
1783 return var->curlSlnOlder();
1784 return var->curlSlnOlderNeighbor();
1800 return var->adCurlSln();
1801 return var->adCurlSlnNeighbor();
1817 return (
_c_is_implicit) ? var->divSlnNeighbor() : var->divSlnOldNeighbor();
1833 return (
_c_is_implicit) ? var->divSlnOldNeighbor() : var->divSlnOlderNeighbor();
1848 return var->divSlnOlder();
1849 return var->divSlnOlderNeighbor();
1855 const auto * var =
getVar(var_name, comp);
1864 return (
_c_is_implicit) ? var->secondSln() : var->secondSlnOlder();
1865 return (
_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOlderNeighbor();
1871 const auto * var =
getVar(var_name, comp);
1880 return (
_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder();
1881 return (
_c_is_implicit) ? var->secondSlnOldNeighbor() : var->secondSlnOlderNeighbor();
1887 const auto * var =
getVar(var_name, comp);
1896 return var->secondSlnOlder();
1897 return var->secondSlnOlderNeighbor();
1903 const auto * var =
getVar(var_name, comp);
1913 return var->secondSlnPreviousNL();
1914 return var->secondSlnPreviousNLNeighbor();
1917 template <
typename T>
1921 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1923 return getDefaultNodalValue<T>(var_name, comp);
1926 if (!var->isNodal())
1928 ": Trying to get nodal values of variable '",
1930 "', but it is not nodal.");
1933 return (
_c_is_implicit) ? var->nodalValue() : var->nodalValueOld();
1934 return (
_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor();
1937 template <
typename T>
1941 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1943 return getDefaultNodalValue<T>(var_name, comp);
1946 if (!var->isNodal())
1948 ": Trying to get old nodal values of variable '",
1950 "', but it is not nodal.");
1953 return (
_c_is_implicit) ? var->nodalValueOld() : var->nodalValueOlder();
1954 return (
_c_is_implicit) ? var->nodalValueOldNeighbor() : var->nodalValueOlderNeighbor();
1957 template <
typename T>
1961 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1963 return getDefaultNodalValue<T>(var_name, comp);
1966 if (!var->isNodal())
1968 ": Trying to get older nodal values of variable '",
1970 "', but it is not nodal.");
1973 return var->nodalValueOlder();
1974 return var->nodalValueOlderNeighbor();
1977 template <
typename T>
1981 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1983 return getDefaultNodalValue<T>(var_name, comp);
1989 return var->nodalValuePreviousNL();
1990 return var->nodalValuePreviousNLNeighbor();
1993 template <
typename T>
1997 static const T
zero = 0;
1998 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2004 return var->nodalValueDot();
2005 mooseError(
"Neighbor version not implemented");
2011 const auto * var =
getVar(var_name, comp);
2020 return var->dofValuesDotDot();
2021 return var->dofValuesDotDotNeighbor();
2027 const auto * var =
getVar(var_name, comp);
2036 return var->dofValuesDotOld();
2037 return var->dofValuesDotOldNeighbor();
2043 const auto * var =
getVar(var_name, comp);
2052 return var->dofValuesDotDotOld();
2053 return var->dofValuesDotDotOldNeighbor();
2059 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2065 return (
_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
2066 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
2069 std::vector<const VariableValue *>
2072 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDofValues(var_name, comp); };
2073 return coupledVectorHelper<const VariableValue *>(var_name, func);
2079 const auto * var =
getVar(var_name, comp);
2085 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
2086 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
2089 std::vector<const VariableValue *>
2092 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDofValuesOld(var_name, comp); };
2093 return coupledVectorHelper<const VariableValue *>(var_name, func);
2099 const auto * var =
getVar(var_name, comp);
2105 return var->dofValuesOlder();
2106 return var->dofValuesOlderNeighbor();
2109 std::vector<const VariableValue *>
2112 auto func = [
this, &var_name](
unsigned int comp)
2114 return coupledVectorHelper<const VariableValue *>(var_name, func);
2126 return (
_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
2127 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
2133 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2143 return var->adDofValues();
2144 return var->adDofValuesNeighbor();
2154 "\" on variable \"",
2156 "\" when using a \"Steady\" executioner is not allowed. This value is available " 2157 "only in transient simulations.");
2160 template <
typename T>
2169 mooseError(
"The adCoupledNodalValue method should only be called for nodal computing objects");
2172 "The adCoupledNodalValue method shouldn't be called for neighbor computing objects. I " 2173 "don't even know what that would mean, although maybe someone could explain it to me.");
2175 mooseError(
"If you're going to use an explicit scheme, then use coupledNodalValue instead of " 2176 "adCoupledNodalValue");
2178 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2180 return var->adNodalValue();
2186 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2196 return var->adDofValues();
2199 return var->adSln();
2200 return var->adSlnNeighbor();
2206 auto var = getVarHelper<MooseVariableFE<Real>>(var_name, comp);
2213 mooseError(
"adCoupledLowerValue cannot be called in a coupleable neighbor object");
2216 return var->adDofValues();
2218 return var->adSlnLower();
2224 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2234 return var->adGradSln();
2235 return var->adGradSlnNeighbor();
2241 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2251 return var->adGradSlnDot();
2252 return var->adGradSlnNeighborDot();
2258 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2268 return var->adSecondSln();
2270 return var->adSecondSlnNeighbor();
2276 mooseError(
"Automatic differentiation using second derivatives of vector variables is not " 2283 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2292 return var->adDofValuesDot();
2293 return var->adUDot();
2298 mooseError(
"AD neighbor nodal dof dot not implemented");
2299 return var->adUDotNeighbor();
2306 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2316 return var->adUDotDot();
2317 return var->adUDotDotNeighbor();
2332 return var->adUDot();
2333 return var->adUDotNeighbor();
2350 return var->adSln();
2351 return var->adSlnNeighbor();
2366 return var->adGradSln();
2367 return var->adGradSlnNeighbor();
2381 return default_value_it->second.get();
2398 return default_value_it->second.get();
2432 mooseDeprecated(
"Method adZeroValue() is deprecated. Use '_ad_zero' instead.");
2439 mooseDeprecated(
"Method adZeroGradient() is deprecated. Use '_ad_grad_zero' instead.");
2446 mooseDeprecated(
"Method adZeroSecond() is deprecated. Use '_ad_second_zero' instead.");
2452 Coupleable::genericZeroValue<false>()
2459 Coupleable::genericZeroValue<true>()
2466 Coupleable::genericZeroGradient<false>()
2473 Coupleable::genericZeroGradient<true>()
2475 return _ad_grad_zero;
2480 Coupleable::genericZeroSecond<false>()
2482 return _second_zero;
2487 Coupleable::genericZeroSecond<true>()
2489 return _ad_second_zero;
2494 Coupleable::coupledGenericGradient<false>(
const std::string & var_name,
unsigned int comp)
const 2496 return coupledGradient(var_name, comp);
2501 Coupleable::coupledGenericGradient<true>(
const std::string & var_name,
unsigned int comp)
const 2503 return adCoupledGradient(var_name, comp);
2506 std::vector<unsigned int>
2509 auto func = [
this, &var_name](
unsigned int comp) {
return coupled(var_name, comp); };
2510 return coupledVectorHelper<unsigned int>(var_name, func);
2521 ": a variable name was queried but a constant was passed for parameter '",
2523 "Either pass a true variable or contact a developer to shield the call to " 2524 "'coupledName' with 'isCoupledConstant'");
2527 _c_name,
": Variable '", var_name,
"' does not exist, yet its coupled name is requested");
2530 std::vector<VariableName>
2533 auto func = [
this, &var_name](
unsigned int comp) {
return coupledName(var_name, comp); };
2534 return coupledVectorHelper<VariableName>(var_name, func);
2537 std::vector<const VariableValue *>
2540 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValue(var_name, comp); };
2541 return coupledVectorHelper<const VariableValue *>(var_name, func);
2544 std::vector<const VectorVariableValue *>
2547 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledVectorValue(var_name, comp); };
2548 return coupledVectorHelper<const VectorVariableValue *>(var_name, func);
2552 std::vector<const GenericVariableValue<false> *>
2553 Coupleable::coupledGenericValues<false>(
const std::string & var_name)
const 2555 return coupledValues(var_name);
2559 std::vector<const GenericVariableValue<true> *>
2560 Coupleable::coupledGenericValues<true>(
const std::string & var_name)
const 2562 return adCoupledValues(var_name);
2565 std::vector<const ADVariableValue *>
2568 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledValue(var_name, comp); };
2569 return coupledVectorHelper<const ADVariableValue *>(var_name, func);
2572 std::vector<const ADVectorVariableValue *>
2575 auto func = [
this, &var_name](
unsigned int comp)
2577 return coupledVectorHelper<const ADVectorVariableValue *>(var_name, func);
2580 std::vector<const VariableValue *>
2583 auto func = [
this, &var_names, &tag](
unsigned int comp)
2585 return coupledVectorHelper<const VariableValue *>(var_names, func);
2588 std::vector<const VariableValue *>
2590 const std::string & tag_name)
const 2593 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2597 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2603 std::vector<const ArrayVariableValue *>
2606 auto func = [
this, &var_names, &tag](
unsigned int index)
2608 return coupledVectorHelper<const ArrayVariableValue *>(var_names, func);
2611 std::vector<const ArrayVariableValue *>
2613 const std::string & tag_name)
const 2616 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2620 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2626 std::vector<const VariableGradient *>
2629 auto func = [
this, &var_names, &tag](
unsigned int index)
2631 return coupledVectorHelper<const VariableGradient *>(var_names, func);
2634 std::vector<const VariableGradient *>
2636 const std::string & tag_name)
const 2639 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2643 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2649 std::vector<const ArrayVariableGradient *>
2652 auto func = [
this, &var_names, &tag](
unsigned int index)
2654 return coupledVectorHelper<const ArrayVariableGradient *>(var_names, func);
2657 std::vector<const ArrayVariableGradient *>
2659 const std::string & tag_name)
const 2662 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2666 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2672 std::vector<const VariableValue *>
2675 auto func = [
this, &var_names, &tag](
unsigned int comp)
2677 return coupledVectorHelper<const VariableValue *>(var_names, func);
2680 std::vector<const VariableValue *>
2682 const std::string & tag_name)
const 2685 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2689 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2695 std::vector<const VariableValue *>
2698 auto func = [
this, &var_names, &tag](
unsigned int comp)
2700 return coupledVectorHelper<const VariableValue *>(var_names, func);
2703 std::vector<const VariableValue *>
2705 const std::string & tag_name)
const 2708 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2712 mooseError(
"Matrix tag name '", tagname,
"' does not exist");
2718 std::vector<const VariableValue *>
2721 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValueOld(var_name, comp); };
2722 return coupledVectorHelper<const VariableValue *>(var_name, func);
2725 std::vector<const VariableValue *>
2728 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValueOlder(var_name, comp); };
2729 return coupledVectorHelper<const VariableValue *>(var_name, func);
2732 std::vector<const VectorVariableValue *>
2735 auto func = [
this, &var_name](
unsigned int comp)
2737 return coupledVectorHelper<const VectorVariableValue *>(var_name, func);
2740 std::vector<const VariableGradient *>
2743 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledGradient(var_name, comp); };
2744 return coupledVectorHelper<const VariableGradient *>(var_name, func);
2748 std::vector<const GenericVariableGradient<false> *>
2749 Coupleable::coupledGenericGradients<false>(
const std::string & var_name)
const 2751 return coupledGradients(var_name);
2755 std::vector<const GenericVariableGradient<true> *>
2756 Coupleable::coupledGenericGradients<true>(
const std::string & var_name)
const 2758 auto func = [
this, &var_name](
unsigned int comp) {
return &adCoupledGradient(var_name, comp); };
2759 return coupledVectorHelper<const GenericVariableGradient<true> *>(var_name, func);
2762 std::vector<const ADVariableGradient *>
2765 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledGradient(var_name, comp); };
2766 return coupledVectorHelper<const ADVariableGradient *>(var_name, func);
2769 std::vector<const VariableGradient *>
2772 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledGradientOld(var_name, comp); };
2773 return coupledVectorHelper<const VariableGradient *>(var_name, func);
2776 std::vector<const VariableValue *>
2779 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDot(var_name, comp); };
2780 return coupledVectorHelper<const VariableValue *>(var_name, func);
2783 std::vector<const ADVariableValue *>
2786 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledDot(var_name, comp); };
2787 return coupledVectorHelper<const ADVariableValue *>(var_name, func);
2792 Coupleable::coupledGenericDot<false>(
const std::string & var_name,
unsigned int comp)
const 2794 return coupledDot(var_name, comp);
2799 Coupleable::coupledGenericDot<true>(
const std::string & var_name,
unsigned int comp)
const 2801 return adCoupledDot(var_name, comp);
2806 template const Real & Coupleable::getDefaultNodalValue<Real>(
const std::string & var_name,
2807 unsigned int comp)
const;
2809 template const Real & Coupleable::coupledNodalValue<Real>(
const std::string & var_name,
2810 unsigned int comp)
const;
2811 template const ADReal & Coupleable::adCoupledNodalValue<Real>(
const std::string & var_name,
2812 unsigned int comp)
const;
2814 Coupleable::adCoupledNodalValue<RealVectorValue>(
const std::string & var_name,
2815 unsigned int comp)
const;
2818 Coupleable::coupledNodalValue<RealVectorValue>(
const std::string & var_name,
2819 unsigned int comp)
const;
2820 template const Real & Coupleable::coupledNodalValueOld<Real>(
const std::string & var_name,
2821 unsigned int comp)
const;
2823 Coupleable::coupledNodalValueOld<RealVectorValue>(
const std::string & var_name,
2824 unsigned int comp)
const;
2825 template const Real & Coupleable::coupledNodalValueOlder<Real>(
const std::string & var_name,
2826 unsigned int comp)
const;
2828 Coupleable::coupledNodalValueOlder<RealVectorValue>(
const std::string & var_name,
2829 unsigned int comp)
const;
2830 template const Real & Coupleable::coupledNodalValuePreviousNL<Real>(
const std::string & var_name,
2831 unsigned int comp)
const;
2833 Coupleable::coupledNodalValuePreviousNL<RealVectorValue>(
const std::string & var_name,
2834 unsigned int comp)
const;
2835 template const Real & Coupleable::coupledNodalDot<Real>(
const std::string & var_name,
2836 unsigned int comp)
const;
2838 Coupleable::coupledNodalDot<RealVectorValue>(
const std::string & var_name,
unsigned int comp)
const;
virtual const ArrayVariableValue & coupledArrayDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled array variable.
std::string name(const ElemQuality q)
virtual const VariableValue & coupledDofValues(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the current solution vector of a coupled variable for the local element.
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.
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.
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.
OutputTools< Real >::VariableGradient VariableGradient
const T & coupledNodalDot(const std::string &var_name, unsigned int comp=0) const
Nodal values of time derivative of a coupled variable.
virtual TagID getVectorTagID(const TagName &tag_name) const
Get a TagID from a TagName.
OutputTools< RealVectorValue >::VariableDivergence VectorVariableDivergence
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...
virtual bool isCoupled(const std::string &var_name, unsigned int i=0) const
Returns true if a variables has been coupled as name.
virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid, const std::string &var_name)=0
Returns the scalar variable reference from whichever system contains it.
virtual const VectorVariableGradient & coupledVectorGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled vector variable.
bool _c_nodal
True if we provide coupling to nodal values.
void checkFuncType(const std::string var_name, VarType t, FuncAge age) const
VectorVariableCurl _default_vector_curl
This will always be zero because the default values for optionally coupled variables is always consta...
Moose::GenericType< VectorVariableValue, is_ad > GenericVectorVariableValue
VectorMooseVariable * getVectorVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled vector variable.
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 VectorVariableValue & coupledVectorDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled vector variable.
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.
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 ArrayVariableValue * getDefaultArrayValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for an uncoupled array variable...
std::vector< const VariableValue * > coupledValuesOlder(const std::string &var_name) const
Returns the older values for all of a coupled variable's components.
const ADVariableSecond & adZeroSecond() const
Retrieve a zero second for automatic differentiation.
const ADVectorVariableValue * getADDefaultVectorValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default vector value for Automatic Differentiat...
virtual const VariableSecond & coupledSecond(const std::string &var_name, unsigned int comp=0) const
Returns second spatial derivatives of a coupled variable.
virtual bool isCoupledConstant(const std::string &var_name) const
Returns true if a variable passed as a coupled value is really a constant.
virtual const VariableValue & coupledDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled variable.
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.
std::vector< const ArrayVariableValue * > coupledArrayValues(const std::string &var_name) const
Returns the values for all of a coupled array variable's components.
std::vector< const VariableValue * > coupledDots(const std::string &var_name) const
Returns the time derivatives for all of a coupled variable's components.
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.
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 ...
VariableName coupledName(const std::string &var_name, unsigned int comp=0) const
Names of the variable in the Coupleable interface.
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.
std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > > _coupled_vars
Coupled vars whose values we provide.
const MooseArray< ADRealVectorValue > & _ad_grad_zero
virtual const VectorVariableValue & coupledVectorDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled vector variable.
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.
void checkWritableVar(MooseWritableVariable *var)
Checks that the passed in variable is only accessed writable by one object in a given subdomain...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
const bool _is_fv
Whether the MooseObject is a finite volume object.
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.
const TagName OLDER_SOLUTION_TAG
std::vector< ArrayMooseVariable * > _coupled_array_moose_vars
Vector of array coupled variables.
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...
std::vector< const VectorVariableValue * > coupledVectorValuesOld(const std::string &var_name) const
Returns the old values for all of a coupled vector variable's components.
constexpr std::size_t constMaxQpsPerElem
This is used for places where we initialize some qp-sized data structures that would end up being siz...
const T & coupledNodalValue(const std::string &var_name, unsigned int comp=0) const
Returns nodal values of a coupled variable.
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
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.
OutputTools< RealVectorValue >::VariableValue VectorVariableValue
const ADVariableGradient & adCoupledGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable for use in Automatic Differentiation.
VectorVariableDivergence _default_div
This will always be zero because the default values for optionally coupled variables is always consta...
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
const bool _c_allow_element_to_nodal_coupling
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.
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 VariableGradient * > coupledVectorTagGradients(const std::string &var_names, TagID tag) const
Returns gradients for all the coupled variables desired for a given tag.
MooseArray< ADRealVectorValue > _ad_default_curl
This will always be zero because the default values for optionally coupled vector variables is always...
bool setsIntersect(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2)
This method detects whether two sets intersect without building a result set.
virtual const VariableValue & coupledDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled variable.
THREAD_ID _c_tid
Thread ID of the thread using this object.
const ADVariableValue & adCoupledValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled variable for use in 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.
const ADVariableGradient & getADDefaultGradient() const
Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation ...
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
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...
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...
virtual const VariableGradient & coupledGradientDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of the gradient of a coupled variable.
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
std::unordered_map< std::string, std::vector< MooseVariableScalar * > > _c_coupled_scalar_vars
Scalar variables coupled into this object (for error checking)
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
const ADVectorVariableCurl & getADDefaultCurl() const
Helper method to return (and insert if necessary) the default curl value for Automatic Differentiatio...
OutputTools< RealVectorValue >::VariableCurl VectorVariableCurl
virtual const ArrayVariableValue & coupledArrayDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled array variable.
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.
This class provides an interface for common operations on field variables of both FE and FV types wit...
virtual const ArrayVariableValue & coupledArrayDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled array variable.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
virtual const VariableValue & coupledMatrixTagValue(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns value of a coupled variable for a given tag.
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...
const ADVariableGradient & adZeroGradient() const
method that returns _grad_zero to RESIDUAL computing objects and _ad_grad_zero to JACOBIAN computing ...
MooseWritableVariable & writableVariable(const std::string &var_name, unsigned int comp=0)
Returns a writable MooseVariable object for a nodal or elemental variable.
Base class for a system (of equations)
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< VectorVariableValue > > _default_vector_value
Will hold the default value for optional vector coupled variables.
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...
DualNumber< Real, DNDerivativeType, true > ADReal
std::vector< VariableName > coupledNames(const std::string &var_name) const
Names of the variables in the Coupleable interface.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
virtual const VariableGradient & coupledGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable.
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
const T & coupledNodalValuePreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns nodal values of a coupled variable for previous Newton iterate.
auto max(const L &left, const R &right)
std::vector< const ADVariableValue * > adCoupledValues(const std::string &var_name) const
Returns the values for all of a coupled variable's components for use in Automatic Differentiation...
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.
std::vector< MooseVariable * > _coupled_standard_moose_vars
Vector of standard coupled variables.
const ADVariableValue & adCoupledDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled variable for ad simulations.
const SystemBase *const _c_sys
Pointer to the system object if the moose object this is an interface for has one.
FEProblemBase & _c_fe_problem
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.
std::string toUpper(std::string name)
Convert supplied string to upper case.
virtual const VariableSecond & coupledSecondOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old second derivative from two time steps previous of a coupled variable.
A user object that runs over all the nodes and does an aggregation step to compute a single value...
const OutputTools< T >::VariableValue & vectorTagDofValueHelper(const std::string &var_name, TagID tag, unsigned int comp=0) const
Generic helper method to get vector tag degree of freedom values based on tag ID. ...
bool _c_is_implicit
True if implicit value is required.
virtual const VariableValue & coupledValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled variable.
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.
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.
std::vector< VectorMooseVariable * > _coupled_vector_moose_vars
Vector of vector coupled variables.
const std::string & name() const
Get the name of the class.
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 const VariableValue & coupledValueLower(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled lower-dimensional variable.
Coupleable(const MooseObject *moose_object, bool nodal, bool is_fv=false)
Constructing the object.
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.
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.
OutputTools< RealEigenVector >::VariableValue ArrayVariableValue
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
virtual const VariableValue & coupledVectorDotDu(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled vector variable with respect to the coefficients.
void addFEVariableCoupleableVectorTag(TagID tag)
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.
Moose::GenericType< VariableValue, is_ad > GenericVariableValue
const TagName OLD_SOLUTION_TAG
Every object that can be built by the factory should be derived from this class.
virtual TagID getMatrixTagID(const TagName &tag_name) const
Get a TagID from a TagName.
Moose::GenericType< VariableGradient, is_ad > GenericVariableGradient
virtual const ArrayVariableValue & coupledArrayValue(const std::string &var_name, unsigned int comp=0) const
Returns value 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.
std::vector< const VariableGradient * > coupledGradientsOld(const std::string &var_name) const
Returns the old gradients for all of a coupled variable's components.
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.
A NodeFaceConstraint is used when you need to create constraints between two surfaces in a mesh...
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
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.
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...
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.
void needsPreviousNewtonIteration(bool state)
Set a flag that indicated that user required values for the previous Newton iterate.
virtual const VariableGradient & coupledGradientDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of the gradient of a coupled variable.
virtual bool hasScalarVariable(const std::string &var_name) const =0
Returns a Boolean indicating whether any system contains a variable with the name provided...
const ADVariableValue * getADDefaultValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for Automatic Differentiation for...
const ADVariableValue & adCoupledDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled variable for ad simulations.
const std::string & _c_name
The name of the object this interface is part of.
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 ADVariableValue & adCoupledDofValues(const std::string &var_name, unsigned int comp=0) const
Returns DOF value of a coupled variable for use in Automatic Differentiation.
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
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.
unsigned int number() const
Gets the number of this system.
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...
std::vector< const VariableGradient * > coupledGradients(const std::string &var_name) const
Returns the gradients for all of a coupled variable's components.
virtual const MooseVariableFieldBase & getVariable(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const =0
Returns the variable reference for requested variable which must be of the expected_var_type (Nonline...
std::vector< const VariableValue * > coupledAllDofValuesOlder(const std::string &var_name) const
Returns DoFs in the older solution vector of all of a coupled variable's components for the local ele...
AuxiliarySystem & getAuxiliarySystem()
const ADVectorVariableValue & adCoupledVectorDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a vector coupled variable for ad simulations.
virtual bool hasVariable(const std::string &var_name) const =0
Whether or not this problem has the variable.
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
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.
const ADVectorVariableGradient & getADDefaultVectorGradient() const
Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation ...
const ADVariableValue & adZeroValue() const
method that returns _zero to RESIDUAL computing objects and _ad_zero to JACOBIAN computing objects ...
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.
const MooseObject *const _obj
VectorVariableGradient _default_vector_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
std::vector< MooseVariableFieldBase * > _coupled_moose_vars
Vector of all coupled variables.
virtual const VectorVariableCurl & coupledCurl(const std::string &var_name, unsigned int comp=0) const
Returns curl of a coupled variable.
OutputTools< Real >::VariableValue VariableValue
virtual const ArrayVariableGradient & coupledArrayGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled array variable.
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.
unsigned int coupledComponents(const std::string &var_name) const
Number of coupled components.
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 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 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.
void checkComponent(const MooseObject *obj, unsigned int comp, unsigned int bound, const std::string &var_name)
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...
Interface for objects that needs coupling capabilities.
std::vector< MooseVariableField< Real > * > _coupled_fv_moose_vars
Vector of all finite volume coupled variables.
std::vector< const VariableValue * > coupledValues(const std::string &var_name) const
Returns the values for all of a coupled variable components.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::vector< const ArrayVariableGradient * > coupledVectorTagArrayGradients(const std::string &var_names, TagID tag) const
Returns gradients for all the coupled variables desired for a given tag.
const T & getDefaultNodalValue(const std::string &var_name, unsigned int comp=0) const
Get nodal default value.
Generic class for solving transient nonlinear problems.
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.
const MooseArray< ADRealTensorValue > & _ad_second_zero
VectorVariableValue _default_vector_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
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 & coupledValuePreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns value of previous Newton iterate of a coupled variable.
bool hasBlocks(const SubdomainID id) const override
Returns whether the functor is defined on this block.
MooseArray< ADRealTensorValue > _ad_default_vector_gradient
This will always be zero because the default values for optionally coupled vector variables is always...
virtual const VectorVariableValue & coupledVectorValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled vector variable.
virtual const VariableValue & coupledDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled variable.
MooseArray< ADRealTensorValue > _ad_default_second
This will always be zero because the default values for optionally coupled variables is always consta...
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.
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.
ArrayMooseVariable * getArrayVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled array variable.
virtual const ArrayVariableValue & coupledArrayDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled array variable.
An interface that restricts an object to subdomains via the 'blocks' input parameter.
Class for scalar variables (they are different).
IntRange< T > make_range(T beg, T end)
void resize(unsigned int size)
Change the number of elements the array can store.
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.
std::unordered_map< std::string, std::vector< unsigned int > > _optional_var_index
Unique indices for optionally coupled vars that weren't provided.
const MooseVariableFieldBase * getFEVar(const std::string &var_name, unsigned int comp) const
Deprecated method.
std::unordered_map< std::string, std::vector< std::unique_ptr< VariableValue > > > _default_value
Will hold the default value for optional coupled variables.
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...
Moose::GenericType< VariableSecond, is_ad > GenericVariableSecond
const InputParameters & _c_parameters
OutputTools< Real >::VariableSecond VariableSecond
const MooseArray< ADReal > & _ad_zero
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
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.
const std::vector< T * > & getInterfaceObjects() const
Gets the registered interface objects for a given interface.
const Moose::ADType< T >::type & adCoupledNodalValue(const std::string &var_name, unsigned int comp=0) const
Returns AD nodal values of a coupled variable.
virtual const VariableValue & coupledNodalDotOld(const std::string &var_name, unsigned int comp=0) const
Nodal values of old time derivative of a coupled variable.
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
std::unordered_map< std::string, std::unique_ptr< ArrayVariableValue > > _default_array_value
Will hold the default value for optional array coupled variables.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
OutputTools< RealVectorValue >::VariableGradient VectorVariableGradient
ArrayVariableGradient _default_array_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
virtual bool isTransient() const override
const ADVariableSecond & getADDefaultSecond() const
Helper method to return (and insert if necessary) the default second derivatives for Automatic Differ...
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 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.
virtual const VectorVariableDivergence & coupledDiv(const std::string &var_name, unsigned int comp=0) const
Returns divergence of a coupled variable.
virtual const VariableGradient & coupledGradientPreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable for previous Newton iterate.
ArrayVariableValue _default_array_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
unsigned int _coupleable_max_qps
Maximum qps for any element in this system.
OutputTools< RealEigenVector >::VariableGradient ArrayVariableGradient
void addFEVariableCoupleableMatrixTag(TagID tag)
A NodeElemConstraintBase is used when you need to create constraints between a secondary node and a p...
Moose::VarKindType varKind() const
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...
const ADVectorVariableSecond & adCoupledVectorSecond(const std::string &, unsigned int)
std::vector< const VectorVariableValue * > coupledVectorValues(const std::string &var_name) const
Returns the values for all of a coupled vector variable's components.
virtual const VariableValue & coupledDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled variable.
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 VectorVariableValue & coupledVectorDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled 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.
void ErrorVector unsigned int
const ADVariableSecond & adCoupledSecond(const std::string &var_name, unsigned int comp=0) const
Returns second derivatives of a coupled variable for use in Automatic Differentiation.
virtual const VectorVariableValue & coupledVectorDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled vector 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.
virtual bool matrixTagExists(const TagName &tag_name) const
Check to see if a particular Tag exists.
void registerInterfaceObject(T &interface)
Registers an interface object for accessing with getInterfaceObjects.
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.
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.
MooseArray< ADRealVectorValue > _ad_default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
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 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 * > 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 MooseVariableFieldBase * getFieldVar(const std::string &var_name, unsigned int comp) const
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.