27 : _c_parameters(moose_object->parameters()),
28 _c_name(_c_parameters.
get<
std::string>(
"_object_name")),
29 _c_type(_c_parameters.
get<
std::string>(
"_type")),
30 _c_fe_problem(*_c_parameters.getCheckedPointerParam<
FEProblemBase *>(
"_fe_problem_base")),
31 _c_sys(_c_parameters.isParamValid(
"_sys") ? _c_parameters.
get<
SystemBase *>(
"_sys") : nullptr),
32 _new_to_deprecated_coupled_vars(_c_parameters.getNewToDeprecatedVarMap()),
34 _c_is_implicit(_c_parameters.have_parameter<bool>(
"implicit")
35 ? _c_parameters.
get<bool>(
"implicit")
37 _c_allow_element_to_nodal_coupling(
38 _c_parameters.have_parameter<bool>(
"_allow_nodal_to_elemental_coupling")
39 ? _c_parameters.
get<bool>(
"_allow_nodal_to_elemental_coupling")
42 _zero(_c_fe_problem._zero[_c_tid]),
43 _phi_zero(_c_fe_problem._phi_zero[_c_tid]),
44 _ad_zero(_c_fe_problem._ad_zero[_c_tid]),
45 _grad_zero(_c_fe_problem._grad_zero[_c_tid]),
46 _ad_grad_zero(_c_fe_problem._ad_grad_zero[_c_tid]),
47 _grad_phi_zero(_c_fe_problem._grad_phi_zero[_c_tid]),
48 _second_zero(_c_fe_problem._second_zero[_c_tid]),
49 _ad_second_zero(_c_fe_problem._ad_second_zero[_c_tid]),
50 _second_phi_zero(_c_fe_problem._second_phi_zero[_c_tid]),
51 _vector_zero(_c_fe_problem._vector_zero[_c_tid]),
52 _vector_curl_zero(_c_fe_problem._vector_curl_zero[_c_tid]),
53 _coupleable_neighbor(_c_parameters.have_parameter<bool>(
"_neighbor")
54 ? _c_parameters.
get<bool>(
"_neighbor")
64 unsigned int optional_var_index_counter = 0;
69 std::string
name = *iter;
74 for (
const auto & coupled_var_name : vars)
85 if (
auto * tmp_var = dynamic_cast<MooseVariable *>(moose_var))
87 else if (
auto * tmp_var = dynamic_cast<VectorMooseVariable *>(moose_var))
89 else if (
auto * tmp_var = dynamic_cast<ArrayMooseVariable *>(moose_var))
96 tmp_var->requireQpComputations();
122 ++optional_var_index_counter;
134 return (i < it->second.size());
140 ": The coupled variable \"",
142 "\" was never added to this object's " 143 "InputParameters, please double-check your " 164 var_name <<
" must not actually be coupled!");
180 const std::string & var_name)
182 if (bound > 0 && comp >= bound)
184 var_name,
"component ", comp,
" is out of range for this variable (max ", bound - 1,
")");
202 "' uses older variable values that are unavailable with explicit schemes");
210 unsigned int comp_bound)
const 217 for (
auto jt : it->second)
218 cvars +=
" " + jt->name();
223 "' to a scalar variable (",
225 ") where field variable is expected");
233 mooseError(
_c_name,
": Trying to get a coupled var ", var_name,
" that doesn't exist");
235 const auto & vars_vector = vars_vector_it->second;
237 auto bound = comp_bound ? comp_bound : vars_vector.size();
241 const auto * var = vars_vector[comp];
245 ": We did all our checks for the existence of a var, yet we still don't have a var!?");
252 if (!var->isFV() &&
_is_fv)
253 mooseError(
"Attempting to couple non-FV variable ",
255 " into an FV object ",
257 ". This is not currently supported");
269 mooseDeprecated(
"Coupleable::getFEVar is deprecated. Please use Coupleable::getFieldVar instead. " 270 "Note that this method could potentially return a finite volume variable");
277 return getVarHelper<MooseVariableFieldBase>(var_name, comp);
283 return getVarHelper<MooseVariableFieldBase>(var_name, comp);
289 return const_cast<MooseVariable *
>(getVarHelper<MooseVariable>(var_name, comp));
299 mooseError(
_c_name,
": Only LAGRANGE_VEC vector variables are defined at nodes");
307 return const_cast<ArrayMooseVariable *
>(getVarHelper<ArrayMooseVariable>(var_name, comp));
313 return getVarHelper<MooseVariable>(var_name, comp);
319 const auto *
const var = getVarHelper<VectorMooseVariable>(var_name, comp);
322 mooseError(
_c_name,
": Only LAGRANGE_VEC vector variables are defined at nodes");
330 return getVarHelper<ArrayMooseVariable>(var_name, comp);
342 _default_value[var_name].emplace_back(std::make_unique<VariableValue>(
345 _default_value[var_name].emplace_back(std::make_unique<VariableValue>(
350 const auto & default_value_vec = default_value_it->second;
351 const auto n_default_vals = default_value_vec.size();
352 if (comp >= n_default_vals)
355 " is equal to or greater than the number of default values ",
357 return default_value_vec[comp].get();
367 bool already_warned =
false;
375 catch (
const std::out_of_range &)
379 "You supplied less than 3 arguments for the default vector value for variable ",
381 ". Did you accidently leave something off? We are going to assign 0s, assuming " 384 already_warned =
true;
392 return default_value_it->second.get();
405 (*value)[qp].resize(n);
406 for (
unsigned int i = 0; i < n; ++i)
413 return default_value_it->second.get();
416 template <
typename T>
421 return *default_variable_value->data();
426 Coupleable::getDefaultNodalValue<RealVectorValue>(
const std::string & var_name,
unsigned int)
const 428 auto && default_variable_value = getDefaultVectorValue(var_name);
429 return *default_variable_value->data();
434 Coupleable::getDefaultNodalValue<RealEigenVector>(
const std::string & var_name,
unsigned int)
const 436 auto && default_variable_value = getDefaultArrayValue(var_name);
437 return *default_variable_value->data();
447 "optional var index for " << var_name <<
" does not exist!");
460 return var->number();
469 Coupleable::coupledGenericValue<false>(
const std::string & var_name,
unsigned int comp)
const 471 return coupledValue(var_name, comp);
476 Coupleable::coupledGenericValue<true>(
const std::string & var_name,
unsigned int comp)
const 478 return adCoupledValue(var_name, comp);
484 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
499 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
501 return (
_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
505 template <
typename T>
509 const unsigned int index)
const 511 const auto *
const var = getVarHelper<MooseVariableField<T>>(var_names, index);
513 mooseError(var_names,
": invalid variable name for coupledVectorTagValue");
517 mooseError(
"Attempting to couple to vector tag with ID ",
521 ", but a vector tag with that ID does not exist");
526 return var->nodalVectorTagValue(tag);
528 return var->vectorTagValue(tag);
531 template <
typename T>
534 const TagName & tag_name,
535 const unsigned int comp)
540 mooseError(var_name,
": invalid variable name for tag coupling");
542 auto & var_sys = var->sys();
544 var_sys.needSolutionState(1);
546 var_sys.needSolutionState(2);
549 template <
typename T>
552 const std::string & tag_param_name,
553 const unsigned int index)
const 556 mooseError(
"Tag name parameter '", tag_param_name,
"' is invalid");
563 const_cast<Coupleable *
>(
this)->requestStates<T>(var_names, tag_name, index);
566 mooseError(
"Tagged vector with tag name '", tag_name,
"' does not exist");
569 return vectorTagValueHelper<T>(var_names, tag, index);
574 Coupleable::coupledGenericDofValue<false>(
const std::string & var_name,
unsigned int comp)
const 576 return coupledDofValues(var_name, comp);
581 Coupleable::coupledGenericDofValue<true>(
const std::string & var_name,
unsigned int comp)
const 583 return adCoupledDofValues(var_name, comp);
589 const auto * var =
getVar(var_name, comp);
595 mooseError(
_c_name,
":coupledValueLower cannot be called in a coupleable neighbor object");
606 unsigned int index)
const 608 return vectorTagValueHelper<Real>(var_names, tag, index);
613 const std::string & tag_name,
614 unsigned int index)
const 616 return vectorTagValueHelper<Real>(var_names, tag_name, index);
622 unsigned int index)
const 624 return vectorTagValueHelper<RealEigenVector>(var_names, tag, index);
629 const std::string & tag_name,
630 unsigned int index)
const 632 return vectorTagValueHelper<RealEigenVector>(var_names, tag_name, index);
638 unsigned int index)
const 640 const auto * var =
getVar(var_names, index);
642 mooseError(var_names,
": invalid variable name for coupledVectorTagGradient");
646 mooseError(
"Attempting to couple to vector tag with ID ",
650 ", but a vector tag with that ID does not exist");
654 return var->vectorTagGradient(tag);
659 const std::string & tag_name,
660 unsigned int index)
const 663 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
667 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
676 unsigned int index)
const 680 mooseError(var_names,
": invalid variable name for coupledVectorTagArrayGradient");
684 mooseError(
"Attempting to couple to vector tag with ID ",
688 ", but a vector tag with that ID does not exist");
692 return var->vectorTagGradient(tag);
697 const std::string & tag_name,
698 unsigned int index)
const 701 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
705 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
711 template <
typename T>
715 const unsigned int comp)
const 717 const auto * var = getVarHelper<MooseVariableField<T>>(var_name, comp);
719 mooseError(var_name,
": invalid variable name for coupledVectorTagDofValue");
724 return var->vectorTagDofValue(tag);
727 template <
typename T>
730 const std::string & tag_param_name,
731 const unsigned int comp)
const 734 mooseError(
"Tag name parameter '", tag_param_name,
"' is invalid");
741 const_cast<Coupleable *
>(
this)->requestStates<T>(var_name, tag_name, comp);
744 mooseError(
"Tagged vector with tag name '", tag_name,
"' does not exist");
748 return vectorTagDofValueHelper<T>(var_name, tag, comp);
754 unsigned int comp)
const 756 return vectorTagDofValueHelper<Real>(var_name, tag, comp);
761 const std::string & tag_name,
762 unsigned int comp)
const 764 return vectorTagDofValueHelper<Real>(var_name, tag_name, comp);
769 const std::string & tag_name,
770 unsigned int comp)
const 772 return vectorTagDofValueHelper<RealEigenVector>(var_name, tag_name, comp);
778 unsigned int index)
const 780 const auto * var = getVarHelper<MooseVariableField<Real>>(var_names, index);
782 mooseError(var_names,
": invalid variable name for coupledMatrixTagValue");
788 return var->nodalMatrixTagValue(tag);
789 return var->matrixTagValue(tag);
794 const std::string & tag_name,
795 unsigned int index)
const 798 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
802 mooseError(
"Matrix tag name '", tagname,
"' does not exist");
819 return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
827 return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
829 return _c_is_implicit ? var->slnNeighbor() : var->slnOldNeighbor();
850 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
851 return (
_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
855 std::vector<const ArrayVariableValue *>
858 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledArrayValue(var_name, comp); };
859 return coupledVectorHelper<const ArrayVariableValue *>(var_name, func);
865 auto * var = getVarHelper<MooseWritableVariable>(var_name, comp);
867 const auto * aux =
dynamic_cast<const AuxKernel *
>(
this);
872 if (!aux && !euo && !nuo && !nfc)
873 mooseError(
"writableVariable() can only be called from AuxKernels, ElementUserObjects, " 874 "NodalUserObjects, or NodeFaceConstraints. '",
876 "' is none of those.");
878 if (aux && !aux->isNodal() && var->isNodal())
881 "' cannot obtain a writable reference to the nodal variable '",
884 if (euo && var->isNodal())
887 "' cannot obtain a writable reference to the nodal variable '",
900 mooseDeprecated(
"Coupleable::writableCoupledValue is deprecated, please use " 901 "Coupleable::writableVariable instead. ");
904 auto *
const var =
getVar(var_name, comp);
907 "Unable to create a writable reference for '", var_name,
"', is it a constant expression?");
912 "'", var->name(),
"' must be an auxiliary variable in Coupleable::writableCoupledValue");
915 const auto * aux =
dynamic_cast<const AuxKernel *
>(
this);
918 mooseError(
"writableCoupledValue() can only be called from AuxKernels, but '",
920 "' is not an AuxKernel.");
922 if (!aux->isNodal() && var->isNodal())
925 "' cannot obtain a writable reference to the nodal variable '",
942 if (br && !var->
hasBlocks(br->blockIDs()))
945 "' must be defined on all blocks '",
949 if (nfc && !var->
hasBlocks(nfc->getSecondaryConnectedBlocks()))
952 " must be defined on all blocks '",
954 "'s secondary surface is defined on.");
958 if (ci !=
this && ci->_writable_coupled_variables[
_c_tid].count(var))
963 if (br && br_other && br->blockRestricted() && br_other->blockRestricted() &&
971 "' already obtained a writable reference to '",
973 "'. Only one object can obtain such a reference per variable and subdomain in a " 987 const auto * var =
getVar(var_name, comp);
995 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1001 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1002 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1009 const auto * var =
getVar(var_name, comp);
1017 return var->dofValuesOlder();
1018 return var->slnOlder();
1023 return var->dofValuesOlderNeighbor();
1024 return var->slnOlderNeighbor();
1031 const auto * var =
getVar(var_name, comp);
1040 return var->dofValuesPreviousNL();
1041 return var->slnPreviousNL();
1046 return var->dofValuesPreviousNLNeighbor();
1047 return var->slnPreviousNLNeighbor();
1061 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1073 return var->slnOlder();
1074 return var->slnOlderNeighbor();
1088 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1094 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1095 return (
_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
1110 return var->dofValuesOlder();
1111 return var->slnOlder();
1116 return var->dofValuesOlderNeighbor();
1117 return var->slnOlderNeighbor();
1124 const auto * var =
getVar(var_name, comp);
1135 return var->dofValuesDot();
1141 return var->dofValuesDotNeighbor();
1142 return var->uDotNeighbor();
1149 const auto * var =
getVar(var_name, comp);
1160 return var->dofValuesDotDot();
1161 return var->uDotDot();
1166 return var->dofValuesDotDotNeighbor();
1167 return var->uDotDotNeighbor();
1174 const auto * var =
getVar(var_name, comp);
1185 return var->dofValuesDotOld();
1186 return var->uDotOld();
1191 return var->dofValuesDotOldNeighbor();
1192 return var->uDotOldNeighbor();
1199 const auto * var =
getVar(var_name, comp);
1210 return var->dofValuesDotDotOld();
1211 return var->uDotDotOld();
1216 return var->dofValuesDotDotOldNeighbor();
1217 return var->uDotDotOldNeighbor();
1234 return var->uDotNeighbor();
1249 return var->uDotDot();
1250 return var->uDotDotNeighbor();
1265 return var->uDotOld();
1266 return var->uDotOldNeighbor();
1281 return var->uDotDotOld();
1282 return var->uDotDotOldNeighbor();
1297 return var->duDotDu();
1298 return var->duDotDuNeighbor();
1313 return var->duDotDotDu();
1314 return var->duDotDotDuNeighbor();
1328 return var->dofValuesDot();
1334 return var->dofValuesDotNeighbor();
1335 return var->uDotNeighbor();
1350 return var->dofValuesDotDot();
1351 return var->uDotDot();
1356 return var->dofValuesDotDotNeighbor();
1357 return var->uDotDotNeighbor();
1372 return var->dofValuesDotOld();
1373 return var->uDotOld();
1378 return var->dofValuesDotOldNeighbor();
1379 return var->uDotOldNeighbor();
1394 return var->dofValuesDotDotOld();
1395 return var->uDotDotOld();
1400 return var->dofValuesDotDotOldNeighbor();
1401 return var->uDotDotOldNeighbor();
1408 const auto * var =
getVar(var_name, comp);
1419 return var->dofValuesDuDotDu();
1420 return var->duDotDu();
1425 return var->dofValuesDuDotDuNeighbor();
1426 return var->duDotDuNeighbor();
1433 const auto * var =
getVar(var_name, comp);
1444 return var->dofValuesDuDotDotDu();
1445 return var->duDotDotDu();
1450 return var->dofValuesDuDotDotDuNeighbor();
1451 return var->duDotDotDuNeighbor();
1458 const auto *
const var =
getArrayVar(var_name, comp);
1469 return var->dofValuesDuDotDu();
1470 return var->duDotDu();
1475 return var->dofValuesDuDotDuNeighbor();
1476 return var->duDotDuNeighbor();
1483 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
1493 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1499 const auto * var =
getVar(var_name, comp);
1508 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1509 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1515 const auto * var =
getVar(var_name, comp);
1524 return var->gradSlnOlder();
1525 return var->gradSlnOlderNeighbor();
1531 const auto * var =
getVar(var_name, comp);
1541 return var->gradSlnPreviousNL();
1542 return var->gradSlnPreviousNLNeighbor();
1548 const auto * var =
getVar(var_name, comp);
1557 return var->gradSlnDot();
1558 return var->gradSlnNeighborDot();
1564 const auto * var =
getVar(var_name, comp);
1573 return var->gradSlnDotDot();
1574 return var->gradSlnNeighborDotDot();
1590 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1605 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1606 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1621 return var->gradSlnOlder();
1622 return var->gradSlnOlderNeighbor();
1635 return (
_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1647 return (
_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1648 return (
_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1660 return var->gradSlnOlder();
1661 return var->gradSlnOlderNeighbor();
1667 const auto *
const var =
getArrayVar(var_name, comp);
1673 return var->gradSlnDot();
1674 return var->gradSlnNeighborDot();
1690 return (
_c_is_implicit) ? var->curlSlnNeighbor() : var->curlSlnOldNeighbor();
1705 return (
_c_is_implicit) ? var->curlSlnOld() : var->curlSlnOlder();
1706 return (
_c_is_implicit) ? var->curlSlnOldNeighbor() : var->curlSlnOlderNeighbor();
1721 return var->curlSlnOlder();
1722 return var->curlSlnOlderNeighbor();
1738 return (
_c_is_implicit) ? var->divSlnNeighbor() : var->divSlnOldNeighbor();
1754 return (
_c_is_implicit) ? var->divSlnOldNeighbor() : var->divSlnOlderNeighbor();
1769 return var->divSlnOlder();
1770 return var->divSlnOlderNeighbor();
1776 const auto * var =
getVar(var_name, comp);
1785 return (
_c_is_implicit) ? var->secondSln() : var->secondSlnOlder();
1786 return (
_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOlderNeighbor();
1792 const auto * var =
getVar(var_name, comp);
1801 return (
_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder();
1802 return (
_c_is_implicit) ? var->secondSlnOldNeighbor() : var->secondSlnOlderNeighbor();
1808 const auto * var =
getVar(var_name, comp);
1817 return var->secondSlnOlder();
1818 return var->secondSlnOlderNeighbor();
1824 const auto * var =
getVar(var_name, comp);
1834 return var->secondSlnPreviousNL();
1835 return var->secondSlnPreviousNLNeighbor();
1838 template <
typename T>
1842 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1844 return getDefaultNodalValue<T>(var_name, comp);
1847 if (!var->isNodal())
1849 ": Trying to get nodal values of variable '",
1851 "', but it is not nodal.");
1854 return (
_c_is_implicit) ? var->nodalValue() : var->nodalValueOld();
1855 return (
_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor();
1858 template <
typename T>
1862 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1864 return getDefaultNodalValue<T>(var_name, comp);
1867 if (!var->isNodal())
1869 ": Trying to get old nodal values of variable '",
1871 "', but it is not nodal.");
1874 return (
_c_is_implicit) ? var->nodalValueOld() : var->nodalValueOlder();
1875 return (
_c_is_implicit) ? var->nodalValueOldNeighbor() : var->nodalValueOlderNeighbor();
1878 template <
typename T>
1882 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1884 return getDefaultNodalValue<T>(var_name, comp);
1887 if (!var->isNodal())
1889 ": Trying to get older nodal values of variable '",
1891 "', but it is not nodal.");
1894 return var->nodalValueOlder();
1895 return var->nodalValueOlderNeighbor();
1898 template <
typename T>
1902 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1904 return getDefaultNodalValue<T>(var_name, comp);
1910 return var->nodalValuePreviousNL();
1911 return var->nodalValuePreviousNLNeighbor();
1914 template <
typename T>
1918 static const T
zero = 0;
1919 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
1925 return var->nodalValueDot();
1926 mooseError(
"Neighbor version not implemented");
1932 const auto * var =
getVar(var_name, comp);
1941 return var->dofValuesDotDot();
1942 return var->dofValuesDotDotNeighbor();
1948 const auto * var =
getVar(var_name, comp);
1957 return var->dofValuesDotOld();
1958 return var->dofValuesDotOldNeighbor();
1964 const auto * var =
getVar(var_name, comp);
1973 return var->dofValuesDotDotOld();
1974 return var->dofValuesDotDotOldNeighbor();
1980 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
1986 return (
_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
1987 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
1990 std::vector<const VariableValue *>
1993 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDofValues(var_name, comp); };
1994 return coupledVectorHelper<const VariableValue *>(var_name, func);
2000 const auto * var =
getVar(var_name, comp);
2006 return (
_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
2007 return (
_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
2010 std::vector<const VariableValue *>
2013 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDofValuesOld(var_name, comp); };
2014 return coupledVectorHelper<const VariableValue *>(var_name, func);
2020 const auto * var =
getVar(var_name, comp);
2026 return var->dofValuesOlder();
2027 return var->dofValuesOlderNeighbor();
2030 std::vector<const VariableValue *>
2033 auto func = [
this, &var_name](
unsigned int comp)
2035 return coupledVectorHelper<const VariableValue *>(var_name, func);
2047 return (
_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
2048 return (
_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
2054 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2064 return var->adDofValues();
2065 return var->adDofValuesNeighbor();
2075 "\" on variable \"",
2077 "\" when using a \"Steady\" executioner is not allowed. This value is available " 2078 "only in transient simulations.");
2081 template <
typename T>
2090 mooseError(
"The adCoupledNodalValue method should only be called for nodal computing objects");
2093 "The adCoupledNodalValue method shouldn't be called for neighbor computing objects. I " 2094 "don't even know what that would mean, although maybe someone could explain it to me.");
2096 mooseError(
"If you're going to use an explicit scheme, then use coupledNodalValue instead of " 2097 "adCoupledNodalValue");
2099 const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
2101 return var->adNodalValue();
2107 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2117 return var->adDofValues();
2120 return var->adSln();
2121 return var->adSlnNeighbor();
2127 auto var = getVarHelper<MooseVariableFE<Real>>(var_name, comp);
2134 mooseError(
"adCoupledLowerValue cannot be called in a coupleable neighbor object");
2137 return var->adDofValues();
2139 return var->adSlnLower();
2145 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2155 return var->adGradSln();
2156 return var->adGradSlnNeighbor();
2162 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2172 return var->adGradSlnDot();
2173 return var->adGradSlnNeighborDot();
2179 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2189 return var->adSecondSln();
2191 return var->adSecondSlnNeighbor();
2197 mooseError(
"Automatic differentiation using second derivatives of vector variables is not " 2204 const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2214 return var->adUDot();
2215 return var->adUDotNeighbor();
2221 const auto *
const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
2231 return var->adUDotDot();
2232 return var->adUDotDotNeighbor();
2247 return var->adUDot();
2248 return var->adUDotNeighbor();
2265 return var->adSln();
2266 return var->adSlnNeighbor();
2281 return var->adGradSln();
2282 return var->adGradSlnNeighbor();
2296 return default_value_it->second.get();
2313 return default_value_it->second.get();
2340 mooseDeprecated(
"Method adZeroValue() is deprecated. Use '_ad_zero' instead.");
2347 mooseDeprecated(
"Method adZeroGradient() is deprecated. Use '_ad_grad_zero' instead.");
2354 mooseDeprecated(
"Method adZeroSecond() is deprecated. Use '_ad_second_zero' instead.");
2360 Coupleable::genericZeroValue<false>()
2367 Coupleable::genericZeroValue<true>()
2374 Coupleable::genericZeroGradient<false>()
2381 Coupleable::genericZeroGradient<true>()
2383 return _ad_grad_zero;
2388 Coupleable::genericZeroSecond<false>()
2390 return _second_zero;
2395 Coupleable::genericZeroSecond<true>()
2397 return _ad_second_zero;
2402 Coupleable::coupledGenericGradient<false>(
const std::string & var_name,
unsigned int comp)
const 2404 return coupledGradient(var_name, comp);
2409 Coupleable::coupledGenericGradient<true>(
const std::string & var_name,
unsigned int comp)
const 2411 return adCoupledGradient(var_name, comp);
2414 std::vector<unsigned int>
2417 auto func = [
this, &var_name](
unsigned int comp) {
return coupled(var_name, comp); };
2418 return coupledVectorHelper<unsigned int>(var_name, func);
2429 ": a variable name was queried but a constant was passed for parameter '",
2431 "Either pass a true variable or contact a developer to shield the call to " 2432 "'coupledName' with 'isCoupledConstant'");
2435 _c_name,
": Variable '", var_name,
"' does not exist, yet its coupled name is requested");
2438 std::vector<VariableName>
2441 auto func = [
this, &var_name](
unsigned int comp) {
return coupledName(var_name, comp); };
2442 return coupledVectorHelper<VariableName>(var_name, func);
2445 std::vector<const VariableValue *>
2448 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValue(var_name, comp); };
2449 return coupledVectorHelper<const VariableValue *>(var_name, func);
2452 std::vector<const VectorVariableValue *>
2455 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledVectorValue(var_name, comp); };
2456 return coupledVectorHelper<const VectorVariableValue *>(var_name, func);
2460 std::vector<const GenericVariableValue<false> *>
2461 Coupleable::coupledGenericValues<false>(
const std::string & var_name)
const 2463 return coupledValues(var_name);
2467 std::vector<const GenericVariableValue<true> *>
2468 Coupleable::coupledGenericValues<true>(
const std::string & var_name)
const 2470 return adCoupledValues(var_name);
2473 std::vector<const ADVariableValue *>
2476 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledValue(var_name, comp); };
2477 return coupledVectorHelper<const ADVariableValue *>(var_name, func);
2480 std::vector<const ADVectorVariableValue *>
2483 auto func = [
this, &var_name](
unsigned int comp)
2485 return coupledVectorHelper<const ADVectorVariableValue *>(var_name, func);
2488 std::vector<const VariableValue *>
2491 auto func = [
this, &var_names, &tag](
unsigned int comp)
2493 return coupledVectorHelper<const VariableValue *>(var_names, func);
2496 std::vector<const VariableValue *>
2498 const std::string & tag_name)
const 2501 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2505 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2511 std::vector<const ArrayVariableValue *>
2514 auto func = [
this, &var_names, &tag](
unsigned int index)
2516 return coupledVectorHelper<const ArrayVariableValue *>(var_names, func);
2519 std::vector<const ArrayVariableValue *>
2521 const std::string & tag_name)
const 2524 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2528 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2534 std::vector<const VariableGradient *>
2537 auto func = [
this, &var_names, &tag](
unsigned int index)
2539 return coupledVectorHelper<const VariableGradient *>(var_names, func);
2542 std::vector<const VariableGradient *>
2544 const std::string & tag_name)
const 2547 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2551 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
2557 std::vector<const ArrayVariableGradient *>
2560 auto func = [
this, &var_names, &tag](
unsigned int index)
2562 return coupledVectorHelper<const ArrayVariableGradient *>(var_names, func);
2565 std::vector<const ArrayVariableGradient *>
2567 const std::string & tag_name)
const 2570 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2574 mooseError(
"Tagged vector with tag name '", tagname,
"' does not exist");
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 VariableValue *>
2606 auto func = [
this, &var_names, &tag](
unsigned int comp)
2608 return coupledVectorHelper<const VariableValue *>(var_names, func);
2611 std::vector<const VariableValue *>
2613 const std::string & tag_name)
const 2616 mooseError(
"Tag name parameter '", tag_name,
"' is invalid");
2620 mooseError(
"Matrix tag name '", tagname,
"' does not exist");
2626 std::vector<const VariableValue *>
2629 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValueOld(var_name, comp); };
2630 return coupledVectorHelper<const VariableValue *>(var_name, func);
2633 std::vector<const VariableValue *>
2636 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledValueOlder(var_name, comp); };
2637 return coupledVectorHelper<const VariableValue *>(var_name, func);
2640 std::vector<const VariableGradient *>
2643 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledGradient(var_name, comp); };
2644 return coupledVectorHelper<const VariableGradient *>(var_name, func);
2648 std::vector<const GenericVariableGradient<false> *>
2649 Coupleable::coupledGenericGradients<false>(
const std::string & var_name)
const 2651 return coupledGradients(var_name);
2655 std::vector<const GenericVariableGradient<true> *>
2656 Coupleable::coupledGenericGradients<true>(
const std::string & var_name)
const 2658 auto func = [
this, &var_name](
unsigned int comp) {
return &adCoupledGradient(var_name, comp); };
2659 return coupledVectorHelper<const GenericVariableGradient<true> *>(var_name, func);
2662 std::vector<const ADVariableGradient *>
2665 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledGradient(var_name, comp); };
2666 return coupledVectorHelper<const ADVariableGradient *>(var_name, func);
2669 std::vector<const VariableGradient *>
2672 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledGradientOld(var_name, comp); };
2673 return coupledVectorHelper<const VariableGradient *>(var_name, func);
2676 std::vector<const VariableValue *>
2679 auto func = [
this, &var_name](
unsigned int comp) {
return &
coupledDot(var_name, comp); };
2680 return coupledVectorHelper<const VariableValue *>(var_name, func);
2683 std::vector<const ADVariableValue *>
2686 auto func = [
this, &var_name](
unsigned int comp) {
return &
adCoupledDot(var_name, comp); };
2687 return coupledVectorHelper<const ADVariableValue *>(var_name, func);
2692 template const Real & Coupleable::getDefaultNodalValue<Real>(
const std::string & var_name,
2693 unsigned int comp)
const;
2695 template const Real & Coupleable::coupledNodalValue<Real>(
const std::string & var_name,
2696 unsigned int comp)
const;
2697 template const ADReal & Coupleable::adCoupledNodalValue<Real>(
const std::string & var_name,
2698 unsigned int comp)
const;
2700 Coupleable::adCoupledNodalValue<RealVectorValue>(
const std::string & var_name,
2701 unsigned int comp)
const;
2704 Coupleable::coupledNodalValue<RealVectorValue>(
const std::string & var_name,
2705 unsigned int comp)
const;
2706 template const Real & Coupleable::coupledNodalValueOld<Real>(
const std::string & var_name,
2707 unsigned int comp)
const;
2709 Coupleable::coupledNodalValueOld<RealVectorValue>(
const std::string & var_name,
2710 unsigned int comp)
const;
2711 template const Real & Coupleable::coupledNodalValueOlder<Real>(
const std::string & var_name,
2712 unsigned int comp)
const;
2714 Coupleable::coupledNodalValueOlder<RealVectorValue>(
const std::string & var_name,
2715 unsigned int comp)
const;
2716 template const Real & Coupleable::coupledNodalValuePreviousNL<Real>(
const std::string & var_name,
2717 unsigned int comp)
const;
2719 Coupleable::coupledNodalValuePreviousNL<RealVectorValue>(
const std::string & var_name,
2720 unsigned int comp)
const;
2721 template const Real & Coupleable::coupledNodalDot<Real>(
const std::string & var_name,
2722 unsigned int comp)
const;
2724 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...
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.
typename Moose::GenericType< VariableValue, is_ad > GenericVariableValue
typename Moose::GenericType< VariableSecond, is_ad > GenericVariableSecond
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.
Class for stuff related to variables.
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.
std::string toUpper(const std::string &name)
Convert supplied string to upper case.
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.
std::vector< MooseVariableFV< Real > * > _coupled_standard_fv_moose_vars
Vector of standard finite volume coupled variables.
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...
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.
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.
const std::string & name() const override
Get the variable name.
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.
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...
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 std::string & name() const
Get the name of the class.
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.
const MooseArray< DualReal > & _ad_zero
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.
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.
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.
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...
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.
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 ...
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< 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.
std::unordered_map< std::string, std::unique_ptr< MooseArray< DualReal > > > _ad_default_value
Will hold the default value for optional 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 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.
std::vector< MooseLinearVariableFV< Real > * > _coupled_standard_linear_fv_moose_vars
Vector of standard linear finite volume coupled variables.
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...
const InputParameters & _c_parameters
OutputTools< Real >::VariableSecond VariableSecond
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 It sho...
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)
typename Moose::GenericType< VariableGradient, is_ad > GenericVariableGradient
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.
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.