https://mooseframework.inl.gov
SystemBase.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "MooseApp.h"
11 #include "SystemBase.h"
12 #include "Factory.h"
13 #include "SubProblem.h"
14 #include "MooseVariableFE.h"
15 #include "MooseVariableFV.h"
16 #include "MooseVariableScalar.h"
18 #include "Conversion.h"
19 #include "Parser.h"
21 #include "MooseTypes.h"
22 #include "InitialCondition.h"
23 #include "ScalarInitialCondition.h"
24 #include "Assembly.h"
25 #include "MooseMesh.h"
26 #include "MooseUtils.h"
27 #include "FVBoundaryCondition.h"
28 #include "FEProblemBase.h"
29 #include "TimeIntegrator.h"
30 
31 #include "libmesh/dof_map.h"
32 #include "libmesh/string_to_enum.h"
33 #include "libmesh/fe_interface.h"
34 #include "libmesh/static_condensation.h"
35 
36 using namespace libMesh;
37 
39 void
40 extraSendList(std::vector<dof_id_type> & send_list, void * context)
41 {
42  SystemBase * sys = static_cast<SystemBase *>(context);
43  sys->augmentSendList(send_list);
44 }
45 
47 void
49  std::vector<dof_id_type> & n_nz,
50  std::vector<dof_id_type> & n_oz,
51  void * context)
52 {
53  SystemBase * sys = static_cast<SystemBase *>(context);
54  sys->augmentSparsity(sparsity, n_nz, n_oz);
55 }
56 
58  FEProblemBase & fe_problem,
59  const std::string & name,
60  Moose::VarKindType var_kind)
61  : libMesh::ParallelObject(subproblem),
62  ConsoleStreamInterface(subproblem.getMooseApp()),
63  _subproblem(subproblem),
64  _fe_problem(fe_problem),
65  _app(subproblem.getMooseApp()),
66  _factory(_app.getFactory()),
67  _mesh(subproblem.mesh()),
68  _name(name),
69  _vars(libMesh::n_threads()),
70  _var_map(),
71  _max_var_number(0),
72  _u_dot(nullptr),
73  _u_dotdot(nullptr),
74  _u_dot_old(nullptr),
75  _u_dotdot_old(nullptr),
76  _saved_old(nullptr),
77  _saved_older(nullptr),
78  _saved_dot_old(nullptr),
79  _saved_dotdot_old(nullptr),
80  _var_kind(var_kind),
81  _max_var_n_dofs_per_elem(0),
82  _max_var_n_dofs_per_node(0),
83  _automatic_scaling(false),
84  _verbose(false),
85  _solution_states_initialized(false)
86 {
87 }
88 
90 SystemBase::getVariable(THREAD_ID tid, const std::string & var_name) const
91 {
93  dynamic_cast<MooseVariableFieldBase *>(_vars[tid].getVariable(var_name));
94  if (!var)
95  mooseError("Variable '", var_name, "' does not exist in this system");
96  return *var;
97 }
98 
100 SystemBase::getVariable(THREAD_ID tid, unsigned int var_number) const
101 {
102  if (var_number < _numbered_vars[tid].size())
103  if (_numbered_vars[tid][var_number])
104  return *_numbered_vars[tid][var_number];
105 
106  mooseError("Variable #", Moose::stringify(var_number), " does not exist in this system");
107 }
108 
109 template <typename T>
111 SystemBase::getFieldVariable(THREAD_ID tid, const std::string & var_name)
112 {
113  return *_vars[tid].getFieldVariable<T>(var_name);
114 }
115 
116 template <typename T>
118 SystemBase::getActualFieldVariable(THREAD_ID tid, const std::string & var_name)
119 {
120  return *_vars[tid].getActualFieldVariable<T>(var_name);
121 }
122 
123 template <typename T>
125 SystemBase::getFVVariable(THREAD_ID tid, const std::string & var_name)
126 {
127  return *_vars[tid].getFVVariable<T>(var_name);
128 }
129 
130 template <typename T>
132 SystemBase::getFieldVariable(THREAD_ID tid, unsigned int var_number)
133 {
134  return *_vars[tid].getFieldVariable<T>(var_number);
135 }
136 
137 template <typename T>
139 SystemBase::getActualFieldVariable(THREAD_ID tid, unsigned int var_number)
140 {
141  return *_vars[tid].getActualFieldVariable<T>(var_number);
142 }
143 
145 SystemBase::getScalarVariable(THREAD_ID tid, const std::string & var_name) const
146 {
147  MooseVariableScalar * var = dynamic_cast<MooseVariableScalar *>(_vars[tid].getVariable(var_name));
148  if (!var)
149  mooseError("Scalar variable '" + var_name + "' does not exist in this system");
150  return *var;
151 }
152 
154 SystemBase::getScalarVariable(THREAD_ID tid, unsigned int var_number) const
155 {
156  MooseVariableScalar * var =
157  dynamic_cast<MooseVariableScalar *>(_vars[tid].getVariable(var_number));
158  if (!var)
159  mooseError("variable #" + Moose::stringify(var_number) + " does not exist in this system");
160  return *var;
161 }
162 
163 const std::set<SubdomainID> *
164 SystemBase::getVariableBlocks(unsigned int var_number)
165 {
166  mooseAssert(_var_map.find(var_number) != _var_map.end(), "Variable does not exist.");
167  if (_var_map[var_number].empty())
168  return nullptr;
169  else
170  return &_var_map[var_number];
171 }
172 
173 void
175 {
176  _vars_to_be_zeroed_on_residual.push_back(var_name);
177 }
178 
179 void
181 {
182  _vars_to_be_zeroed_on_jacobian.push_back(var_name);
183 }
184 
185 void
186 SystemBase::setVariableGlobalDoFs(const std::string & var_name)
187 {
188  AllLocalDofIndicesThread aldit(_subproblem, {var_name});
190  Threads::parallel_reduce(elem_range, aldit);
191 
192  // Gather the dof indices across procs to get all the dof indices for var_name
193  aldit.dofIndicesSetUnion();
194 
195  const auto & all_dof_indices = aldit.getDofIndices();
196  _var_all_dof_indices.assign(all_dof_indices.begin(), all_dof_indices.end());
197 }
198 
199 void
200 SystemBase::zeroVariables(std::vector<std::string> & vars_to_be_zeroed)
201 {
202  if (vars_to_be_zeroed.size() > 0)
203  {
205 
206  auto problem = dynamic_cast<FEProblemBase *>(&_subproblem);
207  if (!problem)
208  mooseError("System needs to be registered in FEProblemBase for using zeroVariables.");
209 
210  AllLocalDofIndicesThread aldit(*problem, vars_to_be_zeroed, true);
212  Threads::parallel_reduce(elem_range, aldit);
213 
214  const auto & dof_indices_to_zero = aldit.getDofIndices();
215 
216  solution.close();
217 
218  for (const auto & dof : dof_indices_to_zero)
219  solution.set(dof, 0);
220 
221  solution.close();
222 
223  // Call update to update the current_local_solution for this system
224  system().update();
225  }
226 }
227 
228 void
230 {
232 }
233 
234 void
236 {
238 }
239 
240 Order
242 {
243  Order order = CONSTANT;
244  const std::vector<MooseVariableFieldBase *> & vars = _vars[0].fieldVariables();
245  for (const auto & var : vars)
246  {
247  FEType fe_type = var->feType();
248  if (fe_type.default_quadrature_order() > order)
249  order = fe_type.default_quadrature_order();
250  }
251 
252  return order;
253 }
254 
255 void
257 {
259  {
260  const std::set<MooseVariableFieldBase *> & active_elemental_moose_variables =
262  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
263  for (const auto & var : vars)
264  var->clearDofIndices();
265 
266  for (const auto & var : active_elemental_moose_variables)
267  if (&(var->sys()) == this)
268  var->prepare();
269  }
270  else
271  {
272  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
273  for (const auto & var : vars)
274  var->prepare();
275  }
276 }
277 
278 void
279 SystemBase::prepareFace(THREAD_ID tid, bool resize_data)
280 {
281  // We only need to do something if the element prepare was restricted
283  {
284  const std::set<MooseVariableFieldBase *> & active_elemental_moose_variables =
286 
287  std::vector<MooseVariableFieldBase *> newly_prepared_vars;
288 
289  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
290  for (const auto & var : vars)
291  {
292  mooseAssert(&var->sys() == this,
293  "I will cry if we store variables in our warehouse that don't belong to us");
294 
295  // If it wasn't in the active list, we need to prepare it. This has the potential to duplicate
296  // prepare if we have these conditions:
297  //
298  // 1. We have a displaced problem
299  // 2. We are using AD
300  // 3. We are not using global AD indexing
301  //
302  // But I think I would rather risk duplicate prepare than introduce an additional member set
303  // variable for tracking prepared variables. Set insertion is slow and some simulations have a
304  // ton of variables
305  if (!active_elemental_moose_variables.count(var))
306  {
307  var->prepare();
308  newly_prepared_vars.push_back(var);
309  }
310  }
311 
312  // Make sure to resize the residual and jacobian datastructures for all the new variables
313  if (resize_data)
314  for (const auto var_ptr : newly_prepared_vars)
315  {
316  _subproblem.assembly(tid, number()).prepareVariable(var_ptr);
319  }
320  }
321 }
322 
323 void
325 {
326  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
327  for (const auto & var : vars)
328  var->prepareNeighbor();
329 }
330 
331 void
333 {
334  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
335  for (const auto & var : vars)
336  var->prepareLowerD();
337 }
338 
339 void
340 SystemBase::reinitElem(const Elem * const elem, THREAD_ID tid)
341 {
343  {
344  const std::set<MooseVariableFieldBase *> & active_elemental_moose_variables =
346  for (const auto & var : active_elemental_moose_variables)
347  if (&(var->sys()) == this)
348  var->computeElemValues();
349  }
350  else
351  {
352  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
353  for (const auto & var : vars)
354  var->computeElemValues();
355  }
356 
357  if (system().has_static_condensation())
358  for (auto & [tag, matrix] : _active_tagged_matrices)
359  {
360  libmesh_ignore(tag);
361  cast_ptr<StaticCondensation *>(matrix)->set_current_elem(*elem);
362  }
363 }
364 
365 void
366 SystemBase::reinitElemFace(const Elem * /*elem*/, unsigned int /*side*/, THREAD_ID tid)
367 {
368  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
369  for (const auto & var : vars)
370  var->computeElemValuesFace();
371 }
372 
373 void
374 SystemBase::reinitNeighborFace(const Elem * /*elem*/, unsigned int /*side*/, THREAD_ID tid)
375 {
376  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
377  for (const auto & var : vars)
378  var->computeNeighborValuesFace();
379 }
380 
381 void
383 {
384  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
385  for (const auto & var : vars)
386  var->computeNeighborValues();
387 }
388 
389 void
391 {
392  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
393  for (const auto & var : vars)
394  var->computeLowerDValues();
395 }
396 
397 void
398 SystemBase::reinitNode(const Node * /*node*/, THREAD_ID tid)
399 {
400  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
401  for (const auto & var : vars)
402  {
403  var->reinitNode();
404  if (var->isNodalDefined())
405  var->computeNodalValues();
406  }
407 }
408 
409 void
410 SystemBase::reinitNodeFace(const Node * /*node*/, BoundaryID /*bnd_id*/, THREAD_ID tid)
411 {
412  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
413  for (const auto & var : vars)
414  {
415  var->reinitNode();
416  if (var->isNodalDefined())
417  var->computeNodalValues();
418  }
419 }
420 
421 void
422 SystemBase::reinitNodes(const std::vector<dof_id_type> & nodes, THREAD_ID tid)
423 {
424  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
425  for (const auto & var : vars)
426  {
427  var->reinitNodes(nodes);
428  var->computeNodalValues();
429  }
430 }
431 
432 void
433 SystemBase::reinitNodesNeighbor(const std::vector<dof_id_type> & nodes, THREAD_ID tid)
434 {
435  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
436  for (const auto & var : vars)
437  {
438  var->reinitNodesNeighbor(nodes);
439  var->computeNodalNeighborValues();
440  }
441 }
442 
443 void
444 SystemBase::reinitScalars(THREAD_ID tid, bool reinit_for_derivative_reordering /*=false*/)
445 {
446  const std::vector<MooseVariableScalar *> & vars = _vars[tid].scalars();
447  for (const auto & var : vars)
448  var->reinit(reinit_for_derivative_reordering);
449 }
450 
451 void
452 SystemBase::augmentSendList(std::vector<dof_id_type> & send_list)
453 {
454  std::set<dof_id_type> & ghosted_elems = _subproblem.ghostedElems();
455 
456  DofMap & dof_map = dofMap();
457 
458  std::vector<dof_id_type> dof_indices;
459 
460  System & sys = system();
461 
462  unsigned int sys_num = sys.number();
463 
464  unsigned int n_vars = sys.n_vars();
465 
466  for (const auto & elem_id : ghosted_elems)
467  {
468  Elem * elem = _mesh.elemPtr(elem_id);
469 
470  if (elem->active())
471  {
472  dof_map.dof_indices(elem, dof_indices);
473 
474  // Only need to ghost it if it's actually not on this processor
475  for (const auto & dof : dof_indices)
476  if (dof < dof_map.first_dof() || dof >= dof_map.end_dof())
477  send_list.push_back(dof);
478 
479  // Now add the DoFs from all of the nodes. This is necessary because of block
480  // restricted variables. A variable might not live _on_ this element but it
481  // might live on nodes connected to this element.
482  for (unsigned int n = 0; n < elem->n_nodes(); n++)
483  {
484  Node * node = elem->node_ptr(n);
485 
486  // Have to get each variable's dofs
487  for (unsigned int v = 0; v < n_vars; v++)
488  {
489  const Variable & var = sys.variable(v);
490  unsigned int var_num = var.number();
491  unsigned int n_comp = var.n_components();
492 
493  // See if this variable has any dofs at this node
494  if (node->n_dofs(sys_num, var_num) > 0)
495  {
496  // Loop over components of the variable
497  for (unsigned int c = 0; c < n_comp; c++)
498  send_list.push_back(node->dof_number(sys_num, var_num, c));
499  }
500  }
501  }
502  }
503  }
504 }
505 
509 void
511 {
512  const auto states =
513  _solution_states[static_cast<unsigned short>(Moose::SolutionIterationType::Time)].size();
514  if (states > 1)
515  {
516  _saved_solution_states.resize(states);
517  for (unsigned int i = 1; i <= states - 1; ++i)
518  if (!_saved_solution_states[i])
520  &addVector("save_solution_state_" + std::to_string(i), false, PARALLEL);
521 
522  for (unsigned int i = 1; i <= states - 1; ++i)
524  }
525 
527  _saved_dot_old = &addVector("save_solution_dot_old", false, PARALLEL);
529  _saved_dotdot_old = &addVector("save_solution_dotdot_old", false, PARALLEL);
530 
531  if (solutionUDotOld())
533 
534  if (solutionUDotDotOld())
536 }
537 
541 void
543 {
544  const auto states =
545  _solution_states[static_cast<unsigned short>(Moose::SolutionIterationType::Time)].size();
546  if (states > 1)
547  for (unsigned int i = 1; i <= states - 1; ++i)
548  if (_saved_solution_states[i])
549  {
551  removeVector("save_solution_state_" + std::to_string(i));
552  _saved_solution_states[i] = nullptr;
553  }
554 
556  {
558  removeVector("save_solution_dot_old");
559  _saved_dot_old = nullptr;
560  }
562  {
564  removeVector("save_solution_dotdot_old");
565  _saved_dotdot_old = nullptr;
566  }
567 }
568 
571 {
572  if (!_subproblem.matrixTagExists(tag))
573  mooseError("Cannot add tagged matrix with TagID ",
574  tag,
575  " in system '",
576  name(),
577  "' because the tag does not exist in the problem");
578 
579  if (hasMatrix(tag))
580  return getMatrix(tag);
581 
582  const auto matrix_name = _subproblem.matrixTagName(tag);
583  SparseMatrix<Number> & mat = system().add_matrix(matrix_name);
584  associateMatrixToTag(mat, tag);
585 
586  return mat;
587 }
588 
589 void
591 {
592  if (!_subproblem.matrixTagExists(tag_id))
593  mooseError("Cannot remove the matrix with TagID ",
594  tag_id,
595  "\nin system '",
596  name(),
597  "', because that tag does not exist in the problem");
598 
599  if (hasMatrix(tag_id))
600  {
601  const auto matrix_name = _subproblem.matrixTagName(tag_id);
602  system().remove_matrix(matrix_name);
603  _tagged_matrices[tag_id] = nullptr;
604  }
605 }
606 
608 SystemBase::addVector(const std::string & vector_name, const bool project, const ParallelType type)
609 {
610  if (hasVector(vector_name))
611  return getVector(vector_name);
612 
613  NumericVector<Number> & vec = system().add_vector(vector_name, project, type);
614  return vec;
615 }
616 
618 SystemBase::addVector(TagID tag, const bool project, const ParallelType type)
619 {
620  if (!_subproblem.vectorTagExists(tag))
621  mooseError("Cannot add tagged vector with TagID ",
622  tag,
623  " in system '",
624  name(),
625  "' because the tag does not exist in the problem");
626 
627  if (hasVector(tag))
628  {
629  auto & vec = getVector(tag);
630 
631  if (type != ParallelType::AUTOMATIC && vec.type() != type)
632  mooseError("Cannot add tagged vector '",
634  "', in system '",
635  name(),
636  "' because a vector with the same name was found with a different parallel type");
637 
638  return vec;
639  }
640 
641  const auto vector_name = _subproblem.vectorTagName(tag);
642  NumericVector<Number> & vec = system().add_vector(vector_name, project, type);
643  associateVectorToTag(vec, tag);
644 
645  return vec;
646 }
647 
648 void
650 {
651  if (!_subproblem.vectorTagExists(tag))
652  mooseError("Cannot close vector with TagID ",
653  tag,
654  " in system '",
655  name(),
656  "' because that tag does not exist in the problem");
657  else if (!hasVector(tag))
658  mooseError("Cannot close vector tag with name '",
660  "' in system '",
661  name(),
662  "' because there is no vector associated with that tag");
663  getVector(tag).close();
664 }
665 
666 void
667 SystemBase::closeTaggedVectors(const std::set<TagID> & tags)
668 {
669  for (const auto tag : tags)
670  closeTaggedVector(tag);
671 }
672 
673 void
675 {
676  if (!_subproblem.vectorTagExists(tag))
677  mooseError("Cannot zero vector with TagID ",
678  tag,
679  " in system '",
680  name(),
681  "' because that tag does not exist in the problem");
682  else if (!hasVector(tag))
683  mooseError("Cannot zero vector tag with name '",
685  "' in system '",
686  name(),
687  "' because there is no vector associated with that tag");
689  getVector(tag).zero();
690 }
691 
692 void
693 SystemBase::zeroTaggedVectors(const std::set<TagID> & tags)
694 {
695  for (const auto tag : tags)
696  zeroTaggedVector(tag);
697 }
698 
699 void
701 {
702  if (!_subproblem.vectorTagExists(tag_id))
703  mooseError("Cannot remove the vector with TagID ",
704  tag_id,
705  "\nin system '",
706  name(),
707  "', because that tag does not exist in the problem");
708 
709  if (hasVector(tag_id))
710  {
711  auto vector_name = _subproblem.vectorTagName(tag_id);
712  system().remove_vector(vector_name);
713  _tagged_vectors[tag_id] = nullptr;
714  }
715 }
716 
717 void
718 SystemBase::addVariable(const std::string & var_type,
719  const std::string & name,
720  InputParameters & parameters)
721 {
723 
724  const auto components = parameters.get<unsigned int>("components");
725 
726  // Convert the std::vector parameter provided by the user into a std::set for use by libMesh's
727  // System::add_variable method
728  std::set<SubdomainID> blocks;
729  const auto & block_param = parameters.get<std::vector<SubdomainName>>("block");
730  for (const auto & subdomain_name : block_param)
731  {
732  SubdomainID blk_id = _mesh.getSubdomainID(subdomain_name);
733  blocks.insert(blk_id);
734  }
735 
736  const auto fe_type =
737  FEType(Utility::string_to_enum<Order>(parameters.get<MooseEnum>("order")),
738  Utility::string_to_enum<FEFamily>(parameters.get<MooseEnum>("family")));
739  const auto fe_field_type = FEInterface::field_type(fe_type);
740 
741  unsigned int var_num;
742 
743  if (var_type == "ArrayMooseVariable")
744  {
745  if (fe_field_type == TYPE_VECTOR)
746  mooseError("Vector family type cannot be used in an array variable");
747 
748  std::vector<std::string> array_var_component_names;
749  const bool has_array_names = parameters.isParamValid("array_var_component_names");
750  if (has_array_names)
751  {
752  array_var_component_names =
753  parameters.get<std::vector<std::string>>("array_var_component_names");
754  if (array_var_component_names.size() != components)
755  parameters.paramError("array_var_component_names",
756  "Must be the same size as 'components' (size ",
757  components,
758  ") for array variable '",
759  name,
760  "'");
761  }
762 
763  // Build up the variable names
764  std::vector<std::string> var_names;
765  for (unsigned int i = 0; i < components; i++)
766  {
767  if (!has_array_names)
768  array_var_component_names.push_back(std::to_string(i));
769  var_names.push_back(name + "_" + array_var_component_names[i]);
770  }
771 
772  // makes sure there is always a name, either the provided one or '1 2 3 ...'
773  parameters.set<std::vector<std::string>>("array_var_component_names") =
774  array_var_component_names;
775 
776  // The number returned by libMesh is the _last_ variable number... we want to hold onto the
777  // _first_
778  var_num = system().add_variables(var_names, fe_type, &blocks) - (components - 1);
779 
780  // Set as array variable
781  if (parameters.isParamSetByUser("array") && !parameters.get<bool>("array"))
782  parameters.paramError("array",
783  "Must be set to true for variable '",
784  name,
785  "' because 'components' > 1 (is an array variable)");
786  parameters.set<bool>("array") = true;
787  }
788  else
789  {
790  if (parameters.isParamSetByUser("array_var_component_names"))
791  parameters.paramError("array_var_component_names",
792  "Should not be set because this variable (",
793  name,
794  ") is a non-array variable");
795  var_num = system().add_variable(name, fe_type, &blocks);
796  }
797 
798  parameters.set<unsigned int>("_var_num") = var_num;
799  parameters.set<SystemBase *>("_system_base") = this;
800 
801  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
802  {
803  parameters.set<THREAD_ID>("tid") = tid;
804  std::shared_ptr<MooseVariableBase> var =
805  _factory.create<MooseVariableBase>(var_type, name, parameters, tid);
806 
807  _vars[tid].add(name, var);
808 
809  if (auto fe_var = dynamic_cast<MooseVariableFieldBase *>(var.get()))
810  {
811  auto required_size = var_num + components;
812  if (required_size > _numbered_vars[tid].size())
813  _numbered_vars[tid].resize(required_size);
814  for (MooseIndex(components) component = 0; component < components; ++component)
815  _numbered_vars[tid][var_num + component] = fe_var;
816 
817  if (auto * const functor = dynamic_cast<Moose::FunctorBase<ADReal> *>(fe_var))
818  _subproblem.addFunctor(name, *functor, tid);
819  else if (auto * const functor = dynamic_cast<Moose::FunctorBase<ADRealVectorValue> *>(fe_var))
820  _subproblem.addFunctor(name, *functor, tid);
821  else if (auto * const functor = dynamic_cast<Moose::FunctorBase<RealEigenVector> *>(fe_var))
822  _subproblem.addFunctor(name, *functor, tid);
823  else
824  mooseError("This should be a functor");
825  }
826 
827  if (var->blockRestricted())
828  for (const SubdomainID & id : var->blockIDs())
829  for (MooseIndex(components) component = 0; component < components; ++component)
830  _var_map[var_num + component].insert(id);
831  else
832  for (MooseIndex(components) component = 0; component < components; ++component)
833  _var_map[var_num + component] = std::set<SubdomainID>();
834  }
835 
836  // getMaxVariableNumber is an API method used in Rattlesnake
837  if (var_num > _max_var_number)
838  _max_var_number = var_num;
839  _du_dot_du.resize(var_num + 1);
840 }
841 
842 bool
843 SystemBase::hasVariable(const std::string & var_name) const
844 {
845  auto & names = getVariableNames();
846  if (system().has_variable(var_name))
847  return system().variable_type(var_name).family != SCALAR;
848  if (std::find(names.begin(), names.end(), var_name) != names.end())
849  // array variable
850  return true;
851  else
852  return false;
853 }
854 
855 bool
856 SystemBase::isArrayVariable(const std::string & var_name) const
857 {
858  auto & names = getVariableNames();
859  if (!system().has_variable(var_name) &&
860  std::find(names.begin(), names.end(), var_name) != names.end())
861  // array variable
862  return true;
863  else
864  return false;
865 }
866 
867 bool
868 SystemBase::hasScalarVariable(const std::string & var_name) const
869 {
870  if (system().has_variable(var_name))
871  return system().variable_type(var_name).family == SCALAR;
872  else
873  return false;
874 }
875 
876 bool
877 SystemBase::isScalarVariable(unsigned int var_num) const
878 {
879  return (system().variable(var_num).type().family == SCALAR);
880 }
881 
882 unsigned int
884 {
885  unsigned int n = nFieldVariables();
886  n += _vars[0].scalars().size();
887 
888  return n;
889 }
890 
891 unsigned int
893 {
894  unsigned int n = 0;
895  for (auto & var : _vars[0].fieldVariables())
896  n += var->count();
897 
898  return n;
899 }
900 
901 unsigned int
903 {
904  unsigned int n = 0;
905  for (auto & var : _vars[0].fieldVariables())
906  if (var->isFV())
907  n += var->count();
908 
909  return n;
910 }
911 
915 bool
916 SystemBase::hasVector(const std::string & name) const
917 {
918  return system().have_vector(name);
919 }
920 
925 SystemBase::getVector(const std::string & name)
926 {
927  return system().get_vector(name);
928 }
929 
930 const NumericVector<Number> &
931 SystemBase::getVector(const std::string & name) const
932 {
933  return system().get_vector(name);
934 }
935 
938 {
939  if (!hasVector(tag))
940  {
941  if (!_subproblem.vectorTagExists(tag))
942  mooseError("Cannot retreive vector with tag ", tag, " because that tag does not exist");
943  else
944  mooseError("Cannot retreive vector with tag ",
945  tag,
946  " in system '",
947  name(),
948  "'\nbecause a vector has not been associated with that tag.");
949  }
950 
951  return *_tagged_vectors[tag];
952 }
953 
954 const NumericVector<Number> &
956 {
957  if (!hasVector(tag))
958  {
959  if (!_subproblem.vectorTagExists(tag))
960  mooseError("Cannot retreive vector with tag ", tag, " because that tag does not exist");
961  else
962  mooseError("Cannot retreive vector with tag ",
963  tag,
964  " in system '",
965  name(),
966  "'\nbecause a vector has not been associated with that tag.");
967  }
968 
969  return *_tagged_vectors[tag];
970 }
971 
972 void
974 {
975  if (!_subproblem.vectorTagExists(tag))
976  mooseError("Cannot associate vector to tag ", tag, " because that tag does not exist");
977 
978  if (_tagged_vectors.size() < tag + 1)
979  _tagged_vectors.resize(tag + 1);
980 
981  _tagged_vectors[tag] = &vec;
982 }
983 
984 void
986 {
987  if (!_subproblem.vectorTagExists(tag))
988  mooseError("Cannot disassociate vector from tag ", tag, " because that tag does not exist");
989  if (hasVector(tag) && &getVector(tag) != &vec)
990  mooseError("You can not disassociate a vector from a tag which it was not associated to");
991 
993 }
994 
995 void
997 {
998  if (!_subproblem.vectorTagExists(tag))
999  mooseError("Cannot disassociate vector from tag ", tag, " because that tag does not exist");
1000 
1001  if (_tagged_vectors.size() < tag + 1)
1002  _tagged_vectors.resize(tag + 1);
1003  _tagged_vectors[tag] = nullptr;
1004 }
1005 
1006 void
1008 {
1009  const auto tags = defaultVectorTags();
1010  for (const auto tag : tags)
1011  if (_subproblem.vectorTagExists(tag))
1013 }
1014 
1017 {
1018  if (!hasMatrix(tag))
1019  {
1020  if (!_subproblem.matrixTagExists(tag))
1021  mooseError("Cannot retreive matrix with tag ", tag, " because that tag does not exist");
1022  else
1023  mooseError("Cannot retreive matrix with tag ",
1024  tag,
1025  " in system '",
1026  name(),
1027  "'\nbecause a matrix has not been associated with that tag.");
1028  }
1029 
1030  return *_tagged_matrices[tag];
1031 }
1032 
1033 const SparseMatrix<Number> &
1035 {
1036  if (!hasMatrix(tag))
1037  {
1038  if (!_subproblem.matrixTagExists(tag))
1039  mooseError("Cannot retreive matrix with tag ", tag, " because that tag does not exist");
1040  else
1041  mooseError("Cannot retreive matrix with tag ",
1042  tag,
1043  " in system '",
1044  name(),
1045  "'\nbecause a matrix has not been associated with that tag.");
1046  }
1047 
1048  return *_tagged_matrices[tag];
1049 }
1050 
1051 void
1052 SystemBase::closeTaggedMatrices(const std::set<TagID> & tags)
1053 {
1054  for (auto tag : tags)
1055  if (hasMatrix(tag))
1056  getMatrix(tag).close();
1057 }
1058 
1059 void
1060 SystemBase::flushTaggedMatrices(const std::set<TagID> & tags)
1061 {
1062  for (auto tag : tags)
1063  if (hasMatrix(tag))
1064  getMatrix(tag).flush();
1065 }
1066 
1067 void
1069 {
1070  if (!_subproblem.matrixTagExists(tag))
1071  mooseError("Cannot associate matrix to tag ", tag, " because that tag does not exist");
1072 
1073  if (_tagged_matrices.size() < tag + 1)
1074  _tagged_matrices.resize(tag + 1);
1075 
1076  _tagged_matrices[tag] = &matrix;
1077 }
1078 
1079 void
1081 {
1082  if (!_subproblem.matrixTagExists(tag))
1083  mooseError("Cannot disassociate matrix from tag ", tag, " because that tag does not exist");
1084  if (hasMatrix(tag) && &getMatrix(tag) != &matrix)
1085  mooseError("You can not disassociate a matrix from a tag which it was not associated to");
1086 
1088 }
1089 
1090 void
1092 {
1093  if (!_subproblem.matrixTagExists(tag))
1094  mooseError("Cannot disassociate matrix from tag ", tag, " because that tag does not exist");
1095 
1096  if (_tagged_matrices.size() < tag + 1)
1097  _tagged_matrices.resize(tag + 1);
1098  _tagged_matrices[tag] = nullptr;
1099 }
1100 
1101 void
1103 {
1104  const auto tags = defaultMatrixTags();
1105  for (const auto tag : tags)
1106  if (_subproblem.matrixTagExists(tag))
1108 }
1109 
1110 void
1112 {
1113  auto num_matrix_tags = _subproblem.numMatrixTags();
1114 
1115  _matrix_tag_active_flags.resize(num_matrix_tags);
1116 
1117  for (decltype(num_matrix_tags) tag = 0; tag < num_matrix_tags; tag++)
1118  _matrix_tag_active_flags[tag] = false;
1119  _active_tagged_matrices.clear();
1120 }
1121 
1122 void
1124 {
1125  auto num_matrix_tags = _subproblem.numMatrixTags();
1126 
1127  _matrix_tag_active_flags.resize(num_matrix_tags);
1128  _active_tagged_matrices.clear();
1129 
1130  for (const auto tag : make_range(num_matrix_tags))
1131  if (hasMatrix(tag))
1132  {
1133  _matrix_tag_active_flags[tag] = true;
1134  _active_tagged_matrices.emplace(tag, &getMatrix(tag));
1135  }
1136  else
1137  _matrix_tag_active_flags[tag] = false;
1138 }
1139 
1140 bool
1142 {
1143  mooseAssert(_subproblem.matrixTagExists(tag), "Matrix tag " << tag << " does not exist");
1144 
1145  return tag < _matrix_tag_active_flags.size() && _matrix_tag_active_flags[tag];
1146 }
1147 
1148 unsigned int
1150 {
1151  return system().number();
1152 }
1153 
1154 DofMap &
1156 {
1157  return system().get_dof_map();
1158 }
1159 
1160 const DofMap &
1162 {
1163  return system().get_dof_map();
1164 }
1165 
1166 void
1167 SystemBase::addVariableToCopy(const std::string & dest_name,
1168  const std::string & source_name,
1169  const std::string & timestep)
1170 {
1171  _var_to_copy.push_back(VarCopyInfo(dest_name, source_name, timestep));
1172 }
1173 
1174 void
1176 {
1177  int n_steps = io.get_num_time_steps();
1178 
1179  bool did_copy = false;
1180  for (const auto & vci : _var_to_copy)
1181  {
1182  int timestep = -1;
1183 
1184  if (vci._timestep == "LATEST")
1185  // Use the last time step in the file from which to retrieve the solution
1186  timestep = n_steps;
1187  else
1188  {
1189  timestep = MooseUtils::convert<int>(vci._timestep);
1190  if (timestep > n_steps)
1191  mooseError("Invalid value passed as \"initial_from_file_timestep\". Expected \"LATEST\" or "
1192  "a valid integer between 1 and ",
1193  n_steps,
1194  " inclusive, received ",
1195  vci._timestep);
1196  }
1197 
1198  did_copy = true;
1199 
1200  if (hasVariable(vci._dest_name))
1201  {
1202  const auto & var = getVariable(0, vci._dest_name);
1203  if (var.isArray())
1204  {
1205  const auto & array_var = getFieldVariable<RealEigenVector>(0, vci._dest_name);
1206  for (MooseIndex(var.count()) i = 0; i < var.count(); ++i)
1207  {
1208  const auto & exodus_var = var.arrayVariableComponent(i);
1209  const auto & system_var = array_var.componentName(i);
1210  if (var.isNodal())
1211  io.copy_nodal_solution(system(), exodus_var, system_var, timestep);
1212  else
1213  io.copy_elemental_solution(system(), exodus_var, system_var, timestep);
1214  }
1215  }
1216  else
1217  {
1218  if (var.isNodal())
1219  io.copy_nodal_solution(system(), vci._dest_name, vci._source_name, timestep);
1220  else
1221  io.copy_elemental_solution(system(), vci._dest_name, vci._source_name, timestep);
1222  }
1223  }
1224  else if (hasScalarVariable(vci._dest_name))
1225  io.copy_scalar_solution(system(), {vci._dest_name}, {vci._source_name}, timestep);
1226  else
1227  mooseError("Unrecognized variable ", vci._dest_name, " in variables to copy.");
1228  }
1229 
1230  if (did_copy)
1231  solution().close();
1232 }
1233 
1234 void
1236 {
1237  system().update();
1238 }
1239 
1240 void
1242 {
1243  system().solve();
1244 }
1245 
1249 void
1251 {
1252  system().update();
1253  copyOldSolutions();
1255 }
1256 
1260 void
1262 {
1263  const auto states =
1264  _solution_states[static_cast<unsigned short>(Moose::SolutionIterationType::Nonlinear)].size();
1265  if (states > 1)
1266  for (unsigned int i = states - 1; i > 0; --i)
1269 
1270  if (solutionPreviousNewton())
1272 }
1273 
1277 void
1279 {
1280  // copy the solutions backward: current->old, old->older
1281  const auto states =
1282  _solution_states[static_cast<unsigned short>(Moose::SolutionIterationType::Time)].size();
1283  if (states > 1)
1284  for (unsigned int i = states - 1; i > 0; --i)
1285  solutionState(i) = solutionState(i - 1);
1286 
1287  if (solutionUDotOld())
1288  *solutionUDotOld() = *solutionUDot();
1289  if (solutionUDotDotOld())
1291 }
1292 
1293 void
1295 {
1296  const auto n_states =
1297  _solution_states[static_cast<unsigned short>(Moose::SolutionIterationType::FixedPoint)]
1298  .size();
1299  if (n_states > 1)
1300  for (unsigned int i = n_states - 1; i > 0; --i)
1303 }
1304 
1308 void
1310 {
1311  if (!hasSolutionState(1))
1312  mooseError("Cannot restore solutions without old solution");
1313 
1314  *(const_cast<NumericVector<Number> *&>(currentSolution())) = solutionOld();
1315  solution() = solutionOld();
1316  if (solutionUDotOld())
1317  *solutionUDot() = *solutionUDotOld();
1318  if (solutionUDotDotOld())
1320  if (solutionPreviousNewton())
1322  system().update();
1323 }
1324 
1325 void
1326 SystemBase::removeVector(const std::string & name)
1327 {
1329 }
1330 
1331 const std::string &
1333 {
1334  return system().name();
1335 }
1336 
1339 {
1342  else
1343  return nullptr;
1344 }
1345 
1346 const NumericVector<Number> *
1348 {
1351  else
1352  return nullptr;
1353 }
1354 
1355 void
1357 {
1358  // Default is the current solution
1359  unsigned int state = 0;
1360 
1361  // Add additional states as required by the variable states requested
1362  for (const auto & var : getVariables(/* tid = */ 0))
1363  state = std::max(state, var->oldestSolutionStateRequested());
1364  for (const auto & var : getScalarVariables(/* tid = */ 0))
1365  state = std::max(state, var->oldestSolutionStateRequested());
1366 
1368 
1370 }
1371 
1372 TagName
1374  const Moose::SolutionIterationType iteration_type) const
1375 {
1376  mooseAssert(state != 0, "Not an old state");
1377 
1378  if (iteration_type == Moose::SolutionIterationType::Time)
1379  {
1380  if (state == 1)
1381  return Moose::OLD_SOLUTION_TAG;
1382  else if (state == 2)
1384  }
1385  else if (iteration_type == Moose::SolutionIterationType::Nonlinear && state == 1)
1387  else if (iteration_type == Moose::SolutionIterationType::FixedPoint && state == 1)
1389 
1390  return "solution_state_" + std::to_string(state) + "_" + Moose::stringify(iteration_type);
1391 }
1392 
1393 const NumericVector<Number> &
1394 SystemBase::solutionState(const unsigned int state,
1395  const Moose::SolutionIterationType iteration_type) const
1396 {
1397  if (!hasSolutionState(state, iteration_type))
1398  mooseError("For iteration type '",
1399  Moose::stringify(iteration_type),
1400  "': solution state ",
1401  state,
1402  " was requested in ",
1403  name(),
1404  " but only up to state ",
1405  (_solution_states[static_cast<unsigned short>(iteration_type)].size() == 0)
1406  ? 0
1407  : _solution_states[static_cast<unsigned short>(iteration_type)].size() - 1,
1408  " is available.");
1409 
1410  const auto & solution_states = _solution_states[static_cast<unsigned short>(iteration_type)];
1411 
1412  if (state == 0)
1413  mooseAssert(solution_states[0] == &solutionInternal(), "Inconsistent current solution");
1414  else
1415  mooseAssert(solution_states[state] ==
1416  &getVector(oldSolutionStateVectorName(state, iteration_type)),
1417  "Inconsistent solution state");
1418 
1419  return *solution_states[state];
1420 }
1421 
1423 SystemBase::solutionState(const unsigned int state,
1424  const Moose::SolutionIterationType iteration_type)
1425 {
1426  if (!hasSolutionState(state, iteration_type))
1427  needSolutionState(state, iteration_type);
1428  return *_solution_states[static_cast<unsigned short>(iteration_type)][state];
1429 }
1430 
1432 SystemBase::solutionStateParallelType(const unsigned int state,
1433  const Moose::SolutionIterationType iteration_type) const
1434 {
1435  if (!hasSolutionState(state, iteration_type))
1436  mooseError("solutionStateParallelType() may only be called if the solution state exists.");
1437 
1438  return _solution_states[static_cast<unsigned short>(iteration_type)][state]->type();
1439 }
1440 
1441 void
1442 SystemBase::needSolutionState(const unsigned int state,
1443  const Moose::SolutionIterationType iteration_type,
1444  const libMesh::ParallelType parallel_type)
1445 {
1446  libmesh_parallel_only(this->comm());
1447  mooseAssert(!Threads::in_threads,
1448  "This routine is not thread-safe. Request the solution state before using it in "
1449  "a threaded region.");
1450 
1451  if (hasSolutionState(state, iteration_type))
1452  return;
1453 
1454  auto & solution_states = _solution_states[static_cast<unsigned short>(iteration_type)];
1455  solution_states.resize(state + 1);
1456 
1457  // The 0-th (current) solution state is owned by libMesh
1458  if (!solution_states[0])
1459  solution_states[0] = &solutionInternal();
1460  else
1461  mooseAssert(solution_states[0] == &solutionInternal(), "Inconsistent current solution");
1462 
1463  // We will manually add all states past current
1464  for (unsigned int i = 1; i <= state; ++i)
1465  if (!solution_states[i])
1466  {
1467  auto tag = _subproblem.addVectorTag(oldSolutionStateVectorName(i, iteration_type),
1469  solution_states[i] = &addVector(tag, true, parallel_type);
1470  }
1471  else
1472  {
1473  // If the existing parallel type is PARALLEL and GHOSTED is now requested,
1474  // this would require an upgrade, which is risky if anybody has already
1475  // stored a pointer to the existing vector, since the upgrade would create
1476  // a new vector and make that pointer null. If the existing parallel type
1477  // is GHOSTED and PARALLEL is now requested, we don't need to do anything.
1478  if (parallel_type == GHOSTED && solutionStateParallelType(i, iteration_type) == PARALLEL)
1479  mooseError("The solution state has already been declared as PARALLEL");
1480 
1481  mooseAssert(solution_states[i] == &getVector(oldSolutionStateVectorName(i, iteration_type)),
1482  "Inconsistent solution state");
1483  }
1484 }
1485 
1486 void
1487 SystemBase::applyScalingFactors(const std::vector<Real> & inverse_scaling_factors)
1488 {
1489  for (MooseIndex(_vars) thread = 0; thread < _vars.size(); ++thread)
1490  {
1491  auto & field_variables = _vars[thread].fieldVariables();
1492  for (MooseIndex(field_variables) i = 0, p = 0; i < field_variables.size(); ++i)
1493  {
1494  auto factors = field_variables[i]->arrayScalingFactor();
1495  for (unsigned int j = 0; j < field_variables[i]->count(); ++j, ++p)
1496  factors[j] /= inverse_scaling_factors[p];
1497 
1498  field_variables[i]->scalingFactor(factors);
1499  }
1500 
1501  auto offset = field_variables.size();
1502 
1503  auto & scalar_variables = _vars[thread].scalars();
1504  for (MooseIndex(scalar_variables) i = 0; i < scalar_variables.size(); ++i)
1505  scalar_variables[i]->scalingFactor(
1506  {1. / inverse_scaling_factors[offset + i] * scalar_variables[i]->scalingFactor()});
1507 
1508  if (thread == 0 && _verbose)
1509  {
1510  _console << "Automatic scaling factors:\n";
1511  auto original_flags = _console.flags();
1512  auto original_precision = _console.precision();
1513  _console.unsetf(std::ios_base::floatfield);
1514  _console.precision(6);
1515 
1516  for (const auto & field_variable : field_variables)
1517  {
1518  const auto & factors = field_variable->arrayScalingFactor();
1519  _console << " " << field_variable->name() << ":";
1520  for (const auto i : make_range(field_variable->count()))
1521  _console << " " << factors[i];
1522  _console << "\n";
1523  }
1524  for (const auto & scalar_variable : scalar_variables)
1525  _console << " " << scalar_variable->name() << ": " << scalar_variable->scalingFactor()
1526  << "\n";
1527  _console << "\n" << std::endl;
1528 
1529  // restore state
1530  _console.flags(original_flags);
1531  _console.precision(original_precision);
1532  }
1533  }
1534 }
1535 
1536 void
1538 {
1539  addVector("scaling_factors", /*project=*/false, libMesh::ParallelType::GHOSTED);
1541 }
1542 
1543 bool
1545 {
1547 }
1548 
1549 void
1551 {
1552  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
1553  _vars[tid].initialSetup();
1554 
1555  // If we need raw gradients, we initialize them here.
1556  bool gradient_storage_initialized = false;
1557  for (const auto & field_var : _vars[0].fieldVariables())
1558  if (!gradient_storage_initialized && field_var->needsGradientVectorStorage())
1559  {
1560  _raw_grad_container.clear();
1561  for (const auto i : make_range(this->_mesh.dimension()))
1562  {
1563  libmesh_ignore(i);
1564  _raw_grad_container.push_back(currentSolution()->zero_clone());
1565  }
1566  }
1567 }
1568 
1569 void
1571 {
1572  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
1573  _vars[tid].timestepSetup();
1574 }
1575 
1576 void
1578 {
1579  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
1580  _vars[tid].customSetup(exec_type);
1581 }
1582 
1583 void
1585 {
1586  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
1587  _vars[tid].subdomainSetup();
1588 }
1589 
1590 void
1592 {
1593  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
1594  _vars[tid].residualSetup();
1595 }
1596 
1597 void
1599 {
1600  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
1601  _vars[tid].jacobianSetup();
1602 }
1603 
1604 void
1606 {
1607  for (auto & var_warehouse : _vars)
1608  var_warehouse.clearAllDofIndices();
1609 }
1610 
1611 void
1613 {
1614  _vars[tid].setActiveVariableCoupleableVectorTags(vtags);
1615 }
1616 
1617 void
1619  THREAD_ID tid)
1620 {
1621  _vars[tid].setActiveScalarVariableCoupleableVectorTags(vtags);
1622 }
1623 
1624 void
1626 {
1627  if (_fe_problem.uDotRequested())
1628  _u_dot = &addVector("u_dot", true, GHOSTED);
1630  _u_dot_old = &addVector("u_dot_old", true, GHOSTED);
1632  _u_dotdot = &addVector("u_dotdot", true, GHOSTED);
1634  _u_dotdot_old = &addVector("u_dotdot_old", true, GHOSTED);
1635 }
1636 
1639 {
1640  if (!_serialized_solution.get())
1641  {
1643  _serialized_solution->init(system().n_dofs(), false, SERIAL);
1644  }
1645 
1646  return *_serialized_solution;
1647 }
1648 
1649 void
1650 SystemBase::addTimeIntegrator(const std::string & type,
1651  const std::string & name,
1652  InputParameters & parameters)
1653 {
1654  parameters.set<SystemBase *>("_sys") = this;
1655  _time_integrators.push_back(_factory.create<TimeIntegrator>(type, name, parameters));
1656 }
1657 
1658 void
1660 {
1662 }
1663 
1664 const TimeIntegrator *
1665 SystemBase::queryTimeIntegrator(const unsigned int var_num) const
1666 {
1667  for (auto & ti : _time_integrators)
1668  if (ti->integratesVar(var_num))
1669  return ti.get();
1670 
1671  return nullptr;
1672 }
1673 
1674 const TimeIntegrator &
1675 SystemBase::getTimeIntegrator(const unsigned int var_num) const
1676 {
1677  const auto * const ti = queryTimeIntegrator(var_num);
1678 
1679  if (ti)
1680  return *ti;
1681  else
1682  mooseError("No time integrator found that integrates variable number ",
1683  std::to_string(var_num));
1684 }
1685 
1686 const std::vector<std::shared_ptr<TimeIntegrator>> &
1688 {
1689  return _time_integrators;
1690 }
1691 
1692 const Number &
1693 SystemBase::duDotDu(const unsigned int var_num) const
1694 {
1695  return _du_dot_du[var_num];
1696 }
1697 
1698 const std::set<SubdomainID> &
1699 SystemBase::getSubdomainsForVar(const std::string & var_name) const
1700 {
1701  return getSubdomainsForVar(getVariable(0, var_name).number());
1702 }
1703 
1704 std::string
1706 {
1707  return system().prefix_with_name() ? system().prefix() : "";
1708 }
1709 
1710 void
1712 {
1713  for (const auto & warehouse : _vars)
1714  for (const auto & [var_num, var_ptr] : warehouse.numberToVariableMap())
1715  var_ptr->sizeMatrixTagData();
1716 }
1717 
1718 template MooseVariableFE<Real> & SystemBase::getFieldVariable<Real>(THREAD_ID tid,
1719  const std::string & var_name);
1720 
1722 SystemBase::getFieldVariable<RealVectorValue>(THREAD_ID tid, const std::string & var_name);
1723 
1725 SystemBase::getFieldVariable<RealEigenVector>(THREAD_ID tid, const std::string & var_name);
1726 
1727 template MooseVariableFE<Real> & SystemBase::getFieldVariable<Real>(THREAD_ID tid,
1728  unsigned int var_number);
1729 
1731 SystemBase::getFieldVariable<RealVectorValue>(THREAD_ID tid, unsigned int var_number);
1732 
1734 SystemBase::getFieldVariable<RealEigenVector>(THREAD_ID tid, unsigned int var_number);
1735 
1736 template MooseVariableField<Real> &
1737 SystemBase::getActualFieldVariable<Real>(THREAD_ID tid, const std::string & var_name);
1738 
1740 SystemBase::getActualFieldVariable<RealVectorValue>(THREAD_ID tid, const std::string & var_name);
1741 
1743 SystemBase::getActualFieldVariable<RealEigenVector>(THREAD_ID tid, const std::string & var_name);
1744 
1745 template MooseVariableField<Real> &
1746 SystemBase::getActualFieldVariable<Real>(THREAD_ID tid, unsigned int var_number);
1747 
1749 SystemBase::getActualFieldVariable<RealVectorValue>(THREAD_ID tid, unsigned int var_number);
1750 
1752 SystemBase::getActualFieldVariable<RealEigenVector>(THREAD_ID tid, unsigned int var_number);
1753 
1754 template MooseVariableFV<Real> & SystemBase::getFVVariable<Real>(THREAD_ID tid,
1755  const std::string & var_name);
std::string name(const ElemQuality q)
void zeroTaggedVector(const TagID tag)
Zero vector with the given tag.
Definition: SystemBase.C:674
std::vector< std::shared_ptr< TimeIntegrator > > _time_integrators
Time integrator.
Definition: SystemBase.h:1049
unsigned int add_variables(const std::vector< std::string > &vars, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
virtual const std::set< SubdomainID > * getVariableBlocks(unsigned int var_number)
Get the block where a variable of this system is defined.
Definition: SystemBase.C:164
virtual void reinitNode(const Node *node, THREAD_ID tid)
Reinit nodal assembly info.
Definition: SystemBase.C:398
const std::vector< MooseVariableFieldBase * > & getVariables(THREAD_ID tid)
Definition: SystemBase.h:751
void closeTaggedVector(const TagID tag)
Close vector with the given tag.
Definition: SystemBase.C:649
virtual const NumericVector< Number > *const & currentSolution() const =0
The solution vector that is currently being operated on.
std::vector< std::vector< MooseVariableFieldBase * > > _numbered_vars
Map variable number to its pointer.
Definition: SystemBase.h:1052
dof_id_type end_dof(const processor_id_type proc) const
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
Definition: MooseMesh.C:1238
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Order
std::vector< dof_id_type > _var_all_dof_indices
Container for the dof indices of a given variable.
Definition: SystemBase.h:1064
std::vector< Real > _du_dot_du
Derivative of time derivative of u with respect to uj.
Definition: SystemBase.h:1017
const Variable & variable(unsigned int var) const
virtual NumericVector< Number > & solutionInternal() const =0
Internal getter for solution owned by libMesh.
unsigned int n_threads()
std::vector< libMesh::SparseMatrix< Number > * > _tagged_matrices
Tagged matrices (pointer)
Definition: SystemBase.h:1023
const std::vector< MooseVariableScalar * > & getScalarVariables(THREAD_ID tid)
Definition: SystemBase.h:756
void zeroTaggedVectors(const std::set< TagID > &tags)
Zero all vectors for given tags.
Definition: SystemBase.C:693
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
Definition: SystemBase.C:916
void applyScalingFactors(const std::vector< Real > &inverse_scaling_factors)
Applies scaling factors to the system&#39;s variables.
Definition: SystemBase.C:1487
virtual bool uDotDotOldRequested()
Get boolean flag to check whether old solution second time derivative needs to be stored...
virtual void augmentSparsity(libMesh::SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz)=0
Will modify the sparsity pattern to add logical geometric connections.
virtual void copyOldSolutions()
Shifts the solutions backwards in time.
Definition: SystemBase.C:1278
bool _solution_states_initialized
Whether or not the solution states have been initialized.
Definition: SystemBase.h:1061
SCALAR
unsigned int TagID
Definition: MooseTypes.h:210
virtual bool checkNonlocalCouplingRequirement() const =0
std::unordered_map< TagID, libMesh::SparseMatrix< Number > * > _active_tagged_matrices
Active tagged matrices. A matrix is active if its tag-matrix pair is present in the map...
Definition: SystemBase.h:1025
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3113
NumericVector< Number > & solution()
Definition: SystemBase.h:196
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters &parameters)
Canonical method for adding a variable.
Definition: SystemBase.C:718
char ** blocks
PARALLEL
virtual bool computingScalingJacobian() const =0
Getter for whether we&#39;re computing the scaling jacobian.
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:333
const TagName OLDER_SOLUTION_TAG
Definition: MooseTypes.C:27
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
std::vector< std::string > _vars_to_be_zeroed_on_residual
Definition: SystemBase.h:1002
std::ios_base::fmtflags flags() const
Return the current flags.
Definition: ConsoleStream.C:56
NumericVector< Number > * _u_dot_old
old solution vector for u^dot
Definition: SystemBase.h:1011
virtual bool uDotRequested()
Get boolean flag to check whether solution time derivative needs to be stored.
virtual void initSolutionState()
Initializes the solution state.
Definition: SystemBase.C:1356
virtual void disassociateDefaultVectorTags()
Disassociate the vectors associated with the default vector tags of this system.
Definition: SystemBase.C:1007
virtual void reinitElem(const Elem *elem, THREAD_ID tid)
Reinit an element assembly info.
Definition: SystemBase.C:340
virtual void reinitLowerD(THREAD_ID tid)
Compute the values of the variables on the lower dimensional element.
Definition: SystemBase.C:390
virtual bool uDotDotRequested()
Get boolean flag to check whether solution second time derivative needs to be stored.
char ** vars
virtual TagID addVectorTag(const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
Create a Tag.
Definition: SubProblem.C:92
const TimeIntegrator & getTimeIntegrator(const unsigned int var_num) const
Retrieve the time integrator that integrates the given variable&#39;s equation.
Definition: SystemBase.C:1675
virtual const std::set< MooseVariableFieldBase * > & getActiveElementalMooseVariables(const THREAD_ID tid) const
Get the MOOSE variables to be reinited on each element.
Definition: SubProblem.C:454
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
virtual void associateVectorToTag(NumericVector< Number > &vec, TagID tag)
Associate a vector for a given tag.
Definition: SystemBase.C:973
virtual libMesh::Order getMinQuadratureOrder()
Get minimal quadrature order needed for integrating variables in this system.
Definition: SystemBase.C:241
void addFunctor(const std::string &name, const Moose::FunctorBase< T > &functor, const THREAD_ID tid)
add a functor to the problem functor container
Definition: SubProblem.h:1375
virtual libMesh::System & system()=0
Get the reference to the libMesh system.
virtual NumericVector< Number > & solutionState(const unsigned int state, Moose::SolutionIterationType iteration_type=Moose::SolutionIterationType::Time)
Get a state of the solution (0 = current, 1 = old, 2 = older, etc).
Definition: SystemBase.C:1423
MeshBase & mesh
Factory & _factory
Definition: SystemBase.h:989
bool vectorTagNotZeroed(const TagID tag) const
Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors ar...
Definition: SubProblem.C:155
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
bool computingScalingJacobian() const
Whether we are computing an initial Jacobian for automatic variable scaling.
Definition: SystemBase.C:1544
NumericVector< Number > * _u_dotdot
solution vector for u^dotdot
Definition: SystemBase.h:1008
const Parallel::Communicator & comm() const
Order default_quadrature_order() const
NumericVector< Number > & add_vector(std::string_view vec_name, const bool projections=true, const ParallelType type=PARALLEL)
virtual void addVariableToCopy(const std::string &dest_name, const std::string &source_name, const std::string &timestep)
Add info about variable that will be copied.
Definition: SystemBase.C:1167
virtual bool hasMatrix(TagID tag) const
Check if the tagged matrix exists in the system.
Definition: SystemBase.h:360
virtual NumericVector< Number > * solutionUDotDotOld()
Definition: SystemBase.h:264
void removeMatrix(TagID tag)
Removes a matrix with a given tag.
Definition: SystemBase.C:590
virtual void associateMatrixToTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Associate a matrix to a tag.
Definition: SystemBase.C:1068
This class provides an interface for common operations on field variables of both FE and FV types wit...
const Parallel::Communicator & _communicator
virtual void prepareFace(THREAD_ID tid, bool resize_data)
Prepare the system for use on sides.
Definition: SystemBase.C:279
void addScalingVector()
Add the scaling factor vector to the system.
Definition: SystemBase.C:1537
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
void addTimeIntegrator(const std::string &type, const std::string &name, InputParameters &parameters)
Definition: SystemBase.C:1650
void setActiveVariableCoupleableVectorTags(const std::set< TagID > &vtags, THREAD_ID tid)
Set the active vector tags for the variables.
Definition: SystemBase.C:1612
Base class for a system (of equations)
Definition: SystemBase.h:84
std::vector< std::unique_ptr< NumericVector< Number > > > _raw_grad_container
A cache for storing gradients at dof locations.
Definition: SystemBase.h:1073
virtual void copyPreviousNonlinearSolutions()
Shifts the solutions backwards in nonlinear iteration history.
Definition: SystemBase.C:1261
virtual bool isArrayVariable(const std::string &var_name) const
If a variable is an array variable.
Definition: SystemBase.C:856
virtual void reinitNodes(const std::vector< dof_id_type > &nodes, THREAD_ID tid)
Reinit variables at a set of nodes.
Definition: SystemBase.C:422
std::unique_ptr< NumericVector< Number > > _serialized_solution
Serialized version of the solution vector, or nullptr if a serialized solution is not needed...
Definition: SystemBase.h:1068
const TagName PREVIOUS_FP_SOLUTION_TAG
Definition: MooseTypes.C:29
virtual void reinitNodesNeighbor(const std::vector< dof_id_type > &nodes, THREAD_ID tid)
Reinit variables at a set of neighbor nodes.
Definition: SystemBase.C:433
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
MooseVariableFV< T > & getFVVariable(THREAD_ID tid, const std::string &var_name)
Return a finite volume variable.
Definition: SystemBase.C:125
virtual void disassociateMatrixFromTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Disassociate a matrix from a tag.
Definition: SystemBase.C:1080
const std::set< dof_id_type > & getDofIndices() const
virtual void zero()=0
auto max(const L &left, const R &right)
NumericVector< Number > & addVector(const std::string &vector_name, const bool project, const libMesh::ParallelType type)
Adds a solution length vector to the system.
void update()
Update the system (doing libMesh magic)
Definition: SystemBase.C:1235
virtual unsigned int nVariables() const
Get the number of variables in this system.
Definition: SystemBase.C:883
void setActiveScalarVariableCoupleableVectorTags(const std::set< TagID > &vtags, THREAD_ID tid)
Set the active vector tags for the scalar variables.
Definition: SystemBase.C:1618
virtual void activateAllMatrixTags()
Make all existing matrices active.
Definition: SystemBase.C:1123
Grab all the (possibly semi)local dof indices for the variables passed in, in the system passed in...
virtual const std::string & name() const
Definition: SystemBase.C:1332
virtual void jacobianSetup()
Definition: SystemBase.C:1598
unsigned int n_dofs(const unsigned int s, const unsigned int var=libMesh::invalid_uint) const
void unsetf(std::ios_base::fmtflags mask) const
Unset format flags.
Definition: ConsoleStream.C:38
void closeTaggedMatrices(const std::set< TagID > &tags)
Close all matrices associated the tags.
Definition: SystemBase.C:1052
void paramError(const std::string &param, Args... args) const
Emits a parameter error prefixed with the parameter location and object information if available...
std::vector< VarCopyInfo > _var_to_copy
Definition: SystemBase.h:1040
virtual void flush()
virtual libMesh::DofMap & dofMap()
Gets writeable reference to the dof map.
Definition: SystemBase.C:1155
void sizeVariableMatrixData()
size the matrix data for each variable for the number of matrix tags we have
Definition: SystemBase.C:1711
virtual void deactivateAllMatrixTags()
Make matrices inactive.
Definition: SystemBase.C:1111
void libmesh_ignore(const Args &...)
void copyTimeIntegrators(const SystemBase &other_sys)
Copy time integrators from another system.
Definition: SystemBase.C:1659
CONSTANT
unsigned int number() const
SERIAL
virtual NumericVector< Number > & serializedSolution()
Returns a reference to a serialized version of the solution vector for this subproblem.
Definition: SystemBase.C:1638
void remove_vector(std::string_view vec_name)
virtual std::unique_ptr< Base > create()=0
void copyVars(libMesh::ExodusII_IO &io)
Definition: SystemBase.C:1175
int convert< int >(const std::string &str, bool throw_on_failure)
Definition: MooseUtils.C:1009
virtual const Number & duDotDu(unsigned int var_num=0) const
Definition: SystemBase.C:1693
unsigned int n_vars
virtual unsigned int n_nodes() const=0
const TagName OLD_SOLUTION_TAG
Definition: MooseTypes.C:26
void remove_matrix(std::string_view mat_name)
unsigned int n_components() const
virtual void zeroVariablesForResidual()
Zero out the solution for the variables that were registered as needing to have their solutions zeroe...
Definition: SystemBase.C:229
virtual unsigned int dimension() const
Returns MeshBase::mesh_dimension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh me...
Definition: MooseMesh.C:2928
std::string prefix() const
std::vector< bool > _matrix_tag_active_flags
Active flags for tagged matrices.
Definition: SystemBase.h:1027
GHOSTED
std::vector< std::string > _vars_to_be_zeroed_on_jacobian
Definition: SystemBase.h:1003
boundary_id_type BoundaryID
void copy_nodal_solution(System &system, std::string system_var_name, std::string exodus_var_name, unsigned int timestep=1)
Information about variables that will be copied.
Definition: SystemBase.h:66
virtual NumericVector< Number > * solutionUDot()
Definition: SystemBase.h:261
void hasScalingVector(const unsigned int nl_sys_num)
Tells this problem that the assembly associated with the given nonlinear system number involves a sca...
Definition: SubProblem.C:1170
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
virtual void prepareNeighbor(THREAD_ID tid)
Prepare the system for use.
Definition: SystemBase.C:324
An inteface for the _console for outputting to the Console object.
virtual NumericVector< Number > * solutionUDotOld()
Definition: SystemBase.h:263
virtual void reinitScalars(THREAD_ID tid, bool reinit_for_derivative_reordering=false)
Reinit scalar varaibles.
Definition: SystemBase.C:444
void copy_elemental_solution(System &system, std::string system_var_name, std::string exodus_var_name, unsigned int timestep=1)
SubProblem & _subproblem
The subproblem for whom this class holds variable data, etc; this can either be the governing finite ...
Definition: SystemBase.h:983
virtual bool uDotOldRequested()
Get boolean flag to check whether old solution time derivative needs to be stored.
bool have_vector(std::string_view vec_name) const
virtual bool matrixTagActive(TagID tag) const
If or not a matrix tag is active.
Definition: SystemBase.C:1141
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
virtual void reinitNeighborFace(const Elem *elem, unsigned int side, THREAD_ID tid)
Compute the values of the variables at all the current points.
Definition: SystemBase.C:374
unsigned int add_variable(std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
virtual void disassociateVectorFromTag(NumericVector< Number > &vec, TagID tag)
Disassociate a given vector from a given tag.
libMesh::SparseMatrix< Number > & addMatrix(TagID tag)
Adds a matrix with a given tag.
Definition: SystemBase.C:570
virtual void addDotVectors()
Add u_dot, u_dotdot, u_dot_old and u_dotdot_old vectors if requested by the time integrator.
Definition: SystemBase.C:1625
virtual std::set< dof_id_type > & ghostedElems()
Return the list of elements that should have their DoFs ghosted to this processor.
Definition: SubProblem.h:672
NumericVector< Real > * _saved_dot_old
Definition: SystemBase.h:1034
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
virtual bool hasSolutionState(const unsigned int state, Moose::SolutionIterationType iteration_type=Moose::SolutionIterationType::Time) const
Whether or not the system has the solution state (0 = current, 1 = old, 2 = older, etc).
Definition: SystemBase.h:1090
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1149
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
void closeTaggedVectors(const std::set< TagID > &tags)
Close all vectors for given tags.
Definition: SystemBase.C:667
virtual void reinitNeighbor(const Elem *elem, THREAD_ID tid)
Compute the values of the variables at all the current points.
Definition: SystemBase.C:382
void extraSendList(std::vector< dof_id_type > &send_list, void *context)
Free function used for a libMesh callback.
Definition: SystemBase.C:40
virtual void needSolutionState(const unsigned int state, Moose::SolutionIterationType iteration_type=Moose::SolutionIterationType::Time, libMesh::ParallelType parallel_type=GHOSTED)
Registers that the solution state state is needed.
Definition: SystemBase.C:1442
const std::vector< std::shared_ptr< TimeIntegrator > > & getTimeIntegrators()
Definition: SystemBase.C:1687
std::streamsize precision() const
Return the current precision.
Definition: ConsoleStream.C:44
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
Definition: SystemBase.C:843
virtual void solve()
virtual void close()=0
std::map< unsigned int, std::set< SubdomainID > > _var_map
Map of variables (variable id -> array of subdomains where it lives)
Definition: SystemBase.h:998
virtual void copySolutionsBackwards()
Copy current solution into old and older.
Definition: SystemBase.C:1250
virtual std::set< TagID > defaultMatrixTags() const
Get the default matrix tags associted with this system.
Definition: SystemBase.h:319
void copy_scalar_solution(System &system, std::vector< std::string > system_var_names, std::vector< std::string > exodus_var_names, unsigned int timestep=1)
virtual void solve()
Solve the system (using libMesh magic)
Definition: SystemBase.C:1241
virtual unsigned int numMatrixTags() const
The total number of tags.
Definition: SubProblem.h:248
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.
FEProblemBase & _fe_problem
the governing finite element/volume problem
Definition: SystemBase.h:986
virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a scalar variable with specified number.
Definition: SystemBase.C:145
ParallelType type() const
virtual void saveOldSolutions()
Save the old and older solutions.
Definition: SystemBase.C:510
std::vector< VariableWarehouse > _vars
Variable warehouses (one for each thread)
Definition: SystemBase.h:996
virtual void update()
virtual void close()=0
const FEType & variable_type(const unsigned int i) const
Base class for time integrators.
virtual void subdomainSetup()
Definition: SystemBase.C:1584
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
bool _verbose
True if printing out additional information.
Definition: SystemBase.h:1058
void removeVector(const std::string &name)
Remove a vector from the system with the given name.
Definition: SystemBase.C:1326
Class for containing MooseEnum item information.
Definition: MooseEnumItem.h:18
unsigned int nFVVariables() const
Get the number of finite volume variables in this system.
Definition: SystemBase.C:902
MooseMesh & _mesh
Definition: SystemBase.h:991
NumericVector< Number > * _u_dot
solution vector for u^dot
Definition: SystemBase.h:1006
virtual void addVariableToZeroOnResidual(std::string var_name)
Adds this variable to the list of variables to be zeroed during each residual evaluation.
Definition: SystemBase.C:174
MooseVariableFE< T > & getFieldVariable(THREAD_ID tid, const std::string &var_name)
Gets a reference to a variable of with specified name.
Definition: SystemBase.C:111
const Node * node_ptr(const unsigned int i) const
void prepareVariableNonlocal(MooseVariableFieldBase *var)
Definition: Assembly.C:2772
virtual libMesh::SparseMatrix< Number > & getMatrix(TagID tag)
Get a raw SparseMatrix.
Definition: SystemBase.C:1016
virtual void reinitNodeFace(const Node *node, BoundaryID bnd_id, THREAD_ID tid)
Reinit nodal assembly info on a face.
Definition: SystemBase.C:410
virtual void zeroVariablesForJacobian()
Zero out the solution for the variables that were registered as needing to have their solutions zeroe...
Definition: SystemBase.C:235
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num)=0
virtual std::set< TagID > defaultVectorTags() const
Get the default vector tags associated with this system.
Definition: SystemBase.h:312
TagName oldSolutionStateVectorName(const unsigned int, Moose::SolutionIterationType iteration_type) const
Gets the vector name used for an old (not current) solution state.
Definition: SystemBase.C:1373
Class for scalar variables (they are different).
IntRange< T > make_range(T beg, T end)
std::string prefix() const
Definition: SystemBase.C:1705
libMesh::ParallelType solutionStateParallelType(const unsigned int state, const Moose::SolutionIterationType iteration_type) const
Returns the parallel type of the given solution state.
Definition: SystemBase.C:1432
NumericVector< Real > * _saved_dotdot_old
Definition: SystemBase.h:1035
const std::vector< VariableName > & getVariableNames() const
Definition: SystemBase.h:860
virtual void prepare(THREAD_ID tid)
Prepare the system for use.
Definition: SystemBase.C:256
virtual void copyPreviousFixedPointSolutions()
Definition: SystemBase.C:1294
virtual void addVariableToZeroOnJacobian(std::string var_name)
Adds this variable to the list of variables to be zeroed during each Jacobian evaluation.
Definition: SystemBase.C:180
std::array< std::vector< NumericVector< Number > * >, 3 > _solution_states
2D array of solution state vector pointers; first index corresponds to SolutionIterationType, second index corresponds to state index (0=current, 1=old, 2=older)
Definition: SystemBase.h:1084
virtual const NumericVector< Number > * solutionPreviousNewton() const
Definition: SystemBase.C:1347
virtual void customSetup(const ExecFlagType &exec_type)
Definition: SystemBase.C:1577
const TimeIntegrator * queryTimeIntegrator(const unsigned int var_num) const
Retrieve the time integrator that integrates the given variable&#39;s equation.
Definition: SystemBase.C:1665
const std::set< SubdomainID > & getSubdomainsForVar(unsigned int var_number) const
Definition: SystemBase.h:761
void prepareVariable(MooseVariableFieldBase *var)
Used for preparing the dense residual and jacobian blocks for one particular variable.
Definition: Assembly.C:2744
virtual bool isScalarVariable(unsigned int var_name) const
Definition: SystemBase.C:877
unsigned int nFieldVariables() const
Get the number of field variables in this system.
Definition: SystemBase.C:892
virtual void set(const numeric_index_type i, const T value)=0
virtual void reinitElemFace(const Elem *elem, unsigned int side, THREAD_ID tid)
Reinit assembly info for a side of an element.
Definition: SystemBase.C:366
virtual TagName vectorTagName(const TagID tag) const
Retrieve the name associated with a TagID.
Definition: SubProblem.C:221
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
virtual bool hasActiveElementalMooseVariables(const THREAD_ID tid) const
Whether or not a list of active elemental moose variables has been set.
Definition: SubProblem.C:460
virtual void prepareLowerD(THREAD_ID tid)
Prepare the system for use for lower dimensional elements.
Definition: SystemBase.C:332
MooseVariableFieldBase & getVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a variable of with specified name.
Definition: SystemBase.C:90
const std::string & name() const
dof_id_type first_dof(const processor_id_type proc) const
unsigned int number() const
Real Number
virtual NumericVector< Number > * solutionUDotDot()
Definition: SystemBase.h:262
unsigned int n_vars() const
void setVariableGlobalDoFs(const std::string &var_name)
set all the global dof indices for a variable
Definition: SystemBase.C:186
std::vector< NumericVector< Number > * > _tagged_vectors
Tagged vectors (pointer)
Definition: SystemBase.h:1021
void prefix_with_name(bool value)
NumericVector< Number > & solutionOld()
Definition: SystemBase.h:197
SystemBase(SubProblem &subproblem, FEProblemBase &fe_problem, const std::string &name, Moose::VarKindType var_kind)
Definition: SystemBase.C:57
virtual bool hasScalarVariable(const std::string &var_name) const
Definition: SystemBase.C:868
const TagName PREVIOUS_NL_SOLUTION_TAG
Definition: MooseTypes.C:28
virtual void augmentSendList(std::vector< dof_id_type > &send_list)
Will modify the send_list to add all of the extra ghosted dofs for this system.
Definition: SystemBase.C:452
virtual void initialSetup()
Setup Functions.
Definition: SystemBase.C:1550
TYPE_VECTOR
bool active() const
virtual void restoreSolutions()
Restore current solutions (call after your solve failed)
Definition: SystemBase.C:1309
SparseMatrix< Number > & add_matrix(std::string_view mat_name, ParallelType type=PARALLEL, MatrixBuildType mat_build_type=MatrixBuildType::AUTOMATIC)
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
Definition: SystemBase.C:925
void extraSparsity(SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *context)
Free function used for a libMesh callback.
Definition: SystemBase.C:48
const DofMap & get_dof_map() const
virtual void residualSetup()
Definition: SystemBase.C:1591
std::vector< NumericVector< Number > * > _saved_solution_states
The saved solution states (0 = current, 1 = old, 2 = older, etc)
Definition: SystemBase.h:1086
virtual void disassociateDefaultMatrixTags()
Disassociate the matrices associated with the default matrix tags of this system. ...
Definition: SystemBase.C:1102
void clearAllDofIndices()
Clear all dof indices from moose variables.
Definition: SystemBase.C:1605
unsigned int _max_var_number
Maximum variable number.
Definition: SystemBase.h:1000
virtual void zeroVariables(std::vector< std::string > &vars_to_be_zeroed)
Zero out the solution for the list of variables passed in.
Definition: SystemBase.C:200
virtual void restoreOldSolutions()
Restore the old and older solutions when the saved solutions present.
Definition: SystemBase.C:542
void flushTaggedMatrices(const std::set< TagID > &tags)
flushes all matrices associated to tags.
Definition: SystemBase.C:1060
virtual bool matrixTagExists(const TagName &tag_name) const
Check to see if a particular Tag exists.
Definition: SubProblem.C:328
SolutionIterationType
Definition: MooseTypes.h:241
const NumericVector< Number > & get_vector(std::string_view vec_name) const
NumericVector< Number > * _u_dotdot_old
old solution vector for u^dotdot
Definition: SystemBase.h:1013
virtual TagName matrixTagName(TagID tag)
Retrieve the name associated with a TagID.
Definition: SubProblem.C:357
Base variable class.
unsigned int THREAD_ID
Definition: MooseTypes.h:209
SubdomainID getSubdomainID(const SubdomainName &subdomain_name) const
Get the associated subdomain ID for the subdomain name.
Definition: MooseMesh.C:1731
ParallelType
virtual void timestepSetup()
Definition: SystemBase.C:1570
MooseVariableField< T > & getActualFieldVariable(THREAD_ID tid, const std::string &var_name)
Returns a field variable pointer - this includes finite volume variables.
Definition: SystemBase.C:118
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.