www.mooseframework.org
Coupleable.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "Coupleable.h"
11 #include "Problem.h"
12 #include "SubProblem.h"
13 #include "FEProblem.h"
14 #include "MooseVariableScalar.h"
15 #include "MooseVariableFE.h"
16 #include "InputParameters.h"
17 #include "MooseObject.h"
18 
19 Coupleable::Coupleable(const MooseObject * moose_object, bool nodal)
20  : _c_parameters(moose_object->parameters()),
21  _c_name(_c_parameters.get<std::string>("_object_name")),
22  _c_fe_problem(*_c_parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
23  _c_nodal(nodal),
24  _c_is_implicit(_c_parameters.have_parameter<bool>("implicit")
25  ? _c_parameters.get<bool>("implicit")
26  : true),
27  _c_tid(_c_parameters.get<THREAD_ID>("_tid")),
28  _zero(_c_fe_problem._zero[_c_tid]),
29  _ad_zero(_c_fe_problem._ad_zero[_c_tid]),
30  _grad_zero(_c_fe_problem._grad_zero[_c_tid]),
31  _ad_grad_zero(_c_fe_problem._ad_grad_zero[_c_tid]),
32  _second_zero(_c_fe_problem._second_zero[_c_tid]),
33  _ad_second_zero(_c_fe_problem._ad_second_zero[_c_tid]),
34  _second_phi_zero(_c_fe_problem._second_phi_zero[_c_tid]),
35  _vector_zero(_c_fe_problem._vector_zero[_c_tid]),
36  _vector_curl_zero(_c_fe_problem._vector_curl_zero[_c_tid]),
37  _coupleable_neighbor(_c_parameters.have_parameter<bool>("_neighbor")
38  ? _c_parameters.get<bool>("_neighbor")
39  : false),
40  _coupleable_max_qps(_c_fe_problem.getMaxQps())
41 {
42  SubProblem & problem = *_c_parameters.getCheckedPointerParam<SubProblem *>("_subproblem");
43 
44  unsigned int optional_var_index_counter = 0;
45 
46  // Coupling
47  for (auto iter = _c_parameters.coupledVarsBegin(); iter != _c_parameters.coupledVarsEnd(); ++iter)
48  {
49  std::string name = *iter;
50 
51  std::vector<std::string> vars = _c_parameters.getVecMooseType(name);
52  if (vars.size() > 0)
53  {
54  for (const auto & coupled_var_name : vars)
55  {
56  if (problem.hasVariable(coupled_var_name))
57  {
58  MooseVariableFEBase * moose_var =
59  &problem.getVariable(_c_tid,
60  coupled_var_name,
63  _coupled_vars[name].push_back(moose_var);
64  _coupled_moose_vars.push_back(moose_var);
65  if (auto * tmp_var = dynamic_cast<MooseVariable *>(moose_var))
66  _coupled_standard_moose_vars.push_back(tmp_var);
67  else if (auto * tmp_var = dynamic_cast<VectorMooseVariable *>(moose_var))
68  _coupled_vector_moose_vars.push_back(tmp_var);
69  else
70  mooseError("Unknown variable type!");
71  }
72  else if (problem.hasScalarVariable(coupled_var_name))
73  {
74  MooseVariableScalar * moose_scalar_var =
75  &problem.getScalarVariable(_c_tid, coupled_var_name);
76  _c_coupled_scalar_vars[name].push_back(moose_scalar_var);
77  }
78  else
79  mooseError(_c_name, ": Coupled variable '", coupled_var_name, "' was not found");
80  }
81  }
82  else // This means it was optional coupling. Let's assign a unique id to this variable
83  {
85  for (unsigned int j = 0; j < _optional_var_index[name].size(); ++j)
86  _optional_var_index[name][j] =
87  std::numeric_limits<unsigned int>::max() - optional_var_index_counter;
88  ++optional_var_index_counter;
89  }
90  }
91 
101 }
102 
104 {
105  for (auto & it : _default_value)
106  for (auto itt : it.second)
107  {
108  itt->release();
109  delete itt;
110  }
111  for (auto & it : _default_vector_value)
112  {
113  it.second->release();
114  delete it.second;
115  }
116  for (auto & it : _ad_default_value)
117  {
118  it.second->release();
119  delete it.second;
120  }
121  for (auto & it : _ad_default_vector_value)
122  {
123  it.second->release();
124  delete it.second;
125  }
126 
127  _default_value_zero.release();
128  _default_gradient.release();
129  _default_second.release();
130  _default_vector_value_zero.release();
131  _default_vector_gradient.release();
136 }
137 
138 void
139 Coupleable::coupledCallback(const std::string & /*var_name*/, bool /*is_old*/)
140 {
141 }
142 
143 bool
144 Coupleable::isCoupled(const std::string & var_name, unsigned int i)
145 {
146  std::map<std::string, std::vector<MooseVariableFEBase *>>::iterator it =
147  _coupled_vars.find(var_name);
148  if (it != _coupled_vars.end())
149  return (i < it->second.size());
150  else
151  {
152  // Make sure the user originally requested this value in the InputParameter syntax
153  if (!_c_parameters.hasCoupledValue(var_name))
155  ": The coupled variable \"",
156  var_name,
157  "\" was never added to this objects's "
158  "InputParameters, please double-check your "
159  "spelling");
160 
161  return false;
162  }
163 }
164 
165 unsigned int
166 Coupleable::coupledComponents(const std::string & var_name)
167 {
168  if (isCoupled(var_name))
169  return _coupled_vars[var_name].size();
170  else
171  {
173  return _c_parameters.numberDefaultCoupledValues(var_name);
174  else
175  return 0;
176  }
177 }
178 
179 void
180 Coupleable::checkVar(const std::string & var_name)
181 {
182  auto it = _c_coupled_scalar_vars.find(var_name);
183  if (it != _c_coupled_scalar_vars.end())
184  {
185  std::string cvars;
186  for (auto jt : it->second)
187  cvars += " " + jt->name();
189  ": Trying to couple a scalar variable where field variable is expected, '",
190  var_name,
191  " =",
192  cvars,
193  "'");
194  }
195  // NOTE: non-existent variables are handled in the constructor
196 }
197 
199 Coupleable::getFEVar(const std::string & var_name, unsigned int comp)
200 {
201  if (comp < _coupled_vars[var_name].size())
202  {
203  // Error check - don't couple elemental to nodal
204  if (!(_coupled_vars[var_name][comp])->isNodal() && _c_nodal)
205  mooseError(_c_name, ": You cannot couple an elemental variable to a nodal variable");
206  return _coupled_vars[var_name][comp];
207  }
208  else
209  mooseError(_c_name, ": Trying to get a non-existent component of variable '", var_name, "'");
210 }
211 
212 template <typename T>
214 Coupleable::getVarHelper(const std::string & var_name, unsigned int comp)
215 {
216  if (comp < _coupled_vars[var_name].size())
217  {
218  // Error check - don't couple elemental to nodal
219  if (!(_coupled_vars[var_name][comp])->isNodal() && _c_nodal)
220  mooseError(_c_name, ": You cannot couple an elemental variable to a nodal variable");
221  if (auto * coupled_var = dynamic_cast<MooseVariableFE<T> *>(_coupled_vars[var_name][comp]))
222  return coupled_var;
223  else
224  {
225  for (auto & var : _coupled_standard_moose_vars)
226  if (var->name() == var_name)
227  mooseError("The coupled call is not for coupled standard variables");
228  for (auto & var : _coupled_vector_moose_vars)
229  if (var->name() == var_name)
230  mooseError("The coupled call is not for coupled vector variables");
231  mooseError("Error for coupling variable ", var_name);
232  }
233  }
234  else
235  mooseError(_c_name, ": Trying to get a non-existent component of variable '", var_name, "'");
236 
237  return nullptr;
238 }
239 
241 Coupleable::getVar(const std::string & var_name, unsigned int comp)
242 {
243  return getVarHelper<Real>(var_name, comp);
244 }
245 
247 Coupleable::getVectorVar(const std::string & var_name, unsigned int comp)
248 {
249  return getVarHelper<RealVectorValue>(var_name, comp);
250 }
251 
252 unsigned int
253 Coupleable::coupled(const std::string & var_name, unsigned int comp)
254 {
255  checkVar(var_name);
256 
257  if (!isCoupled(var_name))
258  {
259  // make sure we don't try to access default var ids that were not provided
260  if (comp + 1 > _optional_var_index[var_name].size())
262  ": Requested component ",
263  comp,
264  " of coupled value ",
265  var_name,
266  " is out of range.");
267  return _optional_var_index[var_name][comp];
268  }
269 
270  MooseVariableFEBase * var = getFEVar(var_name, comp);
271  switch (var->kind())
272  {
274  return var->number();
276  return std::numeric_limits<unsigned int>::max() - var->number();
277  default:
278  mooseError(_c_name, ": Unknown variable kind. Corrupted binary?");
279  }
280 }
281 
283 Coupleable::getDefaultValue(const std::string & var_name, unsigned int comp)
284 {
285  // make sure we don't access values that were not provided
286  if (comp + 1 > _c_parameters.numberDefaultCoupledValues(var_name))
288  ": Requested component ",
289  comp,
290  " of coupled value ",
291  var_name,
292  " is out of range.");
293 
294  std::map<std::string, std::vector<VariableValue *>>::iterator default_value_it =
295  _default_value.find(var_name);
296  if (default_value_it == _default_value.end())
297  {
298  _default_value[var_name] = {
300  for (unsigned int j = 1; j < _c_parameters.numberDefaultCoupledValues(var_name); ++j)
301  _default_value[var_name].push_back(
303  default_value_it = _default_value.find(var_name);
304  }
305 
306  return default_value_it->second[comp];
307 }
308 
310 Coupleable::getDefaultVectorValue(const std::string & var_name)
311 {
312  std::map<std::string, VectorVariableValue *>::iterator default_value_it =
313  _default_vector_value.find(var_name);
314  if (default_value_it == _default_vector_value.end())
315  {
317  bool already_warned = false;
318  for (unsigned int qp = 0; qp < _coupleable_max_qps; ++qp)
319  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
320  {
321  try
322  {
323  (*value)[qp](i) = _c_parameters.defaultCoupledValue(var_name, i);
324  }
325  catch (const std::out_of_range &)
326  {
327  if (!already_warned)
328  mooseWarning(
329  "You supplied less than 3 arguments for the default vector value for variable ",
330  var_name,
331  ". Did you accidently leave something off? We are going to assign 0s, assuming "
332  "this "
333  "was intentional.");
334  already_warned = true;
335  (*value)[qp](i) = 0;
336  }
337  }
338  default_value_it = _default_vector_value.insert(std::make_pair(var_name, value)).first;
339  }
340 
341  return default_value_it->second;
342 }
343 
344 template <typename T>
345 const T &
346 Coupleable::getNodalDefaultValue(const std::string & var_name, unsigned int comp)
347 {
348  auto && default_variable_value = getDefaultValue(var_name, comp);
349  return *default_variable_value->data();
350 }
351 
352 template <>
353 const RealVectorValue &
354 Coupleable::getNodalDefaultValue<RealVectorValue>(const std::string & var_name, unsigned int)
355 {
356  auto && default_variable_value = getDefaultVectorValue(var_name);
357  return *default_variable_value->data();
358 }
359 
360 const VariableValue &
361 Coupleable::coupledValue(const std::string & var_name, unsigned int comp)
362 {
363  checkVar(var_name);
364  if (!isCoupled(var_name))
365  return *getDefaultValue(var_name, comp);
366 
367  coupledCallback(var_name, false);
368  MooseVariable * var = getVar(var_name, comp);
369  // var should be a valid pointer at this point, otherwise an error has been thrown in getVar
370 
372  {
373  if (_c_nodal)
374  return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
375  else
376  return (_c_is_implicit) ? var->sln() : var->slnOld();
377  }
378  else
379  {
380  if (_c_nodal)
381  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
382  else
383  return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
384  }
385 }
386 
387 const VariableValue &
388 Coupleable::coupledVectorTagValue(const std::string & var_name, TagID tag, unsigned int comp)
389 {
390  checkVar(var_name);
391  if (!isCoupled(var_name))
392  mooseError(var_name, ": invalid variable name for coupledVectorTagValue");
393 
395 
396  coupledCallback(var_name, false);
397  MooseVariable * var = getVar(var_name, comp);
398 
399  if (_c_nodal)
400  return var->nodalVectorTagValue(tag);
401  else
402  return var->vectorTagValue(tag);
403 }
404 
405 const VariableValue &
406 Coupleable::coupledMatrixTagValue(const std::string & var_name, TagID tag, unsigned int comp)
407 {
408  checkVar(var_name);
409  if (!isCoupled(var_name))
410  mooseError(var_name, ": invalid variable name for coupledMatrixTagValue");
411 
413 
414  coupledCallback(var_name, false);
415  MooseVariable * var = getVar(var_name, comp);
416 
417  if (_c_nodal)
418  return var->nodalMatrixTagValue(tag);
419  else
420  return var->matrixTagValue(tag);
421 }
422 
423 const VectorVariableValue &
424 Coupleable::coupledVectorValue(const std::string & var_name, unsigned int comp)
425 {
426  if (!isCoupled(var_name))
427  return *getDefaultVectorValue(var_name);
428 
429  coupledCallback(var_name, false);
430  VectorMooseVariable * var = getVectorVar(var_name, comp);
431 
433  {
434  if (_c_nodal)
435  mooseError("Vector variables are not required to be continuous and so should not be used "
436  "with nodal compute objects");
437  else
438  return (_c_is_implicit) ? var->sln() : var->slnOld();
439  }
440  else
441  {
442  if (_c_nodal)
443  mooseError("Vector variables are not required to be continuous and so should not be used "
444  "with nodal compute objects");
445  else
446  return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
447  }
448 }
449 
451 Coupleable::writableCoupledValue(const std::string & var_name, unsigned int comp)
452 {
453  return const_cast<VariableValue &>(coupledValue(var_name, comp));
454 }
455 
456 const VariableValue &
457 Coupleable::coupledValueOld(const std::string & var_name, unsigned int comp)
458 {
459  checkVar(var_name);
460  if (!isCoupled(var_name))
461  return *getDefaultValue(var_name, comp);
462 
463  validateExecutionerType(var_name, "coupledValueOld");
464  coupledCallback(var_name, true);
465  MooseVariable * var = getVar(var_name, comp);
466 
468  {
469  if (_c_nodal)
470  return (_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
471  else
472  return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
473  }
474  else
475  {
476  if (_c_nodal)
478  else
479  return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
480  }
481 }
482 
483 const VariableValue &
484 Coupleable::coupledValueOlder(const std::string & var_name, unsigned int comp)
485 {
486  checkVar(var_name);
487  if (!isCoupled(var_name))
488  return *getDefaultValue(var_name, comp);
489 
490  validateExecutionerType(var_name, "coupledValueOlder");
491  coupledCallback(var_name, true);
492  MooseVariable * var = getVar(var_name, comp);
493 
495  {
496  if (_c_nodal)
497  {
498  if (_c_is_implicit)
499  return var->dofValuesOlder();
500  else
501  mooseError(_c_name, ": Older values not available for explicit schemes");
502  }
503  else
504  {
505  if (_c_is_implicit)
506  return var->slnOlder();
507  else
508  mooseError(_c_name, ": Older values not available for explicit schemes");
509  }
510  }
511  else
512  {
513  if (_c_nodal)
514  {
515  if (_c_is_implicit)
516  return var->dofValuesOlderNeighbor();
517  else
518  mooseError(_c_name, ": Older values not available for explicit schemes");
519  }
520  else
521  {
522  if (_c_is_implicit)
523  return var->slnOlderNeighbor();
524  else
525  mooseError(_c_name, ": Older values not available for explicit schemes");
526  }
527  }
528 }
529 
530 const VariableValue &
531 Coupleable::coupledValuePreviousNL(const std::string & var_name, unsigned int comp)
532 {
533  checkVar(var_name);
534  if (!isCoupled(var_name))
535  return *getDefaultValue(var_name, comp);
536 
538  coupledCallback(var_name, true);
539  MooseVariable * var = getVar(var_name, comp);
540 
542  {
543  if (_c_nodal)
544  return var->dofValuesPreviousNL();
545  else
546  return var->slnPreviousNL();
547  }
548  else
549  {
550  if (_c_nodal)
551  return var->dofValuesPreviousNLNeighbor();
552  else
553  return var->slnPreviousNLNeighbor();
554  }
555 }
556 
557 const VectorVariableValue &
558 Coupleable::coupledVectorValueOld(const std::string & var_name, unsigned int comp)
559 {
560  if (!isCoupled(var_name))
561  return *getDefaultVectorValue(var_name);
562 
563  validateExecutionerType(var_name, "coupledVectorValueOld");
564  coupledCallback(var_name, true);
565  VectorMooseVariable * var = getVectorVar(var_name, comp);
566 
568  {
569  if (_c_nodal)
570  mooseError("Vector variables are not required to be continuous and so should not be used "
571  "with nodal compute objects");
572  else
573  return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
574  }
575  else
576  {
577  if (_c_nodal)
578  mooseError("Vector variables are not required to be continuous and so should not be used "
579  "with nodal compute objects");
580  else
581  return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
582  }
583 }
584 
585 const VectorVariableValue &
586 Coupleable::coupledVectorValueOlder(const std::string & var_name, unsigned int comp)
587 {
588  if (!isCoupled(var_name))
589  return *getDefaultVectorValue(var_name);
590 
591  validateExecutionerType(var_name, "coupledVectorValueOlder");
592  coupledCallback(var_name, true);
593  VectorMooseVariable * var = getVectorVar(var_name, comp);
594 
596  {
597  if (_c_nodal)
598  mooseError("Vector variables are not required to be continuous and so should not be used "
599  "with nodal compute objects");
600  else
601  {
602  if (_c_is_implicit)
603  return var->slnOlder();
604  else
605  mooseError("Older values not available for explicit schemes");
606  }
607  }
608  else
609  {
610  if (_c_nodal)
611  mooseError("Vector variables are not required to be continuous and so should not be used "
612  "with nodal compute objects");
613  else
614  {
615  if (_c_is_implicit)
616  return var->slnOlderNeighbor();
617  else
618  mooseError("Older values not available for explicit schemes");
619  }
620  }
621 }
622 
623 const VariableValue &
624 Coupleable::coupledDot(const std::string & var_name, unsigned int comp)
625 {
626  checkVar(var_name);
627  if (!isCoupled(var_name)) // Return default 0
628  return _default_value_zero;
629 
630  validateExecutionerType(var_name, "coupledDot");
631  MooseVariable * var = getVar(var_name, comp);
632 
634  {
635  if (_c_nodal)
636  return var->dofValuesDot();
637  else
638  return var->uDot();
639  }
640  else
641  {
642  if (_c_nodal)
643  return var->dofValuesDotNeighbor();
644  else
645  return var->uDotNeighbor();
646  }
647 }
648 
649 const VariableValue &
650 Coupleable::coupledDotDot(const std::string & var_name, unsigned int comp)
651 {
652  checkVar(var_name);
653  if (!isCoupled(var_name)) // Return default 0
654  return _default_value_zero;
655 
656  validateExecutionerType(var_name, "coupledDotDot");
657  MooseVariable * var = getVar(var_name, comp);
658 
660  {
661  if (_c_nodal)
662  return var->dofValuesDotDot();
663  else
664  return var->uDotDot();
665  }
666  else
667  {
668  if (_c_nodal)
669  return var->dofValuesDotDotNeighbor();
670  else
671  return var->uDotDotNeighbor();
672  }
673 }
674 
675 const VariableValue &
676 Coupleable::coupledDotOld(const std::string & var_name, unsigned int comp)
677 {
678  checkVar(var_name);
679  if (!isCoupled(var_name)) // Return default 0
680  return _default_value_zero;
681 
682  validateExecutionerType(var_name, "coupledDotOld");
683  MooseVariable * var = getVar(var_name, comp);
684 
686  {
687  if (_c_nodal)
688  return var->dofValuesDotOld();
689  else
690  return var->uDotOld();
691  }
692  else
693  {
694  if (_c_nodal)
695  return var->dofValuesDotOldNeighbor();
696  else
697  return var->uDotOldNeighbor();
698  }
699 }
700 
701 const VariableValue &
702 Coupleable::coupledDotDotOld(const std::string & var_name, unsigned int comp)
703 {
704  checkVar(var_name);
705  if (!isCoupled(var_name)) // Return default 0
706  return _default_value_zero;
707 
708  validateExecutionerType(var_name, "coupledDotDotOld");
709  MooseVariable * var = getVar(var_name, comp);
710 
712  {
713  if (_c_nodal)
714  return var->dofValuesDotDotOld();
715  else
716  return var->uDotDotOld();
717  }
718  else
719  {
720  if (_c_nodal)
721  return var->dofValuesDotDotOldNeighbor();
722  else
723  return var->uDotDotOldNeighbor();
724  }
725 }
726 
727 const VectorVariableValue &
728 Coupleable::coupledVectorDot(const std::string & var_name, unsigned int comp)
729 {
730  checkVar(var_name);
731  if (!isCoupled(var_name)) // Return default 0
733 
734  validateExecutionerType(var_name, "coupledVectorDot");
735  VectorMooseVariable * var = getVectorVar(var_name, comp);
736 
738  {
739  if (_c_nodal)
740  mooseError("Vector variables are not required to be continuous and so should not be used "
741  "with nodal compute objects");
742  else
743  return var->uDot();
744  }
745  else
746  {
747  if (_c_nodal)
748  mooseError("Vector variables are not required to be continuous and so should not be used "
749  "with nodal compute objects");
750  else
751  return var->uDotNeighbor();
752  }
753 }
754 
755 const VectorVariableValue &
756 Coupleable::coupledVectorDotDot(const std::string & var_name, unsigned int comp)
757 {
758  checkVar(var_name);
759  if (!isCoupled(var_name)) // Return default 0
761 
762  validateExecutionerType(var_name, "coupledVectorDotDot");
763  VectorMooseVariable * var = getVectorVar(var_name, comp);
764 
766  {
767  if (_c_nodal)
768  mooseError("Vector variables are not required to be continuous and so should not be used "
769  "with nodal compute objects");
770  else
771  return var->uDotDot();
772  }
773  else
774  {
775  if (_c_nodal)
776  mooseError("Vector variables are not required to be continuous and so should not be used "
777  "with nodal compute objects");
778  else
779  return var->uDotDotNeighbor();
780  }
781 }
782 
783 const VectorVariableValue &
784 Coupleable::coupledVectorDotOld(const std::string & var_name, unsigned int comp)
785 {
786  checkVar(var_name);
787  if (!isCoupled(var_name)) // Return default 0
789 
790  validateExecutionerType(var_name, "coupledVectorDotOld");
791  VectorMooseVariable * var = getVectorVar(var_name, comp);
792 
794  {
795  if (_c_nodal)
796  mooseError("Vector variables are not required to be continuous and so should not be used "
797  "with nodal compute objects");
798  else
799  return var->uDotOld();
800  }
801  else
802  {
803  if (_c_nodal)
804  mooseError("Vector variables are not required to be continuous and so should not be used "
805  "with nodal compute objects");
806  else
807  return var->uDotOldNeighbor();
808  }
809 }
810 
811 const VectorVariableValue &
812 Coupleable::coupledVectorDotDotOld(const std::string & var_name, unsigned int comp)
813 {
814  checkVar(var_name);
815  if (!isCoupled(var_name)) // Return default 0
817 
818  validateExecutionerType(var_name, "coupledVectorDotDotOld");
819  VectorMooseVariable * var = getVectorVar(var_name, comp);
820 
822  {
823  if (_c_nodal)
824  mooseError("Vector variables are not required to be continuous and so should not be used "
825  "with nodal compute objects");
826  else
827  return var->uDotDotOld();
828  }
829  else
830  {
831  if (_c_nodal)
832  mooseError("Vector variables are not required to be continuous and so should not be used "
833  "with nodal compute objects");
834  else
835  return var->uDotDotOldNeighbor();
836  }
837 }
838 
839 const VariableValue &
840 Coupleable::coupledDotDu(const std::string & var_name, unsigned int comp)
841 {
842  checkVar(var_name);
843  if (!isCoupled(var_name)) // Return default 0
844  return _default_value_zero;
845 
846  validateExecutionerType(var_name, "coupledDotDu");
847  MooseVariable * var = getVar(var_name, comp);
848 
850  {
851  if (_c_nodal)
852  return var->dofValuesDuDotDu();
853  else
854  return var->duDotDu();
855  }
856  else
857  {
858  if (_c_nodal)
859  return var->dofValuesDuDotDuNeighbor();
860  else
861  return var->duDotDuNeighbor();
862  }
863 }
864 
865 const VariableValue &
866 Coupleable::coupledDotDotDu(const std::string & var_name, unsigned int comp)
867 {
868  checkVar(var_name);
869  if (!isCoupled(var_name)) // Return default 0
870  return _default_value_zero;
871 
872  validateExecutionerType(var_name, "coupledDotDotDu");
873  MooseVariable * var = getVar(var_name, comp);
874 
876  {
877  if (_c_nodal)
878  return var->dofValuesDuDotDotDu();
879  else
880  return var->duDotDotDu();
881  }
882  else
883  {
884  if (_c_nodal)
885  return var->dofValuesDuDotDotDuNeighbor();
886  else
887  return var->duDotDotDu();
888  }
889 }
890 
891 const VariableGradient &
892 Coupleable::coupledGradient(const std::string & var_name, unsigned int comp)
893 {
894  checkVar(var_name);
895  if (!isCoupled(var_name)) // Return default 0
896  return _default_gradient;
897 
898  coupledCallback(var_name, false);
899  if (_c_nodal)
900  mooseError(_c_name, ": Nodal variables do not have gradients");
901 
902  MooseVariable * var = getVar(var_name, comp);
903 
905  return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
906  else
907  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
908 }
909 
910 const VariableGradient &
911 Coupleable::coupledGradientOld(const std::string & var_name, unsigned int comp)
912 {
913  checkVar(var_name);
914  if (!isCoupled(var_name)) // Return default 0
915  return _default_gradient;
916 
917  coupledCallback(var_name, true);
918  if (_c_nodal)
919  mooseError(_c_name, ": Nodal compute objects do not support gradients");
920 
921  validateExecutionerType(var_name, "coupledGradientOld");
922  MooseVariable * var = getVar(var_name, comp);
923 
925  return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
926  else
927  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
928 }
929 
930 const VariableGradient &
931 Coupleable::coupledGradientOlder(const std::string & var_name, unsigned int comp)
932 {
933  checkVar(var_name);
934  if (!isCoupled(var_name)) // Return default 0
935  return _default_gradient;
936 
937  coupledCallback(var_name, true);
938  if (_c_nodal)
939  mooseError(_c_name, ": Nodal compute objects do not support gradients");
940 
941  validateExecutionerType(var_name, "coupledGradientOlder");
942  MooseVariable * var = getVar(var_name, comp);
943 
944  if (_c_is_implicit)
945  {
947  return var->gradSlnOlder();
948  else
949  return var->gradSlnOlderNeighbor();
950  }
951  else
952  mooseError(_c_name, ": Older values not available for explicit schemes");
953 }
954 
955 const VariableGradient &
956 Coupleable::coupledGradientPreviousNL(const std::string & var_name, unsigned int comp)
957 {
958  checkVar(var_name);
959  if (!isCoupled(var_name)) // Return default 0
960  return _default_gradient;
961 
963  coupledCallback(var_name, true);
964  if (_c_nodal)
965  mooseError(_c_name, ": Nodal compute objects do not support gradients");
966 
967  MooseVariable * var = getVar(var_name, comp);
968 
970  return var->gradSlnPreviousNL();
971  else
972  return var->gradSlnPreviousNLNeighbor();
973 }
974 
975 const VariableGradient &
976 Coupleable::coupledGradientDot(const std::string & var_name, unsigned int comp)
977 {
978  checkVar(var_name);
979  if (!isCoupled(var_name)) // Return default 0
980  return _default_gradient;
981 
982  coupledCallback(var_name, false);
983  if (_c_nodal)
984  mooseError(_c_name, ": Nodal variables do not have gradients");
985 
986  MooseVariable * var = getVar(var_name, comp);
987 
989  return var->gradSlnDot();
990  else
991  return var->gradSlnNeighborDot();
992 }
993 
994 const VariableGradient &
995 Coupleable::coupledGradientDotDot(const std::string & var_name, unsigned int comp)
996 {
997  checkVar(var_name);
998  if (!isCoupled(var_name)) // Return default 0
999  return _default_gradient;
1000 
1001  coupledCallback(var_name, false);
1002  if (_c_nodal)
1003  mooseError(_c_name, ": Nodal variables do not have gradients");
1004 
1005  MooseVariable * var = getVar(var_name, comp);
1006 
1007  if (!_coupleable_neighbor)
1008  return var->gradSlnDotDot();
1009  else
1010  return var->gradSlnNeighborDotDot();
1011 }
1012 
1013 const VectorVariableGradient &
1014 Coupleable::coupledVectorGradient(const std::string & var_name, unsigned int comp)
1015 {
1016  checkVar(var_name);
1017  if (!isCoupled(var_name)) // Return default 0
1018  return _default_vector_gradient;
1019 
1020  coupledCallback(var_name, false);
1021  if (_c_nodal)
1022  mooseError(_c_name, ": Gradients are non-sensical with nodal compute objects");
1023 
1024  VectorMooseVariable * var = getVectorVar(var_name, comp);
1025 
1026  if (!_coupleable_neighbor)
1027  return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
1028  else
1029  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
1030 }
1031 
1032 const VectorVariableGradient &
1033 Coupleable::coupledVectorGradientOld(const std::string & var_name, unsigned int comp)
1034 {
1035  checkVar(var_name);
1036  if (!isCoupled(var_name)) // Return default 0
1037  return _default_vector_gradient;
1038 
1039  coupledCallback(var_name, true);
1040  if (_c_nodal)
1041  mooseError(_c_name, ": Gradients are non-sensical with nodal compute objects");
1042 
1043  validateExecutionerType(var_name, "coupledGradientOld");
1044  VectorMooseVariable * var = getVectorVar(var_name, comp);
1045 
1046  if (!_coupleable_neighbor)
1047  return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
1048  else
1049  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
1050 }
1051 
1052 const VectorVariableGradient &
1053 Coupleable::coupledVectorGradientOlder(const std::string & var_name, unsigned int comp)
1054 {
1055  checkVar(var_name);
1056  if (!isCoupled(var_name)) // Return default 0
1057  return _default_vector_gradient;
1058 
1059  coupledCallback(var_name, true);
1060  if (_c_nodal)
1061  mooseError(_c_name, ": Gradients are non-sensical with nodal compute objects");
1062 
1063  validateExecutionerType(var_name, "coupledGradientOlder");
1064  VectorMooseVariable * var = getVectorVar(var_name, comp);
1065 
1066  if (_c_is_implicit)
1067  {
1068  if (!_coupleable_neighbor)
1069  return var->gradSlnOlder();
1070  else
1071  return var->gradSlnOlderNeighbor();
1072  }
1073  else
1074  mooseError(_c_name, ": Older values not available for explicit schemes");
1075 }
1076 
1077 const VectorVariableCurl &
1078 Coupleable::coupledCurl(const std::string & var_name, unsigned int comp)
1079 {
1080  if (!isCoupled(var_name)) // Return default 0
1081  return _default_vector_curl;
1082 
1083  coupledCallback(var_name, false);
1084  if (_c_nodal)
1085  mooseError("Nodal variables do not have curls");
1086 
1087  VectorMooseVariable * var = getVectorVar(var_name, comp);
1088  if (var == NULL)
1089  mooseError("Call corresponding scalar field variable method");
1090 
1091  if (!_coupleable_neighbor)
1092  return (_c_is_implicit) ? var->curlSln() : var->curlSlnOld();
1093  else
1094  return (_c_is_implicit) ? var->curlSlnNeighbor() : var->curlSlnOldNeighbor();
1095 }
1096 
1097 const VectorVariableCurl &
1098 Coupleable::coupledCurlOld(const std::string & var_name, unsigned int comp)
1099 {
1100  if (!isCoupled(var_name)) // Return default 0
1101  return _default_vector_curl;
1102 
1103  coupledCallback(var_name, true);
1104  if (_c_nodal)
1105  mooseError("Nodal variables do not have curls");
1106 
1107  validateExecutionerType(var_name, "coupledCurlOld");
1108  VectorMooseVariable * var = getVectorVar(var_name, comp);
1109  if (var == NULL)
1110  mooseError("Call corresponding scalar field variable method");
1111 
1112  if (!_coupleable_neighbor)
1113  return (_c_is_implicit) ? var->curlSlnOld() : var->curlSlnOlder();
1114  else
1115  return (_c_is_implicit) ? var->curlSlnOldNeighbor() : var->curlSlnOlderNeighbor();
1116 }
1117 
1118 const VectorVariableCurl &
1119 Coupleable::coupledCurlOlder(const std::string & var_name, unsigned int comp)
1120 {
1121  if (!isCoupled(var_name)) // Return default 0
1122  return _default_vector_curl;
1123 
1124  coupledCallback(var_name, true);
1125  if (_c_nodal)
1126  mooseError("Nodal variables do not have curls");
1127 
1128  validateExecutionerType(var_name, "coupledCurlOlder");
1129  VectorMooseVariable * var = getVectorVar(var_name, comp);
1130  if (var == NULL)
1131  mooseError("Call corresponding scalar field variable method");
1132 
1133  if (_c_is_implicit)
1134  {
1135  if (!_coupleable_neighbor)
1136  return var->curlSlnOlder();
1137  else
1138  return var->curlSlnOlderNeighbor();
1139  }
1140  else
1141  mooseError("Older values not available for explicit schemes");
1142 }
1143 
1144 const VariableSecond &
1145 Coupleable::coupledSecond(const std::string & var_name, unsigned int comp)
1146 {
1147  checkVar(var_name);
1148  if (!isCoupled(var_name)) // Return default 0
1149  return _default_second;
1150 
1151  coupledCallback(var_name, false);
1152  if (_c_nodal)
1153  mooseError(_c_name, ": Nodal variables do not have second derivatives");
1154 
1155  MooseVariable * var = getVar(var_name, comp);
1156  if (var == NULL)
1157  mooseError("Call corresponding vector variable method");
1158 
1159  if (!_coupleable_neighbor)
1160  return (_c_is_implicit) ? var->secondSln() : var->secondSlnOlder();
1161  else
1162  return (_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOlderNeighbor();
1163 }
1164 
1165 const VariableSecond &
1166 Coupleable::coupledSecondOld(const std::string & var_name, unsigned int comp)
1167 {
1168  checkVar(var_name);
1169  if (!isCoupled(var_name)) // Return default 0
1170  return _default_second;
1171 
1172  coupledCallback(var_name, true);
1173  if (_c_nodal)
1174  mooseError(_c_name, ": Nodal variables do not have second derivatives");
1175 
1176  validateExecutionerType(var_name, "coupledSecondOld");
1177  MooseVariable * var = getVar(var_name, comp);
1178  if (var == NULL)
1179  mooseError("Call corresponding vector variable method");
1180  if (!_coupleable_neighbor)
1181  return (_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder();
1182  else
1183  return (_c_is_implicit) ? var->secondSlnOldNeighbor() : var->secondSlnOlderNeighbor();
1184 }
1185 
1186 const VariableSecond &
1187 Coupleable::coupledSecondOlder(const std::string & var_name, unsigned int comp)
1188 {
1189  checkVar(var_name);
1190  if (!isCoupled(var_name)) // Return default 0
1191  return _default_second;
1192 
1193  coupledCallback(var_name, true);
1194  if (_c_nodal)
1195  mooseError(_c_name, ": Nodal variables do not have second derivatives");
1196 
1197  validateExecutionerType(var_name, "coupledSecondOlder");
1198  MooseVariable * var = getVar(var_name, comp);
1199  if (var == NULL)
1200  mooseError("Call corresponding vector variable method");
1201  if (_c_is_implicit)
1202  {
1203  if (!_coupleable_neighbor)
1204  return var->secondSlnOlder();
1205  else
1206  return var->secondSlnOlderNeighbor();
1207  }
1208  else
1209  mooseError(_c_name, ": Older values not available for explicit schemes");
1210 }
1211 
1212 const VariableSecond &
1213 Coupleable::coupledSecondPreviousNL(const std::string & var_name, unsigned int comp)
1214 {
1215  checkVar(var_name);
1216  if (!isCoupled(var_name)) // Return default 0
1217  return _default_second;
1218 
1220  coupledCallback(var_name, true);
1221  if (_c_nodal)
1222  mooseError(_c_name, ": Nodal variables do not have second derivatives");
1223 
1224  MooseVariable * var = getVar(var_name, comp);
1225  if (var == NULL)
1226  mooseError("Call corresponding vector variable method");
1227  if (!_coupleable_neighbor)
1228  return var->secondSlnPreviousNL();
1229  else
1230  return var->secondSlnPreviousNLNeighbor();
1231 }
1232 
1233 template <typename T>
1234 const T &
1235 Coupleable::coupledNodalValue(const std::string & var_name, unsigned int comp)
1236 {
1237  checkVar(var_name);
1238  if (!isCoupled(var_name))
1239  return getNodalDefaultValue<T>(var_name, comp);
1240 
1241  coupledCallback(var_name, false);
1242  MooseVariableFE<T> * var = getVarHelper<T>(var_name, comp);
1243  if (var == NULL)
1244  mooseError("Call corresponding vector variable method");
1245  if (!var->isNodal())
1247  ": Trying to get nodal values of variable '",
1248  var->name(),
1249  "', but it is not nodal.");
1250 
1251  if (!_coupleable_neighbor)
1252  return (_c_is_implicit) ? var->nodalValue() : var->nodalValueOld();
1253  else
1254  return (_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor();
1255 }
1256 
1257 template <typename T>
1258 const T &
1259 Coupleable::coupledNodalValueOld(const std::string & var_name, unsigned int comp)
1260 {
1261  checkVar(var_name);
1262  if (!isCoupled(var_name))
1263  return getNodalDefaultValue<T>(var_name, comp);
1264 
1265  validateExecutionerType(var_name, "coupledNodalValueOld");
1266  coupledCallback(var_name, true);
1267  MooseVariableFE<T> * var = getVarHelper<T>(var_name, comp);
1268  if (var == NULL)
1269  mooseError("Call corresponding vector variable method");
1270  if (!var->isNodal())
1272  ": Trying to get old nodal values of variable '",
1273  var->name(),
1274  "', but it is not nodal.");
1275 
1276  if (!_coupleable_neighbor)
1277  return (_c_is_implicit) ? var->nodalValueOld() : var->nodalValueOlder();
1278  else
1280 }
1281 
1282 template <typename T>
1283 const T &
1284 Coupleable::coupledNodalValueOlder(const std::string & var_name, unsigned int comp)
1285 {
1286  checkVar(var_name);
1287  if (!isCoupled(var_name))
1288  return getNodalDefaultValue<T>(var_name, comp);
1289 
1290  validateExecutionerType(var_name, "coupledNodalValueOlder");
1291  coupledCallback(var_name, true);
1292  MooseVariableFE<T> * var = getVarHelper<T>(var_name, comp);
1293  if (var == NULL)
1294  mooseError("Call corresponding vector variable method");
1295  if (!var->isNodal())
1297  ": Trying to get older nodal values of variable '",
1298  var->name(),
1299  "', but it is not nodal.");
1300  if (_c_is_implicit)
1301  {
1302  if (!_coupleable_neighbor)
1303  return var->nodalValueOlder();
1304  else
1305  return var->nodalValueOlderNeighbor();
1306  }
1307  else
1308  mooseError(_c_name, ": Older values not available for explicit schemes");
1309 }
1310 
1311 template <typename T>
1312 const T &
1313 Coupleable::coupledNodalValuePreviousNL(const std::string & var_name, unsigned int comp)
1314 {
1315  checkVar(var_name);
1316  if (!isCoupled(var_name))
1317  return getNodalDefaultValue<T>(var_name, comp);
1318 
1320  coupledCallback(var_name, true);
1321  MooseVariableFE<T> * var = getVarHelper<T>(var_name, comp);
1322  if (var == NULL)
1323  mooseError("Call corresponding vector variable method");
1324 
1325  if (!_coupleable_neighbor)
1326  return var->nodalValuePreviousNL();
1327  else
1328  return var->nodalValuePreviousNLNeighbor();
1329 }
1330 
1331 template <typename T>
1332 const T &
1333 Coupleable::coupledNodalDot(const std::string & var_name, unsigned int comp)
1334 {
1335  checkVar(var_name);
1336  static const T zero = 0;
1337  if (!isCoupled(var_name)) // Return default 0
1338  return zero;
1339 
1340  validateExecutionerType(var_name, "coupledNodalDot");
1341  coupledCallback(var_name, false);
1342  MooseVariableFE<T> * var = getVarHelper<T>(var_name, comp);
1343  if (var == NULL)
1344  mooseError("Call corresponding vector variable method");
1345 
1346  if (!_coupleable_neighbor)
1347  return var->nodalValueDot();
1348  else
1349  mooseError("Neighbor version not implemented");
1350 }
1351 
1352 const VariableValue &
1353 Coupleable::coupledNodalDotDot(const std::string & var_name, unsigned int comp)
1354 {
1355  checkVar(var_name);
1356  if (!isCoupled(var_name)) // Return default 0
1357  return _default_value_zero;
1358 
1359  validateExecutionerType(var_name, "coupledNodalDotDot");
1360  coupledCallback(var_name, false);
1361  MooseVariable * var = getVar(var_name, comp);
1362  if (var == NULL)
1363  mooseError("Call corresponding vector variable method");
1364 
1365  if (!_coupleable_neighbor)
1366  return var->dofValuesDotDot();
1367  else
1368  return var->dofValuesDotDotNeighbor();
1369 }
1370 
1371 const VariableValue &
1372 Coupleable::coupledNodalDotOld(const std::string & var_name, unsigned int comp)
1373 {
1374  checkVar(var_name);
1375  if (!isCoupled(var_name)) // Return default 0
1376  return _default_value_zero;
1377 
1378  validateExecutionerType(var_name, "coupledNodalDotOld");
1379  coupledCallback(var_name, false);
1380  MooseVariable * var = getVar(var_name, comp);
1381  if (var == NULL)
1382  mooseError("Call corresponding vector variable method");
1383 
1384  if (!_coupleable_neighbor)
1385  return var->dofValuesDotOld();
1386  else
1387  return var->dofValuesDotOldNeighbor();
1388 }
1389 
1390 const VariableValue &
1391 Coupleable::coupledNodalDotDotOld(const std::string & var_name, unsigned int comp)
1392 {
1393  checkVar(var_name);
1394  if (!isCoupled(var_name)) // Return default 0
1395  return _default_value_zero;
1396 
1397  validateExecutionerType(var_name, "coupledNodalDotDotOld");
1398  coupledCallback(var_name, false);
1399  MooseVariable * var = getVar(var_name, comp);
1400  if (var == NULL)
1401  mooseError("Call corresponding vector variable method");
1402 
1403  if (!_coupleable_neighbor)
1404  return var->dofValuesDotDotOld();
1405  else
1406  return var->dofValuesDotDotOldNeighbor();
1407 }
1408 
1409 const VariableValue &
1410 Coupleable::coupledDofValues(const std::string & var_name, unsigned int comp)
1411 {
1412  checkVar(var_name);
1413 
1414  if (!isCoupled(var_name))
1415  return *getDefaultValue(var_name, comp);
1416 
1417  coupledCallback(var_name, false);
1418  MooseVariableFEBase * var = getFEVar(var_name, comp);
1419 
1420  if (!_coupleable_neighbor)
1421  return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
1422  else
1423  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
1424 }
1425 
1426 const VariableValue &
1427 Coupleable::coupledDofValuesOld(const std::string & var_name, unsigned int comp)
1428 {
1429  checkVar(var_name);
1430 
1431  if (!isCoupled(var_name))
1432  return *getDefaultValue(var_name, comp);
1433 
1434  validateExecutionerType(var_name, "coupledDofValuesOld");
1435  coupledCallback(var_name, true);
1436  MooseVariableFEBase * var = getFEVar(var_name, comp);
1437 
1438  if (!_coupleable_neighbor)
1439  return (_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
1440  else
1441  return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
1442 }
1443 
1444 const VariableValue &
1445 Coupleable::coupledDofValuesOlder(const std::string & var_name, unsigned int comp)
1446 {
1447  checkVar(var_name);
1448 
1449  if (!isCoupled(var_name))
1450  return *getDefaultValue(var_name, comp);
1451 
1452  validateExecutionerType(var_name, "coupledDofValuesOlder");
1453  coupledCallback(var_name, true);
1454  MooseVariableFEBase * var = getFEVar(var_name, comp);
1455  if (_c_is_implicit)
1456  {
1457  if (!_coupleable_neighbor)
1458  return var->dofValuesOlder();
1459  else
1460  return var->dofValuesOlderNeighbor();
1461  }
1462  else
1463  mooseError(_c_name, ": Older values not available for explicit schemes");
1464 }
1465 
1466 void
1467 Coupleable::validateExecutionerType(const std::string & name, const std::string & fn_name) const
1468 {
1469  if (!_c_fe_problem.isTransient())
1471  ": Calling '",
1472  fn_name,
1473  "' on variable \"",
1474  name,
1475  "\" when using a \"Steady\" executioner is not allowed. This value is available "
1476  "only in transient simulations.");
1477 }
1478 
1479 template <>
1480 VariableValue *
1481 Coupleable::getADDefaultValue<RESIDUAL>(const std::string & var_name)
1482 {
1483  return getDefaultValue(var_name, 0);
1484 }
1485 
1486 template <>
1488 Coupleable::getADDefaultVectorValue<RESIDUAL>(const std::string & var_name)
1489 {
1490  return getDefaultVectorValue(var_name);
1491 }
1492 
1493 template <>
1495 Coupleable::getADDefaultGradient<RESIDUAL>()
1496 {
1497  return _default_gradient;
1498 }
1499 
1500 template <>
1502 Coupleable::getADDefaultVectorGradient<RESIDUAL>()
1503 {
1504  return _default_vector_gradient;
1505 }
1506 
1507 template <>
1509 Coupleable::getADDefaultSecond<RESIDUAL>()
1510 {
1511  return _default_second;
1512 }
1513 
1514 template <>
1515 const VariableValue &
1516 Coupleable::adZeroValueTemplate<RESIDUAL>()
1517 {
1518  return _zero;
1519 }
1520 
1521 template <>
1522 const VariableGradient &
1523 Coupleable::adZeroGradientTemplate<RESIDUAL>()
1524 {
1525  return _grad_zero;
1526 }
1527 
1528 template <>
1529 const VariableSecond &
1530 Coupleable::adZeroSecondTemplate<RESIDUAL>()
1531 {
1532  return _second_zero;
1533 }
1534 
1535 template <typename T, ComputeStage compute_stage>
1537 Coupleable::adCoupledNodalValueTemplate(const std::string & var_name, unsigned int comp)
1538 {
1539  static const typename Moose::ValueType<T, compute_stage>::type zero = 0;
1540  if (!isCoupled(var_name))
1541  return zero;
1542 
1543  if (!_c_nodal)
1544  mooseError("The adCoupledNodalValue method should only be called for nodal computing objects");
1546  mooseError(
1547  "The adCoupledNodalValue method shouldn't be called for neighbor computing objects. I "
1548  "don't even know what that would mean, although maybe someone could explain it to me.");
1549  if (!_c_is_implicit)
1550  mooseError("If you're going to use an explicit scheme, then use coupledNodalValue instead of "
1551  "adCoupledNodalValue");
1552 
1553  coupledCallback(var_name, false);
1554  MooseVariableFE<T> * var = getVarHelper<T>(var_name, comp);
1555 
1556  return var->template adNodalValue<compute_stage>();
1557 }
1558 
1559 // Explicit instantiations
1560 
1561 template const Real & Coupleable::getNodalDefaultValue<Real>(const std::string & var_name,
1562  unsigned int comp);
1563 
1564 template MooseVariableFE<Real> * Coupleable::getVarHelper<Real>(const std::string & var_name,
1565  unsigned int comp);
1566 
1568 Coupleable::getVarHelper<RealVectorValue>(const std::string & var_name, unsigned int comp);
1569 
1570 template const Real & Coupleable::coupledNodalValue<Real>(const std::string & var_name,
1571  unsigned int comp);
1572 template const RealVectorValue &
1573 Coupleable::coupledNodalValue<RealVectorValue>(const std::string & var_name, unsigned int comp);
1574 template const Real & Coupleable::coupledNodalValueOld<Real>(const std::string & var_name,
1575  unsigned int comp);
1576 template const RealVectorValue &
1577 Coupleable::coupledNodalValueOld<RealVectorValue>(const std::string & var_name, unsigned int comp);
1578 template const Real & Coupleable::coupledNodalValueOlder<Real>(const std::string & var_name,
1579  unsigned int comp);
1580 template const RealVectorValue &
1581 Coupleable::coupledNodalValueOlder<RealVectorValue>(const std::string & var_name,
1582  unsigned int comp);
1583 template const Real & Coupleable::coupledNodalValuePreviousNL<Real>(const std::string & var_name,
1584  unsigned int comp);
1585 template const RealVectorValue &
1586 Coupleable::coupledNodalValuePreviousNL<RealVectorValue>(const std::string & var_name,
1587  unsigned int comp);
1588 template const Real & Coupleable::coupledNodalDot<Real>(const std::string & var_name,
1589  unsigned int comp);
1590 template const RealVectorValue &
1591 Coupleable::coupledNodalDot<RealVectorValue>(const std::string & var_name, unsigned int comp);
1592 
1593 template const Real &
1594 Coupleable::adCoupledNodalValueTemplate<Real, RESIDUAL>(const std::string & var_name,
1595  unsigned int comp);
1596 template const RealVectorValue &
1597 Coupleable::adCoupledNodalValueTemplate<RealVectorValue, RESIDUAL>(const std::string & var_name,
1598  unsigned int comp);
1599 template const DualReal &
1600 Coupleable::adCoupledNodalValueTemplate<Real, JACOBIAN>(const std::string & var_name,
1601  unsigned int comp);
1602 template const libMesh::VectorValue<DualReal> &
1603 Coupleable::adCoupledNodalValueTemplate<RealVectorValue, JACOBIAN>(const std::string & var_name,
1604  unsigned int comp);
const MooseArray< Number > & dofValuesDotDotOldNeighbor() override
Returns old second time derivative of neighboring degrees of freedom.
OutputTools< Real >::VariableGradient VariableGradient
Definition: MooseTypes.h:198
void validateExecutionerType(const std::string &name, const std::string &fn_name) const
Checks to make sure that the current Executioner has set "_is_transient" when old/older values are co...
Definition: Coupleable.C:1467
virtual const VariableValue & coupledDotDotDu(const std::string &var_name, unsigned int comp=0)
Second time derivative of a coupled variable with respect to the coefficients.
Definition: Coupleable.C:866
const FieldVariableValue & uDotDotNeighbor() const
const FieldVariableCurl & curlSlnNeighbor() const
neighbor solution curls
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:749
const MooseArray< Number > & dofValuesDot() override
Returns time derivative of degrees of freedom.
VectorVariableCurl _default_vector_curl
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:818
const FieldVariableSecond & secondSlnOlderNeighbor() const
VectorMooseVariable * getVectorVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled vector variable.
Definition: Coupleable.C:247
const MooseArray< Number > & dofValuesOlder() override
Returns older dof solution on element.
bool hasCoupledValue(const std::string &coupling_name) const
Return whether or not the coupled variable exists.
const OutputType & nodalValuePreviousNL()
const T & coupledNodalValueOld(const std::string &var_name, unsigned int comp=0)
Returns an old nodal value from previous time step of a coupled variable.
Definition: Coupleable.C:1259
MooseVariableFE< T > * getVarHelper(const std::string &var_name, unsigned int comp)
Helper that segues off to either getVar of getVectorVar depending on template paramter.
Definition: Coupleable.C:214
virtual const VariableValue & coupledMatrixTagValue(const std::string &var_name, TagID tag, unsigned int comp=0)
Returns value of a coupled variable for a given tag.
Definition: Coupleable.C:406
unsigned int coupledComponents(const std::string &var_name)
Number of coupled components.
Definition: Coupleable.C:166
virtual const VariableValue & coupledDotOld(const std::string &var_name, unsigned int comp=0)
Old time derivative of a coupled variable.
Definition: Coupleable.C:676
const FieldVariableGradient & gradSlnPreviousNL() const
MooseArray< DualRealTensorValue > _ad_default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:788
virtual const VariableValue & coupledVectorTagValue(const std::string &var_name, TagID tag, unsigned int comp=0)
Returns value of a coupled variable for a given tag.
Definition: Coupleable.C:388
const MooseArray< Number > & dofValuesDotOld() override
Returns old time derivative of degrees of freedom.
unsigned int TagID
Definition: MooseTypes.h:162
const OutputType & nodalValueOlderNeighbor()
const FieldVariableSecond & secondSlnPreviousNLNeighbor() const
const FieldVariableCurl & curlSlnOldNeighbor() const
const MooseArray< Number > & dofValuesDotDot() override
Returns second time derivative of degrees of freedom.
VectorValue< Real > RealVectorValue
Definition: Assembly.h:31
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
unsigned int number() const
Get variable number coming from libMesh.
void resize(unsigned int size)
Change the number of elements the array can store.
Definition: MooseArray.h:218
MooseArray< DualRealTensorValue > _ad_default_vector_gradient
This will always be zero because the default values for optionally coupled vector variables is always...
Definition: Coupleable.h:782
const FieldVariableGradient & gradSlnNeighborDotDot() const
virtual const VariableValue & coupledNodalDotDotOld(const std::string &var_name, unsigned int comp=0)
Nodal values of old second time derivative of a coupled variable.
Definition: Coupleable.C:1391
virtual const VectorVariableValue & coupledVectorDot(const std::string &var_name, unsigned int comp=0)
Time derivative of a coupled vector variable.
Definition: Coupleable.C:728
virtual const VariableValue & coupledDotDotOld(const std::string &var_name, unsigned int comp=0)
Old second time derivative of a coupled variable.
Definition: Coupleable.C:702
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:219
const VariableValue & duDotDuNeighbor() const
const OutputType & nodalValueOld()
OutputTools< RealVectorValue >::VariableValue VectorVariableValue
Definition: MooseTypes.h:211
const FieldVariableSecond & secondSlnOld() const
virtual MooseVariableFEBase & getVariable(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)=0
Returns the variable reference for requested variable which must be of the expected_var_type (Nonline...
const FieldVariableValue & slnOlderNeighbor() const
virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, const std::string &var_name)=0
Returns the scalar variable reference from whichever system contains it.
T getCheckedPointerParam(const std::string &name, const std::string &error_string="") const
Verifies that the requested parameter exists and is not NULL and returns it to the caller...
THREAD_ID _c_tid
Thread ID of the thread using this object.
Definition: Coupleable.h:755
const T & coupledNodalValueOlder(const std::string &var_name, unsigned int comp=0)
Returns an old nodal value from two time steps previous of a coupled variable.
Definition: Coupleable.C:1284
DualNumber< Real, NumberArray< AD_MAX_DOFS_PER_ELEM, Real > > DualReal
Definition: DualReal.h:29
const FieldVariableGradient & gradSlnPreviousNLNeighbor() const
std::set< std::string >::const_iterator coupledVarsBegin() const
Methods returning iterators to the coupled variables names stored in this InputParameters object...
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:773
virtual const VariableValue & coupledDofValuesOld(const std::string &var_name, unsigned int comp=0)
Returns DoFs in the old solution vector of a coupled variable for the local element.
Definition: Coupleable.C:1427
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:241
OutputTools< RealVectorValue >::VariableCurl VectorVariableCurl
Definition: MooseTypes.h:214
const FieldVariableValue & uDotOld() const
virtual const VariableValue & coupledValuePreviousNL(const std::string &var_name, unsigned int comp=0)
Returns value of previous Newton iterate of a coupled variable.
Definition: Coupleable.C:531
virtual const VariableValue & coupledNodalDotOld(const std::string &var_name, unsigned int comp=0)
Nodal values of old time derivative of a coupled variable.
Definition: Coupleable.C:1372
const FieldVariableValue & sln() const
element solutions
virtual const VariableGradient & coupledGradientDotDot(const std::string &var_name, unsigned int comp=0)
Second time derivative of the gradient of a coupled variable.
Definition: Coupleable.C:995
VectorVariableValue * getDefaultVectorValue(const std::string &var_name)
Helper method to return (and insert if necessary) the default value for an uncoupled vector variable...
Definition: Coupleable.C:310
std::map< std::string, MooseArray< DualRealVectorValue > * > _ad_default_vector_value
Will hold the default value for optional vector coupled variables for automatic differentiation.
Definition: Coupleable.h:767
const OutputType & nodalValuePreviousNLNeighbor()
virtual VariableValue & writableCoupledValue(const std::string &var_name, unsigned int comp=0)
Returns a writable reference to a coupled variable.
Definition: Coupleable.C:451
virtual const VariableSecond & coupledSecondOlder(const std::string &var_name, unsigned int comp=0)
Returns an old second derivative from two time steps previous of a coupled variable.
Definition: Coupleable.C:1187
const FieldVariableCurl & curlSlnOld() const
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
VariableValue * getDefaultValue(const std::string &var_name, unsigned int comp)
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:283
const FieldVariableGradient & gradSlnOlderNeighbor() const
virtual const VectorVariableCurl & coupledCurlOlder(const std::string &var_name, unsigned int comp=0)
Returns an old curl from two time steps previous of a coupled variable.
Definition: Coupleable.C:1119
virtual const MooseArray< Number > & dofValuesOlderNeighbor()=0
Returns older dof solution on neighbor element.
const FieldVariableSecond & secondSlnOldNeighbor() const
std::vector< MooseVariable * > _coupled_standard_moose_vars
Vector of standard coupled variables.
Definition: Coupleable.h:743
const FieldVariableGradient & gradSlnOldNeighbor() const
unsigned int numberDefaultCoupledValues(const std::string &coupling_name) const
Get the number of defaulted coupled value entries.
Coupleable(const MooseObject *moose_object, bool nodal)
Constructing the object.
Definition: Coupleable.C:19
const FieldVariableValue & uDot() const
element dots
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:734
const FieldVariableCurl & curlSln() const
element curls
const MooseArray< Number > & dofValuesDotDotOld() override
Returns old second time derivative of degrees of freedom.
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:752
const VariableValue & duDotDotDu() const
const T & coupledNodalDot(const std::string &var_name, unsigned int comp=0)
Nodal values of time derivative of a coupled variable.
Definition: Coupleable.C:1333
virtual bool isCoupled(const std::string &var_name, unsigned int i=0)
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:144
const FieldVariableValue & vectorTagValue(TagID tag)
virtual const VectorVariableCurl & coupledCurlOld(const std::string &var_name, unsigned int comp=0)
Returns an old curl from previous time step of a coupled variable.
Definition: Coupleable.C:1098
const OutputType & nodalValueDot()
const FieldVariableValue & uDotDotOldNeighbor() const
std::vector< VectorMooseVariable * > _coupled_vector_moose_vars
Vector of vector coupled variables.
Definition: Coupleable.h:746
const MooseArray< Number > & dofValuesPreviousNL() override
Returns previous nl solution on element.
const T & coupledNodalValue(const std::string &var_name, unsigned int comp=0)
Returns nodal values of a coupled variable.
Definition: Coupleable.C:1235
std::map< std::string, std::vector< VariableValue * > > _default_value
Will hold the default value for optional coupled variables.
Definition: Coupleable.h:758
virtual void coupledCallback(const std::string &var_name, bool is_old)
Definition: Coupleable.C:139
const OutputType & nodalValueNeighbor()
const MooseArray< Number > & dofValuesDotDotNeighbor() override
Returns second time derivative of neighboring degrees of freedom.
std::map< std::string, std::vector< MooseVariableScalar * > > _c_coupled_scalar_vars
Scalar variables coupled into this object (for error checking)
Definition: Coupleable.h:939
virtual const MooseArray< Number > & dofValues()=0
Returns dof solution on element.
const FieldVariableSecond & secondSlnPreviousNL() const
void addFEVariableCoupleableVectorTag(TagID tag)
Definition: Coupleable.h:113
std::set< std::string >::const_iterator coupledVarsEnd() const
virtual const MooseArray< Number > & dofValuesOld()=0
Returns old dof solution on element.
const MooseArray< Number > & dofValuesDotNeighbor() override
Returns time derivative of neighboring degrees of freedom.
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:42
const Moose::ValueType< T, compute_stage >::type & adCoupledNodalValueTemplate(const std::string &var_name, unsigned int comp=0)
Returns AD nodal values of a coupled variable.
Definition: Coupleable.C:1537
const FieldVariableValue & slnPreviousNL() const
const FieldVariableValue & uDotDot() const
bool hasDefaultCoupledValue(const std::string &coupling_name) const
Return whether or not the requested parameter has a default coupled value.
const FieldVariableSecond & secondSlnNeighbor() const
neighbor solution seconds
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:776
std::map< std::string, VectorVariableValue * > _default_vector_value
Will hold the default value for optional vector coupled variables.
Definition: Coupleable.h:764
const FieldVariableValue & slnOld() const
Real defaultCoupledValue(const std::string &coupling_name, unsigned int i=0) const
Get the default value for an optionally coupled variable.
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:785
const MooseArray< Number > & dofValuesOld() override
Returns old dof solution on element.
virtual const VectorVariableCurl & coupledCurl(const std::string &var_name, unsigned int comp=0)
Returns curl of a coupled variable.
Definition: Coupleable.C:1078
virtual const VariableGradient & coupledGradientOlder(const std::string &var_name, unsigned int comp=0)
Returns an old gradient from two time steps previous of a coupled variable.
Definition: Coupleable.C:931
const FieldVariableSecond & secondSlnOlder() const
MooseArray< DualRealVectorValue > _ad_default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:779
const FieldVariableValue & uDotDotOld() const
void needsPreviousNewtonIteration(bool state)
Set a flag that indicated that user required values for the previous Newton iterate.
virtual ~Coupleable()
Destructor for object.
Definition: Coupleable.C:103
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 MooseArray< Number > & dofValuesDotOldNeighbor() override
Returns old time derivative of neighboring degrees of freedom.
std::map< std::string, std::vector< MooseVariableFEBase * > > _coupled_vars
Coupled vars whose values we provide.
Definition: Coupleable.h:737
const std::string & _c_name
The name of the object this interface is part of.
Definition: Coupleable.h:731
virtual const VariableValue & coupledDofValues(const std::string &var_name, unsigned int comp=0)
Returns DoFs in the current solution vector of a coupled variable for the local element.
Definition: Coupleable.C:1410
virtual const VectorVariableGradient & coupledVectorGradientOlder(const std::string &var_name, unsigned int comp=0)
Returns an old gradient from two time steps previous of a coupled vector variable.
Definition: Coupleable.C:1053
const OutputType & nodalValue()
Methods for retrieving values of variables at the nodes.
const FieldVariableGradient & gradSlnOld() const
const FieldVariableValue & uDotNeighbor() const
neighbor dots
const OutputType & nodalValueOldNeighbor()
virtual const VariableValue & coupledValue(const std::string &var_name, unsigned int comp=0)
Returns value of a coupled variable.
Definition: Coupleable.C:361
virtual bool hasVariable(const std::string &var_name) const =0
const FieldVariableValue & slnNeighbor() const
neighbor solutions
const FieldVariableSecond & secondSln() const
element seconds
const MooseArray< Number > & dofValuesPreviousNLNeighbor() override
Returns previous nl solution on neighbor element.
bool isNodal() const override
Is this variable nodal.
const MooseArray< Number > & dofValuesDuDotDu() override
Returns derivative of time derivative of degrees of freedom.
const T & coupledNodalValuePreviousNL(const std::string &var_name, unsigned int comp=0)
Returns nodal values of a coupled variable for previous Newton iterate.
Definition: Coupleable.C:1313
VectorVariableGradient _default_vector_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:815
const T & getNodalDefaultValue(const std::string &var_name, unsigned int comp=0)
Get nodal default value.
Definition: Coupleable.C:346
OutputTools< Real >::VariableValue VariableValue
Definition: MooseTypes.h:197
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:866
std::map< std::string, MooseArray< DualReal > * > _ad_default_value
Will hold the default value for optional coupled variables for automatic differentiation.
Definition: Coupleable.h:761
virtual const VariableValue & coupledValueOld(const std::string &var_name, unsigned int comp=0)
Returns an old value from previous time step of a coupled variable.
Definition: Coupleable.C:457
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:59
const FieldVariableGradient & gradSlnNeighborDot() const
neighbor grad dots
VectorVariableValue _default_vector_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:812
const FieldVariableGradient & gradSlnDotDot() const
virtual const VariableValue & coupledDofValuesOlder(const std::string &var_name, unsigned int comp=0)
Returns DoFs in the older solution vector of a coupled variable for the local element.
Definition: Coupleable.C:1445
virtual const VariableValue & coupledDotDot(const std::string &var_name, unsigned int comp=0)
Second time derivative of a coupled variable.
Definition: Coupleable.C:650
virtual const VectorVariableValue & coupledVectorDotOld(const std::string &var_name, unsigned int comp=0)
Old time derivative of a coupled vector variable.
Definition: Coupleable.C:784
const FieldVariableCurl & curlSlnOlder() const
const MooseArray< Number > & dofValuesNeighbor() override
Returns dof solution on neighbor element.
void release()
Manually deallocates the data pointer.
Definition: MooseArray.h:61
const MooseArray< Number > & dofValuesDuDotDuNeighbor() override
Returns derivative of time derivative of neighboring degrees of freedom.
const std::string & name() const
Get the variable name.
const FieldVariableValue & matrixTagValue(TagID tag)
Moose::VarKindType kind() const
Kind of the variable (Nonlinear, Auxiliary, ...)
virtual const VariableGradient & coupledGradient(const std::string &var_name, unsigned int comp=0)
Returns gradient of a coupled variable.
Definition: Coupleable.C:892
const MooseArray< Number > & dofValuesDuDotDotDu() override
Returns derivative of second time derivative of degrees of freedom.
std::vector< MooseVariableFEBase * > _coupled_moose_vars
Vector of all coupled variables.
Definition: Coupleable.h:740
virtual const VectorVariableValue & coupledVectorValue(const std::string &var_name, unsigned int comp=0)
Returns value of a coupled vector variable.
Definition: Coupleable.C:424
const FieldVariableValue & uDotOldNeighbor() const
virtual const VariableSecond & coupledSecond(const std::string &var_name, unsigned int comp=0)
Returns second derivative of a coupled variable.
Definition: Coupleable.C:1145
const FieldVariableValue & slnOldNeighbor() const
virtual const VectorVariableValue & coupledVectorDotDot(const std::string &var_name, unsigned int comp=0)
Second time derivative of a coupled vector variable.
Definition: Coupleable.C:756
const VariableValue & duDotDu() const
Class for scalar variables (they are different).
const MooseArray< Number > & dofValuesDuDotDotDuNeighbor() override
Returns derivative of second time derivative of neighboring degrees of freedom.
virtual const VectorVariableValue & coupledVectorValueOld(const std::string &var_name, unsigned int comp=0)
Returns an old value from previous time step of a coupled vector variable.
Definition: Coupleable.C:558
virtual const VariableGradient & coupledGradientPreviousNL(const std::string &var_name, unsigned int comp=0)
Returns gradient of a coupled variable for previous Newton iterate.
Definition: Coupleable.C:956
const FieldVariableGradient & gradSlnOlder() const
const InputParameters & _c_parameters
Definition: Coupleable.h:728
OutputTools< Real >::VariableSecond VariableSecond
Definition: MooseTypes.h:199
const FieldVariableValue & slnOlder() const
const MooseArray< Number > & dofValuesOlderNeighbor() override
Returns older dof solution on neighbor element.
const FieldVariableGradient & gradSlnDot() const
element gradient dots
std::map< std::string, std::vector< unsigned int > > _optional_var_index
Unique indices for optionally coupled vars that weren&#39;t provided.
Definition: Coupleable.h:936
OutputTools< RealVectorValue >::VariableGradient VectorVariableGradient
Definition: MooseTypes.h:212
virtual const VariableSecond & coupledSecondOld(const std::string &var_name, unsigned int comp=0)
Returns an old second derivative from previous time step of a coupled variable.
Definition: Coupleable.C:1166
virtual bool isTransient() const override
const FieldVariableCurl & curlSlnOlderNeighbor() const
virtual const VariableSecond & coupledSecondPreviousNL(const std::string &var_name, unsigned int comp=0)
Returns second derivative of a coupled variable for the previous Newton iterate.
Definition: Coupleable.C:1213
const MooseArray< Real > & nodalVectorTagValue(TagID tag)
virtual const VariableValue & coupledDotDu(const std::string &var_name, unsigned int comp=0)
Time derivative of a coupled variable with respect to the coefficients.
Definition: Coupleable.C:840
virtual const VectorVariableValue & coupledVectorDotDotOld(const std::string &var_name, unsigned int comp=0)
Old second time derivative of a coupled vector variable.
Definition: Coupleable.C:812
virtual const VariableGradient & coupledGradientDot(const std::string &var_name, unsigned int comp=0)
Time derivative of the gradient of a coupled variable.
Definition: Coupleable.C:976
const MooseArray< Number > & dofValuesOldNeighbor() override
Returns old dof solution on neighbor element.
const FieldVariableGradient & gradSlnNeighbor() const
neighbor solution gradients
unsigned int _coupleable_max_qps
Maximum qps for any element in this system.
Definition: Coupleable.h:933
virtual const VariableValue & coupledDot(const std::string &var_name, unsigned int comp=0)
Time derivative of a coupled variable.
Definition: Coupleable.C:624
void addFEVariableCoupleableMatrixTag(TagID tag)
Definition: Coupleable.h:115
void checkVar(const std::string &var_name)
Check that the right kind of variable is being coupled in.
Definition: Coupleable.C:180
virtual const VectorVariableGradient & coupledVectorGradient(const std::string &var_name, unsigned int comp=0)
Returns gradient of a coupled vector variable.
Definition: Coupleable.C:1014
std::vector< std::string > getVecMooseType(const std::string &name) const
virtual const MooseArray< Number > & dofValuesOldNeighbor()=0
Returns old dof solution on neighbor element.
virtual const VectorVariableGradient & coupledVectorGradientOld(const std::string &var_name, unsigned int comp=0)
Returns an old gradient from previous time step of a coupled vector variable.
Definition: Coupleable.C:1033
const OutputType & nodalValueOlder()
virtual const VariableValue & coupledNodalDotDot(const std::string &var_name, unsigned int comp=0)
Nodal values of second time derivative of a coupled variable.
Definition: Coupleable.C:1353
virtual const MooseArray< Number > & dofValuesOlder()=0
Returns older dof solution on element.
virtual const VariableGradient & coupledGradientOld(const std::string &var_name, unsigned int comp=0)
Returns an old gradient from previous time step of a coupled variable.
Definition: Coupleable.C:911
virtual unsigned int coupled(const std::string &var_name, unsigned int comp=0)
Returns the index for a coupled variable by name.
Definition: Coupleable.C:253
const FieldVariableGradient & gradSln() const
element gradients
const FieldVariableValue & slnPreviousNLNeighbor() const
virtual const VariableValue & coupledValueOlder(const std::string &var_name, unsigned int comp=0)
Returns an old value from two time steps previous of a coupled variable.
Definition: Coupleable.C:484
virtual const VectorVariableValue & coupledVectorValueOlder(const std::string &var_name, unsigned int comp=0)
Returns an old value from two time steps previous of a coupled vector variable.
Definition: Coupleable.C:586
MooseVariableFEBase * getFEVar(const std::string &var_name, unsigned int comp)
Extract pointer to a base finite element coupled variable.
Definition: Coupleable.C:199
unsigned int THREAD_ID
Definition: MooseTypes.h:161
const MooseArray< Real > & nodalMatrixTagValue(TagID tag)
virtual const MooseArray< Number > & dofValuesNeighbor()=0
Returns dof solution on neighbor element.
const MooseArray< Number > & dofValues() override
Returns dof solution on element.