https://mooseframework.inl.gov
FEProblemBase.h
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 #pragma once
11 
12 #ifdef MOOSE_KOKKOS_ENABLED
13 #include "KokkosAssembly.h"
14 #include "KokkosSystem.h"
15 #endif
16 
17 // MOOSE includes
18 #include "SubProblem.h"
19 #include "GeometricSearchData.h"
20 #include "MeshDivision.h"
21 #include "MortarData.h"
22 #include "ReporterData.h"
23 #include "Adaptivity.h"
27 #include "Restartable.h"
28 #include "SolverParams.h"
29 #include "PetscSupport.h"
30 #include "MooseApp.h"
32 #include "MaterialWarehouse.h"
33 #include "MooseVariableFE.h"
34 #include "MultiAppTransfer.h"
35 #include "Postprocessor.h"
36 #include "HashMap.h"
37 #include "VectorPostprocessor.h"
38 #include "PerfGraphInterface.h"
39 #include "Attributes.h"
40 #include "MooseObjectWarehouse.h"
43 #include "SolutionInvalidity.h"
44 #include "PetscSupport.h"
45 
46 #include "libmesh/enum_quadrature_type.h"
47 #include "libmesh/equation_systems.h"
48 
49 #include <unordered_map>
50 #include <memory>
51 
52 // Forward declarations
53 class AuxiliarySystem;
54 class DisplacedProblem;
55 class MooseMesh;
57 class LinearSystem;
58 class SolverSystem;
59 class NonlinearSystem;
60 class RandomInterface;
61 class RandomData;
64 class MultiMooseEnum;
66 class MaterialData;
67 class MooseEnum;
68 class Assembly;
69 class JacobianBlock;
70 class Control;
71 class MultiApp;
72 class TransientMultiApp;
74 class Indicator;
76 class Marker;
77 class Material;
78 class Transfer;
79 class XFEMInterface;
80 class SideUserObject;
81 class NodalUserObject;
82 class ElementUserObject;
85 class GeneralUserObject;
86 class Positions;
87 class Function;
88 class Distribution;
89 class Sampler;
90 class KernelBase;
91 class IntegratedBCBase;
92 class LineSearch;
93 class UserObject;
96 class Convergence;
98 class MortarUserObject;
99 class SolutionInvalidity;
100 
101 #ifdef MOOSE_KOKKOS_ENABLED
102 namespace Moose::Kokkos
103 {
105 }
106 #endif
107 
108 // libMesh forward declarations
109 namespace libMesh
110 {
111 class CouplingMatrix;
112 class NonlinearImplicitSystem;
113 class LinearImplicitSystem;
114 } // namespace libMesh
115 
117 {
118  ITERATING = 0,
119  // CONVERGED_RTOL_NORMAL = 1,
120  // CONVERGED_ATOL_NORMAL = 9,
121  CONVERGED_RTOL = 2,
122  CONVERGED_ATOL = 3,
123  CONVERGED_ITS = 4,
124  // CONVERGED_CG_NEG_CURVE = 5,
125  // CONVERGED_CG_CONSTRAINED = 6,
126  // CONVERGED_STEP_LENGTH = 7,
127  // CONVERGED_HAPPY_BREAKDOWN = 8,
128  DIVERGED_NULL = -2,
129  // DIVERGED_ITS = -3,
130  // DIVERGED_DTOL = -4,
131  // DIVERGED_BREAKDOWN = -5,
132  // DIVERGED_BREAKDOWN_BICG = -6,
133  // DIVERGED_NONSYMMETRIC = -7,
134  // DIVERGED_INDEFINITE_PC = -8,
135  DIVERGED_NANORINF = -9,
136  // DIVERGED_INDEFINITE_MAT = -10
138 };
139 
144 class FEProblemBase : public SubProblem, public Restartable
145 {
146 public:
147  static InputParameters validParams();
148 
150  virtual ~FEProblemBase();
151 
152  enum class CoverageCheckMode
153  {
154  FALSE,
155  TRUE,
156  OFF,
157  ON,
158  SKIP_LIST,
159  ONLY_LIST,
160  };
161 
162  virtual libMesh::EquationSystems & es() override { return _req.set().es(); }
163  virtual MooseMesh & mesh() override { return _mesh; }
164  virtual const MooseMesh & mesh() const override { return _mesh; }
165  const MooseMesh & mesh(bool use_displaced) const override;
166 
167  void setCoordSystem(const std::vector<SubdomainName> & blocks, const MultiMooseEnum & coord_sys);
168  void setAxisymmetricCoordAxis(const MooseEnum & rz_coord_axis);
169 
176 
178 
184  void setCouplingMatrix(std::unique_ptr<libMesh::CouplingMatrix> cm,
185  const unsigned int nl_sys_num);
186 
187  // DEPRECATED METHOD
188  void setCouplingMatrix(libMesh::CouplingMatrix * cm, const unsigned int nl_sys_num);
189 
190  const libMesh::CouplingMatrix * couplingMatrix(const unsigned int nl_sys_num) const override;
191 
194 
195  bool
196  areCoupled(const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const;
197 
201  bool hasUOAuxStateCheck() const { return _uo_aux_state_check; }
202 
210 
217 
218  std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> &
219  couplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num);
220  std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> &
221  nonlocalCouplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num);
222 
223  virtual bool hasVariable(const std::string & var_name) const override;
224  // NOTE: hasAuxiliaryVariable defined in parent class
225  bool hasSolverVariable(const std::string & var_name) const;
227  virtual const MooseVariableFieldBase &
228  getVariable(const THREAD_ID tid,
229  const std::string & var_name,
231  Moose::VarFieldType expected_var_field_type =
232  Moose::VarFieldType::VAR_FIELD_ANY) const override;
234  const std::string & var_name) override;
235  virtual MooseVariable & getStandardVariable(const THREAD_ID tid,
236  const std::string & var_name) override;
237  virtual VectorMooseVariable & getVectorVariable(const THREAD_ID tid,
238  const std::string & var_name) override;
239  virtual ArrayMooseVariable & getArrayVariable(const THREAD_ID tid,
240  const std::string & var_name) override;
241 
242  virtual bool hasScalarVariable(const std::string & var_name) const override;
243  virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid,
244  const std::string & var_name) override;
245  virtual libMesh::System & getSystem(const std::string & var_name) override;
246 
249 
256  virtual void setActiveElementalMooseVariables(const std::set<MooseVariableFEBase *> & moose_vars,
257  const THREAD_ID tid) override;
258 
266  virtual void clearActiveElementalMooseVariables(const THREAD_ID tid) override;
267 
268  virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid) override;
269 
270  virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid) override;
271 
272  virtual void setActiveFEVariableCoupleableVectorTags(std::set<TagID> & vtags,
273  const THREAD_ID tid) override;
274 
275  virtual void setActiveFEVariableCoupleableMatrixTags(std::set<TagID> & mtags,
276  const THREAD_ID tid) override;
277 
278  virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid) override;
279 
280  virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid) override;
281 
282  virtual void setActiveScalarVariableCoupleableVectorTags(std::set<TagID> & vtags,
283  const THREAD_ID tid) override;
284 
285  virtual void setActiveScalarVariableCoupleableMatrixTags(std::set<TagID> & mtags,
286  const THREAD_ID tid) override;
287 
289  libMesh::Order order,
290  libMesh::Order volume_order = libMesh::INVALID_ORDER,
293  bool allow_negative_qweights = true);
294 
303 
304  void bumpAllQRuleOrder(libMesh::Order order, SubdomainID block);
305 
309  unsigned int getMaxQps() const;
310 
315 
319  void checkNonlocalCoupling();
321  void setVariableAllDoFMap(const std::vector<const MooseVariableFEBase *> & moose_vars);
322 
323  const std::vector<const MooseVariableFEBase *> &
325  {
326  return _uo_jacobian_moose_vars[tid];
327  }
328 
329  virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override;
330  virtual const Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) const override;
331 
332 #ifdef MOOSE_KOKKOS_ENABLED
335 #endif
336 
340  virtual std::vector<VariableName> getVariableNames();
341 
342  void initialSetup() override;
344  void timestepSetup() override;
345  void customSetup(const ExecFlagType & exec_type) override;
346  void residualSetup() override;
347  void jacobianSetup() override;
348 
349  virtual void prepare(const Elem * elem, const THREAD_ID tid) override;
350  virtual void prepareFace(const Elem * elem, const THREAD_ID tid) override;
351  virtual void prepare(const Elem * elem,
352  unsigned int ivar,
353  unsigned int jvar,
354  const std::vector<dof_id_type> & dof_indices,
355  const THREAD_ID tid) override;
356 
357  virtual void setCurrentSubdomainID(const Elem * elem, const THREAD_ID tid) override;
358  virtual void
359  setNeighborSubdomainID(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
360  virtual void setNeighborSubdomainID(const Elem * elem, const THREAD_ID tid);
361  virtual void prepareAssembly(const THREAD_ID tid) override;
362 
363  virtual void addGhostedElem(dof_id_type elem_id) override;
364  virtual void addGhostedBoundary(BoundaryID boundary_id) override;
365  virtual void ghostGhostedBoundaries() override;
366 
367  virtual void sizeZeroes(unsigned int size, const THREAD_ID tid);
368  virtual bool reinitDirac(const Elem * elem, const THREAD_ID tid) override;
369 
370  virtual void reinitElem(const Elem * elem, const THREAD_ID tid) override;
371  virtual void reinitElemPhys(const Elem * elem,
372  const std::vector<Point> & phys_points_in_elem,
373  const THREAD_ID tid) override;
374  void reinitElemFace(const Elem * elem, unsigned int side, BoundaryID, const THREAD_ID tid);
375  virtual void reinitElemFace(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
376  virtual void reinitLowerDElem(const Elem * lower_d_elem,
377  const THREAD_ID tid,
378  const std::vector<Point> * const pts = nullptr,
379  const std::vector<Real> * const weights = nullptr) override;
380  virtual void reinitNode(const Node * node, const THREAD_ID tid) override;
381  virtual void reinitNodeFace(const Node * node, BoundaryID bnd_id, const THREAD_ID tid) override;
382  virtual void reinitNodes(const std::vector<dof_id_type> & nodes, const THREAD_ID tid) override;
383  virtual void reinitNodesNeighbor(const std::vector<dof_id_type> & nodes,
384  const THREAD_ID tid) override;
385  virtual void reinitNeighbor(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
386  virtual void reinitNeighborPhys(const Elem * neighbor,
387  unsigned int neighbor_side,
388  const std::vector<Point> & physical_points,
389  const THREAD_ID tid) override;
390  virtual void reinitNeighborPhys(const Elem * neighbor,
391  const std::vector<Point> & physical_points,
392  const THREAD_ID tid) override;
393  virtual void
394  reinitElemNeighborAndLowerD(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
395  virtual void reinitScalars(const THREAD_ID tid,
396  bool reinit_for_derivative_reordering = false) override;
397  virtual void reinitOffDiagScalars(const THREAD_ID tid) override;
398 
400  virtual void getDiracElements(std::set<const Elem *> & elems) override;
401  virtual void clearDiracInfo() override;
402 
403  virtual void subdomainSetup(SubdomainID subdomain, const THREAD_ID tid);
404  virtual void neighborSubdomainSetup(SubdomainID subdomain, const THREAD_ID tid);
405 
406  virtual void newAssemblyArray(std::vector<std::shared_ptr<SolverSystem>> & solver_systems);
407  virtual void initNullSpaceVectors(const InputParameters & parameters,
408  std::vector<std::shared_ptr<NonlinearSystemBase>> & nl);
409 
410  virtual void init() override;
411  virtual void solve(const unsigned int nl_sys_num);
412 
413 #ifdef MOOSE_KOKKOS_ENABLED
414 
417  void initKokkos();
418 #endif
419 
425  virtual void solveLinearSystem(const unsigned int linear_sys_num,
426  const Moose::PetscSupport::PetscOptions * po = nullptr);
427 
429 
448 
450 
465 
467 
488 
497  virtual void setException(const std::string & message);
498 
502  virtual bool hasException() { return _has_exception; }
503 
520  virtual void checkExceptionAndStopSolve(bool print_message = true);
521 
522  virtual bool solverSystemConverged(const unsigned int solver_sys_num) override;
523  virtual unsigned int nNonlinearIterations(const unsigned int nl_sys_num) const override;
524  virtual unsigned int nLinearIterations(const unsigned int nl_sys_num) const override;
525  virtual Real finalNonlinearResidual(const unsigned int nl_sys_num) const override;
526  virtual bool computingPreSMOResidual(const unsigned int nl_sys_num) const override;
527 
531  virtual std::string solverTypeString(unsigned int solver_sys_num = 0);
532 
536  virtual bool startedInitialSetup() { return _started_initial_setup; }
537 
538  virtual void onTimestepBegin() override;
539  virtual void onTimestepEnd() override;
540 
541  virtual Real & time() const { return _time; }
542  virtual Real & timeOld() const { return _time_old; }
543  virtual int & timeStep() const { return _t_step; }
544  virtual Real & dt() const { return _dt; }
545  virtual Real & dtOld() const { return _dt_old; }
549  Real getTimeFromStateArg(const Moose::StateArg & state) const;
550 
551  virtual void transient(bool trans) { _transient = trans; }
552  virtual bool isTransient() const override { return _transient; }
553 
554  virtual void addTimeIntegrator(const std::string & type,
555  const std::string & name,
557  virtual void
558  addPredictor(const std::string & type, const std::string & name, InputParameters & parameters);
559 
560  virtual void copySolutionsBackwards();
561 
566  virtual void advanceState();
567 
568  virtual void restoreSolutions();
569 
573  virtual void saveOldSolutions();
574 
578  virtual void restoreOldSolutions();
579 
585  void needSolutionState(unsigned int oldest_needed, Moose::SolutionIterationType iteration_type);
586 
593  virtual void outputStep(ExecFlagType type);
594 
598  virtual void postExecute();
599 
601 
607  void allowOutput(bool state);
608  template <typename T>
609  void allowOutput(bool state);
611 
620  void forceOutput();
621 
627 
632 
636  void logAdd(const std::string & system,
637  const std::string & name,
638  const std::string & type,
639  const InputParameters & params) const;
640 
641  // Function /////
642  virtual void
643  addFunction(const std::string & type, const std::string & name, InputParameters & parameters);
644  virtual bool hasFunction(const std::string & name, const THREAD_ID tid = 0);
645  virtual Function & getFunction(const std::string & name, const THREAD_ID tid = 0);
646 
648  virtual void
649  addMeshDivision(const std::string & type, const std::string & name, InputParameters & params);
651  MeshDivision & getMeshDivision(const std::string & name, const THREAD_ID tid = 0) const;
652 
654  virtual void
655  addConvergence(const std::string & type, const std::string & name, InputParameters & parameters);
657  virtual Convergence & getConvergence(const std::string & name, const THREAD_ID tid = 0) const;
659  virtual const std::vector<std::shared_ptr<Convergence>> &
660  getConvergenceObjects(const THREAD_ID tid = 0) const;
662  virtual bool hasConvergence(const std::string & name, const THREAD_ID tid = 0) const;
665  {
667  }
670  {
672  }
675  {
677  }
680  {
682  }
685  {
687  }
690  {
692  }
695  {
696  return _multiapp_fixed_point_convergence_name.has_value();
697  }
700  {
701  return _steady_state_convergence_name.has_value();
702  }
710  virtual void addDefaultNonlinearConvergence(const InputParameters & params);
718  virtual bool onlyAllowDefaultNonlinearConvergence() const { return false; }
735 
739  virtual void addLineSearch(const InputParameters & /*parameters*/)
740  {
741  mooseError("Line search not implemented for this problem type yet.");
742  }
743 
747  virtual void lineSearch();
748 
752  LineSearch * getLineSearch() override { return _line_search.get(); }
753 
757  virtual void
758  addDistribution(const std::string & type, const std::string & name, InputParameters & parameters);
759  virtual Distribution & getDistribution(const std::string & name);
760 
764  virtual void
765  addSampler(const std::string & type, const std::string & name, InputParameters & parameters);
766  virtual Sampler & getSampler(const std::string & name, const THREAD_ID tid = 0);
767 
768  // NL /////
769  NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num);
770  const NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num) const;
771  void setCurrentNonlinearSystem(const unsigned int nl_sys_num);
774 
775  virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const override;
776  virtual SystemBase & systemBaseNonlinear(const unsigned int sys_num) override;
777 
778  virtual const SystemBase & systemBaseSolver(const unsigned int sys_num) const override;
779  virtual SystemBase & systemBaseSolver(const unsigned int sys_num) override;
780 
781  virtual const SystemBase & systemBaseAuxiliary() const override;
782  virtual SystemBase & systemBaseAuxiliary() override;
783 
784  virtual NonlinearSystem & getNonlinearSystem(const unsigned int sys_num);
785 
786 #ifdef MOOSE_KOKKOS_ENABLED
787 
794  {
795  return _kokkos_systems;
796  }
798 
804  Moose::Kokkos::System & getKokkosSystem(const unsigned int sys_num);
806  const Moose::Kokkos::System & getKokkosSystem(const unsigned int sys_num) const;
808 #endif
809 
814  virtual const SystemBase & getSystemBase(const unsigned int sys_num) const;
815 
820  virtual SystemBase & getSystemBase(const unsigned int sys_num);
821 
826  SystemBase & getSystemBase(const std::string & sys_name);
827 
832  LinearSystem & getLinearSystem(unsigned int sys_num);
833 
838  const LinearSystem & getLinearSystem(unsigned int sys_num) const;
839 
844  SolverSystem & getSolverSystem(unsigned int sys_num);
845 
850  const SolverSystem & getSolverSystem(unsigned int sys_num) const;
851 
856  void setCurrentLinearSystem(unsigned int sys_num);
857 
861  const LinearSystem & currentLinearSystem() const;
862 
867  virtual const SystemBase & systemBaseLinear(unsigned int sys_num) const override;
868 
873  virtual SystemBase & systemBaseLinear(unsigned int sys_num) override;
874 
881  virtual void
882  addVariable(const std::string & var_type, const std::string & var_name, InputParameters & params);
883 
884  virtual void addKernel(const std::string & kernel_name,
885  const std::string & name,
887  virtual void addHDGKernel(const std::string & kernel_name,
888  const std::string & name,
890  virtual void addNodalKernel(const std::string & kernel_name,
891  const std::string & name,
893  virtual void addScalarKernel(const std::string & kernel_name,
894  const std::string & name,
896  virtual void addBoundaryCondition(const std::string & bc_name,
897  const std::string & name,
899 
900 #ifdef MOOSE_KOKKOS_ENABLED
901  virtual void addKokkosKernel(const std::string & kernel_name,
902  const std::string & name,
904  virtual void addKokkosNodalKernel(const std::string & kernel_name,
905  const std::string & name,
907  virtual void addKokkosBoundaryCondition(const std::string & bc_name,
908  const std::string & name,
910 #endif
911 
912  virtual void
913  addConstraint(const std::string & c_name, const std::string & name, InputParameters & parameters);
914 
916  {
917  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
918  }
919 
920  // Aux /////
921 
928  virtual void addAuxVariable(const std::string & var_type,
929  const std::string & var_name,
930  InputParameters & params);
931 
932  virtual void addAuxVariable(const std::string & var_name,
933  const libMesh::FEType & type,
934  const std::set<SubdomainID> * const active_subdomains = NULL);
935  virtual void addAuxArrayVariable(const std::string & var_name,
936  const libMesh::FEType & type,
937  unsigned int components,
938  const std::set<SubdomainID> * const active_subdomains = NULL);
939  virtual void addAuxScalarVariable(const std::string & var_name,
940  libMesh::Order order,
941  Real scale_factor = 1.,
942  const std::set<SubdomainID> * const active_subdomains = NULL);
943  virtual void addAuxKernel(const std::string & kernel_name,
944  const std::string & name,
946  virtual void addAuxScalarKernel(const std::string & kernel_name,
947  const std::string & name,
949 
950 #ifdef MOOSE_KOKKOS_ENABLED
951  virtual void addKokkosAuxKernel(const std::string & kernel_name,
952  const std::string & name,
954 #endif
955 
957 
958  // Dirac /////
959  virtual void addDiracKernel(const std::string & kernel_name,
960  const std::string & name,
962 
963  // DG /////
964  virtual void addDGKernel(const std::string & kernel_name,
965  const std::string & name,
967  // FV /////
968  virtual void addFVKernel(const std::string & kernel_name,
969  const std::string & name,
971 
972  virtual void addLinearFVKernel(const std::string & kernel_name,
973  const std::string & name,
975  virtual void
976  addFVBC(const std::string & fv_bc_name, const std::string & name, InputParameters & parameters);
977  virtual void addLinearFVBC(const std::string & fv_bc_name,
978  const std::string & name,
980 
981  virtual void addFVInterfaceKernel(const std::string & fv_ik_name,
982  const std::string & name,
984 
985  // Interface /////
986  virtual void addInterfaceKernel(const std::string & kernel_name,
987  const std::string & name,
989 
990  // IC /////
991  virtual void addInitialCondition(const std::string & ic_name,
992  const std::string & name,
1000  virtual void addFVInitialCondition(const std::string & ic_name,
1001  const std::string & name,
1003 
1004  void projectSolution();
1005 
1010  unsigned short getCurrentICState();
1011 
1021  libMesh::ConstElemRange & elem_range,
1022  ConstBndNodeRange & bnd_node_range,
1023  const std::optional<std::set<VariableName>> & target_vars = std::nullopt);
1024 
1039  void projectFunctionOnCustomRange(ConstElemRange & elem_range,
1040  Number (*func)(const Point &,
1041  const libMesh::Parameters &,
1042  const std::string &,
1043  const std::string &),
1044  Gradient (*func_grad)(const Point &,
1045  const libMesh::Parameters &,
1046  const std::string &,
1047  const std::string &),
1048  const libMesh::Parameters & params,
1049  const VariableName & target_var);
1050 
1051  // Materials
1052  virtual void addMaterial(const std::string & material_name,
1053  const std::string & name,
1055  virtual void addMaterialHelper(std::vector<MaterialWarehouse *> warehouse,
1056  const std::string & material_name,
1057  const std::string & name,
1059  virtual void addInterfaceMaterial(const std::string & material_name,
1060  const std::string & name,
1062  virtual void addFunctorMaterial(const std::string & functor_material_name,
1063  const std::string & name,
1065 
1066 #ifdef MOOSE_KOKKOS_ENABLED
1067  virtual void addKokkosMaterial(const std::string & material_name,
1068  const std::string & name,
1070 #endif
1071 
1083  void prepareMaterials(const std::unordered_set<unsigned int> & consumer_needed_mat_props,
1084  const SubdomainID blk_id,
1085  const THREAD_ID tid);
1086 
1087  void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful = true);
1088 
1098  void reinitMaterialsFace(SubdomainID blk_id,
1099  const THREAD_ID tid,
1100  bool swap_stateful = true,
1101  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1102 
1114  void
1115  reinitMaterialsFaceOnBoundary(const BoundaryID boundary_id,
1116  const SubdomainID blk_id,
1117  const THREAD_ID tid,
1118  const bool swap_stateful = true,
1119  const std::deque<MaterialBase *> * const reinit_mats = nullptr);
1120 
1132  void
1134  const SubdomainID blk_id,
1135  const THREAD_ID tid,
1136  const bool swap_stateful = true,
1137  const std::deque<MaterialBase *> * const reinit_mats = nullptr);
1138 
1149  const THREAD_ID tid,
1150  bool swap_stateful = true,
1151  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1152 
1165  void reinitMaterialsBoundary(BoundaryID boundary_id,
1166  const THREAD_ID tid,
1167  bool swap_stateful = true,
1168  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1169 
1170  void
1171  reinitMaterialsInterface(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful = true);
1172 
1173 #ifdef MOOSE_KOKKOS_ENABLED
1174  void prepareKokkosMaterials(const std::unordered_set<unsigned int> & consumer_needed_mat_props);
1175  void reinitKokkosMaterials();
1176 #endif
1177 
1178  /*
1179  * Swap back underlying data storing stateful material properties
1180  */
1181  virtual void swapBackMaterials(const THREAD_ID tid);
1182  virtual void swapBackMaterialsFace(const THREAD_ID tid);
1183  virtual void swapBackMaterialsNeighbor(const THREAD_ID tid);
1184 
1191  void setActiveMaterialProperties(const std::unordered_set<unsigned int> & mat_prop_ids,
1192  const THREAD_ID tid);
1193 
1202  bool hasActiveMaterialProperties(const THREAD_ID tid) const;
1203 
1209  void clearActiveMaterialProperties(const THREAD_ID tid);
1210 
1222  template <typename T>
1223  std::vector<std::shared_ptr<T>> addObject(const std::string & type,
1224  const std::string & name,
1226  const bool threaded = true,
1227  const std::string & var_param_name = "variable");
1228 
1229  // Postprocessors /////
1230  virtual void addPostprocessor(const std::string & pp_name,
1231  const std::string & name,
1233 
1234  // VectorPostprocessors /////
1235  virtual void addVectorPostprocessor(const std::string & pp_name,
1236  const std::string & name,
1238 
1247  virtual void
1248  addReporter(const std::string & type, const std::string & name, InputParameters & parameters);
1249 
1257  const ReporterData & getReporterData() const { return _reporter_data; }
1258 
1265 
1266  // UserObjects /////
1267  virtual std::vector<std::shared_ptr<UserObject>> addUserObject(
1268  const std::string & user_object_name, const std::string & name, InputParameters & parameters);
1269 
1270  // TODO: delete this function after apps have been updated to not call it
1272  {
1274  "This function is deprecated, use theWarehouse().query() to construct a query instead");
1275  return _all_user_objects;
1276  }
1277 
1283  template <class T>
1284  T & getUserObject(const std::string & name, unsigned int tid = 0) const
1285  {
1286  std::vector<T *> objs;
1287  theWarehouse()
1288  .query()
1289  .condition<AttribSystem>("UserObject")
1290  .condition<AttribThread>(tid)
1291  .condition<AttribName>(name)
1292  .queryInto(objs);
1293  if (objs.empty())
1294  mooseError("Unable to find user object with name '" + name + "'");
1295  return *(objs[0]);
1296  }
1303  const UserObject & getUserObjectBase(const std::string & name, const THREAD_ID tid = 0) const;
1304 
1310  const Positions & getPositionsObject(const std::string & name) const;
1311 
1317  bool hasUserObject(const std::string & name) const;
1318 
1327  bool hasPostprocessorValueByName(const PostprocessorName & name) const;
1328 
1339  const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName & name,
1340  std::size_t t_index = 0) const;
1341 
1356  void setPostprocessorValueByName(const PostprocessorName & name,
1357  const PostprocessorValue & value,
1358  std::size_t t_index = 0);
1359 
1363  bool hasPostprocessor(const std::string & name) const;
1364 
1375  const VectorPostprocessorValue &
1376  getVectorPostprocessorValueByName(const std::string & object_name,
1377  const std::string & vector_name,
1378  std::size_t t_index = 0) const;
1379 
1387  void setVectorPostprocessorValueByName(const std::string & object_name,
1388  const std::string & vector_name,
1389  const VectorPostprocessorValue & value,
1390  std::size_t t_index = 0);
1391 
1400  const VectorPostprocessor & getVectorPostprocessorObjectByName(const std::string & object_name,
1401  const THREAD_ID tid = 0) const;
1402 
1404 
1407  bool hasMultiApps() const { return _multi_apps.hasActiveObjects(); }
1408  bool hasMultiApps(ExecFlagType type) const;
1409  bool hasMultiApp(const std::string & name) const;
1411 
1412  // Dampers /////
1413  virtual void addDamper(const std::string & damper_name,
1414  const std::string & name,
1416  void setupDampers();
1417 
1421  bool hasDampers() { return _has_dampers; }
1422 
1423  // Indicators /////
1424  virtual void addIndicator(const std::string & indicator_name,
1425  const std::string & name,
1427 
1428  // Markers //////
1429  virtual void addMarker(const std::string & marker_name,
1430  const std::string & name,
1432 
1436  virtual void addMultiApp(const std::string & multi_app_name,
1437  const std::string & name,
1439 
1443  std::shared_ptr<MultiApp> getMultiApp(const std::string & multi_app_name) const;
1444 
1448  std::vector<std::shared_ptr<Transfer>> getTransfers(ExecFlagType type,
1449  Transfer::DIRECTION direction) const;
1450  std::vector<std::shared_ptr<Transfer>> getTransfers(Transfer::DIRECTION direction) const;
1451 
1457 
1464 
1468  bool execMultiApps(ExecFlagType type, bool auto_advance = true);
1469 
1470  void finalizeMultiApps();
1471 
1476 
1482  {
1483  mooseDeprecated("Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep "
1484  "depending on your purpose");
1486  }
1487 
1492  void finishMultiAppStep(ExecFlagType type, bool recurse_through_multiapp_levels = false);
1493 
1498 
1503  void restoreMultiApps(ExecFlagType type, bool force = false);
1504 
1509 
1513  virtual void addTransfer(const std::string & transfer_name,
1514  const std::string & name,
1516 
1524 
1530 
1536 
1543  virtual Real computeResidualL2Norm();
1544 
1549  const NumericVector<libMesh::Number> & soln,
1550  NumericVector<libMesh::Number> & residual);
1556  const NumericVector<libMesh::Number> & soln,
1557  NumericVector<libMesh::Number> & residual);
1558 
1562  virtual void computeResidual(const NumericVector<libMesh::Number> & soln,
1563  NumericVector<libMesh::Number> & residual,
1564  const unsigned int nl_sys_num);
1565 
1569  void computeResidualAndJacobian(const NumericVector<libMesh::Number> & soln,
1570  NumericVector<libMesh::Number> & residual,
1572 
1576  virtual void computeResidualTag(const NumericVector<libMesh::Number> & soln,
1577  NumericVector<libMesh::Number> & residual,
1578  TagID tag);
1582  virtual void computeResidualType(const NumericVector<libMesh::Number> & soln,
1583  NumericVector<libMesh::Number> & residual,
1584  TagID tag);
1585 
1590  virtual void computeResidualInternal(const NumericVector<libMesh::Number> & soln,
1591  NumericVector<libMesh::Number> & residual,
1592  const std::set<TagID> & tags);
1596  virtual void computeResidualTags(const std::set<TagID> & tags);
1597 
1602  const NumericVector<libMesh::Number> & soln,
1607  virtual void computeJacobian(const NumericVector<libMesh::Number> & soln,
1609  const unsigned int nl_sys_num);
1610 
1614  virtual void computeJacobianTag(const NumericVector<libMesh::Number> & soln,
1616  TagID tag);
1617 
1621  virtual void computeJacobianInternal(const NumericVector<libMesh::Number> & soln,
1623  const std::set<TagID> & tags);
1624 
1628  virtual void computeJacobianTags(const std::set<TagID> & tags);
1629 
1638  virtual void computeJacobianBlocks(std::vector<JacobianBlock *> & blocks,
1639  const unsigned int nl_sys_num);
1640 
1655  libMesh::System & precond_system,
1656  unsigned int ivar,
1657  unsigned int jvar);
1658 
1670  NumericVector<libMesh::Number> & rhs,
1671  const bool compute_gradients = true);
1672 
1682  void computeLinearSystemTags(const NumericVector<libMesh::Number> & soln,
1683  const std::set<TagID> & vector_tags,
1684  const std::set<TagID> & matrix_tags,
1685  const bool compute_gradients = true);
1686 
1687  virtual Real computeDamping(const NumericVector<libMesh::Number> & soln,
1688  const NumericVector<libMesh::Number> & update);
1689 
1694  virtual bool shouldUpdateSolution();
1695 
1702  virtual bool updateSolution(NumericVector<libMesh::Number> & vec_solution,
1703  NumericVector<libMesh::Number> & ghosted_solution);
1704 
1709  virtual void predictorCleanup(NumericVector<libMesh::Number> & ghosted_solution);
1710 
1712  NumericVector<libMesh::Number> & lower,
1713  NumericVector<libMesh::Number> & upper);
1715  std::vector<NumericVector<libMesh::Number> *> & sp);
1717  std::vector<NumericVector<libMesh::Number> *> & sp);
1719  std::vector<NumericVector<libMesh::Number> *> & sp);
1721  const NumericVector<libMesh::Number> & old_soln,
1722  NumericVector<libMesh::Number> & search_direction,
1723  NumericVector<libMesh::Number> & new_soln,
1724  bool & changed_search_direction,
1725  bool & changed_new_soln);
1726 
1727  virtual void computeIndicatorsAndMarkers();
1728  virtual void computeIndicators();
1729  virtual void computeMarkers();
1730 
1731  virtual void addResidual(const THREAD_ID tid) override;
1732  virtual void addResidualNeighbor(const THREAD_ID tid) override;
1733  virtual void addResidualLower(const THREAD_ID tid) override;
1734  virtual void addResidualScalar(const THREAD_ID tid = 0);
1735 
1736  virtual void cacheResidual(const THREAD_ID tid) override;
1737  virtual void cacheResidualNeighbor(const THREAD_ID tid) override;
1738  virtual void addCachedResidual(const THREAD_ID tid) override;
1739 
1747  virtual void addCachedResidualDirectly(NumericVector<libMesh::Number> & residual,
1748  const THREAD_ID tid);
1749 
1750  virtual void setResidual(NumericVector<libMesh::Number> & residual, const THREAD_ID tid) override;
1751  virtual void setResidualNeighbor(NumericVector<libMesh::Number> & residual,
1752  const THREAD_ID tid) override;
1753 
1754  virtual void addJacobian(const THREAD_ID tid) override;
1755  virtual void addJacobianNeighbor(const THREAD_ID tid) override;
1756  virtual void addJacobianNeighborLowerD(const THREAD_ID tid) override;
1757  virtual void addJacobianLowerD(const THREAD_ID tid) override;
1759  unsigned int ivar,
1760  unsigned int jvar,
1761  const DofMap & dof_map,
1762  std::vector<dof_id_type> & dof_indices,
1763  const std::set<TagID> & tags,
1764  const THREAD_ID tid);
1766  unsigned int ivar,
1767  unsigned int jvar,
1768  const DofMap & dof_map,
1769  std::vector<dof_id_type> & dof_indices,
1770  std::vector<dof_id_type> & neighbor_dof_indices,
1771  const std::set<TagID> & tags,
1772  const THREAD_ID tid) override;
1773  virtual void addJacobianScalar(const THREAD_ID tid = 0);
1774  virtual void addJacobianOffDiagScalar(unsigned int ivar, const THREAD_ID tid = 0);
1775 
1776  virtual void cacheJacobian(const THREAD_ID tid) override;
1777  virtual void cacheJacobianNeighbor(const THREAD_ID tid) override;
1778  virtual void addCachedJacobian(const THREAD_ID tid) override;
1779 
1780  virtual void prepareShapes(unsigned int var, const THREAD_ID tid) override;
1781  virtual void prepareFaceShapes(unsigned int var, const THREAD_ID tid) override;
1782  virtual void prepareNeighborShapes(unsigned int var, const THREAD_ID tid) override;
1783 
1784  // Displaced problem /////
1785  virtual void addDisplacedProblem(std::shared_ptr<DisplacedProblem> displaced_problem);
1786  virtual std::shared_ptr<const DisplacedProblem> getDisplacedProblem() const
1787  {
1788  return _displaced_problem;
1789  }
1790  virtual std::shared_ptr<DisplacedProblem> getDisplacedProblem() { return _displaced_problem; }
1791 
1792  virtual void updateGeomSearch(
1794  virtual void updateMortarMesh();
1795 
1796  void createMortarInterface(
1797  const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1798  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1799  bool on_displaced,
1800  bool periodic,
1801  const bool debug,
1802  const bool correct_edge_dropping,
1803  const Real minimum_projection_angle);
1804 
1811  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1812  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1813  bool on_displaced) const;
1814 
1816  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1817  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1818  bool on_displaced);
1820 
1821  const std::unordered_map<std::pair<BoundaryID, BoundaryID>, AutomaticMortarGeneration> &
1822  getMortarInterfaces(bool on_displaced) const;
1823 
1824  virtual void possiblyRebuildGeomSearchPatches();
1825 
1827 
1832  void setRestartFile(const std::string & file_name);
1833 
1838  {
1839  return _material_prop_registry;
1840  }
1841 
1850  {
1851  return _neighbor_material_props;
1852  }
1853 
1854 #ifdef MOOSE_KOKKOS_ENABLED
1856  {
1857  return _kokkos_material_props;
1858  }
1860  {
1862  }
1864  {
1866  }
1867 #endif
1868 
1876  {
1878  }
1881 
1886 
1891 
1895  SolverParams & solverParams(unsigned int solver_sys_num = 0);
1896 
1900  const SolverParams & solverParams(unsigned int solver_sys_num = 0) const;
1901 
1902 #ifdef LIBMESH_ENABLE_AMR
1903  // Adaptivity /////
1905  virtual void initialAdaptMesh();
1906 
1910  virtual bool adaptMesh();
1911 
1915  unsigned int getNumCyclesCompleted() { return _cycles_completed; }
1916 
1920  bool hasInitialAdaptivity() const { return _adaptivity.getInitialSteps() > 0; }
1921 #else
1922 
1925  bool hasInitialAdaptivity() const { return false; }
1926 #endif // LIBMESH_ENABLE_AMR
1927 
1929  void initXFEM(std::shared_ptr<XFEMInterface> xfem);
1930 
1932  std::shared_ptr<XFEMInterface> getXFEM() { return _xfem; }
1933 
1935  bool haveXFEM() { return _xfem != nullptr; }
1936 
1938  virtual bool updateMeshXFEM();
1939 
1954  virtual void
1955  meshChanged(bool intermediate_change, bool contract_mesh, bool clean_refinement_flags);
1956 
1962 
1968 
1974  void initElementStatefulProps(const libMesh::ConstElemRange & elem_range, const bool threaded);
1975 
1976 #ifdef MOOSE_KOKKOS_ENABLED
1977  void initKokkosStatefulProps();
1978 #endif
1979 
1984  virtual void checkProblemIntegrity();
1985 
1986  void registerRandomInterface(RandomInterface & random_interface, const std::string & name);
1987 
1992  void setConstJacobian(bool state) { _const_jacobian = state; }
1993 
1999 
2004  void setKernelCoverageCheck(bool flag)
2005  {
2007  }
2008 
2016 
2024  {
2026  }
2027 
2032 
2034  void setVerboseProblem(bool verbose);
2035 
2039  bool verboseMultiApps() const { return _verbose_multiapps; }
2040 
2045 
2047 
2064  bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid);
2065  bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid);
2066  bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, const THREAD_ID tid);
2068 
2073  unsigned int subspaceDim(const std::string & prefix) const
2074  {
2075  if (_subspace_dim.count(prefix))
2076  return _subspace_dim.find(prefix)->second;
2077  else
2078  return 0;
2079  }
2080 
2081  /*
2082  * Return a reference to the material warehouse of *all* Material objects.
2083  */
2085 
2086  /*
2087  * Return a reference to the material warehouse of Material objects to be computed.
2088  */
2092 
2093 #ifdef MOOSE_KOKKOS_ENABLED
2094  /*
2095  * Return a reference to the material warehouse of Kokkos Material objects to be computed.
2096  */
2098 #endif
2099 
2107  std::shared_ptr<MaterialBase> getMaterial(std::string name,
2109  const THREAD_ID tid = 0,
2110  bool no_warn = false);
2111 
2116  const THREAD_ID tid = 0,
2117  const MooseObject * object = nullptr) const;
2118 
2119 #ifdef MOOSE_KOKKOS_ENABLED
2120 
2124  const MooseObject * object = nullptr) const;
2125 #endif
2126 
2130  const std::set<const MooseObject *> &
2132 
2133 #ifdef MOOSE_KOKKOS_ENABLED
2134 
2137  const std::set<const MooseObject *> &
2139 #endif
2140 
2145 
2151  {
2153  }
2154 
2156  {
2158  }
2159 
2165 
2169  void setPreserveMatrixSparsityPattern(bool preserve);
2170 
2176 
2179 
2186  bool acceptInvalidSolution() const;
2191 
2196 
2201 
2203  bool hasTimeIntegrator() const { return _has_time_integrator; }
2204 
2206 
2212  const ExecFlagType & getCurrentExecuteOnFlag() const;
2213  void setCurrentExecuteOnFlag(const ExecFlagType &);
2215 
2219  virtual void execute(const ExecFlagType & exec_type);
2220  virtual void executeAllObjects(const ExecFlagType & exec_type);
2221 
2222  virtual Executor & getExecutor(const std::string & name) { return _app.getExecutor(name); }
2223 
2227  virtual void computeUserObjects(const ExecFlagType & type, const Moose::AuxGroup & group);
2228 
2232  virtual void computeUserObjectByName(const ExecFlagType & type,
2233  const Moose::AuxGroup & group,
2234  const std::string & name);
2235 
2239  void needsPreviousNewtonIteration(bool state);
2240 
2245  bool needsPreviousNewtonIteration() const;
2246 
2248 
2251  std::vector<Real> _real_zero;
2252  std::vector<VariableValue> _scalar_zero;
2253  std::vector<VariableValue> _zero;
2254  std::vector<VariablePhiValue> _phi_zero;
2255  std::vector<MooseArray<ADReal>> _ad_zero;
2256  std::vector<VariableGradient> _grad_zero;
2257  std::vector<MooseArray<ADRealVectorValue>> _ad_grad_zero;
2258  std::vector<VariablePhiGradient> _grad_phi_zero;
2259  std::vector<VariableSecond> _second_zero;
2260  std::vector<MooseArray<ADRealTensorValue>> _ad_second_zero;
2261  std::vector<VariablePhiSecond> _second_phi_zero;
2262  std::vector<Point> _point_zero;
2263  std::vector<VectorVariableValue> _vector_zero;
2264  std::vector<VectorVariableCurl> _vector_curl_zero;
2266 
2271 
2275  void executeControls(const ExecFlagType & exec_type);
2276 
2280  void executeSamplers(const ExecFlagType & exec_type);
2281 
2285  virtual void updateActiveObjects();
2286 
2293 
2295 
2299  bool hasJacobian() const;
2300 
2305  bool constJacobian() const;
2306 
2310  void addOutput(const std::string &, const std::string &, InputParameters &);
2311 
2312  inline TheWarehouse & theWarehouse() const { return _app.theWarehouse(); }
2313 
2317  void setSNESMFReuseBase(bool reuse, bool set_by_user)
2318  {
2319  _snesmf_reuse_base = reuse, _snesmf_reuse_base_set_by_user = set_by_user;
2320  }
2321 
2326 
2330  void skipExceptionCheck(bool skip_exception_check)
2331  {
2332  _skip_exception_check = skip_exception_check;
2333  }
2334 
2339 
2344 
2345 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
2346  PetscOptions & petscOptionsDatabase() { return _petsc_option_data_base; }
2347 #endif
2348 
2350  virtual void setUDotRequested(const bool u_dot_requested) { _u_dot_requested = u_dot_requested; }
2351 
2353  virtual void setUDotDotRequested(const bool u_dotdot_requested)
2354  {
2355  _u_dotdot_requested = u_dotdot_requested;
2356  }
2357 
2359  virtual void setUDotOldRequested(const bool u_dot_old_requested)
2360  {
2361  _u_dot_old_requested = u_dot_old_requested;
2362  }
2363 
2365  virtual void setUDotDotOldRequested(const bool u_dotdot_old_requested)
2366  {
2367  _u_dotdot_old_requested = u_dotdot_old_requested;
2368  }
2369 
2371  virtual bool uDotRequested() { return _u_dot_requested; }
2372 
2374  virtual bool uDotDotRequested() { return _u_dotdot_requested; }
2375 
2377  virtual bool uDotOldRequested()
2378  {
2380  mooseError("FEProblemBase: When requesting old time derivative of solution, current time "
2381  "derivative of solution should also be stored. Please set `u_dot_requested` to "
2382  "true using setUDotRequested.");
2383 
2384  return _u_dot_old_requested;
2385  }
2386 
2388  virtual bool uDotDotOldRequested()
2389  {
2391  mooseError("FEProblemBase: When requesting old second time derivative of solution, current "
2392  "second time derivation of solution should also be stored. Please set "
2393  "`u_dotdot_requested` to true using setUDotDotRequested.");
2394  return _u_dotdot_old_requested;
2395  }
2396 
2398  void haveADObjects(bool have_ad_objects) override;
2399 
2400  // Whether or not we should solve this system
2401  bool shouldSolve() const { return _solve; }
2402 
2406  const MortarData & mortarData() const { return _mortar_data; }
2408 
2413 
2417  virtual bool hasMortarCoupling() const { return _has_mortar; }
2418 
2420  void computingNonlinearResid(bool computing_nonlinear_residual) final;
2421 
2423  void setCurrentlyComputingResidual(bool currently_computing_residual) final;
2424 
2428  void numGridSteps(unsigned int num_grid_steps) { _num_grid_steps = num_grid_steps; }
2429 
2434  void uniformRefine();
2435 
2437  void automaticScaling(bool automatic_scaling) override;
2438 
2440 
2443  template <typename T>
2444  static void objectSetupHelper(const std::vector<T *> & objects, const ExecFlagType & exec_flag);
2445  template <typename T>
2446  static void objectExecuteHelper(const std::vector<T *> & objects);
2448 
2455  virtual void reinitElemFaceRef(const Elem * elem,
2456  unsigned int side,
2457  Real tolerance,
2458  const std::vector<Point> * const pts,
2459  const std::vector<Real> * const weights = nullptr,
2460  const THREAD_ID tid = 0) override;
2461 
2468  virtual void reinitNeighborFaceRef(const Elem * neighbor_elem,
2469  unsigned int neighbor_side,
2470  Real tolerance,
2471  const std::vector<Point> * const pts,
2472  const std::vector<Real> * const weights = nullptr,
2473  const THREAD_ID tid = 0) override;
2474 
2479 
2484  void fvBCsIntegrityCheck(bool fv_bcs_integrity_check);
2485 
2494  void getFVMatsAndDependencies(SubdomainID block_id,
2495  std::vector<std::shared_ptr<MaterialBase>> & face_materials,
2496  std::vector<std::shared_ptr<MaterialBase>> & neighbor_materials,
2497  std::set<MooseVariableFieldBase *> & variables,
2498  const THREAD_ID tid);
2499 
2506  void resizeMaterialData(Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid);
2507 
2508  bool haveDisplaced() const override final { return _displaced_problem.get(); }
2509 
2511  bool hasLinearConvergenceObjects() const;
2515  void setNonlinearConvergenceNames(const std::vector<ConvergenceName> & convergence_names);
2519  void setLinearConvergenceNames(const std::vector<ConvergenceName> & convergence_names);
2523  void setMultiAppFixedPointConvergenceName(const ConvergenceName & convergence_name);
2527  void setSteadyStateConvergenceName(const ConvergenceName & convergence_name);
2528 
2532  const std::vector<ConvergenceName> & getNonlinearConvergenceNames() const;
2536  const std::vector<ConvergenceName> & getLinearConvergenceNames() const;
2540  const ConvergenceName & getMultiAppFixedPointConvergenceName() const;
2544  const ConvergenceName & getSteadyStateConvergenceName() const;
2545 
2549  void computingScalingJacobian(bool computing_scaling_jacobian)
2550  {
2551  _computing_scaling_jacobian = computing_scaling_jacobian;
2552  }
2553 
2554  bool computingScalingJacobian() const override final { return _computing_scaling_jacobian; }
2555 
2559  void computingScalingResidual(bool computing_scaling_residual)
2560  {
2561  _computing_scaling_residual = computing_scaling_residual;
2562  }
2563 
2567  bool computingScalingResidual() const override final { return _computing_scaling_residual; }
2568 
2574 
2575  virtual std::size_t numNonlinearSystems() const override { return _num_nl_sys; }
2576 
2577  virtual std::size_t numLinearSystems() const override { return _num_linear_sys; }
2578 
2579  virtual std::size_t numSolverSystems() const override { return _num_nl_sys + _num_linear_sys; }
2580 
2582  bool isSolverSystemNonlinear(const unsigned int sys_num) { return sys_num < _num_nl_sys; }
2583 
2584  virtual unsigned int currentNlSysNum() const override;
2585 
2586  virtual unsigned int currentLinearSysNum() const override;
2587 
2591  virtual unsigned int nlSysNum(const NonlinearSystemName & nl_sys_name) const override;
2592 
2596  unsigned int linearSysNum(const LinearSystemName & linear_sys_name) const override;
2597 
2601  unsigned int solverSysNum(const SolverSystemName & solver_sys_name) const override;
2602 
2607  unsigned int systemNumForVariable(const VariableName & variable_name) const;
2608 
2613 
2618 
2623 
2624  /*
2625  * Set the status of loop order of execution printing
2626  * @param print_exec set of execution flags to print on
2627  */
2628  void setExecutionPrinting(const ExecFlagEnum & print_exec) { _print_execution_on = print_exec; }
2629 
2633  bool shouldPrintExecution(const THREAD_ID tid) const;
2638  void reinitMortarUserObjects(BoundaryID primary_boundary_id,
2639  BoundaryID secondary_boundary_id,
2640  bool displaced);
2641 
2642  virtual const std::vector<VectorTag> & currentResidualVectorTags() const override;
2643 
2649  {
2650  friend class CrankNicolson;
2651  friend class FEProblemBase;
2654  };
2655 
2659  void setCurrentResidualVectorTags(const std::set<TagID> & vector_tags);
2660 
2665 
2670 
2671  virtual void needFV() override { _have_fv = true; }
2672  virtual bool haveFV() const override { return _have_fv; }
2673 
2674  virtual bool hasNonlocalCoupling() const override { return _has_nonlocal_coupling; }
2675 
2680 
2681  virtual void setCurrentLowerDElem(const Elem * const lower_d_elem, const THREAD_ID tid) override;
2682  virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid) override;
2683 
2687  const std::vector<NonlinearSystemName> & getNonlinearSystemNames() const { return _nl_sys_names; }
2691  const std::vector<LinearSystemName> & getLinearSystemNames() const { return _linear_sys_names; }
2695  const std::vector<SolverSystemName> & getSolverSystemNames() const { return _solver_sys_names; }
2696 
2697  virtual const libMesh::CouplingMatrix & nonlocalCouplingMatrix(const unsigned i) const override;
2698 
2699  virtual bool checkNonlocalCouplingRequirement() const override;
2700 
2702 
2704  {
2707 
2709  };
2710 
2712 
2713 #ifdef MOOSE_KOKKOS_ENABLED
2714 
2717  bool hasKokkosObjects() const { return _has_kokkos_objects; }
2722 #endif
2723 
2724 protected:
2728  virtual void meshChanged() {}
2729 
2731  void createTagVectors();
2732 
2734  void createTagSolutions();
2735 
2739  virtual void meshDisplaced();
2740 
2744  void computeSystems(const ExecFlagType & type);
2745 
2747 
2748 private:
2751 
2763  void setResidualObjectParamsAndLog(const std::string & ro_name,
2764  const std::string & name,
2766  const unsigned int nl_sys_num,
2767  const std::string & base_name,
2768  bool & reinit_displaced);
2769 
2777  void setAuxKernelParamsAndLog(const std::string & ak_name,
2778  const std::string & name,
2780  const std::string & base_name);
2781 
2786 
2787 protected:
2789 
2791  std::optional<std::vector<ConvergenceName>> _nonlinear_convergence_names;
2793  std::optional<std::vector<ConvergenceName>> _linear_convergence_names;
2795  std::optional<ConvergenceName> _multiapp_fixed_point_convergence_name;
2797  std::optional<ConvergenceName> _steady_state_convergence_name;
2798 
2799  std::set<TagID> _fe_vector_tags;
2800 
2801  std::set<TagID> _fe_matrix_tags;
2802 
2804  std::set<TagID> _linear_vector_tags;
2805 
2807  std::set<TagID> _linear_matrix_tags;
2808 
2810  const bool & _solve;
2811 
2815  int & _t_step;
2818 
2825 
2827  const std::vector<LinearSystemName> _linear_sys_names;
2828 
2830  const std::size_t _num_linear_sys;
2831 
2833  std::vector<std::shared_ptr<LinearSystem>> _linear_systems;
2834 
2836  std::map<LinearSystemName, unsigned int> _linear_sys_name_to_num;
2837 
2840 
2842  const bool _using_default_nl;
2843 
2845  const std::vector<NonlinearSystemName> _nl_sys_names;
2846 
2848  const std::size_t _num_nl_sys;
2849 
2851  std::vector<std::shared_ptr<NonlinearSystemBase>> _nl;
2852 
2854  std::map<NonlinearSystemName, unsigned int> _nl_sys_name_to_num;
2855 
2858 
2861 
2863  std::vector<std::shared_ptr<SolverSystem>> _solver_systems;
2864 
2866  std::map<SolverVariableName, unsigned int> _solver_var_to_sys_num;
2867 
2869  std::map<SolverSystemName, unsigned int> _solver_sys_name_to_num;
2870 
2872  std::vector<SolverSystemName> _solver_sys_names;
2873 
2875  std::shared_ptr<AuxiliarySystem> _aux;
2876 
2878  std::vector<std::unique_ptr<libMesh::CouplingMatrix>> _cm;
2879 
2880 #ifdef MOOSE_KOKKOS_ENABLED
2882 #endif
2883 
2885  std::map<std::string, unsigned int> _subspace_dim;
2886 
2889  std::vector<std::vector<std::unique_ptr<Assembly>>> _assembly;
2890 
2891 #ifdef MOOSE_KOKKOS_ENABLED
2893 #endif
2894 
2899 
2902 
2905 
2908 
2911 
2916  ScalarInitialConditionWarehouse _scalar_ics; // use base b/c of setup methods
2918 
2919  // material properties
2924 
2925 #ifdef MOOSE_KOKKOS_ENABLED
2929 #endif
2930  // Material Warehouses
2932  MaterialWarehouse _materials; // regular materials
2933  MaterialWarehouse _interface_materials; // interface materials
2934  MaterialWarehouse _discrete_materials; // Materials that the user must compute
2935  MaterialWarehouse _all_materials; // All materials for error checking and MaterialData storage
2936 
2937 #ifdef MOOSE_KOKKOS_ENABLED
2939 #endif
2940 
2943  // Indicator Warehouses
2947 
2948  // Marker Warehouse
2950 
2951  // Helper class to access Reporter object values
2953 
2954  // TODO: delete this after apps have been updated to not call getUserObjects
2956 
2959 
2962 
2965 
2968 
2971 
2974 
2976  std::map<std::string, std::unique_ptr<RandomData>> _random_data_objects;
2977 
2979  std::vector<std::unordered_map<SubdomainID, bool>> _block_mat_side_cache;
2980 
2982  std::vector<std::unordered_map<BoundaryID, bool>> _bnd_mat_side_cache;
2983 
2985  std::vector<std::unordered_map<BoundaryID, bool>> _interface_mat_side_cache;
2986 
2988  std::vector<MeshChangedInterface *> _notify_when_mesh_changes;
2989 
2991  std::vector<MeshDisplacedInterface *> _notify_when_mesh_displaces;
2992 
2994  bool duplicateVariableCheck(const std::string & var_name,
2995  const libMesh::FEType & type,
2996  bool is_aux,
2997  const std::set<SubdomainID> * const active_subdomains);
2998 
3000  const Moose::AuxGroup & group,
3001  TheWarehouse::Query & query);
3002 
3004  void checkDisplacementOrders();
3005 
3006  void checkUserObjects();
3007 
3014  const std::map<SubdomainID, std::vector<std::shared_ptr<MaterialBase>>> & materials_map);
3015 
3017  void checkCoordinateSystems();
3018 
3024  void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed = false);
3025 
3032  void addObjectParamsHelper(InputParameters & params,
3033  const std::string & object_name,
3034  const std::string & var_param_name = "variable");
3035 
3036 #ifdef LIBMESH_ENABLE_AMR
3038  unsigned int _cycles_completed;
3039 #endif
3040 
3042  std::shared_ptr<XFEMInterface> _xfem;
3043 
3044  // Displaced mesh /////
3046  std::shared_ptr<DisplacedProblem> _displaced_problem;
3049 
3056 
3059 
3062 
3065 
3068 
3071 
3074 
3077 
3080 
3083 
3086 
3089 
3093 
3094  std::vector<std::vector<const MooseVariableFEBase *>> _uo_jacobian_moose_vars;
3095 
3097  std::vector<unsigned char> _has_active_material_properties;
3098 
3099  std::vector<SolverParams> _solver_params;
3100 
3103  std::vector<SubdomainName> _kernel_coverage_blocks;
3104 
3108 
3112 
3115  std::vector<SubdomainName> _material_coverage_blocks;
3116 
3119 
3122 
3125 
3127  unsigned int _max_qps;
3128 
3131 
3134 
3137 
3140 
3143 
3146 
3149 
3151  std::string _exception_message;
3152 
3155 
3158 
3161 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
3163 #endif
3164 
3167 
3168  std::shared_ptr<LineSearch> _line_search;
3169 
3170  std::unique_ptr<libMesh::ConstElemRange> _evaluable_local_elem_range;
3171  std::unique_ptr<libMesh::ConstElemRange> _nl_evaluable_local_elem_range;
3172  std::unique_ptr<libMesh::ConstElemRange> _aux_evaluable_local_elem_range;
3173 
3174  std::unique_ptr<libMesh::ConstElemRange> _current_algebraic_elem_range;
3175  std::unique_ptr<libMesh::ConstNodeRange> _current_algebraic_node_range;
3176  std::unique_ptr<ConstBndNodeRange> _current_algebraic_bnd_node_range;
3177 
3181 
3182  // loop state during projection of initial conditions
3183  unsigned short _current_ic_state;
3184 
3188 
3189 private:
3194  void handleException(const std::string & calling_method);
3195 
3200  std::vector<MortarUserObject *>
3201  getMortarUserObjects(BoundaryID primary_boundary_id,
3202  BoundaryID secondary_boundary_id,
3203  bool displaced,
3204  const std::vector<MortarUserObject *> & mortar_uo_superset);
3205 
3210  std::vector<MortarUserObject *> getMortarUserObjects(BoundaryID primary_boundary_id,
3211  BoundaryID secondary_boundary_id,
3212  bool displaced);
3213 
3223  virtual std::pair<bool, unsigned int>
3224  determineSolverSystem(const std::string & var_name,
3225  bool error_if_not_found = false) const override;
3226 
3233  void checkICRestartError(const std::string & ic_name,
3234  const std::string & name,
3235  const VariableName & var_name);
3236 
3237  /*
3238  * Test if stateful property redistribution is expected to be
3239  * necessary, and set it up if so.
3240  */
3241  void addAnyRedistributers();
3242 
3243  void updateMaxQps();
3244 
3245  void joinAndFinalize(TheWarehouse::Query query, bool isgen = false);
3246 
3250  virtual void resetState();
3251 
3252  // Parameters handling Jacobian sparsity pattern behavior
3264 
3265  const bool _force_restart;
3272 
3275 
3278 
3281 
3284 
3287 
3290 
3291  friend class AuxiliarySystem;
3292  friend class NonlinearSystemBase;
3293  friend class MooseEigenSystem;
3294  friend class Resurrector;
3295  friend class Restartable;
3296  friend class DisplacedProblem;
3297 
3300 
3302  unsigned int _num_grid_steps;
3303 
3307 
3310 
3313 
3316 
3319 
3322 
3326  std::vector<VectorTag> _current_residual_vector_tags;
3327 
3329  bool _have_fv = false;
3330 
3334 
3336  std::vector<libMesh::CouplingMatrix> _nonlocal_cm;
3337 
3340 
3341 #ifdef MOOSE_KOKKOS_ENABLED
3342  bool _has_kokkos_objects = false;
3344 
3347 #endif
3348 
3349  friend void Moose::PetscSupport::setSinglePetscOption(const std::string & name,
3350  const std::string & value,
3351  FEProblemBase * const problem);
3352 };
3353 
3355 
3356 template <typename T>
3357 void
3359 {
3360  _app.getOutputWarehouse().allowOutput<T>(state);
3361 }
3362 
3363 template <typename T>
3364 void
3365 FEProblemBase::objectSetupHelper(const std::vector<T *> & objects, const ExecFlagType & exec_flag)
3366 {
3367  if (exec_flag == EXEC_INITIAL)
3368  {
3369  for (T * obj_ptr : objects)
3370  obj_ptr->initialSetup();
3371  }
3372 
3373  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
3374  {
3375  for (const auto obj_ptr : objects)
3376  obj_ptr->timestepSetup();
3377  }
3378  else if (exec_flag == EXEC_SUBDOMAIN)
3379  {
3380  for (const auto obj_ptr : objects)
3381  obj_ptr->subdomainSetup();
3382  }
3383 
3384  else if (exec_flag == EXEC_NONLINEAR)
3385  {
3386  for (const auto obj_ptr : objects)
3387  obj_ptr->jacobianSetup();
3388  }
3389 
3390  else if (exec_flag == EXEC_LINEAR)
3391  {
3392  for (const auto obj_ptr : objects)
3393  obj_ptr->residualSetup();
3394  }
3395 }
3396 
3397 template <typename T>
3398 void
3399 FEProblemBase::objectExecuteHelper(const std::vector<T *> & objects)
3400 {
3401  for (T * obj_ptr : objects)
3402  obj_ptr->execute();
3403 }
3404 
3405 template <typename T>
3406 std::vector<std::shared_ptr<T>>
3407 FEProblemBase::addObject(const std::string & type,
3408  const std::string & name,
3410  const bool threaded,
3411  const std::string & var_param_name)
3412 {
3413  parallel_object_only();
3414 
3415  logAdd(MooseUtils::prettyCppType<T>(), name, type, parameters);
3416  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
3417  addObjectParamsHelper(parameters, name, var_param_name);
3418 
3419  const auto n_threads = threaded ? libMesh::n_threads() : 1;
3420  std::vector<std::shared_ptr<T>> objects(n_threads);
3421  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
3422  {
3423  std::shared_ptr<T> obj = _factory.create<T>(type, name, parameters, tid);
3424  theWarehouse().add(obj);
3425  objects[tid] = std::move(obj);
3426  }
3427 
3428  return objects;
3429 }
3430 
3431 inline NonlinearSystemBase &
3432 FEProblemBase::getNonlinearSystemBase(const unsigned int sys_num)
3433 {
3434  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3435  return *_nl[sys_num];
3436 }
3437 
3438 inline const NonlinearSystemBase &
3439 FEProblemBase::getNonlinearSystemBase(const unsigned int sys_num) const
3440 {
3441  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3442  return *_nl[sys_num];
3443 }
3444 
3445 inline SolverSystem &
3446 FEProblemBase::getSolverSystem(const unsigned int sys_num)
3447 {
3448  mooseAssert(sys_num < _solver_systems.size(),
3449  "System number greater than the number of solver systems");
3450  return *_solver_systems[sys_num];
3451 }
3452 
3453 inline const SolverSystem &
3454 FEProblemBase::getSolverSystem(const unsigned int sys_num) const
3455 {
3456  mooseAssert(sys_num < _solver_systems.size(),
3457  "System number greater than the number of solver systems");
3458  return *_solver_systems[sys_num];
3459 }
3460 
3461 inline NonlinearSystemBase &
3463 {
3464  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3465  return *_current_nl_sys;
3466 }
3467 
3468 inline const NonlinearSystemBase &
3470 {
3471  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3472  return *_current_nl_sys;
3473 }
3474 
3475 inline LinearSystem &
3476 FEProblemBase::getLinearSystem(const unsigned int sys_num)
3477 {
3478  mooseAssert(sys_num < _linear_systems.size(),
3479  "System number greater than the number of linear systems");
3480  return *_linear_systems[sys_num];
3481 }
3482 
3483 inline const LinearSystem &
3484 FEProblemBase::getLinearSystem(const unsigned int sys_num) const
3485 {
3486  mooseAssert(sys_num < _linear_systems.size(),
3487  "System number greater than the number of linear systems");
3488  return *_linear_systems[sys_num];
3489 }
3490 
3491 inline LinearSystem &
3493 {
3494  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3495  return *_current_linear_sys;
3496 }
3497 
3498 inline const LinearSystem &
3500 {
3501  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3502  return *_current_linear_sys;
3503 }
3504 
3505 inline Assembly &
3506 FEProblemBase::assembly(const THREAD_ID tid, const unsigned int sys_num)
3507 {
3508  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3509  mooseAssert(sys_num < _assembly[tid].size(),
3510  "System number larger than the assembly container size");
3511  return *_assembly[tid][sys_num];
3512 }
3513 
3514 inline const Assembly &
3515 FEProblemBase::assembly(const THREAD_ID tid, const unsigned int sys_num) const
3516 {
3517  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3518  mooseAssert(sys_num < _assembly[tid].size(),
3519  "System number larger than the assembly container size");
3520  return *_assembly[tid][sys_num];
3521 }
3522 
3523 inline const libMesh::CouplingMatrix *
3524 FEProblemBase::couplingMatrix(const unsigned int i) const
3525 {
3526  return _cm[i].get();
3527 }
3528 
3529 inline void
3530 FEProblemBase::fvBCsIntegrityCheck(const bool fv_bcs_integrity_check)
3531 {
3533  // the user has requested that we don't check integrity so we will honor that
3534  return;
3535 
3536  _fv_bcs_integrity_check = fv_bcs_integrity_check;
3537 }
3538 
3539 inline const std::vector<VectorTag> &
3541 {
3543 }
3544 
3545 inline void
3546 FEProblemBase::setCurrentResidualVectorTags(const std::set<TagID> & vector_tags)
3547 {
3549 }
3550 
3551 inline void
3553 {
3555 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
virtual void addInterfaceMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters)
std::map< NonlinearSystemName, unsigned int > _nl_sys_name_to_num
Map from nonlinear system name to number.
void setCurrentAlgebraicElementRange(libMesh::ConstElemRange *range)
These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes tha...
std::vector< Point > _point_zero
Interface for objects that need parallel consistent random numbers without patterns over the course o...
virtual void computeJacobianTag(const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, TagID tag)
Form a Jacobian matrix for a given tag.
unsigned short getCurrentICState()
Retrieves the current initial condition state.
void resetFailNextNonlinearConvergenceCheck()
Tell the problem that the nonlinear convergence check(s) may proceed as normal.
bool _u_dot_requested
Whether solution time derivative needs to be stored.
void finalizeMultiApps()
Warehouse for storing scalar initial conditions.
virtual void addFVInitialCondition(const std::string &ic_name, const std::string &name, InputParameters &parameters)
Add an initial condition for a finite volume variables.
VarFieldType
Definition: MooseTypes.h:722
virtual void addMaterialHelper(std::vector< MaterialWarehouse *> warehouse, const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual bool hasNeighborCoupling() const
Whether the simulation has neighbor coupling.
virtual bool hasVariable(const std::string &var_name) const override
Whether or not this problem has the variable.
void setActiveMaterialProperties(const std::unordered_set< unsigned int > &mat_prop_ids, const THREAD_ID tid)
Record and set the material properties required by the current computing thread.
bool shouldSolve() const
const bool _regard_general_exceptions_as_errors
If we catch an exception during residual/Jacobian evaluaton for which we don&#39;t have specific handling...
const std::vector< NonlinearSystemName > & getNonlinearSystemNames() const
const std::size_t _num_nl_sys
The number of nonlinear systems.
void setVariableAllDoFMap(const std::vector< const MooseVariableFEBase *> &moose_vars)
virtual void initPetscOutputAndSomeSolverSettings()
Reinitialize PETSc output for proper linear/nonlinear iteration display.
void setKernelCoverageCheck(CoverageCheckMode mode)
Set flag to indicate whether kernel coverage checks should be performed.
const std::vector< ConvergenceName > & getNonlinearConvergenceNames() const
Gets the nonlinear system convergence object name(s).
void timestepSetup() override
virtual void addSampler(const std::string &type, const std::string &name, InputParameters &parameters)
The following functions will enable MOOSE to have the capability to import Samplers.
bool _skip_exception_check
If or not skip &#39;exception and stop solve&#39;.
virtual void setUDotDotOldRequested(const bool u_dotdot_old_requested)
Set boolean flag to true to store old solution second time derivative.
Helper class for holding the preconditioning blocks to fill.
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
virtual void meshChanged()
Deprecated.
virtual void addDamper(const std::string &damper_name, const std::string &name, InputParameters &parameters)
std::map< LinearSystemName, unsigned int > _linear_sys_name_to_num
Map from linear system name to number.
The Kokkos assembly class.
Moose::PetscSupport::PetscOptions & getPetscOptions()
Retrieve a writable reference the PETSc options (used by PetscSupport)
void getFVMatsAndDependencies(SubdomainID block_id, std::vector< std::shared_ptr< MaterialBase >> &face_materials, std::vector< std::shared_ptr< MaterialBase >> &neighbor_materials, std::set< MooseVariableFieldBase *> &variables, const THREAD_ID tid)
Get the materials and variables potentially needed for FV.
std::vector< MooseArray< ADRealTensorValue > > _ad_second_zero
virtual Real & dtOld() const
bool _need_to_add_default_steady_state_convergence
Flag that the problem needs to add the default steady convergence.
virtual void prepareFace(const Elem *elem, const THREAD_ID tid) override
Base class for function objects.
Definition: Function.h:36
void setPreserveMatrixSparsityPattern(bool preserve)
Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian)...
void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed=false)
Call when it is possible that the needs for ghosted elements has changed.
virtual void addTransfer(const std::string &transfer_name, const std::string &name, InputParameters &parameters)
Add a Transfer to the problem.
const MortarData & mortarData() const
Returns the mortar data object.
virtual libMesh::System & getSystem(const std::string &var_name) override
Returns the equation system containing the variable provided.
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:21
static SolverParams makeLinearSolverParams()
Make basic solver params for linear solves.
bool _snesmf_reuse_base_set_by_user
If or not _snesmf_reuse_base is set by user.
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.
virtual void addResidualLower(const THREAD_ID tid) override
bool _computing_scaling_jacobian
Flag used to indicate whether we are computing the scaling Jacobian.
A class for creating restricted objects.
Definition: Restartable.h:28
virtual void addJacobianLowerD(const THREAD_ID tid) override
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid) override
MaterialPropertyStorage & _bnd_material_props
virtual void addGhostedElem(dof_id_type elem_id) override
Will make sure that all dofs connected to elem_id are ghosted to this processor.
void setNonlocalCouplingMatrix()
Set custom coupling matrix for variables requiring nonlocal contribution.
void setExecutionPrinting(const ExecFlagEnum &print_exec)
virtual Real & time() const
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & couplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num)
void checkDependMaterialsHelper(const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase >>> &materials_map)
Helper method for checking Material object dependency.
unsigned int n_threads()
void setNeedToAddDefaultSteadyStateConvergence()
Sets _need_to_add_default_steady_state_convergence to true.
void projectFunctionOnCustomRange(ConstElemRange &elem_range, Number(*func)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), Gradient(*func_grad)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), const libMesh::Parameters &params, const VariableName &target_var)
Project a function onto a range of elements for a given variable.
virtual void cacheResidualNeighbor(const THREAD_ID tid) override
virtual void setInputParametersFEProblem(InputParameters &parameters)
bool identifyVariableGroupsInNL() const
Whether to identify variable groups in nonlinear systems.
ExecFlagType _current_execute_on_flag
Current execute_on flag.
void clearCurrentResidualVectorTags()
Clear the current residual vector tag data structure.
QueryCache is a convenient way to construct and pass around (possible partially constructed) warehous...
Definition: TheWarehouse.h:208
T & getUserObject(const std::string &name, unsigned int tid=0) const
Get the user object by its name.
std::shared_ptr< DisplacedProblem > displaced_problem
virtual bool hasNonlocalCoupling() const override
Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian...
void setNeedToAddDefaultMultiAppFixedPointConvergence()
Sets _need_to_add_default_multiapp_fixed_point_convergence to true.
virtual void checkExceptionAndStopSolve(bool print_message=true)
Check to see if an exception has occurred on any processor and, if possible, force the solve to fail...
virtual void meshDisplaced()
Update data after a mesh displaced.
virtual bool uDotDotOldRequested()
Get boolean flag to check whether old solution second time derivative needs to be stored...
std::optional< ConvergenceName > _multiapp_fixed_point_convergence_name
MultiApp fixed point convergence name.
Keeps track of stuff related to assembling.
Definition: Assembly.h:109
MooseAppCoordTransform & coordTransform()
virtual void setActiveFEVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid) override
void setCurrentAlgebraicNodeRange(libMesh::ConstNodeRange *range)
bool _error_on_jacobian_nonzero_reallocation
Whether to error when the Jacobian is re-allocated, usually because the sparsity pattern changed...
unsigned int TagID
Definition: MooseTypes.h:210
virtual void reinitNode(const Node *node, const THREAD_ID tid) override
virtual std::size_t numNonlinearSystems() const override
virtual void predictorCleanup(NumericVector< libMesh::Number > &ghosted_solution)
Perform cleanup tasks after application of predictor to solution vector.
virtual void prepare(const Elem *elem, const THREAD_ID tid) override
MPI_Datatype data_type
bool verboseMultiApps() const
Whether or not to use verbose printing for MultiApps.
bool _has_jacobian
Indicates if the Jacobian was computed.
virtual bool haveFV() const override
returns true if this problem includes/needs finite volume functionality.
char ** blocks
Interface for objects acting when the mesh has been displaced.
virtual void addKokkosMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters)
const Moose::Kokkos::Assembly & kokkosAssembly() const
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
bool _has_dampers
Whether or not this system has any Dampers associated with it.
std::vector< SubdomainName > _kernel_coverage_blocks
virtual void setUDotDotRequested(const bool u_dotdot_requested)
Set boolean flag to true to store solution second time derivative.
virtual Distribution & getDistribution(const std::string &name)
bool haveDisplaced() const override final
Whether we have a displaced problem in our simulation.
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
void setCurrentAlgebraicBndNodeRange(ConstBndNodeRange *range)
This is the base class for Samplers as used within the Stochastic Tools module.
Definition: Sampler.h:43
bool areCoupled(const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const
Registry class for material property IDs and names.
void setPostprocessorValueByName(const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
Set the value of a PostprocessorValue.
virtual void addKokkosNodalKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid) override
virtual void postExecute()
Method called at the end of the simulation.
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
void prepareKokkosMaterials(const std::unordered_set< unsigned int > &consumer_needed_mat_props)
void joinAndFinalize(TheWarehouse::Query query, bool isgen=false)
std::vector< MooseArray< ADRealVectorValue > > _ad_grad_zero
Warehouse for storing initial conditions.
std::vector< SolverParams > _solver_params
virtual void addKokkosBoundaryCondition(const std::string &bc_name, const std::string &name, InputParameters &parameters)
const std::vector< SolverSystemName > & getSolverSystemNames() const
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.
void reinitMaterialsFaceOnBoundary(const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
reinit materials on element faces on a boundary (internal or external) This specific routine helps us...
virtual std::pair< bool, unsigned int > determineSolverSystem(const std::string &var_name, bool error_if_not_found=false) const override
Determine what solver system the provided variable name lies in.
std::unique_ptr< libMesh::ConstNodeRange > _current_algebraic_node_range
virtual void setActiveScalarVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid) override
void setCoupling(Moose::CouplingType type)
Set the coupling between variables TODO: allow user-defined coupling.
const ExecFlagType & getCurrentExecuteOnFlag() const
Return/set the current execution flag.
unsigned int _cycles_completed
virtual void reinitScalars(const THREAD_ID tid, bool reinit_for_derivative_reordering=false) override
fills the VariableValue arrays for scalar variables from the solution vector
virtual bool uDotRequested()
Get boolean flag to check whether solution time derivative needs to be stored.
virtual void init() override
void add(std::shared_ptr< MooseObject > obj)
add adds a new object to the warehouse and stores attributes/metadata about it for running queries/fi...
Definition: TheWarehouse.C:116
virtual void needFV() override
marks this problem as including/needing finite volume functionality.
virtual void getDiracElements(std::set< const Elem *> &elems) override
Fills "elems" with the elements that should be looped over for Dirac Kernels.
void parentOutputPositionChanged()
Calls parentOutputPositionChanged() on all sub apps.
virtual void addInterfaceKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
bool _is_petsc_options_inserted
If or not PETSc options have been added to database.
void setCurrentlyComputingResidual(bool currently_computing_residual) final
Set whether or not the problem is in the process of computing the residual.
virtual void addMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual void lineSearch()
execute MOOSE line search
virtual bool checkNonlocalCouplingRequirement() const override
virtual bool uDotDotRequested()
Get boolean flag to check whether solution second time derivative needs to be stored.
bool _has_kokkos_objects
Whether we have any Kokkos objects.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
unsigned short _current_ic_state
virtual void reinitNeighborPhys(const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points, const THREAD_ID tid) override
std::vector< MeshDisplacedInterface * > _notify_when_mesh_displaces
Objects to be notified when the mesh displaces.
void trustUserCouplingMatrix()
Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a ...
virtual void newAssemblyArray(std::vector< std::shared_ptr< SolverSystem >> &solver_systems)
const bool _uo_aux_state_check
Whether or not checking the state of uo/aux evaluation.
virtual void addMeshDivision(const std::string &type, const std::string &name, InputParameters &params)
Add a MeshDivision.
bool _computing_scaling_residual
Flag used to indicate whether we are computing the scaling Residual.
A struct for storing the various types of petsc options and values.
Definition: PetscSupport.h:44
virtual void computeMarkers()
void reportMooseObjectDependency(MooseObject *a, MooseObject *b)
Register a MOOSE object dependency so we can either order operations properly or report when we canno...
void residualSetup() override
MaterialDataType
MaterialData types.
Definition: MooseTypes.h:692
void computeUserObjectsInternal(const ExecFlagType &type, const Moose::AuxGroup &group, TheWarehouse::Query &query)
virtual bool onlyAllowDefaultNonlinearConvergence() const
Returns true if an error will result if the user supplies &#39;nonlinear_convergence&#39;.
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Positions objects are under the hood Reporters.
Definition: Positions.h:20
void reinitMortarUserObjects(BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)
Call reinit on mortar user objects with matching primary boundary ID, secondary boundary ID...
std::shared_ptr< MooseObject > create(const std::string &obj_name, const std::string &name, const InputParameters &parameters, THREAD_ID tid=0, bool print_deprecated=true)
Definition: Factory.C:111
virtual void reinitNodes(const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
virtual void updateActiveObjects()
Update the active objects in the warehouses.
Stores the stateful material properties computed by materials.
const RestartableEquationSystems & getRestartableEquationSystems() const
Get the RestartableEquationSystems object.
virtual void computeIndicatorsAndMarkers()
void reinitMaterialsBoundary(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on a boundary
Definition: Marker.h:41
virtual void addJacobianOffDiagScalar(unsigned int ivar, const THREAD_ID tid=0)
virtual void setException(const std::string &message)
Set an exception, which is stored at this point by toggling a member variable in this class...
virtual void addJacobian(const THREAD_ID tid) override
CreateTaggedMatrixKey(const CreateTaggedMatrixKey &)
virtual void addAuxScalarKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
void setErrorOnJacobianNonzeroReallocation(bool state)
bool _has_kokkos_residual_objects
Whether we have any Kokkos residual objects.
PetscOptions _petsc_option_data_base
virtual const std::vector< VectorTag > & currentResidualVectorTags() const override
Return the residual vector tags we are currently computing.
bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
These methods are used to determine whether stateful material properties need to be stored on interna...
Moose::Kokkos::MaterialPropertyStorage & getKokkosNeighborMaterialPropertyStorage()
std::vector< VectorTag > _current_residual_vector_tags
A data member to store the residual vector tag(s) passed into computeResidualTag(s).
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
std::vector< SubdomainName > _material_coverage_blocks
void setSteadyStateConvergenceName(const ConvergenceName &convergence_name)
Sets the steady-state detection convergence object name if there is one.
virtual void addAuxScalarVariable(const std::string &var_name, libMesh::Order order, Real scale_factor=1., const std::set< SubdomainID > *const active_subdomains=NULL)
virtual const SystemBase & systemBaseLinear(unsigned int sys_num) const override
Get a constant base class reference to a linear system.
void logAdd(const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const
Output information about the object just added to the problem.
virtual bool hasScalarVariable(const std::string &var_name) const override
Returns a Boolean indicating whether any system contains a variable with the name provided...
MultiApp Implementation for Transient Apps.
Moose::Kokkos::MaterialPropertyStorage & getKokkosBndMaterialPropertyStorage()
void resizeMaterialData(Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)
Resize material data.
Warehouse for storing finite volume initial conditions.
void finishMultiAppStep(ExecFlagType type, bool recurse_through_multiapp_levels=false)
Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.
virtual void addFunctorMaterial(const std::string &functor_material_name, const std::string &name, InputParameters &parameters)
std::vector< VariableSecond > _second_zero
std::map< SolverVariableName, unsigned int > _solver_var_to_sys_num
Map connecting variable names with their respective solver systems.
std::vector< MooseArray< ADReal > > _ad_zero
Moose::Kokkos::MaterialPropertyStorage & getKokkosMaterialPropertyStorage()
bool _requires_nonlocal_coupling
nonlocal coupling requirement flag
virtual void onTimestepEnd() override
virtual void computeNearNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
virtual void addNodalKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
All Distributions should inherit from this class.
Definition: Distribution.h:18
MaterialWarehouse _kokkos_materials
std::vector< VectorVariableCurl > _vector_curl_zero
virtual bool hasMortarCoupling() const
Whether the simulation has mortar coupling.
Base class for user objects executed one or more sidesets, which may be on the outer boundary of the ...
bool _has_exception
Whether or not an exception has occurred.
unsigned int _num_grid_steps
Number of steps in a grid sequence.
bool _needs_old_newton_iter
Indicates that we need to compute variable values for previous Newton iteration.
bool haveXFEM()
Find out whether the current analysis is using XFEM.
virtual void addJacobianBlockTags(libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)
void registerRandomInterface(RandomInterface &random_interface, const std::string &name)
bool _has_time_integrator
Indicates whether or not this executioner has a time integrator (during setup)
This class provides an interface for common operations on field variables of both FE and FV types wit...
ExecuteMooseObjectWarehouse< MultiApp > & getMultiAppWarehouse()
virtual void addAuxKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
MaterialPropertyRegistry _material_prop_registry
Moose::Kokkos::Assembly & kokkosAssembly()
void clearActiveMaterialProperties(const THREAD_ID tid)
Clear the active material properties.
virtual unsigned int nLinearIterations(const unsigned int nl_sys_num) const override
MaterialBase objects are special in that they have additional objects created automatically (see FEPr...
ExecuteMooseObjectWarehouse< TransientMultiApp > _transient_multi_apps
Storage for TransientMultiApps (only needed for calling &#39;computeDT&#39;)
Moose::Kokkos::Assembly _kokkos_assembly
MaterialWarehouse _interface_materials
bool hasUserObject(const std::string &name) const
Check if there if a user object of given name.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
bool _ignore_zeros_in_jacobian
Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.
const libMesh::ConstElemRange & getCurrentAlgebraicElementRange()
These are the element and nodes that contribute to the jacobian and residual for this local processor...
void setCurrentExecuteOnFlag(const ExecFlagType &)
const MaterialWarehouse & getMaterialWarehouse() const
virtual void computeResidualInternal(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const std::set< TagID > &tags)
Form a residual vector for a set of tags.
void initElementStatefulProps(const libMesh::ConstElemRange &elem_range, const bool threaded)
Initialize stateful properties for elements in a specific elem_range This is needed when elements/bou...
const libMesh::ConstNodeRange & getCurrentAlgebraicNodeRange()
void computingScalingJacobian(bool computing_scaling_jacobian)
Setter for whether we&#39;re computing the scaling jacobian.
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
virtual void addKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Base class for a system (of equations)
Definition: SystemBase.h:84
const InitialConditionWarehouse & getInitialConditionWarehouse() const
Return InitialCondition storage.
const std::set< const MooseObject * > & getKokkosMaterialPropertyStorageConsumers(Moose::MaterialDataType type) const
virtual void addAuxVariable(const std::string &var_type, const std::string &var_name, InputParameters &params)
Canonical method for adding an auxiliary variable.
The Kokkos system class.
Definition: KokkosSystem.h:35
std::optional< ConvergenceName > _steady_state_convergence_name
Steady-state detection convergence name.
Base class for MeshDivision objects.
Definition: MeshDivision.h:35
const MaterialPropertyStorage & getBndMaterialPropertyStorage()
bool computingNonlinearResid() const
Returns true if the problem is in the process of computing the nonlinear residual.
Definition: SubProblem.h:707
virtual void addFVInterfaceKernel(const std::string &fv_ik_name, const std::string &name, InputParameters &parameters)
MeshDivision & getMeshDivision(const std::string &name, const THREAD_ID tid=0) const
Get a MeshDivision.
unsigned int getNumCyclesCompleted()
Base class for creating new nodally-based mortar user objects.
bool hasDampers()
Whether or not this system has dampers.
const Positions & getPositionsObject(const std::string &name) const
Get the Positions object by its name.
std::map< SolverSystemName, unsigned int > _solver_sys_name_to_num
Map connecting solver system names with their respective systems.
FEProblemBase(const InputParameters &parameters)
void setFailNextNonlinearConvergenceCheck()
Skip further residual evaluations and fail the next nonlinear convergence check(s) ...
virtual Executor & getExecutor(const std::string &name)
virtual void cacheJacobianNeighbor(const THREAD_ID tid) override
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
bool needToAddDefaultSteadyStateConvergence() const
Returns true if the problem needs to add the default steady-state detection convergence.
std::vector< std::unordered_map< BoundaryID, bool > > _bnd_mat_side_cache
Cache for calculating materials on side.
bool _have_fv
Whether we are performing some calculations with finite volume discretizations.
bool hasLinearConvergenceObjects() const
Whether we have linear convergence objects.
ExecFlagEnum _print_execution_on
When to print the execution of loops.
virtual void setResidual(NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
bool & petscOptionsInserted()
If PETSc options are already inserted.
virtual void solve(const unsigned int nl_sys_num)
virtual void setCurrentLowerDElem(const Elem *const lower_d_elem, const THREAD_ID tid) override
Set the current lower dimensional element.
std::set< TagID > _linear_matrix_tags
Temporary storage for filtered matrix tags for linear systems.
void bumpAllQRuleOrder(libMesh::Order order, SubdomainID block)
Real computeMultiAppsDT(ExecFlagType type)
Find the smallest timestep over all MultiApps.
void setParallelBarrierMessaging(bool flag)
Toggle parallel barrier messaging (defaults to on).
void projectSolution()
const MaterialWarehouse & getRegularMaterialsWarehouse() const
virtual const MooseVariableFieldBase & getVariable(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const override
Returns the variable reference for requested variable which must be of the expected_var_type (Nonline...
void reinitMaterialsFace(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on element faces
std::unique_ptr< libMesh::ConstElemRange > _nl_evaluable_local_elem_range
virtual void computeResidualTags(const std::set< TagID > &tags)
Form multiple residual vectors and each is associated with one tag.
const bool & currentlyComputingResidual() const
Returns true if the problem is in the process of computing the residual.
Definition: SubProblem.h:720
void setMaterialCoverageCheck(CoverageCheckMode mode)
Set flag to indicate whether material coverage checks should be performed.
virtual void computeJacobianSys(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian)
Form a Jacobian matrix.
std::shared_ptr< MultiApp > getMultiApp(const std::string &multi_app_name) const
Get a MultiApp object by name.
ExecuteMooseObjectWarehouse< UserObject > _all_user_objects
virtual void reinitElemNeighborAndLowerD(const Elem *elem, unsigned int side, const THREAD_ID tid) override
bool hasSolverVariable(const std::string &var_name) const
AuxGroup
Flag for AuxKernel related execution type.
Definition: MooseTypes.h:704
virtual void addMarker(const std::string &marker_name, const std::string &name, InputParameters &parameters)
unsigned int subspaceDim(const std::string &prefix) const
Dimension of the subspace spanned by vectors with a given prefix.
virtual GeometricSearchData & geomSearchData() override
virtual void setUDotOldRequested(const bool u_dot_old_requested)
Set boolean flag to true to store old solution time derivative.
bool needsPreviousNewtonIteration() const
Check to see whether we need to compute the variable values of the previous Newton iterate...
virtual void addBoundaryCondition(const std::string &bc_name, const std::string &name, InputParameters &parameters)
const libMesh::CouplingMatrix * couplingMatrix(const unsigned int nl_sys_num) const override
The coupling matrix defining what blocks exist in the preconditioning matrix.
virtual bool computingPreSMOResidual(const unsigned int nl_sys_num) const override
Returns true if the problem is in the process of computing it&#39;s initial residual. ...
This class is a container/interface for the objects involved in automatic generation of mortar spaces...
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override
void createTagMatrices(CreateTaggedMatrixKey)
const bool _skip_nl_system_check
virtual void resetState()
Reset state of this object in preparation for the next evaluation.
virtual void addCachedResidualDirectly(NumericVector< libMesh::Number > &residual, const THREAD_ID tid)
Allows for all the residual contributions that are currently cached to be added directly into the vec...
virtual void addInitialCondition(const std::string &ic_name, const std::string &name, InputParameters &parameters)
ScalarInitialConditionWarehouse _scalar_ics
virtual void computeLinearSystemSys(libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
Assemble both the right hand side and the system matrix of a given linear system. ...
Nonlinear system to be solved.
void skipExceptionCheck(bool skip_exception_check)
Set a flag that indicates if we want to skip exception and stop solve.
Moose::Kokkos::System & getKokkosSystem(const unsigned int sys_num)
Get the Kokkos system of a specified number that is associated with MOOSE nonlinear and auxiliary sys...
virtual void swapBackMaterialsFace(const THREAD_ID tid)
virtual void addDistribution(const std::string &type, const std::string &name, InputParameters &parameters)
The following functions will enable MOOSE to have the capability to import distributions.
virtual void advanceState()
Advance all of the state holding vectors / datastructures so that we can move to the next timestep...
A user object that runs over all the nodes and does an aggregation step to compute a single value...
ExecuteMooseObjectWarehouse< Transfer > _transfers
Normal Transfers.
void setAuxKernelParamsAndLog(const std::string &ak_name, const std::string &name, InputParameters &parameters, const std::string &base_name)
Set the subproblem and system parameters for auxiliary kernels and log their addition.
const VectorPostprocessorValue & getVectorPostprocessorValueByName(const std::string &object_name, const std::string &vector_name, std::size_t t_index=0) const
Get a read-only reference to the vector value associated with the VectorPostprocessor.
MooseLinearConvergenceReason
virtual Function & getFunction(const std::string &name, const THREAD_ID tid=0)
virtual void addPredictor(const std::string &type, const std::string &name, InputParameters &parameters)
virtual void computeJacobianBlocks(std::vector< JacobianBlock *> &blocks, const unsigned int nl_sys_num)
Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditio...
virtual void addLineSearch(const InputParameters &)
add a MOOSE line search
virtual void copySolutionsBackwards()
const ConstBndNodeRange & getCurrentAlgebraicBndNodeRange()
bool _calculate_jacobian_in_uo
virtual void reinitElemFaceRef(const Elem *elem, unsigned int side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override
reinitialize FE objects on a given element on a given side at a given set of reference points and the...
virtual void prepareFaceShapes(unsigned int var, const THREAD_ID tid) override
virtual void addPostprocessor(const std::string &pp_name, const std::string &name, InputParameters &parameters)
virtual Real finalNonlinearResidual(const unsigned int nl_sys_num) const override
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
bool automaticScaling() const
Automatic scaling getter.
Definition: SubProblem.C:1163
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
virtual void setActiveElementalMooseVariables(const std::set< MooseVariableFEBase *> &moose_vars, const THREAD_ID tid) override
Set the MOOSE variables to be reinited on each element.
const MaterialWarehouse & getInterfaceMaterialsWarehouse() const
std::vector< VariablePhiGradient > _grad_phi_zero
const std::vector< const MooseVariableFEBase * > & getUserObjectJacobianVariables(const THREAD_ID tid) const
const MaterialWarehouse & getDiscreteMaterialWarehouse() const
bool hasJacobian() const
Returns _has_jacobian.
void notifyWhenMeshDisplaces(MeshDisplacedInterface *mdi)
Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh ge...
void createTagSolutions()
Create extra tagged solution vectors.
std::vector< SolverSystemName > _solver_sys_names
The union of nonlinear and linear system names.
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
bool _verbose_restore
Whether or not to be verbose on solution restoration post a failed time step.
bool _previous_nl_solution_required
Indicates we need to save the previous NL iteration variable values.
bool _trust_user_coupling_matrix
Whether to trust the user coupling matrix no matter what.
const ConvergenceName & getSteadyStateConvergenceName() const
Gets the steady-state detection convergence object name.
void handleException(const std::string &calling_method)
Handle exceptions.
virtual std::vector< VariableName > getVariableNames()
Returns a list of all the variables in the problem (both from the NL and Aux systems.
ReporterData _reporter_data
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
void uniformRefine()
uniformly refine the problem mesh(es).
bool hasSetMultiAppFixedPointConvergenceName() const
Returns true if the problem has set the fixed point convergence name.
virtual void computeResidualSys(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
This function is called by Libmesh to form a residual.
const ReporterData & getReporterData() const
Provides const access the ReporterData object.
virtual const libMesh::CouplingMatrix & nonlocalCouplingMatrix(const unsigned i) const override
std::unique_ptr< libMesh::ConstElemRange > _current_algebraic_elem_range
const bool & _immediately_print_invalid_solution
std::vector< std::shared_ptr< Transfer > > getTransfers(ExecFlagType type, Transfer::DIRECTION direction) const
Get Transfers by ExecFlagType and direction.
bool hasSetSteadyStateConvergenceName() const
Returns true if the problem has set the steady-state detection convergence name.
virtual void addConvergence(const std::string &type, const std::string &name, InputParameters &parameters)
Adds a Convergence object.
bool shouldPrintExecution(const THREAD_ID tid) const
Check whether the problem should output execution orders at this time.
const bool & _solve
Whether or not to actually solve the nonlinear system.
virtual const SystemBase & systemBaseSolver(const unsigned int sys_num) const override
Return the solver system object as a base class reference given the system number.
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
MooseObjectWarehouse< Convergence > _convergences
convergence warehouse
Interface for notifications that the mesh has changed.
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
virtual std::shared_ptr< DisplacedProblem > getDisplacedProblem()
This is the common base class for the three main kernel types implemented in MOOSE, Kernel, VectorKernel and ArrayKernel.
Definition: KernelBase.h:23
void numGridSteps(unsigned int num_grid_steps)
Set the number of steps in a grid sequences.
Base class for convergence criteria.
Definition: Convergence.h:21
bool _input_file_saved
whether input file has been written
virtual void reinitElem(const Elem *elem, const THREAD_ID tid) override
virtual Convergence & getConvergence(const std::string &name, const THREAD_ID tid=0) const
Gets a Convergence object.
TheWarehouse & theWarehouse() const
void createTagVectors()
Create extra tagged vectors and matrices.
virtual void createQRules(libMesh::QuadratureType type, libMesh::Order order, libMesh::Order volume_order=libMesh::INVALID_ORDER, libMesh::Order face_order=libMesh::INVALID_ORDER, SubdomainID block=Moose::ANY_BLOCK_ID, bool allow_negative_qweights=true)
void reinitMaterialsNeighbor(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on the neighboring element face
void setMultiAppFixedPointConvergenceName(const ConvergenceName &convergence_name)
Sets the MultiApp fixed point convergence object name if there is one.
void checkUserObjects()
Moose::CouplingType _coupling
Type of variable coupling.
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:28
virtual bool shouldUpdateSolution()
Check to see whether the problem should update the solution.
const ConvergenceName & getMultiAppFixedPointConvergenceName() const
Gets the MultiApp fixed point convergence object name.
Real getTimeFromStateArg(const Moose::StateArg &state) const
Returns the time associated with the requested state.
virtual std::string solverTypeString(unsigned int solver_sys_num=0)
Return solver type as a human readable string.
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
void executeSamplers(const ExecFlagType &exec_type)
Performs setup and execute calls for Sampler objects.
virtual void computeJacobianInternal(const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const std::set< TagID > &tags)
Form a Jacobian matrix for multiple tags.
virtual void computeJacobian(const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const unsigned int nl_sys_num)
Form a Jacobian matrix with the default tag (system).
void reinitMaterialsNeighborOnBoundary(const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specif...
void addOutput(const std::string &, const std::string &, InputParameters &)
Adds an Output object.
boundary_id_type BoundaryID
const MooseObjectWarehouse< InternalSideIndicatorBase > & getInternalSideIndicatorWarehouse()
virtual void setUDotRequested(const bool u_dot_requested)
Set boolean flag to true to store solution time derivative.
const bool _allow_ics_during_restart
bool constJacobian() const
Returns _const_jacobian (whether a MOOSE object has specified that the Jacobian is the same as the pr...
virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid) override
std::vector< MeshChangedInterface * > _notify_when_mesh_changes
Objects to be notified when the mesh changes.
void checkNonlocalCoupling()
void addDefaultSteadyStateConvergence(const InputParameters &params)
Adds the default steady-state detection Convergence.
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
NonlinearSystemBase & currentNonlinearSystem()
void computingScalingResidual(bool computing_scaling_residual)
Setter for whether we&#39;re computing the scaling residual.
void checkDisplacementOrders()
Verify that SECOND order mesh uses SECOND order displacements.
virtual void addFunction(const std::string &type, const std::string &name, InputParameters &parameters)
Real PostprocessorValue
various MOOSE typedefs
Definition: MooseTypes.h:202
virtual void addJacobianNeighbor(const THREAD_ID tid) override
virtual libMesh::EquationSystems & es() override
std::vector< std::unordered_map< SubdomainID, bool > > _block_mat_side_cache
Cache for calculating materials on side.
MortarData _mortar_data
bool hasTimeIntegrator() const
Returns whether or not this Problem has a TimeIntegrator.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
NumberVectorValue Gradient
TheWarehouse is a container for MooseObjects that allows querying/filtering over various customizeabl...
Definition: TheWarehouse.h:185
virtual void addVectorPostprocessor(const std::string &pp_name, const std::string &name, InputParameters &parameters)
const bool _allow_invalid_solution
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:92
virtual unsigned int currentNlSysNum() const override
const MaterialPropertyStorage & getMaterialPropertyStorage()
Return a reference to the material property storage.
virtual void computeIndicators()
bool hasInitialAdaptivity() const
Return a Boolean indicating whether initial AMR is turned on.
virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the scalar variable reference from whichever system contains it.
static void objectSetupHelper(const std::vector< T *> &objects, const ExecFlagType &exec_flag)
Helpers for calling the necessary setup/execute functions for the supplied objects.
const bool _boundary_restricted_node_integrity_check
whether to perform checking of boundary restricted nodal object variable dependencies, e.g.
virtual void setActiveScalarVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid) override
MooseMesh & _mesh
virtual bool uDotOldRequested()
Get boolean flag to check whether old solution time derivative needs to be stored.
virtual bool updateMeshXFEM()
Update the mesh due to changing XFEM cuts.
virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const override
Return the nonlinear system object as a base class reference given the system number.
std::vector< MortarUserObject * > getMortarUserObjects(BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced, const std::vector< MortarUserObject *> &mortar_uo_superset)
Helper for getting mortar objects corresponding to primary boundary ID, secondary boundary ID...
virtual void restoreSolutions()
bool fvBCsIntegrityCheck() const
virtual bool hasConvergence(const std::string &name, const THREAD_ID tid=0) const
Returns true if the problem has a Convergence object of the given name.
bool _u_dotdot_old_requested
Whether old solution second time derivative needs to be stored.
void setFailNextSystemConvergenceCheck()
Tell the problem that the system(s) cannot be considered converged next time convergence is checked...
void addAnyRedistributers()
void mooseDeprecated(Args &&... args) const
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
bool hasPostprocessorValueByName(const PostprocessorName &name) const
Whether or not a Postprocessor value exists by a given name.
const ExecuteMooseObjectWarehouse< UserObject > & getUserObjects() const
void setAxisymmetricCoordAxis(const MooseEnum &rz_coord_axis)
void initialSetup() override
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
Adaptivity _adaptivity
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Definition: SubProblem.C:173
bool allowInvalidSolution() const
Whether to accept / allow an invalid solution.
bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, const THREAD_ID tid)
virtual const SystemBase & systemBaseAuxiliary() const override
Return the auxiliary system object as a base class reference.
void setLinearConvergenceNames(const std::vector< ConvergenceName > &convergence_names)
Sets the linear convergence object name(s) if there is one.
void checkUserObjectJacobianRequirement(THREAD_ID tid)
MooseVariableFieldBase & getActualFieldVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the variable reference for requested MooseVariableField which may be in any system...
LineSearch * getLineSearch() override
getter for the MOOSE line search
void reinitKokkosMaterials()
virtual void computeNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
virtual void addTimeIntegrator(const std::string &type, const std::string &name, InputParameters &parameters)
LinearSystem * _current_linear_sys
The current linear system that we are solving.
virtual void cacheResidual(const THREAD_ID tid) override
virtual void computeResidualType(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
Form a residual vector for a given tag and "residual" tag.
const bool _force_restart
void forceOutput()
Indicates that the next call to outputStep should be forced.
const VectorPostprocessor & getVectorPostprocessorObjectByName(const std::string &object_name, const THREAD_ID tid=0) const
Return the VPP object given the name.
std::vector< VariablePhiSecond > _second_phi_zero
bool _started_initial_setup
At or beyond initialSteup stage.
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
bool errorOnJacobianNonzeroReallocation() const
Will return True if the user wants to get an error when a nonzero is reallocated in the Jacobian by P...
std::unique_ptr< ConstBndNodeRange > _current_algebraic_bnd_node_range
virtual void addResidual(const THREAD_ID tid) override
NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num)
virtual void addResidualNeighbor(const THREAD_ID tid) override
virtual void addKokkosAuxKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void reinitNeighborFaceRef(const Elem *neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override
reinitialize FE objects on a given neighbor element on a given side at a given set of reference point...
void needSolutionState(unsigned int oldest_needed, Moose::SolutionIterationType iteration_type)
Declare that we need up to old (1) or older (2) solution states for a given type of iteration...
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
Moose::CouplingType coupling() const
virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid) override
void setCouplingMatrix(std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)
Set custom coupling matrix.
virtual void addDefaultNonlinearConvergence(const InputParameters &params)
Adds the default nonlinear Convergence associated with the problem.
virtual const MooseVariableFieldBase & getVariable(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const =0
Returns the variable reference for requested variable which must be of the expected_var_type (Nonline...
void setNonlinearConvergenceNames(const std::vector< ConvergenceName > &convergence_names)
Sets the nonlinear convergence object name(s) if there is one.
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
virtual bool solverSystemConverged(const unsigned int solver_sys_num) override
std::string _exception_message
The error message to go with an exception.
void setNeedToAddDefaultNonlinearConvergence()
Sets _need_to_add_default_nonlinear_convergence to true.
virtual void checkProblemIntegrity()
Method called to perform a series of sanity checks before a simulation is run.
AuxiliarySystem & getAuxiliarySystem()
virtual void updateGeomSearch(GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
MooseObjectWarehouse< MeshDivision > _mesh_divisions
Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the ...
virtual void addConstraint(const std::string &c_name, const std::string &name, InputParameters &parameters)
MooseObjectWarehouse< Indicator > _indicators
virtual void addMultiApp(const std::string &multi_app_name, const std::string &name, InputParameters &parameters)
Add a MultiApp to the problem.
The Kokkos class responsible for allocating and storing Kokkos material properties.
virtual void prepareAssembly(const THREAD_ID tid) override
bool haveADObjects() const
Method for reading wehther we have any ad objects.
Definition: SubProblem.h:771
unsigned int systemNumForVariable(const VariableName &variable_name) const
bool _checking_uo_aux_state
Flag used to indicate whether we are doing the uo/aux state check in execute.
const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName &name, std::size_t t_index=0) const
Get a read-only reference to the value associated with a Postprocessor that exists.
bool _fv_bcs_integrity_check
Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset...
const MooseObjectWarehouse< Indicator > & getIndicatorWarehouse()
Return indicator/marker storage.
InitialConditions are objects that set the initial value of variables.
bool showInvalidSolutionConsole() const
Whether or not to print out the invalid solutions summary table in console.
Base class for user objects executed on all element sides internal to one or more blocks...
virtual void initNullSpaceVectors(const InputParameters &parameters, std::vector< std::shared_ptr< NonlinearSystemBase >> &nl)
virtual void setCurrentSubdomainID(const Elem *elem, const THREAD_ID tid) override
MaterialData & getMaterialData(Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const
bool getFailNextSystemConvergenceCheck() const
Whether it will fail the next system convergence check(s), triggering failed step behavior...
virtual void clearDiracInfo() override
Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in...
virtual void addIndicator(const std::string &indicator_name, const std::string &name, InputParameters &parameters)
virtual void reinitNodesNeighbor(const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
bool duplicateVariableCheck(const std::string &var_name, const libMesh::FEType &type, bool is_aux, const std::set< SubdomainID > *const active_subdomains)
Helper to check for duplicate variable names across systems or within a single system.
GeometricSearchType
Used to select groups of geometric search objects to update.
void backupMultiApps(ExecFlagType type)
Backup the MultiApps associated with the ExecFlagType.
virtual ~FEProblemBase()
The SolutionInvalidity will contain all the information about the occurrence(s) of solution invalidit...
MaterialData & getKokkosMaterialData(Moose::MaterialDataType type, const MooseObject *object=nullptr) const
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters &params)
Canonical method for adding a non-linear variable.
const std::vector< LinearSystemName > & getLinearSystemNames() const
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
virtual int & timeStep() const
virtual Moose::FEBackend feBackend() const
LinearSystem & getLinearSystem(unsigned int sys_num)
Get non-constant reference to a linear system.
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
virtual void addDisplacedProblem(std::shared_ptr< DisplacedProblem > displaced_problem)
void computeResidual(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
This function is called by Libmesh to form a residual.
static void objectExecuteHelper(const std::vector< T *> &objects)
void setResidualObjectParamsAndLog(const std::string &ro_name, const std::string &name, InputParameters &parameters, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
Set the subproblem and system parameters for residual objects and log their addition.
void setVectorPostprocessorValueByName(const std::string &object_name, const std::string &vector_name, const VectorPostprocessorValue &value, std::size_t t_index=0)
Set the value of a VectorPostprocessor vector.
virtual MooseVariable & getStandardVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the variable reference for requested MooseVariable which may be in any system.
void setCoordSystem(const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
Materials compute MaterialProperties.
Definition: Material.h:34
virtual void swapBackMaterialsNeighbor(const THREAD_ID tid)
const bool _show_invalid_solution_console
virtual void addLinearFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
std::unique_ptr< libMesh::ConstElemRange > _aux_evaluable_local_elem_range
virtual NonlinearSystem & getNonlinearSystem(const unsigned int sys_num)
bool _snesmf_reuse_base
If or not to resuse the base vector for matrix-free calculation.
virtual bool reinitDirac(const Elem *elem, const THREAD_ID tid) override
Returns true if the Problem has Dirac kernels it needs to compute on elem.
void setKernelCoverageCheck(bool flag)
Set flag to indicate whether kernel coverage checks should be performed.
This is the XFEMInterface class.
Definition: XFEMInterface.h:37
bool _need_to_add_default_multiapp_fixed_point_convergence
Flag that the problem needs to add the default fixed point convergence.
const std::vector< NonlinearSystemName > _nl_sys_names
The nonlinear system names.
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:203
const FVInitialConditionWarehouse & getFVInitialConditionWarehouse() const
Return FVInitialCondition storage.
virtual void updateMortarMesh()
Adds tagged matrices.
void addDefaultMultiAppFixedPointConvergence(const InputParameters &params)
Adds the default fixed point Convergence associated with the problem.
std::set< TagID > _fe_matrix_tags
Moose::Kokkos::MaterialPropertyStorage & _kokkos_material_props
virtual void addAuxArrayVariable(const std::string &var_name, const libMesh::FEType &type, unsigned int components, const std::set< SubdomainID > *const active_subdomains=NULL)
const ExecuteMooseObjectWarehouse< Transfer > & getMultiAppTransferWarehouse(Transfer::DIRECTION direction) const
Return the complete warehouse for MultiAppTransfer object for the given direction.
virtual const SystemBase & getSystemBase(const unsigned int sys_num) const
Get constant reference to a system in this problem.
virtual void reinitLowerDElem(const Elem *lower_d_elem, const THREAD_ID tid, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr) override
bool isSNESMFReuseBaseSetbyUser()
Return a flag to indicate if _snesmf_reuse_base is set by users.
virtual void addReporter(const std::string &type, const std::string &name, InputParameters &parameters)
Add a Reporter object to the simulation.
virtual void swapBackMaterials(const THREAD_ID tid)
std::vector< VariablePhiValue > _phi_zero
InitialConditionWarehouse _ics
std::vector< unsigned char > _has_active_material_properties
Whether there are active material properties on each thread.
const SubdomainID ANY_BLOCK_ID
Definition: MooseTypes.C:19
MaterialWarehouse _discrete_materials
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
void setSinglePetscOption(const std::string &name, const std::string &value="", FEProblemBase *const problem=nullptr)
A wrapper function for dealing with different versions of PetscOptionsSetValue.
virtual void addDGKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid) override
sets the current boundary ID in assembly
SolverSystem * _current_solver_sys
The current solver system.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
Takes care of everything related to mesh adaptivity.
Definition: Adaptivity.h:49
std::optional< std::vector< ConvergenceName > > _nonlinear_convergence_names
Nonlinear system(s) convergence name(s)
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
void setConstJacobian(bool state)
Set flag that Jacobian is constant (for optimization purposes)
Class for containing MooseEnum item information.
Definition: MooseEnumItem.h:18
unsigned int solverSysNum(const SolverSystemName &solver_sys_name) const override
Class that is used as a parameter to set/clearCurrentResidualVectorTags that allows only blessed clas...
Base class for Control objects.
Definition: Control.h:34
std::shared_ptr< MaterialBase > getMaterial(std::string name, Moose::MaterialDataType type, const THREAD_ID tid=0, bool no_warn=false)
Return a pointer to a MaterialBase object.
std::vector< VariableGradient > _grad_zero
bool hasActiveObjects(THREAD_ID tid=0) const
void clearCurrentJacobianMatrixTags()
Clear the current Jacobian matrix tag data structure ...
virtual void subdomainSetup(SubdomainID subdomain, const THREAD_ID tid)
virtual void restoreOldSolutions()
Restore old solutions from the backup vectors and deallocate them.
unsigned int getInitialSteps() const
Pull out the number of initial steps previously set by calling init()
Definition: Adaptivity.h:98
void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)
const bool _identify_variable_groups_in_nl
Whether to identify variable groups in nonlinear systems. This affects dof ordering.
PetscOptions & petscOptionsDatabase()
bool acceptInvalidSolution() const
Whether or not to accept the solution based on its invalidity.
const AutomaticMortarGeneration & getMortarInterface(const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced) const
Return the undisplaced or displaced mortar generation object associated with the provided boundaries ...
const bool _restore_original_nonzero_pattern
Whether we should restore the original nonzero pattern for every Jacobian evaluation.
void execMultiAppTransfers(ExecFlagType type, Transfer::DIRECTION direction)
Execute MultiAppTransfers associated with execution flag and direction.
bool hasKokkosResidualObjects() const
Wrapper class that owns a libMesh EquationSystem and adds advanced restart capability to it...
void restoreMultiApps(ExecFlagType type, bool force=false)
Restore the MultiApps associated with the ExecFlagType.
virtual void addLinearFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
void customSetup(const ExecFlagType &exec_type) override
void setRestartFile(const std::string &file_name)
Communicate to the Resurector the name of the restart filer.
void setCurrentLinearSystem(unsigned int sys_num)
Set the current linear system pointer.
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
MortarData & mortarData()
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
void allowOutput(bool state)
Ability to enable/disable output calls This is private, users should utilize FEProblemBase::allowOutp...
virtual void onTimestepBegin() override
virtual void computeBounds(libMesh::NonlinearImplicitSystem &sys, NumericVector< libMesh::Number > &lower, NumericVector< libMesh::Number > &upper)
Nonlinear system to be solved.
void initKokkos()
Construct Kokkos assembly and systems and allocate Kokkos material property storages.
virtual void computePostCheck(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &old_soln, NumericVector< libMesh::Number > &search_direction, NumericVector< libMesh::Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln)
void checkDuplicatePostprocessorVariableNames()
void computeResidualAndJacobian(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, libMesh::SparseMatrix< libMesh::Number > &jacobian)
Form a residual and Jacobian with default tags.
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & nonlocalCouplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num)
bool _using_ad_mat_props
Automatic differentiaion (AD) flag which indicates whether any consumer has requested an AD material ...
std::vector< VariableValue > _scalar_zero
virtual Real computeResidualL2Norm()
Computes the residual using whatever is sitting in the current solution vector then returns the L2 no...
const std::vector< LinearSystemName > _linear_sys_names
The linear system names.
Moose::Kokkos::Array< Moose::Kokkos::System > & getKokkosSystems()
Get all Kokkos systems that are associated with MOOSE nonlinear and auxiliary systems.
std::shared_ptr< XFEMInterface > getXFEM()
Get a pointer to the XFEM controller object.
bool getFailNextNonlinearConvergenceCheck() const
Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s) ...
void incrementMultiAppTStep(ExecFlagType type)
Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType.
Class for scalar variables (they are different).
void computeLinearSystemTags(const NumericVector< libMesh::Number > &soln, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
Assemble the current linear system given a set of vector and matrix tags.
void bumpVolumeQRuleOrder(libMesh::Order order, SubdomainID block)
Increases the element/volume quadrature order for the specified mesh block if and only if the current...
const bool _material_dependency_check
Determines whether a check to verify material dependencies on every subdomain.
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars
virtual MooseMesh & mesh() override
std::vector< VariableValue > _zero
CouplingType
Definition: MooseTypes.h:731
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
unsigned int linearSysNum(const LinearSystemName &linear_sys_name) const override
LinearSystem & currentLinearSystem()
Get a non-constant reference to the current linear system.
void resetFailNextSystemConvergenceCheck()
Tell the problem that the system convergence check(s) may proceed as normal.
libMesh::EquationSystems & es()
std::set< TagID > _fe_vector_tags
const std::set< const MooseObject * > & getMaterialPropertyStorageConsumers(Moose::MaterialDataType type) const
void addObjectParamsHelper(InputParameters &params, const std::string &object_name, const std::string &var_param_name="variable")
Helper for setting the "_subproblem" and "_sys" parameters in addObject() and in addUserObject().
Base class for deriving any boundary condition of a integrated type.
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.
SolverSystem & getSolverSystem(unsigned int sys_num)
Get non-constant reference to a solver system.
virtual void saveOldSolutions()
Allocate vectors and save old solutions into them.
virtual void computeTransposeNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
bool hasPostprocessor(const std::string &name) const
Deprecated.
virtual bool updateSolution(NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)
Update the solution.
std::shared_ptr< DisplacedProblem > _displaced_problem
GeometricSearchData _geometric_search_data
State argument for evaluating functors.
void setCurrentResidualVectorTags(const std::set< TagID > &vector_tags)
Set the current residual vector tag data structure based on the passed in tag IDs.
MooseObjectWarehouse< Function > _functions
functions
virtual Real & timeOld() const
Proxy for accessing MaterialPropertyStorage.
Definition: MaterialData.h:37
std::vector< VectorVariableValue > _vector_zero
bool hasMultiApp(const std::string &name) const
bool _u_dot_old_requested
Whether old solution time derivative needs to be stored.
bool ignoreZerosInJacobian() const
Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern.
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
Coupling matrix for variables.
void createMortarInterface(const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle)
bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
void reinitElemFace(const Elem *elem, unsigned int side, BoundaryID, const THREAD_ID tid)
Linear system to be solved.
Definition: LinearSystem.h:35
bool needToAddDefaultNonlinearConvergence() const
Returns true if the problem needs to add the default nonlinear convergence.
std::optional< std::vector< ConvergenceName > > _linear_convergence_names
Linear system(s) convergence name(s) (if any)
bool useSNESMFReuseBase()
Return a flag that indicates if we are reusing the vector base.
std::vector< std::shared_ptr< T > > addObject(const std::string &type, const std::string &name, InputParameters &parameters, const bool threaded=true, const std::string &var_param_name="variable")
Method for creating and adding an object to the warehouse.
bool _has_initialized_stateful
Whether nor not stateful materials have been initialized.
void checkICRestartError(const std::string &ic_name, const std::string &name, const VariableName &var_name)
Checks if the variable of the initial condition is getting restarted and errors for specific cases...
virtual void setResidualNeighbor(NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284
unsigned int _max_qps
Maximum number of quadrature points used in the problem.
void setMaterialCoverageCheck(bool flag)
Set flag to indicate whether material coverage checks should be performed.
static InputParameters validParams()
virtual void addScalarKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
TheWarehouse & theWarehouse()
Definition: MooseApp.h:137
bool _preserve_matrix_sparsity_pattern
Whether to preserve the system matrix / Jacobian sparsity pattern, using 0-valued entries usually...
Base class for implementing interface user objects.
virtual unsigned int nNonlinearIterations(const unsigned int nl_sys_num) const override
CoverageCheckMode _material_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active material...
virtual std::size_t numLinearSystems() const override
MaterialPropertyStorage & _neighbor_material_props
Moose::Kokkos::Array< Moose::Kokkos::System > _kokkos_systems
const std::size_t _num_linear_sys
The number of linear systems.
bool hasKokkosObjects() const
std::map< std::string, unsigned int > _subspace_dim
Dimension of the subspace spanned by the vectors with a given prefix.
ReporterData & getReporterData(ReporterData::WriteKey)
Provides non-const access the ReporterData object that is used to store reporter values.
const libMesh::ConstElemRange & getEvaluableElementRange()
In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}.
const bool _use_hash_table_matrix_assembly
Whether to assemble matrices using hash tables instead of preallocating matrix memory.
friend class Resurrector
bool restoreOriginalNonzeroPattern() const
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
bool _has_internal_edge_residual_objects
Whether the problem has dgkernels or interface kernels.
virtual void addKokkosKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
bool computingScalingJacobian() const override final
Getter for whether we&#39;re computing the scaling jacobian.
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
ExecuteMooseObjectWarehouse< Control > & getControlWarehouse()
Reference to the control logic warehouse.
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > & getMortarInterfaces(bool on_displaced) const
const ExecFlagType EXEC_SUBDOMAIN
Definition: Moose.C:50
virtual ArrayMooseVariable & getArrayVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the variable reference for requested ArrayMooseVariable which may be in any system...
const MooseObjectWarehouse< Marker > & getMarkerWarehouse()
bool _has_constraints
Whether or not this system has any Constraints.
virtual bool isTransient() const override
bool _need_to_add_default_nonlinear_convergence
Flag that the problem needs to add the default nonlinear convergence.
bool hasMultiApps() const
Returns whether or not the current simulation has any multiapps.
virtual void reinitNeighbor(const Elem *elem, unsigned int side, const THREAD_ID tid) override
void notifyWhenMeshChanges(MeshChangedInterface *mci)
Register an object that derives from MeshChangedInterface to be notified when the mesh changes...
void setSNESMFReuseBase(bool reuse, bool set_by_user)
If or not to reuse the base vector for matrix-free calculation.
std::unique_ptr< libMesh::ConstElemRange > _evaluable_local_elem_range
bool computingScalingResidual() const override final
virtual void executeAllObjects(const ExecFlagType &exec_type)
CoverageCheckMode _kernel_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active kernel...
virtual void setActiveFEVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid) override
Real Number
bool _fail_next_system_convergence_check
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.
const bool _boundary_restricted_elem_integrity_check
whether to perform checking of boundary restricted elemental object variable dependencies, e.g.
virtual void prepareShapes(unsigned int var, const THREAD_ID tid) override
void reinitMaterialsInterface(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)
bool _const_jacobian
true if the Jacobian is constant
virtual void computeJacobianBlock(libMesh::SparseMatrix< libMesh::Number > &jacobian, libMesh::System &precond_system, unsigned int ivar, unsigned int jvar)
Really not a good idea to use this.
virtual void solveLinearSystem(const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)
Build and solve a linear system.
virtual void computeUserObjectByName(const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)
Compute an user object with the given name.
const MaterialPropertyRegistry & getMaterialPropertyRegistry() const
virtual void possiblyRebuildGeomSearchPatches()
std::set< TagID > _linear_vector_tags
Temporary storage for filtered vector tags for linear systems.
Moose::Kokkos::MaterialPropertyStorage & _kokkos_bnd_material_props
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:112
bool checkingUOAuxState() const
Return a flag to indicate whether we are executing user objects and auxliary kernels for state check ...
const libMesh::ConstElemRange & getNonlinearEvaluableElementRange()
MaterialPropertyStorage & _material_props
Base class for Postprocessors that produce a vector of values.
void prepareMaterials(const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)
Add the MooseVariables and the material properties that the current materials depend on to the depend...
virtual void addFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void addFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
libMesh::Order _max_scalar_order
Maximum scalar variable order.
virtual void addGhostedBoundary(BoundaryID boundary_id) override
Will make sure that all necessary elements from boundary_id are ghosted to this processor.
virtual bool hasFunction(const std::string &name, const THREAD_ID tid=0)
Adaptivity & adaptivity()
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.
bool hasUOAuxStateCheck() const
Whether or not MOOSE will perform a user object/auxiliary kernel state check.
virtual void cacheJacobian(const THREAD_ID tid) override
void jacobianSetup() override
virtual std::size_t numSolverSystems() const override
virtual void addHDGKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Executor * getExecutor() const
Definition: MooseApp.h:335
const Moose::Kokkos::Array< Moose::Kokkos::System > & getKokkosSystems() const
virtual Real & dt() const
void advanceMultiApps(ExecFlagType type)
Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep depending on your purpose...
bool immediatelyPrintInvalidSolution() const
Whether or not the solution invalid warnings are printed out immediately.
Restartable::ManagedValue< RestartableEquationSystems > _req
The EquationSystems object, wrapped for restart.
virtual unsigned int currentLinearSysNum() const override
std::vector< libMesh::CouplingMatrix > _nonlocal_cm
nonlocal coupling matrix
virtual void reinitNodeFace(const Node *node, BoundaryID bnd_id, const THREAD_ID tid) override
virtual void reinitOffDiagScalars(const THREAD_ID tid) override
virtual void reinitElemPhys(const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid) override
std::vector< std::unordered_map< BoundaryID, bool > > _interface_mat_side_cache
Cache for calculating materials on interface.
void initKokkosStatefulProps()
virtual void addJacobianNeighborLowerD(const THREAD_ID tid) override
virtual void prepareNeighborShapes(unsigned int var, const THREAD_ID tid) override
MooseObjectWarehouse< Marker > _markers
FVInitialConditionWarehouse _fv_ics
void setVerboseProblem(bool verbose)
Make the problem be verbose.
virtual void setNeighborSubdomainID(const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual bool hasException()
Whether or not an exception has occurred.
CurrentResidualVectorTagsKey(const CurrentResidualVectorTagsKey &)
virtual void initialAdaptMesh()
virtual void addResidualScalar(const THREAD_ID tid=0)
Moose::Kokkos::MaterialPropertyStorage & _kokkos_neighbor_material_props
const bool _using_default_nl
Boolean to check if we have the default nonlinear system.
MaterialWarehouse _all_materials
bool _u_dotdot_requested
Whether solution second time derivative needs to be stored.
virtual void addCachedResidual(const THREAD_ID tid) override
A system that holds auxiliary variables.
Moose::PetscSupport::PetscOptions _petsc_options
PETSc option storage.
Crank-Nicolson time integrator.
Definition: CrankNicolson.h:22
virtual const std::vector< std::shared_ptr< Convergence > > & getConvergenceObjects(const THREAD_ID tid=0) const
Gets the Convergence objects.
bool preserveMatrixSparsityPattern() const
Will return True if the executioner in use requires preserving the sparsity pattern of the matrices b...
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid) override
Clear the active elemental MooseVariableFEBase.
Base class for user-specific data.
Definition: UserObject.h:40
void allowOutput(bool state)
Ability to enable/disable all output calls.
virtual Sampler & getSampler(const std::string &name, const THREAD_ID tid=0)
virtual void outputStep(ExecFlagType type)
Output the current step.
void projectInitialConditionOnCustomRange(libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range, const std::optional< std::set< VariableName >> &target_vars=std::nullopt)
Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boun...
virtual unsigned int nlSysNum(const NonlinearSystemName &nl_sys_name) const override
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2515
MooseEnum _verbose_setup
Whether or not to be verbose during setup.
bool needToAddDefaultMultiAppFixedPointConvergence() const
Returns true if the problem needs to add the default fixed point convergence.
void setIgnoreZerosInJacobian(bool state)
Set whether the zeros in the Jacobian should be dropped from the sparsity pattern.
void computeSystems(const ExecFlagType &type)
Do generic system computations.
virtual void computeJacobianTags(const std::set< TagID > &tags)
Form multiple matrices, and each is associated with a tag.
SolutionIterationType
Definition: MooseTypes.h:241
MooseMesh * _displaced_mesh
const MaterialWarehouse & getKokkosMaterialsWarehouse() const
bool _has_mortar
Whether the simulation requires mortar coupling.
libMesh::Order getMaxScalarOrder() const
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
const std::vector< ConvergenceName > & getLinearConvergenceNames() const
Gets the linear convergence object name(s).
unsigned int THREAD_ID
Definition: MooseTypes.h:209
virtual void ghostGhostedBoundaries() override
Causes the boundaries added using addGhostedBoundary to actually be ghosted.
The Executor class directs the execution flow of simulations.
Definition: Executor.h:26
MaterialWarehouse _materials
uint8_t dof_id_type
virtual bool adaptMesh()
virtual void addJacobianScalar(const THREAD_ID tid=0)
const MaterialPropertyStorage & getNeighborMaterialPropertyStorage()
virtual void addDiracKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
MooseObjectWarehouse< IntegratedBCBase > _nonlocal_integrated_bcs
nonlocal integrated_bcs
virtual const MooseMesh & mesh() const override
virtual void computeResidualTag(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
Form a residual vector for a given tag.
virtual bool startedInitialSetup()
Returns true if we are in or beyond the initialSetup stage.
virtual VectorMooseVariable & getVectorVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the variable reference for requested VectorMooseVariable which may be in any system...
std::shared_ptr< LineSearch > _line_search
void initXFEM(std::shared_ptr< XFEMInterface > xfem)
Create XFEM controller object.
Base class for all Transfer objects.
Definition: Transfer.h:36
virtual void neighborSubdomainSetup(SubdomainID subdomain, const THREAD_ID tid)
virtual void addCachedJacobian(const THREAD_ID tid) override
virtual void sizeZeroes(unsigned int size, const THREAD_ID tid)
virtual Real computeDamping(const NumericVector< libMesh::Number > &soln, const NumericVector< libMesh::Number > &update)
std::vector< Real > _real_zero
Convenience zeros.
MooseObjectWarehouse< KernelBase > _nonlocal_kernels
nonlocal kernels
void checkCoordinateSystems()
Verify that there are no element type/coordinate type conflicts.
unsigned int getMaxQps() const
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:30
bool _verbose_multiapps
Whether or not to be verbose with multiapps.
This is a helper class for managing the storage of declared Reporter object values.
Definition: ReporterData.h:48