www.mooseframework.org
FEProblemBase.h
Go to the documentation of this file.
1 /****************************************************************/
2 /* DO NOT MODIFY THIS HEADER */
3 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
4 /* */
5 /* (c) 2010 Battelle Energy Alliance, LLC */
6 /* ALL RIGHTS RESERVED */
7 /* */
8 /* Prepared by Battelle Energy Alliance, LLC */
9 /* Under Contract No. DE-AC07-05ID14517 */
10 /* With the U. S. Department of Energy */
11 /* */
12 /* See COPYRIGHT for full restrictions */
13 /****************************************************************/
14 
15 #ifndef FEPROBLEMBASE_H
16 #define FEPROBLEMBASE_H
17 
18 // MOOSE includes
19 #include "SubProblem.h"
20 #include "GeometricSearchData.h"
21 #include "PostprocessorData.h"
23 #include "Adaptivity.h"
25 #include "Restartable.h"
26 #include "SolverParams.h"
27 #include "PetscSupport.h"
28 #include "MooseApp.h"
31 #include "MaterialWarehouse.h"
32 #include "MooseVariableBase.h"
33 #include "MultiAppTransfer.h"
34 #include "Postprocessor.h"
35 
36 #include "libmesh/enum_quadrature_type.h"
37 #include "libmesh/equation_systems.h"
38 
39 #include <unordered_map>
40 
41 // Forward declarations
42 class AuxiliarySystem;
43 class DisplacedProblem;
44 class FEProblemBase;
45 class MooseMesh;
47 class NonlinearSystem;
48 class RandomInterface;
49 class RandomData;
51 class MultiMooseEnum;
53 class MaterialData;
54 class MooseEnum;
55 class Resurrector;
56 class Assembly;
57 class JacobianBlock;
58 class Control;
59 class MultiApp;
60 class TransientMultiApp;
62 class Indicator;
64 class Marker;
65 class Material;
66 class Transfer;
67 class XFEMInterface;
68 class SideUserObject;
69 class NodalUserObject;
70 class ElementUserObject;
72 class GeneralUserObject;
73 class Function;
74 class Distribution;
75 class Sampler;
76 class KernelBase;
77 class IntegratedBC;
78 
79 // libMesh forward declarations
80 namespace libMesh
81 {
82 class CouplingMatrix;
83 class NonlinearImplicitSystem;
84 }
85 
86 template <>
88 
90 {
98 };
99 
100 // The idea with these enums is to abstract the reasons for
101 // convergence/divergence, i.e. they could be used with linear algebra
102 // packages other than PETSc. They were directly inspired by PETSc,
103 // though. This enum could also be combined with the
104 // MooseNonlinearConvergenceReason enum but there might be some
105 // confusion (?)
107 {
109  // MOOSE_CONVERGED_RTOL_NORMAL = 1,
110  // MOOSE_CONVERGED_ATOL_NORMAL = 9,
114  // MOOSE_CONVERGED_CG_NEG_CURVE = 5,
115  // MOOSE_CONVERGED_CG_CONSTRAINED = 6,
116  // MOOSE_CONVERGED_STEP_LENGTH = 7,
117  // MOOSE_CONVERGED_HAPPY_BREAKDOWN = 8,
119  // MOOSE_DIVERGED_ITS = -3,
120  // MOOSE_DIVERGED_DTOL = -4,
121  // MOOSE_DIVERGED_BREAKDOWN = -5,
122  // MOOSE_DIVERGED_BREAKDOWN_BICG = -6,
123  // MOOSE_DIVERGED_NONSYMMETRIC = -7,
124  // MOOSE_DIVERGED_INDEFINITE_PC = -8,
126  // MOOSE_DIVERGED_INDEFINITE_MAT = -10
128 };
129 
134 class FEProblemBase : public SubProblem, public Restartable
135 {
136 public:
137  FEProblemBase(const InputParameters & parameters);
138  virtual ~FEProblemBase();
139 
140  virtual EquationSystems & es() override { return _eq; }
141  virtual MooseMesh & mesh() override { return _mesh; }
142 
143  virtual Moose::CoordinateSystemType getCoordSystem(SubdomainID sid) override;
144  virtual void setCoordSystem(const std::vector<SubdomainName> & blocks,
145  const MultiMooseEnum & coord_sys);
146  void setAxisymmetricCoordAxis(const MooseEnum & rz_coord_axis);
147 
153  void setCoupling(Moose::CouplingType type);
154 
155  Moose::CouplingType coupling() { return _coupling; }
156 
161  void setCouplingMatrix(std::unique_ptr<CouplingMatrix> cm);
162 
163  // DEPRECATED METHOD
164  void setCouplingMatrix(CouplingMatrix * cm);
165 
166  const CouplingMatrix * couplingMatrix() { return _cm.get(); }
167 
169  void setNonlocalCouplingMatrix();
170 
171  bool areCoupled(unsigned int ivar, unsigned int jvar);
172 
173  std::vector<std::pair<MooseVariable *, MooseVariable *>> & couplingEntries(THREAD_ID tid);
174  std::vector<std::pair<MooseVariable *, MooseVariable *>> & nonlocalCouplingEntries(THREAD_ID tid);
175 
193  checkNonlinearConvergence(std::string & msg,
194  const PetscInt it,
195  const Real xnorm,
196  const Real snorm,
197  const Real fnorm,
198  const Real rtol,
199  const Real stol,
200  const Real abstol,
201  const PetscInt nfuncs,
202  const PetscInt max_funcs,
203  const Real initial_residual_before_preset_bcs,
204  const Real div_threshold);
205 
216  virtual MooseLinearConvergenceReason checkLinearConvergence(std::string & msg,
217  const PetscInt n,
218  const Real rnorm,
219  const Real rtol,
220  const Real atol,
221  const Real dtol,
222  const PetscInt maxits);
223 
224  virtual bool hasVariable(const std::string & var_name) override;
225  virtual MooseVariable & getVariable(THREAD_ID tid, const std::string & var_name) override;
226  virtual bool hasScalarVariable(const std::string & var_name) override;
227  virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid,
228  const std::string & var_name) override;
229  virtual System & getSystem(const std::string & var_name) override;
230 
237  virtual void setActiveElementalMooseVariables(const std::set<MooseVariable *> & moose_vars,
238  THREAD_ID tid) override;
239 
245  virtual const std::set<MooseVariable *> &
246  getActiveElementalMooseVariables(THREAD_ID tid) override;
247 
253  virtual bool hasActiveElementalMooseVariables(THREAD_ID tid) override;
254 
262  virtual void clearActiveElementalMooseVariables(THREAD_ID tid) override;
263 
270  virtual void setActiveMaterialProperties(const std::set<unsigned int> & mat_prop_ids,
271  THREAD_ID tid) override;
272 
278  virtual const std::set<unsigned int> & getActiveMaterialProperties(THREAD_ID tid) override;
279 
288  virtual bool hasActiveMaterialProperties(THREAD_ID tid) override;
289 
295  virtual void clearActiveMaterialProperties(THREAD_ID tid) override;
296 
297  virtual void createQRules(QuadratureType type,
298  Order order,
299  Order volume_order = INVALID_ORDER,
300  Order face_order = INVALID_ORDER);
301 
305  unsigned int getMaxQps() const;
306 
310  unsigned int getMaxShapeFunctions() const;
311 
315  Order getMaxScalarOrder() const;
316 
320  void checkNonlocalCoupling();
321  void checkUserObjectJacobianRequirement(THREAD_ID tid);
322  void setVariableAllDoFMap(const std::vector<MooseVariable *> moose_vars);
323 
324  const std::vector<MooseVariable *> & getUserObjectJacobianVariables(THREAD_ID tid) const
325  {
326  return _uo_jacobian_moose_vars[tid];
327  }
328 
329  virtual Assembly & assembly(THREAD_ID tid) override { return *_assembly[tid]; }
330 
334  virtual std::vector<VariableName> getVariableNames();
335 
339  virtual void addExtraVectors();
340  virtual void initialSetup();
341  virtual void timestepSetup();
342 
343  virtual void prepare(const Elem * elem, THREAD_ID tid) override;
344  virtual void prepareFace(const Elem * elem, THREAD_ID tid) override;
345  virtual void prepare(const Elem * elem,
346  unsigned int ivar,
347  unsigned int jvar,
348  const std::vector<dof_id_type> & dof_indices,
349  THREAD_ID tid) override;
350 
351  virtual void setCurrentSubdomainID(const Elem * elem, THREAD_ID tid) override;
352  virtual void setNeighborSubdomainID(const Elem * elem, unsigned int side, THREAD_ID tid) override;
353  virtual void setNeighborSubdomainID(const Elem * elem, THREAD_ID tid);
354  virtual void prepareAssembly(THREAD_ID tid) override;
355 
356  virtual void addGhostedElem(dof_id_type elem_id) override;
357  virtual void addGhostedBoundary(BoundaryID boundary_id) override;
358  virtual void ghostGhostedBoundaries() override;
359 
360  virtual void sizeZeroes(unsigned int size, THREAD_ID tid);
361  virtual bool reinitDirac(const Elem * elem, THREAD_ID tid) override;
362  virtual void reinitElem(const Elem * elem, THREAD_ID tid) override;
363  virtual void
364  reinitElemPhys(const Elem * elem, std::vector<Point> phys_points_in_elem, THREAD_ID tid) override;
365  virtual void
366  reinitElemFace(const Elem * elem, unsigned int side, BoundaryID bnd_id, THREAD_ID tid) override;
367  virtual void reinitNode(const Node * node, THREAD_ID tid) override;
368  virtual void reinitNodeFace(const Node * node, BoundaryID bnd_id, THREAD_ID tid) override;
369  virtual void reinitNodes(const std::vector<dof_id_type> & nodes, THREAD_ID tid) override;
370  virtual void reinitNodesNeighbor(const std::vector<dof_id_type> & nodes, THREAD_ID tid) override;
371  virtual void reinitNeighbor(const Elem * elem, unsigned int side, THREAD_ID tid) override;
372  virtual void reinitNeighborPhys(const Elem * neighbor,
373  unsigned int neighbor_side,
374  const std::vector<Point> & physical_points,
375  THREAD_ID tid) override;
376  virtual void reinitNeighborPhys(const Elem * neighbor,
377  const std::vector<Point> & physical_points,
378  THREAD_ID tid) override;
379  virtual void reinitNodeNeighbor(const Node * node, THREAD_ID tid) override;
380  virtual void reinitScalars(THREAD_ID tid) override;
381  virtual void reinitOffDiagScalars(THREAD_ID tid) override;
382 
384  virtual void getDiracElements(std::set<const Elem *> & elems) override;
385  virtual void clearDiracInfo() override;
386 
387  virtual void subdomainSetup(SubdomainID subdomain, THREAD_ID tid);
388  virtual void neighborSubdomainSetup(SubdomainID subdomain, THREAD_ID tid);
389 
390  virtual void newAssemblyArray(NonlinearSystemBase & nl);
391  virtual void deleteAssemblyArray();
392  virtual void initNullSpaceVectors(const InputParameters & parameters, NonlinearSystemBase & nl);
393 
399  virtual void useFECache(bool fe_cache) override;
400 
401  virtual void init() override;
402  virtual void solve() override;
403 
410  virtual void setException(const std::string & message);
411 
415  virtual bool hasException() { return _has_exception; }
416 
427  virtual void checkExceptionAndStopSolve();
428 
429  virtual bool converged() override;
430  virtual unsigned int nNonlinearIterations() override;
431  virtual unsigned int nLinearIterations() override;
432  virtual Real finalNonlinearResidual() override;
433  virtual bool computingInitialResidual() override;
434 
438  virtual bool currentlyComputingJacobian() { return _currently_computing_jacobian; }
439 
443  virtual bool startedInitialSetup() { return _started_initial_setup; }
444 
445  virtual void onTimestepBegin() override;
446  virtual void onTimestepEnd() override;
447 
448  virtual Real & time() const { return _time; }
449  virtual Real & timeOld() const { return _time_old; }
450  virtual int & timeStep() const { return _t_step; }
451  virtual Real & dt() const { return _dt; }
452  virtual Real & dtOld() const { return _dt_old; }
453 
454  virtual void transient(bool trans) { _transient = trans; }
455  virtual bool isTransient() const override { return _transient; }
456 
457  virtual void
458  addTimeIntegrator(const std::string & type, const std::string & name, InputParameters parameters);
459  virtual void
460  addPredictor(const std::string & type, const std::string & name, InputParameters parameters);
461 
462  virtual void copySolutionsBackwards();
463 
468  virtual void advanceState();
469 
470  virtual void restoreSolutions();
471 
475  virtual void saveOldSolutions();
476 
480  virtual void restoreOldSolutions();
481 
488  virtual void outputStep(ExecFlagType type);
489 
493  virtual void postExecute();
494 
496 
502  void allowOutput(bool state);
503  template <typename T>
504  void allowOutput(bool state);
506 
515  void forceOutput();
516 
520  void initPetscOutput();
521 
522 #ifdef LIBMESH_HAVE_PETSC
523 
526  Moose::PetscSupport::PetscOptions & getPetscOptions() { return _petsc_options; }
527 #endif // LIBMESH_HAVE_PETSC
528 
529  // Function /////
530  virtual void addFunction(std::string type, const std::string & name, InputParameters parameters);
531  virtual bool hasFunction(const std::string & name, THREAD_ID tid = 0);
532  virtual Function & getFunction(const std::string & name, THREAD_ID tid = 0);
533 
537  virtual void
538  addDistribution(std::string type, const std::string & name, InputParameters parameters);
539  virtual Distribution & getDistribution(const std::string & name);
540 
544  virtual void addSampler(std::string type, const std::string & name, InputParameters parameters);
545  virtual Sampler & getSampler(const std::string & name, THREAD_ID tid = 0);
546 
547  // NL /////
549  const NonlinearSystemBase & getNonlinearSystemBase() const { return *_nl; }
550 
551  virtual NonlinearSystem & getNonlinearSystem();
552 
553  void addVariable(const std::string & var_name,
554  const FEType & type,
555  Real scale_factor,
556  const std::set<SubdomainID> * const active_subdomains = NULL);
557  void addScalarVariable(const std::string & var_name,
558  Order order,
559  Real scale_factor = 1.,
560  const std::set<SubdomainID> * const active_subdomains = NULL);
561  void
562  addKernel(const std::string & kernel_name, const std::string & name, InputParameters parameters);
563  void addNodalKernel(const std::string & kernel_name,
564  const std::string & name,
565  InputParameters parameters);
566  void addScalarKernel(const std::string & kernel_name,
567  const std::string & name,
568  InputParameters parameters);
569  void addBoundaryCondition(const std::string & bc_name,
570  const std::string & name,
571  InputParameters parameters);
572  void
573  addConstraint(const std::string & c_name, const std::string & name, InputParameters parameters);
574 
575  virtual void setInputParametersFEProblem(InputParameters & parameters)
576  {
577  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
578  }
579 
580  // Aux /////
581  void addAuxVariable(const std::string & var_name,
582  const FEType & type,
583  const std::set<SubdomainID> * const active_subdomains = NULL);
584  void addAuxScalarVariable(const std::string & var_name,
585  Order order,
586  Real scale_factor = 1.,
587  const std::set<SubdomainID> * const active_subdomains = NULL);
588  void addAuxKernel(const std::string & kernel_name,
589  const std::string & name,
590  InputParameters parameters);
591  void addAuxScalarKernel(const std::string & kernel_name,
592  const std::string & name,
593  InputParameters parameters);
594 
595  AuxiliarySystem & getAuxiliarySystem() { return *_aux; }
596 
597  // Dirac /////
598  void addDiracKernel(const std::string & kernel_name,
599  const std::string & name,
600  InputParameters parameters);
601 
602  // DG /////
603  void addDGKernel(const std::string & kernel_name,
604  const std::string & name,
605  InputParameters parameters);
606 
607  // Interface /////
608  void addInterfaceKernel(const std::string & kernel_name,
609  const std::string & name,
610  InputParameters parameters);
611 
612  // IC /////
613  void addInitialCondition(const std::string & ic_name,
614  const std::string & name,
615  InputParameters parameters);
616 
617  void projectSolution();
618 
619  // Materials /////
620  void addMaterial(const std::string & kernel_name,
621  const std::string & name,
622  InputParameters parameters);
623 
629  virtual void prepareMaterials(SubdomainID blk_id, THREAD_ID tid);
630 
631  virtual void reinitMaterials(SubdomainID blk_id, THREAD_ID tid, bool swap_stateful = true);
632  virtual void reinitMaterialsFace(SubdomainID blk_id, THREAD_ID tid, bool swap_stateful = true);
633  virtual void
634  reinitMaterialsNeighbor(SubdomainID blk_id, THREAD_ID tid, bool swap_stateful = true);
635  virtual void
636  reinitMaterialsBoundary(BoundaryID boundary_id, THREAD_ID tid, bool swap_stateful = true);
637  /*
638  * Swap back underlying data storing stateful material properties
639  */
640  virtual void swapBackMaterials(THREAD_ID tid);
641  virtual void swapBackMaterialsFace(THREAD_ID tid);
642  virtual void swapBackMaterialsNeighbor(THREAD_ID tid);
643 
644  // Postprocessors /////
645  virtual void
646  addPostprocessor(std::string pp_name, const std::string & name, InputParameters parameters);
647 
648  // VectorPostprocessors /////
649  virtual void
650  addVectorPostprocessor(std::string pp_name, const std::string & name, InputParameters parameters);
651 
656  void initPostprocessorData(const std::string & name);
657 
658  // UserObjects /////
659  virtual void
660  addUserObject(std::string user_object_name, const std::string & name, InputParameters parameters);
661 
667  const ExecuteMooseObjectWarehouse<UserObject> & getUserObjects() { return _all_user_objects; }
668 
674  template <class T>
675  const T & getUserObject(const std::string & name, unsigned int tid = 0)
676  {
677  if (_all_user_objects.hasActiveObject(name, tid))
678  {
679  auto uo_ptr = std::dynamic_pointer_cast<T>(_all_user_objects.getActiveObject(name, tid));
680  if (uo_ptr == nullptr)
681  mooseError("User object with name '" + name + "' is of wrong type");
682  return *uo_ptr;
683  }
684  mooseError("Unable to find user object with name '" + name + "'");
685  }
691  const UserObject & getUserObjectBase(const std::string & name);
692 
698  bool hasUserObject(const std::string & name);
699 
705  bool hasPostprocessor(const std::string & name);
706 
710  PostprocessorValue & getPostprocessorValue(const PostprocessorName & name);
711 
717  PostprocessorValue & getPostprocessorValueOld(const std::string & name);
718 
724  PostprocessorValue & getPostprocessorValueOlder(const std::string & name);
725 
729  bool hasMultiApps() const { return _multi_apps.hasActiveObjects(); }
730  bool hasMultiApp(const std::string & name);
731 
737  bool hasVectorPostprocessor(const std::string & name);
738 
745  VectorPostprocessorValue & getVectorPostprocessorValue(const VectorPostprocessorName & name,
746  const std::string & vector_name);
747 
754  VectorPostprocessorValue & getVectorPostprocessorValueOld(const std::string & name,
755  const std::string & vector_name);
756 
763  VectorPostprocessorValue & declareVectorPostprocessorVector(const VectorPostprocessorName & name,
764  const std::string & vector_name);
765 
769  bool vectorPostprocessorHasVectors(const std::string & vpp_name)
770  {
771  return _vpps_data.hasVectors(vpp_name);
772  }
773 
778  const std::vector<std::pair<std::string, VectorPostprocessorData::VectorPostprocessorState>> &
779  getVectorPostprocessorVectors(const std::string & vpp_name);
780 
781  // Dampers /////
782  void addDamper(std::string damper_name, const std::string & name, InputParameters parameters);
783  void setupDampers();
784 
788  bool hasDampers() { return _has_dampers; }
789 
790  // Indicators /////
791  void
792  addIndicator(std::string indicator_name, const std::string & name, InputParameters parameters);
793 
794  // Markers //////
795  void addMarker(std::string marker_name, const std::string & name, InputParameters parameters);
796 
800  void addMultiApp(const std::string & multi_app_name,
801  const std::string & name,
802  InputParameters parameters);
803 
807  std::shared_ptr<MultiApp> getMultiApp(const std::string & multi_app_name);
808 
812  std::vector<std::shared_ptr<Transfer>> getTransfers(ExecFlagType type,
813  MultiAppTransfer::DIRECTION direction) const;
814 
820  void execMultiAppTransfers(ExecFlagType type, MultiAppTransfer::DIRECTION direction);
821 
825  bool execMultiApps(ExecFlagType type, bool auto_advance = true);
826 
830  void advanceMultiApps(ExecFlagType type);
831 
835  void backupMultiApps(ExecFlagType type);
836 
841  void restoreMultiApps(ExecFlagType type, bool force = false);
842 
846  Real computeMultiAppsDT(ExecFlagType type);
847 
851  void addTransfer(const std::string & transfer_name,
852  const std::string & name,
853  InputParameters parameters);
854 
861  void execTransfers(ExecFlagType type);
862 
864  void computeTransientImplicitResidual(Real time,
865  const NumericVector<Number> & u,
866  const NumericVector<Number> & udot,
867  NumericVector<Number> & residual);
868 
870  void computeTransientImplicitJacobian(Real time,
871  const NumericVector<Number> & u,
872  const NumericVector<Number> & udot,
873  Real shift,
874  SparseMatrix<Number> & jacobian);
875 
877 
884  virtual Real computeResidualL2Norm();
885 
886  virtual void computeResidual(NonlinearImplicitSystem & sys,
887  const NumericVector<Number> & soln,
888  NumericVector<Number> & residual);
889  virtual void computeResidual(const NumericVector<Number> & soln,
890  NumericVector<Number> & residual);
891  virtual void computeResidualType(const NumericVector<Number> & soln,
892  NumericVector<Number> & residual,
894  virtual void computeJacobian(NonlinearImplicitSystem & sys,
895  const NumericVector<Number> & soln,
896  SparseMatrix<Number> & jacobian);
897  virtual void computeJacobian(const NumericVector<Number> & soln,
898  SparseMatrix<Number> & jacobian,
899  Moose::KernelType kernel_type = Moose::KT_ALL);
908  virtual void computeJacobianBlocks(std::vector<JacobianBlock *> & blocks);
909 
923  virtual void computeJacobianBlock(SparseMatrix<Number> & jacobian,
924  libMesh::System & precond_system,
925  unsigned int ivar,
926  unsigned int jvar);
927 
928  virtual Real computeDamping(const NumericVector<Number> & soln,
929  const NumericVector<Number> & update);
930 
935  virtual bool shouldUpdateSolution();
936 
943  virtual bool updateSolution(NumericVector<Number> & vec_solution,
944  NumericVector<Number> & ghosted_solution);
945 
950  virtual void predictorCleanup(NumericVector<Number> & ghosted_solution);
951 
952  virtual void computeBounds(NonlinearImplicitSystem & sys,
953  NumericVector<Number> & lower,
954  NumericVector<Number> & upper);
955  virtual void computeNearNullSpace(NonlinearImplicitSystem & sys,
956  std::vector<NumericVector<Number> *> & sp);
957  virtual void computeNullSpace(NonlinearImplicitSystem & sys,
958  std::vector<NumericVector<Number> *> & sp);
959  virtual void computeTransposeNullSpace(NonlinearImplicitSystem & sys,
960  std::vector<NumericVector<Number> *> & sp);
961  virtual void computePostCheck(NonlinearImplicitSystem & sys,
962  const NumericVector<Number> & old_soln,
963  NumericVector<Number> & search_direction,
964  NumericVector<Number> & new_soln,
965  bool & changed_search_direction,
966  bool & changed_new_soln);
967 
968  virtual void computeIndicatorsAndMarkers();
969  virtual void computeIndicators();
970  virtual void computeMarkers();
971 
972  virtual NumericVector<Number> & residualVector(Moose::KernelType type);
973 
974  virtual void addResidual(THREAD_ID tid) override;
975  virtual void addResidualNeighbor(THREAD_ID tid) override;
976  virtual void addResidualScalar(THREAD_ID tid = 0);
977 
978  virtual void cacheResidual(THREAD_ID tid) override;
979  virtual void cacheResidualNeighbor(THREAD_ID tid) override;
980  virtual void addCachedResidual(THREAD_ID tid) override;
981 
989  virtual void addCachedResidualDirectly(NumericVector<Number> & residual, THREAD_ID tid);
990 
991  virtual void setResidual(NumericVector<Number> & residual, THREAD_ID tid) override;
992  virtual void setResidualNeighbor(NumericVector<Number> & residual, THREAD_ID tid) override;
993 
994  virtual void addJacobian(SparseMatrix<Number> & jacobian, THREAD_ID tid) override;
995  virtual void addJacobianNeighbor(SparseMatrix<Number> & jacobian, THREAD_ID tid) override;
996  virtual void addJacobianBlock(SparseMatrix<Number> & jacobian,
997  unsigned int ivar,
998  unsigned int jvar,
999  const DofMap & dof_map,
1000  std::vector<dof_id_type> & dof_indices,
1001  THREAD_ID tid) override;
1002  virtual void addJacobianNeighbor(SparseMatrix<Number> & jacobian,
1003  unsigned int ivar,
1004  unsigned int jvar,
1005  const DofMap & dof_map,
1006  std::vector<dof_id_type> & dof_indices,
1007  std::vector<dof_id_type> & neighbor_dof_indices,
1008  THREAD_ID tid) override;
1009  virtual void addJacobianScalar(SparseMatrix<Number> & jacobian, THREAD_ID tid = 0);
1010  virtual void
1011  addJacobianOffDiagScalar(SparseMatrix<Number> & jacobian, unsigned int ivar, THREAD_ID tid = 0);
1012 
1013  virtual void cacheJacobian(THREAD_ID tid) override;
1014  virtual void cacheJacobianNeighbor(THREAD_ID tid) override;
1015  virtual void addCachedJacobian(SparseMatrix<Number> & jacobian, THREAD_ID tid) override;
1016 
1017  virtual void prepareShapes(unsigned int var, THREAD_ID tid) override;
1018  virtual void prepareFaceShapes(unsigned int var, THREAD_ID tid) override;
1019  virtual void prepareNeighborShapes(unsigned int var, THREAD_ID tid) override;
1020 
1021  // Displaced problem /////
1022  virtual void addDisplacedProblem(std::shared_ptr<DisplacedProblem> displaced_problem);
1023  virtual std::shared_ptr<DisplacedProblem> getDisplacedProblem() { return _displaced_problem; }
1024 
1025  virtual void updateGeomSearch(
1027 
1028  virtual void possiblyRebuildGeomSearchPatches();
1029 
1030  virtual GeometricSearchData & geomSearchData() override { return _geometric_search_data; }
1031 
1036  void setRestartFile(const std::string & file_name);
1037 
1039 
1043  const MaterialPropertyStorage & getMaterialPropertyStorage() { return _material_props; }
1044  const MaterialPropertyStorage & getBndMaterialPropertyStorage() { return _bnd_material_props; }
1046 
1048 
1051  const MooseObjectWarehouse<Indicator> & getIndicatorWarehouse() { return _indicators; }
1053  {
1054  return _internal_side_indicators;
1055  }
1056  const MooseObjectWarehouse<Marker> & getMarkerWarehouse() { return _markers; }
1058 
1063 
1067  SolverParams & solverParams();
1068 
1069 #ifdef LIBMESH_ENABLE_AMR
1070  // Adaptivity /////
1071  Adaptivity & adaptivity() { return _adaptivity; }
1072  virtual void initialAdaptMesh();
1073  virtual void adaptMesh();
1077  unsigned int getNumCyclesCompleted() { return _cycles_completed; }
1078 
1082  bool hasInitialAdaptivity() const { return _adaptivity.getInitialSteps() > 0; }
1083 #else
1084 
1087  bool hasInitialAdaptivity() const { return false; }
1088 #endif // LIBMESH_ENABLE_AMR
1089 
1091  void initXFEM(std::shared_ptr<XFEMInterface> xfem);
1092 
1094  std::shared_ptr<XFEMInterface> getXFEM() { return _xfem; }
1095 
1097  bool haveXFEM() { return _xfem != NULL; }
1098 
1100  virtual bool updateMeshXFEM();
1101 
1102  virtual void meshChanged() override;
1103 
1108  void notifyWhenMeshChanges(MeshChangedInterface * mci);
1109 
1110  virtual void checkProblemIntegrity();
1111 
1112  void serializeSolution();
1113 
1114  // debugging iface /////
1115 
1116  void setKernelTypeResidual(Moose::KernelType kt) { _kernel_type = kt; }
1117 
1122  void setConstJacobian(bool state) { _const_jacobian = state; }
1123 
1124  void registerRandomInterface(RandomInterface & random_interface, const std::string & name);
1125 
1126  void setKernelCoverageCheck(bool flag) { _kernel_coverage_check = flag; }
1127 
1128  void setMaterialCoverageCheck(bool flag) { _material_coverage_check = flag; }
1129 
1133  void parentOutputPositionChanged();
1134 
1136 
1153  bool needMaterialOnSide(BoundaryID bnd_id, THREAD_ID tid);
1154  bool needMaterialOnSide(SubdomainID subdomain_id, THREAD_ID tid);
1156 
1161  unsigned int subspaceDim(const std::string & prefix) const
1162  {
1163  if (_subspace_dim.count(prefix))
1164  return _subspace_dim.find(prefix)->second;
1165  else
1166  return 0;
1167  }
1168 
1169  /*
1170  * Return a reference to the material warehouse of *all* Material objects.
1171  */
1172  const MaterialWarehouse & getMaterialWarehouse() { return _all_materials; }
1173 
1174  /*
1175  * Return a reference to the material warehouse of Material objects to be computed.
1176  */
1177  const MaterialWarehouse & getComputeMaterialWarehouse() { return _materials; }
1178  const MaterialWarehouse & getDiscreteMaterialWarehouse() { return _discrete_materials; }
1179 
1187  std::shared_ptr<Material> getMaterial(std::string name,
1189  THREAD_ID tid = 0,
1190  bool no_warn = false);
1191 
1192  /*
1193  * Return a pointer to the MaterialData
1194  */
1195  std::shared_ptr<MaterialData> getMaterialData(Moose::MaterialDataType type, THREAD_ID tid = 0);
1196 
1201  bool errorOnJacobianNonzeroReallocation() { return _error_on_jacobian_nonzero_reallocation; }
1202 
1204  {
1205  _error_on_jacobian_nonzero_reallocation = state;
1206  }
1207 
1208  bool ignoreZerosInJacobian() { return _ignore_zeros_in_jacobian; }
1209 
1210  void setIgnoreZerosInJacobian(bool state) { _ignore_zeros_in_jacobian = state; }
1211 
1213  bool hasTimeIntegrator() const { return _has_time_integrator; }
1214 
1221  const ExecFlagType & getCurrentExecuteOnFlag() const;
1222 
1226  void execute(const ExecFlagType & exec_type);
1227 
1231  virtual void computeUserObjects(const ExecFlagType & type, const Moose::AuxGroup & group);
1232  template <typename T>
1233  void initializeUserObjects(const MooseObjectWarehouse<T> & warehouse);
1234  template <typename T>
1235  void finalizeUserObjects(const MooseObjectWarehouse<T> & warehouse);
1236 
1240  virtual void computeAuxiliaryKernels(const ExecFlagType & type);
1241 
1245  void needsPreviousNewtonIteration(bool state);
1246 
1251  bool needsPreviousNewtonIteration();
1252 
1256  bool skipAdditionalRestartData() const { return _skip_additional_restart_data; }
1257 
1258 public:
1260 
1264  std::vector<Real> _real_zero;
1265  std::vector<VariableValue> _zero;
1266  std::vector<VariableGradient> _grad_zero;
1267  std::vector<VariableSecond> _second_zero;
1268  std::vector<VariablePhiSecond> _second_phi_zero;
1270 
1275 
1279  void executeControls(const ExecFlagType & exec_type);
1280 
1284  void executeSamplers(const ExecFlagType & exec_type);
1285 
1289  void updateActiveObjects();
1290 
1296  void reportMooseObjectDependency(MooseObject * a, MooseObject * b);
1297 
1299 
1300 protected:
1302 
1305  VectorPostprocessorData & getVectorPostprocessorData();
1307 
1309  EquationSystems _eq;
1312 
1314  bool _solve;
1315 
1317  Real & _time;
1318  Real & _time_old;
1319  int & _t_step;
1320  Real & _dt;
1321  Real & _dt_old;
1322 
1323  std::shared_ptr<NonlinearSystemBase> _nl;
1324  std::shared_ptr<AuxiliarySystem> _aux;
1325 
1327  std::unique_ptr<CouplingMatrix> _cm;
1328 
1329  // Dimension of the subspace spanned by the vectors with a given prefix
1330  std::map<std::string, unsigned int> _subspace_dim;
1331 
1332  std::vector<Assembly *> _assembly;
1333 
1336 
1339 
1342 
1345 
1348 
1354 
1355  // material properties
1358 
1359  std::vector<std::shared_ptr<MaterialData>> _material_data;
1360  std::vector<std::shared_ptr<MaterialData>> _bnd_material_data;
1361  std::vector<std::shared_ptr<MaterialData>> _neighbor_material_data;
1362 
1364  // Material Warehouses
1365  MaterialWarehouse _materials; // Traditional materials that MOOSE computes
1366  MaterialWarehouse _discrete_materials; // Materials that the user must compute
1367  MaterialWarehouse _all_materials; // All materials for error checking and MaterialData storage
1369 
1371  // Indicator Warehouses
1375 
1376  // Marker Warehouse
1378 
1379  // postprocessors
1381 
1382  // VectorPostprocessors
1384 
1394 
1397 
1400 
1403 
1406 
1409 
1411  std::map<std::string, std::unique_ptr<RandomData>> _random_data_objects;
1412 
1414  std::vector<std::unordered_map<SubdomainID, bool>> _block_mat_side_cache;
1415 
1417  std::vector<std::unordered_map<BoundaryID, bool>> _bnd_mat_side_cache;
1418 
1420  std::vector<MeshChangedInterface *> _notify_when_mesh_changes;
1421 
1423  bool duplicateVariableCheck(const std::string & var_name, const FEType & type, bool is_aux);
1424 
1426  void checkDisplacementOrders();
1427 
1428  void checkUserObjects();
1429 
1435  void checkDependMaterialsHelper(
1436  const std::map<SubdomainID, std::vector<std::shared_ptr<Material>>> & materials_map);
1437 
1439  void checkCoordinateSystems();
1440 
1444  void reinitBecauseOfGhostingOrNewGeomObjects();
1445 
1446 #ifdef LIBMESH_ENABLE_AMR
1448  unsigned int _cycles_completed;
1449 #endif
1450 
1452  std::shared_ptr<XFEMInterface> _xfem;
1453 
1454  // Displaced mesh /////
1456  std::shared_ptr<DisplacedProblem> _displaced_problem;
1458 
1461 
1464 
1467 
1470 
1473 
1475  std::unique_ptr<Resurrector> _resurrector;
1476 
1479 
1482 
1485 
1489 
1490  std::vector<std::vector<MooseVariable *>> _uo_jacobian_moose_vars;
1491 
1493 
1496 
1499 
1501  unsigned int _max_qps;
1502 
1504  unsigned int _max_shape_funcs;
1505 
1508 
1511 
1514 
1516  std::string _exception_message;
1517 
1520 
1523 
1524 #ifdef LIBMESH_HAVE_PETSC
1525  Moose::PetscSupport::PetscOptions _petsc_options;
1527 #endif // LIBMESH_HAVE_PETSC
1528 
1529 private:
1535 
1538 
1541 
1542  friend class AuxiliarySystem;
1543  friend class NonlinearSystemBase;
1544  friend class MooseEigenSystem;
1545  friend class Resurrector;
1546  friend class RestartableDataIO;
1547  friend class Restartable;
1548  friend class DisplacedProblem;
1549 };
1550 
1551 template <typename T>
1552 void
1554 {
1555  _app.getOutputWarehouse().allowOutput<T>(state);
1556 }
1557 
1558 template <typename T>
1559 void
1561 {
1562  if (warehouse.hasActiveObjects())
1563  {
1564  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
1565  {
1566  const auto & objects = warehouse.getActiveObjects(tid);
1567  for (const auto & object : objects)
1568  object->initialize();
1569  }
1570  }
1571 }
1572 
1573 template <typename T>
1574 void
1576 {
1577  if (warehouse.hasActiveObjects())
1578  {
1579  const auto & objects = warehouse.getActiveObjects(0);
1580 
1581  // Join them down to processor 0
1582  for (THREAD_ID tid = 1; tid < libMesh::n_threads(); ++tid)
1583  {
1584  const auto & other_objects = warehouse.getActiveObjects(tid);
1585 
1586  for (unsigned int i = 0; i < objects.size(); ++i)
1587  objects[i]->threadJoin(*(other_objects[i]));
1588  }
1589 
1590  // Finalize them and save off PP values
1591  for (auto & object : objects)
1592  {
1593  object->finalize();
1594 
1595  auto pp = std::dynamic_pointer_cast<Postprocessor>(object);
1596 
1597  if (pp)
1598  _pps_data.storeValue(pp->PPName(), pp->getValue());
1599  }
1600  }
1601 }
1602 
1603 #endif /* FEPROBLEMBASE_H */
bool errorOnJacobianNonzeroReallocation()
Will return True if the user wants to get an error when a nonzero is reallocated in the Jacobian by P...
bool _reinit_displaced_elem
Interface for objects that need parallel consistent random numbers without patterns over the course o...
Class for doing restart.
Definition: Resurrector.h:32
Helper class for holding the preconditioning blocks to fill.
bool hasTimeIntegrator() const
Returns whether or not this Problem has a TimeIntegrator.
virtual Real & timeOld() const
Moose::PetscSupport::PetscOptions & getPetscOptions()
Retrieve a writable reference the PETSc options (used by PetscSupport)
Base class for function objects.
Definition: Function.h:46
const CouplingMatrix * couplingMatrix()
A class for creating restricted objects.
Definition: Restartable.h:31
std::vector< std::shared_ptr< MaterialData > > _neighbor_material_data
MaterialPropertyStorage & _bnd_material_props
SolverParams _solver_params
virtual void setInputParametersFEProblem(InputParameters &parameters)
ExecFlagType _current_execute_on_flag
Current execute_on flag.
Keeps track of stuff related to assembling.
Definition: Assembly.h:63
bool _error_on_jacobian_nonzero_reallocation
Class for stuff related to variables.
Definition: MooseVariable.h:43
NonlinearSystemBase & getNonlinearSystemBase()
std::shared_ptr< NonlinearSystemBase > _nl
bool _has_jacobian
Indicates if the Jacobian was computed.
bool hasMultiApps() const
Returns whether or not the current simulation has any multiapps.
bool _has_dampers
Whether or not this system has any Dampers associated with it.
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
This is the base class for Samplers.
Definition: Sampler.h:46
subdomain_id_type SubdomainID
Definition: MooseTypes.h:77
const std::vector< MooseVariable * > & getUserObjectJacobianVariables(THREAD_ID tid) const
Warehouse for storing initial conditions.
virtual Assembly & assembly(THREAD_ID tid) override
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.
AuxGroupExecuteMooseObjectWarehouse< NodalUserObject > _nodal_user_objects
unsigned int _cycles_completed
AuxGroupExecuteMooseObjectWarehouse< ElementUserObject > _elemental_user_objects
bool ignoreZerosInJacobian()
Class for doing restart.
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
A struct for storing the various types of petsc options and values.
Definition: PetscSupport.h:41
MaterialDataType
MaterialData types.
Definition: MooseTypes.h:129
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Stores the stateful material properties computed by materials.
Definition: Marker.h:42
virtual Real & time() const
void setErrorOnJacobianNonzeroReallocation(bool state)
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
MultiApp Implementation for Transient Apps.
virtual bool currentlyComputingJacobian()
Returns true if we are currently computing Jacobian.
std::vector< VariableSecond > _second_zero
All Distributions should inherit from this class.
Definition: Distribution.h:28
bool _has_exception
Whether or not an exception has occurred.
bool _needs_old_newton_iter
Indicates that we need to compute variable values for previous Newton iteration.
bool haveXFEM()
Find out whether the current analysis is using XFEM.
bool _has_time_integrator
Indicates whether or not this executioner has a time integrator (during setup)
ExecuteMooseObjectWarehouse< MultiApp > & getMultiAppWarehouse()
Material objects are special in that they have additional objects created automatically (see FEProble...
ExecuteMooseObjectWarehouse< TransientMultiApp > _transient_multi_apps
Storage for TransientMultiApps (only needed for calling &#39;computeDT&#39;)
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
bool _ignore_zeros_in_jacobian
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
void initializeUserObjects(const MooseObjectWarehouse< T > &warehouse)
const MaterialPropertyStorage & getBndMaterialPropertyStorage()
bool hasInitialAdaptivity() const
Return a Boolean indicating whether initial AMR is turned on.
unsigned int getNumCyclesCompleted()
bool hasDampers()
Whether or not this system has dampers.
std::vector< std::shared_ptr< MaterialData > > _bnd_material_data
std::unique_ptr< CouplingMatrix > _cm
Coupling matrix for variables.
bool skipAdditionalRestartData() const
Whether or not to skip loading the additional data when restarting.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
std::vector< std::unordered_map< BoundaryID, bool > > _bnd_mat_side_cache
Cache for calculating materials on side.
const InitialConditionWarehouse & getInitialConditionWarehouse() const
Return InitialCondition storage.
bool vectorPostprocessorHasVectors(const std::string &vpp_name)
Whether or not the specified VectorPostprocessor has declared any vectors.
ExecuteMooseObjectWarehouse< UserObject > _all_user_objects
AuxGroup
Flag for AuxKernel related exeuction type.
Definition: MooseTypes.h:140
virtual GeometricSearchData & geomSearchData() override
virtual EquationSystems & es() override
std::vector< Assembly * > _assembly
NonlinearSystemBase * nl
Nonlinear system to be solved.
A user object that runs over all the nodes and does an aggregation step to compute a single value...
ExecuteMooseObjectWarehouse< Transfer > _transfers
Normal Transfers.
MooseLinearConvergenceReason
bool _calculate_jacobian_in_uo
MooseObjectWarehouse< IntegratedBC > _nonlocal_integrated_bcs
nonlocal integrated_bcs
MooseObjectWarehouse< InternalSideIndicator > _internal_side_indicators
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
Interface for notifications that the mesh has changed.
virtual std::shared_ptr< DisplacedProblem > getDisplacedProblem()
This is the common base class for the two main kernel types implemented in MOOSE, EigenKernel and Ker...
Definition: KernelBase.h:47
bool _input_file_saved
whether input file has been written
Moose::CouplingType _coupling
Type of variable coupling.
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:36
PostprocessorData _pps_data
const MaterialWarehouse & getComputeMaterialWarehouse()
const ExecuteMooseObjectWarehouse< UserObject > & getUserObjects()
Return the storage of all UserObjects.
std::vector< MeshChangedInterface * > _notify_when_mesh_changes
Objects to be notified when the mesh changes.
void finalizeUserObjects(const MooseObjectWarehouse< T > &warehouse)
Real PostprocessorValue
MOOSE typedefs.
Definition: MooseTypes.h:73
DofMap & dof_map
std::vector< std::unordered_map< SubdomainID, bool > > _block_mat_side_cache
Cache for calculating materials on side.
std::shared_ptr< AuxiliarySystem > _aux
virtual int & timeStep() const
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:74
const MaterialPropertyStorage & getMaterialPropertyStorage()
Return a reference to the material property storage.
MooseMesh & _mesh
bool hasActiveObjects(THREAD_ID tid=0) const
Convenience functions for determining if objects exist.
unsigned int _max_shape_funcs
Maximum number of shape functions on any element in the problem.
virtual bool isTransient() const override
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:37
Adaptivity _adaptivity
VectorPostprocessorData _vpps_data
Base class for deriving any boundary condition of a integrated type.
Definition: IntegratedBC.h:33
bool _currently_computing_jacobian
Whether or not the system is currently computing the Jacobian matrix.
std::vector< VariablePhiSecond > _second_phi_zero
bool _started_initial_setup
At or beyond initialSteup stage.
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
virtual Real & dt() const
Base class for all Postprocessors.
Definition: Postprocessor.h:35
std::string _exception_message
The error message to go with an exception.
void setKernelTypeResidual(Moose::KernelType kt)
AuxiliarySystem & getAuxiliarySystem()
bool _kernel_coverage_check
Determines whether a check to verify an active kernel on every subdomain.
MooseObjectWarehouse< Indicator > _indicators
std::unique_ptr< Resurrector > _resurrector
Object responsible for restart (read/write)
KernelType
Definition: MooseTypes.h:162
const NonlinearSystemBase & getNonlinearSystemBase() const
const MooseObjectWarehouse< Indicator > & getIndicatorWarehouse()
Return indicator/marker storage.
InitialConditions are objects that set the initial value of variables.
GeometricSearchType
Used to select groups of geometric search objects to update.
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
ExecuteMooseObjectWarehouse< Sampler > _samplers
Samplers.
CoordinateSystemType
Definition: MooseTypes.h:212
Materials compute MaterialProperties.
Definition: Material.h:53
bool _solve
Whether or not to actually solve the nonlinear system.
const MaterialWarehouse & getMaterialWarehouse()
void setKernelCoverageCheck(bool flag)
This is the XFEMInterface class.
Definition: XFEMInterface.h:43
MooseNonlinearConvergenceReason
Definition: FEProblemBase.h:89
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:74
MatType type
InitialConditionWarehouse _ics
MaterialWarehouse _discrete_materials
bool _reinit_displaced_face
The InternalSideIndicator class is responsible for calculating the residuals for various physics on i...
unsigned int subspaceDim(const std::string &prefix) const
Dimension of the subspace spanned by vectors with a given prefix.
Takes care of everything related to mesh adaptivity.
Definition: Adaptivity.h:48
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:53
void setConstJacobian(bool state)
Set flag that Jacobian is constant (for optimization purposes)
Base class for Control objects.
Definition: Control.h:43
std::vector< VariableGradient > _grad_zero
std::vector< std::vector< MooseVariable * > > _uo_jacobian_moose_vars
PetscInt n
virtual Real & dtOld() const
void allowOutput(bool state)
Ability to enable/disable output calls This is private, users should utilize FEProblemBase::allowOutp...
Nonlinear system to be solved.
InputParameters validParams< FEProblemBase >()
AuxGroupExecuteMooseObjectWarehouse< SideUserObject > _side_user_objects
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:108
std::shared_ptr< XFEMInterface > getXFEM()
Get a pointer to the XFEM controller object.
Class for scalar variables (they are different).
virtual MooseMesh & mesh() override
std::vector< VariableValue > _zero
CouplingType
Definition: MooseTypes.h:171
bool _skip_additional_restart_data
std::shared_ptr< DisplacedProblem > _displaced_problem
GeometricSearchData _geometric_search_data
Moose::CouplingType coupling()
MooseObjectWarehouse< Function > _functions
functions
Proxy for accessing MaterialPropertyStorage.
Definition: MaterialData.h:33
bool _has_initialized_stateful
Whether nor not stateful materials have been initialized.
unsigned int _max_qps
Maximum number of quadrature points used in the problem.
void setMaterialCoverageCheck(bool flag)
ExecFlagType
Execution flags - when is the object executed/evaluated.
Definition: MooseTypes.h:90
const T & getUserObject(const std::string &name, unsigned int tid=0)
Get the user object by its name.
std::map< std::string, unsigned int > _subspace_dim
EquationSystems _eq
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
ExecuteMooseObjectWarehouse< Control > & getControlWarehouse()
Reference to the control logic warehouse.
const MooseObjectWarehouse< Marker > & getMarkerWarehouse()
bool _has_constraints
Whether or not this system has any Constraints.
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.
const MaterialWarehouse & getDiscreteMaterialWarehouse()
bool _const_jacobian
true if the Jacobian is constant
AuxGroupExecuteMooseObjectWarehouse< InternalSideUserObject > _internal_side_user_objects
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:59
MaterialPropertyStorage & _material_props
const std::vector< std::shared_ptr< T > > & getActiveObjects(THREAD_ID tid=0) const
Retrieve complete vector to the active all/block/boundary restricted objects for a given thread...
Adaptivity & adaptivity()
MooseObjectWarehouse< Marker > _markers
virtual bool hasException()
Whether or not an exception has occurred.
MooseObjectWarehouseBase< Distribution > _distributions
distributions
bool _material_coverage_check
Determines whether a check to verify an active material on every subdomain.
Order _max_scalar_order
Maximum scalar variable order.
MaterialWarehouse _all_materials
A system that holds auxiliary variables.
Base class for user-specific data.
Definition: UserObject.h:42
MooseObjectWarehouseBase< ScalarInitialCondition > _scalar_ics
std::vector< std::shared_ptr< MaterialData > > _material_data
void allowOutput(bool state)
Ability to enable/disable all output calls.
const MooseObjectWarehouse< InternalSideIndicator > & getInternalSideIndicatorWarehouse()
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:841
void setIgnoreZerosInJacobian(bool state)
MooseMesh * _displaced_mesh
Moose::KernelType _kernel_type
AuxGroupExecuteMooseObjectWarehouse< GeneralUserObject > _general_user_objects
boundary_id_type BoundaryID
Definition: MooseTypes.h:75
unsigned int THREAD_ID
Definition: MooseTypes.h:79
MaterialWarehouse _materials
bool _fail_next_linear_convergence_check
virtual bool startedInitialSetup()
Returns true if we are in or beyond the initialSetup stage.
Base class for all Transfer objects.
Definition: Transfer.h:46
std::vector< Real > _real_zero
Convenience zeros.
MooseObjectWarehouse< KernelBase > _nonlocal_kernels
nonlocal kernels