https://mooseframework.inl.gov
FEProblemBase.h
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #pragma once
11 
12 #ifdef MOOSE_KOKKOS_ENABLED
13 #include "KokkosAssembly.h"
14 #include "KokkosFESystem.h"
15 #endif
16 
17 // MOOSE includes
18 #include "SubProblem.h"
19 #include "GeometricSearchData.h"
20 #include "MeshDivision.h"
21 #include "ReporterData.h"
22 #include "Adaptivity.h"
23 #include "InitialConditionWarehouse.h"
24 #include "FVInitialConditionWarehouse.h"
25 #include "ScalarInitialConditionWarehouse.h"
26 #include "Restartable.h"
27 #include "SolverParams.h"
28 #include "PetscSupport.h"
29 #include "MooseApp.h"
30 #include "ExecuteMooseObjectWarehouse.h"
31 #include "MaterialWarehouse.h"
32 #include "MortarInterfaceWarehouse.h"
33 #include "Mortar3DSubpatchPlane.h"
34 #include "MooseVariableFE.h"
35 #include "MultiAppTransfer.h"
36 #include "Postprocessor.h"
37 #include "HashMap.h"
38 #include "VectorPostprocessor.h"
39 #include "PerfGraphInterface.h"
40 #include "Attributes.h"
41 #include "MooseObjectWarehouse.h"
42 #include "MaterialPropertyRegistry.h"
43 #include "RestartableEquationSystems.h"
44 #include "SolutionInvalidity.h"
45 #include "PetscSupport.h"
46 
47 #include "libmesh/enum_quadrature_type.h"
48 #include "libmesh/equation_systems.h"
49 
50 #include <unordered_map>
51 #include <memory>
52 
53 // Forward declarations
54 class AuxiliarySystem;
55 class DisplacedProblem;
56 class MooseMesh;
57 class NonlinearSystemBase;
58 class LinearSystem;
59 class SolverSystem;
60 class NonlinearSystem;
61 class RandomInterface;
62 class RandomData;
63 class MeshChangedInterface;
64 class MeshDisplacedInterface;
65 class MultiMooseEnum;
66 class MaterialPropertyStorage;
67 class MaterialData;
68 class MooseEnum;
69 class MortarInterfaceWarehouse;
70 class Assembly;
71 class JacobianBlock;
72 class Control;
73 class MultiApp;
74 class TransientMultiApp;
75 class ScalarInitialCondition;
76 class Indicator;
77 class InternalSideIndicatorBase;
78 class Marker;
79 class Material;
80 class Transfer;
81 class XFEMInterface;
82 class SideUserObject;
83 class NodalUserObject;
84 class ElementUserObject;
85 class InternalSideUserObject;
86 class InterfaceUserObject;
87 class GeneralUserObject;
88 class Positions;
89 class Function;
90 class Distribution;
91 class Sampler;
92 class KernelBase;
93 class IntegratedBCBase;
94 class LineSearch;
95 class UserObject;
96 class UserObjectBase;
97 class FVInterpolationMethod;
98 class FVFaceInterpolationMethod;
99 class FVAdvectedInterpolationMethod;
100 class AutomaticMortarGeneration;
101 class VectorPostprocessor;
102 class Convergence;
103 class MooseAppCoordTransform;
104 class MortarUserObject;
105 class SolutionInvalidity;
106 
107 namespace Moose
108 {
109 class FunctionBase;
110 }
111 
112 #ifdef MOOSE_KOKKOS_ENABLED
113 namespace Moose::Kokkos
114 {
115 class MaterialPropertyStorage;
116 class Function;
117 class UserObject;
118 }
119 #endif
120 
121 // libMesh forward declarations
122 namespace libMesh
123 {
124 class CouplingMatrix;
125 class NonlinearImplicitSystem;
126 class LinearImplicitSystem;
127 } // namespace libMesh
128 
129 enum class MooseLinearConvergenceReason
130 {
131  ITERATING = 0,
132  // CONVERGED_RTOL_NORMAL = 1,
133  // CONVERGED_ATOL_NORMAL = 9,
134  CONVERGED_RTOL = 2,
135  CONVERGED_ATOL = 3,
136  CONVERGED_ITS = 4,
137  // CONVERGED_CG_NEG_CURVE = 5,
138  // CONVERGED_CG_CONSTRAINED = 6,
139  // CONVERGED_STEP_LENGTH = 7,
140  // CONVERGED_HAPPY_BREAKDOWN = 8,
141  DIVERGED_NULL = -2,
142  // DIVERGED_ITS = -3,
143  // DIVERGED_DTOL = -4,
144  // DIVERGED_BREAKDOWN = -5,
145  // DIVERGED_BREAKDOWN_BICG = -6,
146  // DIVERGED_NONSYMMETRIC = -7,
147  // DIVERGED_INDEFINITE_PC = -8,
148  DIVERGED_NANORINF = -9,
149  // DIVERGED_INDEFINITE_MAT = -10
150  DIVERGED_PCSETUP_FAILED = -11
151 };
152 
157 class FEProblemBase : public SubProblem, public Restartable
158 {
159 public:
160  static InputParameters validParams();
161 
162  FEProblemBase(const InputParameters & parameters);
163  virtual ~FEProblemBase();
164 
168  [[nodiscard]] bool initialized() const { return _initialized; }
169 
170  enum class CoverageCheckMode
171  {
172  FALSE,
173  TRUE,
174  OFF,
175  ON,
176  SKIP_LIST,
177  ONLY_LIST,
178  };
179 
180  virtual libMesh::EquationSystems & es() override { return _req.set().es(); }
181  virtual MooseMesh & mesh() override { return _mesh; }
182  virtual const MooseMesh & mesh() const override { return _mesh; }
183  const MooseMesh & mesh(bool use_displaced) const override;
184  MooseMesh & mesh(bool use_displaced);
185 
186  void setCoordSystem(const std::vector<SubdomainName> & blocks, const MultiMooseEnum & coord_sys);
187  void setAxisymmetricCoordAxis(const MooseEnum & rz_coord_axis);
188 
194  void setCoupling(Moose::CouplingType type);
195 
196  Moose::CouplingType coupling() const { return _coupling; }
197 
203  void setCouplingMatrix(std::unique_ptr<libMesh::CouplingMatrix> cm,
204  const unsigned int nl_sys_num);
205 
206  // DEPRECATED METHOD
207  void setCouplingMatrix(libMesh::CouplingMatrix * cm, const unsigned int nl_sys_num);
208 
209  const libMesh::CouplingMatrix * couplingMatrix(const unsigned int nl_sys_num) const override;
210 
212  void setNonlocalCouplingMatrix();
213 
214  bool
215  areCoupled(const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const;
216 
220  bool hasUOAuxStateCheck() const { return _uo_aux_state_check; }
221 
228  bool checkingUOAuxState() const { return _checking_uo_aux_state; }
229 
230 #ifndef NDEBUG
231  virtual bool checkResidualForNans() const override { return _check_residual_for_nans; }
232 
234  void setCheckResidualForNans(bool check_residual_for_nans)
235  {
236  _check_residual_for_nans = check_residual_for_nans;
237  }
238 #endif
239 
245  void trustUserCouplingMatrix();
246 
247  std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>> &
248  couplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num);
249  std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *>> &
250  nonlocalCouplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num);
251 
252  virtual bool hasVariable(const std::string & var_name) const override;
253  // NOTE: hasAuxiliaryVariable defined in parent class
254  bool hasSolverVariable(const std::string & var_name) const;
255  using SubProblem::getVariable;
256  virtual const MooseVariableFieldBase &
257  getVariable(const THREAD_ID tid,
258  const std::string & var_name,
259  Moose::VarKindType expected_var_type = Moose::VarKindType::VAR_ANY,
260  Moose::VarFieldType expected_var_field_type =
261  Moose::VarFieldType::VAR_FIELD_ANY) const override;
262  MooseVariableFieldBase & getActualFieldVariable(const THREAD_ID tid,
263  const std::string & var_name) override;
264  virtual MooseVariable & getStandardVariable(const THREAD_ID tid,
265  const std::string & var_name) override;
266  virtual VectorMooseVariable & getVectorVariable(const THREAD_ID tid,
267  const std::string & var_name) override;
268  virtual ArrayMooseVariable & getArrayVariable(const THREAD_ID tid,
269  const std::string & var_name) override;
270 
271  virtual bool hasScalarVariable(const std::string & var_name) const override;
272  virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid,
273  const std::string & var_name) override;
274  virtual libMesh::System & getSystem(const std::string & var_name) override;
275 
277  const RestartableEquationSystems & getRestartableEquationSystems() const;
278 
285  virtual void setActiveElementalMooseVariables(const std::set<MooseVariableFEBase *> & moose_vars,
286  const THREAD_ID tid) override;
287 
295  virtual void clearActiveElementalMooseVariables(const THREAD_ID tid) override;
296 
297  virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid) override;
298 
299  virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid) override;
300 
301  virtual void setActiveFEVariableCoupleableVectorTags(std::set<TagID> & vtags,
302  const THREAD_ID tid) override;
303 
304  virtual void setActiveFEVariableCoupleableMatrixTags(std::set<TagID> & mtags,
305  const THREAD_ID tid) override;
306 
307  virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid) override;
308 
309  virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid) override;
310 
311  virtual void setActiveScalarVariableCoupleableVectorTags(std::set<TagID> & vtags,
312  const THREAD_ID tid) override;
313 
314  virtual void setActiveScalarVariableCoupleableMatrixTags(std::set<TagID> & mtags,
315  const THREAD_ID tid) override;
316 
317  virtual void createQRules(libMesh::QuadratureType type,
318  libMesh::Order order,
319  libMesh::Order volume_order = libMesh::INVALID_ORDER,
320  libMesh::Order face_order = libMesh::INVALID_ORDER,
321  SubdomainID block = Moose::ANY_BLOCK_ID,
322  bool allow_negative_qweights = true);
323 
331  void bumpVolumeQRuleOrder(libMesh::Order order, SubdomainID block);
332 
333  void bumpAllQRuleOrder(libMesh::Order order, SubdomainID block);
334 
338  unsigned int getMaxQps() const;
339 
343  libMesh::Order getMaxScalarOrder() const;
344 
348  void checkNonlocalCoupling();
349  void checkUserObjectJacobianRequirement(THREAD_ID tid);
350  void setVariableAllDoFMap(const std::vector<const MooseVariableFEBase *> & moose_vars);
351 
352  const std::vector<const MooseVariableFEBase *> &
353  getUserObjectJacobianVariables(const THREAD_ID tid) const
354  {
355  return _uo_jacobian_moose_vars[tid];
356  }
357 
358  virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override;
359  virtual const Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) const override;
360 
361 #ifdef MOOSE_KOKKOS_ENABLED
362  Moose::Kokkos::Assembly & kokkosAssembly() { return _kokkos_assembly; }
363  const Moose::Kokkos::Assembly & kokkosAssembly() const { return _kokkos_assembly; }
364 #endif
365 
369  virtual std::vector<VariableName> getVariableNames();
370 
371  void initialSetup() override;
372  void checkDuplicatePostprocessorVariableNames();
373  void timestepSetup() override;
374  void customSetup(const ExecFlagType & exec_type) override;
375  void residualSetup() override;
376  void jacobianSetup() override;
377 
378  virtual void prepare(const Elem * elem, const THREAD_ID tid) override;
379  virtual void prepareFace(const Elem * elem, const THREAD_ID tid) override;
380  virtual void prepare(const Elem * elem,
381  unsigned int ivar,
382  unsigned int jvar,
383  const std::vector<dof_id_type> & dof_indices,
384  const THREAD_ID tid) override;
385 
386  virtual void setCurrentSubdomainID(const Elem * elem, const THREAD_ID tid) override;
387  virtual void
388  setNeighborSubdomainID(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
389  virtual void setNeighborSubdomainID(const Elem * elem, const THREAD_ID tid);
390  virtual void prepareAssembly(const THREAD_ID tid) override;
394  virtual void prepareAssemblyNeighbor(const THREAD_ID tid);
395 
396  virtual void addGhostedElem(dof_id_type elem_id) override;
397  virtual void addGhostedBoundary(BoundaryID boundary_id) override;
398  virtual void ghostGhostedBoundaries() override;
399 
400  virtual void sizeZeroes(unsigned int size, const THREAD_ID tid);
401  virtual bool reinitDirac(const Elem * elem, const THREAD_ID tid) override;
402 
403  virtual void reinitElem(const Elem * elem, const THREAD_ID tid) override;
404  virtual void reinitElemPhys(const Elem * elem,
405  const std::vector<Point> & phys_points_in_elem,
406  const THREAD_ID tid) override;
407  void reinitElemFace(const Elem * elem, unsigned int side, BoundaryID, const THREAD_ID tid);
408  virtual void reinitElemFace(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
409  virtual void reinitLowerDElem(const Elem * lower_d_elem,
410  const THREAD_ID tid,
411  const std::vector<Point> * const pts = nullptr,
412  const std::vector<Real> * const weights = nullptr) override;
413  virtual void reinitNode(const Node * node, const THREAD_ID tid) override;
414  virtual void reinitNodeFace(const Node * node, BoundaryID bnd_id, const THREAD_ID tid) override;
415  virtual void reinitNodes(const std::vector<dof_id_type> & nodes, const THREAD_ID tid) override;
416  virtual void reinitNodesNeighbor(const std::vector<dof_id_type> & nodes,
417  const THREAD_ID tid) override;
418  virtual void reinitNeighbor(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
419  virtual void reinitNeighborPhys(const Elem * neighbor,
420  unsigned int neighbor_side,
421  const std::vector<Point> & physical_points,
422  const THREAD_ID tid) override;
423  virtual void reinitNeighborPhys(const Elem * neighbor,
424  const std::vector<Point> & physical_points,
425  const THREAD_ID tid) override;
426  virtual void
427  reinitElemNeighborAndLowerD(const Elem * elem, unsigned int side, const THREAD_ID tid) override;
428  virtual void reinitScalars(const THREAD_ID tid,
429  bool reinit_for_derivative_reordering = false) override;
430  virtual void reinitOffDiagScalars(const THREAD_ID tid) override;
431 
433  virtual void getDiracElements(std::set<const Elem *> & elems) override;
434  virtual void clearDiracInfo() override;
435 
436  virtual void subdomainSetup(SubdomainID subdomain, const THREAD_ID tid);
437  virtual void neighborSubdomainSetup(SubdomainID subdomain, const THREAD_ID tid);
438 
439  virtual void newAssemblyArray(std::vector<std::shared_ptr<SolverSystem>> & solver_systems);
440  virtual void initNullSpaceVectors(const InputParameters & parameters,
441  std::vector<std::shared_ptr<NonlinearSystemBase>> & nl);
442 
443  virtual void init() override;
444  virtual void solve(const unsigned int nl_sys_num);
445 
446 #ifdef MOOSE_KOKKOS_ENABLED
447 
450  void initKokkos();
451 #endif
452 
458  virtual void solveLinearSystem(const unsigned int linear_sys_num,
459  const Moose::PetscSupport::PetscOptions * po = nullptr);
460 
462 
478  const libMesh::ConstElemRange & getEvaluableElementRange();
479  const libMesh::ConstElemRange & getNonlinearEvaluableElementRange();
481 
483 
494  const libMesh::ConstElemRange & getCurrentAlgebraicElementRange();
495  const libMesh::ConstNodeRange & getCurrentAlgebraicNodeRange();
496  const ConstBndNodeRange & getCurrentAlgebraicBndNodeRange();
498 
500 
517  void setCurrentAlgebraicElementRange(libMesh::ConstElemRange * range);
518  void setCurrentAlgebraicNodeRange(libMesh::ConstNodeRange * range);
519  void setCurrentAlgebraicBndNodeRange(ConstBndNodeRange * range);
521 
530  virtual void setException(const std::string & message);
531 
535  virtual bool hasException() { return _has_exception; }
536 
553  virtual void checkExceptionAndStopSolve(bool print_message = true);
554 
555  virtual bool solverSystemConverged(const unsigned int solver_sys_num) override;
556  virtual unsigned int nNonlinearIterations(const unsigned int nl_sys_num) const override;
557  virtual unsigned int nLinearIterations(const unsigned int nl_sys_num) const override;
558  virtual Real finalNonlinearResidual(const unsigned int nl_sys_num) const override;
559  virtual bool computingPreSMOResidual(const unsigned int nl_sys_num) const override;
560 
564  virtual std::string solverTypeString(unsigned int solver_sys_num = 0);
565 
569  virtual bool startedInitialSetup() { return _started_initial_setup; }
570 
571  virtual void onTimestepBegin() override;
572  virtual void onTimestepEnd() override;
573 
574  virtual Real & time() const { return _time; }
575  virtual Real & timeOld() const { return _time_old; }
576  virtual int & timeStep() const { return _t_step; }
577  virtual Real & dt() const { return _dt; }
578  virtual Real & dtOld() const { return _dt_old; }
582  Real getTimeFromStateArg(const Moose::StateArg & state) const;
583 
584  virtual void transient(bool trans) { _transient = trans; }
585  virtual bool isTransient() const override { return _transient; }
586 
587  virtual void addTimeIntegrator(const std::string & type,
588  const std::string & name,
589  InputParameters & parameters);
590  virtual void
591  addPredictor(const std::string & type, const std::string & name, InputParameters & parameters);
592 
593  virtual void copySolutionsBackwards();
594 
598  void skipNextForwardSolutionCopyToOld();
599 
604  virtual void advanceState();
605 
606  virtual void restoreSolutions();
607 
611  virtual void saveOldSolutions();
612 
616  virtual void restoreOldSolutions();
617 
623  void needSolutionState(unsigned int oldest_needed, Moose::SolutionIterationType iteration_type);
624 
630  bool hasSolutionState(unsigned int state, Moose::SolutionIterationType iteration_type) const;
631 
638  virtual void outputStep(ExecFlagType type);
639 
643  virtual void postExecute();
644 
646 
652  void allowOutput(bool state);
653  template <typename T>
654  void allowOutput(bool state);
656 
665  void forceOutput();
666 
671  virtual void initPetscOutputAndSomeSolverSettings();
672 
676  Moose::PetscSupport::PetscOptions & getPetscOptions() { return _petsc_options; }
677 
681  void logAdd(const std::string & system,
682  const std::string & name,
683  const std::string & type,
684  const InputParameters & params) const;
685 
686  // Function /////
687  virtual void
688  addFunction(const std::string & type, const std::string & name, InputParameters & parameters);
689  virtual bool hasFunction(const std::string & name, const THREAD_ID tid = 0);
690  virtual Function & getFunction(const std::string & name, const THREAD_ID tid = 0);
691 
692 #ifdef MOOSE_KOKKOS_ENABLED
693 
699  virtual void addKokkosFunction(const std::string & type,
700  const std::string & name,
701  InputParameters & parameters);
707  virtual bool hasKokkosFunction(const std::string & name) const;
713  virtual Moose::Kokkos::Function getKokkosFunction(const std::string & name);
720  template <typename T>
721  T & getKokkosFunction(const std::string & name);
722 #endif
723 
725  virtual void
726  addMeshDivision(const std::string & type, const std::string & name, InputParameters & params);
728  MeshDivision & getMeshDivision(const std::string & name, const THREAD_ID tid = 0) const;
729 
731  virtual void
732  addConvergence(const std::string & type, const std::string & name, InputParameters & parameters);
734  virtual Convergence & getConvergence(const std::string & name, const THREAD_ID tid = 0) const;
736  virtual const std::vector<std::shared_ptr<Convergence>> &
737  getConvergenceObjects(const THREAD_ID tid = 0) const;
739  virtual bool hasConvergence(const std::string & name, const THREAD_ID tid = 0) const;
741  bool needToAddDefaultNonlinearConvergence() const
742  {
743  return _need_to_add_default_nonlinear_convergence;
744  }
746  bool needToAddDefaultMultiAppFixedPointConvergence() const
747  {
748  return _need_to_add_default_multiapp_fixed_point_convergence;
749  }
751  bool needToAddDefaultSteadyStateConvergence() const
752  {
753  return _need_to_add_default_steady_state_convergence;
754  }
756  void setNeedToAddDefaultNonlinearConvergence()
757  {
758  _need_to_add_default_nonlinear_convergence = true;
759  }
761  void setNeedToAddDefaultMultiAppFixedPointConvergence()
762  {
763  _need_to_add_default_multiapp_fixed_point_convergence = true;
764  }
766  void setNeedToAddDefaultSteadyStateConvergence()
767  {
768  _need_to_add_default_steady_state_convergence = true;
769  }
771  bool hasSetMultiAppFixedPointConvergenceName() const
772  {
773  return _multiapp_fixed_point_convergence_name.has_value();
774  }
776  bool hasSetSteadyStateConvergenceName() const
777  {
778  return _steady_state_convergence_name.has_value();
779  }
787  virtual void addDefaultNonlinearConvergence(const InputParameters & params);
795  virtual bool onlyAllowDefaultNonlinearConvergence() const { return false; }
803  void addDefaultMultiAppFixedPointConvergence(const InputParameters & params);
811  void addDefaultSteadyStateConvergence(const InputParameters & params);
812 
816  virtual void addLineSearch(const InputParameters & /*parameters*/)
817  {
818  mooseError("Line search not implemented for this problem type yet.");
819  }
820 
824  virtual void lineSearch();
825 
829  LineSearch * getLineSearch() override { return _line_search.get(); }
830 
834  virtual void
835  addDistribution(const std::string & type, const std::string & name, InputParameters & parameters);
836  virtual bool hasDistribution(const std::string & name) const;
837  virtual Distribution & getDistribution(const std::string & name);
838 
842  virtual void
843  addSampler(const std::string & type, const std::string & name, InputParameters & parameters);
844  virtual Sampler & getSampler(const std::string & name, const THREAD_ID tid = 0);
845 
846  // NL /////
847  NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num);
848  const NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num) const;
849  void setCurrentNonlinearSystem(const unsigned int nl_sys_num);
850  NonlinearSystemBase & currentNonlinearSystem();
851  const NonlinearSystemBase & currentNonlinearSystem() const;
852 
853  virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const override;
854  virtual SystemBase & systemBaseNonlinear(const unsigned int sys_num) override;
855 
856  virtual const SystemBase & systemBaseSolver(const unsigned int sys_num) const override;
857  virtual SystemBase & systemBaseSolver(const unsigned int sys_num) override;
858 
859  virtual const SystemBase & systemBaseAuxiliary() const override;
860  virtual SystemBase & systemBaseAuxiliary() override;
861 
862  virtual NonlinearSystem & getNonlinearSystem(const unsigned int sys_num);
863 
864 #ifdef MOOSE_KOKKOS_ENABLED
865 
869  Moose::Kokkos::Array<Moose::Kokkos::System> & getKokkosSystems() { return _kokkos_systems; }
871  const Moose::Kokkos::Array<Moose::Kokkos::System> & getKokkosSystems() const
872  {
873  return _kokkos_systems;
874  }
876 
881  Moose::Kokkos::Array<Moose::Kokkos::FESystem> & getKokkosFESystems()
883  {
884  return _kokkos_fe_systems;
885  }
886  const Moose::Kokkos::Array<Moose::Kokkos::FESystem> & getKokkosFESystems() const
887  {
888  return _kokkos_fe_systems;
889  }
891 
897  Moose::Kokkos::System & getKokkosSystem(const unsigned int sys_num);
899  const Moose::Kokkos::System & getKokkosSystem(const unsigned int sys_num) const;
901 
907  Moose::Kokkos::FESystem & getKokkosFESystem(const unsigned int sys_num);
909  const Moose::Kokkos::FESystem & getKokkosFESystem(const unsigned int sys_num) const;
911 #endif
912 
917  virtual const SystemBase & getSystemBase(const unsigned int sys_num) const;
918 
923  virtual SystemBase & getSystemBase(const unsigned int sys_num);
924 
929  SystemBase & getSystemBase(const std::string & sys_name);
930 
935  LinearSystem & getLinearSystem(unsigned int sys_num);
936 
941  const LinearSystem & getLinearSystem(unsigned int sys_num) const;
942 
947  SolverSystem & getSolverSystem(unsigned int sys_num);
948 
953  const SolverSystem & getSolverSystem(unsigned int sys_num) const;
954 
959  void setCurrentLinearSystem(unsigned int sys_num);
960 
962  LinearSystem & currentLinearSystem();
964  const LinearSystem & currentLinearSystem() const;
965 
970  virtual const SystemBase & systemBaseLinear(unsigned int sys_num) const override;
971 
976  virtual SystemBase & systemBaseLinear(unsigned int sys_num) override;
977 
984  virtual void
985  addVariable(const std::string & var_type, const std::string & var_name, InputParameters & params);
986 
987  virtual void addKernel(const std::string & kernel_name,
988  const std::string & name,
989  InputParameters & parameters);
990  virtual void addHDGKernel(const std::string & kernel_name,
991  const std::string & name,
992  InputParameters & parameters);
993  virtual void addNodalKernel(const std::string & kernel_name,
994  const std::string & name,
995  InputParameters & parameters);
996  virtual void addScalarKernel(const std::string & kernel_name,
997  const std::string & name,
998  InputParameters & parameters);
999  virtual void addBoundaryCondition(const std::string & bc_name,
1000  const std::string & name,
1001  InputParameters & parameters);
1002 
1003 #ifdef MOOSE_KOKKOS_ENABLED
1004  virtual void addKokkosKernel(const std::string & kernel_name,
1005  const std::string & name,
1006  InputParameters & parameters);
1007  virtual void addKokkosNodalKernel(const std::string & kernel_name,
1008  const std::string & name,
1009  InputParameters & parameters);
1010  virtual void addKokkosBoundaryCondition(const std::string & bc_name,
1011  const std::string & name,
1012  InputParameters & parameters);
1013  virtual void addKokkosLinearFVKernel(const std::string & kernel_name,
1014  const std::string & name,
1015  InputParameters & parameters);
1016  virtual void addKokkosLinearFVBC(const std::string & bc_name,
1017  const std::string & name,
1018  InputParameters & parameters);
1019 #endif
1020 
1021  virtual void
1022  addConstraint(const std::string & c_name, const std::string & name, InputParameters & parameters);
1023 
1024  virtual void setInputParametersFEProblem(InputParameters & parameters)
1025  {
1026  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
1027  }
1028 
1029  // Aux /////
1030 
1037  virtual void addAuxVariable(const std::string & var_type,
1038  const std::string & var_name,
1039  InputParameters & params);
1040 
1044  virtual void addElementalFieldVariable(const std::string & var_type,
1045  const std::string & var_name,
1046  InputParameters & params);
1047 
1048  virtual void addAuxVariable(const std::string & var_name,
1049  const libMesh::FEType & type,
1050  const std::set<SubdomainID> * const active_subdomains = NULL);
1051  virtual void addAuxArrayVariable(const std::string & var_name,
1052  const libMesh::FEType & type,
1053  unsigned int components,
1054  const std::set<SubdomainID> * const active_subdomains = NULL);
1055  virtual void addAuxScalarVariable(const std::string & var_name,
1056  libMesh::Order order,
1057  Real scale_factor = 1.,
1058  const std::set<SubdomainID> * const active_subdomains = NULL);
1059  virtual void addAuxKernel(const std::string & kernel_name,
1060  const std::string & name,
1061  InputParameters & parameters);
1062  virtual void addAuxScalarKernel(const std::string & kernel_name,
1063  const std::string & name,
1064  InputParameters & parameters);
1065 
1066 #ifdef MOOSE_KOKKOS_ENABLED
1067  virtual void addKokkosAuxKernel(const std::string & kernel_name,
1068  const std::string & name,
1069  InputParameters & parameters);
1070 #endif
1071 
1072  AuxiliarySystem & getAuxiliarySystem() { return *_aux; }
1073 
1074  // Dirac /////
1075  virtual void addDiracKernel(const std::string & kernel_name,
1076  const std::string & name,
1077  InputParameters & parameters);
1078 
1079  // DG /////
1080  virtual void addDGKernel(const std::string & kernel_name,
1081  const std::string & name,
1082  InputParameters & parameters);
1083  // FV /////
1084  virtual void addFVKernel(const std::string & kernel_name,
1085  const std::string & name,
1086  InputParameters & parameters);
1087 
1088  virtual void addLinearFVKernel(const std::string & kernel_name,
1089  const std::string & name,
1090  InputParameters & parameters);
1091  virtual void
1092  addFVBC(const std::string & fv_bc_name, const std::string & name, InputParameters & parameters);
1093  virtual void addLinearFVBC(const std::string & fv_bc_name,
1094  const std::string & name,
1095  InputParameters & parameters);
1096 
1097  virtual void addFVInterfaceKernel(const std::string & fv_ik_name,
1098  const std::string & name,
1099  InputParameters & parameters);
1100 
1101  // Interface /////
1102  virtual void addInterfaceKernel(const std::string & kernel_name,
1103  const std::string & name,
1104  InputParameters & parameters);
1105 
1106  // IC /////
1107  virtual void addInitialCondition(const std::string & ic_name,
1108  const std::string & name,
1109  InputParameters & parameters);
1116  virtual void addFVInitialCondition(const std::string & ic_name,
1117  const std::string & name,
1118  InputParameters & parameters);
1119 
1120  void projectSolution();
1121 
1126  unsigned short getCurrentICState();
1127 
1136  void projectInitialConditionOnCustomRange(
1137  libMesh::ConstElemRange & elem_range,
1138  ConstBndNodeRange & bnd_node_range,
1139  const std::optional<std::set<VariableName>> & target_vars = std::nullopt);
1140 
1150  void projectFunctionOnCustomRange(ConstElemRange & elem_range,
1151  Number (*func)(const Point &,
1152  const libMesh::Parameters &,
1153  const std::string &,
1154  const std::string &),
1155  Gradient (*func_grad)(const Point &,
1156  const libMesh::Parameters &,
1157  const std::string &,
1158  const std::string &),
1159  const libMesh::Parameters & params,
1160  const std::vector<VariableName> & target_vars);
1161 
1162  // Materials
1163  virtual void addMaterial(const std::string & material_name,
1164  const std::string & name,
1165  InputParameters & parameters);
1166  virtual void addMaterialHelper(std::vector<MaterialWarehouse *> warehouse,
1167  const std::string & material_name,
1168  const std::string & name,
1169  InputParameters & parameters);
1170  virtual void addInterfaceMaterial(const std::string & material_name,
1171  const std::string & name,
1172  InputParameters & parameters);
1173  virtual void addFunctorMaterial(const std::string & functor_material_name,
1174  const std::string & name,
1175  InputParameters & parameters);
1176 
1177 #ifdef MOOSE_KOKKOS_ENABLED
1178  virtual void addKokkosMaterial(const std::string & material_name,
1179  const std::string & name,
1180  InputParameters & parameters);
1181 #endif
1182 
1194  void prepareMaterials(const std::unordered_set<unsigned int> & consumer_needed_mat_props,
1195  const SubdomainID blk_id,
1196  const THREAD_ID tid);
1197 
1198  void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful = true);
1199 
1209  void reinitMaterialsFace(SubdomainID blk_id,
1210  const THREAD_ID tid,
1211  bool swap_stateful = true,
1212  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1213 
1225  void
1226  reinitMaterialsFaceOnBoundary(const BoundaryID boundary_id,
1227  const SubdomainID blk_id,
1228  const THREAD_ID tid,
1229  const bool swap_stateful = true,
1230  const std::deque<MaterialBase *> * const reinit_mats = nullptr);
1231 
1243  void
1244  reinitMaterialsNeighborOnBoundary(const BoundaryID boundary_id,
1245  const SubdomainID blk_id,
1246  const THREAD_ID tid,
1247  const bool swap_stateful = true,
1248  const std::deque<MaterialBase *> * const reinit_mats = nullptr);
1249 
1259  void reinitMaterialsNeighbor(SubdomainID blk_id,
1260  const THREAD_ID tid,
1261  bool swap_stateful = true,
1262  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1263 
1276  void reinitMaterialsBoundary(BoundaryID boundary_id,
1277  const THREAD_ID tid,
1278  bool swap_stateful = true,
1279  const std::deque<MaterialBase *> * reinit_mats = nullptr);
1280 
1281  void
1282  reinitMaterialsInterface(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful = true);
1283 
1284 #ifdef MOOSE_KOKKOS_ENABLED
1285  void prepareKokkosMaterials(const std::unordered_set<unsigned int> & consumer_needed_mat_props);
1286  void reinitKokkosMaterials();
1287 #endif
1288 
1289  /*
1290  * Swap back underlying data storing stateful material properties
1291  */
1292  virtual void swapBackMaterials(const THREAD_ID tid);
1293  virtual void swapBackMaterialsFace(const THREAD_ID tid);
1294  virtual void swapBackMaterialsNeighbor(const THREAD_ID tid);
1295 
1302  void setActiveMaterialProperties(const std::unordered_set<unsigned int> & mat_prop_ids,
1303  const THREAD_ID tid);
1304 
1313  bool hasActiveMaterialProperties(const THREAD_ID tid) const;
1314 
1320  void clearActiveMaterialProperties(const THREAD_ID tid);
1321 
1333  template <typename T>
1334  std::vector<std::shared_ptr<T>> addObject(const std::string & type,
1335  const std::string & name,
1336  InputParameters & parameters,
1337  const bool threaded = true,
1338  const std::string & var_param_name = "variable");
1339 
1340  // Postprocessors /////
1341  virtual void addPostprocessor(const std::string & pp_name,
1342  const std::string & name,
1343  InputParameters & parameters);
1344 
1345  // VectorPostprocessors /////
1346  virtual void addVectorPostprocessor(const std::string & pp_name,
1347  const std::string & name,
1348  InputParameters & parameters);
1349 
1358  virtual void
1359  addReporter(const std::string & type, const std::string & name, InputParameters & parameters);
1360 
1361 #ifdef MOOSE_KOKKOS_ENABLED
1362  virtual void addKokkosPostprocessor(const std::string & pp_name,
1363  const std::string & name,
1364  InputParameters & parameters);
1365  virtual void addKokkosVectorPostprocessor(const std::string & pp_name,
1366  const std::string & name,
1367  InputParameters & parameters);
1368  virtual void addKokkosReporter(const std::string & type,
1369  const std::string & name,
1370  InputParameters & parameters);
1371 #endif
1372 
1380  const ReporterData & getReporterData() const { return _reporter_data; }
1381 
1387  ReporterData & getReporterData(ReporterData::WriteKey /*key*/) { return _reporter_data; }
1388 
1389  // UserObjects /////
1390  virtual std::vector<std::shared_ptr<UserObject>> addUserObject(
1391  const std::string & user_object_name, const std::string & name, InputParameters & parameters);
1392 
1398  template <class T>
1399  T & getUserObject(const std::string & name, unsigned int tid = 0) const
1400  {
1401  std::vector<T *> objs;
1402  theWarehouse()
1403  .query()
1404  .condition<AttribSystem>("UserObject")
1405  .condition<AttribThread>(tid)
1406  .condition<AttribName>(name)
1407  .queryInto(objs);
1408  if (objs.empty())
1409  mooseError("Unable to find user object with name '" + name + "'");
1410  return *(objs[0]);
1411  }
1412 
1419  const UserObject & getUserObjectBase(const std::string & name, const THREAD_ID tid = 0) const;
1420 
1426  bool hasUserObject(const std::string & name) const;
1427 
1428 #ifdef MOOSE_KOKKOS_ENABLED
1429  virtual void addKokkosUserObject(const std::string & user_object_name,
1430  const std::string & name,
1431  InputParameters & parameters);
1432 
1438  template <class T>
1439  const T & getKokkosUserObject(const std::string & name) const
1440  {
1441  std::vector<T *> objs;
1442  theWarehouse()
1443  .query()
1444  .condition<AttribSystem>("KokkosUserObject")
1445  .condition<AttribName>(name)
1446  .queryInto(objs);
1447  if (objs.empty())
1448  mooseError("Unable to find Kokkos user object with name '" + name + "'");
1449  return *(objs[0]);
1450  }
1451 
1457  bool hasKokkosUserObject(const std::string & name) const;
1458 #endif
1459 
1465  void checkUserObjectNameCollision(const std::string & name, const std::string & type) const;
1466 
1472  const Positions & getPositionsObject(const std::string & name) const;
1473 
1480  virtual void addFVInterpolationMethod(const std::string & method_type,
1481  const std::string & name,
1482  InputParameters & parameters);
1483 
1489  const FVInterpolationMethod & getFVInterpolationMethod(const InterpolationMethodName & name,
1490  const THREAD_ID tid = 0) const;
1491 
1497  const FVFaceInterpolationMethod &
1498  getFVFaceInterpolationMethod(const InterpolationMethodName & name, const THREAD_ID tid = 0) const;
1499 
1505  const FVAdvectedInterpolationMethod &
1506  getFVAdvectedInterpolationMethod(const InterpolationMethodName & name,
1507  const THREAD_ID tid = 0) const;
1508 
1512  bool hasFVInterpolationMethod(const InterpolationMethodName & name) const;
1513 
1522  bool hasPostprocessorValueByName(const PostprocessorName & name) const;
1523 
1529  const Postprocessor & getPostprocessorObjectByName(const PostprocessorName & object_name,
1530  const THREAD_ID tid = 0) const;
1531 
1542  const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName & name,
1543  std::size_t t_index = 0) const;
1544 
1559  void setPostprocessorValueByName(const PostprocessorName & name,
1560  const PostprocessorValue & value,
1561  std::size_t t_index = 0);
1562 
1566  bool hasPostprocessor(const std::string & name) const;
1567 
1578  const VectorPostprocessorValue &
1579  getVectorPostprocessorValueByName(const std::string & object_name,
1580  const std::string & vector_name,
1581  std::size_t t_index = 0) const;
1582 
1590  void setVectorPostprocessorValueByName(const std::string & object_name,
1591  const std::string & vector_name,
1592  const VectorPostprocessorValue & value,
1593  std::size_t t_index = 0);
1594 
1603  const VectorPostprocessor & getVectorPostprocessorObjectByName(const std::string & object_name,
1604  const THREAD_ID tid = 0) const;
1605 
1607 
1610  bool hasMultiApps() const { return _multi_apps.hasActiveObjects(); }
1611  bool hasMultiApps(ExecFlagType type) const;
1612  bool hasMultiApp(const std::string & name) const;
1614 
1615  // Dampers /////
1616  virtual void addDamper(const std::string & damper_name,
1617  const std::string & name,
1618  InputParameters & parameters);
1619  void setupDampers();
1620 
1624  bool hasDampers() { return _has_dampers; }
1625 
1626  // Indicators /////
1627  virtual void addIndicator(const std::string & indicator_name,
1628  const std::string & name,
1629  InputParameters & parameters);
1630 
1631  // Markers //////
1632  virtual void addMarker(const std::string & marker_name,
1633  const std::string & name,
1634  InputParameters & parameters);
1635 
1639  virtual void addMultiApp(const std::string & multi_app_name,
1640  const std::string & name,
1641  InputParameters & parameters);
1642 
1646  std::shared_ptr<MultiApp> getMultiApp(const std::string & multi_app_name) const;
1647 
1651  std::vector<std::shared_ptr<Transfer>> getTransfers(ExecFlagType type,
1652  Transfer::DIRECTION direction) const;
1653  std::vector<std::shared_ptr<Transfer>> getTransfers(Transfer::DIRECTION direction) const;
1654 
1658  const ExecuteMooseObjectWarehouse<Transfer> &
1659  getMultiAppTransferWarehouse(Transfer::DIRECTION direction) const;
1660 
1666  void execMultiAppTransfers(ExecFlagType type, Transfer::DIRECTION direction);
1667 
1671  bool execMultiApps(ExecFlagType type, bool auto_advance = true);
1672 
1673  void finalizeMultiApps();
1674 
1678  void incrementMultiAppTStep(ExecFlagType type);
1679 
1684  void advanceMultiApps(ExecFlagType type)
1685  {
1686  mooseDeprecated("Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep "
1687  "depending on your purpose");
1688  finishMultiAppStep(type);
1689  }
1690 
1695  void finishMultiAppStep(ExecFlagType type, bool recurse_through_multiapp_levels = false);
1696 
1700  void backupMultiApps(ExecFlagType type);
1701 
1706  void restoreMultiApps(ExecFlagType type, bool force = false);
1707 
1711  Real computeMultiAppsDT(ExecFlagType type);
1712 
1716  virtual void addTransfer(const std::string & transfer_name,
1717  const std::string & name,
1718  InputParameters & parameters);
1719 
1726  void execTransfers(ExecFlagType type);
1727 
1732  Real computeResidualL2Norm(NonlinearSystemBase & sys);
1733 
1738  Real computeResidualL2Norm(LinearSystem & sys);
1739 
1746  virtual Real computeResidualL2Norm();
1747 
1751  virtual void computeResidualSys(libMesh::NonlinearImplicitSystem & sys,
1752  const NumericVector<libMesh::Number> & soln,
1753  NumericVector<libMesh::Number> & residual);
1758  void computeResidual(libMesh::NonlinearImplicitSystem & sys,
1759  const NumericVector<libMesh::Number> & soln,
1760  NumericVector<libMesh::Number> & residual);
1761 
1765  virtual void computeResidual(const NumericVector<libMesh::Number> & soln,
1766  NumericVector<libMesh::Number> & residual,
1767  const unsigned int nl_sys_num);
1768 
1772  void computeResidualAndJacobian(const NumericVector<libMesh::Number> & soln,
1773  NumericVector<libMesh::Number> & residual,
1774  libMesh::SparseMatrix<libMesh::Number> & jacobian);
1775 
1779  virtual void computeResidualTag(const NumericVector<libMesh::Number> & soln,
1780  NumericVector<libMesh::Number> & residual,
1781  TagID tag);
1785  virtual void computeResidualType(const NumericVector<libMesh::Number> & soln,
1786  NumericVector<libMesh::Number> & residual,
1787  TagID tag);
1788 
1793  virtual void computeResidualInternal(const NumericVector<libMesh::Number> & soln,
1794  NumericVector<libMesh::Number> & residual,
1795  const std::set<TagID> & tags);
1799  virtual void computeResidualTags(const std::set<TagID> & tags);
1800 
1804  virtual void computeJacobianSys(libMesh::NonlinearImplicitSystem & sys,
1805  const NumericVector<libMesh::Number> & soln,
1806  libMesh::SparseMatrix<libMesh::Number> & jacobian);
1810  virtual void computeJacobian(const NumericVector<libMesh::Number> & soln,
1811  libMesh::SparseMatrix<libMesh::Number> & jacobian,
1812  const unsigned int nl_sys_num);
1813 
1817  virtual void computeJacobianTag(const NumericVector<libMesh::Number> & soln,
1818  libMesh::SparseMatrix<libMesh::Number> & jacobian,
1819  TagID tag);
1820 
1824  virtual void computeJacobianInternal(const NumericVector<libMesh::Number> & soln,
1825  libMesh::SparseMatrix<libMesh::Number> & jacobian,
1826  const std::set<TagID> & tags);
1827 
1831  virtual void computeJacobianTags(const std::set<TagID> & tags);
1832 
1841  virtual void computeJacobianBlocks(std::vector<JacobianBlock *> & blocks,
1842  const unsigned int nl_sys_num);
1843 
1857  virtual void computeJacobianBlock(libMesh::SparseMatrix<libMesh::Number> & jacobian,
1858  libMesh::System & precond_system,
1859  unsigned int ivar,
1860  unsigned int jvar);
1861 
1871  virtual void computeLinearSystemSys(libMesh::LinearImplicitSystem & sys,
1872  libMesh::SparseMatrix<libMesh::Number> & system_matrix,
1873  NumericVector<libMesh::Number> & rhs,
1874  const bool compute_gradients = true);
1875 
1885  void computeLinearSystemTags(const NumericVector<libMesh::Number> & soln,
1886  const std::set<TagID> & vector_tags,
1887  const std::set<TagID> & matrix_tags,
1888  const bool compute_gradients = true);
1889 
1890  virtual Real computeDamping(const NumericVector<libMesh::Number> & soln,
1891  const NumericVector<libMesh::Number> & update);
1892 
1897  virtual bool shouldUpdateSolution();
1898 
1905  virtual bool updateSolution(NumericVector<libMesh::Number> & vec_solution,
1906  NumericVector<libMesh::Number> & ghosted_solution);
1907 
1912  virtual void predictorCleanup(NumericVector<libMesh::Number> & ghosted_solution);
1913 
1914  virtual void computeBounds(libMesh::NonlinearImplicitSystem & sys,
1915  NumericVector<libMesh::Number> & lower,
1916  NumericVector<libMesh::Number> & upper);
1917  virtual void computeNearNullSpace(libMesh::NonlinearImplicitSystem & sys,
1918  std::vector<NumericVector<libMesh::Number> *> & sp);
1919  virtual void computeNullSpace(libMesh::NonlinearImplicitSystem & sys,
1920  std::vector<NumericVector<libMesh::Number> *> & sp);
1921  virtual void computeTransposeNullSpace(libMesh::NonlinearImplicitSystem & sys,
1922  std::vector<NumericVector<libMesh::Number> *> & sp);
1923  virtual void computePostCheck(libMesh::NonlinearImplicitSystem & sys,
1924  const NumericVector<libMesh::Number> & old_soln,
1925  NumericVector<libMesh::Number> & search_direction,
1926  NumericVector<libMesh::Number> & new_soln,
1927  bool & changed_search_direction,
1928  bool & changed_new_soln);
1929 
1930  virtual void computeIndicatorsAndMarkers();
1931  virtual void computeIndicators();
1932  virtual void computeMarkers();
1933 
1934  virtual void addResidual(const THREAD_ID tid) override;
1935  virtual void addResidualNeighbor(const THREAD_ID tid) override;
1936  virtual void addResidualLower(const THREAD_ID tid) override;
1937  virtual void addResidualScalar(const THREAD_ID tid = 0);
1938 
1939  virtual void cacheResidual(const THREAD_ID tid) override;
1940  virtual void cacheResidualNeighbor(const THREAD_ID tid) override;
1941  virtual void addCachedResidual(const THREAD_ID tid) override;
1942 
1950  virtual void addCachedResidualDirectly(NumericVector<libMesh::Number> & residual,
1951  const THREAD_ID tid);
1952 
1953  virtual void setResidual(NumericVector<libMesh::Number> & residual, const THREAD_ID tid) override;
1954  virtual void setResidualNeighbor(NumericVector<libMesh::Number> & residual,
1955  const THREAD_ID tid) override;
1956 
1957  virtual void addJacobian(const THREAD_ID tid) override;
1958  virtual void addJacobianNeighbor(const THREAD_ID tid) override;
1959  virtual void addJacobianNeighborLowerD(const THREAD_ID tid) override;
1960  virtual void addJacobianLowerD(const THREAD_ID tid) override;
1961  virtual void addJacobianBlockTags(libMesh::SparseMatrix<libMesh::Number> & jacobian,
1962  unsigned int ivar,
1963  unsigned int jvar,
1964  const DofMap & dof_map,
1965  std::vector<dof_id_type> & dof_indices,
1966  const std::set<TagID> & tags,
1967  const THREAD_ID tid);
1968  virtual void addJacobianNeighbor(libMesh::SparseMatrix<libMesh::Number> & jacobian,
1969  unsigned int ivar,
1970  unsigned int jvar,
1971  const DofMap & dof_map,
1972  std::vector<dof_id_type> & dof_indices,
1973  std::vector<dof_id_type> & neighbor_dof_indices,
1974  const std::set<TagID> & tags,
1975  const THREAD_ID tid) override;
1976  virtual void addJacobianScalar(const THREAD_ID tid = 0);
1977  virtual void addJacobianOffDiagScalar(unsigned int ivar, const THREAD_ID tid = 0);
1978 
1979  virtual void cacheJacobian(const THREAD_ID tid) override;
1980  virtual void cacheJacobianNeighbor(const THREAD_ID tid) override;
1981  virtual void addCachedJacobian(const THREAD_ID tid) override;
1982 
1983  virtual void prepareShapes(unsigned int var, const THREAD_ID tid) override;
1984  virtual void prepareFaceShapes(unsigned int var, const THREAD_ID tid) override;
1985  virtual void prepareNeighborShapes(unsigned int var, const THREAD_ID tid) override;
1986 
1987  // Displaced problem /////
1988  virtual void addDisplacedProblem(std::shared_ptr<DisplacedProblem> displaced_problem);
1989  virtual std::shared_ptr<const DisplacedProblem> getDisplacedProblem() const
1990  {
1991  return _displaced_problem;
1992  }
1993  virtual std::shared_ptr<DisplacedProblem> getDisplacedProblem() { return _displaced_problem; }
1994 
1998  virtual void updateGeomSearch(
1999  GeometricSearchData::GeometricSearchType type = GeometricSearchData::ALL) override;
2000  virtual void updateMortarMesh();
2001 
2002  void createMortarInterface(
2003  const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
2004  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
2005  bool on_displaced,
2006  bool periodic,
2007  const bool debug,
2008  const bool correct_edge_dropping,
2009  const Real minimum_projection_angle,
2010  const Mortar3DSubpatchPlane mortar_3d_subpatch_plane,
2011  const MooseEnum & triangulation,
2012  const bool triangulate_triangles,
2013  const Mortar3DQuadraturePointMapping mortar_3d_qp_mapping =
2014  Mortar3DQuadraturePointMapping::NORMAL_PROJECTION);
2015 
2020  const AutomaticMortarGeneration &
2022  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
2023  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
2024  bool on_displaced) const;
2025 
2026  AutomaticMortarGeneration &
2027  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
2028  const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
2029  bool on_displaced);
2031 
2032  const std::unordered_map<std::pair<BoundaryID, BoundaryID>, MortarInterfaceConfig> &
2033  getMortarInterfaces(bool on_displaced) const;
2034 
2035  virtual void possiblyRebuildGeomSearchPatches();
2036 
2037  virtual GeometricSearchData & geomSearchData() override { return _geometric_search_data; }
2038 
2043  void setRestartFile(const std::string & file_name);
2044 
2048  const MaterialPropertyRegistry & getMaterialPropertyRegistry() const
2049  {
2050  return _material_prop_registry;
2051  }
2052 
2057  const MaterialPropertyStorage & getMaterialPropertyStorage() { return _material_props; }
2059  const MaterialPropertyStorage & getBndMaterialPropertyStorage() { return _bnd_material_props; }
2060  const MaterialPropertyStorage & getNeighborMaterialPropertyStorage()
2061  {
2062  return _neighbor_material_props;
2063  }
2064 
2065 #ifdef MOOSE_KOKKOS_ENABLED
2066  Moose::Kokkos::MaterialPropertyStorage & getKokkosMaterialPropertyStorage()
2067  {
2068  return _kokkos_material_props;
2069  }
2070  Moose::Kokkos::MaterialPropertyStorage & getKokkosBndMaterialPropertyStorage()
2071  {
2072  return _kokkos_bnd_material_props;
2073  }
2074  Moose::Kokkos::MaterialPropertyStorage & getKokkosNeighborMaterialPropertyStorage()
2075  {
2076  return _kokkos_neighbor_material_props;
2077  }
2078 #endif
2079 
2084  const MooseObjectWarehouse<Indicator> & getIndicatorWarehouse() { return _indicators; }
2086  const MooseObjectWarehouse<InternalSideIndicatorBase> & getInternalSideIndicatorWarehouse()
2087  {
2088  return _internal_side_indicators;
2089  }
2090  const MooseObjectWarehouse<Marker> & getMarkerWarehouse() { return _markers; }
2092 
2096  const InitialConditionWarehouse & getInitialConditionWarehouse() const { return _ics; }
2097 
2101  const FVInitialConditionWarehouse & getFVInitialConditionWarehouse() const { return _fv_ics; }
2102 
2106  SolverParams & solverParams(unsigned int solver_sys_num = 0);
2107 
2111  const SolverParams & solverParams(unsigned int solver_sys_num = 0) const;
2112 
2113 #ifdef LIBMESH_ENABLE_AMR
2114  // Adaptivity /////
2115  Adaptivity & adaptivity() { return _adaptivity; }
2116  virtual void initialAdaptMesh();
2117 
2121  virtual bool adaptMesh();
2122 
2126  unsigned int getNumCyclesCompleted() { return _cycles_completed; }
2127 
2131  bool hasInitialAdaptivity() const { return _adaptivity.getInitialSteps() > 0; }
2132 #else
2133 
2136  bool hasInitialAdaptivity() const { return false; }
2137 #endif // LIBMESH_ENABLE_AMR
2138 
2140  void initXFEM(std::shared_ptr<XFEMInterface> xfem);
2141 
2143  std::shared_ptr<XFEMInterface> getXFEM() { return _xfem; }
2144 
2146  bool haveXFEM() { return _xfem != nullptr; }
2147 
2149  virtual bool updateMeshXFEM();
2150 
2165  virtual void
2166  meshChanged(bool intermediate_change, bool contract_mesh, bool clean_refinement_flags);
2167 
2172  void notifyWhenMeshChanges(MeshChangedInterface * mci);
2173 
2178  void notifyWhenMeshDisplaces(MeshDisplacedInterface * mdi);
2179 
2185  void initElementStatefulProps(const libMesh::ConstElemRange & elem_range, const bool threaded);
2186 
2187 #ifdef MOOSE_KOKKOS_ENABLED
2188  void initKokkosStatefulProps();
2189 #endif
2190 
2195  virtual void checkProblemIntegrity();
2196 
2197  void registerRandomInterface(RandomInterface & random_interface, const std::string & name);
2198 
2203  void setConstJacobian(bool state) { _const_jacobian = state; }
2204 
2209  void setKernelCoverageCheck(CoverageCheckMode mode) { _kernel_coverage_check = mode; }
2210 
2215  void setKernelCoverageCheck(bool flag)
2216  {
2217  _kernel_coverage_check = flag ? CoverageCheckMode::TRUE : CoverageCheckMode::FALSE;
2218  }
2219 
2226  void setMaterialCoverageCheck(CoverageCheckMode mode) { _material_coverage_check = mode; }
2227 
2234  void setMaterialCoverageCheck(bool flag)
2235  {
2236  _material_coverage_check = flag ? CoverageCheckMode::TRUE : CoverageCheckMode::FALSE;
2237  }
2238 
2242  void setParallelBarrierMessaging(bool flag) { _parallel_barrier_messaging = flag; }
2243 
2245  void setVerboseProblem(bool verbose);
2246 
2250  bool verboseMultiApps() const { return _verbose_multiapps; }
2251 
2255  void parentOutputPositionChanged();
2256 
2258 
2275  bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid);
2276  bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid);
2277  bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, const THREAD_ID tid);
2279 
2284  unsigned int subspaceDim(const std::string & prefix) const
2285  {
2286  if (_subspace_dim.count(prefix))
2287  return _subspace_dim.find(prefix)->second;
2288  else
2289  return 0;
2290  }
2291 
2292  /*
2293  * Return reference to function warehouse.
2294  */
2295  const MooseObjectWarehouse<Function> & getFunctionWarehouse() { return _functions; }
2296 
2297  /*
2298  * Return a reference to the material warehouse of *all* Material objects.
2299  */
2300  const MaterialWarehouse & getMaterialWarehouse() const { return _all_materials; }
2301 
2302  /*
2303  * Return a reference to the material warehouse of Material objects to be computed.
2304  */
2305  const MaterialWarehouse & getRegularMaterialsWarehouse() const { return _materials; }
2306  const MaterialWarehouse & getDiscreteMaterialWarehouse() const { return _discrete_materials; }
2307  const MaterialWarehouse & getInterfaceMaterialsWarehouse() const { return _interface_materials; }
2308 
2309 #ifdef MOOSE_KOKKOS_ENABLED
2310  /*
2311  * Return a reference to the material warehouse of Kokkos Material objects to be computed.
2312  */
2313  const MaterialWarehouse & getKokkosMaterialsWarehouse() const { return _kokkos_materials; }
2314 #endif
2315 
2323  std::shared_ptr<MaterialBase> getMaterial(std::string name,
2324  Moose::MaterialDataType type,
2325  const THREAD_ID tid = 0,
2326  bool no_warn = false);
2327 
2331  MaterialData & getMaterialData(Moose::MaterialDataType type,
2332  const THREAD_ID tid = 0,
2333  const MooseObject * object = nullptr) const;
2334 
2335 #ifdef MOOSE_KOKKOS_ENABLED
2336 
2339  MaterialData & getKokkosMaterialData(Moose::MaterialDataType type,
2340  const MooseObject * object = nullptr) const;
2341 #endif
2342 
2346  const std::set<const MooseObject *> &
2347  getMaterialPropertyStorageConsumers(Moose::MaterialDataType type) const;
2348 
2349 #ifdef MOOSE_KOKKOS_ENABLED
2350 
2353  const std::set<const MooseObject *> &
2354  getKokkosMaterialPropertyStorageConsumers(Moose::MaterialDataType type) const;
2355 #endif
2356 
2360  bool restoreOriginalNonzeroPattern() const { return _restore_original_nonzero_pattern; }
2361 
2366  bool errorOnJacobianNonzeroReallocation() const
2367  {
2368  return _error_on_jacobian_nonzero_reallocation;
2369  }
2370 
2371  void setErrorOnJacobianNonzeroReallocation(bool state)
2372  {
2373  _error_on_jacobian_nonzero_reallocation = state;
2374  }
2375 
2380  bool preserveMatrixSparsityPattern() const { return _preserve_matrix_sparsity_pattern; };
2381 
2385  void setPreserveMatrixSparsityPattern(bool preserve);
2386 
2391  bool ignoreZerosInJacobian() const { return _ignore_zeros_in_jacobian; }
2392 
2394  void setIgnoreZerosInJacobian(bool state) { _ignore_zeros_in_jacobian = state; }
2395 
2402  bool acceptInvalidSolution() const;
2406  bool allowInvalidSolution() const { return _allow_invalid_solution; }
2407 
2411  bool showInvalidSolutionConsole() const { return _show_invalid_solution_console; }
2412 
2416  bool immediatelyPrintInvalidSolution() const { return _immediately_print_invalid_solution; }
2417 
2419  bool hasTimeIntegrator() const { return _has_time_integrator; }
2420 
2422 
2428  const ExecFlagType & getCurrentExecuteOnFlag() const;
2429  void setCurrentExecuteOnFlag(const ExecFlagType &);
2431 
2435  virtual void execute(const ExecFlagType & exec_type);
2436  virtual void executeAllObjects(const ExecFlagType & exec_type);
2437 
2438  virtual Executor & getExecutor(const std::string & name) { return _app.getExecutor(name); }
2439 
2443  virtual void computeUserObjects(const ExecFlagType & type, const Moose::AuxGroup & group);
2444 
2448  virtual void computeUserObjectByName(const ExecFlagType & type,
2449  const Moose::AuxGroup & group,
2450  const std::string & name);
2451 
2455  void needsPreviousNewtonIteration(bool state);
2456 
2461  bool needsPreviousNewtonIteration() const;
2462 
2469  void needsPreviousMultiAppFixedPointIterationSolution(bool needed,
2470  const unsigned int solver_sys_num);
2471 
2478  bool needsPreviousMultiAppFixedPointIterationSolution(const unsigned int solver_sys_num) const;
2479 
2484  void needsPreviousMultiAppFixedPointIterationAuxiliary(bool state);
2485 
2492  bool needsPreviousMultiAppFixedPointIterationAuxiliary() const;
2493 
2495 
2498  std::vector<Real> _real_zero;
2499  std::vector<VariableValue> _scalar_zero;
2500  std::vector<VariableValue> _zero;
2501  std::vector<VariablePhiValue> _phi_zero;
2502  std::vector<MooseArray<ADReal>> _ad_zero;
2503  std::vector<VariableGradient> _grad_zero;
2504  std::vector<MooseArray<ADRealVectorValue>> _ad_grad_zero;
2505  std::vector<VariablePhiGradient> _grad_phi_zero;
2506  std::vector<VariableSecond> _second_zero;
2507  std::vector<MooseArray<ADRealTensorValue>> _ad_second_zero;
2508  std::vector<VariablePhiSecond> _second_phi_zero;
2509  std::vector<Point> _point_zero;
2510  std::vector<VectorVariableValue> _vector_zero;
2511  std::vector<VectorVariableCurl> _vector_curl_zero;
2513 
2517  ExecuteMooseObjectWarehouse<Control> & getControlWarehouse() { return _control_warehouse; }
2518 
2522  void executeControls(const ExecFlagType & exec_type);
2523 
2527  void executeSamplers(const ExecFlagType & exec_type);
2528 
2532  virtual void updateActiveObjects();
2533 
2539  void reportMooseObjectDependency(MooseObject * a, MooseObject * b);
2540 
2541  ExecuteMooseObjectWarehouse<MultiApp> & getMultiAppWarehouse() { return _multi_apps; }
2542 
2546  bool hasJacobian() const;
2547 
2552  bool constJacobian() const;
2553 
2557  void addOutput(const std::string &, const std::string &, InputParameters &);
2558 
2559  inline TheWarehouse & theWarehouse() const { return _app.theWarehouse(); }
2560 
2564  void setSNESMFReuseBase(bool reuse, bool set_by_user)
2565  {
2566  _snesmf_reuse_base = reuse, _snesmf_reuse_base_set_by_user = set_by_user;
2567  }
2568 
2572  bool useSNESMFReuseBase() { return _snesmf_reuse_base; }
2573 
2577  void skipExceptionCheck(bool skip_exception_check)
2578  {
2579  _skip_exception_check = skip_exception_check;
2580  }
2581 
2585  bool isSNESMFReuseBaseSetbyUser() { return _snesmf_reuse_base_set_by_user; }
2586 
2590  bool & petscOptionsInserted() { return _is_petsc_options_inserted; }
2591 
2592 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
2593  PetscOptions & petscOptionsDatabase() { return _petsc_option_data_base; }
2594 #endif
2595 
2597  virtual void setUDotRequested(const bool u_dot_requested) { _u_dot_requested = u_dot_requested; }
2598 
2600  virtual void setUDotDotRequested(const bool u_dotdot_requested)
2601  {
2602  _u_dotdot_requested = u_dotdot_requested;
2603  }
2604 
2606  virtual void setUDotOldRequested(const bool u_dot_old_requested)
2607  {
2608  _u_dot_old_requested = u_dot_old_requested;
2609  }
2610 
2612  virtual void setUDotDotOldRequested(const bool u_dotdot_old_requested)
2613  {
2614  _u_dotdot_old_requested = u_dotdot_old_requested;
2615  }
2616 
2618  virtual bool uDotRequested() { return _u_dot_requested; }
2619 
2621  virtual bool uDotDotRequested() { return _u_dotdot_requested; }
2622 
2624  virtual bool uDotOldRequested()
2625  {
2626  if (_u_dot_old_requested && !_u_dot_requested)
2627  mooseError("FEProblemBase: When requesting old time derivative of solution, current time "
2628  "derivative of solution should also be stored. Please set `u_dot_requested` to "
2629  "true using setUDotRequested.");
2630 
2631  return _u_dot_old_requested;
2632  }
2633 
2635  virtual bool uDotDotOldRequested()
2636  {
2637  if (_u_dotdot_old_requested && !_u_dotdot_requested)
2638  mooseError("FEProblemBase: When requesting old second time derivative of solution, current "
2639  "second time derivation of solution should also be stored. Please set "
2640  "`u_dotdot_requested` to true using setUDotDotRequested.");
2641  return _u_dotdot_old_requested;
2642  }
2643 
2644  using SubProblem::haveADObjects;
2645  void haveADObjects(bool have_ad_objects) override;
2646 
2647  // Whether or not we should solve this system
2648  bool shouldSolve() const { return _solve; }
2649 
2653  const MortarInterfaceWarehouse & mortarData() const { return *_mortar_data; }
2654  MortarInterfaceWarehouse & mortarData() { return *_mortar_data; }
2655 
2659  virtual bool hasNeighborCoupling() const { return _has_internal_edge_residual_objects; }
2660 
2664  virtual bool hasMortarCoupling() const { return _has_mortar; }
2665 
2666  using SubProblem::computingNonlinearResid;
2667  void computingNonlinearResid(bool computing_nonlinear_residual) final;
2668 
2669  using SubProblem::currentlyComputingResidual;
2670  void setCurrentlyComputingResidual(bool currently_computing_residual) final;
2671 
2675  void numGridSteps(unsigned int num_grid_steps) { _num_grid_steps = num_grid_steps; }
2676 
2681  void uniformRefine();
2682 
2683  using SubProblem::automaticScaling;
2684  void automaticScaling(bool automatic_scaling) override;
2685 
2687 
2690  template <typename T>
2691  static void objectSetupHelper(const std::vector<T *> & objects, const ExecFlagType & exec_flag);
2692  template <typename T>
2693  static void objectExecuteHelper(const std::vector<T *> & objects);
2695 
2702  virtual void reinitElemFaceRef(const Elem * elem,
2703  unsigned int side,
2704  Real tolerance,
2705  const std::vector<Point> * const pts,
2706  const std::vector<Real> * const weights = nullptr,
2707  const THREAD_ID tid = 0) override;
2708 
2715  virtual void reinitNeighborFaceRef(const Elem * neighbor_elem,
2716  unsigned int neighbor_side,
2717  Real tolerance,
2718  const std::vector<Point> * const pts,
2719  const std::vector<Real> * const weights = nullptr,
2720  const THREAD_ID tid = 0) override;
2721 
2725  bool fvBCsIntegrityCheck() const { return _fv_bcs_integrity_check; }
2726 
2731  void fvBCsIntegrityCheck(bool fv_bcs_integrity_check);
2732 
2741  void getFVMatsAndDependencies(SubdomainID block_id,
2742  std::vector<std::shared_ptr<MaterialBase>> & face_materials,
2743  std::vector<std::shared_ptr<MaterialBase>> & neighbor_materials,
2744  std::set<MooseVariableFieldBase *> & variables,
2745  const THREAD_ID tid);
2746 
2753  void resizeMaterialData(Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid);
2754 
2755  bool haveDisplaced() const override final { return _displaced_problem.get(); }
2756 
2758  bool hasLinearConvergenceObjects() const;
2762  void setNonlinearConvergenceNames(const std::vector<ConvergenceName> & convergence_names);
2766  void setLinearConvergenceNames(const std::vector<ConvergenceName> & convergence_names);
2770  void setMultiAppFixedPointConvergenceName(const ConvergenceName & convergence_name);
2774  void setSteadyStateConvergenceName(const ConvergenceName & convergence_name);
2775 
2779  const std::vector<ConvergenceName> & getNonlinearConvergenceNames() const;
2783  const std::vector<ConvergenceName> & getLinearConvergenceNames() const;
2787  const ConvergenceName & getMultiAppFixedPointConvergenceName() const;
2791  const ConvergenceName & getSteadyStateConvergenceName() const;
2792 
2796  void computingScalingJacobian(bool computing_scaling_jacobian)
2797  {
2798  _computing_scaling_jacobian = computing_scaling_jacobian;
2799  }
2800 
2801  bool computingScalingJacobian() const override final { return _computing_scaling_jacobian; }
2802 
2806  void computingScalingResidual(bool computing_scaling_residual)
2807  {
2808  _computing_scaling_residual = computing_scaling_residual;
2809  }
2810 
2814  bool computingScalingResidual() const override final { return _computing_scaling_residual; }
2815 
2820  MooseAppCoordTransform & coordTransform();
2821 
2822  virtual std::size_t numNonlinearSystems() const override { return _num_nl_sys; }
2823 
2824  virtual std::size_t numLinearSystems() const override { return _num_linear_sys; }
2825 
2826  virtual std::size_t numSolverSystems() const override { return _num_nl_sys + _num_linear_sys; }
2827 
2829  bool isSolverSystemNonlinear(const unsigned int sys_num) { return sys_num < _num_nl_sys; }
2830 
2831  virtual unsigned int currentNlSysNum() const override;
2832 
2833  virtual unsigned int currentLinearSysNum() const override;
2834 
2838  virtual unsigned int nlSysNum(const NonlinearSystemName & nl_sys_name) const override;
2839 
2843  unsigned int linearSysNum(const LinearSystemName & linear_sys_name) const override;
2844 
2848  unsigned int solverSysNum(const SolverSystemName & solver_sys_name) const override;
2849 
2854  unsigned int systemNumForVariable(const VariableName & variable_name) const;
2855 
2857  bool getFailNextNonlinearConvergenceCheck() const { return getFailNextSystemConvergenceCheck(); }
2859  bool getFailNextSystemConvergenceCheck() const { return _fail_next_system_convergence_check; }
2860 
2862  void setFailNextNonlinearConvergenceCheck() { setFailNextSystemConvergenceCheck(); }
2864  void setFailNextSystemConvergenceCheck() { _fail_next_system_convergence_check = true; }
2865 
2867  void resetFailNextNonlinearConvergenceCheck() { resetFailNextSystemConvergenceCheck(); }
2869  void resetFailNextSystemConvergenceCheck() { _fail_next_system_convergence_check = false; }
2870 
2871  /*
2872  * Set the status of loop order of execution printing
2873  * @param print_exec set of execution flags to print on
2874  */
2875  void setExecutionPrinting(const ExecFlagEnum & print_exec) { _print_execution_on = print_exec; }
2876 
2880  bool shouldPrintExecution(const THREAD_ID tid) const;
2885  void reinitMortarUserObjects(BoundaryID primary_boundary_id,
2886  BoundaryID secondary_boundary_id,
2887  bool displaced);
2888 
2889  virtual const std::vector<VectorTag> & currentResidualVectorTags() const override;
2890 
2895  class CurrentResidualVectorTagsKey
2896  {
2897  friend class CrankNicolson;
2898  friend class FEProblemBase;
2899  CurrentResidualVectorTagsKey() {}
2900  CurrentResidualVectorTagsKey(const CurrentResidualVectorTagsKey &) {}
2901  };
2902 
2906  void setCurrentResidualVectorTags(const std::set<TagID> & vector_tags);
2907 
2911  void clearCurrentResidualVectorTags();
2912 
2916  void clearCurrentJacobianMatrixTags() {}
2917 
2918  virtual void needFV() override { _have_fv = true; }
2919  virtual bool haveFV() const override { return _have_fv; }
2920 
2921  virtual bool hasNonlocalCoupling() const override { return _has_nonlocal_coupling; }
2922 
2926  bool identifyVariableGroupsInNL() const { return _identify_variable_groups_in_nl; }
2927 
2928  virtual void setCurrentLowerDElem(const Elem * const lower_d_elem, const THREAD_ID tid) override;
2929  virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid) override;
2930 
2934  const std::vector<NonlinearSystemName> & getNonlinearSystemNames() const { return _nl_sys_names; }
2938  const std::vector<LinearSystemName> & getLinearSystemNames() const { return _linear_sys_names; }
2942  const std::vector<SolverSystemName> & getSolverSystemNames() const { return _solver_sys_names; }
2943 
2944  virtual const libMesh::CouplingMatrix & nonlocalCouplingMatrix(const unsigned i) const override;
2945 
2946  virtual bool checkNonlocalCouplingRequirement() const override;
2947 
2948  virtual Moose::FEBackend feBackend() const { return Moose::FEBackend::LibMesh; }
2949 
2950  class CreateTaggedMatrixKey
2951  {
2952  CreateTaggedMatrixKey() {}
2953  CreateTaggedMatrixKey(const CreateTaggedMatrixKey &) {}
2954 
2955  friend class AddTaggedMatricesAction;
2956  };
2957 
2958  void createTagMatrices(CreateTaggedMatrixKey);
2959 
2960  bool useHashTableMatrixAssembly() const { return _use_hash_table_matrix_assembly; }
2961 
2962 #ifdef MOOSE_KOKKOS_ENABLED
2963 
2966  bool hasKokkosObjects() const { return _has_kokkos_objects; }
2970  bool hasKokkosResidualObjects() const { return _has_kokkos_residual_objects; }
2975  void addKokkosMeshInitializationHook(std::function<void()> function)
2976  {
2977  _kokkos_mesh_initialization_hooks.push_back(function);
2978  }
2979 #endif
2980 
2981 protected:
2985  virtual void meshChanged() {}
2986 
2988  void createTagVectors();
2989 
2991  void createTagSolutions();
2992 
2996  virtual void meshDisplaced();
2997 
3001  void computeSystems(const ExecFlagType & type);
3002 
3003  MooseMesh & _mesh;
3004 
3005 private:
3007  Restartable::ManagedValue<RestartableEquationSystems> _req;
3008 
3020  void setResidualObjectParamsAndLog(const std::string & ro_name,
3021  const std::string & name,
3022  InputParameters & parameters,
3023  const unsigned int nl_sys_num,
3024  const std::string & base_name,
3025  bool & reinit_displaced);
3026 
3034  void setAuxKernelParamsAndLog(const std::string & ak_name,
3035  const std::string & name,
3036  InputParameters & parameters,
3037  const std::string & base_name);
3038 
3042  static SolverParams makeLinearSolverParams();
3043 
3044  TheWarehouse::Query getUOQuery(const std::string & system,
3045  const ExecFlagType & type,
3046  const Moose::AuxGroup & group) const;
3047 
3048  void getUOExecutionGroups(TheWarehouse::Query & query, std::set<int> & execution_groups) const;
3049 
3050 protected:
3051  bool _initialized;
3052 
3054  std::optional<std::vector<ConvergenceName>> _nonlinear_convergence_names;
3056  std::optional<std::vector<ConvergenceName>> _linear_convergence_names;
3058  std::optional<ConvergenceName> _multiapp_fixed_point_convergence_name;
3060  std::optional<ConvergenceName> _steady_state_convergence_name;
3061 
3062  std::set<TagID> _fe_vector_tags;
3063 
3064  std::set<TagID> _fe_matrix_tags;
3065 
3067  std::set<TagID> _linear_vector_tags;
3068 
3070  std::set<TagID> _linear_matrix_tags;
3071 
3073  const bool & _solve;
3074 
3075  bool _transient;
3076  Real & _time;
3077  Real & _time_old;
3078  int & _t_step;
3079  Real & _dt;
3080  Real & _dt_old;
3081 
3083  bool _need_to_add_default_nonlinear_convergence;
3085  bool _need_to_add_default_multiapp_fixed_point_convergence;
3087  bool _need_to_add_default_steady_state_convergence;
3088 
3090  const std::vector<LinearSystemName> _linear_sys_names;
3091 
3093  const std::size_t _num_linear_sys;
3094 
3096  std::vector<std::shared_ptr<LinearSystem>> _linear_systems;
3097 
3099  std::map<LinearSystemName, unsigned int> _linear_sys_name_to_num;
3100 
3102  LinearSystem * _current_linear_sys;
3103 
3105  const bool _using_default_nl;
3106 
3108  const std::vector<NonlinearSystemName> _nl_sys_names;
3109 
3111  const std::size_t _num_nl_sys;
3112 
3114  std::vector<std::shared_ptr<NonlinearSystemBase>> _nl;
3115 
3117  std::map<NonlinearSystemName, unsigned int> _nl_sys_name_to_num;
3118 
3120  NonlinearSystemBase * _current_nl_sys;
3121 
3123  SolverSystem * _current_solver_sys;
3124 
3126  std::vector<std::shared_ptr<SolverSystem>> _solver_systems;
3127 
3129  std::map<SolverVariableName, unsigned int> _solver_var_to_sys_num;
3130 
3132  std::map<SolverSystemName, unsigned int> _solver_sys_name_to_num;
3133 
3135  std::vector<SolverSystemName> _solver_sys_names;
3136 
3138  std::shared_ptr<AuxiliarySystem> _aux;
3139 
3140  Moose::CouplingType _coupling;
3141  std::vector<std::unique_ptr<libMesh::CouplingMatrix>> _cm;
3142 
3143 #ifdef MOOSE_KOKKOS_ENABLED
3144  Moose::Kokkos::Array<Moose::Kokkos::System> _kokkos_systems;
3147  Moose::Kokkos::Array<Moose::Kokkos::FESystem> _kokkos_fe_systems;
3148 #endif
3149 
3151  std::map<std::string, unsigned int> _subspace_dim;
3152 
3155  std::vector<std::vector<std::unique_ptr<Assembly>>> _assembly;
3156 
3157 #ifdef MOOSE_KOKKOS_ENABLED
3158  Moose::Kokkos::Assembly _kokkos_assembly;
3159 #endif
3160 
3164  MooseObjectWarehouse<MeshDivision> _mesh_divisions;
3165 
3167  MooseObjectWarehouse<Function> _functions;
3168 
3169 #ifdef MOOSE_KOKKOS_ENABLED
3170  MooseObjectWarehouse<Moose::FunctionBase> _kokkos_functions;
3171 #endif
3172 
3174  MooseObjectWarehouse<Convergence> _convergences;
3175 
3177  MooseObjectWarehouse<KernelBase> _nonlocal_kernels;
3178 
3180  MooseObjectWarehouse<IntegratedBCBase> _nonlocal_integrated_bcs;
3181 
3184  InitialConditionWarehouse _ics;
3185  FVInitialConditionWarehouse _fv_ics;
3186  ScalarInitialConditionWarehouse _scalar_ics; // use base b/c of setup methods
3188 
3189  // material properties
3190  MaterialPropertyRegistry _material_prop_registry;
3191  MaterialPropertyStorage & _material_props;
3192  MaterialPropertyStorage & _bnd_material_props;
3193  MaterialPropertyStorage & _neighbor_material_props;
3194 
3195 #ifdef MOOSE_KOKKOS_ENABLED
3196  Moose::Kokkos::MaterialPropertyStorage & _kokkos_material_props;
3197  Moose::Kokkos::MaterialPropertyStorage & _kokkos_bnd_material_props;
3198  Moose::Kokkos::MaterialPropertyStorage & _kokkos_neighbor_material_props;
3199 #endif
3200  // Material Warehouses
3202  MaterialWarehouse _materials; // regular materials
3203  MaterialWarehouse _interface_materials; // interface materials
3204  MaterialWarehouse _discrete_materials; // Materials that the user must compute
3205  MaterialWarehouse _all_materials; // All materials for error checking and MaterialData storage
3206 
3207 #ifdef MOOSE_KOKKOS_ENABLED
3208  MaterialWarehouse _kokkos_materials; // Kokkos materials
3209 #endif
3210 
3213  // Indicator Warehouses
3214  MooseObjectWarehouse<Indicator> _indicators;
3215  MooseObjectWarehouse<InternalSideIndicatorBase> _internal_side_indicators;
3217 
3218  // Marker Warehouse
3219  MooseObjectWarehouse<Marker> _markers;
3220 
3221  // Helper class to access Reporter object values
3222  ReporterData _reporter_data;
3223 
3225  ExecuteMooseObjectWarehouse<MultiApp> _multi_apps;
3226 
3228  ExecuteMooseObjectWarehouse<TransientMultiApp> _transient_multi_apps;
3229 
3231  ExecuteMooseObjectWarehouse<Transfer> _transfers;
3232 
3234  ExecuteMooseObjectWarehouse<Transfer> _to_multi_app_transfers;
3235 
3237  ExecuteMooseObjectWarehouse<Transfer> _from_multi_app_transfers;
3238 
3240  ExecuteMooseObjectWarehouse<Transfer> _between_multi_app_transfers;
3241 
3243  std::map<std::string, std::unique_ptr<RandomData>> _random_data_objects;
3244 
3246  std::vector<std::unordered_map<SubdomainID, bool>> _block_mat_side_cache;
3247 
3249  std::vector<std::unordered_map<BoundaryID, bool>> _bnd_mat_side_cache;
3250 
3252  std::vector<std::unordered_map<BoundaryID, bool>> _interface_mat_side_cache;
3253 
3255  std::vector<MeshChangedInterface *> _notify_when_mesh_changes;
3256 
3258  std::vector<MeshDisplacedInterface *> _notify_when_mesh_displaces;
3259 
3261  bool duplicateVariableCheck(const std::string & var_name,
3262  const libMesh::FEType & type,
3263  bool is_aux,
3264  const std::set<SubdomainID> * const active_subdomains);
3265 
3266  void computeUserObjectsInternal(const ExecFlagType & type, TheWarehouse::Query & query);
3267 
3268 #ifdef MOOSE_KOKKOS_ENABLED
3269  void computeKokkosUserObjectsInternal(const ExecFlagType & type, TheWarehouse::Query & query);
3270 #endif
3271 
3273  void checkDisplacementOrders();
3274 
3275  void checkUserObjects();
3276 
3282  void checkDependMaterialsHelper(
3283  const std::map<SubdomainID, std::vector<std::shared_ptr<MaterialBase>>> & materials_map);
3284 
3286  void checkCoordinateSystems();
3287 
3293  void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed = false);
3294 
3301  void addObjectParamsHelper(InputParameters & params,
3302  const std::string & object_name,
3303  const std::string & var_param_name = "variable");
3304 
3305 #ifdef LIBMESH_ENABLE_AMR
3306  Adaptivity _adaptivity;
3307  unsigned int _cycles_completed;
3308 #endif
3309 
3311  std::shared_ptr<XFEMInterface> _xfem;
3312 
3313  // Displaced mesh /////
3314  MooseMesh * _displaced_mesh;
3315  std::shared_ptr<DisplacedProblem> _displaced_problem;
3316  GeometricSearchData _geometric_search_data;
3317  std::unique_ptr<MortarInterfaceWarehouse> _mortar_data;
3318 
3320  bool _reinit_displaced_elem;
3322  bool _reinit_displaced_face;
3324  bool _reinit_displaced_neighbor;
3325 
3327  bool _input_file_saved;
3328 
3330  bool _has_dampers;
3331 
3333  bool _has_constraints;
3334 
3336  bool _snesmf_reuse_base;
3337 
3339  bool _skip_exception_check;
3340 
3342  bool _snesmf_reuse_base_set_by_user;
3343 
3345  bool _has_initialized_stateful;
3346 
3348  bool _const_jacobian;
3349 
3351  bool _has_jacobian;
3352 
3354  bool _needs_old_newton_iter;
3355 
3357  bool _previous_nl_solution_required;
3359  std::vector<bool> _previous_multiapp_fp_nl_solution_required;
3361  bool _previous_multiapp_fp_aux_solution_required;
3362 
3364  bool _has_nonlocal_coupling;
3365  bool _calculate_jacobian_in_uo;
3366 
3367  std::vector<std::vector<const MooseVariableFEBase *>> _uo_jacobian_moose_vars;
3368 
3370  std::vector<unsigned char> _has_active_material_properties;
3371 
3372  std::vector<SolverParams> _solver_params;
3373 
3375  CoverageCheckMode _kernel_coverage_check;
3376  std::vector<SubdomainName> _kernel_coverage_blocks;
3377 
3380  const bool _boundary_restricted_node_integrity_check;
3381 
3384  const bool _boundary_restricted_elem_integrity_check;
3385 
3387  CoverageCheckMode _material_coverage_check;
3388  std::vector<SubdomainName> _material_coverage_blocks;
3389 
3391  bool _fv_bcs_integrity_check;
3392 
3394  const bool _material_dependency_check;
3395 
3397  const bool _uo_aux_state_check;
3398 
3399 #ifndef NDEBUG
3400  bool _check_residual_for_nans;
3402 #endif
3403 
3405  unsigned int _max_qps;
3406 
3408  libMesh::Order _max_scalar_order;
3409 
3411  bool _has_time_integrator;
3412 
3414  bool _has_exception;
3415 
3417  bool _parallel_barrier_messaging;
3418 
3420  MooseEnum _verbose_setup;
3421 
3423  bool _verbose_multiapps;
3424 
3426  bool _verbose_restore;
3427 
3429  std::string _exception_message;
3430 
3432  ExecFlagType _current_execute_on_flag;
3433 
3435  ExecuteMooseObjectWarehouse<Control> _control_warehouse;
3436 
3438  Moose::PetscSupport::PetscOptions _petsc_options;
3439 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
3440  PetscOptions _petsc_option_data_base;
3441 #endif
3442 
3444  bool _is_petsc_options_inserted;
3445 
3446  std::shared_ptr<LineSearch> _line_search;
3447 
3448  std::unique_ptr<libMesh::ConstElemRange> _evaluable_local_elem_range;
3449  std::unique_ptr<libMesh::ConstElemRange> _nl_evaluable_local_elem_range;
3450  std::unique_ptr<libMesh::ConstElemRange> _aux_evaluable_local_elem_range;
3451 
3452  std::unique_ptr<libMesh::ConstElemRange> _current_algebraic_elem_range;
3453  std::unique_ptr<libMesh::ConstNodeRange> _current_algebraic_node_range;
3454  std::unique_ptr<ConstBndNodeRange> _current_algebraic_bnd_node_range;
3455 
3458  bool _using_ad_mat_props;
3459 
3460  // loop state during projection of initial conditions
3461  unsigned short _current_ic_state;
3462 
3465  const bool _use_hash_table_matrix_assembly;
3466 
3467 private:
3472  void handleException(const std::string & calling_method);
3473 
3478  std::vector<MortarUserObject *>
3479  getMortarUserObjects(BoundaryID primary_boundary_id,
3480  BoundaryID secondary_boundary_id,
3481  bool displaced,
3482  const std::vector<MortarUserObject *> & mortar_uo_superset);
3483 
3488  std::vector<MortarUserObject *> getMortarUserObjects(BoundaryID primary_boundary_id,
3489  BoundaryID secondary_boundary_id,
3490  bool displaced);
3491 
3501  virtual std::pair<bool, unsigned int>
3502  determineSolverSystem(const std::string & var_name,
3503  bool error_if_not_found = false) const override;
3504 
3511  void checkICRestartError(const std::string & ic_name,
3512  const std::string & name,
3513  const VariableName & var_name);
3514 
3515  /*
3516  * Test if stateful property redistribution is expected to be
3517  * necessary, and set it up if so.
3518  */
3519  void addAnyRedistributers();
3520 
3521  void updateMaxQps();
3522 
3523  void joinAndFinalize(TheWarehouse::Query query, bool isgen = false);
3524 
3525 #ifdef MOOSE_KOKKOS_ENABLED
3526  void kokkosJoinAndFinalize(const std::vector<Moose::Kokkos::UserObject *> & userobjs);
3527 #endif
3528 
3532  virtual void resetState();
3533 
3534  // Parameters handling Jacobian sparsity pattern behavior
3536  bool _error_on_jacobian_nonzero_reallocation;
3541  const bool _restore_original_nonzero_pattern;
3543  bool _ignore_zeros_in_jacobian;
3545  bool _preserve_matrix_sparsity_pattern;
3546 
3547  const bool _force_restart;
3548  const bool _allow_ics_during_restart;
3549  const bool _skip_nl_system_check;
3550  bool _fail_next_system_convergence_check;
3551  const bool _allow_invalid_solution;
3552  const bool _show_invalid_solution_console;
3553  const bool & _immediately_print_invalid_solution;
3554 
3556  bool _started_initial_setup;
3557 
3559  bool _has_internal_edge_residual_objects;
3560 
3562  bool _u_dot_requested;
3563 
3565  bool _u_dotdot_requested;
3566 
3568  bool _u_dot_old_requested;
3569 
3571  bool _u_dotdot_old_requested;
3572 
3573  friend class AuxiliarySystem;
3574  friend class NonlinearSystemBase;
3575  friend class MooseEigenSystem;
3576  friend class Resurrector;
3577  friend class Restartable;
3578  friend class DisplacedProblem;
3579 
3581  bool _has_mortar;
3582 
3584  unsigned int _num_grid_steps;
3585 
3588  bool _trust_user_coupling_matrix = false;
3589 
3591  bool _computing_scaling_jacobian = false;
3592 
3594  bool _computing_scaling_residual = false;
3595 
3597  bool _checking_uo_aux_state = false;
3598 
3600  ExecFlagEnum _print_execution_on;
3601 
3603  const bool _identify_variable_groups_in_nl;
3604 
3608  std::vector<VectorTag> _current_residual_vector_tags;
3609 
3611  bool _have_fv = false;
3612 
3615  const bool _regard_general_exceptions_as_errors;
3616 
3618  std::vector<libMesh::CouplingMatrix> _nonlocal_cm;
3619 
3621  bool _requires_nonlocal_coupling;
3622 
3623 #ifdef MOOSE_KOKKOS_ENABLED
3624  bool _has_kokkos_objects = false;
3626 
3628  bool _has_kokkos_residual_objects = false;
3629 
3631  std::vector<std::function<void()>> _kokkos_mesh_initialization_hooks;
3632 #endif
3633 
3634  friend void Moose::PetscSupport::setSinglePetscOption(const std::string & name,
3635  const std::string & value,
3636  FEProblemBase * const problem);
3637 };
3638 
3639 using FVProblemBase = FEProblemBase;
3640 
3641 template <typename T>
3642 void
3643 FEProblemBase::allowOutput(bool state)
3644 {
3645  _app.getOutputWarehouse().allowOutput<T>(state);
3646 }
3647 
3648 template <typename T>
3649 void
3650 FEProblemBase::objectSetupHelper(const std::vector<T *> & objects, const ExecFlagType & exec_flag)
3651 {
3652  if (exec_flag == EXEC_INITIAL)
3653  {
3654  for (T * obj_ptr : objects)
3655  obj_ptr->initialSetup();
3656  }
3657 
3658  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
3659  {
3660  for (const auto obj_ptr : objects)
3661  obj_ptr->timestepSetup();
3662  }
3663  else if (exec_flag == EXEC_SUBDOMAIN)
3664  {
3665  for (const auto obj_ptr : objects)
3666  obj_ptr->subdomainSetup();
3667  }
3668 
3669  else if (exec_flag == EXEC_NONLINEAR)
3670  {
3671  for (const auto obj_ptr : objects)
3672  obj_ptr->jacobianSetup();
3673  }
3674 
3675  else if (exec_flag == EXEC_LINEAR)
3676  {
3677  for (const auto obj_ptr : objects)
3678  obj_ptr->residualSetup();
3679  }
3680 }
3681 
3682 template <typename T>
3683 void
3684 FEProblemBase::objectExecuteHelper(const std::vector<T *> & objects)
3685 {
3686  for (T * obj_ptr : objects)
3687  obj_ptr->execute();
3688 }
3689 
3690 template <typename T>
3691 std::vector<std::shared_ptr<T>>
3692 FEProblemBase::addObject(const std::string & type,
3693  const std::string & name,
3694  InputParameters & parameters,
3695  const bool threaded,
3696  const std::string & var_param_name)
3697 {
3698  parallel_object_only();
3699 
3700  logAdd(MooseUtils::prettyCppType<T>(), name, type, parameters);
3701  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
3702  addObjectParamsHelper(parameters, name, var_param_name);
3703 
3704  const auto n_threads = threaded ? libMesh::n_threads() : 1;
3705  std::vector<std::shared_ptr<T>> objects(n_threads);
3706  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
3707  {
3708  std::shared_ptr<T> obj = _factory.create<T>(type, name, parameters, tid);
3709  theWarehouse().add(obj);
3710  objects[tid] = std::move(obj);
3711  }
3712 
3713  return objects;
3714 }
3715 
3716 inline NonlinearSystemBase &
3717 FEProblemBase::getNonlinearSystemBase(const unsigned int sys_num)
3718 {
3719  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3720  return *_nl[sys_num];
3721 }
3722 
3723 inline const NonlinearSystemBase &
3724 FEProblemBase::getNonlinearSystemBase(const unsigned int sys_num) const
3725 {
3726  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3727  return *_nl[sys_num];
3728 }
3729 
3730 inline SolverSystem &
3731 FEProblemBase::getSolverSystem(const unsigned int sys_num)
3732 {
3733  mooseAssert(sys_num < _solver_systems.size(),
3734  "System number greater than the number of solver systems");
3735  return *_solver_systems[sys_num];
3736 }
3737 
3738 inline const SolverSystem &
3739 FEProblemBase::getSolverSystem(const unsigned int sys_num) const
3740 {
3741  mooseAssert(sys_num < _solver_systems.size(),
3742  "System number greater than the number of solver systems");
3743  return *_solver_systems[sys_num];
3744 }
3745 
3746 inline NonlinearSystemBase &
3747 FEProblemBase::currentNonlinearSystem()
3748 {
3749  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3750  return *_current_nl_sys;
3751 }
3752 
3753 inline const NonlinearSystemBase &
3754 FEProblemBase::currentNonlinearSystem() const
3755 {
3756  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3757  return *_current_nl_sys;
3758 }
3759 
3760 inline LinearSystem &
3761 FEProblemBase::getLinearSystem(const unsigned int sys_num)
3762 {
3763  mooseAssert(sys_num < _linear_systems.size(),
3764  "System number greater than the number of linear systems");
3765  return *_linear_systems[sys_num];
3766 }
3767 
3768 inline const LinearSystem &
3769 FEProblemBase::getLinearSystem(const unsigned int sys_num) const
3770 {
3771  mooseAssert(sys_num < _linear_systems.size(),
3772  "System number greater than the number of linear systems");
3773  return *_linear_systems[sys_num];
3774 }
3775 
3776 inline LinearSystem &
3777 FEProblemBase::currentLinearSystem()
3778 {
3779  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3780  return *_current_linear_sys;
3781 }
3782 
3783 inline const LinearSystem &
3784 FEProblemBase::currentLinearSystem() const
3785 {
3786  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3787  return *_current_linear_sys;
3788 }
3789 
3790 inline Assembly &
3791 FEProblemBase::assembly(const THREAD_ID tid, const unsigned int sys_num)
3792 {
3793  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3794  mooseAssert(sys_num < _assembly[tid].size(),
3795  "System number larger than the assembly container size");
3796  return *_assembly[tid][sys_num];
3797 }
3798 
3799 inline const Assembly &
3800 FEProblemBase::assembly(const THREAD_ID tid, const unsigned int sys_num) const
3801 {
3802  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3803  mooseAssert(sys_num < _assembly[tid].size(),
3804  "System number larger than the assembly container size");
3805  return *_assembly[tid][sys_num];
3806 }
3807 
3808 inline const libMesh::CouplingMatrix *
3809 FEProblemBase::couplingMatrix(const unsigned int i) const
3810 {
3811  return _cm[i].get();
3812 }
3813 
3814 inline void
3815 FEProblemBase::fvBCsIntegrityCheck(const bool fv_bcs_integrity_check)
3816 {
3817  if (!_fv_bcs_integrity_check)
3818  // the user has requested that we don't check integrity so we will honor that
3819  return;
3820 
3821  _fv_bcs_integrity_check = fv_bcs_integrity_check;
3822 }
3823 
3824 inline const std::vector<VectorTag> &
3825 FEProblemBase::currentResidualVectorTags() const
3826 {
3827  return _current_residual_vector_tags;
3828 }
3829 
3830 inline void
3831 FEProblemBase::setCurrentResidualVectorTags(const std::set<TagID> & vector_tags)
3832 {
3833  _current_residual_vector_tags = getVectorTags(vector_tags);
3834 }
3835 
3836 inline void
3837 FEProblemBase::clearCurrentResidualVectorTags()
3838 {
3839  _current_residual_vector_tags.clear();
3840 }
3841 
3842 #ifdef MOOSE_KOKKOS_ENABLED
3843 template <typename T>
3844 T &
3845 FEProblemBase::getKokkosFunction(const std::string & name)
3846 {
3847  if (!hasKokkosFunction(name))
3848  {
3849  // If we didn't find a function, it might be a default function, attempt to construct one now
3850  std::istringstream ss(name);
3851  Real real_value;
3852 
3853  // First see if it's just a constant. If it is, build a ConstantFunction
3854  if (ss >> real_value && ss.eof())
3855  {
3856  InputParameters params = _factory.getValidParams("KokkosConstantFunction");
3857  params.set<Real>("value") = real_value;
3858  addKokkosFunction("KokkosConstantFunction", ss.str(), params);
3859  }
3860 
3861  // Try once more
3862  if (!hasKokkosFunction(name))
3863  mooseError("Unable to find Kokkos function '" + name, "'");
3864  }
3865 
3866  auto * const ret = dynamic_cast<T *>(_kokkos_functions.getActiveObject(name).get());
3867  if (!ret)
3868  mooseError("No Kokkos function named '", name, "' of appropriate type");
3869 
3870  return *ret;
3871 }
3872 #endif
FEProblemBase::_reinit_displaced_elem
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
Definition: FEProblemBase.h:3320
FEProblemBase::initialized
bool initialized() const
Definition: FEProblemBase.h:168
FEProblemBase::addInterfaceMaterial
virtual void addInterfaceMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:4130
FEProblemBase::_nl_sys_name_to_num
std::map< NonlinearSystemName, unsigned int > _nl_sys_name_to_num
Map from nonlinear system name to number.
Definition: FEProblemBase.h:3117
FEProblemBase::setCurrentAlgebraicElementRange
void setCurrentAlgebraicElementRange(libMesh::ConstElemRange *range)
These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes tha...
Definition: FEProblemBase.C:10015
FEProblemBase::_point_zero
std::vector< Point > _point_zero
Definition: FEProblemBase.h:2509
RandomInterface
Interface for objects that need parallel consistent random numbers without patterns over the course o...
Definition: RandomInterface.h:28
FEProblemBase::computeJacobianTag
virtual void computeJacobianTag(const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, TagID tag)
Form a Jacobian matrix for a given tag.
Definition: FEProblemBase.C:7859
FEProblemBase::getCurrentICState
unsigned short getCurrentICState()
Retrieves the current initial condition state.
Definition: FEProblemBase.C:10049
FEProblemBase::resetFailNextNonlinearConvergenceCheck
void resetFailNextNonlinearConvergenceCheck()
Tell the problem that the nonlinear convergence check(s) may proceed as normal.
Definition: FEProblemBase.h:2867
FEProblemBase::_u_dot_requested
bool _u_dot_requested
Whether solution time derivative needs to be stored.
Definition: FEProblemBase.h:3562
FEProblemBase::finalizeMultiApps
void finalizeMultiApps()
Definition: FEProblemBase.C:6023
ScalarInitialConditionWarehouse
Warehouse for storing scalar initial conditions.
Definition: ScalarInitialConditionWarehouse.h:20
FEProblemBase::addFVInitialCondition
virtual void addFVInitialCondition(const std::string &ic_name, const std::string &name, InputParameters &parameters)
Add an initial condition for a finite volume variables.
Definition: FEProblemBase.C:3785
Moose::VarFieldType
VarFieldType
Definition: MooseTypes.h:770
FEProblemBase::addMaterialHelper
virtual void addMaterialHelper(std::vector< MaterialWarehouse *> warehouse, const std::string &material_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:4138
FEProblemBase::hasNeighborCoupling
virtual bool hasNeighborCoupling() const
Whether the simulation has neighbor coupling.
Definition: FEProblemBase.h:2659
FEProblemBase::hasVariable
virtual bool hasVariable(const std::string &var_name) const override
Whether or not this problem has the variable.
Definition: FEProblemBase.C:6224
FEProblemBase::mortarData
MortarInterfaceWarehouse & mortarData()
Definition: FEProblemBase.h:2654
FEProblemBase::setActiveMaterialProperties
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.
Definition: FEProblemBase.C:6439
FEProblemBase::shouldSolve
bool shouldSolve() const
Definition: FEProblemBase.h:2648
FEProblemBase::_regard_general_exceptions_as_errors
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...
Definition: FEProblemBase.h:3615
FEProblemBase::getNonlinearSystemNames
const std::vector< NonlinearSystemName > & getNonlinearSystemNames() const
Definition: FEProblemBase.h:2934
FEProblemBase::_num_nl_sys
const std::size_t _num_nl_sys
The number of nonlinear systems.
Definition: FEProblemBase.h:3111
FEProblemBase::setVariableAllDoFMap
void setVariableAllDoFMap(const std::vector< const MooseVariableFEBase *> &moose_vars)
Definition: FEProblemBase.C:1798
FEProblemBase::initPetscOutputAndSomeSolverSettings
virtual void initPetscOutputAndSomeSolverSettings()
Reinitialize PETSc output for proper linear/nonlinear iteration display.
Definition: FEProblemBase.C:7295
FEProblemBase::setKernelCoverageCheck
void setKernelCoverageCheck(CoverageCheckMode mode)
Set flag to indicate whether kernel coverage checks should be performed.
Definition: FEProblemBase.h:2209
FEProblemBase::getNonlinearConvergenceNames
const std::vector< ConvergenceName > & getNonlinearConvergenceNames() const
Gets the nonlinear system convergence object name(s).
Definition: FEProblemBase.C:9770
FEProblemBase::timestepSetup
void timestepSetup() override
Definition: FEProblemBase.C:1591
FEProblemBase::addSampler
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.
Definition: FEProblemBase.C:2875
FEProblemBase::_skip_exception_check
bool _skip_exception_check
If or not skip &#39;exception and stop solve&#39;.
Definition: FEProblemBase.h:3339
FEProblemBase::setUDotDotOldRequested
virtual void setUDotDotOldRequested(const bool u_dotdot_old_requested)
Set boolean flag to true to store old solution second time derivative.
Definition: FEProblemBase.h:2612
JacobianBlock
Helper class for holding the preconditioning blocks to fill.
Definition: ComputeJacobianBlocksThread.h:20
FEProblemBase::_reinit_displaced_neighbor
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
Definition: FEProblemBase.h:3324
FEProblemBase::meshChanged
virtual void meshChanged()
Deprecated.
Definition: FEProblemBase.h:2985
FEProblemBase::addDamper
virtual void addDamper(const std::string &damper_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:5689
FEProblemBase::_linear_sys_name_to_num
std::map< LinearSystemName, unsigned int > _linear_sys_name_to_num
Map from linear system name to number.
Definition: FEProblemBase.h:3099
Moose::Kokkos::Assembly
The Kokkos assembly class.
Definition: KokkosAssembly.h:28
FEProblemBase::getPetscOptions
Moose::PetscSupport::PetscOptions & getPetscOptions()
Retrieve a writable reference the PETSc options (used by PetscSupport)
Definition: FEProblemBase.h:676
FEProblemBase::getFVMatsAndDependencies
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.
Definition: FEProblemBase.C:9685
FEProblemBase::_ad_second_zero
std::vector< MooseArray< ADRealTensorValue > > _ad_second_zero
Definition: FEProblemBase.h:2507
FEProblemBase::dtOld
virtual Real & dtOld() const
Definition: FEProblemBase.h:578
FEProblemBase::_need_to_add_default_steady_state_convergence
bool _need_to_add_default_steady_state_convergence
Flag that the problem needs to add the default steady convergence.
Definition: FEProblemBase.h:3087
FEProblemBase::prepareFace
virtual void prepareFace(const Elem *elem, const THREAD_ID tid) override
Definition: FEProblemBase.C:1843
Function
Base class for function objects.
Definition: Function.h:29
FEProblemBase::setPreserveMatrixSparsityPattern
void setPreserveMatrixSparsityPattern(bool preserve)
Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian)...
Definition: FEProblemBase.C:4074
FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects
void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed=false)
Call when it is possible that the needs for ghosted elements has changed.
Definition: FEProblemBase.C:5662
FEProblemBase::addTransfer
virtual void addTransfer(const std::string &transfer_name, const std::string &name, InputParameters &parameters)
Add a Transfer to the problem.
Definition: FEProblemBase.C:6152
FEProblemBase::getSystem
virtual libMesh::System & getSystem(const std::string &var_name) override
Returns the equation system containing the variable provided.
Definition: FEProblemBase.C:6328
ExecFlagEnum
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:21
FEProblemBase::makeLinearSolverParams
static SolverParams makeLinearSolverParams()
Make basic solver params for linear solves.
Definition: FEProblemBase.C:10061
FEProblemBase::_snesmf_reuse_base_set_by_user
bool _snesmf_reuse_base_set_by_user
If or not _snesmf_reuse_base is set by user.
Definition: FEProblemBase.h:3342
FEProblemBase::_parallel_barrier_messaging
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.
Definition: FEProblemBase.h:3417
FEProblemBase::addResidualLower
virtual void addResidualLower(const THREAD_ID tid) override
Definition: FEProblemBase.C:1974
FEProblemBase::_computing_scaling_jacobian
bool _computing_scaling_jacobian
Flag used to indicate whether we are computing the scaling Jacobian.
Definition: FEProblemBase.h:3591
Restartable
A class for creating restricted objects.
Definition: Restartable.h:28
FEProblemBase::addJacobianLowerD
virtual void addJacobianLowerD(const THREAD_ID tid) override
Definition: FEProblemBase.C:2099
SubProblem::_factory
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1062
FEProblemBase::clearActiveScalarVariableCoupleableVectorTags
virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid) override
Definition: FEProblemBase.C:6430
FEProblemBase::_bnd_material_props
MaterialPropertyStorage & _bnd_material_props
Definition: FEProblemBase.h:3192
FEProblemBase::addGhostedElem
virtual void addGhostedElem(dof_id_type elem_id) override
Will make sure that all dofs connected to elem_id are ghosted to this processor.
Definition: FEProblemBase.C:2225
FEProblemBase::setNonlocalCouplingMatrix
void setNonlocalCouplingMatrix()
Set custom coupling matrix for variables requiring nonlocal contribution.
Definition: FEProblemBase.C:6656
FEProblemBase::setExecutionPrinting
void setExecutionPrinting(const ExecFlagEnum &print_exec)
Definition: FEProblemBase.h:2875
FEProblemBase::time
virtual Real & time() const
Definition: FEProblemBase.h:574
FEProblemBase::checkDependMaterialsHelper
void checkDependMaterialsHelper(const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase >>> &materials_map)
Helper method for checking Material object dependency.
Definition: FEProblemBase.C:9124
n_threads
unsigned int n_threads()
FEProblemBase::setNeedToAddDefaultSteadyStateConvergence
void setNeedToAddDefaultSteadyStateConvergence()
Sets _need_to_add_default_steady_state_convergence to true.
Definition: FEProblemBase.h:766
FEProblemBase::cacheResidualNeighbor
virtual void cacheResidualNeighbor(const THREAD_ID tid) override
Definition: FEProblemBase.C:1999
FEProblemBase::setInputParametersFEProblem
virtual void setInputParametersFEProblem(InputParameters &parameters)
Definition: FEProblemBase.h:1024
FEProblemBase::identifyVariableGroupsInNL
bool identifyVariableGroupsInNL() const
Whether to identify variable groups in nonlinear systems.
Definition: FEProblemBase.h:2926
FEProblemBase::_current_execute_on_flag
ExecFlagType _current_execute_on_flag
Current execute_on flag.
Definition: FEProblemBase.h:3432
FEProblemBase::clearCurrentResidualVectorTags
void clearCurrentResidualVectorTags()
Clear the current residual vector tag data structure.
Definition: FEProblemBase.h:3837
TheWarehouse::QueryCache
QueryCache is a convenient way to construct and pass around (possible partially constructed) warehous...
Definition: TheWarehouse.h:209
FEProblemBase::getUserObject
T & getUserObject(const std::string &name, unsigned int tid=0) const
Get the user object by its name.
Definition: FEProblemBase.h:1399
displaced_problem
std::shared_ptr< DisplacedProblem > displaced_problem
Definition: PetscDMMoose.C:1800
FEProblemBase::hasNonlocalCoupling
virtual bool hasNonlocalCoupling() const override
Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian...
Definition: FEProblemBase.h:2921
FEProblemBase::setNeedToAddDefaultMultiAppFixedPointConvergence
void setNeedToAddDefaultMultiAppFixedPointConvergence()
Sets _need_to_add_default_multiapp_fixed_point_convergence to true.
Definition: FEProblemBase.h:761
FEProblemBase::checkExceptionAndStopSolve
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...
Definition: FEProblemBase.C:6996
FEProblemBase::meshDisplaced
virtual void meshDisplaced()
Update data after a mesh displaced.
Definition: FEProblemBase.C:8853
FEProblemBase::uDotDotOldRequested
virtual bool uDotDotOldRequested()
Get boolean flag to check whether old solution second time derivative needs to be stored...
Definition: FEProblemBase.h:2635
FEProblemBase::_multiapp_fixed_point_convergence_name
std::optional< ConvergenceName > _multiapp_fixed_point_convergence_name
MultiApp fixed point convergence name.
Definition: FEProblemBase.h:3058
Assembly
Keeps track of stuff related to assembling.
Definition: Assembly.h:109
FEProblemBase::coordTransform
MooseAppCoordTransform & coordTransform()
Definition: FEProblemBase.C:9848
FEProblemBase::setActiveFEVariableCoupleableMatrixTags
virtual void setActiveFEVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid) override
Definition: FEProblemBase.C:6346
FEProblemBase::setCurrentAlgebraicNodeRange
void setCurrentAlgebraicNodeRange(libMesh::ConstNodeRange *range)
Definition: FEProblemBase.C:10026
FEProblemBase::_error_on_jacobian_nonzero_reallocation
bool _error_on_jacobian_nonzero_reallocation
Whether to error when the Jacobian is re-allocated, usually because the sparsity pattern changed...
Definition: FEProblemBase.h:3536
FEProblemBase::projectFunctionOnCustomRange
void projectFunctionOnCustomRange(ConstElemRange &elem_range, Number(*func)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), Gradient(*func_grad)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), const libMesh::Parameters &params, const std::vector< VariableName > &target_vars)
Project a function onto a range of elements for a given variable.
Definition: FEProblemBase.C:3967
TagID
unsigned int TagID
Definition: MooseTypes.h:238
FEProblemBase::reinitNode
virtual void reinitNode(const Node *node, const THREAD_ID tid) override
Definition: FEProblemBase.C:2385
FEProblemBase::numNonlinearSystems
virtual std::size_t numNonlinearSystems() const override
Definition: FEProblemBase.h:2822
FEProblemBase::predictorCleanup
virtual void predictorCleanup(NumericVector< libMesh::Number > &ghosted_solution)
Perform cleanup tasks after application of predictor to solution vector.
Definition: FEProblemBase.C:8367
FEProblemBase::prepare
virtual void prepare(const Elem *elem, const THREAD_ID tid) override
data_type
MPI_Datatype data_type
FEProblemBase::verboseMultiApps
bool verboseMultiApps() const
Whether or not to use verbose printing for MultiApps.
Definition: FEProblemBase.h:2250
FEProblemBase::getFunctionWarehouse
const MooseObjectWarehouse< Function > & getFunctionWarehouse()
Definition: FEProblemBase.h:2295
FEProblemBase::_has_jacobian
bool _has_jacobian
Indicates if the Jacobian was computed.
Definition: FEProblemBase.h:3351
FEProblemBase::haveFV
virtual bool haveFV() const override
returns true if this problem includes/needs finite volume functionality.
Definition: FEProblemBase.h:2919
blocks
char ** blocks
Definition: PetscDMMoose.C:1733
MeshDisplacedInterface
Interface for objects acting when the mesh has been displaced.
Definition: MeshDisplacedInterface.h:21
FEProblemBase::addKokkosLinearFVBC
virtual void addKokkosLinearFVBC(const std::string &bc_name, const std::string &name, InputParameters &parameters)
FEProblemBase::addKokkosMaterial
virtual void addKokkosMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters)
FEProblemBase::kokkosAssembly
const Moose::Kokkos::Assembly & kokkosAssembly() const
Definition: FEProblemBase.h:363
FEProblemBase::_internal_side_indicators
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
Definition: FEProblemBase.h:3215
FEProblemBase::_has_dampers
bool _has_dampers
Whether or not this system has any Dampers associated with it.
Definition: FEProblemBase.h:3330
FEProblemBase::_kernel_coverage_blocks
std::vector< SubdomainName > _kernel_coverage_blocks
Definition: FEProblemBase.h:3376
FEProblemBase::setUDotDotRequested
virtual void setUDotDotRequested(const bool u_dotdot_requested)
Set boolean flag to true to store solution second time derivative.
Definition: FEProblemBase.h:2600
FEProblemBase::getDistribution
virtual Distribution & getDistribution(const std::string &name)
Definition: FEProblemBase.C:2855
FEProblemBase::needsPreviousMultiAppFixedPointIterationSolution
void needsPreviousMultiAppFixedPointIterationSolution(bool needed, const unsigned int solver_sys_num)
Set a flag that indicated that user required values for the previous multiapp fixed point iterate for...
Definition: FEProblemBase.C:9429
FEProblemBase::haveDisplaced
bool haveDisplaced() const override final
Whether we have a displaced problem in our simulation.
Definition: FEProblemBase.h:2755
FEProblemBase::_has_nonlocal_coupling
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
Definition: FEProblemBase.h:3364
FEProblemBase::useHashTableMatrixAssembly
bool useHashTableMatrixAssembly() const
Definition: FEProblemBase.h:2960
FEProblemBase::_kokkos_mesh_initialization_hooks
std::vector< std::function< void()> > _kokkos_mesh_initialization_hooks
Container holding hooks for functions that need to be called after Kokkos mesh initialization.
Definition: FEProblemBase.h:3631
FEProblemBase::setCurrentAlgebraicBndNodeRange
void setCurrentAlgebraicBndNodeRange(ConstBndNodeRange *range)
Definition: FEProblemBase.C:10037
Sampler
This is the base class for Samplers as used within the Stochastic Tools module.
Definition: Sampler.h:45
FEProblemBase::areCoupled
bool areCoupled(const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const
Definition: FEProblemBase.C:6708
MaterialPropertyRegistry
Registry class for material property IDs and names.
Definition: MaterialPropertyRegistry.h:26
FEProblemBase::setPostprocessorValueByName
void setPostprocessorValueByName(const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
Set the value of a PostprocessorValue.
Definition: FEProblemBase.C:4894
FEProblemBase::addKokkosNodalKernel
virtual void addKokkosNodalKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags
virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid) override
Definition: FEProblemBase.C:6421
FEProblemBase::postExecute
virtual void postExecute()
Method called at the end of the simulation.
Definition: FEProblemBase.C:6032
FEProblemBase::addKokkosReporter
virtual void addKokkosReporter(const std::string &type, const std::string &name, InputParameters &parameters)
FEProblemBase::isSolverSystemNonlinear
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
Definition: FEProblemBase.h:2829
FEProblemBase::prepareKokkosMaterials
void prepareKokkosMaterials(const std::unordered_set< unsigned int > &consumer_needed_mat_props)
FEProblemBase::joinAndFinalize
void joinAndFinalize(TheWarehouse::Query query, bool isgen=false)
Definition: FEProblemBase.C:5219
FEProblemBase::_ad_grad_zero
std::vector< MooseArray< ADRealVectorValue > > _ad_grad_zero
Definition: FEProblemBase.h:2504
InitialConditionWarehouse
Warehouse for storing initial conditions.
Definition: InitialConditionWarehouse.h:20
FEProblemBase::_solver_params
std::vector< SolverParams > _solver_params
Definition: FEProblemBase.h:3372
FEProblemBase::addKokkosBoundaryCondition
virtual void addKokkosBoundaryCondition(const std::string &bc_name, const std::string &name, InputParameters &parameters)
FEProblemBase::getSolverSystemNames
const std::vector< SolverSystemName > & getSolverSystemNames() const
Definition: FEProblemBase.h:2942
FEProblemBase::_control_warehouse
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.
Definition: FEProblemBase.h:3435
FEProblemBase::reinitMaterialsFaceOnBoundary
void reinitMaterialsFaceOnBoundary(const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
reinit materials on element faces on a boundary (internal or external) This specific routine helps us...
Definition: FEProblemBase.C:4343
FEProblemBase::determineSolverSystem
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.
Definition: FEProblemBase.C:3058
FEProblemBase::_current_algebraic_node_range
std::unique_ptr< libMesh::ConstNodeRange > _current_algebraic_node_range
Definition: FEProblemBase.h:3453
FEProblemBase::setActiveScalarVariableCoupleableMatrixTags
virtual void setActiveScalarVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid) override
Definition: FEProblemBase.C:6364
FEProblemBase::setCoupling
void setCoupling(Moose::CouplingType type)
Set the coupling between variables TODO: allow user-defined coupling.
Definition: FEProblemBase.C:6615
FEProblemBase::getCurrentExecuteOnFlag
const ExecFlagType & getCurrentExecuteOnFlag() const
Return/set the current execution flag.
Definition: FEProblemBase.C:5051
FEProblemBase::_cycles_completed
unsigned int _cycles_completed
Definition: FEProblemBase.h:3307
FEProblemBase::reinitScalars
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
Definition: FEProblemBase.C:2435
FEProblemBase::uDotRequested
virtual bool uDotRequested()
Get boolean flag to check whether solution time derivative needs to be stored.
Definition: FEProblemBase.h:2618
FEProblemBase::init
virtual void init() override
Definition: FEProblemBase.C:6728
TheWarehouse::add
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
FEProblemBase::needFV
virtual void needFV() override
marks this problem as including/needing finite volume functionality.
Definition: FEProblemBase.h:2918
FEProblemBase::getDiracElements
virtual void getDiracElements(std::set< const Elem *> &elems) override
Fills "elems" with the elements that should be looped over for Dirac Kernels.
Definition: FEProblemBase.C:2586
FEProblemBase::parentOutputPositionChanged
void parentOutputPositionChanged()
Calls parentOutputPositionChanged() on all sub apps.
Definition: FEProblemBase.C:4958
FEProblemBase::addInterfaceKernel
virtual void addInterfaceKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3653
FEProblemBase::_is_petsc_options_inserted
bool _is_petsc_options_inserted
If or not PETSc options have been added to database.
Definition: FEProblemBase.h:3444
FEProblemBase::setCurrentlyComputingResidual
void setCurrentlyComputingResidual(bool currently_computing_residual) final
Set whether or not the problem is in the process of computing the residual.
Definition: FEProblemBase.C:9622
FEProblemBase::addMaterial
virtual void addMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:4122
FEProblemBase::lineSearch
virtual void lineSearch()
execute MOOSE line search
Definition: FEProblemBase.C:2813
FEProblemBase::checkNonlocalCouplingRequirement
virtual bool checkNonlocalCouplingRequirement() const override
Definition: FEProblemBase.C:10076
FEProblemBase::uDotDotRequested
virtual bool uDotDotRequested()
Get boolean flag to check whether solution second time derivative needs to be stored.
Definition: FEProblemBase.h:2621
FEProblemBase::_has_kokkos_objects
bool _has_kokkos_objects
Whether we have any Kokkos objects.
Definition: FEProblemBase.h:3625
MooseBase::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
FEProblemBase::_current_ic_state
unsigned short _current_ic_state
Definition: FEProblemBase.h:3461
FEProblemBase::mortarData
const MortarInterfaceWarehouse & mortarData() const
Returns the mortar data object.
Definition: FEProblemBase.h:2653
FEProblemBase::reinitNeighborPhys
virtual void reinitNeighborPhys(const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points, const THREAD_ID tid) override
FEProblemBase::_notify_when_mesh_displaces
std::vector< MeshDisplacedInterface * > _notify_when_mesh_displaces
Objects to be notified when the mesh displaces.
Definition: FEProblemBase.h:3258
FEProblemBase::trustUserCouplingMatrix
void trustUserCouplingMatrix()
Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a ...
Definition: FEProblemBase.C:6646
FEProblemBase::newAssemblyArray
virtual void newAssemblyArray(std::vector< std::shared_ptr< SolverSystem >> &solver_systems)
Definition: FEProblemBase.C:775
FEProblemBase::_uo_aux_state_check
const bool _uo_aux_state_check
Whether or not checking the state of uo/aux evaluation.
Definition: FEProblemBase.h:3397
FEProblemBase::addMeshDivision
virtual void addMeshDivision(const std::string &type, const std::string &name, InputParameters &params)
Add a MeshDivision.
Definition: FEProblemBase.C:2789
FEProblemBase::_computing_scaling_residual
bool _computing_scaling_residual
Flag used to indicate whether we are computing the scaling Residual.
Definition: FEProblemBase.h:3594
Moose::PetscSupport::PetscOptions
A struct for storing the various types of petsc options and values.
Definition: PetscSupport.h:44
FEProblemBase::computeMarkers
virtual void computeMarkers()
Definition: FEProblemBase.C:5018
FEProblemBase::reportMooseObjectDependency
void reportMooseObjectDependency(MooseObject *a, MooseObject *b)
Register a MOOSE object dependency so we can either order operations properly or report when we canno...
Definition: FEProblemBase.C:5656
FEProblemBase::residualSetup
void residualSetup() override
Definition: FEProblemBase.C:9820
Moose::MaterialDataType
MaterialDataType
MaterialData types.
Definition: MooseTypes.h:740
FEProblemBase::onlyAllowDefaultNonlinearConvergence
virtual bool onlyAllowDefaultNonlinearConvergence() const
Returns true if an error will result if the user supplies &#39;nonlinear_convergence&#39;.
Definition: FEProblemBase.h:795
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition: InputParameters.h:1596
Positions
Positions objects are under the hood Reporters.
Definition: Positions.h:20
FEProblemBase::reinitMortarUserObjects
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...
Definition: FEProblemBase.C:9920
Factory::create
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:142
FEProblemBase::reinitNodes
virtual void reinitNodes(const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
Definition: FEProblemBase.C:2413
FEProblemBase::updateActiveObjects
virtual void updateActiveObjects()
Update the active objects in the warehouses.
Definition: FEProblemBase.C:5625
MaterialPropertyStorage
Stores the stateful material properties computed by materials.
Definition: MaterialPropertyStorage.h:43
FEProblemBase::getRestartableEquationSystems
const RestartableEquationSystems & getRestartableEquationSystems() const
Get the RestartableEquationSystems object.
Definition: FEProblemBase.C:6340
FEProblemBase::computeIndicatorsAndMarkers
virtual void computeIndicatorsAndMarkers()
Definition: FEProblemBase.C:4969
FEProblemBase::reinitMaterialsBoundary
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: FEProblemBase.C:4433
Marker
Definition: Marker.h:41
FEProblemBase::addJacobianOffDiagScalar
virtual void addJacobianOffDiagScalar(unsigned int ivar, const THREAD_ID tid=0)
Definition: FEProblemBase.C:2113
FEProblemBase::setCheckResidualForNans
void setCheckResidualForNans(bool check_residual_for_nans)
Setter for residual NaN/Inf checking.
Definition: FEProblemBase.h:234
FEProblemBase::setException
virtual void setException(const std::string &message)
Set an exception, which is stored at this point by toggling a member variable in this class...
Definition: FEProblemBase.C:6989
FEProblemBase::addJacobian
virtual void addJacobian(const THREAD_ID tid) override
Definition: FEProblemBase.C:2069
FEProblemBase::CreateTaggedMatrixKey::CreateTaggedMatrixKey
CreateTaggedMatrixKey(const CreateTaggedMatrixKey &)
Definition: FEProblemBase.h:2953
FEProblemBase::addAuxScalarKernel
virtual void addAuxScalarKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3490
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition: Factory.C:68
FVAdvectedInterpolationMethod
Interface for interpolation methods that provide matrix and RHS contributions for advected face value...
Definition: FVAdvectedInterpolationMethod.h:22
FEProblemBase::setErrorOnJacobianNonzeroReallocation
void setErrorOnJacobianNonzeroReallocation(bool state)
Definition: FEProblemBase.h:2371
FEProblemBase::getKokkosFESystems
const Moose::Kokkos::Array< Moose::Kokkos::FESystem > & getKokkosFESystems() const
Definition: FEProblemBase.h:886
FEProblemBase::_has_kokkos_residual_objects
bool _has_kokkos_residual_objects
Whether we have any Kokkos residual objects.
Definition: FEProblemBase.h:3628
FEProblemBase::_petsc_option_data_base
PetscOptions _petsc_option_data_base
Definition: FEProblemBase.h:3440
FEProblemBase::currentResidualVectorTags
virtual const std::vector< VectorTag > & currentResidualVectorTags() const override
Return the residual vector tags we are currently computing.
Definition: FEProblemBase.h:3825
FEProblemBase::needBoundaryMaterialOnSide
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...
Definition: FEProblemBase.C:9308
FEProblemBase::getKokkosNeighborMaterialPropertyStorage
Moose::Kokkos::MaterialPropertyStorage & getKokkosNeighborMaterialPropertyStorage()
Definition: FEProblemBase.h:2074
FEProblemBase::_current_residual_vector_tags
std::vector< VectorTag > _current_residual_vector_tags
A data member to store the residual vector tag(s) passed into computeResidualTag(s).
Definition: FEProblemBase.h:3608
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Definition: InputParameters.h:67
FEProblemBase::_material_coverage_blocks
std::vector< SubdomainName > _material_coverage_blocks
Definition: FEProblemBase.h:3388
FEProblemBase::setSteadyStateConvergenceName
void setSteadyStateConvergenceName(const ConvergenceName &convergence_name)
Sets the steady-state detection convergence object name if there is one.
Definition: FEProblemBase.C:9764
FEProblemBase::addAuxScalarVariable
virtual void addAuxScalarVariable(const std::string &var_name, libMesh::Order order, Real scale_factor=1., const std::set< SubdomainID > *const active_subdomains=NULL)
Definition: FEProblemBase.C:3444
FEProblemBase::systemBaseLinear
virtual const SystemBase & systemBaseLinear(unsigned int sys_num) const override
Get a constant base class reference to a linear system.
Definition: FEProblemBase.C:9568
FEProblemBase::logAdd
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.
Definition: FEProblemBase.C:4527
FEProblemBase::hasScalarVariable
virtual bool hasScalarVariable(const std::string &var_name) const override
Returns a Boolean indicating whether any system contains a variable with the name provided...
Definition: FEProblemBase.C:6304
TransientMultiApp
MultiApp Implementation for Transient Apps.
Definition: TransientMultiApp.h:23
FEProblemBase::getKokkosBndMaterialPropertyStorage
Moose::Kokkos::MaterialPropertyStorage & getKokkosBndMaterialPropertyStorage()
Definition: FEProblemBase.h:2070
FEProblemBase::resizeMaterialData
void resizeMaterialData(Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)
Resize material data.
Definition: FEProblemBase.C:9741
FVInitialConditionWarehouse
Warehouse for storing finite volume initial conditions.
Definition: FVInitialConditionWarehouse.h:20
FEProblemBase::finishMultiAppStep
void finishMultiAppStep(ExecFlagType type, bool recurse_through_multiapp_levels=false)
Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.
Definition: FEProblemBase.C:6051
FEProblemBase::addFunctorMaterial
virtual void addFunctorMaterial(const std::string &functor_material_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:4092
FEProblemBase::addKokkosUserObject
virtual void addKokkosUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
FEProblemBase::hasKokkosFunction
virtual bool hasKokkosFunction(const std::string &name) const
Get whether a Kokkos function exists.
FVInterpolationMethod
Registered base class for linear FV interpolation objects.
Definition: FVInterpolationMethod.h:17
FEProblemBase::_second_zero
std::vector< VariableSecond > _second_zero
Definition: FEProblemBase.h:2506
FEProblemBase::_solver_var_to_sys_num
std::map< SolverVariableName, unsigned int > _solver_var_to_sys_num
Map connecting variable names with their respective solver systems.
Definition: FEProblemBase.h:3129
FEProblemBase::_ad_zero
std::vector< MooseArray< ADReal > > _ad_zero
Definition: FEProblemBase.h:2502
FEProblemBase::getKokkosMaterialPropertyStorage
Moose::Kokkos::MaterialPropertyStorage & getKokkosMaterialPropertyStorage()
Definition: FEProblemBase.h:2066
FEProblemBase::prepareAssemblyNeighbor
virtual void prepareAssemblyNeighbor(const THREAD_ID tid)
Begin a fresh neighbor accumulation phase by sizing and zeroing the neighbor blocks.
Definition: FEProblemBase.C:1945
FEProblemBase::_requires_nonlocal_coupling
bool _requires_nonlocal_coupling
nonlocal coupling requirement flag
Definition: FEProblemBase.h:3621
FEProblemBase::onTimestepEnd
virtual void onTimestepEnd() override
Definition: FEProblemBase.C:7311
FEProblemBase::computeNearNullSpace
virtual void computeNearNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
Definition: FEProblemBase.C:8195
FEProblemBase::addNodalKernel
virtual void addNodalKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3186
FEProblemBase::_solver_systems
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
Definition: FEProblemBase.h:3126
Distribution
All Distributions should inherit from this class.
Definition: Distribution.h:18
FEProblemBase::_kokkos_materials
MaterialWarehouse _kokkos_materials
Definition: FEProblemBase.h:3208
FEProblemBase::hasKokkosUserObject
bool hasKokkosUserObject(const std::string &name) const
Check if there if a Kokkos user object of given name.
FEProblemBase::_vector_curl_zero
std::vector< VectorVariableCurl > _vector_curl_zero
Definition: FEProblemBase.h:2511
FEProblemBase::hasMortarCoupling
virtual bool hasMortarCoupling() const
Whether the simulation has mortar coupling.
Definition: FEProblemBase.h:2664
SideUserObject
Base class for user objects executed one or more sidesets, which may be on the outer boundary of the ...
Definition: SideUserObject.h:25
FEProblemBase::_has_exception
bool _has_exception
Whether or not an exception has occurred.
Definition: FEProblemBase.h:3414
FEProblemBase::_num_grid_steps
unsigned int _num_grid_steps
Number of steps in a grid sequence.
Definition: FEProblemBase.h:3584
FEProblemBase::_needs_old_newton_iter
bool _needs_old_newton_iter
Indicates that we need to compute variable values for previous Newton iteration.
Definition: FEProblemBase.h:3354
FEProblemBase::haveXFEM
bool haveXFEM()
Find out whether the current analysis is using XFEM.
Definition: FEProblemBase.h:2146
FEProblemBase::addJacobianBlockTags
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)
Definition: FEProblemBase.C:2144
FEProblemBase::registerRandomInterface
void registerRandomInterface(RandomInterface &random_interface, const std::string &name)
Definition: FEProblemBase.C:9298
FEProblemBase::_has_time_integrator
bool _has_time_integrator
Indicates whether or not this executioner has a time integrator (during setup)
Definition: FEProblemBase.h:3411
FEProblemBase::computeUserObjectsInternal
void computeUserObjectsInternal(const ExecFlagType &type, TheWarehouse::Query &query)
Definition: FEProblemBase.C:5361
MooseVariableFieldBase
This class provides an interface for common operations on field variables of both FE and FV types wit...
Definition: MooseVariableFieldBase.h:29
FEProblemBase::getMultiAppWarehouse
ExecuteMooseObjectWarehouse< MultiApp > & getMultiAppWarehouse()
Definition: FEProblemBase.h:2541
FEProblemBase::addAuxKernel
virtual void addAuxKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3478
FEProblemBase::_material_prop_registry
MaterialPropertyRegistry _material_prop_registry
Definition: FEProblemBase.h:3190
FEProblemBase::kokkosAssembly
Moose::Kokkos::Assembly & kokkosAssembly()
Definition: FEProblemBase.h:362
FEProblemBase::clearActiveMaterialProperties
void clearActiveMaterialProperties(const THREAD_ID tid)
Clear the active material properties.
Definition: FEProblemBase.C:6460
FEProblemBase::nLinearIterations
virtual unsigned int nLinearIterations(const unsigned int nl_sys_num) const override
Definition: FEProblemBase.C:7140
MaterialWarehouse
MaterialBase objects are special in that they have additional objects created automatically (see FEPr...
Definition: MaterialWarehouse.h:26
FEProblemBase::_transient_multi_apps
ExecuteMooseObjectWarehouse< TransientMultiApp > _transient_multi_apps
Storage for TransientMultiApps (only needed for calling &#39;computeDT&#39;)
Definition: FEProblemBase.h:3228
FEProblemBase::_kokkos_assembly
Moose::Kokkos::Assembly _kokkos_assembly
Definition: FEProblemBase.h:3158
FEProblemBase::_interface_materials
MaterialWarehouse _interface_materials
Definition: FEProblemBase.h:3203
FEProblemBase::hasUserObject
bool hasUserObject(const std::string &name) const
Check if there if a user object of given name.
Definition: FEProblemBase.C:4774
libMesh
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
FEProblemBase::_ignore_zeros_in_jacobian
bool _ignore_zeros_in_jacobian
Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.
Definition: FEProblemBase.h:3543
FEProblemBase::kokkosJoinAndFinalize
void kokkosJoinAndFinalize(const std::vector< Moose::Kokkos::UserObject *> &userobjs)
FEProblemBase::getCurrentAlgebraicElementRange
const libMesh::ConstElemRange & getCurrentAlgebraicElementRange()
These are the element and nodes that contribute to the jacobian and residual for this local processor...
Definition: FEProblemBase.C:9990
FEProblemBase::setCurrentExecuteOnFlag
void setCurrentExecuteOnFlag(const ExecFlagType &)
Definition: FEProblemBase.C:5057
FEProblemBase::getMaterialWarehouse
const MaterialWarehouse & getMaterialWarehouse() const
Definition: FEProblemBase.h:2300
FEProblemBase::computeResidualInternal
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.
Definition: FEProblemBase.C:7646
FEProblemBase::initElementStatefulProps
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...
Definition: FEProblemBase.C:8860
FEProblemBase::getCurrentAlgebraicNodeRange
const libMesh::ConstNodeRange & getCurrentAlgebraicNodeRange()
Definition: FEProblemBase.C:9998
FEProblemBase::computingScalingJacobian
void computingScalingJacobian(bool computing_scaling_jacobian)
Setter for whether we&#39;re computing the scaling jacobian.
Definition: FEProblemBase.h:2796
FEProblemBase::_from_multi_app_transfers
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
Definition: FEProblemBase.h:3237
FEProblemBase::checkResidualForNans
virtual bool checkResidualForNans() const override
Whether to check residual for NaN/Inf values.
Definition: FEProblemBase.h:231
FEProblemBase::addKernel
virtual void addKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3154
SystemBase
Base class for a system (of equations)
Definition: SystemBase.h:85
FEProblemBase::getInitialConditionWarehouse
const InitialConditionWarehouse & getInitialConditionWarehouse() const
Return InitialCondition storage.
Definition: FEProblemBase.h:2096
FEProblemBase::getKokkosMaterialPropertyStorageConsumers
const std::set< const MooseObject * > & getKokkosMaterialPropertyStorageConsumers(Moose::MaterialDataType type) const
FEProblemBase::addAuxVariable
virtual void addAuxVariable(const std::string &var_type, const std::string &var_name, InputParameters &params)
Canonical method for adding an auxiliary variable.
Definition: FEProblemBase.C:3327
Moose::Kokkos::System
The Kokkos base system class.
Definition: KokkosSystem.h:30
FEProblemBase::_steady_state_convergence_name
std::optional< ConvergenceName > _steady_state_convergence_name
Steady-state detection convergence name.
Definition: FEProblemBase.h:3060
MeshDivision
Base class for MeshDivision objects.
Definition: MeshDivision.h:35
FEProblemBase::getBndMaterialPropertyStorage
const MaterialPropertyStorage & getBndMaterialPropertyStorage()
Definition: FEProblemBase.h:2059
FEProblemBase::_previous_multiapp_fp_nl_solution_required
std::vector< bool > _previous_multiapp_fp_nl_solution_required
Indicates we need to save the previous multiapp fixed-point iteration solver variable values...
Definition: FEProblemBase.h:3359
FEProblemBase::_kokkos_functions
MooseObjectWarehouse< Moose::FunctionBase > _kokkos_functions
Definition: FEProblemBase.h:3170
SubProblem::computingNonlinearResid
bool computingNonlinearResid() const
Returns true if the problem is in the process of computing the nonlinear residual.
Definition: SubProblem.h:715
FEProblemBase::addFVInterfaceKernel
virtual void addFVInterfaceKernel(const std::string &fv_ik_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3624
FEProblemBase::getMeshDivision
MeshDivision & getMeshDivision(const std::string &name, const THREAD_ID tid=0) const
Get a MeshDivision.
Definition: FEProblemBase.C:2804
FEProblemBase::getNumCyclesCompleted
unsigned int getNumCyclesCompleted()
Definition: FEProblemBase.h:2126
MortarUserObject
Base class for creating new nodally-based mortar user objects.
Definition: MortarUserObject.h:21
FEProblemBase::hasDampers
bool hasDampers()
Whether or not this system has dampers.
Definition: FEProblemBase.h:1624
FEProblemBase::getPositionsObject
const Positions & getPositionsObject(const std::string &name) const
Get the Positions object by its name.
Definition: FEProblemBase.C:4759
FEProblemBase::_solver_sys_name_to_num
std::map< SolverSystemName, unsigned int > _solver_sys_name_to_num
Map connecting solver system names with their respective systems.
Definition: FEProblemBase.h:3132
FEProblemBase::FEProblemBase
FEProblemBase(const InputParameters &parameters)
Definition: FEProblemBase.C:401
FEProblemBase::setFailNextNonlinearConvergenceCheck
void setFailNextNonlinearConvergenceCheck()
Skip further residual evaluations and fail the next nonlinear convergence check(s) ...
Definition: FEProblemBase.h:2862
FEProblemBase::getExecutor
virtual Executor & getExecutor(const std::string &name)
Definition: FEProblemBase.h:2438
FEProblemBase::cacheJacobianNeighbor
virtual void cacheJacobianNeighbor(const THREAD_ID tid) override
Definition: FEProblemBase.C:2128
FEProblemBase
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Definition: FEProblemBase.h:157
FEProblemBase::needToAddDefaultSteadyStateConvergence
bool needToAddDefaultSteadyStateConvergence() const
Returns true if the problem needs to add the default steady-state detection convergence.
Definition: FEProblemBase.h:751
FEProblemBase::_bnd_mat_side_cache
std::vector< std::unordered_map< BoundaryID, bool > > _bnd_mat_side_cache
Cache for calculating materials on side.
Definition: FEProblemBase.h:3249
FEProblemBase::_have_fv
bool _have_fv
Whether we are performing some calculations with finite volume discretizations.
Definition: FEProblemBase.h:3611
FEProblemBase::hasLinearConvergenceObjects
bool hasLinearConvergenceObjects() const
Whether we have linear convergence objects.
Definition: FEProblemBase.C:9778
FEProblemBase::_print_execution_on
ExecFlagEnum _print_execution_on
When to print the execution of loops.
Definition: FEProblemBase.h:3600
FEProblemBase::needsPreviousMultiAppFixedPointIterationAuxiliary
bool needsPreviousMultiAppFixedPointIterationAuxiliary() const
Check to see whether we need to compute the variable values of the previous multiapp fixed point iter...
Definition: FEProblemBase.C:9449
FEProblemBase::setResidual
virtual void setResidual(NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
Definition: FEProblemBase.C:2049
FEProblemBase::petscOptionsInserted
bool & petscOptionsInserted()
If PETSc options are already inserted.
Definition: FEProblemBase.h:2590
FEProblemBase::solve
virtual void solve(const unsigned int nl_sys_num)
Definition: FEProblemBase.C:6927
FEProblemBase::setCurrentLowerDElem
virtual void setCurrentLowerDElem(const Elem *const lower_d_elem, const THREAD_ID tid) override
Set the current lower dimensional element.
Definition: FEProblemBase.C:9942
FEProblemBase::_linear_matrix_tags
std::set< TagID > _linear_matrix_tags
Temporary storage for filtered matrix tags for linear systems.
Definition: FEProblemBase.h:3070
FEProblemBase::bumpAllQRuleOrder
void bumpAllQRuleOrder(libMesh::Order order, SubdomainID block)
Definition: FEProblemBase.C:6565
FEProblemBase::computeMultiAppsDT
Real computeMultiAppsDT(ExecFlagType type)
Find the smallest timestep over all MultiApps.
Definition: FEProblemBase.C:6125
FEProblemBase::setParallelBarrierMessaging
void setParallelBarrierMessaging(bool flag)
Toggle parallel barrier messaging (defaults to on).
Definition: FEProblemBase.h:2242
FEProblemBase::projectSolution
void projectSolution()
Definition: FEProblemBase.C:3826
FEProblemBase::getRegularMaterialsWarehouse
const MaterialWarehouse & getRegularMaterialsWarehouse() const
Definition: FEProblemBase.h:2305
FEProblemBase::getVariable
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...
Definition: FEProblemBase.C:6246
FEProblemBase::reinitMaterialsFace
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
Definition: FEProblemBase.C:4311
FEProblemBase::_nl_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange > _nl_evaluable_local_elem_range
Definition: FEProblemBase.h:3449
FEProblemBase::computeResidualTags
virtual void computeResidualTags(const std::set< TagID > &tags)
Form multiple residual vectors and each is associated with one tag.
Definition: FEProblemBase.C:7765
SubProblem::currentlyComputingResidual
const bool & currentlyComputingResidual() const
Returns true if the problem is in the process of computing the residual.
Definition: SubProblem.h:728
FEProblemBase::setMaterialCoverageCheck
void setMaterialCoverageCheck(CoverageCheckMode mode)
Set flag to indicate whether material coverage checks should be performed.
Definition: FEProblemBase.h:2226
FEProblemBase::computeJacobianSys
virtual void computeJacobianSys(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian)
Form a Jacobian matrix.
Definition: FEProblemBase.C:7849
FEProblemBase::skipNextForwardSolutionCopyToOld
void skipNextForwardSolutionCopyToOld()
Prevents the copy of the solution vector to the old solution vector in each system.
Definition: FEProblemBase.C:7168
FEProblemBase::getMultiApp
std::shared_ptr< MultiApp > getMultiApp(const std::string &multi_app_name) const
Get a MultiApp object by name.
Definition: FEProblemBase.C:5856
FEProblemBase::reinitElemNeighborAndLowerD
virtual void reinitElemNeighborAndLowerD(const Elem *elem, unsigned int side, const THREAD_ID tid) override
Definition: FEProblemBase.C:2499
FEProblemBase::hasSolverVariable
bool hasSolverVariable(const std::string &var_name) const
Definition: FEProblemBase.C:6236
Moose::AuxGroup
AuxGroup
Flag for AuxKernel related execution type.
Definition: MooseTypes.h:752
FEProblemBase::addMarker
virtual void addMarker(const std::string &marker_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:5763
MortarInterfaceConfig
Per-mortar-interface configuration.
Definition: MortarInterfaceWarehouse.h:35
FEProblemBase::subspaceDim
unsigned int subspaceDim(const std::string &prefix) const
Dimension of the subspace spanned by vectors with a given prefix.
Definition: FEProblemBase.h:2284
FEProblemBase::geomSearchData
virtual GeometricSearchData & geomSearchData() override
Definition: FEProblemBase.h:2037
FEProblemBase::setUDotOldRequested
virtual void setUDotOldRequested(const bool u_dot_old_requested)
Set boolean flag to true to store old solution time derivative.
Definition: FEProblemBase.h:2606
FEProblemBase::needsPreviousNewtonIteration
bool needsPreviousNewtonIteration() const
Check to see whether we need to compute the variable values of the previous Newton iterate...
Definition: FEProblemBase.C:9415
FEProblemBase::addBoundaryCondition
virtual void addBoundaryCondition(const std::string &bc_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3256
FEProblemBase::couplingMatrix
const libMesh::CouplingMatrix * couplingMatrix(const unsigned int nl_sys_num) const override
The coupling matrix defining what blocks exist in the preconditioning matrix.
Definition: FEProblemBase.h:3809
FEProblemBase::computingPreSMOResidual
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. ...
Definition: FEProblemBase.C:7152
AutomaticMortarGeneration
This class is a container/interface for the objects involved in automatic generation of mortar spaces...
Definition: AutomaticMortarGeneration.h:68
FEProblemBase::assembly
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override
Definition: FEProblemBase.h:3791
Moose::Kokkos::Function
The abstract class that provides polymorphic interfaces for a function.
Definition: KokkosFunction.h:147
FEProblemBase::createTagMatrices
void createTagMatrices(CreateTaggedMatrixKey)
Definition: FEProblemBase.C:714
FEProblemBase::_skip_nl_system_check
const bool _skip_nl_system_check
Definition: FEProblemBase.h:3549
FEProblemBase::resetState
virtual void resetState()
Reset state of this object in preparation for the next evaluation.
Definition: FEProblemBase.C:7060
FEProblemBase::addCachedResidualDirectly
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...
Definition: FEProblemBase.C:2015
FEProblemBase::addInitialCondition
virtual void addInitialCondition(const std::string &ic_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3725
FEProblemBase::addKokkosPostprocessor
virtual void addKokkosPostprocessor(const std::string &pp_name, const std::string &name, InputParameters &parameters)
FEProblemBase::_scalar_ics
ScalarInitialConditionWarehouse _scalar_ics
Definition: FEProblemBase.h:3186
FEProblemBase::computeLinearSystemSys
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. ...
Definition: FEProblemBase.C:8086
NonlinearSystemBase
Nonlinear system to be solved.
Definition: NonlinearSystemBase.h:68
FEProblemBase::skipExceptionCheck
void skipExceptionCheck(bool skip_exception_check)
Set a flag that indicates if we want to skip exception and stop solve.
Definition: FEProblemBase.h:2577
FEProblemBase::getKokkosSystem
Moose::Kokkos::System & getKokkosSystem(const unsigned int sys_num)
Get the Kokkos System of a specified number.
FEProblemBase::swapBackMaterialsFace
virtual void swapBackMaterialsFace(const THREAD_ID tid)
Definition: FEProblemBase.C:4490
FEProblemBase::addDistribution
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.
Definition: FEProblemBase.C:2834
FEProblemBase::advanceState
virtual void advanceState()
Advance all of the state holding vectors / datastructures so that we can move to the next timestep...
Definition: FEProblemBase.C:7176
NodalUserObject
A user object that runs over all the nodes and does an aggregation step to compute a single value...
Definition: NodalUserObject.h:24
FEProblemBase::_transfers
ExecuteMooseObjectWarehouse< Transfer > _transfers
Normal Transfers.
Definition: FEProblemBase.h:3231
FEProblemBase::setAuxKernelParamsAndLog
void setAuxKernelParamsAndLog(const std::string &ak_name, const std::string &name, InputParameters &parameters, const std::string &base_name)
Set the subproblem and system parameters for auxiliary kernels and log their addition.
Definition: FEProblemBase.C:3118
FEProblemBase::checkUserObjectNameCollision
void checkUserObjectNameCollision(const std::string &name, const std::string &type) const
Check for name collision between different user objects.
Definition: FEProblemBase.C:4591
FEProblemBase::getVectorPostprocessorValueByName
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.
Definition: FEProblemBase.C:4911
MooseLinearConvergenceReason
MooseLinearConvergenceReason
Definition: FEProblemBase.h:129
FEProblemBase::getFunction
virtual Function & getFunction(const std::string &name, const THREAD_ID tid=0)
Definition: FEProblemBase.C:2715
FEProblemBase::addPredictor
virtual void addPredictor(const std::string &type, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:7372
FEProblemBase::computeJacobianBlocks
virtual void computeJacobianBlocks(std::vector< JacobianBlock *> &blocks, const unsigned int nl_sys_num)
Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditio...
Definition: FEProblemBase.C:8010
FEProblemBase::addLineSearch
virtual void addLineSearch(const InputParameters &)
add a MOOSE line search
Definition: FEProblemBase.h:816
FEProblemBase::copySolutionsBackwards
virtual void copySolutionsBackwards()
Definition: FEProblemBase.C:7158
FEProblemBase::getCurrentAlgebraicBndNodeRange
const ConstBndNodeRange & getCurrentAlgebraicBndNodeRange()
Definition: FEProblemBase.C:10006
FEProblemBase::_calculate_jacobian_in_uo
bool _calculate_jacobian_in_uo
Definition: FEProblemBase.h:3365
FEProblemBase::reinitElemFaceRef
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...
Definition: FEProblemBase.C:9655
FEProblemBase::prepareFaceShapes
virtual void prepareFaceShapes(unsigned int var, const THREAD_ID tid) override
Definition: FEProblemBase.C:2213
FEProblemBase::addPostprocessor
virtual void addPostprocessor(const std::string &pp_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:4612
FEProblemBase::finalNonlinearResidual
virtual Real finalNonlinearResidual(const unsigned int nl_sys_num) const override
Definition: FEProblemBase.C:7146
FEProblemBase::_nl
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
Definition: FEProblemBase.h:3114
SubProblem::automaticScaling
bool automaticScaling() const
Automatic scaling getter.
Definition: SubProblem.C:1163
FEProblemBase::computeUserObjects
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
Definition: FEProblemBase.C:5336
FEProblemBase::setActiveElementalMooseVariables
virtual void setActiveElementalMooseVariables(const std::set< MooseVariableFEBase *> &moose_vars, const THREAD_ID tid) override
Set the MOOSE variables to be reinited on each element.
Definition: FEProblemBase.C:6384
FEProblemBase::getInterfaceMaterialsWarehouse
const MaterialWarehouse & getInterfaceMaterialsWarehouse() const
Definition: FEProblemBase.h:2307
FEProblemBase::_grad_phi_zero
std::vector< VariablePhiGradient > _grad_phi_zero
Definition: FEProblemBase.h:2505
FEProblemBase::getUserObjectJacobianVariables
const std::vector< const MooseVariableFEBase * > & getUserObjectJacobianVariables(const THREAD_ID tid) const
Definition: FEProblemBase.h:353
FEProblemBase::getDiscreteMaterialWarehouse
const MaterialWarehouse & getDiscreteMaterialWarehouse() const
Definition: FEProblemBase.h:2306
FEProblemBase::hasJacobian
bool hasJacobian() const
Returns _has_jacobian.
Definition: FEProblemBase.C:9455
FEProblemBase::notifyWhenMeshDisplaces
void notifyWhenMeshDisplaces(MeshDisplacedInterface *mdi)
Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh ge...
Definition: FEProblemBase.C:8847
FEProblemBase::createTagSolutions
void createTagSolutions()
Create extra tagged solution vectors.
Definition: FEProblemBase.C:730
FEProblemBase::_solver_sys_names
std::vector< SolverSystemName > _solver_sys_names
The union of nonlinear and linear system names.
Definition: FEProblemBase.h:3135
FEProblemBase::execute
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
Definition: FEProblemBase.C:5118
FEProblemBase::_verbose_restore
bool _verbose_restore
Whether or not to be verbose on solution restoration post a failed time step.
Definition: FEProblemBase.h:3426
FEProblemBase::_previous_nl_solution_required
bool _previous_nl_solution_required
Indicates we need to save the previous NL iteration variable values.
Definition: FEProblemBase.h:3357
FEProblemBase::_trust_user_coupling_matrix
bool _trust_user_coupling_matrix
Whether to trust the user coupling matrix no matter what.
Definition: FEProblemBase.h:3588
FEProblemBase::getSteadyStateConvergenceName
const ConvergenceName & getSteadyStateConvergenceName() const
Gets the steady-state detection convergence object name.
Definition: FEProblemBase.C:9811
FEProblemBase::handleException
void handleException(const std::string &calling_method)
Handle exceptions.
Definition: FEProblemBase.C:7710
FEProblemBase::getVariableNames
virtual std::vector< VariableName > getVariableNames()
Returns a list of all the variables in the problem (both from the NL and Aux systems.
Definition: FEProblemBase.C:9266
FEProblemBase::_reporter_data
ReporterData _reporter_data
Definition: FEProblemBase.h:3222
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
FEProblemBase::uniformRefine
void uniformRefine()
uniformly refine the problem mesh(es).
Definition: FEProblemBase.C:9630
FEProblemBase::hasSetMultiAppFixedPointConvergenceName
bool hasSetMultiAppFixedPointConvergenceName() const
Returns true if the problem has set the fixed point convergence name.
Definition: FEProblemBase.h:771
FEProblemBase::computeResidualSys
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.
Definition: FEProblemBase.C:7438
FEProblemBase::getReporterData
const ReporterData & getReporterData() const
Provides const access the ReporterData object.
Definition: FEProblemBase.h:1380
FEProblemBase::nonlocalCouplingMatrix
virtual const libMesh::CouplingMatrix & nonlocalCouplingMatrix(const unsigned i) const override
Definition: FEProblemBase.C:10070
FEProblemBase::_current_algebraic_elem_range
std::unique_ptr< libMesh::ConstElemRange > _current_algebraic_elem_range
Definition: FEProblemBase.h:3452
FEProblemBase::_immediately_print_invalid_solution
const bool & _immediately_print_invalid_solution
Definition: FEProblemBase.h:3553
FEProblemBase::getTransfers
std::vector< std::shared_ptr< Transfer > > getTransfers(ExecFlagType type, Transfer::DIRECTION direction) const
Get Transfers by ExecFlagType and direction.
Definition: FEProblemBase.C:5935
FEProblemBase::hasSetSteadyStateConvergenceName
bool hasSetSteadyStateConvergenceName() const
Returns true if the problem has set the steady-state detection convergence name.
Definition: FEProblemBase.h:776
FEProblemBase::addConvergence
virtual void addConvergence(const std::string &type, const std::string &name, InputParameters &parameters)
Adds a Convergence object.
Definition: FEProblemBase.C:2661
FEProblemBase::shouldPrintExecution
bool shouldPrintExecution(const THREAD_ID tid) const
Check whether the problem should output execution orders at this time.
Definition: FEProblemBase.C:9876
FEProblemBase::_kokkos_fe_systems
Moose::Kokkos::Array< Moose::Kokkos::FESystem > _kokkos_fe_systems
FESystem array - sparsely populated (only slots for systems needing a Kokkos::FESystem) ...
Definition: FEProblemBase.h:3147
FEProblemBase::_solve
const bool & _solve
Whether or not to actually solve the nonlinear system.
Definition: FEProblemBase.h:3073
FEProblemBase::systemBaseSolver
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.
Definition: FEProblemBase.C:9584
FEProblemBase::_to_multi_app_transfers
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
Definition: FEProblemBase.h:3234
FEProblemBase::_current_nl_sys
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
Definition: FEProblemBase.h:3120
FEProblemBase::_check_residual_for_nans
bool _check_residual_for_nans
Whether to check the residual for NaN or Inf values.
Definition: FEProblemBase.h:3401
FEProblemBase::_convergences
MooseObjectWarehouse< Convergence > _convergences
convergence warehouse
Definition: FEProblemBase.h:3174
MeshChangedInterface
Interface for notifications that the mesh has changed.
Definition: MeshChangedInterface.h:21
FEProblemBase::setCurrentNonlinearSystem
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
Definition: FEProblemBase.C:9959
FEProblemBase::getDisplacedProblem
virtual std::shared_ptr< DisplacedProblem > getDisplacedProblem()
Definition: FEProblemBase.h:1993
MooseObjectWarehouseBase::getActiveObject
std::shared_ptr< T > getActiveObject(const std::string &name, THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:630
KernelBase
This is the common base class for the three main kernel types implemented in MOOSE, Kernel, VectorKernel and ArrayKernel.
Definition: KernelBase.h:23
FEProblemBase::numGridSteps
void numGridSteps(unsigned int num_grid_steps)
Set the number of steps in a grid sequences.
Definition: FEProblemBase.h:2675
Convergence
Base class for convergence criteria.
Definition: Convergence.h:21
FEProblemBase::hasFVInterpolationMethod
bool hasFVInterpolationMethod(const InterpolationMethodName &name) const
Check if an FV interpolation method with a given name exists.
Definition: FEProblemBase.C:4848
FEProblemBase::_input_file_saved
bool _input_file_saved
whether input file has been written
Definition: FEProblemBase.h:3327
FEProblemBase::reinitElem
virtual void reinitElem(const Elem *elem, const THREAD_ID tid) override
Definition: FEProblemBase.C:2313
FEProblemBase::getConvergence
virtual Convergence & getConvergence(const std::string &name, const THREAD_ID tid=0) const
Gets a Convergence object.
Definition: FEProblemBase.C:2773
FEProblemBase::theWarehouse
TheWarehouse & theWarehouse() const
Definition: FEProblemBase.h:2559
FEProblemBase::createTagVectors
void createTagVectors()
Create extra tagged vectors and matrices.
Definition: FEProblemBase.C:692
FEProblemBase::createQRules
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)
Definition: FEProblemBase.C:6578
FEProblemBase::reinitMaterialsNeighbor
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
Definition: FEProblemBase.C:4393
FEProblemBase::setMultiAppFixedPointConvergenceName
void setMultiAppFixedPointConvergenceName(const ConvergenceName &convergence_name)
Sets the MultiApp fixed point convergence object name if there is one.
Definition: FEProblemBase.C:9758
FEProblemBase::addKokkosMeshInitializationHook
void addKokkosMeshInitializationHook(std::function< void()> function)
Add a function hook that needs to be called after Kokkos mesh initialization.
Definition: FEProblemBase.h:2975
FEProblemBase::computeKokkosUserObjectsInternal
void computeKokkosUserObjectsInternal(const ExecFlagType &type, TheWarehouse::Query &query)
FEProblemBase::checkUserObjects
void checkUserObjects()
Definition: FEProblemBase.C:9089
FEProblemBase::_coupling
Moose::CouplingType _coupling
Type of variable coupling.
Definition: FEProblemBase.h:3140
MooseObject
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:28
FEProblemBase::getKokkosUserObject
const T & getKokkosUserObject(const std::string &name) const
Get the Kokkos user object by its name.
Definition: FEProblemBase.h:1439
FEProblemBase::shouldUpdateSolution
virtual bool shouldUpdateSolution()
Check to see whether the problem should update the solution.
Definition: FEProblemBase.C:8354
FEProblemBase::getFVInterpolationMethod
const FVInterpolationMethod & getFVInterpolationMethod(const InterpolationMethodName &name, const THREAD_ID tid=0) const
Retrieve an FV interpolation method.
Definition: FEProblemBase.C:4787
FEProblemBase::getMultiAppFixedPointConvergenceName
const ConvergenceName & getMultiAppFixedPointConvergenceName() const
Gets the MultiApp fixed point convergence object name.
Definition: FEProblemBase.C:9802
FEProblemBase::getTimeFromStateArg
Real getTimeFromStateArg(const Moose::StateArg &state) const
Returns the time associated with the requested state.
Definition: FEProblemBase.C:7316
FEProblemBase::solverTypeString
virtual std::string solverTypeString(unsigned int solver_sys_num=0)
Return solver type as a human readable string.
Definition: FEProblemBase.C:10055
EXEC_TIMESTEP_BEGIN
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
FEProblemBase::executeSamplers
void executeSamplers(const ExecFlagType &exec_type)
Performs setup and execute calls for Sampler objects.
Definition: FEProblemBase.C:5601
FEProblemBase::computeJacobianInternal
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.
Definition: FEProblemBase.C:7889
FEProblemBase::computeJacobian
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).
Definition: FEProblemBase.C:7873
FEProblemBase::reinitMaterialsNeighborOnBoundary
void reinitMaterialsNeighborOnBoundary(const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specif...
Definition: FEProblemBase.C:4376
FEProblemBase::getUOExecutionGroups
void getUOExecutionGroups(TheWarehouse::Query &query, std::set< int > &execution_groups) const
Definition: FEProblemBase.C:5293
FEProblemBase::addOutput
void addOutput(const std::string &, const std::string &, InputParameters &)
Adds an Output object.
Definition: FEProblemBase.C:9467
BoundaryID
boundary_id_type BoundaryID
Definition: AutomaticMortarGeneration.h:52
FEProblemBase::getInternalSideIndicatorWarehouse
const MooseObjectWarehouse< InternalSideIndicatorBase > & getInternalSideIndicatorWarehouse()
Definition: FEProblemBase.h:2086
FEProblemBase::setUDotRequested
virtual void setUDotRequested(const bool u_dot_requested)
Set boolean flag to true to store solution time derivative.
Definition: FEProblemBase.h:2597
FEProblemBase::_allow_ics_during_restart
const bool _allow_ics_during_restart
Definition: FEProblemBase.h:3548
FEProblemBase::constJacobian
bool constJacobian() const
Returns _const_jacobian (whether a MOOSE object has specified that the Jacobian is the same as the pr...
Definition: FEProblemBase.C:9461
FEProblemBase::clearActiveFEVariableCoupleableMatrixTags
virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid) override
Definition: FEProblemBase.C:6403
FEProblemBase::_notify_when_mesh_changes
std::vector< MeshChangedInterface * > _notify_when_mesh_changes
Objects to be notified when the mesh changes.
Definition: FEProblemBase.h:3255
FEProblemBase::checkNonlocalCoupling
void checkNonlocalCoupling()
Definition: FEProblemBase.C:1721
FEProblemBase::addDefaultSteadyStateConvergence
void addDefaultSteadyStateConvergence(const InputParameters &params)
Adds the default steady-state detection Convergence.
Definition: FEProblemBase.C:2698
Moose::VarKindType
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:763
FEProblemBase::currentNonlinearSystem
NonlinearSystemBase & currentNonlinearSystem()
Definition: FEProblemBase.h:3747
FEProblemBase::computingScalingResidual
void computingScalingResidual(bool computing_scaling_residual)
Setter for whether we&#39;re computing the scaling residual.
Definition: FEProblemBase.h:2806
FEProblemBase::checkDisplacementOrders
void checkDisplacementOrders()
Verify that SECOND order mesh uses SECOND order displacements.
Definition: FEProblemBase.C:9048
FEProblemBase::addFunction
virtual void addFunction(const std::string &type, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:2635
PostprocessorValue
Real PostprocessorValue
various MOOSE typedefs
Definition: MooseTypes.h:230
FEProblemBase::addJacobianNeighbor
virtual void addJacobianNeighbor(const THREAD_ID tid) override
Definition: FEProblemBase.C:2083
FEProblemBase::es
virtual libMesh::EquationSystems & es() override
Definition: FEProblemBase.h:180
FEProblemBase::_block_mat_side_cache
std::vector< std::unordered_map< SubdomainID, bool > > _block_mat_side_cache
Cache for calculating materials on side.
Definition: FEProblemBase.h:3246
FEProblemBase::hasTimeIntegrator
bool hasTimeIntegrator() const
Returns whether or not this Problem has a TimeIntegrator.
Definition: FEProblemBase.h:2419
FEProblemBase::_aux
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
Definition: FEProblemBase.h:3138
Gradient
NumberVectorValue Gradient
TheWarehouse
TheWarehouse is a container for MooseObjects that allows querying/filtering over various customizeabl...
Definition: TheWarehouse.h:186
FEProblemBase::addVectorPostprocessor
virtual void addVectorPostprocessor(const std::string &pp_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:4622
FEProblemBase::_allow_invalid_solution
const bool _allow_invalid_solution
Definition: FEProblemBase.h:3551
MooseMesh
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:94
FEProblemBase::currentNlSysNum
virtual unsigned int currentNlSysNum() const override
Definition: FEProblemBase.C:9854
FEProblemBase::getMaterialPropertyStorage
const MaterialPropertyStorage & getMaterialPropertyStorage()
Return a reference to the material property storage.
Definition: FEProblemBase.h:2058
FEProblemBase::computeIndicators
virtual void computeIndicators()
Definition: FEProblemBase.C:4976
FEProblemBase::hasInitialAdaptivity
bool hasInitialAdaptivity() const
Return a Boolean indicating whether initial AMR is turned on.
Definition: FEProblemBase.h:2131
FEProblemBase::getScalarVariable
virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the scalar variable reference from whichever system contains it.
Definition: FEProblemBase.C:6316
FEProblemBase::objectSetupHelper
static void objectSetupHelper(const std::vector< T *> &objects, const ExecFlagType &exec_flag)
Helpers for calling the necessary setup/execute functions for the supplied objects.
Definition: FEProblemBase.h:3650
FEProblemBase::_boundary_restricted_node_integrity_check
const bool _boundary_restricted_node_integrity_check
whether to perform checking of boundary restricted nodal object variable dependencies, e.g.
Definition: FEProblemBase.h:3380
FEProblemBase::setActiveScalarVariableCoupleableVectorTags
virtual void setActiveScalarVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid) override
Definition: FEProblemBase.C:6374
FEProblemBase::_mesh
MooseMesh & _mesh
Definition: FEProblemBase.h:3003
FEProblemBase::uDotOldRequested
virtual bool uDotOldRequested()
Get boolean flag to check whether old solution time derivative needs to be stored.
Definition: FEProblemBase.h:2624
FEProblemBase::updateMeshXFEM
virtual bool updateMeshXFEM()
Update the mesh due to changing XFEM cuts.
Definition: FEProblemBase.C:8654
FEProblemBase::systemBaseNonlinear
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.
Definition: FEProblemBase.C:9554
FEProblemBase::getMortarUserObjects
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...
Definition: FEProblemBase.C:9890
FEProblemBase::restoreSolutions
virtual void restoreSolutions()
Definition: FEProblemBase.C:7217
FEProblemBase::fvBCsIntegrityCheck
bool fvBCsIntegrityCheck() const
Definition: FEProblemBase.h:2725
FEProblemBase::hasConvergence
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.
Definition: FEProblemBase.C:2767
FEProblemBase::_u_dotdot_old_requested
bool _u_dotdot_old_requested
Whether old solution second time derivative needs to be stored.
Definition: FEProblemBase.h:3571
FEProblemBase::setFailNextSystemConvergenceCheck
void setFailNextSystemConvergenceCheck()
Tell the problem that the system(s) cannot be considered converged next time convergence is checked...
Definition: FEProblemBase.h:2864
FEProblemBase::addAnyRedistributers
void addAnyRedistributers()
Definition: FEProblemBase.C:6466
SolutionInvalidInterface::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Definition: SolutionInvalidInterface.h:87
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
FEProblemBase::hasPostprocessorValueByName
bool hasPostprocessorValueByName(const PostprocessorName &name) const
Whether or not a Postprocessor value exists by a given name.
Definition: FEProblemBase.C:4861
FEProblemBase::setAxisymmetricCoordAxis
void setAxisymmetricCoordAxis(const MooseEnum &rz_coord_axis)
Definition: FEProblemBase.C:874
FEProblemBase::initialSetup
void initialSetup() override
Definition: FEProblemBase.C:914
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:54
Moose::Kokkos::FESystem
The Kokkos FE system class.
Definition: KokkosFESystem.h:27
FEProblemBase::_adaptivity
Adaptivity _adaptivity
Definition: FEProblemBase.h:3306
SubProblem::getVectorTags
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Definition: SubProblem.C:173
FEProblemBase::allowInvalidSolution
bool allowInvalidSolution() const
Whether to accept / allow an invalid solution.
Definition: FEProblemBase.h:2406
FEProblemBase::needInternalNeighborSideMaterial
bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, const THREAD_ID tid)
Definition: FEProblemBase.C:9384
FEProblemBase::systemBaseAuxiliary
virtual const SystemBase & systemBaseAuxiliary() const override
Return the auxiliary system object as a base class reference.
Definition: FEProblemBase.C:9600
FEProblemBase::setLinearConvergenceNames
void setLinearConvergenceNames(const std::vector< ConvergenceName > &convergence_names)
Sets the linear convergence object name(s) if there is one.
Definition: FEProblemBase.C:9786
FEProblemBase::checkUserObjectJacobianRequirement
void checkUserObjectJacobianRequirement(THREAD_ID tid)
Definition: FEProblemBase.C:1759
FEProblemBase::getActualFieldVariable
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...
Definition: FEProblemBase.C:6268
FEProblemBase::getLineSearch
LineSearch * getLineSearch() override
getter for the MOOSE line search
Definition: FEProblemBase.h:829
FEProblemBase::hasDistribution
virtual bool hasDistribution(const std::string &name) const
Definition: FEProblemBase.C:2843
FEProblemBase::reinitKokkosMaterials
void reinitKokkosMaterials()
FEProblemBase::computeNullSpace
virtual void computeNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
Definition: FEProblemBase.C:8212
FEProblemBase::addTimeIntegrator
virtual void addTimeIntegrator(const std::string &type, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:7337
FEProblemBase::_current_linear_sys
LinearSystem * _current_linear_sys
The current linear system that we are solving.
Definition: FEProblemBase.h:3102
FEProblemBase::cacheResidual
virtual void cacheResidual(const THREAD_ID tid) override
Definition: FEProblemBase.C:1991
FEProblemBase::computeResidualType
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.
Definition: FEProblemBase.C:7679
FEProblemBase::_force_restart
const bool _force_restart
Definition: FEProblemBase.h:3547
FEProblemBase::forceOutput
void forceOutput()
Indicates that the next call to outputStep should be forced.
Definition: FEProblemBase.C:7289
FEProblemBase::getVectorPostprocessorObjectByName
const VectorPostprocessor & getVectorPostprocessorObjectByName(const std::string &object_name, const THREAD_ID tid=0) const
Return the VPP object given the name.
Definition: FEProblemBase.C:4930
FEProblemBase::_second_phi_zero
std::vector< VariablePhiSecond > _second_phi_zero
Definition: FEProblemBase.h:2508
FEProblemBase::_started_initial_setup
bool _started_initial_setup
At or beyond initialSteup stage.
Definition: FEProblemBase.h:3556
FEProblemBase::_random_data_objects
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
Definition: FEProblemBase.h:3243
FEProblemBase::errorOnJacobianNonzeroReallocation
bool errorOnJacobianNonzeroReallocation() const
Will return True if the user wants to get an error when a nonzero is reallocated in the Jacobian by P...
Definition: FEProblemBase.h:2366
FEProblemBase::_current_algebraic_bnd_node_range
std::unique_ptr< ConstBndNodeRange > _current_algebraic_bnd_node_range
Definition: FEProblemBase.h:3454
FEProblemBase::addResidual
virtual void addResidual(const THREAD_ID tid) override
Definition: FEProblemBase.C:1954
FEProblemBase::getNonlinearSystemBase
NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num)
Definition: FEProblemBase.h:3717
FEProblemBase::addResidualNeighbor
virtual void addResidualNeighbor(const THREAD_ID tid) override
Definition: FEProblemBase.C:1964
FEProblemBase::addKokkosAuxKernel
virtual void addKokkosAuxKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
FEProblemBase::reinitNeighborFaceRef
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...
Definition: FEProblemBase.C:9670
Postprocessor
Base class for all Postprocessors.
Definition: Postprocessor.h:23
FEProblemBase::needSolutionState
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...
Definition: FEProblemBase.C:756
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:375
FEProblemBase::coupling
Moose::CouplingType coupling() const
Definition: FEProblemBase.h:196
FEProblemBase::clearActiveFEVariableCoupleableVectorTags
virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid) override
Definition: FEProblemBase.C:6412
FEProblemBase::setCouplingMatrix
void setCouplingMatrix(std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)
Set custom coupling matrix.
Definition: FEProblemBase.C:6639
FEProblemBase::addDefaultNonlinearConvergence
virtual void addDefaultNonlinearConvergence(const InputParameters &params)
Adds the default nonlinear Convergence associated with the problem.
Definition: FEProblemBase.C:2675
SubProblem::getVariable
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...
FEProblemBase::setNonlinearConvergenceNames
void setNonlinearConvergenceNames(const std::vector< ConvergenceName > &convergence_names)
Sets the nonlinear convergence object name(s) if there is one.
Definition: FEProblemBase.C:9749
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
FEProblemBase::solverSystemConverged
virtual bool solverSystemConverged(const unsigned int solver_sys_num) override
Definition: FEProblemBase.C:7125
FEProblemBase::_exception_message
std::string _exception_message
The error message to go with an exception.
Definition: FEProblemBase.h:3429
FEProblemBase::setNeedToAddDefaultNonlinearConvergence
void setNeedToAddDefaultNonlinearConvergence()
Sets _need_to_add_default_nonlinear_convergence to true.
Definition: FEProblemBase.h:756
FEProblemBase::checkProblemIntegrity
virtual void checkProblemIntegrity()
Method called to perform a series of sanity checks before a simulation is run.
Definition: FEProblemBase.C:8876
FEProblemBase::getAuxiliarySystem
AuxiliarySystem & getAuxiliarySystem()
Definition: FEProblemBase.h:1072
FEProblemBase::updateGeomSearch
virtual void updateGeomSearch(GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
Update this object&#39;s geometric search data as well as the displaced problem&#39;s if it exists...
Definition: FEProblemBase.C:8381
FEProblemBase::_mesh_divisions
MooseObjectWarehouse< MeshDivision > _mesh_divisions
Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the ...
Definition: FEProblemBase.h:3164
FEProblemBase::addConstraint
virtual void addConstraint(const std::string &c_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3274
FEProblemBase::_indicators
MooseObjectWarehouse< Indicator > _indicators
Definition: FEProblemBase.h:3214
FEProblemBase::addMultiApp
virtual void addMultiApp(const std::string &multi_app_name, const std::string &name, InputParameters &parameters)
Add a MultiApp to the problem.
Definition: FEProblemBase.C:5800
Moose::Kokkos::MaterialPropertyStorage
The Kokkos class responsible for allocating and storing Kokkos material properties.
Definition: KokkosMaterialPropertyStorage.h:27
FEProblemBase::prepareAssembly
virtual void prepareAssembly(const THREAD_ID tid) override
Definition: FEProblemBase.C:1929
SubProblem::haveADObjects
bool haveADObjects() const
Method for reading wehther we have any ad objects.
Definition: SubProblem.h:779
FEProblemBase::systemNumForVariable
unsigned int systemNumForVariable(const VariableName &variable_name) const
Definition: FEProblemBase.C:6912
FEProblemBase::_checking_uo_aux_state
bool _checking_uo_aux_state
Flag used to indicate whether we are doing the uo/aux state check in execute.
Definition: FEProblemBase.h:3597
FEProblemBase::couplingEntries
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > & couplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num)
Definition: FEProblemBase.C:6716
FEProblemBase::getPostprocessorValueByName
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.
Definition: FEProblemBase.C:4886
FEProblemBase::_fv_bcs_integrity_check
bool _fv_bcs_integrity_check
Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset...
Definition: FEProblemBase.h:3391
FEProblemBase::getIndicatorWarehouse
const MooseObjectWarehouse< Indicator > & getIndicatorWarehouse()
Return indicator/marker storage.
Definition: FEProblemBase.h:2085
ScalarInitialCondition
InitialConditions are objects that set the initial value of variables.
Definition: ScalarInitialCondition.h:33
FEProblemBase::showInvalidSolutionConsole
bool showInvalidSolutionConsole() const
Whether or not to print out the invalid solutions summary table in console.
Definition: FEProblemBase.h:2411
InternalSideUserObject
Base class for user objects executed on all element sides internal to one or more blocks...
Definition: InternalSideUserObject.h:23
FEProblemBase::initNullSpaceVectors
virtual void initNullSpaceVectors(const InputParameters &parameters, std::vector< std::shared_ptr< NonlinearSystemBase >> &nl)
Definition: FEProblemBase.C:789
FEProblemBase::setCurrentSubdomainID
virtual void setCurrentSubdomainID(const Elem *elem, const THREAD_ID tid) override
Definition: FEProblemBase.C:1890
FEProblemBase::getMaterialData
MaterialData & getMaterialData(Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const
Definition: FEProblemBase.C:4029
FEProblemBase::getFailNextSystemConvergenceCheck
bool getFailNextSystemConvergenceCheck() const
Whether it will fail the next system convergence check(s), triggering failed step behavior...
Definition: FEProblemBase.h:2859
FEProblemBase::clearDiracInfo
virtual void clearDiracInfo() override
Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in...
Definition: FEProblemBase.C:2605
FEProblemBase::addIndicator
virtual void addIndicator(const std::string &indicator_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:5720
FEProblemBase::reinitNodesNeighbor
virtual void reinitNodesNeighbor(const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
Definition: FEProblemBase.C:2424
FEProblemBase::duplicateVariableCheck
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.
Definition: FEProblemBase.C:2910
FEProblemBase::getKokkosFESystem
Moose::Kokkos::FESystem & getKokkosFESystem(const unsigned int sys_num)
Get the Kokkos FESystem of a specified number.
GeometricSearchData::GeometricSearchType
GeometricSearchType
Used to select groups of geometric search objects to update.
Definition: GeometricSearchData.h:32
FEProblemBase::backupMultiApps
void backupMultiApps(ExecFlagType type)
Backup the MultiApps associated with the ExecFlagType.
Definition: FEProblemBase.C:6073
FEProblemBase::~FEProblemBase
virtual ~FEProblemBase()
Definition: FEProblemBase.C:830
SolutionInvalidity
The SolutionInvalidity will contain all the information about the occurrence(s) of solution invalidit...
Definition: SolutionInvalidity.h:37
FEProblemBase::getKokkosMaterialData
MaterialData & getKokkosMaterialData(Moose::MaterialDataType type, const MooseObject *object=nullptr) const
FEProblemBase::addVariable
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters &params)
Canonical method for adding a non-linear variable.
Definition: FEProblemBase.C:3021
FEProblemBase::getLinearSystemNames
const std::vector< LinearSystemName > & getLinearSystemNames() const
Definition: FEProblemBase.h:2938
FEProblemBase::_multi_apps
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
Definition: FEProblemBase.h:3225
FEProblemBase::timeStep
virtual int & timeStep() const
Definition: FEProblemBase.h:576
FEProblemBase::feBackend
virtual Moose::FEBackend feBackend() const
Definition: FEProblemBase.h:2948
FEProblemBase::getLinearSystem
LinearSystem & getLinearSystem(unsigned int sys_num)
Get non-constant reference to a linear system.
Definition: FEProblemBase.h:3761
FEProblemBase::_assembly
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
Definition: FEProblemBase.h:3155
FEProblemBase::addDisplacedProblem
virtual void addDisplacedProblem(std::shared_ptr< DisplacedProblem > displaced_problem)
Definition: FEProblemBase.C:8372
FEProblemBase::computeResidual
void computeResidual(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
This function is called by Libmesh to form a residual.
FEProblemBase::objectExecuteHelper
static void objectExecuteHelper(const std::vector< T *> &objects)
Definition: FEProblemBase.h:3684
FEProblemBase::setResidualObjectParamsAndLog
void setResidualObjectParamsAndLog(const std::string &ro_name, const std::string &name, InputParameters &parameters, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
Set the subproblem and system parameters for residual objects and log their addition.
Definition: FEProblemBase.C:3085
FEProblemBase::setVectorPostprocessorValueByName
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.
Definition: FEProblemBase.C:4920
FEProblemBase::getStandardVariable
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.
Definition: FEProblemBase.C:6256
FEProblemBase::setCoordSystem
void setCoordSystem(const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
Definition: FEProblemBase.C:866
Material
Materials compute MaterialProperties.
Definition: Material.h:35
FEProblemBase::swapBackMaterialsNeighbor
virtual void swapBackMaterialsNeighbor(const THREAD_ID tid)
Definition: FEProblemBase.C:4498
FEProblemBase::_show_invalid_solution_console
const bool _show_invalid_solution_console
Definition: FEProblemBase.h:3552
FEProblemBase::addLinearFVKernel
virtual void addLinearFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3635
FEProblemBase::_aux_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange > _aux_evaluable_local_elem_range
Definition: FEProblemBase.h:3450
FEProblemBase::getNonlinearSystem
virtual NonlinearSystem & getNonlinearSystem(const unsigned int sys_num)
Definition: FEProblemBase.C:2819
FEProblemBase::_snesmf_reuse_base
bool _snesmf_reuse_base
If or not to resuse the base vector for matrix-free calculation.
Definition: FEProblemBase.h:3336
FEProblemBase::reinitDirac
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.
Definition: FEProblemBase.C:2258
FEProblemBase::setKernelCoverageCheck
void setKernelCoverageCheck(bool flag)
Set flag to indicate whether kernel coverage checks should be performed.
Definition: FEProblemBase.h:2215
XFEMInterface
This is the XFEMInterface class.
Definition: XFEMInterface.h:37
FEProblemBase::_need_to_add_default_multiapp_fixed_point_convergence
bool _need_to_add_default_multiapp_fixed_point_convergence
Flag that the problem needs to add the default fixed point convergence.
Definition: FEProblemBase.h:3085
FEProblemBase::_nl_sys_names
const std::vector< NonlinearSystemName > _nl_sys_names
The nonlinear system names.
Definition: FEProblemBase.h:3108
EXEC_NONLINEAR
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
FEProblemBase::getFVAdvectedInterpolationMethod
const FVAdvectedInterpolationMethod & getFVAdvectedInterpolationMethod(const InterpolationMethodName &name, const THREAD_ID tid=0) const
Retrieve an advected interpolation method.
Definition: FEProblemBase.C:4831
VectorPostprocessorValue
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:231
FEProblemBase::getFVInitialConditionWarehouse
const FVInitialConditionWarehouse & getFVInitialConditionWarehouse() const
Return FVInitialCondition storage.
Definition: FEProblemBase.h:2101
FEProblemBase::updateMortarMesh
virtual void updateMortarMesh()
Definition: FEProblemBase.C:8392
AddTaggedMatricesAction
Adds tagged matrices.
Definition: AddTaggedMatricesAction.h:19
FEProblemBase::addKokkosVectorPostprocessor
virtual void addKokkosVectorPostprocessor(const std::string &pp_name, const std::string &name, InputParameters &parameters)
FEProblemBase::getUOQuery
TheWarehouse::Query getUOQuery(const std::string &system, const ExecFlagType &type, const Moose::AuxGroup &group) const
Definition: FEProblemBase.C:5275
FEProblemBase::addDefaultMultiAppFixedPointConvergence
void addDefaultMultiAppFixedPointConvergence(const InputParameters &params)
Adds the default fixed point Convergence associated with the problem.
Definition: FEProblemBase.C:2687
FEProblemBase::_fe_matrix_tags
std::set< TagID > _fe_matrix_tags
Definition: FEProblemBase.h:3064
FEProblemBase::_kokkos_material_props
Moose::Kokkos::MaterialPropertyStorage & _kokkos_material_props
Definition: FEProblemBase.h:3196
FEProblemBase::addAuxArrayVariable
virtual void addAuxArrayVariable(const std::string &var_name, const libMesh::FEType &type, unsigned int components, const std::set< SubdomainID > *const active_subdomains=NULL)
Definition: FEProblemBase.C:3410
FEProblemBase::getMultiAppTransferWarehouse
const ExecuteMooseObjectWarehouse< Transfer > & getMultiAppTransferWarehouse(Transfer::DIRECTION direction) const
Return the complete warehouse for MultiAppTransfer object for the given direction.
Definition: FEProblemBase.C:5957
FEProblemBase::getSystemBase
virtual const SystemBase & getSystemBase(const unsigned int sys_num) const
Get constant reference to a system in this problem.
Definition: FEProblemBase.C:9524
FEProblemBase::reinitLowerDElem
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
Definition: FEProblemBase.C:2372
FEProblemBase::isSNESMFReuseBaseSetbyUser
bool isSNESMFReuseBaseSetbyUser()
Return a flag to indicate if _snesmf_reuse_base is set by users.
Definition: FEProblemBase.h:2585
FEProblemBase::addReporter
virtual void addReporter(const std::string &type, const std::string &name, InputParameters &parameters)
Add a Reporter object to the simulation.
Definition: FEProblemBase.C:4632
FEProblemBase::swapBackMaterials
virtual void swapBackMaterials(const THREAD_ID tid)
Definition: FEProblemBase.C:4483
FEProblemBase::_phi_zero
std::vector< VariablePhiValue > _phi_zero
Definition: FEProblemBase.h:2501
FEProblemBase::_ics
InitialConditionWarehouse _ics
Definition: FEProblemBase.h:3184
FEProblemBase::_has_active_material_properties
std::vector< unsigned char > _has_active_material_properties
Whether there are active material properties on each thread.
Definition: FEProblemBase.h:3370
Moose::ANY_BLOCK_ID
const SubdomainID ANY_BLOCK_ID
Definition: MooseTypes.C:19
FEProblemBase::_discrete_materials
MaterialWarehouse _discrete_materials
Definition: FEProblemBase.h:3204
FEProblemBase::_reinit_displaced_face
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
Definition: FEProblemBase.h:3322
Moose::PetscSupport::setSinglePetscOption
void setSinglePetscOption(const std::string &name, const std::string &value="", FEProblemBase *const problem=nullptr)
A wrapper function for dealing with different versions of PetscOptionsSetValue.
Definition: PetscSupport.C:1139
FEProblemBase::_mortar_data
std::unique_ptr< MortarInterfaceWarehouse > _mortar_data
Definition: FEProblemBase.h:3317
FEProblemBase::addDGKernel
virtual void addDGKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3562
FEProblemBase::setCurrentBoundaryID
virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid) override
sets the current boundary ID in assembly
Definition: FEProblemBase.C:9951
FEProblemBase::_current_solver_sys
SolverSystem * _current_solver_sys
The current solver system.
Definition: FEProblemBase.h:3123
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
FEProblemBase::getDisplacedProblem
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
Definition: FEProblemBase.h:1989
Adaptivity
Takes care of everything related to mesh adaptivity.
Definition: Adaptivity.h:61
FEProblemBase::_nonlinear_convergence_names
std::optional< std::vector< ConvergenceName > > _nonlinear_convergence_names
Nonlinear system(s) convergence name(s)
Definition: FEProblemBase.h:3054
SubProblem
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
FEProblemBase::setConstJacobian
void setConstJacobian(bool state)
Set flag that Jacobian is constant (for optimization purposes)
Definition: FEProblemBase.h:2203
FEProblemBase::getPostprocessorObjectByName
const Postprocessor & getPostprocessorObjectByName(const PostprocessorName &object_name, const THREAD_ID tid=0) const
Return the Postprocessor object registered under the supplied object name.
Definition: FEProblemBase.C:4867
FEProblemBase::createMortarInterface
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, const Mortar3DSubpatchPlane mortar_3d_subpatch_plane, const MooseEnum &triangulation, const bool triangulate_triangles, const Mortar3DQuadraturePointMapping mortar_3d_qp_mapping=Mortar3DQuadraturePointMapping::NORMAL_PROJECTION)
Definition: FEProblemBase.C:8402
MooseEnumItem
Class for containing MooseEnum item information.
Definition: MooseEnumItem.h:18
FEProblemBase::solverSysNum
unsigned int solverSysNum(const SolverSystemName &solver_sys_name) const override
Definition: FEProblemBase.C:6892
FEProblemBase::CurrentResidualVectorTagsKey
Class that is used as a parameter to set/clearCurrentResidualVectorTags that allows only blessed clas...
Definition: FEProblemBase.h:2895
Control
Base class for Control objects.
Definition: Control.h:34
FEProblemBase::getMaterial
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.
Definition: FEProblemBase.C:4000
FEProblemBase::_grad_zero
std::vector< VariableGradient > _grad_zero
Definition: FEProblemBase.h:2503
MooseObjectWarehouseBase::hasActiveObjects
bool hasActiveObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:496
FEProblemBase::clearCurrentJacobianMatrixTags
void clearCurrentJacobianMatrixTags()
Clear the current Jacobian matrix tag data structure ...
Definition: FEProblemBase.h:2916
FEProblemBase::subdomainSetup
virtual void subdomainSetup(SubdomainID subdomain, const THREAD_ID tid)
Definition: FEProblemBase.C:2614
FEProblemBase::restoreOldSolutions
virtual void restoreOldSolutions()
Restore old solutions from the backup vectors and deallocate them.
Definition: FEProblemBase.C:7255
Adaptivity::getInitialSteps
unsigned int getInitialSteps() const
Pull out the number of initial steps previously set by calling init()
Definition: Adaptivity.h:112
FEProblemBase::reinitMaterials
void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)
Definition: FEProblemBase.C:4288
FEProblemBase::_identify_variable_groups_in_nl
const bool _identify_variable_groups_in_nl
Whether to identify variable groups in nonlinear systems. This affects dof ordering.
Definition: FEProblemBase.h:3603
FEProblemBase::petscOptionsDatabase
PetscOptions & petscOptionsDatabase()
Definition: FEProblemBase.h:2593
FEProblemBase::acceptInvalidSolution
bool acceptInvalidSolution() const
Whether or not to accept the solution based on its invalidity.
Definition: FEProblemBase.C:4085
FEProblemBase::getMortarInterface
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 ...
Definition: FEProblemBase.C:8446
FEProblemBase::_restore_original_nonzero_pattern
const bool _restore_original_nonzero_pattern
Whether we should restore the original nonzero pattern for every Jacobian evaluation.
Definition: FEProblemBase.h:3541
FEProblemBase::execMultiAppTransfers
void execMultiAppTransfers(ExecFlagType type, Transfer::DIRECTION direction)
Execute MultiAppTransfers associated with execution flag and direction.
Definition: FEProblemBase.C:5868
FEProblemBase::hasKokkosResidualObjects
bool hasKokkosResidualObjects() const
Definition: FEProblemBase.h:2970
RestartableEquationSystems
Wrapper class that owns a libMesh EquationSystem and adds advanced restart capability to it...
Definition: RestartableEquationSystems.h:32
FEProblemBase::restoreMultiApps
void restoreMultiApps(ExecFlagType type, bool force=false)
Restore the MultiApps associated with the ExecFlagType.
Definition: FEProblemBase.C:6097
FEProblemBase::addLinearFVBC
virtual void addLinearFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3643
FEProblemBase::customSetup
void customSetup(const ExecFlagType &exec_type) override
Definition: FEProblemBase.C:5068
FEProblemBase::setRestartFile
void setRestartFile(const std::string &file_name)
Communicate to the Resurector the name of the restart filer.
Definition: FEProblemBase.C:9251
FEProblemBase::setCurrentLinearSystem
void setCurrentLinearSystem(unsigned int sys_num)
Set the current linear system pointer.
Definition: FEProblemBase.C:9968
FEProblemBase::executeControls
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
Definition: FEProblemBase.C:5553
FEProblemBase::addUserObject
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:4642
TheWarehouse::query
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:467
OutputWarehouse::allowOutput
void allowOutput(bool state)
Ability to enable/disable output calls This is private, users should utilize FEProblemBase::allowOutp...
Definition: OutputWarehouse.C:383
FEProblemBase::onTimestepBegin
virtual void onTimestepBegin() override
Definition: FEProblemBase.C:7302
FEProblemBase::computeBounds
virtual void computeBounds(libMesh::NonlinearImplicitSystem &sys, NumericVector< libMesh::Number > &lower, NumericVector< libMesh::Number > &upper)
Definition: FEProblemBase.C:8042
NonlinearSystem
Nonlinear system to be solved.
Definition: NonlinearSystem.h:27
FEProblemBase::addKokkosFunction
virtual void addKokkosFunction(const std::string &type, const std::string &name, InputParameters &parameters)
Add a Kokkos function to the problem.
FEProblemBase::initKokkos
void initKokkos()
Construct Kokkos assembly and systems and allocate Kokkos material property storages.
FEProblemBase::computePostCheck
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)
Definition: FEProblemBase.C:8242
FEProblemBase::checkDuplicatePostprocessorVariableNames
void checkDuplicatePostprocessorVariableNames()
Definition: FEProblemBase.C:1582
FEProblemBase::computeResidualAndJacobian
void computeResidualAndJacobian(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, libMesh::SparseMatrix< libMesh::Number > &jacobian)
Form a residual and Jacobian with default tags.
Definition: FEProblemBase.C:7483
FEProblemBase::_using_ad_mat_props
bool _using_ad_mat_props
Automatic differentiaion (AD) flag which indicates whether any consumer has requested an AD material ...
Definition: FEProblemBase.h:3458
FEProblemBase::_scalar_zero
std::vector< VariableValue > _scalar_zero
Definition: FEProblemBase.h:2499
FEProblemBase::computeResidualL2Norm
virtual Real computeResidualL2Norm()
Computes the residual using whatever is sitting in the current solution vector then returns the L2 no...
Definition: FEProblemBase.C:7416
FEProblemBase::_linear_sys_names
const std::vector< LinearSystemName > _linear_sys_names
The linear system names.
Definition: FEProblemBase.h:3090
FEProblemBase::getKokkosSystems
Moose::Kokkos::Array< Moose::Kokkos::System > & getKokkosSystems()
Get the Kokkos System array (always populated when any Kokkos object exists)
Definition: FEProblemBase.h:870
FEProblemBase::getXFEM
std::shared_ptr< XFEMInterface > getXFEM()
Get a pointer to the XFEM controller object.
Definition: FEProblemBase.h:2143
FEProblemBase::getFailNextNonlinearConvergenceCheck
bool getFailNextNonlinearConvergenceCheck() const
Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s) ...
Definition: FEProblemBase.h:2857
FEProblemBase::incrementMultiAppTStep
void incrementMultiAppTStep(ExecFlagType type)
Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType.
Definition: FEProblemBase.C:6041
MooseVariableScalar
Class for scalar variables (they are different).
Definition: MooseVariableScalar.h:29
FEProblemBase::computeLinearSystemTags
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.
Definition: FEProblemBase.C:8123
FEProblemBase::bumpVolumeQRuleOrder
void bumpVolumeQRuleOrder(libMesh::Order order, SubdomainID block)
Increases the element/volume quadrature order for the specified mesh block if and only if the current...
Definition: FEProblemBase.C:6552
FEProblemBase::_material_dependency_check
const bool _material_dependency_check
Determines whether a check to verify material dependencies on every subdomain.
Definition: FEProblemBase.h:3394
FEProblemBase::_uo_jacobian_moose_vars
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars
Definition: FEProblemBase.h:3367
FEProblemBase::mesh
virtual MooseMesh & mesh() override
Definition: FEProblemBase.h:181
FEProblemBase::_zero
std::vector< VariableValue > _zero
Definition: FEProblemBase.h:2500
Moose::CouplingType
CouplingType
Definition: MooseTypes.h:779
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
FEProblemBase::linearSysNum
unsigned int linearSysNum(const LinearSystemName &linear_sys_name) const override
Definition: FEProblemBase.C:6881
FEProblemBase::currentLinearSystem
LinearSystem & currentLinearSystem()
Get a non-constant reference to the current linear system.
Definition: FEProblemBase.h:3777
FEProblemBase::resetFailNextSystemConvergenceCheck
void resetFailNextSystemConvergenceCheck()
Tell the problem that the system convergence check(s) may proceed as normal.
Definition: FEProblemBase.h:2869
RestartableEquationSystems::es
libMesh::EquationSystems & es()
Definition: RestartableEquationSystems.h:130
FEProblemBase::_fe_vector_tags
std::set< TagID > _fe_vector_tags
Definition: FEProblemBase.h:3062
FEProblemBase::getMaterialPropertyStorageConsumers
const std::set< const MooseObject * > & getMaterialPropertyStorageConsumers(Moose::MaterialDataType type) const
Definition: FEProblemBase.C:4055
FEProblemBase::addObjectParamsHelper
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().
Definition: FEProblemBase.C:4539
IntegratedBCBase
Base class for deriving any boundary condition of a integrated type.
Definition: IntegratedBCBase.h:19
FEProblemBase::solverParams
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.
Definition: FEProblemBase.C:9283
FEProblemBase::getSolverSystem
SolverSystem & getSolverSystem(unsigned int sys_num)
Get non-constant reference to a solver system.
Definition: FEProblemBase.h:3731
FEProblemBase::saveOldSolutions
virtual void saveOldSolutions()
Allocate vectors and save old solutions into them.
Definition: FEProblemBase.C:7245
FEProblemBase::computeTransposeNullSpace
virtual void computeTransposeNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
Definition: FEProblemBase.C:8227
FEProblemBase::hasPostprocessor
bool hasPostprocessor(const std::string &name) const
Deprecated.
Definition: FEProblemBase.C:4903
FEProblemBase::updateSolution
virtual bool updateSolution(NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)
Update the solution.
Definition: FEProblemBase.C:8360
FEProblemBase::_previous_multiapp_fp_aux_solution_required
bool _previous_multiapp_fp_aux_solution_required
Indicates we need to save the previous multiapp fixed-point iteration auxiliary variable values...
Definition: FEProblemBase.h:3361
FEProblemBase::_displaced_problem
std::shared_ptr< DisplacedProblem > _displaced_problem
Definition: FEProblemBase.h:3315
FEProblemBase::_geometric_search_data
GeometricSearchData _geometric_search_data
Definition: FEProblemBase.h:3316
Moose::StateArg
State argument for evaluating functors.
Definition: MooseFunctorArguments.h:121
FEProblemBase::setCurrentResidualVectorTags
void setCurrentResidualVectorTags(const std::set< TagID > &vector_tags)
Set the current residual vector tag data structure based on the passed in tag IDs.
Definition: FEProblemBase.h:3831
FEProblemBase::_functions
MooseObjectWarehouse< Function > _functions
functions
Definition: FEProblemBase.h:3167
FEProblemBase::timeOld
virtual Real & timeOld() const
Definition: FEProblemBase.h:575
MaterialData
Proxy for accessing MaterialPropertyStorage.
Definition: MaterialData.h:37
FEProblemBase::_vector_zero
std::vector< VectorVariableValue > _vector_zero
Definition: FEProblemBase.h:2510
FEProblemBase::hasMultiApp
bool hasMultiApp(const std::string &name) const
Definition: FEProblemBase.C:5850
FEProblemBase::_u_dot_old_requested
bool _u_dot_old_requested
Whether old solution time derivative needs to be stored.
Definition: FEProblemBase.h:3568
FEProblemBase::ignoreZerosInJacobian
bool ignoreZerosInJacobian() const
Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern.
Definition: FEProblemBase.h:2391
FEProblemBase::_cm
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
Coupling matrix for variables.
Definition: FEProblemBase.h:3141
FEProblemBase::needInterfaceMaterialOnSide
bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
Definition: FEProblemBase.C:9347
FEProblemBase::reinitElemFace
void reinitElemFace(const Elem *elem, unsigned int side, BoundaryID, const THREAD_ID tid)
LinearSystem
Linear system to be solved.
Definition: LinearSystem.h:48
FEProblemBase::needToAddDefaultNonlinearConvergence
bool needToAddDefaultNonlinearConvergence() const
Returns true if the problem needs to add the default nonlinear convergence.
Definition: FEProblemBase.h:741
FEProblemBase::_linear_convergence_names
std::optional< std::vector< ConvergenceName > > _linear_convergence_names
Linear system(s) convergence name(s) (if any)
Definition: FEProblemBase.h:3056
FEProblemBase::useSNESMFReuseBase
bool useSNESMFReuseBase()
Return a flag that indicates if we are reusing the vector base.
Definition: FEProblemBase.h:2572
FEProblemBase::addObject
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.
Definition: FEProblemBase.h:3692
FEProblemBase::_has_initialized_stateful
bool _has_initialized_stateful
Whether nor not stateful materials have been initialized.
Definition: FEProblemBase.h:3345
FEProblemBase::checkICRestartError
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...
Definition: FEProblemBase.C:3693
FEProblemBase::setResidualNeighbor
virtual void setResidualNeighbor(NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
Definition: FEProblemBase.C:2060
TheWarehouse::QueryCache::condition
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:285
FEProblemBase::_max_qps
unsigned int _max_qps
Maximum number of quadrature points used in the problem.
Definition: FEProblemBase.h:3405
FEProblemBase::setMaterialCoverageCheck
void setMaterialCoverageCheck(bool flag)
Set flag to indicate whether material coverage checks should be performed.
Definition: FEProblemBase.h:2234
FEProblemBase::validParams
static InputParameters validParams()
Definition: FEProblemBase.C:162
FEProblemBase::addFVInterpolationMethod
virtual void addFVInterpolationMethod(const std::string &method_type, const std::string &name, InputParameters &parameters)
Add an FV interpolation method.
Definition: FEProblemBase.C:4719
FEProblemBase::addScalarKernel
virtual void addScalarKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3219
MooseApp::theWarehouse
TheWarehouse & theWarehouse()
Definition: MooseApp.h:143
FEProblemBase::_preserve_matrix_sparsity_pattern
bool _preserve_matrix_sparsity_pattern
Whether to preserve the system matrix / Jacobian sparsity pattern, using 0-valued entries usually...
Definition: FEProblemBase.h:3545
InterfaceUserObject
Base class for implementing interface user objects.
Definition: InterfaceUserObject.h:19
FEProblemBase::nNonlinearIterations
virtual unsigned int nNonlinearIterations(const unsigned int nl_sys_num) const override
Definition: FEProblemBase.C:7134
FEProblemBase::_material_coverage_check
CoverageCheckMode _material_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active material...
Definition: FEProblemBase.h:3387
FEProblemBase::numLinearSystems
virtual std::size_t numLinearSystems() const override
Definition: FEProblemBase.h:2824
FEProblemBase::_neighbor_material_props
MaterialPropertyStorage & _neighbor_material_props
Definition: FEProblemBase.h:3193
FEProblemBase::_kokkos_systems
Moose::Kokkos::Array< Moose::Kokkos::System > _kokkos_systems
System array - sparsely populated (only slots for systems needing a Kokkos::System) ...
Definition: FEProblemBase.h:3145
Moose
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
Definition: SetAdaptivityOptionsAction.h:14
FEProblemBase::_num_linear_sys
const std::size_t _num_linear_sys
The number of linear systems.
Definition: FEProblemBase.h:3093
FEProblemBase::hasKokkosObjects
bool hasKokkosObjects() const
Definition: FEProblemBase.h:2966
FEProblemBase::_subspace_dim
std::map< std::string, unsigned int > _subspace_dim
Dimension of the subspace spanned by the vectors with a given prefix.
Definition: FEProblemBase.h:3151
FEProblemBase::getReporterData
ReporterData & getReporterData(ReporterData::WriteKey)
Provides non-const access the ReporterData object that is used to store reporter values.
Definition: FEProblemBase.h:1387
FEProblemBase::getEvaluableElementRange
const libMesh::ConstElemRange & getEvaluableElementRange()
In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}.
Definition: FEProblemBase.C:880
FEProblemBase::_use_hash_table_matrix_assembly
const bool _use_hash_table_matrix_assembly
Whether to assemble matrices using hash tables instead of preallocating matrix memory.
Definition: FEProblemBase.h:3465
FEProblemBase::Resurrector
friend class Resurrector
Definition: FEProblemBase.h:3576
FEProblemBase::restoreOriginalNonzeroPattern
bool restoreOriginalNonzeroPattern() const
Definition: FEProblemBase.h:2360
FEProblemBase::getUserObjectBase
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.
Definition: FEProblemBase.C:4736
MultiMooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
Definition: MultiMooseEnum.h:41
FEProblemBase::_has_internal_edge_residual_objects
bool _has_internal_edge_residual_objects
Whether the problem has dgkernels or interface kernels.
Definition: FEProblemBase.h:3559
FEProblemBase::addKokkosKernel
virtual void addKokkosKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
FEProblemBase::computingScalingJacobian
bool computingScalingJacobian() const override final
Getter for whether we&#39;re computing the scaling jacobian.
Definition: FEProblemBase.h:2801
FEProblemBase::execMultiApps
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
Definition: FEProblemBase.C:5968
FEProblemBase::getControlWarehouse
ExecuteMooseObjectWarehouse< Control > & getControlWarehouse()
Reference to the control logic warehouse.
Definition: FEProblemBase.h:2517
EXEC_SUBDOMAIN
const ExecFlagType EXEC_SUBDOMAIN
Definition: Moose.C:52
FEProblemBase::getArrayVariable
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...
Definition: FEProblemBase.C:6292
FEProblemBase::getMarkerWarehouse
const MooseObjectWarehouse< Marker > & getMarkerWarehouse()
Definition: FEProblemBase.h:2090
FEProblemBase::_has_constraints
bool _has_constraints
Whether or not this system has any Constraints.
Definition: FEProblemBase.h:3333
FEProblemBase::isTransient
virtual bool isTransient() const override
Definition: FEProblemBase.h:585
FEProblemBase::_need_to_add_default_nonlinear_convergence
bool _need_to_add_default_nonlinear_convergence
Flag that the problem needs to add the default nonlinear convergence.
Definition: FEProblemBase.h:3083
FEProblemBase::hasMultiApps
bool hasMultiApps() const
Returns whether or not the current simulation has any multiapps.
Definition: FEProblemBase.h:1610
FEProblemBase::reinitNeighbor
virtual void reinitNeighbor(const Elem *elem, unsigned int side, const THREAD_ID tid) override
Definition: FEProblemBase.C:2460
FEProblemBase::notifyWhenMeshChanges
void notifyWhenMeshChanges(MeshChangedInterface *mci)
Register an object that derives from MeshChangedInterface to be notified when the mesh changes...
Definition: FEProblemBase.C:8841
FEProblemBase::setSNESMFReuseBase
void setSNESMFReuseBase(bool reuse, bool set_by_user)
If or not to reuse the base vector for matrix-free calculation.
Definition: FEProblemBase.h:2564
FEProblemBase::_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange > _evaluable_local_elem_range
Definition: FEProblemBase.h:3448
FEProblemBase::computingScalingResidual
bool computingScalingResidual() const override final
Definition: FEProblemBase.h:2814
FEProblemBase::getFVFaceInterpolationMethod
const FVFaceInterpolationMethod & getFVFaceInterpolationMethod(const InterpolationMethodName &name, const THREAD_ID tid=0) const
Retrieve a scalar face interpolation method.
Definition: FEProblemBase.C:4814
FEProblemBase::executeAllObjects
virtual void executeAllObjects(const ExecFlagType &exec_type)
Definition: FEProblemBase.C:5063
FEProblemBase::_kernel_coverage_check
CoverageCheckMode _kernel_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active kernel...
Definition: FEProblemBase.h:3375
FEProblemBase::setActiveFEVariableCoupleableVectorTags
virtual void setActiveFEVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid) override
Definition: FEProblemBase.C:6355
FEProblemBase::nonlocalCouplingEntries
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > & nonlocalCouplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num)
Definition: FEProblemBase.C:6722
Number
Real Number
FEProblemBase::_fail_next_system_convergence_check
bool _fail_next_system_convergence_check
Definition: FEProblemBase.h:3550
FEProblemBase::_linear_systems
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.
Definition: FEProblemBase.h:3096
FEProblemBase::_xfem
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.
Definition: FEProblemBase.h:3311
FEProblemBase::_boundary_restricted_elem_integrity_check
const bool _boundary_restricted_elem_integrity_check
whether to perform checking of boundary restricted elemental object variable dependencies, e.g.
Definition: FEProblemBase.h:3384
FEProblemBase::prepareShapes
virtual void prepareShapes(unsigned int var, const THREAD_ID tid) override
Definition: FEProblemBase.C:2207
FEProblemBase::reinitMaterialsInterface
void reinitMaterialsInterface(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)
Definition: FEProblemBase.C:4461
FEProblemBase::_const_jacobian
bool _const_jacobian
true if the Jacobian is constant
Definition: FEProblemBase.h:3348
FEProblemBase::computeJacobianBlock
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.
Definition: FEProblemBase.C:8030
FEProblemBase::solveLinearSystem
virtual void solveLinearSystem(const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)
Build and solve a linear system.
Definition: FEProblemBase.C:7085
FEProblemBase::computeUserObjectByName
virtual void computeUserObjectByName(const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)
Compute an user object with the given name.
Definition: FEProblemBase.C:5303
FEProblemBase::getMaterialPropertyRegistry
const MaterialPropertyRegistry & getMaterialPropertyRegistry() const
Definition: FEProblemBase.h:2048
FEProblemBase::possiblyRebuildGeomSearchPatches
virtual void possiblyRebuildGeomSearchPatches()
Definition: FEProblemBase.C:8466
FEProblemBase::_linear_vector_tags
std::set< TagID > _linear_vector_tags
Temporary storage for filtered vector tags for linear systems.
Definition: FEProblemBase.h:3067
FEProblemBase::_kokkos_bnd_material_props
Moose::Kokkos::MaterialPropertyStorage & _kokkos_bnd_material_props
Definition: FEProblemBase.h:3197
FVFaceInterpolationMethod
Abstract base class for interpolation methods that produce a scalar face value from adjacent cell val...
Definition: FVFaceInterpolationMethod.h:19
MultiApp
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:112
FEProblemBase::checkingUOAuxState
bool checkingUOAuxState() const
Return a flag to indicate whether we are executing user objects and auxliary kernels for state check ...
Definition: FEProblemBase.h:228
FEProblemBase::getNonlinearEvaluableElementRange
const libMesh::ConstElemRange & getNonlinearEvaluableElementRange()
Definition: FEProblemBase.C:898
FEProblemBase::_material_props
MaterialPropertyStorage & _material_props
Definition: FEProblemBase.h:3191
VectorPostprocessor
Base class for Postprocessors that produce a vector of values.
Definition: VectorPostprocessor.h:34
FEProblemBase::prepareMaterials
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...
Definition: FEProblemBase.C:4257
FEProblemBase::addFVKernel
virtual void addFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3602
FEProblemBase::addFVBC
virtual void addFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3616
FEProblemBase::_max_scalar_order
libMesh::Order _max_scalar_order
Maximum scalar variable order.
Definition: FEProblemBase.h:3408
FEProblemBase::addGhostedBoundary
virtual void addGhostedBoundary(BoundaryID boundary_id) override
Will make sure that all necessary elements from boundary_id are ghosted to this processor.
Definition: FEProblemBase.C:2232
FEProblemBase::hasFunction
virtual bool hasFunction(const std::string &name, const THREAD_ID tid=0)
Definition: FEProblemBase.C:2709
FEProblemBase::adaptivity
Adaptivity & adaptivity()
Definition: FEProblemBase.h:2115
FEProblemBase::hasActiveMaterialProperties
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.
Definition: FEProblemBase.C:6454
FEProblemBase::_between_multi_app_transfers
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.
Definition: FEProblemBase.h:3240
FEProblemBase::hasUOAuxStateCheck
bool hasUOAuxStateCheck() const
Whether or not MOOSE will perform a user object/auxiliary kernel state check.
Definition: FEProblemBase.h:220
FEProblemBase::cacheJacobian
virtual void cacheJacobian(const THREAD_ID tid) override
Definition: FEProblemBase.C:2120
FEProblemBase::jacobianSetup
void jacobianSetup() override
Definition: FEProblemBase.C:9834
FEProblemBase::numSolverSystems
virtual std::size_t numSolverSystems() const override
Definition: FEProblemBase.h:2826
FEProblemBase::addHDGKernel
virtual void addHDGKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3170
MooseApp::getExecutor
Executor * getExecutor() const
Definition: MooseApp.h:341
FEProblemBase::getKokkosSystems
const Moose::Kokkos::Array< Moose::Kokkos::System > & getKokkosSystems() const
Definition: FEProblemBase.h:871
FEProblemBase::dt
virtual Real & dt() const
Definition: FEProblemBase.h:577
FEProblemBase::advanceMultiApps
void advanceMultiApps(ExecFlagType type)
Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep depending on your purpose...
Definition: FEProblemBase.h:1684
FEProblemBase::immediatelyPrintInvalidSolution
bool immediatelyPrintInvalidSolution() const
Whether or not the solution invalid warnings are printed out immediately.
Definition: FEProblemBase.h:2416
FEProblemBase::_req
Restartable::ManagedValue< RestartableEquationSystems > _req
The EquationSystems object, wrapped for restart.
Definition: FEProblemBase.h:3007
FEProblemBase::currentLinearSysNum
virtual unsigned int currentLinearSysNum() const override
Definition: FEProblemBase.C:9865
FEProblemBase::_nonlocal_cm
std::vector< libMesh::CouplingMatrix > _nonlocal_cm
nonlocal coupling matrix
Definition: FEProblemBase.h:3618
FEProblemBase::reinitNodeFace
virtual void reinitNodeFace(const Node *node, BoundaryID bnd_id, const THREAD_ID tid) override
Definition: FEProblemBase.C:2399
FEProblemBase::reinitOffDiagScalars
virtual void reinitOffDiagScalars(const THREAD_ID tid) override
Definition: FEProblemBase.C:2452
FEProblemBase::reinitElemPhys
virtual void reinitElemPhys(const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid) override
Definition: FEProblemBase.C:2324
FEProblemBase::_interface_mat_side_cache
std::vector< std::unordered_map< BoundaryID, bool > > _interface_mat_side_cache
Cache for calculating materials on interface.
Definition: FEProblemBase.h:3252
FEProblemBase::initKokkosStatefulProps
void initKokkosStatefulProps()
FEProblemBase::addJacobianNeighborLowerD
virtual void addJacobianNeighborLowerD(const THREAD_ID tid) override
Definition: FEProblemBase.C:2091
FEProblemBase::prepareNeighborShapes
virtual void prepareNeighborShapes(unsigned int var, const THREAD_ID tid) override
Definition: FEProblemBase.C:2219
FEProblemBase::hasSolutionState
bool hasSolutionState(unsigned int state, Moose::SolutionIterationType iteration_type) const
Whether we need up to old (1) or older (2) solution states for a given type of iteration.
Definition: FEProblemBase.C:764
FEProblemBase::_markers
MooseObjectWarehouse< Marker > _markers
Definition: FEProblemBase.h:3219
FEProblemBase::_fv_ics
FVInitialConditionWarehouse _fv_ics
Definition: FEProblemBase.h:3185
FEProblemBase::setVerboseProblem
void setVerboseProblem(bool verbose)
Make the problem be verbose.
Definition: FEProblemBase.C:9934
FEProblemBase::setNeighborSubdomainID
virtual void setNeighborSubdomainID(const Elem *elem, unsigned int side, const THREAD_ID tid) override
FEProblemBase::hasException
virtual bool hasException()
Whether or not an exception has occurred.
Definition: FEProblemBase.h:535
FEProblemBase::CurrentResidualVectorTagsKey::CurrentResidualVectorTagsKey
CurrentResidualVectorTagsKey(const CurrentResidualVectorTagsKey &)
Definition: FEProblemBase.h:2900
FEProblemBase::initialAdaptMesh
virtual void initialAdaptMesh()
Definition: FEProblemBase.C:8528
FEProblemBase::addResidualScalar
virtual void addResidualScalar(const THREAD_ID tid=0)
Definition: FEProblemBase.C:1984
FEProblemBase::_kokkos_neighbor_material_props
Moose::Kokkos::MaterialPropertyStorage & _kokkos_neighbor_material_props
Definition: FEProblemBase.h:3198
FEProblemBase::_using_default_nl
const bool _using_default_nl
Boolean to check if we have the default nonlinear system.
Definition: FEProblemBase.h:3105
FEProblemBase::_all_materials
MaterialWarehouse _all_materials
Definition: FEProblemBase.h:3205
FEProblemBase::_u_dotdot_requested
bool _u_dotdot_requested
Whether solution second time derivative needs to be stored.
Definition: FEProblemBase.h:3565
FEProblemBase::addCachedResidual
virtual void addCachedResidual(const THREAD_ID tid) override
Definition: FEProblemBase.C:2007
AuxiliarySystem
A system that holds auxiliary variables.
Definition: AuxiliarySystem.h:43
FEProblemBase::_petsc_options
Moose::PetscSupport::PetscOptions _petsc_options
PETSc option storage.
Definition: FEProblemBase.h:3438
CrankNicolson
Crank-Nicolson time integrator.
Definition: CrankNicolson.h:22
FEProblemBase::getConvergenceObjects
virtual const std::vector< std::shared_ptr< Convergence > > & getConvergenceObjects(const THREAD_ID tid=0) const
Gets the Convergence objects.
Definition: FEProblemBase.C:2783
FEProblemBase::preserveMatrixSparsityPattern
bool preserveMatrixSparsityPattern() const
Will return True if the executioner in use requires preserving the sparsity pattern of the matrices b...
Definition: FEProblemBase.h:2380
FEProblemBase::clearActiveElementalMooseVariables
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid) override
Clear the active elemental MooseVariableFEBase.
Definition: FEProblemBase.C:6394
UserObject
Base class for user-specific data.
Definition: UserObject.h:19
FEProblemBase::allowOutput
void allowOutput(bool state)
Ability to enable/disable all output calls.
Definition: FEProblemBase.C:7283
FEProblemBase::getSampler
virtual Sampler & getSampler(const std::string &name, const THREAD_ID tid=0)
Definition: FEProblemBase.C:2885
FEProblemBase::outputStep
virtual void outputStep(ExecFlagType type)
Output the current step.
Definition: FEProblemBase.C:7265
FEProblemBase::getKokkosFunction
virtual Moose::Kokkos::Function getKokkosFunction(const std::string &name)
Get a Kokkos function in an abstract type.
FEProblemBase::projectInitialConditionOnCustomRange
void projectInitialConditionOnCustomRange(libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range, const std::optional< std::set< VariableName >> &target_vars=std::nullopt)
Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boun...
Definition: FEProblemBase.C:3892
FEProblemBase::nlSysNum
virtual unsigned int nlSysNum(const NonlinearSystemName &nl_sys_name) const override
Definition: FEProblemBase.C:6870
MooseApp::getOutputWarehouse
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2409
FEProblemBase::_verbose_setup
MooseEnum _verbose_setup
Whether or not to be verbose during setup.
Definition: FEProblemBase.h:3420
FEProblemBase::addKokkosLinearFVKernel
virtual void addKokkosLinearFVKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
FEProblemBase::needToAddDefaultMultiAppFixedPointConvergence
bool needToAddDefaultMultiAppFixedPointConvergence() const
Returns true if the problem needs to add the default fixed point convergence.
Definition: FEProblemBase.h:746
FEProblemBase::setIgnoreZerosInJacobian
void setIgnoreZerosInJacobian(bool state)
Set whether the zeros in the Jacobian should be dropped from the sparsity pattern.
Definition: FEProblemBase.h:2394
FEProblemBase::computeSystems
void computeSystems(const ExecFlagType &type)
Do generic system computations.
Definition: FEProblemBase.C:9977
FEProblemBase::computeJacobianTags
virtual void computeJacobianTags(const std::set< TagID > &tags)
Form multiple matrices, and each is associated with a tag.
Definition: FEProblemBase.C:7905
Moose::SolutionIterationType
SolutionIterationType
Definition: MooseTypes.h:269
FEProblemBase::_displaced_mesh
MooseMesh * _displaced_mesh
Definition: FEProblemBase.h:3314
FEProblemBase::getKokkosMaterialsWarehouse
const MaterialWarehouse & getKokkosMaterialsWarehouse() const
Definition: FEProblemBase.h:2313
FEProblemBase::_has_mortar
bool _has_mortar
Whether the simulation requires mortar coupling.
Definition: FEProblemBase.h:3581
FEProblemBase::getMaxScalarOrder
libMesh::Order getMaxScalarOrder() const
Definition: FEProblemBase.C:1715
FEProblemBase::execTransfers
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
Definition: FEProblemBase.C:6138
FEProblemBase::getMortarInterfaces
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, MortarInterfaceConfig > & getMortarInterfaces(bool on_displaced) const
Definition: FEProblemBase.C:10082
FEProblemBase::getLinearConvergenceNames
const std::vector< ConvergenceName > & getLinearConvergenceNames() const
Gets the linear convergence object name(s).
Definition: FEProblemBase.C:9794
THREAD_ID
unsigned int THREAD_ID
Definition: MooseTypes.h:237
FEProblemBase::ghostGhostedBoundaries
virtual void ghostGhostedBoundaries() override
Causes the boundaries added using addGhostedBoundary to actually be ghosted.
Definition: FEProblemBase.C:2240
FEProblemBase::getKokkosFESystems
Moose::Kokkos::Array< Moose::Kokkos::FESystem > & getKokkosFESystems()
Get the Kokkos FESystem array (populated only when FE Kokkos objects exist)
Definition: FEProblemBase.h:882
Executor
The Executor class directs the execution flow of simulations.
Definition: Executor.h:26
FEProblemBase::_materials
MaterialWarehouse _materials
Definition: FEProblemBase.h:3202
dof_id_type
uint8_t dof_id_type
FEProblemBase::adaptMesh
virtual bool adaptMesh()
Definition: FEProblemBase.C:8564
FEProblemBase::addJacobianScalar
virtual void addJacobianScalar(const THREAD_ID tid=0)
Definition: FEProblemBase.C:2107
FEProblemBase::getNeighborMaterialPropertyStorage
const MaterialPropertyStorage & getNeighborMaterialPropertyStorage()
Definition: FEProblemBase.h:2060
FEProblemBase::addDiracKernel
virtual void addDiracKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Definition: FEProblemBase.C:3522
FEProblemBase::_nonlocal_integrated_bcs
MooseObjectWarehouse< IntegratedBCBase > _nonlocal_integrated_bcs
nonlocal integrated_bcs
Definition: FEProblemBase.h:3180
FEProblemBase::mesh
virtual const MooseMesh & mesh() const override
Definition: FEProblemBase.h:182
FEProblemBase::computeResidualTag
virtual void computeResidualTag(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
Form a residual vector for a given tag.
Definition: FEProblemBase.C:7617
FEProblemBase::startedInitialSetup
virtual bool startedInitialSetup()
Returns true if we are in or beyond the initialSetup stage.
Definition: FEProblemBase.h:569
FEProblemBase::getVectorVariable
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...
Definition: FEProblemBase.C:6280
FEProblemBase::_line_search
std::shared_ptr< LineSearch > _line_search
Definition: FEProblemBase.h:3446
FEProblemBase::initXFEM
void initXFEM(std::shared_ptr< XFEMInterface > xfem)
Create XFEM controller object.
Definition: FEProblemBase.C:8626
FEProblemBase::addElementalFieldVariable
virtual void addElementalFieldVariable(const std::string &var_type, const std::string &var_name, InputParameters &params)
Add an elemental field variable for use in the adaptivity system.
Definition: FEProblemBase.C:3360
Transfer
Base class for all Transfer objects.
Definition: Transfer.h:36
FEProblemBase::neighborSubdomainSetup
virtual void neighborSubdomainSetup(SubdomainID subdomain, const THREAD_ID tid)
Definition: FEProblemBase.C:2629
FEProblemBase::addCachedJacobian
virtual void addCachedJacobian(const THREAD_ID tid) override
Definition: FEProblemBase.C:2136
FEProblemBase::sizeZeroes
virtual void sizeZeroes(unsigned int size, const THREAD_ID tid)
Definition: FEProblemBase.C:2251
FEProblemBase::computeDamping
virtual Real computeDamping(const NumericVector< libMesh::Number > &soln, const NumericVector< libMesh::Number > &update)
Definition: FEProblemBase.C:8325
FEProblemBase::_real_zero
std::vector< Real > _real_zero
Convenience zeros.
Definition: FEProblemBase.h:2498
FEProblemBase::_nonlocal_kernels
MooseObjectWarehouse< KernelBase > _nonlocal_kernels
nonlocal kernels
Definition: FEProblemBase.h:3177
FEProblemBase::checkCoordinateSystems
void checkCoordinateSystems()
Verify that there are no element type/coordinate type conflicts.
Definition: FEProblemBase.C:9245
FEProblemBase::getMaxQps
unsigned int getMaxQps() const
Definition: FEProblemBase.C:1707
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:30
FEProblemBase::_verbose_multiapps
bool _verbose_multiapps
Whether or not to be verbose with multiapps.
Definition: FEProblemBase.h:3423
ReporterData
This is a helper class for managing the storage of declared Reporter object values.
Definition: ReporterData.h:48
Generated on Sun Aug 2 2026 21:16:34 for https://mooseframework.inl.gov by   doxygen 1.8.14