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 // MOOSE includes
13 #include "SubProblem.h"
14 #include "GeometricSearchData.h"
15 #include "MeshDivision.h"
16 #include "MortarData.h"
17 #include "ReporterData.h"
18 #include "Adaptivity.h"
22 #include "Restartable.h"
23 #include "SolverParams.h"
24 #include "PetscSupport.h"
25 #include "MooseApp.h"
27 #include "MaterialWarehouse.h"
28 #include "MooseVariableFE.h"
29 #include "MultiAppTransfer.h"
30 #include "Postprocessor.h"
31 #include "HashMap.h"
32 #include "VectorPostprocessor.h"
33 #include "PerfGraphInterface.h"
34 #include "Attributes.h"
35 #include "MooseObjectWarehouse.h"
38 #include "SolutionInvalidity.h"
39 #include "PetscSupport.h"
40 
41 #include "libmesh/enum_quadrature_type.h"
42 #include "libmesh/equation_systems.h"
43 
44 #include <unordered_map>
45 #include <memory>
46 
47 // Forward declarations
48 class AuxiliarySystem;
49 class DisplacedProblem;
50 class MooseMesh;
52 class LinearSystem;
53 class SolverSystem;
54 class NonlinearSystem;
55 class RandomInterface;
56 class RandomData;
59 class MultiMooseEnum;
61 class MaterialData;
62 class MooseEnum;
63 class Assembly;
64 class JacobianBlock;
65 class Control;
66 class MultiApp;
67 class TransientMultiApp;
69 class Indicator;
71 class Marker;
72 class Material;
73 class Transfer;
74 class XFEMInterface;
75 class SideUserObject;
76 class NodalUserObject;
77 class ElementUserObject;
80 class GeneralUserObject;
81 class Positions;
82 class Function;
83 class Distribution;
84 class Sampler;
85 class KernelBase;
86 class IntegratedBCBase;
87 class LineSearch;
88 class UserObject;
91 class Convergence;
93 class MortarUserObject;
94 class SolutionInvalidity;
95 
96 // libMesh forward declarations
97 namespace libMesh
98 {
99 class CouplingMatrix;
100 class NonlinearImplicitSystem;
101 class LinearImplicitSystem;
102 } // namespace libMesh
103 
105 {
106  ITERATING = 0,
107  // CONVERGED_RTOL_NORMAL = 1,
108  // CONVERGED_ATOL_NORMAL = 9,
109  CONVERGED_RTOL = 2,
110  CONVERGED_ATOL = 3,
111  CONVERGED_ITS = 4,
112  // CONVERGED_CG_NEG_CURVE = 5,
113  // CONVERGED_CG_CONSTRAINED = 6,
114  // CONVERGED_STEP_LENGTH = 7,
115  // CONVERGED_HAPPY_BREAKDOWN = 8,
116  DIVERGED_NULL = -2,
117  // DIVERGED_ITS = -3,
118  // DIVERGED_DTOL = -4,
119  // DIVERGED_BREAKDOWN = -5,
120  // DIVERGED_BREAKDOWN_BICG = -6,
121  // DIVERGED_NONSYMMETRIC = -7,
122  // DIVERGED_INDEFINITE_PC = -8,
123  DIVERGED_NANORINF = -9,
124  // DIVERGED_INDEFINITE_MAT = -10
126 };
127 
132 class FEProblemBase : public SubProblem, public Restartable
133 {
134 public:
135  static InputParameters validParams();
136 
138  virtual ~FEProblemBase();
139 
140  enum class CoverageCheckMode
141  {
142  FALSE,
143  TRUE,
144  OFF,
145  ON,
146  SKIP_LIST,
147  ONLY_LIST,
148  };
149 
150  virtual libMesh::EquationSystems & es() override { return _req.set().es(); }
151  virtual MooseMesh & mesh() override { return _mesh; }
152  virtual const MooseMesh & mesh() const override { return _mesh; }
153  const MooseMesh & mesh(bool use_displaced) const override;
154 
155  void setCoordSystem(const std::vector<SubdomainName> & blocks, const MultiMooseEnum & coord_sys);
156  void setAxisymmetricCoordAxis(const MooseEnum & rz_coord_axis);
157 
164 
166 
172  void setCouplingMatrix(std::unique_ptr<libMesh::CouplingMatrix> cm,
173  const unsigned int nl_sys_num);
174 
175  // DEPRECATED METHOD
176  void setCouplingMatrix(libMesh::CouplingMatrix * cm, const unsigned int nl_sys_num);
177 
178  const libMesh::CouplingMatrix * couplingMatrix(const unsigned int nl_sys_num) const override;
179 
182 
183  bool
184  areCoupled(const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const;
185 
189  bool hasUOAuxStateCheck() const { return _uo_aux_state_check; }
190 
198 
205 
206  std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> &
207  couplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num);
208  std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> &
209  nonlocalCouplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num);
210 
211  virtual bool hasVariable(const std::string & var_name) const override;
212  // NOTE: hasAuxiliaryVariable defined in parent class
213  bool hasSolverVariable(const std::string & var_name) const;
215  virtual const MooseVariableFieldBase &
216  getVariable(const THREAD_ID tid,
217  const std::string & var_name,
219  Moose::VarFieldType expected_var_field_type =
220  Moose::VarFieldType::VAR_FIELD_ANY) const override;
222  const std::string & var_name) override;
223  virtual MooseVariable & getStandardVariable(const THREAD_ID tid,
224  const std::string & var_name) override;
225  virtual VectorMooseVariable & getVectorVariable(const THREAD_ID tid,
226  const std::string & var_name) override;
227  virtual ArrayMooseVariable & getArrayVariable(const THREAD_ID tid,
228  const std::string & var_name) override;
229 
230  virtual bool hasScalarVariable(const std::string & var_name) const override;
231  virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid,
232  const std::string & var_name) override;
233  virtual libMesh::System & getSystem(const std::string & var_name) override;
234 
241  virtual void setActiveElementalMooseVariables(const std::set<MooseVariableFEBase *> & moose_vars,
242  const THREAD_ID tid) override;
243 
251  virtual void clearActiveElementalMooseVariables(const THREAD_ID tid) override;
252 
253  virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid) override;
254 
255  virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid) override;
256 
257  virtual void setActiveFEVariableCoupleableVectorTags(std::set<TagID> & vtags,
258  const THREAD_ID tid) override;
259 
260  virtual void setActiveFEVariableCoupleableMatrixTags(std::set<TagID> & mtags,
261  const THREAD_ID tid) override;
262 
263  virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid) override;
264 
265  virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid) override;
266 
267  virtual void setActiveScalarVariableCoupleableVectorTags(std::set<TagID> & vtags,
268  const THREAD_ID tid) override;
269 
270  virtual void setActiveScalarVariableCoupleableMatrixTags(std::set<TagID> & mtags,
271  const THREAD_ID tid) override;
272 
274  libMesh::Order order,
275  libMesh::Order volume_order = libMesh::INVALID_ORDER,
278  bool allow_negative_qweights = true);
279 
288 
289  void bumpAllQRuleOrder(libMesh::Order order, SubdomainID block);
290 
294  unsigned int getMaxQps() const;
295 
300 
304  void checkNonlocalCoupling();
306  void setVariableAllDoFMap(const std::vector<const MooseVariableFEBase *> & moose_vars);
307 
308  const std::vector<const MooseVariableFEBase *> &
310  {
311  return _uo_jacobian_moose_vars[tid];
312  }
313 
314  virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override;
315  virtual const Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) const override;
316 
320  virtual std::vector<VariableName> getVariableNames();
321 
322  void initialSetup() override;
324  void timestepSetup() override;
325  void customSetup(const ExecFlagType & exec_type) override;
326  void residualSetup() override;
327  void jacobianSetup() override;
328 
329  virtual void prepare(const Elem * elem, const THREAD_ID tid) override;
330  virtual void prepareFace(const Elem * elem, const THREAD_ID tid) override;
331  virtual void prepare(const Elem * elem,
332  unsigned int ivar,
333  unsigned int jvar,
334  const std::vector<dof_id_type> & dof_indices,
335  const THREAD_ID tid) override;
336 
337  virtual void setCurrentSubdomainID(const Elem * elem, const THREAD_ID tid) override;
338  virtual void
339  setNeighborSubdomainID(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
340  virtual void setNeighborSubdomainID(const Elem * elem, const THREAD_ID tid);
341  virtual void prepareAssembly(const THREAD_ID tid) override;
342 
343  virtual void addGhostedElem(dof_id_type elem_id) override;
344  virtual void addGhostedBoundary(BoundaryID boundary_id) override;
345  virtual void ghostGhostedBoundaries() override;
346 
347  virtual void sizeZeroes(unsigned int size, const THREAD_ID tid);
348  virtual bool reinitDirac(const Elem * elem, const THREAD_ID tid) override;
349 
350  virtual void reinitElem(const Elem * elem, const THREAD_ID tid) override;
351  virtual void reinitElemPhys(const Elem * elem,
352  const std::vector<Point> & phys_points_in_elem,
353  const THREAD_ID tid) override;
354  void reinitElemFace(const Elem * elem, unsigned int side, BoundaryID, const THREAD_ID tid);
355  virtual void reinitElemFace(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
356  virtual void reinitLowerDElem(const Elem * lower_d_elem,
357  const THREAD_ID tid,
358  const std::vector<Point> * const pts = nullptr,
359  const std::vector<Real> * const weights = nullptr) override;
360  virtual void reinitNode(const Node * node, const THREAD_ID tid) override;
361  virtual void reinitNodeFace(const Node * node, BoundaryID bnd_id, const THREAD_ID tid) override;
362  virtual void reinitNodes(const std::vector<dof_id_type> & nodes, const THREAD_ID tid) override;
363  virtual void reinitNodesNeighbor(const std::vector<dof_id_type> & nodes,
364  const THREAD_ID tid) override;
365  virtual void reinitNeighbor(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
366  virtual void reinitNeighborPhys(const Elem * neighbor,
367  unsigned int neighbor_side,
368  const std::vector<Point> & physical_points,
369  const THREAD_ID tid) override;
370  virtual void reinitNeighborPhys(const Elem * neighbor,
371  const std::vector<Point> & physical_points,
372  const THREAD_ID tid) override;
373  virtual void
374  reinitElemNeighborAndLowerD(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
375  virtual void reinitScalars(const THREAD_ID tid,
376  bool reinit_for_derivative_reordering = false) override;
377  virtual void reinitOffDiagScalars(const THREAD_ID tid) override;
378 
380  virtual void getDiracElements(std::set<const Elem *> & elems) override;
381  virtual void clearDiracInfo() override;
382 
383  virtual void subdomainSetup(SubdomainID subdomain, const THREAD_ID tid);
384  virtual void neighborSubdomainSetup(SubdomainID subdomain, const THREAD_ID tid);
385 
386  virtual void newAssemblyArray(std::vector<std::shared_ptr<SolverSystem>> & solver_systems);
387  virtual void initNullSpaceVectors(const InputParameters & parameters,
388  std::vector<std::shared_ptr<NonlinearSystemBase>> & nl);
389 
390  virtual void init() override;
391  virtual void solve(const unsigned int nl_sys_num);
392 
398  virtual void solveLinearSystem(const unsigned int linear_sys_num,
399  const Moose::PetscSupport::PetscOptions * po = nullptr);
400 
402 
421 
423 
438 
440 
461 
470  virtual void setException(const std::string & message);
471 
475  virtual bool hasException() { return _has_exception; }
476 
493  virtual void checkExceptionAndStopSolve(bool print_message = true);
494 
495  virtual bool solverSystemConverged(const unsigned int solver_sys_num) override;
496  virtual unsigned int nNonlinearIterations(const unsigned int nl_sys_num) const override;
497  virtual unsigned int nLinearIterations(const unsigned int nl_sys_num) const override;
498  virtual Real finalNonlinearResidual(const unsigned int nl_sys_num) const override;
499  virtual bool computingPreSMOResidual(const unsigned int nl_sys_num) const override;
500 
504  virtual std::string solverTypeString(unsigned int solver_sys_num = 0);
505 
509  virtual bool startedInitialSetup() { return _started_initial_setup; }
510 
511  virtual void onTimestepBegin() override;
512  virtual void onTimestepEnd() override;
513 
514  virtual Real & time() const { return _time; }
515  virtual Real & timeOld() const { return _time_old; }
516  virtual int & timeStep() const { return _t_step; }
517  virtual Real & dt() const { return _dt; }
518  virtual Real & dtOld() const { return _dt_old; }
522  Real getTimeFromStateArg(const Moose::StateArg & state) const;
523 
524  virtual void transient(bool trans) { _transient = trans; }
525  virtual bool isTransient() const override { return _transient; }
526 
527  virtual void addTimeIntegrator(const std::string & type,
528  const std::string & name,
530  virtual void
531  addPredictor(const std::string & type, const std::string & name, InputParameters & parameters);
532 
533  virtual void copySolutionsBackwards();
534 
539  virtual void advanceState();
540 
541  virtual void restoreSolutions();
542 
546  virtual void saveOldSolutions();
547 
551  virtual void restoreOldSolutions();
552 
558  void needSolutionState(unsigned int oldest_needed, Moose::SolutionIterationType iteration_type);
559 
566  virtual void outputStep(ExecFlagType type);
567 
571  virtual void postExecute();
572 
574 
580  void allowOutput(bool state);
581  template <typename T>
582  void allowOutput(bool state);
584 
593  void forceOutput();
594 
600 
605 
609  void logAdd(const std::string & system,
610  const std::string & name,
611  const std::string & type,
612  const InputParameters & params) const;
613 
614  // Function /////
615  virtual void
616  addFunction(const std::string & type, const std::string & name, InputParameters & parameters);
617  virtual bool hasFunction(const std::string & name, const THREAD_ID tid = 0);
618  virtual Function & getFunction(const std::string & name, const THREAD_ID tid = 0);
619 
621  virtual void
622  addMeshDivision(const std::string & type, const std::string & name, InputParameters & params);
624  MeshDivision & getMeshDivision(const std::string & name, const THREAD_ID tid = 0) const;
625 
627  virtual void
628  addConvergence(const std::string & type, const std::string & name, InputParameters & parameters);
630  virtual Convergence & getConvergence(const std::string & name, const THREAD_ID tid = 0) const;
632  virtual const std::vector<std::shared_ptr<Convergence>> &
633  getConvergenceObjects(const THREAD_ID tid = 0) const;
635  virtual bool hasConvergence(const std::string & name, const THREAD_ID tid = 0) const;
638  {
640  }
643  {
645  }
648  {
650  }
653  {
655  }
658  {
660  }
663  {
665  }
668  {
669  return _multiapp_fixed_point_convergence_name.has_value();
670  }
673  {
674  return _steady_state_convergence_name.has_value();
675  }
683  virtual void addDefaultNonlinearConvergence(const InputParameters & params);
691  virtual bool onlyAllowDefaultNonlinearConvergence() const { return false; }
708 
712  virtual void addLineSearch(const InputParameters & /*parameters*/)
713  {
714  mooseError("Line search not implemented for this problem type yet.");
715  }
716 
720  virtual void lineSearch();
721 
725  LineSearch * getLineSearch() override { return _line_search.get(); }
726 
730  virtual void
731  addDistribution(const std::string & type, const std::string & name, InputParameters & parameters);
732  virtual Distribution & getDistribution(const std::string & name);
733 
737  virtual void
738  addSampler(const std::string & type, const std::string & name, InputParameters & parameters);
739  virtual Sampler & getSampler(const std::string & name, const THREAD_ID tid = 0);
740 
741  // NL /////
742  NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num);
743  const NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num) const;
744  void setCurrentNonlinearSystem(const unsigned int nl_sys_num);
747 
748  virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const override;
749  virtual SystemBase & systemBaseNonlinear(const unsigned int sys_num) override;
750 
751  virtual const SystemBase & systemBaseSolver(const unsigned int sys_num) const override;
752  virtual SystemBase & systemBaseSolver(const unsigned int sys_num) override;
753 
754  virtual const SystemBase & systemBaseAuxiliary() const override;
755  virtual SystemBase & systemBaseAuxiliary() override;
756 
757  virtual NonlinearSystem & getNonlinearSystem(const unsigned int sys_num);
758 
763  virtual const SystemBase & getSystemBase(const unsigned int sys_num) const;
764 
769  virtual SystemBase & getSystemBase(const unsigned int sys_num);
770 
775  LinearSystem & getLinearSystem(unsigned int sys_num);
776 
781  const LinearSystem & getLinearSystem(unsigned int sys_num) const;
782 
787  SolverSystem & getSolverSystem(unsigned int sys_num);
788 
793  const SolverSystem & getSolverSystem(unsigned int sys_num) const;
794 
799  void setCurrentLinearSystem(unsigned int sys_num);
800 
804  const LinearSystem & currentLinearSystem() const;
805 
810  virtual const SystemBase & systemBaseLinear(unsigned int sys_num) const override;
811 
816  virtual SystemBase & systemBaseLinear(unsigned int sys_num) override;
817 
824  virtual void
825  addVariable(const std::string & var_type, const std::string & var_name, InputParameters & params);
826 
827  virtual void addKernel(const std::string & kernel_name,
828  const std::string & name,
830  virtual void addHDGKernel(const std::string & kernel_name,
831  const std::string & name,
833  virtual void addNodalKernel(const std::string & kernel_name,
834  const std::string & name,
836  virtual void addScalarKernel(const std::string & kernel_name,
837  const std::string & name,
839  virtual void addBoundaryCondition(const std::string & bc_name,
840  const std::string & name,
842  virtual void
843  addConstraint(const std::string & c_name, const std::string & name, InputParameters & parameters);
844 
846  {
847  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
848  }
849 
850  // Aux /////
851 
858  virtual void addAuxVariable(const std::string & var_type,
859  const std::string & var_name,
860  InputParameters & params);
861 
862  virtual void addAuxVariable(const std::string & var_name,
863  const libMesh::FEType & type,
864  const std::set<SubdomainID> * const active_subdomains = NULL);
865  virtual void addAuxArrayVariable(const std::string & var_name,
866  const libMesh::FEType & type,
867  unsigned int components,
868  const std::set<SubdomainID> * const active_subdomains = NULL);
869  virtual void addAuxScalarVariable(const std::string & var_name,
870  libMesh::Order order,
871  Real scale_factor = 1.,
872  const std::set<SubdomainID> * const active_subdomains = NULL);
873  virtual void addAuxKernel(const std::string & kernel_name,
874  const std::string & name,
876  virtual void addAuxScalarKernel(const std::string & kernel_name,
877  const std::string & name,
879 
881 
882  // Dirac /////
883  virtual void addDiracKernel(const std::string & kernel_name,
884  const std::string & name,
886 
887  // DG /////
888  virtual void addDGKernel(const std::string & kernel_name,
889  const std::string & name,
891  // FV /////
892  virtual void addFVKernel(const std::string & kernel_name,
893  const std::string & name,
895 
896  virtual void addLinearFVKernel(const std::string & kernel_name,
897  const std::string & name,
899  virtual void
900  addFVBC(const std::string & fv_bc_name, const std::string & name, InputParameters & parameters);
901  virtual void addLinearFVBC(const std::string & fv_bc_name,
902  const std::string & name,
904 
905  virtual void addFVInterfaceKernel(const std::string & fv_ik_name,
906  const std::string & name,
908 
909  // Interface /////
910  virtual void addInterfaceKernel(const std::string & kernel_name,
911  const std::string & name,
913 
914  // IC /////
915  virtual void addInitialCondition(const std::string & ic_name,
916  const std::string & name,
924  virtual void addFVInitialCondition(const std::string & ic_name,
925  const std::string & name,
927 
928  void projectSolution();
929 
934  unsigned short getCurrentICState();
935 
942  ConstBndNodeRange & bnd_node_range);
943 
944  // Materials /////
945  virtual void addMaterial(const std::string & material_name,
946  const std::string & name,
948  virtual void addMaterialHelper(std::vector<MaterialWarehouse *> warehouse,
949  const std::string & material_name,
950  const std::string & name,
952  virtual void addInterfaceMaterial(const std::string & material_name,
953  const std::string & name,
955  virtual void addFunctorMaterial(const std::string & functor_material_name,
956  const std::string & name,
958 
970  void prepareMaterials(const std::unordered_set<unsigned int> & consumer_needed_mat_props,
971  const SubdomainID blk_id,
972  const THREAD_ID tid);
973 
974  void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful = true);
975 
986  void reinitMaterialsFace(SubdomainID blk_id,
987  const THREAD_ID tid,
988  bool swap_stateful = true,
989  const std::deque<MaterialBase *> * reinit_mats = nullptr);
990 
1002  const THREAD_ID tid,
1003  bool swap_stateful = true,
1004  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1005 
1016  void reinitMaterialsBoundary(BoundaryID boundary_id,
1017  const THREAD_ID tid,
1018  bool swap_stateful = true,
1019  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1020 
1021  void
1022  reinitMaterialsInterface(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful = true);
1023 
1024  /*
1025  * Swap back underlying data storing stateful material properties
1026  */
1027  virtual void swapBackMaterials(const THREAD_ID tid);
1028  virtual void swapBackMaterialsFace(const THREAD_ID tid);
1029  virtual void swapBackMaterialsNeighbor(const THREAD_ID tid);
1030 
1037  void setActiveMaterialProperties(const std::unordered_set<unsigned int> & mat_prop_ids,
1038  const THREAD_ID tid);
1039 
1048  bool hasActiveMaterialProperties(const THREAD_ID tid) const;
1049 
1055  void clearActiveMaterialProperties(const THREAD_ID tid);
1056 
1068  template <typename T>
1069  std::vector<std::shared_ptr<T>> addObject(const std::string & type,
1070  const std::string & name,
1072  const bool threaded = true,
1073  const std::string & var_param_name = "variable");
1074 
1075  // Postprocessors /////
1076  virtual void addPostprocessor(const std::string & pp_name,
1077  const std::string & name,
1079 
1080  // VectorPostprocessors /////
1081  virtual void addVectorPostprocessor(const std::string & pp_name,
1082  const std::string & name,
1084 
1093  virtual void
1094  addReporter(const std::string & type, const std::string & name, InputParameters & parameters);
1095 
1103  const ReporterData & getReporterData() const { return _reporter_data; }
1104 
1111 
1112  // UserObjects /////
1113  virtual std::vector<std::shared_ptr<UserObject>> addUserObject(
1114  const std::string & user_object_name, const std::string & name, InputParameters & parameters);
1115 
1116  // TODO: delete this function after apps have been updated to not call it
1118  {
1120  "This function is deprecated, use theWarehouse().query() to construct a query instead");
1121  return _all_user_objects;
1122  }
1123 
1129  template <class T>
1130  T & getUserObject(const std::string & name, unsigned int tid = 0) const
1131  {
1132  std::vector<T *> objs;
1133  theWarehouse()
1134  .query()
1135  .condition<AttribSystem>("UserObject")
1136  .condition<AttribThread>(tid)
1137  .condition<AttribName>(name)
1138  .queryInto(objs);
1139  if (objs.empty())
1140  mooseError("Unable to find user object with name '" + name + "'");
1141  return *(objs[0]);
1142  }
1149  const UserObject & getUserObjectBase(const std::string & name, const THREAD_ID tid = 0) const;
1150 
1156  const Positions & getPositionsObject(const std::string & name) const;
1157 
1163  bool hasUserObject(const std::string & name) const;
1164 
1173  bool hasPostprocessorValueByName(const PostprocessorName & name) const;
1174 
1185  const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName & name,
1186  std::size_t t_index = 0) const;
1187 
1202  void setPostprocessorValueByName(const PostprocessorName & name,
1203  const PostprocessorValue & value,
1204  std::size_t t_index = 0);
1205 
1209  bool hasPostprocessor(const std::string & name) const;
1210 
1221  const VectorPostprocessorValue &
1222  getVectorPostprocessorValueByName(const std::string & object_name,
1223  const std::string & vector_name,
1224  std::size_t t_index = 0) const;
1225 
1233  void setVectorPostprocessorValueByName(const std::string & object_name,
1234  const std::string & vector_name,
1235  const VectorPostprocessorValue & value,
1236  std::size_t t_index = 0);
1237 
1246  const VectorPostprocessor & getVectorPostprocessorObjectByName(const std::string & object_name,
1247  const THREAD_ID tid = 0) const;
1248 
1250 
1253  bool hasMultiApps() const { return _multi_apps.hasActiveObjects(); }
1254  bool hasMultiApps(ExecFlagType type) const;
1255  bool hasMultiApp(const std::string & name) const;
1257 
1258  // Dampers /////
1259  virtual void addDamper(const std::string & damper_name,
1260  const std::string & name,
1262  void setupDampers();
1263 
1267  bool hasDampers() { return _has_dampers; }
1268 
1269  // Indicators /////
1270  virtual void addIndicator(const std::string & indicator_name,
1271  const std::string & name,
1273 
1274  // Markers //////
1275  virtual void addMarker(const std::string & marker_name,
1276  const std::string & name,
1278 
1282  virtual void addMultiApp(const std::string & multi_app_name,
1283  const std::string & name,
1285 
1289  std::shared_ptr<MultiApp> getMultiApp(const std::string & multi_app_name) const;
1290 
1294  std::vector<std::shared_ptr<Transfer>> getTransfers(ExecFlagType type,
1295  Transfer::DIRECTION direction) const;
1296  std::vector<std::shared_ptr<Transfer>> getTransfers(Transfer::DIRECTION direction) const;
1297 
1303 
1310 
1314  bool execMultiApps(ExecFlagType type, bool auto_advance = true);
1315 
1316  void finalizeMultiApps();
1317 
1322 
1328  {
1329  mooseDeprecated("Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep "
1330  "depending on your purpose");
1332  }
1333 
1338  void finishMultiAppStep(ExecFlagType type, bool recurse_through_multiapp_levels = false);
1339 
1344 
1349  void restoreMultiApps(ExecFlagType type, bool force = false);
1350 
1355 
1359  virtual void addTransfer(const std::string & transfer_name,
1360  const std::string & name,
1362 
1370 
1376 
1382 
1389  virtual Real computeResidualL2Norm();
1390 
1395  const NumericVector<libMesh::Number> & soln,
1396  NumericVector<libMesh::Number> & residual);
1402  const NumericVector<libMesh::Number> & soln,
1403  NumericVector<libMesh::Number> & residual);
1404 
1408  virtual void computeResidual(const NumericVector<libMesh::Number> & soln,
1409  NumericVector<libMesh::Number> & residual,
1410  const unsigned int nl_sys_num);
1411 
1415  void computeResidualAndJacobian(const NumericVector<libMesh::Number> & soln,
1416  NumericVector<libMesh::Number> & residual,
1418 
1422  virtual void computeResidualTag(const NumericVector<libMesh::Number> & soln,
1423  NumericVector<libMesh::Number> & residual,
1424  TagID tag);
1428  virtual void computeResidualType(const NumericVector<libMesh::Number> & soln,
1429  NumericVector<libMesh::Number> & residual,
1430  TagID tag);
1431 
1436  virtual void computeResidualInternal(const NumericVector<libMesh::Number> & soln,
1437  NumericVector<libMesh::Number> & residual,
1438  const std::set<TagID> & tags);
1442  virtual void computeResidualTags(const std::set<TagID> & tags);
1443 
1448  const NumericVector<libMesh::Number> & soln,
1453  virtual void computeJacobian(const NumericVector<libMesh::Number> & soln,
1455  const unsigned int nl_sys_num);
1456 
1460  virtual void computeJacobianTag(const NumericVector<libMesh::Number> & soln,
1462  TagID tag);
1463 
1467  virtual void computeJacobianInternal(const NumericVector<libMesh::Number> & soln,
1469  const std::set<TagID> & tags);
1470 
1474  virtual void computeJacobianTags(const std::set<TagID> & tags);
1475 
1484  virtual void computeJacobianBlocks(std::vector<JacobianBlock *> & blocks,
1485  const unsigned int nl_sys_num);
1486 
1501  libMesh::System & precond_system,
1502  unsigned int ivar,
1503  unsigned int jvar);
1504 
1516  NumericVector<libMesh::Number> & rhs,
1517  const bool compute_gradients = true);
1518 
1528  void computeLinearSystemTags(const NumericVector<libMesh::Number> & soln,
1529  const std::set<TagID> & vector_tags,
1530  const std::set<TagID> & matrix_tags,
1531  const bool compute_gradients = true);
1532 
1533  virtual Real computeDamping(const NumericVector<libMesh::Number> & soln,
1534  const NumericVector<libMesh::Number> & update);
1535 
1540  virtual bool shouldUpdateSolution();
1541 
1548  virtual bool updateSolution(NumericVector<libMesh::Number> & vec_solution,
1549  NumericVector<libMesh::Number> & ghosted_solution);
1550 
1555  virtual void predictorCleanup(NumericVector<libMesh::Number> & ghosted_solution);
1556 
1558  NumericVector<libMesh::Number> & lower,
1559  NumericVector<libMesh::Number> & upper);
1561  std::vector<NumericVector<libMesh::Number> *> & sp);
1563  std::vector<NumericVector<libMesh::Number> *> & sp);
1565  std::vector<NumericVector<libMesh::Number> *> & sp);
1567  const NumericVector<libMesh::Number> & old_soln,
1568  NumericVector<libMesh::Number> & search_direction,
1569  NumericVector<libMesh::Number> & new_soln,
1570  bool & changed_search_direction,
1571  bool & changed_new_soln);
1572 
1573  virtual void computeIndicatorsAndMarkers();
1574  virtual void computeIndicators();
1575  virtual void computeMarkers();
1576 
1577  virtual void addResidual(const THREAD_ID tid) override;
1578  virtual void addResidualNeighbor(const THREAD_ID tid) override;
1579  virtual void addResidualLower(const THREAD_ID tid) override;
1580  virtual void addResidualScalar(const THREAD_ID tid = 0);
1581 
1582  virtual void cacheResidual(const THREAD_ID tid) override;
1583  virtual void cacheResidualNeighbor(const THREAD_ID tid) override;
1584  virtual void addCachedResidual(const THREAD_ID tid) override;
1585 
1593  virtual void addCachedResidualDirectly(NumericVector<libMesh::Number> & residual,
1594  const THREAD_ID tid);
1595 
1596  virtual void setResidual(NumericVector<libMesh::Number> & residual, const THREAD_ID tid) override;
1597  virtual void setResidualNeighbor(NumericVector<libMesh::Number> & residual,
1598  const THREAD_ID tid) override;
1599 
1600  virtual void addJacobian(const THREAD_ID tid) override;
1601  virtual void addJacobianNeighbor(const THREAD_ID tid) override;
1602  virtual void addJacobianNeighborLowerD(const THREAD_ID tid) override;
1603  virtual void addJacobianLowerD(const THREAD_ID tid) override;
1605  unsigned int ivar,
1606  unsigned int jvar,
1607  const DofMap & dof_map,
1608  std::vector<dof_id_type> & dof_indices,
1609  const std::set<TagID> & tags,
1610  const THREAD_ID tid);
1612  unsigned int ivar,
1613  unsigned int jvar,
1614  const DofMap & dof_map,
1615  std::vector<dof_id_type> & dof_indices,
1616  std::vector<dof_id_type> & neighbor_dof_indices,
1617  const std::set<TagID> & tags,
1618  const THREAD_ID tid) override;
1619  virtual void addJacobianScalar(const THREAD_ID tid = 0);
1620  virtual void addJacobianOffDiagScalar(unsigned int ivar, const THREAD_ID tid = 0);
1621 
1622  virtual void cacheJacobian(const THREAD_ID tid) override;
1623  virtual void cacheJacobianNeighbor(const THREAD_ID tid) override;
1624  virtual void addCachedJacobian(const THREAD_ID tid) override;
1625 
1626  virtual void prepareShapes(unsigned int var, const THREAD_ID tid) override;
1627  virtual void prepareFaceShapes(unsigned int var, const THREAD_ID tid) override;
1628  virtual void prepareNeighborShapes(unsigned int var, const THREAD_ID tid) override;
1629 
1630  // Displaced problem /////
1631  virtual void addDisplacedProblem(std::shared_ptr<DisplacedProblem> displaced_problem);
1632  virtual std::shared_ptr<const DisplacedProblem> getDisplacedProblem() const
1633  {
1634  return _displaced_problem;
1635  }
1636  virtual std::shared_ptr<DisplacedProblem> getDisplacedProblem() { return _displaced_problem; }
1637 
1638  virtual void updateGeomSearch(
1640  virtual void updateMortarMesh();
1641 
1642  void createMortarInterface(
1643  const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1644  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1645  bool on_displaced,
1646  bool periodic,
1647  const bool debug,
1648  const bool correct_edge_dropping,
1649  const Real minimum_projection_angle);
1650 
1657  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1658  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1659  bool on_displaced) const;
1660 
1662  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
1663  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
1664  bool on_displaced);
1666 
1667  const std::unordered_map<std::pair<BoundaryID, BoundaryID>, AutomaticMortarGeneration> &
1668  getMortarInterfaces(bool on_displaced) const;
1669 
1670  virtual void possiblyRebuildGeomSearchPatches();
1671 
1673 
1678  void setRestartFile(const std::string & file_name);
1679 
1684  {
1685  return _material_prop_registry;
1686  }
1687 
1696  {
1697  return _neighbor_material_props;
1698  }
1700 
1707  {
1709  }
1712 
1717 
1722 
1726  SolverParams & solverParams(unsigned int solver_sys_num = 0);
1727 
1731  const SolverParams & solverParams(unsigned int solver_sys_num = 0) const;
1732 
1733 #ifdef LIBMESH_ENABLE_AMR
1734  // Adaptivity /////
1736  virtual void initialAdaptMesh();
1737 
1741  virtual bool adaptMesh();
1742 
1746  unsigned int getNumCyclesCompleted() { return _cycles_completed; }
1747 
1751  bool hasInitialAdaptivity() const { return _adaptivity.getInitialSteps() > 0; }
1752 #else
1753 
1756  bool hasInitialAdaptivity() const { return false; }
1757 #endif // LIBMESH_ENABLE_AMR
1758 
1760  void initXFEM(std::shared_ptr<XFEMInterface> xfem);
1761 
1763  std::shared_ptr<XFEMInterface> getXFEM() { return _xfem; }
1764 
1766  bool haveXFEM() { return _xfem != nullptr; }
1767 
1769  virtual bool updateMeshXFEM();
1770 
1785  virtual void
1786  meshChanged(bool intermediate_change, bool contract_mesh, bool clean_refinement_flags);
1787 
1793 
1799 
1805  void initElementStatefulProps(const libMesh::ConstElemRange & elem_range, const bool threaded);
1806 
1811  virtual void checkProblemIntegrity();
1812 
1813  void registerRandomInterface(RandomInterface & random_interface, const std::string & name);
1814 
1819  void setConstJacobian(bool state) { _const_jacobian = state; }
1820 
1826 
1831  void setKernelCoverageCheck(bool flag)
1832  {
1834  }
1835 
1843 
1851  {
1853  }
1854 
1859 
1861  void setVerboseProblem(bool verbose);
1862 
1866  bool verboseMultiApps() const { return _verbose_multiapps; }
1867 
1872 
1874 
1891  bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid);
1892  bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid);
1893  bool needSubdomainMaterialOnSide(SubdomainID subdomain_id, const THREAD_ID tid);
1895 
1900  unsigned int subspaceDim(const std::string & prefix) const
1901  {
1902  if (_subspace_dim.count(prefix))
1903  return _subspace_dim.find(prefix)->second;
1904  else
1905  return 0;
1906  }
1907 
1908  /*
1909  * Return a reference to the material warehouse of *all* Material objects.
1910  */
1912 
1913  /*
1914  * Return a reference to the material warehouse of Material objects to be computed.
1915  */
1919 
1927  std::shared_ptr<MaterialBase> getMaterial(std::string name,
1929  const THREAD_ID tid = 0,
1930  bool no_warn = false);
1931 
1932  /*
1933  * @return The MaterialData for the type \p type for thread \p tid
1934  */
1936 
1941 
1947  {
1949  }
1950 
1952  {
1954  }
1955 
1961 
1965  void setPreserveMatrixSparsityPattern(bool preserve);
1966 
1972 
1975 
1982  bool acceptInvalidSolution() const;
1987 
1992 
1997 
1999  bool hasTimeIntegrator() const { return _has_time_integrator; }
2000 
2002 
2008  const ExecFlagType & getCurrentExecuteOnFlag() const;
2009  void setCurrentExecuteOnFlag(const ExecFlagType &);
2011 
2015  virtual void execute(const ExecFlagType & exec_type);
2016  virtual void executeAllObjects(const ExecFlagType & exec_type);
2017 
2018  virtual Executor & getExecutor(const std::string & name) { return _app.getExecutor(name); }
2019 
2023  virtual void computeUserObjects(const ExecFlagType & type, const Moose::AuxGroup & group);
2024 
2028  virtual void computeUserObjectByName(const ExecFlagType & type,
2029  const Moose::AuxGroup & group,
2030  const std::string & name);
2031 
2035  void needsPreviousNewtonIteration(bool state);
2036 
2041  bool needsPreviousNewtonIteration() const;
2042 
2044 
2047  std::vector<Real> _real_zero;
2048  std::vector<VariableValue> _scalar_zero;
2049  std::vector<VariableValue> _zero;
2050  std::vector<VariablePhiValue> _phi_zero;
2051  std::vector<MooseArray<ADReal>> _ad_zero;
2052  std::vector<VariableGradient> _grad_zero;
2053  std::vector<MooseArray<ADRealVectorValue>> _ad_grad_zero;
2054  std::vector<VariablePhiGradient> _grad_phi_zero;
2055  std::vector<VariableSecond> _second_zero;
2056  std::vector<MooseArray<ADRealTensorValue>> _ad_second_zero;
2057  std::vector<VariablePhiSecond> _second_phi_zero;
2058  std::vector<Point> _point_zero;
2059  std::vector<VectorVariableValue> _vector_zero;
2060  std::vector<VectorVariableCurl> _vector_curl_zero;
2062 
2067 
2071  void executeControls(const ExecFlagType & exec_type);
2072 
2076  void executeSamplers(const ExecFlagType & exec_type);
2077 
2081  virtual void updateActiveObjects();
2082 
2089 
2091 
2095  bool hasJacobian() const;
2096 
2101  bool constJacobian() const;
2102 
2106  void addOutput(const std::string &, const std::string &, InputParameters &);
2107 
2108  inline TheWarehouse & theWarehouse() const { return _app.theWarehouse(); }
2109 
2113  void setSNESMFReuseBase(bool reuse, bool set_by_user)
2114  {
2115  _snesmf_reuse_base = reuse, _snesmf_reuse_base_set_by_user = set_by_user;
2116  }
2117 
2122 
2126  void skipExceptionCheck(bool skip_exception_check)
2127  {
2128  _skip_exception_check = skip_exception_check;
2129  }
2130 
2135 
2140 
2141 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
2142  PetscOptions & petscOptionsDatabase() { return _petsc_option_data_base; }
2143 #endif
2144 
2146  virtual void setUDotRequested(const bool u_dot_requested) { _u_dot_requested = u_dot_requested; }
2147 
2149  virtual void setUDotDotRequested(const bool u_dotdot_requested)
2150  {
2151  _u_dotdot_requested = u_dotdot_requested;
2152  }
2153 
2155  virtual void setUDotOldRequested(const bool u_dot_old_requested)
2156  {
2157  _u_dot_old_requested = u_dot_old_requested;
2158  }
2159 
2161  virtual void setUDotDotOldRequested(const bool u_dotdot_old_requested)
2162  {
2163  _u_dotdot_old_requested = u_dotdot_old_requested;
2164  }
2165 
2167  virtual bool uDotRequested() { return _u_dot_requested; }
2168 
2170  virtual bool uDotDotRequested() { return _u_dotdot_requested; }
2171 
2173  virtual bool uDotOldRequested()
2174  {
2176  mooseError("FEProblemBase: When requesting old time derivative of solution, current time "
2177  "derivative of solution should also be stored. Please set `u_dot_requested` to "
2178  "true using setUDotRequested.");
2179 
2180  return _u_dot_old_requested;
2181  }
2182 
2184  virtual bool uDotDotOldRequested()
2185  {
2187  mooseError("FEProblemBase: When requesting old second time derivative of solution, current "
2188  "second time derivation of solution should also be stored. Please set "
2189  "`u_dotdot_requested` to true using setUDotDotRequested.");
2190  return _u_dotdot_old_requested;
2191  }
2192 
2194  void haveADObjects(bool have_ad_objects) override;
2195 
2196  // Whether or not we should solve this system
2197  bool shouldSolve() const { return _solve; }
2198 
2202  const MortarData & mortarData() const { return _mortar_data; }
2204 
2209 
2213  virtual bool hasMortarCoupling() const { return _has_mortar; }
2214 
2216  void computingNonlinearResid(bool computing_nonlinear_residual) final;
2217 
2219  void setCurrentlyComputingResidual(bool currently_computing_residual) final;
2220 
2224  void numGridSteps(unsigned int num_grid_steps) { _num_grid_steps = num_grid_steps; }
2225 
2230  void uniformRefine();
2231 
2233  void automaticScaling(bool automatic_scaling) override;
2234 
2236 
2239  template <typename T>
2240  static void objectSetupHelper(const std::vector<T *> & objects, const ExecFlagType & exec_flag);
2241  template <typename T>
2242  static void objectExecuteHelper(const std::vector<T *> & objects);
2244 
2251  virtual void reinitElemFaceRef(const Elem * elem,
2252  unsigned int side,
2253  Real tolerance,
2254  const std::vector<Point> * const pts,
2255  const std::vector<Real> * const weights = nullptr,
2256  const THREAD_ID tid = 0) override;
2257 
2264  virtual void reinitNeighborFaceRef(const Elem * neighbor_elem,
2265  unsigned int neighbor_side,
2266  Real tolerance,
2267  const std::vector<Point> * const pts,
2268  const std::vector<Real> * const weights = nullptr,
2269  const THREAD_ID tid = 0) override;
2270 
2275 
2280  void fvBCsIntegrityCheck(bool fv_bcs_integrity_check);
2281 
2290  void getFVMatsAndDependencies(SubdomainID block_id,
2291  std::vector<std::shared_ptr<MaterialBase>> & face_materials,
2292  std::vector<std::shared_ptr<MaterialBase>> & neighbor_materials,
2293  std::set<MooseVariableFieldBase *> & variables,
2294  const THREAD_ID tid);
2295 
2302  void resizeMaterialData(Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid);
2303 
2304  bool haveDisplaced() const override final { return _displaced_problem.get(); }
2305 
2307  bool hasLinearConvergenceObjects() const;
2311  void setNonlinearConvergenceNames(const std::vector<ConvergenceName> & convergence_names);
2315  void setLinearConvergenceNames(const std::vector<ConvergenceName> & convergence_names);
2319  void setMultiAppFixedPointConvergenceName(const ConvergenceName & convergence_name);
2323  void setSteadyStateConvergenceName(const ConvergenceName & convergence_name);
2324 
2328  const std::vector<ConvergenceName> & getNonlinearConvergenceNames() const;
2332  const std::vector<ConvergenceName> & getLinearConvergenceNames() const;
2336  const ConvergenceName & getMultiAppFixedPointConvergenceName() const;
2340  const ConvergenceName & getSteadyStateConvergenceName() const;
2341 
2345  void computingScalingJacobian(bool computing_scaling_jacobian)
2346  {
2347  _computing_scaling_jacobian = computing_scaling_jacobian;
2348  }
2349 
2350  bool computingScalingJacobian() const override final { return _computing_scaling_jacobian; }
2351 
2355  void computingScalingResidual(bool computing_scaling_residual)
2356  {
2357  _computing_scaling_residual = computing_scaling_residual;
2358  }
2359 
2363  bool computingScalingResidual() const override final { return _computing_scaling_residual; }
2364 
2370 
2371  virtual std::size_t numNonlinearSystems() const override { return _num_nl_sys; }
2372 
2373  virtual std::size_t numLinearSystems() const override { return _num_linear_sys; }
2374 
2375  virtual std::size_t numSolverSystems() const override { return _num_nl_sys + _num_linear_sys; }
2376 
2378  bool isSolverSystemNonlinear(const unsigned int sys_num) { return sys_num < _num_nl_sys; }
2379 
2380  virtual unsigned int currentNlSysNum() const override;
2381 
2382  virtual unsigned int currentLinearSysNum() const override;
2383 
2387  virtual unsigned int nlSysNum(const NonlinearSystemName & nl_sys_name) const override;
2388 
2392  unsigned int linearSysNum(const LinearSystemName & linear_sys_name) const override;
2393 
2397  unsigned int solverSysNum(const SolverSystemName & solver_sys_name) const override;
2398 
2403  unsigned int systemNumForVariable(const VariableName & variable_name) const;
2404 
2409 
2414 
2419 
2420  /*
2421  * Set the status of loop order of execution printing
2422  * @param print_exec set of execution flags to print on
2423  */
2424  void setExecutionPrinting(const ExecFlagEnum & print_exec) { _print_execution_on = print_exec; }
2425 
2429  bool shouldPrintExecution(const THREAD_ID tid) const;
2434  void reinitMortarUserObjects(BoundaryID primary_boundary_id,
2435  BoundaryID secondary_boundary_id,
2436  bool displaced);
2437 
2438  virtual const std::vector<VectorTag> & currentResidualVectorTags() const override;
2439 
2445  {
2446  friend class CrankNicolson;
2447  friend class FEProblemBase;
2450  };
2451 
2455  void setCurrentResidualVectorTags(const std::set<TagID> & vector_tags);
2456 
2461 
2466 
2467  virtual void needFV() override { _have_fv = true; }
2468  virtual bool haveFV() const override { return _have_fv; }
2469 
2470  virtual bool hasNonlocalCoupling() const override { return _has_nonlocal_coupling; }
2471 
2476 
2477  virtual void setCurrentLowerDElem(const Elem * const lower_d_elem, const THREAD_ID tid) override;
2478  virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid) override;
2479 
2483  const std::vector<NonlinearSystemName> & getNonlinearSystemNames() const { return _nl_sys_names; }
2487  const std::vector<LinearSystemName> & getLinearSystemNames() const { return _linear_sys_names; }
2491  const std::vector<SolverSystemName> & getSolverSystemNames() const { return _solver_sys_names; }
2492 
2493  virtual const libMesh::CouplingMatrix & nonlocalCouplingMatrix(const unsigned i) const override;
2494 
2495  virtual bool checkNonlocalCouplingRequirement() const override;
2496 
2498 
2499 protected:
2503  virtual void meshChanged() {}
2504 
2506  void createTagVectors();
2507 
2509  void createTagSolutions();
2510 
2514  virtual void meshDisplaced();
2515 
2519  void computeSystems(const ExecFlagType & type);
2520 
2522 
2523 private:
2526 
2538  void setResidualObjectParamsAndLog(const std::string & ro_name,
2539  const std::string & name,
2540  InputParameters & params,
2541  const unsigned int nl_sys_num,
2542  const std::string & base_name,
2543  bool & reinit_displaced);
2544 
2549 
2550 protected:
2552 
2554  std::optional<std::vector<ConvergenceName>> _nonlinear_convergence_names;
2556  std::optional<std::vector<ConvergenceName>> _linear_convergence_names;
2558  std::optional<ConvergenceName> _multiapp_fixed_point_convergence_name;
2560  std::optional<ConvergenceName> _steady_state_convergence_name;
2561 
2562  std::set<TagID> _fe_vector_tags;
2563 
2564  std::set<TagID> _fe_matrix_tags;
2565 
2567  std::set<TagID> _linear_vector_tags;
2568 
2570  std::set<TagID> _linear_matrix_tags;
2571 
2573  const bool & _solve;
2574 
2578  int & _t_step;
2581 
2588 
2590  const std::vector<LinearSystemName> _linear_sys_names;
2591 
2593  const std::size_t _num_linear_sys;
2594 
2596  std::vector<std::shared_ptr<LinearSystem>> _linear_systems;
2597 
2599  std::map<LinearSystemName, unsigned int> _linear_sys_name_to_num;
2600 
2603 
2605  const bool _using_default_nl;
2606 
2608  const std::vector<NonlinearSystemName> _nl_sys_names;
2609 
2611  const std::size_t _num_nl_sys;
2612 
2614  std::vector<std::shared_ptr<NonlinearSystemBase>> _nl;
2615 
2617  std::map<NonlinearSystemName, unsigned int> _nl_sys_name_to_num;
2618 
2621 
2624 
2626  std::vector<std::shared_ptr<SolverSystem>> _solver_systems;
2627 
2629  std::map<SolverVariableName, unsigned int> _solver_var_to_sys_num;
2630 
2632  std::map<SolverSystemName, unsigned int> _solver_sys_name_to_num;
2633 
2635  std::vector<SolverSystemName> _solver_sys_names;
2636 
2638  std::shared_ptr<AuxiliarySystem> _aux;
2639 
2641  std::vector<std::unique_ptr<libMesh::CouplingMatrix>> _cm;
2642 
2644  std::map<std::string, unsigned int> _subspace_dim;
2645 
2648  std::vector<std::vector<std::unique_ptr<Assembly>>> _assembly;
2649 
2654 
2657 
2660 
2663 
2666 
2671  ScalarInitialConditionWarehouse _scalar_ics; // use base b/c of setup methods
2673 
2674  // material properties
2679 
2681  // Material Warehouses
2682  MaterialWarehouse _materials; // regular materials
2683  MaterialWarehouse _interface_materials; // interface materials
2684  MaterialWarehouse _discrete_materials; // Materials that the user must compute
2685  MaterialWarehouse _all_materials; // All materials for error checking and MaterialData storage
2687 
2689  // Indicator Warehouses
2693 
2694  // Marker Warehouse
2696 
2697  // Helper class to access Reporter object values
2699 
2700  // TODO: delete this after apps have been updated to not call getUserObjects
2702 
2705 
2708 
2711 
2714 
2717 
2720 
2722  std::map<std::string, std::unique_ptr<RandomData>> _random_data_objects;
2723 
2725  std::vector<std::unordered_map<SubdomainID, bool>> _block_mat_side_cache;
2726 
2728  std::vector<std::unordered_map<BoundaryID, bool>> _bnd_mat_side_cache;
2729 
2731  std::vector<std::unordered_map<BoundaryID, bool>> _interface_mat_side_cache;
2732 
2734  std::vector<MeshChangedInterface *> _notify_when_mesh_changes;
2735 
2737  std::vector<MeshDisplacedInterface *> _notify_when_mesh_displaces;
2738 
2740  bool duplicateVariableCheck(const std::string & var_name,
2741  const libMesh::FEType & type,
2742  bool is_aux,
2743  const std::set<SubdomainID> * const active_subdomains);
2744 
2746  const Moose::AuxGroup & group,
2747  TheWarehouse::Query & query);
2748 
2750  void checkDisplacementOrders();
2751 
2752  void checkUserObjects();
2753 
2760  const std::map<SubdomainID, std::vector<std::shared_ptr<MaterialBase>>> & materials_map);
2761 
2763  void checkCoordinateSystems();
2764 
2770  void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed = false);
2771 
2778  void addObjectParamsHelper(InputParameters & params,
2779  const std::string & object_name,
2780  const std::string & var_param_name = "variable");
2781 
2782 #ifdef LIBMESH_ENABLE_AMR
2784  unsigned int _cycles_completed;
2785 #endif
2786 
2788  std::shared_ptr<XFEMInterface> _xfem;
2789 
2790  // Displaced mesh /////
2792  std::shared_ptr<DisplacedProblem> _displaced_problem;
2795 
2802 
2805 
2808 
2811 
2814 
2817 
2820 
2823 
2826 
2829 
2832 
2835 
2839 
2840  std::vector<std::vector<const MooseVariableFEBase *>> _uo_jacobian_moose_vars;
2841 
2843  std::vector<unsigned char> _has_active_material_properties;
2844 
2845  std::vector<SolverParams> _solver_params;
2846 
2849  std::vector<SubdomainName> _kernel_coverage_blocks;
2850 
2854 
2858 
2861  std::vector<SubdomainName> _material_coverage_blocks;
2862 
2865 
2868 
2871 
2873  unsigned int _max_qps;
2874 
2877 
2880 
2883 
2886 
2889 
2892 
2895 
2897  std::string _exception_message;
2898 
2901 
2904 
2907 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
2909 #endif
2910 
2913 
2914  std::shared_ptr<LineSearch> _line_search;
2915 
2916  std::unique_ptr<libMesh::ConstElemRange> _evaluable_local_elem_range;
2917  std::unique_ptr<libMesh::ConstElemRange> _nl_evaluable_local_elem_range;
2918  std::unique_ptr<libMesh::ConstElemRange> _aux_evaluable_local_elem_range;
2919 
2920  std::unique_ptr<libMesh::ConstElemRange> _current_algebraic_elem_range;
2921  std::unique_ptr<libMesh::ConstNodeRange> _current_algebraic_node_range;
2922  std::unique_ptr<ConstBndNodeRange> _current_algebraic_bnd_node_range;
2923 
2927 
2928  // loop state during projection of initial conditions
2929  unsigned short _current_ic_state;
2930 
2934 
2935 private:
2940  void handleException(const std::string & calling_method);
2941 
2946  std::vector<MortarUserObject *>
2947  getMortarUserObjects(BoundaryID primary_boundary_id,
2948  BoundaryID secondary_boundary_id,
2949  bool displaced,
2950  const std::vector<MortarUserObject *> & mortar_uo_superset);
2951 
2956  std::vector<MortarUserObject *> getMortarUserObjects(BoundaryID primary_boundary_id,
2957  BoundaryID secondary_boundary_id,
2958  bool displaced);
2959 
2969  virtual std::pair<bool, unsigned int>
2970  determineSolverSystem(const std::string & var_name,
2971  bool error_if_not_found = false) const override;
2972 
2979  void checkICRestartError(const std::string & ic_name,
2980  const std::string & name,
2981  const VariableName & var_name);
2982 
2983  /*
2984  * Test if stateful property redistribution is expected to be
2985  * necessary, and set it up if so.
2986  */
2987  void addAnyRedistributers();
2988 
2989  void updateMaxQps();
2990 
2991  void joinAndFinalize(TheWarehouse::Query query, bool isgen = false);
2992 
2996  virtual void resetState();
2997 
2998  // Parameters handling Jacobian sparsity pattern behavior
3010 
3011  const bool _force_restart;
3018 
3021 
3024 
3027 
3030 
3033 
3036 
3037  friend class AuxiliarySystem;
3038  friend class NonlinearSystemBase;
3039  friend class MooseEigenSystem;
3040  friend class Resurrector;
3041  friend class Restartable;
3042  friend class DisplacedProblem;
3043 
3046 
3048  unsigned int _num_grid_steps;
3049 
3053 
3056 
3059 
3062 
3065 
3068 
3072  std::vector<VectorTag> _current_residual_vector_tags;
3073 
3075  bool _have_fv = false;
3076 
3080 
3082  std::vector<libMesh::CouplingMatrix> _nonlocal_cm;
3083 
3086 
3087  friend void Moose::PetscSupport::setSinglePetscOption(const std::string & name,
3088  const std::string & value,
3089  FEProblemBase * const problem);
3090 };
3091 
3093 
3094 template <typename T>
3095 void
3097 {
3098  _app.getOutputWarehouse().allowOutput<T>(state);
3099 }
3100 
3101 template <typename T>
3102 void
3103 FEProblemBase::objectSetupHelper(const std::vector<T *> & objects, const ExecFlagType & exec_flag)
3104 {
3105  if (exec_flag == EXEC_INITIAL)
3106  {
3107  for (T * obj_ptr : objects)
3108  obj_ptr->initialSetup();
3109  }
3110 
3111  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
3112  {
3113  for (const auto obj_ptr : objects)
3114  obj_ptr->timestepSetup();
3115  }
3116  else if (exec_flag == EXEC_SUBDOMAIN)
3117  {
3118  for (const auto obj_ptr : objects)
3119  obj_ptr->subdomainSetup();
3120  }
3121 
3122  else if (exec_flag == EXEC_NONLINEAR)
3123  {
3124  for (const auto obj_ptr : objects)
3125  obj_ptr->jacobianSetup();
3126  }
3127 
3128  else if (exec_flag == EXEC_LINEAR)
3129  {
3130  for (const auto obj_ptr : objects)
3131  obj_ptr->residualSetup();
3132  }
3133 }
3134 
3135 template <typename T>
3136 void
3137 FEProblemBase::objectExecuteHelper(const std::vector<T *> & objects)
3138 {
3139  for (T * obj_ptr : objects)
3140  obj_ptr->execute();
3141 }
3142 
3143 template <typename T>
3144 std::vector<std::shared_ptr<T>>
3145 FEProblemBase::addObject(const std::string & type,
3146  const std::string & name,
3148  const bool threaded,
3149  const std::string & var_param_name)
3150 {
3151  parallel_object_only();
3152 
3153  logAdd(MooseUtils::prettyCppType<T>(), name, type, parameters);
3154  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
3155  addObjectParamsHelper(parameters, name, var_param_name);
3156 
3157  const auto n_threads = threaded ? libMesh::n_threads() : 1;
3158  std::vector<std::shared_ptr<T>> objects(n_threads);
3159  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
3160  {
3161  std::shared_ptr<T> obj = _factory.create<T>(type, name, parameters, tid);
3162  theWarehouse().add(obj);
3163  objects[tid] = std::move(obj);
3164  }
3165 
3166  return objects;
3167 }
3168 
3169 inline NonlinearSystemBase &
3170 FEProblemBase::getNonlinearSystemBase(const unsigned int sys_num)
3171 {
3172  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3173  return *_nl[sys_num];
3174 }
3175 
3176 inline const NonlinearSystemBase &
3177 FEProblemBase::getNonlinearSystemBase(const unsigned int sys_num) const
3178 {
3179  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3180  return *_nl[sys_num];
3181 }
3182 
3183 inline SolverSystem &
3184 FEProblemBase::getSolverSystem(const unsigned int sys_num)
3185 {
3186  mooseAssert(sys_num < _solver_systems.size(),
3187  "System number greater than the number of solver systems");
3188  return *_solver_systems[sys_num];
3189 }
3190 
3191 inline const SolverSystem &
3192 FEProblemBase::getSolverSystem(const unsigned int sys_num) const
3193 {
3194  mooseAssert(sys_num < _solver_systems.size(),
3195  "System number greater than the number of solver systems");
3196  return *_solver_systems[sys_num];
3197 }
3198 
3199 inline NonlinearSystemBase &
3201 {
3202  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3203  return *_current_nl_sys;
3204 }
3205 
3206 inline const NonlinearSystemBase &
3208 {
3209  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3210  return *_current_nl_sys;
3211 }
3212 
3213 inline LinearSystem &
3214 FEProblemBase::getLinearSystem(const unsigned int sys_num)
3215 {
3216  mooseAssert(sys_num < _linear_systems.size(),
3217  "System number greater than the number of linear systems");
3218  return *_linear_systems[sys_num];
3219 }
3220 
3221 inline const LinearSystem &
3222 FEProblemBase::getLinearSystem(const unsigned int sys_num) const
3223 {
3224  mooseAssert(sys_num < _linear_systems.size(),
3225  "System number greater than the number of linear systems");
3226  return *_linear_systems[sys_num];
3227 }
3228 
3229 inline LinearSystem &
3231 {
3232  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3233  return *_current_linear_sys;
3234 }
3235 
3236 inline const LinearSystem &
3238 {
3239  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3240  return *_current_linear_sys;
3241 }
3242 
3243 inline Assembly &
3244 FEProblemBase::assembly(const THREAD_ID tid, const unsigned int sys_num)
3245 {
3246  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3247  mooseAssert(sys_num < _assembly[tid].size(),
3248  "System number larger than the assembly container size");
3249  return *_assembly[tid][sys_num];
3250 }
3251 
3252 inline const Assembly &
3253 FEProblemBase::assembly(const THREAD_ID tid, const unsigned int sys_num) const
3254 {
3255  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3256  mooseAssert(sys_num < _assembly[tid].size(),
3257  "System number larger than the assembly container size");
3258  return *_assembly[tid][sys_num];
3259 }
3260 
3261 inline const libMesh::CouplingMatrix *
3262 FEProblemBase::couplingMatrix(const unsigned int i) const
3263 {
3264  return _cm[i].get();
3265 }
3266 
3267 inline void
3268 FEProblemBase::fvBCsIntegrityCheck(const bool fv_bcs_integrity_check)
3269 {
3271  // the user has requested that we don't check integrity so we will honor that
3272  return;
3273 
3274  _fv_bcs_integrity_check = fv_bcs_integrity_check;
3275 }
3276 
3277 inline const std::vector<VectorTag> &
3279 {
3281 }
3282 
3283 inline void
3284 FEProblemBase::setCurrentResidualVectorTags(const std::set<TagID> & vector_tags)
3285 {
3287 }
3288 
3289 inline void
3291 {
3293 }
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:721
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.
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.
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...
void mooseDeprecated(Args &&... args) const
std::optional< ConvergenceName > _multiapp_fixed_point_convergence_name
MultiApp fixed point convergence name.
Keeps track of stuff related to assembling.
Definition: Assembly.h:101
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.
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 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 joinAndFinalize(TheWarehouse::Query query, bool isgen=false)
std::vector< MooseArray< ADRealVectorValue > > _ad_grad_zero
Warehouse for storing initial conditions.
std::vector< SolverParams > _solver_params
const std::vector< SolverSystemName > & getSolverSystemNames() const
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.
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.
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:39
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:691
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.
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
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...
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.
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
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.
MaterialData & getMaterialData(Moose::MaterialDataType type, const THREAD_ID tid=0) const
All Distributions should inherit from this class.
Definition: Distribution.h:18
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
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;)
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.
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 const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
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
void projectInitialConditionOnCustomRange(libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range)
Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boun...
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:703
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
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
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
bool needSubdomainMaterialOnSide(SubdomainID subdomain_id, const THREAD_ID tid)
virtual Convergence & getConvergence(const std::string &name, const THREAD_ID tid=0) const
Gets a Convergence object.
TheWarehouse & theWarehouse() const
void createTagVectors()
Create extra tagged vectors and matrices.
virtual void createQRules(libMesh::QuadratureType type, libMesh::Order order, libMesh::Order volume_order=libMesh::INVALID_ORDER, libMesh::Order face_order=libMesh::INVALID_ORDER, SubdomainID block=Moose::ANY_BLOCK_ID, bool allow_negative_qweights=true)
void reinitMaterialsNeighbor(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on the neighboring element face
void setMultiAppFixedPointConvergenceName(const ConvergenceName &convergence_name)
Sets the MultiApp fixed point convergence object name if there is one.
void checkUserObjects()
Moose::CouplingType _coupling
Type of variable coupling.
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:28
virtual bool shouldUpdateSolution()
Check to see whether the problem should update the solution.
const ConvergenceName & getMultiAppFixedPointConvergenceName() const
Gets the MultiApp fixed point convergence object name.
Real getTimeFromStateArg(const Moose::StateArg &state) const
Returns the time associated with the requested state.
virtual std::string solverTypeString(unsigned int solver_sys_num=0)
Return solver type as a human readable string.
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:35
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 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:714
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.
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:88
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:51
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.
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
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:84
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:29
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.
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
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...
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:31
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:203
const FVInitialConditionWarehouse & getFVInitialConditionWarehouse() const
Return FVInitialCondition storage.
virtual void updateMortarMesh()
void addDefaultMultiAppFixedPointConvergence(const InputParameters &params)
Adds the default fixed point Convergence associated with the problem.
std::set< TagID > _fe_matrix_tags
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:33
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.
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.
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.
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:730
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
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
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
const InputParameters & parameters() const
Get the parameters of the object.
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:33
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:130
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
const std::size_t _num_linear_sys
The number of linear systems.
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.
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:46
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
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.
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:361
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.
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)
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.
virtual unsigned int nlSysNum(const NonlinearSystemName &nl_sys_name) const override
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2407
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
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:28
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