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 #endif
799 
804  virtual const SystemBase & getSystemBase(const unsigned int sys_num) const;
805 
810  virtual SystemBase & getSystemBase(const unsigned int sys_num);
811 
816  SystemBase & getSystemBase(const std::string & sys_name);
817 
822  LinearSystem & getLinearSystem(unsigned int sys_num);
823 
828  const LinearSystem & getLinearSystem(unsigned int sys_num) const;
829 
834  SolverSystem & getSolverSystem(unsigned int sys_num);
835 
840  const SolverSystem & getSolverSystem(unsigned int sys_num) const;
841 
846  void setCurrentLinearSystem(unsigned int sys_num);
847 
851  const LinearSystem & currentLinearSystem() const;
852 
857  virtual const SystemBase & systemBaseLinear(unsigned int sys_num) const override;
858 
863  virtual SystemBase & systemBaseLinear(unsigned int sys_num) override;
864 
871  virtual void
872  addVariable(const std::string & var_type, const std::string & var_name, InputParameters & params);
873 
874  virtual void addKernel(const std::string & kernel_name,
875  const std::string & name,
877  virtual void addHDGKernel(const std::string & kernel_name,
878  const std::string & name,
880  virtual void addNodalKernel(const std::string & kernel_name,
881  const std::string & name,
883  virtual void addScalarKernel(const std::string & kernel_name,
884  const std::string & name,
886  virtual void addBoundaryCondition(const std::string & bc_name,
887  const std::string & name,
889 
890 #ifdef MOOSE_KOKKOS_ENABLED
891  virtual void addKokkosKernel(const std::string & kernel_name,
892  const std::string & name,
894  virtual void addKokkosNodalKernel(const std::string & kernel_name,
895  const std::string & name,
897  virtual void addKokkosBoundaryCondition(const std::string & bc_name,
898  const std::string & name,
900 #endif
901 
902  virtual void
903  addConstraint(const std::string & c_name, const std::string & name, InputParameters & parameters);
904 
906  {
907  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
908  }
909 
910  // Aux /////
911 
918  virtual void addAuxVariable(const std::string & var_type,
919  const std::string & var_name,
920  InputParameters & params);
921 
922  virtual void addAuxVariable(const std::string & var_name,
923  const libMesh::FEType & type,
924  const std::set<SubdomainID> * const active_subdomains = NULL);
925  virtual void addAuxArrayVariable(const std::string & var_name,
926  const libMesh::FEType & type,
927  unsigned int components,
928  const std::set<SubdomainID> * const active_subdomains = NULL);
929  virtual void addAuxScalarVariable(const std::string & var_name,
930  libMesh::Order order,
931  Real scale_factor = 1.,
932  const std::set<SubdomainID> * const active_subdomains = NULL);
933  virtual void addAuxKernel(const std::string & kernel_name,
934  const std::string & name,
936  virtual void addAuxScalarKernel(const std::string & kernel_name,
937  const std::string & name,
939 
941 
942  // Dirac /////
943  virtual void addDiracKernel(const std::string & kernel_name,
944  const std::string & name,
946 
947  // DG /////
948  virtual void addDGKernel(const std::string & kernel_name,
949  const std::string & name,
951  // FV /////
952  virtual void addFVKernel(const std::string & kernel_name,
953  const std::string & name,
955 
956  virtual void addLinearFVKernel(const std::string & kernel_name,
957  const std::string & name,
959  virtual void
960  addFVBC(const std::string & fv_bc_name, const std::string & name, InputParameters & parameters);
961  virtual void addLinearFVBC(const std::string & fv_bc_name,
962  const std::string & name,
964 
965  virtual void addFVInterfaceKernel(const std::string & fv_ik_name,
966  const std::string & name,
968 
969  // Interface /////
970  virtual void addInterfaceKernel(const std::string & kernel_name,
971  const std::string & name,
973 
974  // IC /////
975  virtual void addInitialCondition(const std::string & ic_name,
976  const std::string & name,
984  virtual void addFVInitialCondition(const std::string & ic_name,
985  const std::string & name,
987 
988  void projectSolution();
989 
994  unsigned short getCurrentICState();
995 
1005  libMesh::ConstElemRange & elem_range,
1006  ConstBndNodeRange & bnd_node_range,
1007  const std::optional<std::set<VariableName>> & target_vars = std::nullopt);
1008 
1023  void projectFunctionOnCustomRange(ConstElemRange & elem_range,
1024  Number (*func)(const Point &,
1025  const libMesh::Parameters &,
1026  const std::string &,
1027  const std::string &),
1028  Gradient (*func_grad)(const Point &,
1029  const libMesh::Parameters &,
1030  const std::string &,
1031  const std::string &),
1032  const libMesh::Parameters & params,
1033  const VariableName & target_var);
1034 
1035  // Materials
1036  virtual void addMaterial(const std::string & material_name,
1037  const std::string & name,
1039  virtual void addMaterialHelper(std::vector<MaterialWarehouse *> warehouse,
1040  const std::string & material_name,
1041  const std::string & name,
1043  virtual void addInterfaceMaterial(const std::string & material_name,
1044  const std::string & name,
1046  virtual void addFunctorMaterial(const std::string & functor_material_name,
1047  const std::string & name,
1049 
1050 #ifdef MOOSE_KOKKOS_ENABLED
1051  virtual void addKokkosMaterial(const std::string & material_name,
1052  const std::string & name,
1054 #endif
1055 
1067  void prepareMaterials(const std::unordered_set<unsigned int> & consumer_needed_mat_props,
1068  const SubdomainID blk_id,
1069  const THREAD_ID tid);
1070 
1071  void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful = true);
1072 
1082  void reinitMaterialsFace(SubdomainID blk_id,
1083  const THREAD_ID tid,
1084  bool swap_stateful = true,
1085  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1086 
1098  void
1099  reinitMaterialsFaceOnBoundary(const BoundaryID boundary_id,
1100  const SubdomainID blk_id,
1101  const THREAD_ID tid,
1102  const bool swap_stateful = true,
1103  const std::deque<MaterialBase *> * const reinit_mats = nullptr);
1104 
1116  void
1118  const SubdomainID blk_id,
1119  const THREAD_ID tid,
1120  const bool swap_stateful = true,
1121  const std::deque<MaterialBase *> * const reinit_mats = nullptr);
1122 
1133  const THREAD_ID tid,
1134  bool swap_stateful = true,
1135  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1136 
1149  void reinitMaterialsBoundary(BoundaryID boundary_id,
1150  const THREAD_ID tid,
1151  bool swap_stateful = true,
1152  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1153 
1154  void
1155  reinitMaterialsInterface(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful = true);
1156 
1157 #ifdef MOOSE_KOKKOS_ENABLED
1158  void prepareKokkosMaterials(const std::unordered_set<unsigned int> & consumer_needed_mat_props);
1159  void reinitKokkosMaterials();
1160 #endif
1161 
1162  /*
1163  * Swap back underlying data storing stateful material properties
1164  */
1165  virtual void swapBackMaterials(const THREAD_ID tid);
1166  virtual void swapBackMaterialsFace(const THREAD_ID tid);
1167  virtual void swapBackMaterialsNeighbor(const THREAD_ID tid);
1168 
1175  void setActiveMaterialProperties(const std::unordered_set<unsigned int> & mat_prop_ids,
1176  const THREAD_ID tid);
1177 
1186  bool hasActiveMaterialProperties(const THREAD_ID tid) const;
1187 
1193  void clearActiveMaterialProperties(const THREAD_ID tid);
1194 
1206  template <typename T>
1207  std::vector<std::shared_ptr<T>> addObject(const std::string & type,
1208  const std::string & name,
1210  const bool threaded = true,
1211  const std::string & var_param_name = "variable");
1212 
1213  // Postprocessors /////
1214  virtual void addPostprocessor(const std::string & pp_name,
1215  const std::string & name,
1217 
1218  // VectorPostprocessors /////
1219  virtual void addVectorPostprocessor(const std::string & pp_name,
1220  const std::string & name,
1222 
1231  virtual void
1232  addReporter(const std::string & type, const std::string & name, InputParameters & parameters);
1233 
1241  const ReporterData & getReporterData() const { return _reporter_data; }
1242 
1249 
1250  // UserObjects /////
1251  virtual std::vector<std::shared_ptr<UserObject>> addUserObject(
1252  const std::string & user_object_name, const std::string & name, InputParameters & parameters);
1253 
1254  // TODO: delete this function after apps have been updated to not call it
1256  {
1258  "This function is deprecated, use theWarehouse().query() to construct a query instead");
1259  return _all_user_objects;
1260  }
1261 
1267  template <class T>
1268  T & getUserObject(const std::string & name, unsigned int tid = 0) const
1269  {
1270  std::vector<T *> objs;
1271  theWarehouse()
1272  .query()
1273  .condition<AttribSystem>("UserObject")
1274  .condition<AttribThread>(tid)
1275  .condition<AttribName>(name)
1276  .queryInto(objs);
1277  if (objs.empty())
1278  mooseError("Unable to find user object with name '" + name + "'");
1279  return *(objs[0]);
1280  }
1287  const UserObject & getUserObjectBase(const std::string & name, const THREAD_ID tid = 0) const;
1288 
1294  const Positions & getPositionsObject(const std::string & name) const;
1295 
1301  bool hasUserObject(const std::string & name) const;
1302 
1311  bool hasPostprocessorValueByName(const PostprocessorName & name) const;
1312 
1323  const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName & name,
1324  std::size_t t_index = 0) const;
1325 
1340  void setPostprocessorValueByName(const PostprocessorName & name,
1341  const PostprocessorValue & value,
1342  std::size_t t_index = 0);
1343 
1347  bool hasPostprocessor(const std::string & name) const;
1348 
1359  const VectorPostprocessorValue &
1360  getVectorPostprocessorValueByName(const std::string & object_name,
1361  const std::string & vector_name,
1362  std::size_t t_index = 0) const;
1363 
1371  void setVectorPostprocessorValueByName(const std::string & object_name,
1372  const std::string & vector_name,
1373  const VectorPostprocessorValue & value,
1374  std::size_t t_index = 0);
1375 
1384  const VectorPostprocessor & getVectorPostprocessorObjectByName(const std::string & object_name,
1385  const THREAD_ID tid = 0) const;
1386 
1388 
1391  bool hasMultiApps() const { return _multi_apps.hasActiveObjects(); }
1392  bool hasMultiApps(ExecFlagType type) const;
1393  bool hasMultiApp(const std::string & name) const;
1395 
1396  // Dampers /////
1397  virtual void addDamper(const std::string & damper_name,
1398  const std::string & name,
1400  void setupDampers();
1401 
1405  bool hasDampers() { return _has_dampers; }
1406 
1407  // Indicators /////
1408  virtual void addIndicator(const std::string & indicator_name,
1409  const std::string & name,
1411 
1412  // Markers //////
1413  virtual void addMarker(const std::string & marker_name,
1414  const std::string & name,
1416 
1420  virtual void addMultiApp(const std::string & multi_app_name,
1421  const std::string & name,
1423 
1427  std::shared_ptr<MultiApp> getMultiApp(const std::string & multi_app_name) const;
1428 
1432  std::vector<std::shared_ptr<Transfer>> getTransfers(ExecFlagType type,
1433  Transfer::DIRECTION direction) const;
1434  std::vector<std::shared_ptr<Transfer>> getTransfers(Transfer::DIRECTION direction) const;
1435 
1441 
1448 
1452  bool execMultiApps(ExecFlagType type, bool auto_advance = true);
1453 
1454  void finalizeMultiApps();
1455 
1460 
1466  {
1467  mooseDeprecated("Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep "
1468  "depending on your purpose");
1470  }
1471 
1476  void finishMultiAppStep(ExecFlagType type, bool recurse_through_multiapp_levels = false);
1477 
1482 
1487  void restoreMultiApps(ExecFlagType type, bool force = false);
1488 
1493 
1497  virtual void addTransfer(const std::string & transfer_name,
1498  const std::string & name,
1500 
1508 
1514 
1520 
1527  virtual Real computeResidualL2Norm();
1528 
1533  const NumericVector<libMesh::Number> & soln,
1534  NumericVector<libMesh::Number> & residual);
1540  const NumericVector<libMesh::Number> & soln,
1541  NumericVector<libMesh::Number> & residual);
1542 
1546  virtual void computeResidual(const NumericVector<libMesh::Number> & soln,
1547  NumericVector<libMesh::Number> & residual,
1548  const unsigned int nl_sys_num);
1549 
1553  void computeResidualAndJacobian(const NumericVector<libMesh::Number> & soln,
1554  NumericVector<libMesh::Number> & residual,
1556 
1560  virtual void computeResidualTag(const NumericVector<libMesh::Number> & soln,
1561  NumericVector<libMesh::Number> & residual,
1562  TagID tag);
1566  virtual void computeResidualType(const NumericVector<libMesh::Number> & soln,
1567  NumericVector<libMesh::Number> & residual,
1568  TagID tag);
1569 
1574  virtual void computeResidualInternal(const NumericVector<libMesh::Number> & soln,
1575  NumericVector<libMesh::Number> & residual,
1576  const std::set<TagID> & tags);
1580  virtual void computeResidualTags(const std::set<TagID> & tags);
1581 
1586  const NumericVector<libMesh::Number> & soln,
1591  virtual void computeJacobian(const NumericVector<libMesh::Number> & soln,
1593  const unsigned int nl_sys_num);
1594 
1598  virtual void computeJacobianTag(const NumericVector<libMesh::Number> & soln,
1600  TagID tag);
1601 
1605  virtual void computeJacobianInternal(const NumericVector<libMesh::Number> & soln,
1607  const std::set<TagID> & tags);
1608 
1612  virtual void computeJacobianTags(const std::set<TagID> & tags);
1613 
1622  virtual void computeJacobianBlocks(std::vector<JacobianBlock *> & blocks,
1623  const unsigned int nl_sys_num);
1624 
1639  libMesh::System & precond_system,
1640  unsigned int ivar,
1641  unsigned int jvar);
1642 
1654  NumericVector<libMesh::Number> & rhs,
1655  const bool compute_gradients = true);
1656 
1666  void computeLinearSystemTags(const NumericVector<libMesh::Number> & soln,
1667  const std::set<TagID> & vector_tags,
1668  const std::set<TagID> & matrix_tags,
1669  const bool compute_gradients = true);
1670 
1671  virtual Real computeDamping(const NumericVector<libMesh::Number> & soln,
1672  const NumericVector<libMesh::Number> & update);
1673 
1678  virtual bool shouldUpdateSolution();
1679 
1686  virtual bool updateSolution(NumericVector<libMesh::Number> & vec_solution,
1687  NumericVector<libMesh::Number> & ghosted_solution);
1688 
1693  virtual void predictorCleanup(NumericVector<libMesh::Number> & ghosted_solution);
1694 
1696  NumericVector<libMesh::Number> & lower,
1697  NumericVector<libMesh::Number> & upper);
1699  std::vector<NumericVector<libMesh::Number> *> & sp);
1701  std::vector<NumericVector<libMesh::Number> *> & sp);
1703  std::vector<NumericVector<libMesh::Number> *> & sp);
1705  const NumericVector<libMesh::Number> & old_soln,
1706  NumericVector<libMesh::Number> & search_direction,
1707  NumericVector<libMesh::Number> & new_soln,
1708  bool & changed_search_direction,
1709  bool & changed_new_soln);
1710 
1711  virtual void computeIndicatorsAndMarkers();
1712  virtual void computeIndicators();
1713  virtual void computeMarkers();
1714 
1715  virtual void addResidual(const THREAD_ID tid) override;
1716  virtual void addResidualNeighbor(const THREAD_ID tid) override;
1717  virtual void addResidualLower(const THREAD_ID tid) override;
1718  virtual void addResidualScalar(const THREAD_ID tid = 0);
1719 
1720  virtual void cacheResidual(const THREAD_ID tid) override;
1721  virtual void cacheResidualNeighbor(const THREAD_ID tid) override;
1722  virtual void addCachedResidual(const THREAD_ID tid) override;
1723 
1731  virtual void addCachedResidualDirectly(NumericVector<libMesh::Number> & residual,
1732  const THREAD_ID tid);
1733 
1734  virtual void setResidual(NumericVector<libMesh::Number> & residual, const THREAD_ID tid) override;
1735  virtual void setResidualNeighbor(NumericVector<libMesh::Number> & residual,
1736  const THREAD_ID tid) override;
1737 
1738  virtual void addJacobian(const THREAD_ID tid) override;
1739  virtual void addJacobianNeighbor(const THREAD_ID tid) override;
1740  virtual void addJacobianNeighborLowerD(const THREAD_ID tid) override;
1741  virtual void addJacobianLowerD(const THREAD_ID tid) override;
1743  unsigned int ivar,
1744  unsigned int jvar,
1745  const DofMap & dof_map,
1746  std::vector<dof_id_type> & dof_indices,
1747  const std::set<TagID> & tags,
1748  const THREAD_ID tid);
1750  unsigned int ivar,
1751  unsigned int jvar,
1752  const DofMap & dof_map,
1753  std::vector<dof_id_type> & dof_indices,
1754  std::vector<dof_id_type> & neighbor_dof_indices,
1755  const std::set<TagID> & tags,
1756  const THREAD_ID tid) override;
1757  virtual void addJacobianScalar(const THREAD_ID tid = 0);
1758  virtual void addJacobianOffDiagScalar(unsigned int ivar, const THREAD_ID tid = 0);
1759 
1760  virtual void cacheJacobian(const THREAD_ID tid) override;
1761  virtual void cacheJacobianNeighbor(const THREAD_ID tid) override;
1762  virtual void addCachedJacobian(const THREAD_ID tid) override;
1763 
1764  virtual void prepareShapes(unsigned int var, const THREAD_ID tid) override;
1765  virtual void prepareFaceShapes(unsigned int var, const THREAD_ID tid) override;
1766  virtual void prepareNeighborShapes(unsigned int var, const THREAD_ID tid) override;
1767 
1768  // Displaced problem /////
1769  virtual void addDisplacedProblem(std::shared_ptr<DisplacedProblem> displaced_problem);
1770  virtual std::shared_ptr<const DisplacedProblem> getDisplacedProblem() const
1771  {
1772  return _displaced_problem;
1773  }
1774  virtual std::shared_ptr<DisplacedProblem> getDisplacedProblem() { return _displaced_problem; }
1775 
1776  virtual void updateGeomSearch(
1778  virtual void updateMortarMesh();
1779 
1780  void createMortarInterface(
1781  const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1782  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1783  bool on_displaced,
1784  bool periodic,
1785  const bool debug,
1786  const bool correct_edge_dropping,
1787  const Real minimum_projection_angle);
1788 
1795  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1796  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1797  bool on_displaced) const;
1798 
1800  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1801  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1802  bool on_displaced);
1804 
1805  const std::unordered_map<std::pair<BoundaryID, BoundaryID>, AutomaticMortarGeneration> &
1806  getMortarInterfaces(bool on_displaced) const;
1807 
1808  virtual void possiblyRebuildGeomSearchPatches();
1809 
1811 
1816  void setRestartFile(const std::string & file_name);
1817 
1822  {
1823  return _material_prop_registry;
1824  }
1825 
1834  {
1835  return _neighbor_material_props;
1836  }
1837 
1838 #ifdef MOOSE_KOKKOS_ENABLED
1840  {
1841  return _kokkos_material_props;
1842  }
1844  {
1846  }
1848  {
1850  }
1851 #endif
1852 
1860  {
1862  }
1865 
1870 
1875 
1879  SolverParams & solverParams(unsigned int solver_sys_num = 0);
1880 
1884  const SolverParams & solverParams(unsigned int solver_sys_num = 0) const;
1885 
1886 #ifdef LIBMESH_ENABLE_AMR
1887  // Adaptivity /////
1889  virtual void initialAdaptMesh();
1890 
1894  virtual bool adaptMesh();
1895 
1899  unsigned int getNumCyclesCompleted() { return _cycles_completed; }
1900 
1904  bool hasInitialAdaptivity() const { return _adaptivity.getInitialSteps() > 0; }
1905 #else
1906 
1909  bool hasInitialAdaptivity() const { return false; }
1910 #endif // LIBMESH_ENABLE_AMR
1911 
1913  void initXFEM(std::shared_ptr<XFEMInterface> xfem);
1914 
1916  std::shared_ptr<XFEMInterface> getXFEM() { return _xfem; }
1917 
1919  bool haveXFEM() { return _xfem != nullptr; }
1920 
1922  virtual bool updateMeshXFEM();
1923 
1938  virtual void
1939  meshChanged(bool intermediate_change, bool contract_mesh, bool clean_refinement_flags);
1940 
1946 
1952 
1958  void initElementStatefulProps(const libMesh::ConstElemRange & elem_range, const bool threaded);
1959 
1960 #ifdef MOOSE_KOKKOS_ENABLED
1961  void initKokkosStatefulProps();
1962 #endif
1963 
1968  virtual void checkProblemIntegrity();
1969 
1970  void registerRandomInterface(RandomInterface & random_interface, const std::string & name);
1971 
1976  void setConstJacobian(bool state) { _const_jacobian = state; }
1977 
1983 
1988  void setKernelCoverageCheck(bool flag)
1989  {
1991  }
1992 
2000 
2008  {
2010  }
2011 
2016 
2018  void setVerboseProblem(bool verbose);
2019 
2023  bool verboseMultiApps() const { return _verbose_multiapps; }
2024 
2029 
2031 
2048  bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid);
2049  bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid);
2050  bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, const THREAD_ID tid);
2052 
2057  unsigned int subspaceDim(const std::string & prefix) const
2058  {
2059  if (_subspace_dim.count(prefix))
2060  return _subspace_dim.find(prefix)->second;
2061  else
2062  return 0;
2063  }
2064 
2065  /*
2066  * Return a reference to the material warehouse of *all* Material objects.
2067  */
2069 
2070  /*
2071  * Return a reference to the material warehouse of Material objects to be computed.
2072  */
2076 
2077 #ifdef MOOSE_KOKKOS_ENABLED
2078  /*
2079  * Return a reference to the material warehouse of Kokkos Material objects to be computed.
2080  */
2082 #endif
2083 
2091  std::shared_ptr<MaterialBase> getMaterial(std::string name,
2093  const THREAD_ID tid = 0,
2094  bool no_warn = false);
2095 
2100  const THREAD_ID tid = 0,
2101  const MooseObject * object = nullptr) const;
2102 
2103 #ifdef MOOSE_KOKKOS_ENABLED
2104 
2108  const MooseObject * object = nullptr) const;
2109 #endif
2110 
2114  const std::set<const MooseObject *> &
2116 
2117 #ifdef MOOSE_KOKKOS_ENABLED
2118 
2121  const std::set<const MooseObject *> &
2123 #endif
2124 
2129 
2135  {
2137  }
2138 
2140  {
2142  }
2143 
2149 
2153  void setPreserveMatrixSparsityPattern(bool preserve);
2154 
2160 
2163 
2170  bool acceptInvalidSolution() const;
2175 
2180 
2185 
2187  bool hasTimeIntegrator() const { return _has_time_integrator; }
2188 
2190 
2196  const ExecFlagType & getCurrentExecuteOnFlag() const;
2197  void setCurrentExecuteOnFlag(const ExecFlagType &);
2199 
2203  virtual void execute(const ExecFlagType & exec_type);
2204  virtual void executeAllObjects(const ExecFlagType & exec_type);
2205 
2206  virtual Executor & getExecutor(const std::string & name) { return _app.getExecutor(name); }
2207 
2211  virtual void computeUserObjects(const ExecFlagType & type, const Moose::AuxGroup & group);
2212 
2216  virtual void computeUserObjectByName(const ExecFlagType & type,
2217  const Moose::AuxGroup & group,
2218  const std::string & name);
2219 
2223  void needsPreviousNewtonIteration(bool state);
2224 
2229  bool needsPreviousNewtonIteration() const;
2230 
2232 
2235  std::vector<Real> _real_zero;
2236  std::vector<VariableValue> _scalar_zero;
2237  std::vector<VariableValue> _zero;
2238  std::vector<VariablePhiValue> _phi_zero;
2239  std::vector<MooseArray<ADReal>> _ad_zero;
2240  std::vector<VariableGradient> _grad_zero;
2241  std::vector<MooseArray<ADRealVectorValue>> _ad_grad_zero;
2242  std::vector<VariablePhiGradient> _grad_phi_zero;
2243  std::vector<VariableSecond> _second_zero;
2244  std::vector<MooseArray<ADRealTensorValue>> _ad_second_zero;
2245  std::vector<VariablePhiSecond> _second_phi_zero;
2246  std::vector<Point> _point_zero;
2247  std::vector<VectorVariableValue> _vector_zero;
2248  std::vector<VectorVariableCurl> _vector_curl_zero;
2250 
2255 
2259  void executeControls(const ExecFlagType & exec_type);
2260 
2264  void executeSamplers(const ExecFlagType & exec_type);
2265 
2269  virtual void updateActiveObjects();
2270 
2277 
2279 
2283  bool hasJacobian() const;
2284 
2289  bool constJacobian() const;
2290 
2294  void addOutput(const std::string &, const std::string &, InputParameters &);
2295 
2296  inline TheWarehouse & theWarehouse() const { return _app.theWarehouse(); }
2297 
2301  void setSNESMFReuseBase(bool reuse, bool set_by_user)
2302  {
2303  _snesmf_reuse_base = reuse, _snesmf_reuse_base_set_by_user = set_by_user;
2304  }
2305 
2310 
2314  void skipExceptionCheck(bool skip_exception_check)
2315  {
2316  _skip_exception_check = skip_exception_check;
2317  }
2318 
2323 
2328 
2329 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
2330  PetscOptions & petscOptionsDatabase() { return _petsc_option_data_base; }
2331 #endif
2332 
2334  virtual void setUDotRequested(const bool u_dot_requested) { _u_dot_requested = u_dot_requested; }
2335 
2337  virtual void setUDotDotRequested(const bool u_dotdot_requested)
2338  {
2339  _u_dotdot_requested = u_dotdot_requested;
2340  }
2341 
2343  virtual void setUDotOldRequested(const bool u_dot_old_requested)
2344  {
2345  _u_dot_old_requested = u_dot_old_requested;
2346  }
2347 
2349  virtual void setUDotDotOldRequested(const bool u_dotdot_old_requested)
2350  {
2351  _u_dotdot_old_requested = u_dotdot_old_requested;
2352  }
2353 
2355  virtual bool uDotRequested() { return _u_dot_requested; }
2356 
2358  virtual bool uDotDotRequested() { return _u_dotdot_requested; }
2359 
2361  virtual bool uDotOldRequested()
2362  {
2364  mooseError("FEProblemBase: When requesting old time derivative of solution, current time "
2365  "derivative of solution should also be stored. Please set `u_dot_requested` to "
2366  "true using setUDotRequested.");
2367 
2368  return _u_dot_old_requested;
2369  }
2370 
2372  virtual bool uDotDotOldRequested()
2373  {
2375  mooseError("FEProblemBase: When requesting old second time derivative of solution, current "
2376  "second time derivation of solution should also be stored. Please set "
2377  "`u_dotdot_requested` to true using setUDotDotRequested.");
2378  return _u_dotdot_old_requested;
2379  }
2380 
2382  void haveADObjects(bool have_ad_objects) override;
2383 
2384  // Whether or not we should solve this system
2385  bool shouldSolve() const { return _solve; }
2386 
2390  const MortarData & mortarData() const { return _mortar_data; }
2392 
2397 
2401  virtual bool hasMortarCoupling() const { return _has_mortar; }
2402 
2404  void computingNonlinearResid(bool computing_nonlinear_residual) final;
2405 
2407  void setCurrentlyComputingResidual(bool currently_computing_residual) final;
2408 
2412  void numGridSteps(unsigned int num_grid_steps) { _num_grid_steps = num_grid_steps; }
2413 
2418  void uniformRefine();
2419 
2421  void automaticScaling(bool automatic_scaling) override;
2422 
2424 
2427  template <typename T>
2428  static void objectSetupHelper(const std::vector<T *> & objects, const ExecFlagType & exec_flag);
2429  template <typename T>
2430  static void objectExecuteHelper(const std::vector<T *> & objects);
2432 
2439  virtual void reinitElemFaceRef(const Elem * elem,
2440  unsigned int side,
2441  Real tolerance,
2442  const std::vector<Point> * const pts,
2443  const std::vector<Real> * const weights = nullptr,
2444  const THREAD_ID tid = 0) override;
2445 
2452  virtual void reinitNeighborFaceRef(const Elem * neighbor_elem,
2453  unsigned int neighbor_side,
2454  Real tolerance,
2455  const std::vector<Point> * const pts,
2456  const std::vector<Real> * const weights = nullptr,
2457  const THREAD_ID tid = 0) override;
2458 
2463 
2468  void fvBCsIntegrityCheck(bool fv_bcs_integrity_check);
2469 
2478  void getFVMatsAndDependencies(SubdomainID block_id,
2479  std::vector<std::shared_ptr<MaterialBase>> & face_materials,
2480  std::vector<std::shared_ptr<MaterialBase>> & neighbor_materials,
2481  std::set<MooseVariableFieldBase *> & variables,
2482  const THREAD_ID tid);
2483 
2490  void resizeMaterialData(Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid);
2491 
2492  bool haveDisplaced() const override final { return _displaced_problem.get(); }
2493 
2495  bool hasLinearConvergenceObjects() const;
2499  void setNonlinearConvergenceNames(const std::vector<ConvergenceName> & convergence_names);
2503  void setLinearConvergenceNames(const std::vector<ConvergenceName> & convergence_names);
2507  void setMultiAppFixedPointConvergenceName(const ConvergenceName & convergence_name);
2511  void setSteadyStateConvergenceName(const ConvergenceName & convergence_name);
2512 
2516  const std::vector<ConvergenceName> & getNonlinearConvergenceNames() const;
2520  const std::vector<ConvergenceName> & getLinearConvergenceNames() const;
2524  const ConvergenceName & getMultiAppFixedPointConvergenceName() const;
2528  const ConvergenceName & getSteadyStateConvergenceName() const;
2529 
2533  void computingScalingJacobian(bool computing_scaling_jacobian)
2534  {
2535  _computing_scaling_jacobian = computing_scaling_jacobian;
2536  }
2537 
2538  bool computingScalingJacobian() const override final { return _computing_scaling_jacobian; }
2539 
2543  void computingScalingResidual(bool computing_scaling_residual)
2544  {
2545  _computing_scaling_residual = computing_scaling_residual;
2546  }
2547 
2551  bool computingScalingResidual() const override final { return _computing_scaling_residual; }
2552 
2558 
2559  virtual std::size_t numNonlinearSystems() const override { return _num_nl_sys; }
2560 
2561  virtual std::size_t numLinearSystems() const override { return _num_linear_sys; }
2562 
2563  virtual std::size_t numSolverSystems() const override { return _num_nl_sys + _num_linear_sys; }
2564 
2566  bool isSolverSystemNonlinear(const unsigned int sys_num) { return sys_num < _num_nl_sys; }
2567 
2568  virtual unsigned int currentNlSysNum() const override;
2569 
2570  virtual unsigned int currentLinearSysNum() const override;
2571 
2575  virtual unsigned int nlSysNum(const NonlinearSystemName & nl_sys_name) const override;
2576 
2580  unsigned int linearSysNum(const LinearSystemName & linear_sys_name) const override;
2581 
2585  unsigned int solverSysNum(const SolverSystemName & solver_sys_name) const override;
2586 
2591  unsigned int systemNumForVariable(const VariableName & variable_name) const;
2592 
2597 
2602 
2607 
2608  /*
2609  * Set the status of loop order of execution printing
2610  * @param print_exec set of execution flags to print on
2611  */
2612  void setExecutionPrinting(const ExecFlagEnum & print_exec) { _print_execution_on = print_exec; }
2613 
2617  bool shouldPrintExecution(const THREAD_ID tid) const;
2622  void reinitMortarUserObjects(BoundaryID primary_boundary_id,
2623  BoundaryID secondary_boundary_id,
2624  bool displaced);
2625 
2626  virtual const std::vector<VectorTag> & currentResidualVectorTags() const override;
2627 
2633  {
2634  friend class CrankNicolson;
2635  friend class FEProblemBase;
2638  };
2639 
2643  void setCurrentResidualVectorTags(const std::set<TagID> & vector_tags);
2644 
2649 
2654 
2655  virtual void needFV() override { _have_fv = true; }
2656  virtual bool haveFV() const override { return _have_fv; }
2657 
2658  virtual bool hasNonlocalCoupling() const override { return _has_nonlocal_coupling; }
2659 
2664 
2665  virtual void setCurrentLowerDElem(const Elem * const lower_d_elem, const THREAD_ID tid) override;
2666  virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid) override;
2667 
2671  const std::vector<NonlinearSystemName> & getNonlinearSystemNames() const { return _nl_sys_names; }
2675  const std::vector<LinearSystemName> & getLinearSystemNames() const { return _linear_sys_names; }
2679  const std::vector<SolverSystemName> & getSolverSystemNames() const { return _solver_sys_names; }
2680 
2681  virtual const libMesh::CouplingMatrix & nonlocalCouplingMatrix(const unsigned i) const override;
2682 
2683  virtual bool checkNonlocalCouplingRequirement() const override;
2684 
2686 
2688  {
2691 
2693  };
2694 
2696 
2700  bool hasKokkosObjects() const { return _has_kokkos_objects; }
2701 
2702 protected:
2706  virtual void meshChanged() {}
2707 
2709  void createTagVectors();
2710 
2712  void createTagSolutions();
2713 
2717  virtual void meshDisplaced();
2718 
2722  void computeSystems(const ExecFlagType & type);
2723 
2725 
2726 private:
2729 
2741  void setResidualObjectParamsAndLog(const std::string & ro_name,
2742  const std::string & name,
2743  InputParameters & params,
2744  const unsigned int nl_sys_num,
2745  const std::string & base_name,
2746  bool & reinit_displaced);
2747 
2752 
2753 protected:
2755 
2757  std::optional<std::vector<ConvergenceName>> _nonlinear_convergence_names;
2759  std::optional<std::vector<ConvergenceName>> _linear_convergence_names;
2761  std::optional<ConvergenceName> _multiapp_fixed_point_convergence_name;
2763  std::optional<ConvergenceName> _steady_state_convergence_name;
2764 
2765  std::set<TagID> _fe_vector_tags;
2766 
2767  std::set<TagID> _fe_matrix_tags;
2768 
2770  std::set<TagID> _linear_vector_tags;
2771 
2773  std::set<TagID> _linear_matrix_tags;
2774 
2776  const bool & _solve;
2777 
2781  int & _t_step;
2784 
2791 
2793  const std::vector<LinearSystemName> _linear_sys_names;
2794 
2796  const std::size_t _num_linear_sys;
2797 
2799  std::vector<std::shared_ptr<LinearSystem>> _linear_systems;
2800 
2802  std::map<LinearSystemName, unsigned int> _linear_sys_name_to_num;
2803 
2806 
2808  const bool _using_default_nl;
2809 
2811  const std::vector<NonlinearSystemName> _nl_sys_names;
2812 
2814  const std::size_t _num_nl_sys;
2815 
2817  std::vector<std::shared_ptr<NonlinearSystemBase>> _nl;
2818 
2820  std::map<NonlinearSystemName, unsigned int> _nl_sys_name_to_num;
2821 
2824 
2827 
2829  std::vector<std::shared_ptr<SolverSystem>> _solver_systems;
2830 
2832  std::map<SolverVariableName, unsigned int> _solver_var_to_sys_num;
2833 
2835  std::map<SolverSystemName, unsigned int> _solver_sys_name_to_num;
2836 
2838  std::vector<SolverSystemName> _solver_sys_names;
2839 
2841  std::shared_ptr<AuxiliarySystem> _aux;
2842 
2844  std::vector<std::unique_ptr<libMesh::CouplingMatrix>> _cm;
2845 
2846 #ifdef MOOSE_KOKKOS_ENABLED
2848 #endif
2849 
2851  std::map<std::string, unsigned int> _subspace_dim;
2852 
2855  std::vector<std::vector<std::unique_ptr<Assembly>>> _assembly;
2856 
2857 #ifdef MOOSE_KOKKOS_ENABLED
2859 #endif
2860 
2865 
2868 
2871 
2874 
2877 
2882  ScalarInitialConditionWarehouse _scalar_ics; // use base b/c of setup methods
2884 
2885  // material properties
2890 
2891 #ifdef MOOSE_KOKKOS_ENABLED
2895 #endif
2896  // Material Warehouses
2898  MaterialWarehouse _materials; // regular materials
2899  MaterialWarehouse _interface_materials; // interface materials
2900  MaterialWarehouse _discrete_materials; // Materials that the user must compute
2901  MaterialWarehouse _all_materials; // All materials for error checking and MaterialData storage
2902 
2903 #ifdef MOOSE_KOKKOS_ENABLED
2905 #endif
2906 
2909  // Indicator Warehouses
2913 
2914  // Marker Warehouse
2916 
2917  // Helper class to access Reporter object values
2919 
2920  // TODO: delete this after apps have been updated to not call getUserObjects
2922 
2925 
2928 
2931 
2934 
2937 
2940 
2942  std::map<std::string, std::unique_ptr<RandomData>> _random_data_objects;
2943 
2945  std::vector<std::unordered_map<SubdomainID, bool>> _block_mat_side_cache;
2946 
2948  std::vector<std::unordered_map<BoundaryID, bool>> _bnd_mat_side_cache;
2949 
2951  std::vector<std::unordered_map<BoundaryID, bool>> _interface_mat_side_cache;
2952 
2954  std::vector<MeshChangedInterface *> _notify_when_mesh_changes;
2955 
2957  std::vector<MeshDisplacedInterface *> _notify_when_mesh_displaces;
2958 
2960  bool duplicateVariableCheck(const std::string & var_name,
2961  const libMesh::FEType & type,
2962  bool is_aux,
2963  const std::set<SubdomainID> * const active_subdomains);
2964 
2966  const Moose::AuxGroup & group,
2967  TheWarehouse::Query & query);
2968 
2970  void checkDisplacementOrders();
2971 
2972  void checkUserObjects();
2973 
2980  const std::map<SubdomainID, std::vector<std::shared_ptr<MaterialBase>>> & materials_map);
2981 
2983  void checkCoordinateSystems();
2984 
2990  void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed = false);
2991 
2998  void addObjectParamsHelper(InputParameters & params,
2999  const std::string & object_name,
3000  const std::string & var_param_name = "variable");
3001 
3002 #ifdef LIBMESH_ENABLE_AMR
3004  unsigned int _cycles_completed;
3005 #endif
3006 
3008  std::shared_ptr<XFEMInterface> _xfem;
3009 
3010  // Displaced mesh /////
3012  std::shared_ptr<DisplacedProblem> _displaced_problem;
3015 
3022 
3025 
3028 
3031 
3034 
3037 
3040 
3043 
3046 
3049 
3052 
3055 
3059 
3060  std::vector<std::vector<const MooseVariableFEBase *>> _uo_jacobian_moose_vars;
3061 
3063  std::vector<unsigned char> _has_active_material_properties;
3064 
3065  std::vector<SolverParams> _solver_params;
3066 
3069  std::vector<SubdomainName> _kernel_coverage_blocks;
3070 
3074 
3078 
3081  std::vector<SubdomainName> _material_coverage_blocks;
3082 
3085 
3088 
3091 
3093  unsigned int _max_qps;
3094 
3097 
3100 
3103 
3106 
3109 
3112 
3115 
3117  std::string _exception_message;
3118 
3121 
3124 
3127 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
3129 #endif
3130 
3133 
3134  std::shared_ptr<LineSearch> _line_search;
3135 
3136  std::unique_ptr<libMesh::ConstElemRange> _evaluable_local_elem_range;
3137  std::unique_ptr<libMesh::ConstElemRange> _nl_evaluable_local_elem_range;
3138  std::unique_ptr<libMesh::ConstElemRange> _aux_evaluable_local_elem_range;
3139 
3140  std::unique_ptr<libMesh::ConstElemRange> _current_algebraic_elem_range;
3141  std::unique_ptr<libMesh::ConstNodeRange> _current_algebraic_node_range;
3142  std::unique_ptr<ConstBndNodeRange> _current_algebraic_bnd_node_range;
3143 
3147 
3148  // loop state during projection of initial conditions
3149  unsigned short _current_ic_state;
3150 
3154 
3155 private:
3160  void handleException(const std::string & calling_method);
3161 
3166  std::vector<MortarUserObject *>
3167  getMortarUserObjects(BoundaryID primary_boundary_id,
3168  BoundaryID secondary_boundary_id,
3169  bool displaced,
3170  const std::vector<MortarUserObject *> & mortar_uo_superset);
3171 
3176  std::vector<MortarUserObject *> getMortarUserObjects(BoundaryID primary_boundary_id,
3177  BoundaryID secondary_boundary_id,
3178  bool displaced);
3179 
3189  virtual std::pair<bool, unsigned int>
3190  determineSolverSystem(const std::string & var_name,
3191  bool error_if_not_found = false) const override;
3192 
3199  void checkICRestartError(const std::string & ic_name,
3200  const std::string & name,
3201  const VariableName & var_name);
3202 
3203  /*
3204  * Test if stateful property redistribution is expected to be
3205  * necessary, and set it up if so.
3206  */
3207  void addAnyRedistributers();
3208 
3209  void updateMaxQps();
3210 
3211  void joinAndFinalize(TheWarehouse::Query query, bool isgen = false);
3212 
3216  virtual void resetState();
3217 
3218  // Parameters handling Jacobian sparsity pattern behavior
3230 
3231  const bool _force_restart;
3238 
3241 
3244 
3247 
3250 
3253 
3256 
3257  friend class AuxiliarySystem;
3258  friend class NonlinearSystemBase;
3259  friend class MooseEigenSystem;
3260  friend class Resurrector;
3261  friend class Restartable;
3262  friend class DisplacedProblem;
3263 
3266 
3268  unsigned int _num_grid_steps;
3269 
3273 
3276 
3279 
3282 
3285 
3288 
3292  std::vector<VectorTag> _current_residual_vector_tags;
3293 
3295  bool _have_fv = false;
3296 
3300 
3302  std::vector<libMesh::CouplingMatrix> _nonlocal_cm;
3303 
3306 
3308  bool _has_kokkos_objects = false;
3309 
3310  friend void Moose::PetscSupport::setSinglePetscOption(const std::string & name,
3311  const std::string & value,
3312  FEProblemBase * const problem);
3313 };
3314 
3316 
3317 template <typename T>
3318 void
3320 {
3321  _app.getOutputWarehouse().allowOutput<T>(state);
3322 }
3323 
3324 template <typename T>
3325 void
3326 FEProblemBase::objectSetupHelper(const std::vector<T *> & objects, const ExecFlagType & exec_flag)
3327 {
3328  if (exec_flag == EXEC_INITIAL)
3329  {
3330  for (T * obj_ptr : objects)
3331  obj_ptr->initialSetup();
3332  }
3333 
3334  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
3335  {
3336  for (const auto obj_ptr : objects)
3337  obj_ptr->timestepSetup();
3338  }
3339  else if (exec_flag == EXEC_SUBDOMAIN)
3340  {
3341  for (const auto obj_ptr : objects)
3342  obj_ptr->subdomainSetup();
3343  }
3344 
3345  else if (exec_flag == EXEC_NONLINEAR)
3346  {
3347  for (const auto obj_ptr : objects)
3348  obj_ptr->jacobianSetup();
3349  }
3350 
3351  else if (exec_flag == EXEC_LINEAR)
3352  {
3353  for (const auto obj_ptr : objects)
3354  obj_ptr->residualSetup();
3355  }
3356 }
3357 
3358 template <typename T>
3359 void
3360 FEProblemBase::objectExecuteHelper(const std::vector<T *> & objects)
3361 {
3362  for (T * obj_ptr : objects)
3363  obj_ptr->execute();
3364 }
3365 
3366 template <typename T>
3367 std::vector<std::shared_ptr<T>>
3368 FEProblemBase::addObject(const std::string & type,
3369  const std::string & name,
3371  const bool threaded,
3372  const std::string & var_param_name)
3373 {
3374  parallel_object_only();
3375 
3376  logAdd(MooseUtils::prettyCppType<T>(), name, type, parameters);
3377  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
3378  addObjectParamsHelper(parameters, name, var_param_name);
3379 
3380  const auto n_threads = threaded ? libMesh::n_threads() : 1;
3381  std::vector<std::shared_ptr<T>> objects(n_threads);
3382  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
3383  {
3384  std::shared_ptr<T> obj = _factory.create<T>(type, name, parameters, tid);
3385  theWarehouse().add(obj);
3386  objects[tid] = std::move(obj);
3387  }
3388 
3389  return objects;
3390 }
3391 
3392 inline NonlinearSystemBase &
3393 FEProblemBase::getNonlinearSystemBase(const unsigned int sys_num)
3394 {
3395  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3396  return *_nl[sys_num];
3397 }
3398 
3399 inline const NonlinearSystemBase &
3400 FEProblemBase::getNonlinearSystemBase(const unsigned int sys_num) const
3401 {
3402  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3403  return *_nl[sys_num];
3404 }
3405 
3406 inline SolverSystem &
3407 FEProblemBase::getSolverSystem(const unsigned int sys_num)
3408 {
3409  mooseAssert(sys_num < _solver_systems.size(),
3410  "System number greater than the number of solver systems");
3411  return *_solver_systems[sys_num];
3412 }
3413 
3414 inline const SolverSystem &
3415 FEProblemBase::getSolverSystem(const unsigned int sys_num) const
3416 {
3417  mooseAssert(sys_num < _solver_systems.size(),
3418  "System number greater than the number of solver systems");
3419  return *_solver_systems[sys_num];
3420 }
3421 
3422 inline NonlinearSystemBase &
3424 {
3425  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3426  return *_current_nl_sys;
3427 }
3428 
3429 inline const NonlinearSystemBase &
3431 {
3432  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3433  return *_current_nl_sys;
3434 }
3435 
3436 inline LinearSystem &
3437 FEProblemBase::getLinearSystem(const unsigned int sys_num)
3438 {
3439  mooseAssert(sys_num < _linear_systems.size(),
3440  "System number greater than the number of linear systems");
3441  return *_linear_systems[sys_num];
3442 }
3443 
3444 inline const LinearSystem &
3445 FEProblemBase::getLinearSystem(const unsigned int sys_num) const
3446 {
3447  mooseAssert(sys_num < _linear_systems.size(),
3448  "System number greater than the number of linear systems");
3449  return *_linear_systems[sys_num];
3450 }
3451 
3452 inline LinearSystem &
3454 {
3455  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3456  return *_current_linear_sys;
3457 }
3458 
3459 inline const LinearSystem &
3461 {
3462  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3463  return *_current_linear_sys;
3464 }
3465 
3466 inline Assembly &
3467 FEProblemBase::assembly(const THREAD_ID tid, const unsigned int sys_num)
3468 {
3469  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3470  mooseAssert(sys_num < _assembly[tid].size(),
3471  "System number larger than the assembly container size");
3472  return *_assembly[tid][sys_num];
3473 }
3474 
3475 inline const Assembly &
3476 FEProblemBase::assembly(const THREAD_ID tid, const unsigned int sys_num) const
3477 {
3478  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3479  mooseAssert(sys_num < _assembly[tid].size(),
3480  "System number larger than the assembly container size");
3481  return *_assembly[tid][sys_num];
3482 }
3483 
3484 inline const libMesh::CouplingMatrix *
3485 FEProblemBase::couplingMatrix(const unsigned int i) const
3486 {
3487  return _cm[i].get();
3488 }
3489 
3490 inline void
3491 FEProblemBase::fvBCsIntegrityCheck(const bool fv_bcs_integrity_check)
3492 {
3494  // the user has requested that we don't check integrity so we will honor that
3495  return;
3496 
3497  _fv_bcs_integrity_check = fv_bcs_integrity_check;
3498 }
3499 
3500 inline const std::vector<VectorTag> &
3502 {
3504 }
3505 
3506 inline void
3507 FEProblemBase::setCurrentResidualVectorTags(const std::set<TagID> & vector_tags)
3508 {
3510 }
3511 
3512 inline void
3514 {
3516 }
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:1047
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 setResidualObjectParamsAndLog(const std::string &ro_name, const std::string &name, InputParameters &params, 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 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)
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.
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.
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.
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:1162
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:27
virtual bool shouldUpdateSolution()
Check to see whether the problem should update the solution.
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
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()
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:172
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 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 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.
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:2482
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