https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
MFEMProblem Class Referenceabstract

#include <MFEMProblem.h>

Inheritance diagram for MFEMProblem:
[legend]

Public Types

enum  Direction : unsigned char { Direction::TO_EXTERNAL_APP, Direction::FROM_EXTERNAL_APP }
 
enum  CoverageCheckMode {
  CoverageCheckMode::FALSE, CoverageCheckMode::TRUE, CoverageCheckMode::OFF, CoverageCheckMode::ON,
  CoverageCheckMode::SKIP_LIST, CoverageCheckMode::ONLY_LIST
}
 
using DataFileParameterType = DataFileName
 The parameter type this interface expects for a data file name. More...
 

Public Member Functions

 MFEMProblem (const InputParameters &params)
 
virtual ~MFEMProblem ()
 
virtual void initialSetup () override
 
virtual void externalSolve () override
 New interface for solving an External problem. More...
 
virtual void syncSolutions (Direction) override
 Method to transfer data to/from the external application to the associated transfer mesh. More...
 
virtual MFEMMeshmesh () override
 Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMesh. More...
 
virtual const MFEMMeshmesh () const override
 
virtual std::vector< VariableName > getAuxVariableNames ()
 Returns all the variable names from the auxiliary system base. More...
 
void addBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters) override
 
void addMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters) override
 
void addFunctorMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters) override
 
void addFESpace (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
 Add an MFEM FESpace to the problem. More...
 
void setDevice ()
 Set the device to use to solve the FE problem. More...
 
void setMesh ()
 Set the mesh used by MFEM. More...
 
void addSubMesh (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
 Add an MFEM SubMesh to the problem. More...
 
void addTransfer (const std::string &transfer_name, const std::string &name, InputParameters &parameters) override
 Add transfers between MultiApps and/or MFEM SubMeshes. More...
 
void addVariable (const std::string &var_type, const std::string &var_name, InputParameters &parameters) override
 Override of ExternalProblem::addVariable. More...
 
void addGridFunction (const std::string &var_type, const std::string &var_name, InputParameters &parameters)
 Adds one MFEM GridFunction to be used in the MFEM solve. More...
 
void addAuxVariable (const std::string &var_type, const std::string &var_name, InputParameters &parameters) override
 Override of ExternalProblem::addAuxVariable. More...
 
void addKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters) override
 Override of ExternalProblem::addKernel. More...
 
void addAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters) override
 Override of ExternalProblem::addAuxKernel. More...
 
void addFunction (const std::string &type, const std::string &name, InputParameters &parameters) override
 Override of ExternalProblem::addFunction. More...
 
void addInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters) override
 
void addPostprocessor (const std::string &type, const std::string &name, InputParameters &parameters) override
 Override of ExternalProblem::addPostprocessor. More...
 
void addMFEMPreconditioner (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
 Method called in AddMFEMPreconditionerAction which will create the solver. More...
 
void addMFEMSolver (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
 Method called in AddMFEMSolverAction which will create the solver. More...
 
void addMFEMNonlinearSolver ()
 Add the nonlinear solver to the system. More...
 
InputParameters addMFEMFESpaceFromMOOSEVariable (InputParameters &moosevar_params)
 Method used to get an mfem FEC depending on the variable family specified in the input file. More...
 
Moose::MFEM::CoefficientManagergetCoefficients ()
 Method to get the PropertyManager object for storing material properties and converting them to MFEM coefficients. More...
 
MFEMProblemDatagetProblemData ()
 Method to get the current MFEMProblemData object storing the current data specifying the FE problem. More...
 
void displaceMesh ()
 Displace the mesh, if mesh displacement is enabled. More...
 
std::optional< std::reference_wrapper< mfem::ParGridFunction const > > getMeshDisplacementGridFunction ()
 Returns optional reference to the displacement GridFunction to apply to nodes. More...
 
Moose::FEBackend feBackend () const override
 
std::string solverTypeString (unsigned int solver_sys_num) override
 Return solver type as a human readable string. More...
 
std::shared_ptr< mfem::ParGridFunction > getGridFunction (const std::string &name)
 
virtual void solve (unsigned int nl_sys_num=0) override final
 Solve is implemented to providing syncing to/from the "transfer" mesh. More...
 
virtual void addExternalVariables ()
 Method called to add AuxVariables to the simulation. More...
 
virtual libMesh::EquationSystemses () override
 
const MooseMeshmesh (bool use_displaced) const override
 
void setCoordSystem (const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
 
void setAxisymmetricCoordAxis (const MooseEnum &rz_coord_axis)
 
void setCoupling (Moose::CouplingType type)
 Set the coupling between variables TODO: allow user-defined coupling. More...
 
Moose::CouplingType coupling () const
 
void setCouplingMatrix (std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)
 Set custom coupling matrix. More...
 
void setCouplingMatrix (libMesh::CouplingMatrix *cm, const unsigned int nl_sys_num)
 
const libMesh::CouplingMatrixcouplingMatrix (const unsigned int nl_sys_num) const override
 The coupling matrix defining what blocks exist in the preconditioning matrix. More...
 
void setNonlocalCouplingMatrix ()
 Set custom coupling matrix for variables requiring nonlocal contribution. More...
 
bool areCoupled (const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const
 
bool hasUOAuxStateCheck () const
 Whether or not MOOSE will perform a user object/auxiliary kernel state check. More...
 
bool checkingUOAuxState () const
 Return a flag to indicate whether we are executing user objects and auxliary kernels for state check Note: This function can return true only when hasUOAuxStateCheck() returns true, i.e. More...
 
void trustUserCouplingMatrix ()
 Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a full coupling matrix. More...
 
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & couplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)
 
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & nonlocalCouplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)
 
virtual bool hasVariable (const std::string &var_name) const override
 Whether or not this problem has the variable. More...
 
bool hasSolverVariable (const std::string &var_name) const
 
virtual const MooseVariableFieldBasegetVariable (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 (Nonlinear vs. More...
 
virtual const MooseVariableFieldBasegetVariable (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 (Nonlinear vs. More...
 
virtual MooseVariableFieldBasegetVariable (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)
 
virtual MooseVariableFieldBasegetVariable (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)
 
MooseVariableFieldBasegetActualFieldVariable (const THREAD_ID tid, const std::string &var_name) override
 Returns the variable reference for requested MooseVariableField which may be in any system. More...
 
virtual MooseVariablegetStandardVariable (const THREAD_ID tid, const std::string &var_name) override
 Returns the variable reference for requested MooseVariable which may be in any system. More...
 
virtual VectorMooseVariablegetVectorVariable (const THREAD_ID tid, const std::string &var_name) override
 Returns the variable reference for requested VectorMooseVariable which may be in any system. More...
 
virtual ArrayMooseVariablegetArrayVariable (const THREAD_ID tid, const std::string &var_name) override
 Returns the variable reference for requested ArrayMooseVariable which may be in any system. More...
 
virtual bool hasScalarVariable (const std::string &var_name) const override
 Returns a Boolean indicating whether any system contains a variable with the name provided. More...
 
virtual MooseVariableScalargetScalarVariable (const THREAD_ID tid, const std::string &var_name) override
 Returns the scalar variable reference from whichever system contains it. More...
 
virtual libMesh::SystemgetSystem (const std::string &var_name) override
 Returns the equation system containing the variable provided. More...
 
virtual void setActiveElementalMooseVariables (const std::set< MooseVariableFEBase *> &moose_vars, const THREAD_ID tid) override
 Set the MOOSE variables to be reinited on each element. More...
 
virtual void clearActiveElementalMooseVariables (const THREAD_ID tid) override
 Clear the active elemental MooseVariableFEBase. More...
 
virtual void clearActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) override
 
virtual void clearActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) override
 
virtual void setActiveFEVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid) override
 
virtual void setActiveFEVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid) override
 
virtual void clearActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) override
 
virtual void clearActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) override
 
virtual void setActiveScalarVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid) override
 
virtual void setActiveScalarVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid) override
 
virtual void createQRules (libMesh::QuadratureType type, libMesh::Order order, libMesh::Order volume_order=libMesh::INVALID_ORDER, libMesh::Order face_order=libMesh::INVALID_ORDER, SubdomainID block=Moose::ANY_BLOCK_ID, bool allow_negative_qweights=true)
 
void bumpVolumeQRuleOrder (libMesh::Order order, SubdomainID block)
 Increases the element/volume quadrature order for the specified mesh block if and only if the current volume quadrature order is lower. More...
 
void bumpAllQRuleOrder (libMesh::Order order, SubdomainID block)
 
unsigned int getMaxQps () const
 
libMesh::Order getMaxScalarOrder () const
 
void checkNonlocalCoupling ()
 
void checkUserObjectJacobianRequirement (THREAD_ID tid)
 
void setVariableAllDoFMap (const std::vector< const MooseVariableFEBase *> &moose_vars)
 
const std::vector< const MooseVariableFEBase * > & getUserObjectJacobianVariables (const THREAD_ID tid) const
 
virtual Assemblyassembly (const THREAD_ID tid, const unsigned int sys_num) override
 
virtual const Assemblyassembly (const THREAD_ID tid, const unsigned int sys_num) const override
 
Moose::Kokkos::AssemblykokkosAssembly ()
 
const Moose::Kokkos::AssemblykokkosAssembly () const
 
virtual std::vector< VariableName > getVariableNames ()
 Returns a list of all the variables in the problem (both from the NL and Aux systems. More...
 
void checkDuplicatePostprocessorVariableNames ()
 
void timestepSetup () override
 
void customSetup (const ExecFlagType &exec_type) override
 
void residualSetup () override
 
void jacobianSetup () override
 
virtual void prepare (const Elem *elem, const THREAD_ID tid) override
 
virtual void prepare (const Elem *elem, unsigned int ivar, unsigned int jvar, const std::vector< dof_id_type > &dof_indices, const THREAD_ID tid) override
 
virtual void prepareFace (const Elem *elem, const THREAD_ID tid) override
 
virtual void setCurrentSubdomainID (const Elem *elem, const THREAD_ID tid) override
 
virtual void setNeighborSubdomainID (const Elem *elem, unsigned int side, const THREAD_ID tid) override
 
virtual void setNeighborSubdomainID (const Elem *elem, const THREAD_ID tid)
 
virtual void prepareAssembly (const THREAD_ID tid) override
 
virtual void addGhostedElem (dof_id_type elem_id) override
 Will make sure that all dofs connected to elem_id are ghosted to this processor. More...
 
virtual void addGhostedBoundary (BoundaryID boundary_id) override
 Will make sure that all necessary elements from boundary_id are ghosted to this processor. More...
 
virtual void ghostGhostedBoundaries () override
 Causes the boundaries added using addGhostedBoundary to actually be ghosted. More...
 
virtual void sizeZeroes (unsigned int size, const THREAD_ID tid)
 
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. More...
 
virtual void reinitElem (const Elem *elem, const THREAD_ID tid) override
 
virtual void reinitElemPhys (const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid) override
 
void reinitElemFace (const Elem *elem, unsigned int side, BoundaryID, const THREAD_ID tid)
 
virtual void reinitElemFace (const Elem *elem, unsigned int side, const THREAD_ID tid) override
 
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
 
virtual void reinitNode (const Node *node, const THREAD_ID tid) override
 
virtual void reinitNodeFace (const Node *node, BoundaryID bnd_id, const THREAD_ID tid) override
 
virtual void reinitNodes (const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
 
virtual void reinitNodesNeighbor (const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
 
virtual void reinitNeighbor (const Elem *elem, unsigned int side, const THREAD_ID tid) override
 
virtual void reinitNeighborPhys (const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points, const THREAD_ID tid) override
 
virtual void reinitNeighborPhys (const Elem *neighbor, const std::vector< Point > &physical_points, const THREAD_ID tid) override
 
virtual void reinitElemNeighborAndLowerD (const Elem *elem, unsigned int side, const THREAD_ID tid) override
 
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 More...
 
virtual void reinitOffDiagScalars (const THREAD_ID tid) override
 
virtual void getDiracElements (std::set< const Elem *> &elems) override
 Fills "elems" with the elements that should be looped over for Dirac Kernels. More...
 
virtual void clearDiracInfo () override
 Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in. More...
 
virtual void subdomainSetup (SubdomainID subdomain, const THREAD_ID tid)
 
virtual void neighborSubdomainSetup (SubdomainID subdomain, const THREAD_ID tid)
 
virtual void newAssemblyArray (std::vector< std::shared_ptr< SolverSystem >> &solver_systems)
 
virtual void initNullSpaceVectors (const InputParameters &parameters, std::vector< std::shared_ptr< NonlinearSystemBase >> &nl)
 
virtual void init () override
 
void initKokkos ()
 Construct Kokkos assembly and systems and allocate Kokkos material property storages. More...
 
virtual void solveLinearSystem (const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)
 Build and solve a linear system. More...
 
virtual void setException (const std::string &message)
 Set an exception, which is stored at this point by toggling a member variable in this class, and which must be followed up with by a call to checkExceptionAndStopSolve(). More...
 
virtual bool hasException ()
 Whether or not an exception has occurred. More...
 
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, which will result in the time step being cut. More...
 
virtual bool solverSystemConverged (const unsigned int solver_sys_num) override
 
virtual unsigned int nNonlinearIterations (const unsigned int nl_sys_num) const override
 
virtual unsigned int nLinearIterations (const unsigned int nl_sys_num) const override
 
virtual Real finalNonlinearResidual (const unsigned int nl_sys_num) const override
 
virtual bool computingPreSMOResidual (const unsigned int nl_sys_num) const override
 Returns true if the problem is in the process of computing it's initial residual. More...
 
virtual bool startedInitialSetup ()
 Returns true if we are in or beyond the initialSetup stage. More...
 
virtual void onTimestepBegin () override
 
virtual void onTimestepEnd () override
 
virtual Realtime () const
 
virtual RealtimeOld () const
 
virtual inttimeStep () const
 
virtual Realdt () const
 
virtual RealdtOld () const
 
Real getTimeFromStateArg (const Moose::StateArg &state) const
 Returns the time associated with the requested state. More...
 
virtual void transient (bool trans)
 
virtual bool isTransient () const override
 
virtual void addTimeIntegrator (const std::string &type, const std::string &name, InputParameters &parameters)
 
virtual void addPredictor (const std::string &type, const std::string &name, InputParameters &parameters)
 
virtual void copySolutionsBackwards ()
 
virtual void advanceState ()
 Advance all of the state holding vectors / datastructures so that we can move to the next timestep. More...
 
virtual void restoreSolutions ()
 
virtual void saveOldSolutions ()
 Allocate vectors and save old solutions into them. More...
 
virtual void restoreOldSolutions ()
 Restore old solutions from the backup vectors and deallocate them. More...
 
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. More...
 
virtual void outputStep (ExecFlagType type)
 Output the current step. More...
 
virtual void postExecute ()
 Method called at the end of the simulation. More...
 
void forceOutput ()
 Indicates that the next call to outputStep should be forced. More...
 
virtual void initPetscOutputAndSomeSolverSettings ()
 Reinitialize PETSc output for proper linear/nonlinear iteration display. More...
 
Moose::PetscSupport::PetscOptionsgetPetscOptions ()
 Retrieve a writable reference the PETSc options (used by PetscSupport) More...
 
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. More...
 
virtual bool hasFunction (const std::string &name, const THREAD_ID tid=0)
 
virtual FunctiongetFunction (const std::string &name, const THREAD_ID tid=0)
 
virtual void addMeshDivision (const std::string &type, const std::string &name, InputParameters &params)
 Add a MeshDivision. More...
 
MeshDivisiongetMeshDivision (const std::string &name, const THREAD_ID tid=0) const
 Get a MeshDivision. More...
 
virtual void addConvergence (const std::string &type, const std::string &name, InputParameters &parameters)
 Adds a Convergence object. More...
 
virtual ConvergencegetConvergence (const std::string &name, const THREAD_ID tid=0) const
 Gets a Convergence object. More...
 
virtual const std::vector< std::shared_ptr< Convergence > > & getConvergenceObjects (const THREAD_ID tid=0) const
 Gets the Convergence objects. More...
 
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. More...
 
bool needToAddDefaultNonlinearConvergence () const
 Returns true if the problem needs to add the default nonlinear convergence. More...
 
bool needToAddDefaultMultiAppFixedPointConvergence () const
 Returns true if the problem needs to add the default fixed point convergence. More...
 
bool needToAddDefaultSteadyStateConvergence () const
 Returns true if the problem needs to add the default steady-state detection convergence. More...
 
void setNeedToAddDefaultNonlinearConvergence ()
 Sets _need_to_add_default_nonlinear_convergence to true. More...
 
void setNeedToAddDefaultMultiAppFixedPointConvergence ()
 Sets _need_to_add_default_multiapp_fixed_point_convergence to true. More...
 
void setNeedToAddDefaultSteadyStateConvergence ()
 Sets _need_to_add_default_steady_state_convergence to true. More...
 
bool hasSetMultiAppFixedPointConvergenceName () const
 Returns true if the problem has set the fixed point convergence name. More...
 
bool hasSetSteadyStateConvergenceName () const
 Returns true if the problem has set the steady-state detection convergence name. More...
 
virtual void addDefaultNonlinearConvergence (const InputParameters &params)
 Adds the default nonlinear Convergence associated with the problem. More...
 
virtual bool onlyAllowDefaultNonlinearConvergence () const
 Returns true if an error will result if the user supplies 'nonlinear_convergence'. More...
 
void addDefaultMultiAppFixedPointConvergence (const InputParameters &params)
 Adds the default fixed point Convergence associated with the problem. More...
 
void addDefaultSteadyStateConvergence (const InputParameters &params)
 Adds the default steady-state detection Convergence. More...
 
virtual void addLineSearch (const InputParameters &)
 add a MOOSE line search More...
 
virtual void lineSearch ()
 execute MOOSE line search More...
 
LineSearchgetLineSearch () override
 getter for the MOOSE line search More...
 
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. More...
 
virtual DistributiongetDistribution (const std::string &name)
 
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. More...
 
virtual SamplergetSampler (const std::string &name, const THREAD_ID tid=0)
 
NonlinearSystemBasegetNonlinearSystemBase (const unsigned int sys_num)
 
const NonlinearSystemBasegetNonlinearSystemBase (const unsigned int sys_num) const
 
void setCurrentNonlinearSystem (const unsigned int nl_sys_num)
 
NonlinearSystemBasecurrentNonlinearSystem ()
 
const NonlinearSystemBasecurrentNonlinearSystem () const
 
virtual const SystemBasesystemBaseNonlinear (const unsigned int sys_num) const override
 Return the nonlinear system object as a base class reference given the system number. More...
 
virtual SystemBasesystemBaseNonlinear (const unsigned int sys_num) override
 
virtual const SystemBasesystemBaseSolver (const unsigned int sys_num) const override
 Return the solver system object as a base class reference given the system number. More...
 
virtual SystemBasesystemBaseSolver (const unsigned int sys_num) override
 
virtual const SystemBasesystemBaseAuxiliary () const override
 Return the auxiliary system object as a base class reference. More...
 
virtual SystemBasesystemBaseAuxiliary () override
 
virtual NonlinearSystemgetNonlinearSystem (const unsigned int sys_num)
 
Moose::Kokkos::Array< Moose::Kokkos::System > & getKokkosSystems ()
 Get all Kokkos systems that are associated with MOOSE nonlinear and auxiliary systems. More...
 
const Moose::Kokkos::Array< Moose::Kokkos::System > & getKokkosSystems () const
 
virtual const SystemBasegetSystemBase (const unsigned int sys_num) const
 Get constant reference to a system in this problem. More...
 
virtual SystemBasegetSystemBase (const unsigned int sys_num)
 Get non-constant reference to a system in this problem. More...
 
SystemBasegetSystemBase (const std::string &sys_name)
 Get non-constant reference to a system in this problem. More...
 
LinearSystemgetLinearSystem (unsigned int sys_num)
 Get non-constant reference to a linear system. More...
 
const LinearSystemgetLinearSystem (unsigned int sys_num) const
 Get a constant reference to a linear system. More...
 
SolverSystemgetSolverSystem (unsigned int sys_num)
 Get non-constant reference to a solver system. More...
 
const SolverSystemgetSolverSystem (unsigned int sys_num) const
 Get a constant reference to a solver system. More...
 
void setCurrentLinearSystem (unsigned int sys_num)
 Set the current linear system pointer. More...
 
LinearSystemcurrentLinearSystem ()
 Get a non-constant reference to the current linear system. More...
 
const LinearSystemcurrentLinearSystem () const
 Get a constant reference to the current linear system. More...
 
virtual const SystemBasesystemBaseLinear (unsigned int sys_num) const override
 Get a constant base class reference to a linear system. More...
 
virtual SystemBasesystemBaseLinear (unsigned int sys_num) override
 Get a non-constant base class reference to a linear system. More...
 
virtual void addHDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addKokkosKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addKokkosNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addKokkosBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)
 
virtual void addConstraint (const std::string &c_name, const std::string &name, InputParameters &parameters)
 
virtual void setInputParametersFEProblem (InputParameters &parameters)
 
virtual void addAuxVariable (const std::string &var_name, const libMesh::FEType &type, const std::set< SubdomainID > *const active_subdomains=NULL)
 
virtual void addAuxArrayVariable (const std::string &var_name, const libMesh::FEType &type, unsigned int components, const std::set< SubdomainID > *const active_subdomains=NULL)
 
virtual void addAuxScalarVariable (const std::string &var_name, libMesh::Order order, Real scale_factor=1., const std::set< SubdomainID > *const active_subdomains=NULL)
 
virtual void addAuxScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
AuxiliarySystemgetAuxiliarySystem ()
 
virtual void addDiracKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addLinearFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
 
virtual void addLinearFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
 
virtual void addFVInterfaceKernel (const std::string &fv_ik_name, const std::string &name, InputParameters &parameters)
 
virtual void addInterfaceKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addFVInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters)
 Add an initial condition for a finite volume variables. More...
 
void projectSolution ()
 
unsigned short getCurrentICState ()
 Retrieves the current initial condition state. More...
 
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/boundary nodes are added to a specific subdomain at an intermediate step. More...
 
void projectFunctionOnCustomRange (ConstElemRange &elem_range, Number(*func)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), Gradient(*func_grad)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), const libMesh::Parameters &params, const VariableName &target_var)
 Project a function onto a range of elements for a given variable. More...
 
virtual void addMaterialHelper (std::vector< MaterialWarehouse *> warehouse, const std::string &material_name, const std::string &name, InputParameters &parameters)
 
virtual void addInterfaceMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
 
virtual void addKokkosMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
 
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 dependency list. More...
 
void reinitMaterials (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)
 
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 More...
 
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 More...
 
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 More...
 
void reinitMaterialsInterface (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)
 
void prepareKokkosMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props)
 
void reinitKokkosMaterials ()
 
virtual void swapBackMaterials (const THREAD_ID tid)
 
virtual void swapBackMaterialsFace (const THREAD_ID tid)
 
virtual void swapBackMaterialsNeighbor (const THREAD_ID tid)
 
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. More...
 
bool hasActiveMaterialProperties (const THREAD_ID tid) const
 Method to check whether or not a list of active material roperties has been set. More...
 
void clearActiveMaterialProperties (const THREAD_ID tid)
 Clear the active material properties. More...
 
template<typename T >
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. More...
 
virtual void addVectorPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)
 
virtual void addReporter (const std::string &type, const std::string &name, InputParameters &parameters)
 Add a Reporter object to the simulation. More...
 
const ReporterDatagetReporterData () const
 Provides const access the ReporterData object. More...
 
ReporterDatagetReporterData (ReporterData::WriteKey)
 Provides non-const access the ReporterData object that is used to store reporter values. More...
 
virtual std::vector< std::shared_ptr< UserObject > > addUserObject (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
 
const ExecuteMooseObjectWarehouse< UserObject > & getUserObjects () const
 
template<class T >
T & getUserObject (const std::string &name, unsigned int tid=0) const
 Get the user object by its name. More...
 
const UserObjectgetUserObjectBase (const std::string &name, const THREAD_ID tid=0) const
 Get the user object by its name. More...
 
const PositionsgetPositionsObject (const std::string &name) const
 Get the Positions object by its name. More...
 
bool hasUserObject (const std::string &name) const
 Check if there if a user object of given name. More...
 
bool hasPostprocessorValueByName (const PostprocessorName &name) const
 Whether or not a Postprocessor value exists by a given name. More...
 
const PostprocessorValuegetPostprocessorValueByName (const PostprocessorName &name, std::size_t t_index=0) const
 Get a read-only reference to the value associated with a Postprocessor that exists. More...
 
void setPostprocessorValueByName (const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
 Set the value of a PostprocessorValue. More...
 
bool hasPostprocessor (const std::string &name) const
 Deprecated. More...
 
const VectorPostprocessorValuegetVectorPostprocessorValueByName (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. More...
 
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. More...
 
const VectorPostprocessorgetVectorPostprocessorObjectByName (const std::string &object_name, const THREAD_ID tid=0) const
 Return the VPP object given the name. More...
 
virtual void addDamper (const std::string &damper_name, const std::string &name, InputParameters &parameters)
 
void setupDampers ()
 
bool hasDampers ()
 Whether or not this system has dampers. More...
 
virtual void addIndicator (const std::string &indicator_name, const std::string &name, InputParameters &parameters)
 
virtual void addMarker (const std::string &marker_name, const std::string &name, InputParameters &parameters)
 
virtual void addMultiApp (const std::string &multi_app_name, const std::string &name, InputParameters &parameters)
 Add a MultiApp to the problem. More...
 
std::shared_ptr< MultiAppgetMultiApp (const std::string &multi_app_name) const
 Get a MultiApp object by name. More...
 
std::vector< std::shared_ptr< Transfer > > getTransfers (ExecFlagType type, Transfer::DIRECTION direction) const
 Get Transfers by ExecFlagType and direction. More...
 
std::vector< std::shared_ptr< Transfer > > getTransfers (Transfer::DIRECTION direction) const
 
const ExecuteMooseObjectWarehouse< Transfer > & getMultiAppTransferWarehouse (Transfer::DIRECTION direction) const
 Return the complete warehouse for MultiAppTransfer object for the given direction. More...
 
void execMultiAppTransfers (ExecFlagType type, Transfer::DIRECTION direction)
 Execute MultiAppTransfers associated with execution flag and direction. More...
 
bool execMultiApps (ExecFlagType type, bool auto_advance=true)
 Execute the MultiApps associated with the ExecFlagType. More...
 
void finalizeMultiApps ()
 
void incrementMultiAppTStep (ExecFlagType type)
 Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType. More...
 
void advanceMultiApps (ExecFlagType type)
 Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep depending on your purpose. More...
 
void finishMultiAppStep (ExecFlagType type, bool recurse_through_multiapp_levels=false)
 Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType. More...
 
void backupMultiApps (ExecFlagType type)
 Backup the MultiApps associated with the ExecFlagType. More...
 
void restoreMultiApps (ExecFlagType type, bool force=false)
 Restore the MultiApps associated with the ExecFlagType. More...
 
Real computeMultiAppsDT (ExecFlagType type)
 Find the smallest timestep over all MultiApps. More...
 
void execTransfers (ExecFlagType type)
 Execute the Transfers associated with the ExecFlagType. More...
 
Real computeResidualL2Norm (NonlinearSystemBase &sys)
 Computes the residual of a nonlinear system using whatever is sitting in the current solution vector then returns the L2 norm. More...
 
Real computeResidualL2Norm (LinearSystem &sys)
 Computes the residual of a linear system using whatever is sitting in the current solution vector then returns the L2 norm. More...
 
virtual Real computeResidualL2Norm ()
 Computes the residual using whatever is sitting in the current solution vector then returns the L2 norm. More...
 
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. More...
 
void computeResidual (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
 This function is called by Libmesh to form a residual. More...
 
virtual void computeResidual (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const unsigned int nl_sys_num)
 Form a residual with default tags (nontime, time, residual). More...
 
void computeResidualAndJacobian (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, libMesh::SparseMatrix< libMesh::Number > &jacobian)
 Form a residual and Jacobian with default tags. More...
 
virtual void computeResidualTag (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
 Form a residual vector for a given tag. More...
 
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. More...
 
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. More...
 
virtual void computeResidualTags (const std::set< TagID > &tags)
 Form multiple residual vectors and each is associated with one tag. More...
 
virtual void computeJacobianSys (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian)
 Form a Jacobian matrix. More...
 
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). More...
 
virtual void computeJacobianTag (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, TagID tag)
 Form a Jacobian matrix for a given tag. More...
 
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. More...
 
virtual void computeJacobianTags (const std::set< TagID > &tags)
 Form multiple matrices, and each is associated with a tag. More...
 
virtual void computeJacobianBlocks (std::vector< JacobianBlock *> &blocks, const unsigned int nl_sys_num)
 Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices. More...
 
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. More...
 
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. More...
 
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. More...
 
virtual Real computeDamping (const NumericVector< libMesh::Number > &soln, const NumericVector< libMesh::Number > &update)
 
virtual bool shouldUpdateSolution ()
 Check to see whether the problem should update the solution. More...
 
virtual bool updateSolution (NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)
 Update the solution. More...
 
virtual void predictorCleanup (NumericVector< libMesh::Number > &ghosted_solution)
 Perform cleanup tasks after application of predictor to solution vector. More...
 
virtual void computeBounds (libMesh::NonlinearImplicitSystem &sys, NumericVector< libMesh::Number > &lower, NumericVector< libMesh::Number > &upper)
 
virtual void computeNearNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
 
virtual void computeNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
 
virtual void computeTransposeNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
 
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)
 
virtual void computeIndicatorsAndMarkers ()
 
virtual void computeIndicators ()
 
virtual void computeMarkers ()
 
virtual void addResidual (const THREAD_ID tid) override
 
virtual void addResidualNeighbor (const THREAD_ID tid) override
 
virtual void addResidualLower (const THREAD_ID tid) override
 
virtual void addResidualScalar (const THREAD_ID tid=0)
 
virtual void cacheResidual (const THREAD_ID tid) override
 
virtual void cacheResidualNeighbor (const THREAD_ID tid) override
 
virtual void addCachedResidual (const THREAD_ID tid) override
 
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 vector passed in. More...
 
virtual void setResidual (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
 
virtual void setResidual (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
 
virtual void setResidualNeighbor (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
 
virtual void setResidualNeighbor (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
 
virtual void addJacobian (const THREAD_ID tid) override
 
virtual void addJacobianNeighbor (const THREAD_ID tid) override
 
virtual void addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid) override
 
virtual void addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)=0
 
virtual void addJacobianNeighborLowerD (const THREAD_ID tid) override
 
virtual void addJacobianLowerD (const THREAD_ID tid) override
 
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)
 
virtual void addJacobianScalar (const THREAD_ID tid=0)
 
virtual void addJacobianOffDiagScalar (unsigned int ivar, const THREAD_ID tid=0)
 
virtual void cacheJacobian (const THREAD_ID tid) override
 
virtual void cacheJacobianNeighbor (const THREAD_ID tid) override
 
virtual void addCachedJacobian (const THREAD_ID tid) override
 
virtual void prepareShapes (unsigned int var, const THREAD_ID tid) override
 
virtual void prepareFaceShapes (unsigned int var, const THREAD_ID tid) override
 
virtual void prepareNeighborShapes (unsigned int var, const THREAD_ID tid) override
 
virtual void addDisplacedProblem (std::shared_ptr< DisplacedProblem > displaced_problem)
 
virtual std::shared_ptr< const DisplacedProblemgetDisplacedProblem () const
 
virtual std::shared_ptr< DisplacedProblemgetDisplacedProblem ()
 
virtual void updateGeomSearch (GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
 
virtual void updateMortarMesh ()
 
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 std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > & getMortarInterfaces (bool on_displaced) const
 
virtual void possiblyRebuildGeomSearchPatches ()
 
virtual GeometricSearchDatageomSearchData () override
 
void setRestartFile (const std::string &file_name)
 Communicate to the Resurector the name of the restart filer. More...
 
const MaterialPropertyRegistrygetMaterialPropertyRegistry () const
 
const InitialConditionWarehousegetInitialConditionWarehouse () const
 Return InitialCondition storage. More...
 
const FVInitialConditionWarehousegetFVInitialConditionWarehouse () const
 Return FVInitialCondition storage. More...
 
SolverParamssolverParams (unsigned int solver_sys_num=0)
 Get the solver parameters. More...
 
const SolverParamssolverParams (unsigned int solver_sys_num=0) const
 const version More...
 
Adaptivityadaptivity ()
 
virtual void initialAdaptMesh ()
 
virtual bool adaptMesh ()
 
unsigned int getNumCyclesCompleted ()
 
bool hasInitialAdaptivity () const
 Return a Boolean indicating whether initial AMR is turned on. More...
 
bool hasInitialAdaptivity () const
 Return a Boolean indicating whether initial AMR is turned on. More...
 
void initXFEM (std::shared_ptr< XFEMInterface > xfem)
 Create XFEM controller object. More...
 
std::shared_ptr< XFEMInterfacegetXFEM ()
 Get a pointer to the XFEM controller object. More...
 
bool haveXFEM ()
 Find out whether the current analysis is using XFEM. More...
 
virtual bool updateMeshXFEM ()
 Update the mesh due to changing XFEM cuts. More...
 
virtual void meshChanged (bool intermediate_change, bool contract_mesh, bool clean_refinement_flags)
 Update data after a mesh change. More...
 
void notifyWhenMeshChanges (MeshChangedInterface *mci)
 Register an object that derives from MeshChangedInterface to be notified when the mesh changes. More...
 
void notifyWhenMeshDisplaces (MeshDisplacedInterface *mdi)
 Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh gets updated. More...
 
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/boundary nodes are added to a specific subdomain at an intermediate step. More...
 
void initKokkosStatefulProps ()
 
virtual void checkProblemIntegrity ()
 Method called to perform a series of sanity checks before a simulation is run. More...
 
void registerRandomInterface (RandomInterface &random_interface, const std::string &name)
 
void setConstJacobian (bool state)
 Set flag that Jacobian is constant (for optimization purposes) More...
 
void setKernelCoverageCheck (CoverageCheckMode mode)
 Set flag to indicate whether kernel coverage checks should be performed. More...
 
void setKernelCoverageCheck (bool flag)
 Set flag to indicate whether kernel coverage checks should be performed. More...
 
void setMaterialCoverageCheck (CoverageCheckMode mode)
 Set flag to indicate whether material coverage checks should be performed. More...
 
void setMaterialCoverageCheck (bool flag)
 Set flag to indicate whether material coverage checks should be performed. More...
 
void setParallelBarrierMessaging (bool flag)
 Toggle parallel barrier messaging (defaults to on). More...
 
void setVerboseProblem (bool verbose)
 Make the problem be verbose. More...
 
bool verboseMultiApps () const
 Whether or not to use verbose printing for MultiApps. More...
 
void parentOutputPositionChanged ()
 Calls parentOutputPositionChanged() on all sub apps. More...
 
unsigned int subspaceDim (const std::string &prefix) const
 Dimension of the subspace spanned by vectors with a given prefix. More...
 
const MaterialWarehousegetMaterialWarehouse () const
 
const MaterialWarehousegetRegularMaterialsWarehouse () const
 
const MaterialWarehousegetDiscreteMaterialWarehouse () const
 
const MaterialWarehousegetInterfaceMaterialsWarehouse () const
 
const MaterialWarehousegetKokkosMaterialsWarehouse () const
 
std::shared_ptr< MaterialBasegetMaterial (std::string name, Moose::MaterialDataType type, const THREAD_ID tid=0, bool no_warn=false)
 Return a pointer to a MaterialBase object. More...
 
MaterialDatagetMaterialData (Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const
 
MaterialDatagetKokkosMaterialData (Moose::MaterialDataType type, const MooseObject *object=nullptr) const
 
const std::set< const MooseObject * > & getMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const
 
const std::set< const MooseObject * > & getKokkosMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const
 
bool restoreOriginalNonzeroPattern () const
 
bool errorOnJacobianNonzeroReallocation () const
 Will return True if the user wants to get an error when a nonzero is reallocated in the Jacobian by PETSc. More...
 
void setErrorOnJacobianNonzeroReallocation (bool state)
 
bool preserveMatrixSparsityPattern () const
 Will return True if the executioner in use requires preserving the sparsity pattern of the matrices being formed during the solve. More...
 
void setPreserveMatrixSparsityPattern (bool preserve)
 Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian) should be preserved. More...
 
bool ignoreZerosInJacobian () const
 Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern. More...
 
void setIgnoreZerosInJacobian (bool state)
 Set whether the zeros in the Jacobian should be dropped from the sparsity pattern. More...
 
bool acceptInvalidSolution () const
 Whether or not to accept the solution based on its invalidity. More...
 
bool allowInvalidSolution () const
 Whether to accept / allow an invalid solution. More...
 
bool showInvalidSolutionConsole () const
 Whether or not to print out the invalid solutions summary table in console. More...
 
bool immediatelyPrintInvalidSolution () const
 Whether or not the solution invalid warnings are printed out immediately. More...
 
bool hasTimeIntegrator () const
 Returns whether or not this Problem has a TimeIntegrator. More...
 
virtual void execute (const ExecFlagType &exec_type)
 Convenience function for performing execution of MOOSE systems. More...
 
virtual void executeAllObjects (const ExecFlagType &exec_type)
 
virtual ExecutorgetExecutor (const std::string &name)
 
virtual void computeUserObjects (const ExecFlagType &type, const Moose::AuxGroup &group)
 Call compute methods on UserObjects. More...
 
virtual void computeUserObjectByName (const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)
 Compute an user object with the given name. More...
 
void needsPreviousNewtonIteration (bool state)
 Set a flag that indicated that user required values for the previous Newton iterate. More...
 
bool needsPreviousNewtonIteration () const
 Check to see whether we need to compute the variable values of the previous Newton iterate. More...
 
ExecuteMooseObjectWarehouse< Control > & getControlWarehouse ()
 Reference to the control logic warehouse. More...
 
void executeControls (const ExecFlagType &exec_type)
 Performs setup and execute calls for Control objects. More...
 
void executeSamplers (const ExecFlagType &exec_type)
 Performs setup and execute calls for Sampler objects. More...
 
virtual void updateActiveObjects ()
 Update the active objects in the warehouses. More...
 
void reportMooseObjectDependency (MooseObject *a, MooseObject *b)
 Register a MOOSE object dependency so we can either order operations properly or report when we cannot. More...
 
ExecuteMooseObjectWarehouse< MultiApp > & getMultiAppWarehouse ()
 
bool hasJacobian () const
 Returns _has_jacobian. More...
 
bool constJacobian () const
 Returns _const_jacobian (whether a MOOSE object has specified that the Jacobian is the same as the previous time it was computed) More...
 
void addOutput (const std::string &, const std::string &, InputParameters &)
 Adds an Output object. More...
 
TheWarehousetheWarehouse () const
 
void setSNESMFReuseBase (bool reuse, bool set_by_user)
 If or not to reuse the base vector for matrix-free calculation. More...
 
bool useSNESMFReuseBase ()
 Return a flag that indicates if we are reusing the vector base. More...
 
void skipExceptionCheck (bool skip_exception_check)
 Set a flag that indicates if we want to skip exception and stop solve. More...
 
bool isSNESMFReuseBaseSetbyUser ()
 Return a flag to indicate if _snesmf_reuse_base is set by users. More...
 
bool & petscOptionsInserted ()
 If PETSc options are already inserted. More...
 
PetscOptions & petscOptionsDatabase ()
 
virtual void setUDotRequested (const bool u_dot_requested)
 Set boolean flag to true to store solution time derivative. More...
 
virtual void setUDotDotRequested (const bool u_dotdot_requested)
 Set boolean flag to true to store solution second time derivative. More...
 
virtual void setUDotOldRequested (const bool u_dot_old_requested)
 Set boolean flag to true to store old solution time derivative. More...
 
virtual void setUDotDotOldRequested (const bool u_dotdot_old_requested)
 Set boolean flag to true to store old solution second time derivative. More...
 
virtual bool uDotRequested ()
 Get boolean flag to check whether solution time derivative needs to be stored. More...
 
virtual bool uDotDotRequested ()
 Get boolean flag to check whether solution second time derivative needs to be stored. More...
 
virtual bool uDotOldRequested ()
 Get boolean flag to check whether old solution time derivative needs to be stored. More...
 
virtual bool uDotDotOldRequested ()
 Get boolean flag to check whether old solution second time derivative needs to be stored. More...
 
void haveADObjects (bool have_ad_objects) override
 Method for setting whether we have any ad objects. More...
 
virtual void haveADObjects (bool have_ad_objects)
 Method for setting whether we have any ad objects. More...
 
bool haveADObjects () const
 Method for reading wehther we have any ad objects. More...
 
bool haveADObjects () const
 Method for reading wehther we have any ad objects. More...
 
bool shouldSolve () const
 
const MortarDatamortarData () const
 Returns the mortar data object. More...
 
MortarDatamortarData ()
 
virtual bool hasNeighborCoupling () const
 Whether the simulation has neighbor coupling. More...
 
virtual bool hasMortarCoupling () const
 Whether the simulation has mortar coupling. More...
 
void computingNonlinearResid (bool computing_nonlinear_residual) final
 Set whether or not the problem is in the process of computing the nonlinear residual. More...
 
bool computingNonlinearResid () const
 Returns true if the problem is in the process of computing the nonlinear residual. More...
 
virtual void computingNonlinearResid (const bool computing_nonlinear_residual)
 Set whether or not the problem is in the process of computing the nonlinear residual. More...
 
bool computingNonlinearResid () const
 Returns true if the problem is in the process of computing the nonlinear residual. More...
 
void setCurrentlyComputingResidual (bool currently_computing_residual) final
 Set whether or not the problem is in the process of computing the residual. More...
 
void numGridSteps (unsigned int num_grid_steps)
 Set the number of steps in a grid sequences. More...
 
void uniformRefine ()
 uniformly refine the problem mesh(es). More...
 
void automaticScaling (bool automatic_scaling) override
 Automatic scaling setter. More...
 
virtual void automaticScaling (bool automatic_scaling)
 Automatic scaling setter. More...
 
bool automaticScaling () const
 Automatic scaling getter. More...
 
bool automaticScaling () const
 Automatic scaling getter. More...
 
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 then compute variable data. More...
 
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 points and then compute variable data. More...
 
bool fvBCsIntegrityCheck () const
 
void fvBCsIntegrityCheck (bool fv_bcs_integrity_check)
 
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. More...
 
void resizeMaterialData (Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)
 Resize material data. More...
 
bool haveDisplaced () const override final
 Whether we have a displaced problem in our simulation. More...
 
bool hasLinearConvergenceObjects () const
 Whether we have linear convergence objects. More...
 
void setNonlinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
 Sets the nonlinear convergence object name(s) if there is one. More...
 
void setLinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
 Sets the linear convergence object name(s) if there is one. More...
 
void setMultiAppFixedPointConvergenceName (const ConvergenceName &convergence_name)
 Sets the MultiApp fixed point convergence object name if there is one. More...
 
void setSteadyStateConvergenceName (const ConvergenceName &convergence_name)
 Sets the steady-state detection convergence object name if there is one. More...
 
const std::vector< ConvergenceName > & getNonlinearConvergenceNames () const
 Gets the nonlinear system convergence object name(s). More...
 
const std::vector< ConvergenceName > & getLinearConvergenceNames () const
 Gets the linear convergence object name(s). More...
 
const ConvergenceName & getMultiAppFixedPointConvergenceName () const
 Gets the MultiApp fixed point convergence object name. More...
 
const ConvergenceName & getSteadyStateConvergenceName () const
 Gets the steady-state detection convergence object name. More...
 
void computingScalingJacobian (bool computing_scaling_jacobian)
 Setter for whether we're computing the scaling jacobian. More...
 
bool computingScalingJacobian () const override final
 Getter for whether we're computing the scaling jacobian. More...
 
void computingScalingResidual (bool computing_scaling_residual)
 Setter for whether we're computing the scaling residual. More...
 
bool computingScalingResidual () const override final
 
MooseAppCoordTransformcoordTransform ()
 
virtual std::size_t numNonlinearSystems () const override
 
virtual std::size_t numLinearSystems () const override
 
virtual std::size_t numSolverSystems () const override
 
bool isSolverSystemNonlinear (const unsigned int sys_num)
 Check if the solver system is nonlinear. More...
 
virtual unsigned int currentNlSysNum () const override
 
virtual unsigned int currentLinearSysNum () const override
 
virtual unsigned int nlSysNum (const NonlinearSystemName &nl_sys_name) const override
 
unsigned int linearSysNum (const LinearSystemName &linear_sys_name) const override
 
unsigned int solverSysNum (const SolverSystemName &solver_sys_name) const override
 
unsigned int systemNumForVariable (const VariableName &variable_name) const
 
bool getFailNextNonlinearConvergenceCheck () const
 Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s) More...
 
bool getFailNextSystemConvergenceCheck () const
 Whether it will fail the next system convergence check(s), triggering failed step behavior. More...
 
void setFailNextNonlinearConvergenceCheck ()
 Skip further residual evaluations and fail the next nonlinear convergence check(s) More...
 
void setFailNextSystemConvergenceCheck ()
 Tell the problem that the system(s) cannot be considered converged next time convergence is checked. More...
 
void resetFailNextNonlinearConvergenceCheck ()
 Tell the problem that the nonlinear convergence check(s) may proceed as normal. More...
 
void resetFailNextSystemConvergenceCheck ()
 Tell the problem that the system convergence check(s) may proceed as normal. More...
 
void setExecutionPrinting (const ExecFlagEnum &print_exec)
 
bool shouldPrintExecution (const THREAD_ID tid) const
 Check whether the problem should output execution orders at this time. More...
 
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, and displacement characteristics. More...
 
virtual const std::vector< VectorTag > & currentResidualVectorTags () const override
 Return the residual vector tags we are currently computing. More...
 
void setCurrentResidualVectorTags (const std::set< TagID > &vector_tags)
 Set the current residual vector tag data structure based on the passed in tag IDs. More...
 
void clearCurrentResidualVectorTags ()
 Clear the current residual vector tag data structure. More...
 
void clearCurrentJacobianMatrixTags ()
 Clear the current Jacobian matrix tag data structure ... More...
 
virtual void needFV () override
 marks this problem as including/needing finite volume functionality. More...
 
virtual bool haveFV () const override
 returns true if this problem includes/needs finite volume functionality. More...
 
virtual bool hasNonlocalCoupling () const override
 Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian. More...
 
bool identifyVariableGroupsInNL () const
 Whether to identify variable groups in nonlinear systems. More...
 
virtual void setCurrentLowerDElem (const Elem *const lower_d_elem, const THREAD_ID tid) override
 Set the current lower dimensional element. More...
 
virtual void setCurrentBoundaryID (BoundaryID bid, const THREAD_ID tid) override
 sets the current boundary ID in assembly More...
 
const std::vector< NonlinearSystemName > & getNonlinearSystemNames () const
 
const std::vector< LinearSystemName > & getLinearSystemNames () const
 
const std::vector< SolverSystemName > & getSolverSystemNames () const
 
virtual const libMesh::CouplingMatrixnonlocalCouplingMatrix (const unsigned i) const override
 
virtual bool checkNonlocalCouplingRequirement () const override
 
void createTagMatrices (CreateTaggedMatrixKey)
 
bool hasKokkosObjects () const
 
const bool & currentlyComputingResidual () const
 Returns true if the problem is in the process of computing the residual. More...
 
const bool & currentlyComputingResidual () const
 Returns true if the problem is in the process of computing the residual. More...
 
virtual bool nlConverged (const unsigned int nl_sys_num)
 
virtual bool converged (const unsigned int sys_num)
 Eventually we want to convert this virtual over to taking a solver system number argument. More...
 
bool defaultGhosting ()
 Whether or not the user has requested default ghosting ot be on. More...
 
virtual TagID addVectorTag (const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
 Create a Tag. More...
 
void addNotZeroedVectorTag (const TagID tag)
 Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are. More...
 
bool vectorTagNotZeroed (const TagID tag) const
 Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors are. More...
 
virtual const VectorTaggetVectorTag (const TagID tag_id) const
 Get a VectorTag from a TagID. More...
 
std::vector< VectorTaggetVectorTags (const std::set< TagID > &tag_ids) const
 
virtual const std::vector< VectorTag > & getVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
 Return all vector tags, where a tag is represented by a map from name to ID. More...
 
virtual TagID getVectorTagID (const TagName &tag_name) const
 Get a TagID from a TagName. More...
 
virtual TagName vectorTagName (const TagID tag) const
 Retrieve the name associated with a TagID. More...
 
virtual bool vectorTagExists (const TagID tag_id) const
 Check to see if a particular Tag exists. More...
 
virtual bool vectorTagExists (const TagName &tag_name) const
 Check to see if a particular Tag exists by using Tag name. More...
 
virtual unsigned int numVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
 The total number of tags, which can be limited to the tag type. More...
 
virtual Moose::VectorTagType vectorTagType (const TagID tag_id) const
 
virtual TagID addMatrixTag (TagName tag_name)
 Create a Tag. More...
 
virtual TagID getMatrixTagID (const TagName &tag_name) const
 Get a TagID from a TagName. More...
 
virtual TagName matrixTagName (TagID tag)
 Retrieve the name associated with a TagID. More...
 
virtual bool matrixTagExists (const TagName &tag_name) const
 Check to see if a particular Tag exists. More...
 
virtual bool matrixTagExists (TagID tag_id) const
 Check to see if a particular Tag exists. More...
 
virtual unsigned int numMatrixTags () const
 The total number of tags. More...
 
virtual std::map< TagName, TagID > & getMatrixTags ()
 Return all matrix tags in the system, where a tag is represented by a map from name to ID. More...
 
virtual bool hasLinearVariable (const std::string &var_name) const
 Whether or not this problem has this linear variable. More...
 
virtual bool hasAuxiliaryVariable (const std::string &var_name) const
 Whether or not this problem has this auxiliary variable. More...
 
virtual const std::set< MooseVariableFieldBase * > & getActiveElementalMooseVariables (const THREAD_ID tid) const
 Get the MOOSE variables to be reinited on each element. More...
 
virtual bool hasActiveElementalMooseVariables (const THREAD_ID tid) const
 Whether or not a list of active elemental moose variables has been set. More...
 
Moose::CoordinateSystemType getCoordSystem (SubdomainID sid) const
 
unsigned int getAxisymmetricRadialCoord () const
 Returns the desired radial direction for RZ coordinate transformation. More...
 
virtual DiracKernelInfodiracKernelInfo ()
 
void reinitNeighborLowerDElem (const Elem *elem, const THREAD_ID tid=0)
 reinitialize a neighboring lower dimensional element More...
 
void reinitMortarElem (const Elem *elem, const THREAD_ID tid=0)
 Reinit a mortar element to obtain a valid JxW. More...
 
virtual void storeSubdomainMatPropName (SubdomainID block_id, const std::string &name)
 Adds the given material property to a storage map based on block ids. More...
 
virtual void storeBoundaryMatPropName (BoundaryID boundary_id, const std::string &name)
 Adds the given material property to a storage map based on boundary ids. More...
 
virtual void storeSubdomainZeroMatProp (SubdomainID block_id, const MaterialPropertyName &name)
 Adds to a map based on block ids of material properties for which a zero value can be returned. More...
 
virtual void storeBoundaryZeroMatProp (BoundaryID boundary_id, const MaterialPropertyName &name)
 Adds to a map based on boundary ids of material properties for which a zero value can be returned. More...
 
virtual void storeSubdomainDelayedCheckMatProp (const std::string &requestor, SubdomainID block_id, const std::string &name)
 Adds to a map based on block ids of material properties to validate. More...
 
virtual void storeBoundaryDelayedCheckMatProp (const std::string &requestor, BoundaryID boundary_id, const std::string &name)
 Adds to a map based on boundary ids of material properties to validate. More...
 
virtual void checkBlockMatProps ()
 Checks block material properties integrity. More...
 
virtual void checkBoundaryMatProps ()
 Checks boundary material properties integrity. More...
 
virtual void markMatPropRequested (const std::string &)
 Helper method for adding a material property name to the _material_property_requested set. More...
 
virtual bool isMatPropRequested (const std::string &prop_name) const
 Find out if a material property has been requested by any object. More...
 
void addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)
 Helper for tracking the object that is consuming a property for MaterialPropertyDebugOutput. More...
 
const std::map< MooseObjectName, std::set< std::string > > & getConsumedPropertyMap () const
 Return the map that tracks the object with consumed material properties. More...
 
virtual std::set< SubdomainIDgetMaterialPropertyBlocks (const std::string &prop_name)
 Get a vector containing the block ids the material property is defined on. More...
 
virtual std::vector< SubdomainName > getMaterialPropertyBlockNames (const std::string &prop_name)
 Get a vector of block id equivalences that the material property is defined on. More...
 
virtual bool hasBlockMaterialProperty (SubdomainID block_id, const std::string &prop_name)
 Check if a material property is defined on a block. More...
 
virtual std::set< BoundaryIDgetMaterialPropertyBoundaryIDs (const std::string &prop_name)
 Get a vector containing the block ids the material property is defined on. More...
 
virtual std::vector< BoundaryName > getMaterialPropertyBoundaryNames (const std::string &prop_name)
 Get a vector of block id equivalences that the material property is defined on. More...
 
virtual bool hasBoundaryMaterialProperty (BoundaryID boundary_id, const std::string &prop_name)
 Check if a material property is defined on a block. More...
 
virtual std::set< dof_id_type > & ghostedElems ()
 Return the list of elements that should have their DoFs ghosted to this processor. More...
 
const bool & currentlyComputingJacobian () const
 Returns true if the problem is in the process of computing the Jacobian. More...
 
void setCurrentlyComputingJacobian (const bool currently_computing_jacobian)
 Set whether or not the problem is in the process of computing the Jacobian. More...
 
const bool & currentlyComputingResidualAndJacobian () const
 Returns true if the problem is in the process of computing the residual and the Jacobian. More...
 
void setCurrentlyComputingResidualAndJacobian (bool currently_computing_residual_and_jacobian)
 Set whether or not the problem is in the process of computing the Jacobian. More...
 
virtual bool safeAccessTaggedMatrices () const
 Is it safe to access the tagged matrices. More...
 
virtual bool safeAccessTaggedVectors () const
 Is it safe to access the tagged vectors. More...
 
const std::set< TagID > & getActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) const
 
const std::set< TagID > & getActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) const
 
const std::set< TagID > & getActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) const
 
const std::set< TagID > & getActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) const
 
void addAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
 Add an algebraic ghosting functor to this problem's DofMaps. More...
 
void addCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
 Add a coupling functor to this problem's DofMaps. More...
 
void removeAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf)
 Remove an algebraic ghosting functor from this problem's DofMaps. More...
 
void removeCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf)
 Remove a coupling ghosting functor from this problem's DofMaps. More...
 
void hasScalingVector (const unsigned int nl_sys_num)
 Tells this problem that the assembly associated with the given nonlinear system number involves a scaling vector. More...
 
void clearAllDofIndices ()
 Clear dof indices from variables in nl and aux systems. More...
 
template<typename T >
const Moose::Functor< T > & getFunctor (const std::string &name, const THREAD_ID tid, const std::string &requestor_name, bool requestor_is_ad)
 
bool hasFunctor (const std::string &name, const THREAD_ID tid) const
 checks whether we have a functor corresponding to name on the thread id tid More...
 
template<typename T >
bool hasFunctorWithType (const std::string &name, const THREAD_ID tid) const
 checks whether we have a functor of type T corresponding to name on the thread id tid More...
 
template<typename T >
void addFunctor (const std::string &name, const Moose::FunctorBase< T > &functor, const THREAD_ID tid)
 add a functor to the problem functor container More...
 
template<typename T , typename PolymorphicLambda >
const Moose::FunctorBase< T > & addPiecewiseByBlockLambdaFunctor (const std::string &name, PolymorphicLambda my_lammy, const std::set< ExecFlagType > &clearance_schedule, const MooseMesh &mesh, const std::set< SubdomainID > &block_ids, const THREAD_ID tid)
 Add a functor that has block-wise lambda definitions, e.g. More...
 
void setFunctorOutput (bool set_output)
 Setter for debug functor output. More...
 
template<typename T >
void registerUnfilledFunctorRequest (T *functor_interface, const std::string &functor_name, const THREAD_ID tid)
 Register an unfulfilled functor request. More...
 
void reinitFVFace (const THREAD_ID tid, const FaceInfo &fi)
 reinitialize the finite volume assembly data for the provided face and thread More...
 
void preparePRefinement ()
 Prepare DofMap and Assembly classes with our p-refinement information. More...
 
bool doingPRefinement () const
 
bool havePRefinement () const
 Query whether p-refinement has been requested at any point during the simulation. More...
 
template<typename T >
MooseVariableFEBasegetVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &systems, const SystemBase &aux) const
 
void _setCLIOption ()
 For Internal Use. More...
 
virtual void terminateSolve ()
 Allow objects to request clean termination of the solve. More...
 
virtual bool isSolveTerminationRequested () const
 Check of termination has been requested. More...
 
const ConsoleStreamconsole () const
 Return console handle. More...
 
virtual bool enabled () const
 Return the enabled status of the object. More...
 
std::shared_ptr< MooseObjectgetSharedPtr ()
 Get another shared pointer to this object that has the same ownership group. More...
 
std::shared_ptr< const MooseObjectgetSharedPtr () const
 
bool isKokkosObject (IsKokkosObjectKey &&) const
 Get whether this object is a Kokkos functor The parameter is set by the Kokkos base classes: More...
 
MooseAppgetMooseApp () const
 Get the MooseApp this class is associated with. More...
 
const std::string & type () const
 Get the type of this class. More...
 
const std::string & name () const
 Get the name of the class. More...
 
std::string typeAndName () const
 Get the class's combined type and name; useful in error handling. More...
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParametersparameters () const
 Get the parameters of the object. More...
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () const
 
template<typename T >
const T & getParam (const std::string &name) const
 Retrieve a parameter for the object. More...
 
template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 Retrieve two parameters and provide pair of parameters for the object. More...
 
template<typename T >
const T * queryParam (const std::string &name) const
 Query a parameter for the object. More...
 
template<typename T >
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 Retrieve a renamed parameter for the object. More...
 
template<typename T >
getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...
 
bool isParamValid (const std::string &name) const
 Test if the supplied parameter is valid. More...
 
bool isParamSetByUser (const std::string &name) const
 Test if the supplied parameter is set by a user, as opposed to not set or set to default. More...
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 Connect controllable parameter of this action with the controllable parameters of the objects added by this action. More...
 
template<typename... Args>
void paramError (const std::string &param, Args... args) const
 Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
 
template<typename... Args>
void paramWarning (const std::string &param, Args... args) const
 Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
 
template<typename... Args>
void paramInfo (const std::string &param, Args... args) const
 Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 Deprecated message prefix; the error type is no longer used. More...
 
template<typename... Args>
void mooseError (Args &&... args) const
 Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available. More...
 
template<typename... Args>
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
template<typename... Args>
void mooseErrorNonPrefixed (Args &&... args) const
 Emits an error without the prefixing included in mooseError(). More...
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 Emits a warning prefixed with object name and type. More...
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 Emits a warning without the prefixing included in mooseWarning(). More...
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 
template<typename... Args>
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
 External method for calling moose error with added object context. More...
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 
std::string getDataFileName (const std::string &param) const
 Deprecated method. More...
 
std::string getDataFileNameByName (const std::string &relative_path) const
 Deprecated method. More...
 
std::string getDataFilePath (const std::string &relative_path) const
 Returns the path of a data file for a given relative file path. More...
 
PerfGraphperfGraph ()
 Get the PerfGraph. More...
 
const libMesh::ConstElemRangegetEvaluableElementRange ()
 In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}. More...
 
const libMesh::ConstElemRangegetNonlinearEvaluableElementRange ()
 
const libMesh::ConstElemRangegetCurrentAlgebraicElementRange ()
 These are the element and nodes that contribute to the jacobian and residual for this local processor. More...
 
const libMesh::ConstNodeRangegetCurrentAlgebraicNodeRange ()
 
const ConstBndNodeRangegetCurrentAlgebraicBndNodeRange ()
 
void setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)
 These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes that contribute to the jacobian and residual for this local processor. More...
 
void setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)
 
void setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)
 
void allowOutput (bool state)
 Ability to enable/disable all output calls. More...
 
template<typename T >
void allowOutput (bool state)
 
bool hasMultiApps () const
 Returns whether or not the current simulation has any multiapps. More...
 
bool hasMultiApps (ExecFlagType type) const
 
bool hasMultiApp (const std::string &name) const
 
const AutomaticMortarGenerationgetMortarInterface (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 and subdomains. More...
 
AutomaticMortarGenerationgetMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced)
 
const MaterialPropertyStoragegetMaterialPropertyStorage ()
 Return a reference to the material property storage. More...
 
const MaterialPropertyStoragegetBndMaterialPropertyStorage ()
 
const MaterialPropertyStoragegetNeighborMaterialPropertyStorage ()
 
Moose::Kokkos::MaterialPropertyStoragegetKokkosMaterialPropertyStorage ()
 
Moose::Kokkos::MaterialPropertyStoragegetKokkosBndMaterialPropertyStorage ()
 
Moose::Kokkos::MaterialPropertyStoragegetKokkosNeighborMaterialPropertyStorage ()
 
const MooseObjectWarehouse< Indicator > & getIndicatorWarehouse ()
 Return indicator/marker storage. More...
 
const MooseObjectWarehouse< InternalSideIndicatorBase > & getInternalSideIndicatorWarehouse ()
 
const MooseObjectWarehouse< Marker > & getMarkerWarehouse ()
 
bool needBoundaryMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)
 These methods are used to determine whether stateful material properties need to be stored on internal sides. More...
 
bool needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)
 
bool needSubdomainMaterialOnSide (SubdomainID subdomain_id, const THREAD_ID tid)
 
const ExecFlagTypegetCurrentExecuteOnFlag () const
 Return/set the current execution flag. More...
 
void setCurrentExecuteOnFlag (const ExecFlagType &)
 

Static Public Member Functions

static InputParameters validParams ()
 
static void selectVectorTagsFromSystem (const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)
 Select the vector tags which belong to a specific system. More...
 
static void selectMatrixTagsFromSystem (const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)
 Select the matrix tags which belong to a specific system. More...
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node)
 External method for calling moose error with added object context. More...
 
template<typename T >
static void objectSetupHelper (const std::vector< T *> &objects, const ExecFlagType &exec_flag)
 Helpers for calling the necessary setup/execute functions for the supplied objects. More...
 
template<typename T >
static void objectExecuteHelper (const std::vector< T *> &objects)
 

Public Attributes

std::map< std::string, std::vector< dof_id_type > > _var_dof_map
 
const ConsoleStream _console
 An instance of helper class to write streams to the Console objects. More...
 
std::vector< Real_real_zero
 Convenience zeros. More...
 
std::vector< VariableValue_scalar_zero
 
std::vector< VariableValue_zero
 
std::vector< VariablePhiValue_phi_zero
 
std::vector< MooseArray< ADReal > > _ad_zero
 
std::vector< VariableGradient_grad_zero
 
std::vector< MooseArray< ADRealVectorValue > > _ad_grad_zero
 
std::vector< VariablePhiGradient_grad_phi_zero
 
std::vector< VariableSecond_second_zero
 
std::vector< MooseArray< ADRealTensorValue > > _ad_second_zero
 
std::vector< VariablePhiSecond_second_phi_zero
 
std::vector< Point > _point_zero
 
std::vector< VectorVariableValue_vector_zero
 
std::vector< VectorVariableCurl_vector_curl_zero
 

Static Public Attributes

static const std::string type_param = "_type"
 The name of the parameter that contains the object type. More...
 
static const std::string name_param = "_object_name"
 The name of the parameter that contains the object name. More...
 
static const std::string unique_name_param = "_unique_name"
 The name of the parameter that contains the unique object name. More...
 
static const std::string app_param = "_moose_app"
 The name of the parameter that contains the MooseApp. More...
 
static const std::string moose_base_param = "_moose_base"
 The name of the parameter that contains the moose system base. More...
 
static const std::string kokkos_object_param = "_kokkos_object"
 The name of the parameter that indicates an object is a Kokkos functor. More...
 

Protected Member Functions

virtual void meshChanged ()
 Deprecated. More...
 
void createTagVectors ()
 Create extra tagged vectors and matrices. More...
 
void createTagSolutions ()
 Create extra tagged solution vectors. More...
 
virtual void meshDisplaced ()
 Update data after a mesh displaced. More...
 
void computeSystems (const ExecFlagType &type)
 Do generic system computations. More...
 
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. More...
 
void computeUserObjectsInternal (const ExecFlagType &type, const Moose::AuxGroup &group, TheWarehouse::Query &query)
 
void checkDisplacementOrders ()
 Verify that SECOND order mesh uses SECOND order displacements. More...
 
void checkUserObjects ()
 
void checkDependMaterialsHelper (const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase >>> &materials_map)
 Helper method for checking Material object dependency. More...
 
void checkCoordinateSystems ()
 Verify that there are no element type/coordinate type conflicts. More...
 
void reinitBecauseOfGhostingOrNewGeomObjects (bool mortar_changed=false)
 Call when it is possible that the needs for ghosted elements has changed. More...
 
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(). More...
 
template<typename T >
MooseVariableFieldBasegetVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &nls, const SystemBase &aux) const
 Helper function called by getVariable that handles the logic for checking whether Variables of the requested type are available. More...
 
bool verifyVectorTags () const
 Verify the integrity of _vector_tags and _typed_vector_tags. More...
 
void markFamilyPRefinement (const InputParameters &params)
 Mark a variable family for either disabling or enabling p-refinement with valid parameters of a variable. More...
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 Call to register a named section for timing. More...
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 Call to register a named section for timing. More...
 
std::string timedSectionName (const std::string &section_name) const
 
template<typename T , typename... Args>
T & declareRestartableData (const std::string &data_name, Args &&... args)
 Declare a piece of data as "restartable" and initialize it. More...
 
template<typename T , typename... Args>
ManagedValue< T > declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
 Declares a piece of "managed" restartable data and initialize it. More...
 
template<typename T , typename... Args>
const T & getRestartableData (const std::string &data_name) const
 Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object. More...
 
template<typename T , typename... Args>
T & declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
 Declare a piece of data as "restartable" and initialize it. More...
 
template<typename T , typename... Args>
T & declareRecoverableData (const std::string &data_name, Args &&... args)
 Declare a piece of data as "recoverable" and initialize it. More...
 
template<typename T , typename... Args>
T & declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
 Declare a piece of data as "restartable". More...
 
template<typename T , typename... Args>
T & declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
 Declare a piece of data as "restartable". More...
 
std::string restartableName (const std::string &data_name) const
 Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix. More...
 

Protected Attributes

MFEMProblemData _problem_data
 
MooseMesh_mesh
 
bool _initialized
 
std::optional< std::vector< ConvergenceName > > _nonlinear_convergence_names
 Nonlinear system(s) convergence name(s) More...
 
std::optional< std::vector< ConvergenceName > > _linear_convergence_names
 Linear system(s) convergence name(s) (if any) More...
 
std::optional< ConvergenceName > _multiapp_fixed_point_convergence_name
 MultiApp fixed point convergence name. More...
 
std::optional< ConvergenceName > _steady_state_convergence_name
 Steady-state detection convergence name. More...
 
std::set< TagID_fe_vector_tags
 
std::set< TagID_fe_matrix_tags
 
std::set< TagID_linear_vector_tags
 Temporary storage for filtered vector tags for linear systems. More...
 
std::set< TagID_linear_matrix_tags
 Temporary storage for filtered matrix tags for linear systems. More...
 
const bool & _solve
 Whether or not to actually solve the nonlinear system. More...
 
bool _transient
 
Real_time
 
Real_time_old
 
int_t_step
 
Real_dt
 
Real_dt_old
 
bool _need_to_add_default_nonlinear_convergence
 Flag that the problem needs to add the default nonlinear convergence. More...
 
bool _need_to_add_default_multiapp_fixed_point_convergence
 Flag that the problem needs to add the default fixed point convergence. More...
 
bool _need_to_add_default_steady_state_convergence
 Flag that the problem needs to add the default steady convergence. More...
 
const std::vector< LinearSystemName > _linear_sys_names
 The linear system names. More...
 
const std::size_t _num_linear_sys
 The number of linear systems. More...
 
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
 The vector of linear systems. More...
 
std::map< LinearSystemName, unsigned int_linear_sys_name_to_num
 Map from linear system name to number. More...
 
LinearSystem_current_linear_sys
 The current linear system that we are solving. More...
 
const bool _using_default_nl
 Boolean to check if we have the default nonlinear system. More...
 
const std::vector< NonlinearSystemName > _nl_sys_names
 The nonlinear system names. More...
 
const std::size_t _num_nl_sys
 The number of nonlinear systems. More...
 
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
 The nonlinear systems. More...
 
std::map< NonlinearSystemName, unsigned int_nl_sys_name_to_num
 Map from nonlinear system name to number. More...
 
NonlinearSystemBase_current_nl_sys
 The current nonlinear system that we are solving. More...
 
SolverSystem_current_solver_sys
 The current solver system. More...
 
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
 Combined container to base pointer of every solver system. More...
 
std::map< SolverVariableName, unsigned int_solver_var_to_sys_num
 Map connecting variable names with their respective solver systems. More...
 
std::map< SolverSystemName, unsigned int_solver_sys_name_to_num
 Map connecting solver system names with their respective systems. More...
 
std::vector< SolverSystemName > _solver_sys_names
 The union of nonlinear and linear system names. More...
 
std::shared_ptr< AuxiliarySystem_aux
 The auxiliary system. More...
 
Moose::CouplingType _coupling
 Type of variable coupling. More...
 
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
 Coupling matrix for variables. More...
 
Moose::Kokkos::Array< Moose::Kokkos::System_kokkos_systems
 
std::map< std::string, unsigned int_subspace_dim
 Dimension of the subspace spanned by the vectors with a given prefix. More...
 
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
 The Assembly objects. More...
 
Moose::Kokkos::Assembly _kokkos_assembly
 
MooseObjectWarehouse< MeshDivision_mesh_divisions
 Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the Problem Time (and people's uses) will tell where this fits best. More...
 
MooseObjectWarehouse< Function_functions
 functions More...
 
MooseObjectWarehouse< Convergence_convergences
 convergence warehouse More...
 
MooseObjectWarehouse< KernelBase_nonlocal_kernels
 nonlocal kernels More...
 
MooseObjectWarehouse< IntegratedBCBase_nonlocal_integrated_bcs
 nonlocal integrated_bcs More...
 
MaterialPropertyRegistry _material_prop_registry
 
MaterialPropertyStorage_material_props
 
MaterialPropertyStorage_bnd_material_props
 
MaterialPropertyStorage_neighbor_material_props
 
Moose::Kokkos::MaterialPropertyStorage_kokkos_material_props
 
Moose::Kokkos::MaterialPropertyStorage_kokkos_bnd_material_props
 
Moose::Kokkos::MaterialPropertyStorage_kokkos_neighbor_material_props
 
MooseObjectWarehouse< Marker_markers
 
ReporterData _reporter_data
 
ExecuteMooseObjectWarehouse< UserObject_all_user_objects
 
ExecuteMooseObjectWarehouse< MultiApp_multi_apps
 MultiApp Warehouse. More...
 
ExecuteMooseObjectWarehouse< TransientMultiApp_transient_multi_apps
 Storage for TransientMultiApps (only needed for calling 'computeDT') More...
 
ExecuteMooseObjectWarehouse< Transfer_transfers
 Normal Transfers. More...
 
ExecuteMooseObjectWarehouse< Transfer_to_multi_app_transfers
 Transfers executed just before MultiApps to transfer data to them. More...
 
ExecuteMooseObjectWarehouse< Transfer_from_multi_app_transfers
 Transfers executed just after MultiApps to transfer data from them. More...
 
ExecuteMooseObjectWarehouse< Transfer_between_multi_app_transfers
 Transfers executed just before MultiApps to transfer data between them. More...
 
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
 A map of objects that consume random numbers. More...
 
std::vector< std::unordered_map< SubdomainID, bool > > _block_mat_side_cache
 Cache for calculating materials on side. More...
 
std::vector< std::unordered_map< BoundaryID, bool > > _bnd_mat_side_cache
 Cache for calculating materials on side. More...
 
std::vector< std::unordered_map< BoundaryID, bool > > _interface_mat_side_cache
 Cache for calculating materials on interface. More...
 
std::vector< MeshChangedInterface * > _notify_when_mesh_changes
 Objects to be notified when the mesh changes. More...
 
std::vector< MeshDisplacedInterface * > _notify_when_mesh_displaces
 Objects to be notified when the mesh displaces. More...
 
Adaptivity _adaptivity
 
unsigned int _cycles_completed
 
std::shared_ptr< XFEMInterface_xfem
 Pointer to XFEM controller. More...
 
MooseMesh_displaced_mesh
 
std::shared_ptr< DisplacedProblem_displaced_problem
 
GeometricSearchData _geometric_search_data
 
MortarData _mortar_data
 
bool _reinit_displaced_elem
 Whether to call DisplacedProblem::reinitElem when this->reinitElem is called. More...
 
bool _reinit_displaced_face
 Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called. More...
 
bool _reinit_displaced_neighbor
 Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called. More...
 
bool _input_file_saved
 whether input file has been written More...
 
bool _has_dampers
 Whether or not this system has any Dampers associated with it. More...
 
bool _has_constraints
 Whether or not this system has any Constraints. More...
 
bool _snesmf_reuse_base
 If or not to resuse the base vector for matrix-free calculation. More...
 
bool _skip_exception_check
 If or not skip 'exception and stop solve'. More...
 
bool _snesmf_reuse_base_set_by_user
 If or not _snesmf_reuse_base is set by user. More...
 
bool _has_initialized_stateful
 Whether nor not stateful materials have been initialized. More...
 
bool _const_jacobian
 true if the Jacobian is constant More...
 
bool _has_jacobian
 Indicates if the Jacobian was computed. More...
 
bool _needs_old_newton_iter
 Indicates that we need to compute variable values for previous Newton iteration. More...
 
bool _previous_nl_solution_required
 Indicates we need to save the previous NL iteration variable values. More...
 
bool _has_nonlocal_coupling
 Indicates if nonlocal coupling is required/exists. More...
 
bool _calculate_jacobian_in_uo
 
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars
 
std::vector< unsigned char > _has_active_material_properties
 Whether there are active material properties on each thread. More...
 
std::vector< SolverParams_solver_params
 
CoverageCheckMode _kernel_coverage_check
 Determines whether and which subdomains are to be checked to ensure that they have an active kernel. More...
 
std::vector< SubdomainName > _kernel_coverage_blocks
 
const bool _boundary_restricted_node_integrity_check
 whether to perform checking of boundary restricted nodal object variable dependencies, e.g. More...
 
const bool _boundary_restricted_elem_integrity_check
 whether to perform checking of boundary restricted elemental object variable dependencies, e.g. More...
 
CoverageCheckMode _material_coverage_check
 Determines whether and which subdomains are to be checked to ensure that they have an active material. More...
 
std::vector< SubdomainName > _material_coverage_blocks
 
bool _fv_bcs_integrity_check
 Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset. More...
 
const bool _material_dependency_check
 Determines whether a check to verify material dependencies on every subdomain. More...
 
const bool _uo_aux_state_check
 Whether or not checking the state of uo/aux evaluation. More...
 
unsigned int _max_qps
 Maximum number of quadrature points used in the problem. More...
 
libMesh::Order _max_scalar_order
 Maximum scalar variable order. More...
 
bool _has_time_integrator
 Indicates whether or not this executioner has a time integrator (during setup) More...
 
bool _has_exception
 Whether or not an exception has occurred. More...
 
bool _parallel_barrier_messaging
 Whether or not information about how many transfers have completed is printed. More...
 
MooseEnum _verbose_setup
 Whether or not to be verbose during setup. More...
 
bool _verbose_multiapps
 Whether or not to be verbose with multiapps. More...
 
bool _verbose_restore
 Whether or not to be verbose on solution restoration post a failed time step. More...
 
std::string _exception_message
 The error message to go with an exception. More...
 
ExecFlagType _current_execute_on_flag
 Current execute_on flag. More...
 
ExecuteMooseObjectWarehouse< Control_control_warehouse
 The control logic warehouse. More...
 
Moose::PetscSupport::PetscOptions _petsc_options
 PETSc option storage. More...
 
PetscOptions _petsc_option_data_base
 
bool _is_petsc_options_inserted
 If or not PETSc options have been added to database. More...
 
std::shared_ptr< LineSearch_line_search
 
std::unique_ptr< libMesh::ConstElemRange_evaluable_local_elem_range
 
std::unique_ptr< libMesh::ConstElemRange_nl_evaluable_local_elem_range
 
std::unique_ptr< libMesh::ConstElemRange_aux_evaluable_local_elem_range
 
std::unique_ptr< libMesh::ConstElemRange_current_algebraic_elem_range
 
std::unique_ptr< libMesh::ConstNodeRange_current_algebraic_node_range
 
std::unique_ptr< ConstBndNodeRange_current_algebraic_bnd_node_range
 
bool _using_ad_mat_props
 Automatic differentiaion (AD) flag which indicates whether any consumer has requested an AD material property or whether any suppier has declared an AD material property. More...
 
unsigned short _current_ic_state
 
const bool _use_hash_table_matrix_assembly
 Whether to assemble matrices using hash tables instead of preallocating matrix memory. More...
 
std::map< TagName, TagID_matrix_tag_name_to_tag_id
 The currently declared tags. More...
 
std::map< TagID, TagName > _matrix_tag_id_to_tag_name
 Reverse map. More...
 
Factory_factory
 The Factory for building objects. More...
 
DiracKernelInfo _dirac_kernel_info
 
std::map< SubdomainID, std::set< std::string > > _map_block_material_props
 Map of material properties (block_id -> list of properties) More...
 
std::map< BoundaryID, std::set< std::string > > _map_boundary_material_props
 Map for boundary material properties (boundary_id -> list of properties) More...
 
std::map< SubdomainID, std::set< MaterialPropertyName > > _zero_block_material_props
 Set of properties returned as zero properties. More...
 
std::map< BoundaryID, std::set< MaterialPropertyName > > _zero_boundary_material_props
 
std::set< std::string > _material_property_requested
 set containing all material property names that have been requested by getMaterialProperty* More...
 
std::vector< std::set< MooseVariableFieldBase * > > _active_elemental_moose_variables
 This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem) More...
 
std::vector< unsigned int_has_active_elemental_moose_variables
 Whether or not there is currently a list of active elemental moose variables. More...
 
std::vector< std::set< TagID > > _active_fe_var_coupleable_matrix_tags
 
std::vector< std::set< TagID > > _active_fe_var_coupleable_vector_tags
 
std::vector< std::set< TagID > > _active_sc_var_coupleable_matrix_tags
 
std::vector< std::set< TagID > > _active_sc_var_coupleable_vector_tags
 
bool _default_ghosting
 Whether or not to use default libMesh coupling. More...
 
std::set< dof_id_type_ghosted_elems
 Elements that should have Dofs ghosted to the local processor. More...
 
bool _currently_computing_jacobian
 Flag to determine whether the problem is currently computing Jacobian. More...
 
bool _currently_computing_residual_and_jacobian
 Flag to determine whether the problem is currently computing the residual and Jacobian. More...
 
bool _computing_nonlinear_residual
 Whether the non-linear residual is being evaluated. More...
 
bool _currently_computing_residual
 Whether the residual is being evaluated. More...
 
bool _safe_access_tagged_matrices
 Is it safe to retrieve data from tagged matrices. More...
 
bool _safe_access_tagged_vectors
 Is it safe to retrieve data from tagged vectors. More...
 
bool _have_ad_objects
 AD flag indicating whether any AD objects have been added. More...
 
std::unordered_set< TagID_not_zeroed_tagged_vectors
 the list of vector tags that will not be zeroed when all other tags are More...
 
bool _cli_option_found
 True if the CLI option is found. More...
 
bool _color_output
 True if we're going to attempt to write color output. More...
 
bool _termination_requested
 True if termination of the solve has been requested. More...
 
const bool & _enabled
 Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects. More...
 
MooseApp_app
 The MOOSE application this is associated with. More...
 
ActionFactory_action_factory
 Builds Actions. More...
 
const std::string & _type
 The type of this class. More...
 
const std::string & _name
 The name of this class. More...
 
const InputParameters_pars
 The object's parameters. More...
 
const Parallel::Communicator_communicator
 
MooseApp_pg_moose_app
 The MooseApp that owns the PerfGraph. More...
 
const std::string _prefix
 A prefix to use for all sections. More...
 
MooseApp_restartable_app
 Reference to the application. More...
 
const std::string _restartable_system_name
 The system name this object is in. More...
 
const THREAD_ID _restartable_tid
 The thread ID for this object. More...
 
const bool _restartable_read_only
 Flag for toggling read only status (see ReporterData) More...
 
InitialConditionWarehouse _ics
 
FVInitialConditionWarehouse _fv_ics
 
ScalarInitialConditionWarehouse _scalar_ics
 
MaterialWarehouse _materials
 
MaterialWarehouse _interface_materials
 
MaterialWarehouse _discrete_materials
 
MaterialWarehouse _all_materials
 
MaterialWarehouse _kokkos_materials
 
MooseObjectWarehouse< Indicator_indicators
 
MooseObjectWarehouse< InternalSideIndicatorBase_internal_side_indicators
 
std::map< SubdomainID, std::multimap< std::string, std::string > > _map_block_material_props_check
 Data structures of the requested material properties. More...
 
std::map< BoundaryID, std::multimap< std::string, std::string > > _map_boundary_material_props_check
 

Detailed Description

Definition at line 17 of file MFEMProblem.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName
inherited

The parameter type this interface expects for a data file name.

Definition at line 27 of file DataFileInterface.h.

Member Enumeration Documentation

◆ CoverageCheckMode

enum FEProblemBase::CoverageCheckMode
stronginherited
Enumerator
FALSE 
TRUE 
OFF 
ON 
SKIP_LIST 
ONLY_LIST 

Definition at line 152 of file FEProblemBase.h.

153  {
154  FALSE,
155  TRUE,
156  OFF,
157  ON,
158  SKIP_LIST,
159  ONLY_LIST,
160  };

◆ Direction

enum ExternalProblem::Direction : unsigned char
stronginherited
Enumerator
TO_EXTERNAL_APP 
FROM_EXTERNAL_APP 

Definition at line 21 of file ExternalProblem.h.

21  : unsigned char
22  {
23  TO_EXTERNAL_APP,
24  FROM_EXTERNAL_APP
25  };

Constructor & Destructor Documentation

◆ MFEMProblem()

MFEMProblem::MFEMProblem ( const InputParameters params)

Definition at line 33 of file MFEMProblem.C.

33  : ExternalProblem(params)
34 {
35  // Initialise Hypre for all MFEM problems.
36  mfem::Hypre::Init();
37  setMesh();
38 }
void setMesh()
Set the mesh used by MFEM.
Definition: MFEMProblem.C:48
ExternalProblem(const InputParameters &parameters)

◆ ~MFEMProblem()

virtual MFEMProblem::~MFEMProblem ( )
inlinevirtual

Definition at line 23 of file MFEMProblem.h.

23 {}

Member Function Documentation

◆ _setCLIOption()

void Problem::_setCLIOption ( )
inlineinherited

For Internal Use.

Definition at line 32 of file Problem.h.

32 { _cli_option_found = true; }
bool _cli_option_found
True if the CLI option is found.
Definition: Problem.h:52

◆ acceptInvalidSolution()

bool FEProblemBase::acceptInvalidSolution ( ) const
inherited

Whether or not to accept the solution based on its invalidity.

If this returns false, it means that an invalid solution was encountered (an error) that was not allowed.

Definition at line 3939 of file FEProblemBase.C.

Referenced by SolverSystem::checkInvalidSolution(), and NonlinearSystem::converged().

3940 {
3941  return allowInvalidSolution() || // invalid solutions are always allowed
3942  !_app.solutionInvalidity().hasInvalidSolutionError(); // if not allowed, check for errors
3943 }
bool hasInvalidSolutionError() const
Whether or not an invalid solution was encountered that was an error.
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
Definition: MooseApp.h:179
bool allowInvalidSolution() const
Whether to accept / allow an invalid solution.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357

◆ adaptivity()

Adaptivity& FEProblemBase::adaptivity ( )
inlineinherited

◆ adaptMesh()

bool FEProblemBase::adaptMesh ( )
virtualinherited
Returns
Whether or not the mesh was changed

Reimplemented in DumpObjectsProblem.

Definition at line 8116 of file FEProblemBase.C.

Referenced by SteadyBase::execute(), Eigenvalue::execute(), and TransientBase::incrementStepOrReject().

8117 {
8118  // reset cycle counter
8119  _cycles_completed = 0;
8120 
8122  return false;
8123 
8124  TIME_SECTION("adaptMesh", 3, "Adapting Mesh");
8125 
8126  unsigned int cycles_per_step = _adaptivity.getCyclesPerStep();
8127 
8128  bool mesh_changed = false;
8129 
8130  for (unsigned int i = 0; i < cycles_per_step; ++i)
8131  {
8132  if (!_mesh.interiorLowerDBlocks().empty() || !_mesh.boundaryLowerDBlocks().empty())
8133  mooseError("HFEM does not support mesh adaptivity currently.");
8134 
8135  // Markers were already computed once by Executioner
8136  if (_adaptivity.getRecomputeMarkersFlag() && i > 0)
8137  computeMarkers();
8138 
8139  bool mesh_changed_this_step;
8140  mesh_changed_this_step = _adaptivity.adaptMesh();
8141 
8142  if (mesh_changed_this_step)
8143  {
8144  mesh_changed = true;
8145 
8146  meshChanged(
8147  /*intermediate_change=*/true, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
8149  }
8150  else
8151  {
8152  // If the mesh didn't change, we still need to update the displaced mesh
8153  // to undo the undisplacement performed in Adaptivity::adaptMesh
8154  if (_displaced_problem)
8155  _displaced_problem->updateMesh();
8156 
8157  _console << "Mesh unchanged, skipping remaining steps..." << std::endl;
8158  break;
8159  }
8160 
8161  // Show adaptivity progress
8162  _console << std::flush;
8163  }
8164 
8165  // We're done with all intermediate changes; now get systems ready
8166  // for real if necessary.
8167  if (mesh_changed)
8168  es().reinit_systems();
8169 
8170  // Execute multi-apps that need to run after adaptivity, but before the next timestep.
8172 
8173  return mesh_changed;
8174 }
bool adaptMesh(std::string marker_name=std::string())
Adapts the mesh based on the error estimator used.
Definition: Adaptivity.C:131
virtual void meshChanged()
Deprecated.
const std::set< SubdomainID > & interiorLowerDBlocks() const
Definition: MooseMesh.h:1429
unsigned int _cycles_completed
unsigned int getCyclesPerStep() const
Pull out the number of cycles_per_step previously set through the AdaptivityAction.
Definition: Adaptivity.h:112
virtual void computeMarkers()
virtual void reinit_systems()
bool getRecomputeMarkersFlag() const
Pull out the _recompute_markers_during_cycles flag previously set through the AdaptivityAction.
Definition: Adaptivity.h:125
virtual libMesh::EquationSystems & es() override
MooseMesh & _mesh
Adaptivity _adaptivity
const std::set< SubdomainID > & boundaryLowerDBlocks() const
Definition: MooseMesh.h:1433
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
std::shared_ptr< DisplacedProblem > _displaced_problem
bool isAdaptivityDue()
Query if an adaptivity step should be performed at the current time / time step.
Definition: Adaptivity.C:393
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
const ExecFlagType EXEC_POST_ADAPTIVITY
Definition: Moose.C:58

◆ addAlgebraicGhostingFunctor()

void SubProblem::addAlgebraicGhostingFunctor ( libMesh::GhostingFunctor algebraic_gf,
bool  to_mesh = true 
)
inherited

Add an algebraic ghosting functor to this problem's DofMaps.

Definition at line 1023 of file SubProblem.C.

1024 {
1025  EquationSystems & eq = es();
1026  const auto n_sys = eq.n_systems();
1027  if (!n_sys)
1028  return;
1029 
1030  eq.get_system(0).get_dof_map().add_algebraic_ghosting_functor(algebraic_gf, to_mesh);
1031  cloneAlgebraicGhostingFunctor(algebraic_gf, to_mesh);
1032 }
unsigned int n_systems() const
void cloneAlgebraicGhostingFunctor(libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
Creates (n_sys - 1) clones of the provided algebraic ghosting functor (corresponding to the nonlinear...
Definition: SubProblem.C:1001
const T_sys & get_system(std::string_view name) const
virtual libMesh::EquationSystems & es()=0

◆ addAuxArrayVariable()

void FEProblemBase::addAuxArrayVariable ( const std::string &  var_name,
const libMesh::FEType type,
unsigned int  components,
const std::set< SubdomainID > *const  active_subdomains = NULL 
)
virtualinherited

Definition at line 3221 of file FEProblemBase.C.

3225 {
3226  parallel_object_only();
3227 
3228  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");
3229 
3230  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
3231  return;
3232 
3233  InputParameters params = _factory.getValidParams("ArrayMooseVariable");
3234  params.set<FEProblemBase *>("_fe_problem_base") = this;
3236  params.set<MooseEnum>("order") = type.order.get_order();
3237  params.set<MooseEnum>("family") = Moose::stringify(type.family);
3238  params.set<unsigned int>("components") = components;
3239 
3240  if (active_subdomains)
3241  for (const SubdomainID & id : *active_subdomains)
3242  params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
3243 
3244  logAdd("Variable", var_name, "ArrayMooseVariable", params);
3245  _aux->addVariable("ArrayMooseVariable", var_name, params);
3246  if (_displaced_problem)
3247  _displaced_problem->addAuxVariable("ArrayMooseVariable", var_name, params);
3248 
3249  markFamilyPRefinement(params);
3250 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void logAdd(const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const
Output information about the object just added to the problem.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
void markFamilyPRefinement(const InputParameters &params)
Mark a variable family for either disabling or enabling p-refinement with valid parameters of a varia...
Definition: SubProblem.C:1367
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
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.
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addAuxKernel()

void MFEMProblem::addAuxKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Override of ExternalProblem::addAuxKernel.

Uses ExternalProblem::addAuxKernel to create a MFEMGeneralUserObject representing the kernel in MOOSE, and creates corresponding MFEM kernel to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 214 of file MFEMProblem.C.

217 {
219 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)

◆ addAuxScalarKernel()

void FEProblemBase::addAuxScalarKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3325 of file FEProblemBase.C.

3328 {
3329  parallel_object_only();
3330 
3331  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3332  {
3333  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3334  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
3335  }
3336  else
3337  {
3338  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3339  {
3340  // We allow AuxScalarKernels to request that they use_displaced_mesh,
3341  // but then be overridden when no displacements variables are
3342  // provided in the Mesh block. If that happened, update the value
3343  // of use_displaced_mesh appropriately for this AuxScalarKernel.
3344  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3345  parameters.set<bool>("use_displaced_mesh") = false;
3346  }
3347 
3348  parameters.set<SubProblem *>("_subproblem") = this;
3349  parameters.set<SystemBase *>("_sys") = _aux.get();
3350  }
3351 
3352  logAdd("AuxScalarKernel", name, kernel_name, parameters);
3353  _aux->addScalarKernel(kernel_name, name, parameters);
3354 }
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addAuxScalarVariable()

void FEProblemBase::addAuxScalarVariable ( const std::string &  var_name,
libMesh::Order  order,
Real  scale_factor = 1.,
const std::set< SubdomainID > *const  active_subdomains = NULL 
)
virtualinherited

Definition at line 3253 of file FEProblemBase.C.

3257 {
3258  parallel_object_only();
3259 
3260  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");
3261 
3262  if (order > _max_scalar_order)
3263  _max_scalar_order = order;
3264 
3265  FEType type(order, SCALAR);
3266  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
3267  return;
3268 
3269  InputParameters params = _factory.getValidParams("MooseVariableScalar");
3270  params.set<FEProblemBase *>("_fe_problem_base") = this;
3272 
3273  params.set<MooseEnum>("order") = type.order.get_order();
3274  params.set<MooseEnum>("family") = "SCALAR";
3275  params.set<std::vector<Real>>("scaling") = {1};
3276  if (active_subdomains)
3277  for (const SubdomainID & id : *active_subdomains)
3278  params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
3279 
3280  logAdd("ScalarVariable", var_name, "MooseVariableScalar", params);
3281  _aux->addVariable("MooseVariableScalar", var_name, params);
3282  if (_displaced_problem)
3283  _displaced_problem->addAuxVariable("MooseVariableScalar", var_name, params);
3284 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void logAdd(const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const
Output information about the object just added to the problem.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
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.
std::shared_ptr< DisplacedProblem > _displaced_problem
libMesh::Order _max_scalar_order
Maximum scalar variable order.

◆ addAuxVariable() [1/2]

void MFEMProblem::addAuxVariable ( const std::string &  var_type,
const std::string &  var_name,
InputParameters parameters 
)
overridevirtual

Override of ExternalProblem::addAuxVariable.

Sets a MFEM grid function to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 204 of file MFEMProblem.C.

207 {
208  // We handle MFEM AuxVariables just like MFEM Variables, except
209  // we do not add additional GridFunctions for time derivatives.
210  addGridFunction(var_type, var_name, parameters);
211 }
void addGridFunction(const std::string &var_type, const std::string &var_name, InputParameters &parameters)
Adds one MFEM GridFunction to be used in the MFEM solve.
Definition: MFEMProblem.C:173
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131

◆ addAuxVariable() [2/2]

void FEProblemBase::addAuxVariable ( const std::string &  var_name,
const libMesh::FEType type,
const std::set< SubdomainID > *const  active_subdomains = NULL 
)
virtualinherited

Definition at line 3181 of file FEProblemBase.C.

3184 {
3185  parallel_object_only();
3186 
3187  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");
3188 
3189  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
3190  return;
3191 
3192  std::string var_type;
3193  if (type == FEType(0, MONOMIAL))
3194  var_type = "MooseVariableConstMonomial";
3195  else if (type.family == SCALAR)
3196  var_type = "MooseVariableScalar";
3197  else if (FEInterface::field_type(type) == TYPE_VECTOR)
3198  var_type = "VectorMooseVariable";
3199  else
3200  var_type = "MooseVariable";
3201 
3202  InputParameters params = _factory.getValidParams(var_type);
3203  params.set<FEProblemBase *>("_fe_problem_base") = this;
3205  params.set<MooseEnum>("order") = type.order.get_order();
3206  params.set<MooseEnum>("family") = Moose::stringify(type.family);
3207 
3208  if (active_subdomains)
3209  for (const SubdomainID & id : *active_subdomains)
3210  params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
3211 
3212  logAdd("AuxVariable", var_name, var_type, params);
3213  _aux->addVariable(var_type, var_name, params);
3214  if (_displaced_problem)
3215  _displaced_problem->addAuxVariable("MooseVariable", var_name, params);
3216 
3217  markFamilyPRefinement(params);
3218 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void logAdd(const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const
Output information about the object just added to the problem.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
void markFamilyPRefinement(const InputParameters &params)
Mark a variable family for either disabling or enabling p-refinement with valid parameters of a varia...
Definition: SubProblem.C:1367
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
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.
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addBoundaryCondition()

void MFEMProblem::addBoundaryCondition ( const std::string &  bc_name,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Reimplemented from FEProblemBase.

Definition at line 90 of file MFEMProblem.C.

93 {
95  const UserObject * mfem_bc_uo = &(getUserObjectBase(name));
96  if (dynamic_cast<const MFEMIntegratedBC *>(mfem_bc_uo) != nullptr)
97  {
98  auto object_ptr = getUserObject<MFEMIntegratedBC>(name).getSharedPtr();
99  auto bc = std::dynamic_pointer_cast<MFEMIntegratedBC>(object_ptr);
101  {
102  getProblemData().eqn_system->AddIntegratedBC(std::move(bc));
103  }
104  else
105  {
106  mooseError("Cannot add integrated BC with name '" + name +
107  "' because there is no corresponding equation system.");
108  }
109  }
110  else if (dynamic_cast<const MFEMEssentialBC *>(mfem_bc_uo) != nullptr)
111  {
112  auto object_ptr = getUserObject<MFEMEssentialBC>(name).getSharedPtr();
113  auto mfem_bc = std::dynamic_pointer_cast<MFEMEssentialBC>(object_ptr);
115  {
116  getProblemData().eqn_system->AddEssentialBC(std::move(mfem_bc));
117  }
118  else
119  {
120  mooseError("Cannot add boundary condition with name '" + name +
121  "' because there is no corresponding equation system.");
122  }
123  }
124  else
125  {
126  mooseError("Unsupported bc of type '", bc_name, "' and name '", name, "' detected.");
127  }
128 }
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
std::shared_ptr< MooseObject > getSharedPtr()
Get another shared pointer to this object that has the same ownership group.
Definition: MooseObject.C:68
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< Moose::MFEM::EquationSystem > eqn_system
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
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
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.
Base class for user-specific data.
Definition: UserObject.h:40

◆ addCachedJacobian()

void FEProblemBase::addCachedJacobian ( const THREAD_ID  tid)
overridevirtualinherited

◆ addCachedResidual()

void FEProblemBase::addCachedResidual ( const THREAD_ID  tid)
overridevirtualinherited

◆ addCachedResidualDirectly()

void FEProblemBase::addCachedResidualDirectly ( NumericVector< libMesh::Number > &  residual,
const THREAD_ID  tid 
)
virtualinherited

Allows for all the residual contributions that are currently cached to be added directly into the vector passed in.

Parameters
residualThe vector to add the cached contributions to.
tidThe thread id.

Definition at line 1923 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals(), and NonlinearSystemBase::enforceNodalConstraintsResidual().

1924 {
1926  _assembly[tid][_current_nl_sys->number()]->addCachedResidualDirectly(
1928 
1930  _assembly[tid][_current_nl_sys->number()]->addCachedResidualDirectly(
1932 
1933  // We do this because by adding the cached residual directly, we cannot ensure that all of the
1934  // cached residuals are emptied after only the two add calls above
1935  _assembly[tid][_current_nl_sys->number()]->clearCachedResiduals(Assembly::GlobalDataKey{});
1936 
1937  if (_displaced_problem)
1938  _displaced_problem->addCachedResidualDirectly(residual, tid);
1939 }
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
Definition: SystemBase.C:924
TagID nonTimeVectorTag() const override
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
TagID timeVectorTag() const override
Ideally, we should not need this API.
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
Definition: SubProblem.C:161
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addConstraint()

void FEProblemBase::addConstraint ( const std::string &  c_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3097 of file FEProblemBase.C.

3100 {
3101  parallel_object_only();
3102 
3103  _has_constraints = true;
3104 
3105  auto determine_var_param_name = [&parameters, this]()
3106  {
3107  if (parameters.isParamValid("variable"))
3108  return "variable";
3109  else
3110  {
3111  // must be a mortar constraint
3112  const bool has_secondary_var = parameters.isParamValid("secondary_variable");
3113  const bool has_primary_var = parameters.isParamValid("primary_variable");
3114  if (!has_secondary_var && !has_primary_var)
3115  mooseError(
3116  "Either a 'secondary_variable' or 'primary_variable' parameter must be supplied for '",
3118  "'");
3119  return has_secondary_var ? "secondary_variable" : "primary_variable";
3120  }
3121  };
3122 
3123  const auto nl_sys_num =
3124  determineSolverSystem(parameters.varName(determine_var_param_name(), name), true).second;
3125  if (!isSolverSystemNonlinear(nl_sys_num))
3126  mooseError("You are trying to add a Constraint to a linear variable/system, which is not "
3127  "supported at the moment!");
3128 
3129  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3130  {
3131  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3132  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3133  _reinit_displaced_face = true;
3134  }
3135  else
3136  {
3137  // It might _want_ to use a displaced mesh... but we're not so set it to false
3138  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3139  parameters.set<bool>("use_displaced_mesh") = false;
3140 
3141  parameters.set<SubProblem *>("_subproblem") = this;
3142  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3143  }
3144 
3145  logAdd("Constraint", name, c_name, parameters);
3146  _nl[nl_sys_num]->addConstraint(c_name, name, parameters);
3147 }
const std::string & getObjectName() const
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
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.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
std::shared_ptr< DisplacedProblem > _displaced_problem
bool _has_constraints
Whether or not this system has any Constraints.
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ addConsumedPropertyName()

void SubProblem::addConsumedPropertyName ( const MooseObjectName obj_name,
const std::string &  prop_name 
)
inherited

Helper for tracking the object that is consuming a property for MaterialPropertyDebugOutput.

Definition at line 736 of file SubProblem.C.

Referenced by MaterialPropertyInterface::addConsumedPropertyName().

737 {
738  _consumed_material_properties[obj_name].insert(prop_name);
739 }
std::map< MooseObjectName, std::set< std::string > > _consumed_material_properties
Definition: SubProblem.h:1185

◆ addConvergence()

void FEProblemBase::addConvergence ( const std::string &  type,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Adds a Convergence object.

Definition at line 2554 of file FEProblemBase.C.

Referenced by FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), and FEProblemBase::addDefaultSteadyStateConvergence().

2557 {
2558  parallel_object_only();
2559 
2560  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
2561  {
2562  std::shared_ptr<Convergence> conv = _factory.create<Convergence>(type, name, parameters, tid);
2563  _convergences.addObject(conv, tid);
2564  }
2565 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
unsigned int n_threads()
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseObjectWarehouse< Convergence > _convergences
convergence warehouse
virtual std::unique_ptr< Base > create()=0
Base class for convergence criteria.
Definition: Convergence.h:21
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ addCouplingGhostingFunctor()

void SubProblem::addCouplingGhostingFunctor ( libMesh::GhostingFunctor coupling_gf,
bool  to_mesh = true 
)
inherited

Add a coupling functor to this problem's DofMaps.

Definition at line 1056 of file SubProblem.C.

1057 {
1058  const auto num_nl_sys = numNonlinearSystems();
1059  if (!num_nl_sys)
1060  return;
1061 
1062  systemBaseNonlinear(0).system().get_dof_map().add_coupling_functor(coupling_gf, to_mesh);
1063  cloneCouplingGhostingFunctor(coupling_gf, to_mesh);
1064 }
void cloneCouplingGhostingFunctor(libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
Creates (n_sys - 1) clones of the provided coupling ghosting functor (corresponding to the nonlinear ...
Definition: SubProblem.C:1035
virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const =0
Return the nonlinear system object as a base class reference given the system number.
virtual libMesh::System & system()=0
Get the reference to the libMesh system.
void add_coupling_functor(GhostingFunctor &coupling_functor, bool to_mesh=true)
virtual std::size_t numNonlinearSystems() const =0
const DofMap & get_dof_map() const

◆ addDamper()

void FEProblemBase::addDamper ( const std::string &  damper_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 5290 of file FEProblemBase.C.

5293 {
5294  parallel_object_only();
5295 
5296  const auto nl_sys_num =
5297  parameters.isParamValid("variable")
5298  ? determineSolverSystem(parameters.varName("variable", name), true).second
5299  : (unsigned int)0;
5300 
5301  if (!isSolverSystemNonlinear(nl_sys_num))
5302  mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
5303  "supported at the moment!");
5304 
5305  parameters.set<SubProblem *>("_subproblem") = this;
5306  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
5307 
5308  _has_dampers = true;
5309  logAdd("Damper", name, damper_name, parameters);
5310  _nl[nl_sys_num]->addDamper(damper_name, name, parameters);
5311 }
bool _has_dampers
Whether or not this system has any Dampers associated with it.
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
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.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ addDefaultMultiAppFixedPointConvergence()

void FEProblemBase::addDefaultMultiAppFixedPointConvergence ( const InputParameters params)
inherited

Adds the default fixed point Convergence associated with the problem.

This is called if the user does not supply 'multiapp_fixed_point_convergence'.

Parameters
[in]paramsParameters to apply to Convergence parameters

Definition at line 2580 of file FEProblemBase.C.

2581 {
2582  const std::string class_name = "DefaultMultiAppFixedPointConvergence";
2583  InputParameters params = _factory.getValidParams(class_name);
2584  params.applyParameters(params_to_apply);
2585  params.applyParameters(parameters());
2586  params.set<bool>("added_as_default") = true;
2588 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Method for applying common parameters.
virtual void addConvergence(const std::string &type, const std::string &name, InputParameters &parameters)
Adds a Convergence object.
const ConvergenceName & getMultiAppFixedPointConvergenceName() const
Gets the MultiApp fixed point convergence object name.

◆ addDefaultNonlinearConvergence()

void FEProblemBase::addDefaultNonlinearConvergence ( const InputParameters params)
virtualinherited

Adds the default nonlinear Convergence associated with the problem.

This is called if the user does not supply 'nonlinear_convergence'.

Parameters
[in]paramsParameters to apply to Convergence parameters

Reimplemented in ReferenceResidualProblem.

Definition at line 2568 of file FEProblemBase.C.

2569 {
2570  const std::string class_name = "DefaultNonlinearConvergence";
2571  InputParameters params = _factory.getValidParams(class_name);
2572  params.applyParameters(params_to_apply);
2573  params.applyParameters(parameters());
2574  params.set<bool>("added_as_default") = true;
2575  for (const auto & conv_name : getNonlinearConvergenceNames())
2576  addConvergence(class_name, conv_name, params);
2577 }
const std::vector< ConvergenceName > & getNonlinearConvergenceNames() const
Gets the nonlinear system convergence object name(s).
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Method for applying common parameters.
virtual void addConvergence(const std::string &type, const std::string &name, InputParameters &parameters)
Adds a Convergence object.

◆ addDefaultSteadyStateConvergence()

void FEProblemBase::addDefaultSteadyStateConvergence ( const InputParameters params)
inherited

Adds the default steady-state detection Convergence.

This is called if the user does not supply 'steady_state_convergence'.

Parameters
[in]paramsParameters to apply to Convergence parameters

Definition at line 2591 of file FEProblemBase.C.

2592 {
2593  const std::string class_name = "DefaultSteadyStateConvergence";
2594  InputParameters params = _factory.getValidParams(class_name);
2595  params.applyParameters(params_to_apply);
2596  params.applyParameters(parameters());
2597  params.set<bool>("added_as_default") = true;
2598  addConvergence(class_name, getSteadyStateConvergenceName(), params);
2599 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Method for applying common parameters.
const ConvergenceName & getSteadyStateConvergenceName() const
Gets the steady-state detection convergence object name.
virtual void addConvergence(const std::string &type, const std::string &name, InputParameters &parameters)
Adds a Convergence object.

◆ addDGKernel()

void FEProblemBase::addDGKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3397 of file FEProblemBase.C.

3400 {
3401  parallel_object_only();
3402 
3403  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3404  if (!isSolverSystemNonlinear(nl_sys_num))
3405  mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
3406  "supported at the moment!");
3407 
3408  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3409  {
3410  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3411  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3413  }
3414  else
3415  {
3416  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3417  {
3418  // We allow DGKernels to request that they use_displaced_mesh,
3419  // but then be overridden when no displacements variables are
3420  // provided in the Mesh block. If that happened, update the value
3421  // of use_displaced_mesh appropriately for this DGKernel.
3422  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3423  parameters.set<bool>("use_displaced_mesh") = false;
3424  }
3425 
3426  parameters.set<SubProblem *>("_subproblem") = this;
3427  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3428  }
3429 
3430  logAdd("DGKernel", name, dg_kernel_name, parameters);
3431  _nl[nl_sys_num]->addDGKernel(dg_kernel_name, name, parameters);
3432 
3434 }
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
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.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
std::shared_ptr< DisplacedProblem > _displaced_problem
bool _has_internal_edge_residual_objects
Whether the problem has dgkernels or interface kernels.

◆ addDiracKernel()

void FEProblemBase::addDiracKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3357 of file FEProblemBase.C.

3360 {
3361  parallel_object_only();
3362 
3363  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3364  if (!isSolverSystemNonlinear(nl_sys_num))
3365  mooseError("You are trying to add a DiracKernel to a linear variable/system, which is not "
3366  "supported at the moment!");
3367 
3368  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3369  {
3370  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3371  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3372  _reinit_displaced_elem = true;
3373  }
3374  else
3375  {
3376  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3377  {
3378  // We allow DiracKernels to request that they use_displaced_mesh,
3379  // but then be overridden when no displacements variables are
3380  // provided in the Mesh block. If that happened, update the value
3381  // of use_displaced_mesh appropriately for this DiracKernel.
3382  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3383  parameters.set<bool>("use_displaced_mesh") = false;
3384  }
3385 
3386  parameters.set<SubProblem *>("_subproblem") = this;
3387  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3388  }
3389 
3390  logAdd("DiracKernel", name, kernel_name, parameters);
3391  _nl[nl_sys_num]->addDiracKernel(kernel_name, name, parameters);
3392 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
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.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addDisplacedProblem()

void FEProblemBase::addDisplacedProblem ( std::shared_ptr< DisplacedProblem displaced_problem)
virtualinherited

Definition at line 7930 of file FEProblemBase.C.

7931 {
7932  parallel_object_only();
7933 
7936 }
std::shared_ptr< DisplacedProblem > displaced_problem
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseMesh * _displaced_mesh

◆ addDistribution()

void FEProblemBase::addDistribution ( const std::string &  type,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

The following functions will enable MOOSE to have the capability to import distributions.

Definition at line 2720 of file FEProblemBase.C.

2723 {
2724  parameters.set<std::string>("type") = type;
2725  addObject<Distribution>(type, name, parameters, /* threaded = */ false);
2726 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

◆ addExternalVariables()

virtual void ExternalProblem::addExternalVariables ( )
inlinevirtualinherited

Method called to add AuxVariables to the simulation.

These variables would be the fields that should either be saved out with the MOOSE-formatted solutions or available for transfer to variables in Multiapp simulations.

Definition at line 48 of file ExternalProblem.h.

Referenced by AddExternalAuxVariableAction::act().

48 {}

◆ addFESpace()

void MFEMProblem::addFESpace ( const std::string &  user_object_name,
const std::string &  name,
InputParameters parameters 
)

Add an MFEM FESpace to the problem.

Definition at line 147 of file MFEMProblem.C.

Referenced by AddMFEMFESpaceAction::act(), and addMFEMFESpaceFromMOOSEVariable().

150 {
151  FEProblemBase::addUserObject(user_object_name, name, parameters);
152  MFEMFESpace & mfem_fespace(getUserObject<MFEMFESpace>(name));
153 
154  // Register fespace and associated fe collection.
155  getProblemData().fecs.Register(name, mfem_fespace.getFEC());
156  getProblemData().fespaces.Register(name, mfem_fespace.getFESpace());
157 }
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
Moose::MFEM::FESpaces fespaces
Moose::MFEM::FECollections fecs
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
Constructs and stores an mfem::ParFiniteElementSpace object.
Definition: MFEMFESpace.h:22
void Register(const std::string &field_name, FieldArgs &&... args)
Construct new field with name field_name and register.
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)

◆ addFunction()

void MFEMProblem::addFunction ( const std::string &  type,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Override of ExternalProblem::addFunction.

Uses ExternalProblem::addFunction to create a MFEMGeneralUserObject representing the function in MOOSE, and creates a corresponding MFEM Coefficient or VectorCoefficient object.

Reimplemented from FEProblemBase.

Definition at line 325 of file MFEMProblem.C.

328 {
330  auto & func = getFunction(name);
331  // FIXME: Do we want to have optimised versions for when functions
332  // are only of space or only of time.
333  if (std::find(SCALAR_FUNCS.begin(), SCALAR_FUNCS.end(), type) != SCALAR_FUNCS.end())
334  {
335  getCoefficients().declareScalar<mfem::FunctionCoefficient>(
336  name,
337  [&func](const mfem::Vector & p, double t) -> mfem::real_t
338  { return func.value(t, pointFromMFEMVector(p)); });
339  }
340  else if (std::find(VECTOR_FUNCS.begin(), VECTOR_FUNCS.end(), type) != VECTOR_FUNCS.end())
341  {
343  getCoefficients().declareVector<mfem::VectorFunctionCoefficient>(
344  name,
345  dim,
346  [&func, dim](const mfem::Vector & p, double t, mfem::Vector & u)
347  {
348  libMesh::RealVectorValue vector_value = func.vectorValue(t, pointFromMFEMVector(p));
349  for (int i = 0; i < dim; i++)
350  {
351  u[i] = vector_value(i);
352  }
353  });
354  }
355  else
356  {
357  mooseWarning("Could not identify whether function ",
358  type,
359  " is scalar or vector; no MFEM coefficient object created.");
360  }
361 }
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:30
const std::vector< std::string > SCALAR_FUNCS
Definition: MFEMProblem.C:284
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:159
int vectorFunctionDim(const std::string &type, const InputParameters &parameters)
Definition: MFEMProblem.C:257
virtual Function & getFunction(const std::string &name, const THREAD_ID tid=0)
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
mfem::Coefficient & declareScalar(const std::string &name, const std::string &existing_or_literal)
Declare an alias to an existing scalar coefficient or, if it does not exist, try interpreting the nam...
mfem::VectorCoefficient & declareVector(const std::string &name, const std::string &existing_or_literal)
Declare an alias to an existing vector coefficientor or, if it does not exist, try interpreting the n...
virtual void addFunction(const std::string &type, const std::string &name, InputParameters &parameters)
Moose::MFEM::CoefficientManager & getCoefficients()
Method to get the PropertyManager object for storing material properties and converting them to MFEM ...
Definition: MFEMProblem.h:180
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
libMesh::Point pointFromMFEMVector(const mfem::Vector &vec)
Definition: MFEMProblem.C:250
const std::vector< std::string > VECTOR_FUNCS
Definition: MFEMProblem.C:322
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:299

◆ addFunctor()

template<typename T >
void SubProblem::addFunctor ( const std::string &  name,
const Moose::FunctorBase< T > &  functor,
const THREAD_ID  tid 
)
inherited

add a functor to the problem functor container

Definition at line 1375 of file SubProblem.h.

Referenced by FEProblemBase::addFunction(), SubProblem::addPiecewiseByBlockLambdaFunctor(), FEProblemBase::addUserObject(), and SystemBase::addVariable().

1378 {
1379  constexpr bool added_functor_is_ad =
1380  !std::is_same<T, typename MetaPhysicL::RawType<T>::value_type>::value;
1381 
1382  mooseAssert(tid < _functors.size(), "Too large a thread ID");
1383 
1384  auto & functor_to_request_info = _functor_to_request_info[tid];
1385  auto & functors = _functors[tid];
1386  auto it = functors.find("wraps_" + name);
1387  if (it != functors.end())
1388  {
1389  // We have this functor already. If it's a null functor, we want to replace it with the valid
1390  // functor we have now. If it's not then we'll add a new entry into the multimap and then we'll
1391  // error later if a user requests a functor because their request is ambiguous. This is the
1392  // reason that the functors container is a multimap: for nice error messages
1393  auto * const existing_wrapper_base =
1394  added_functor_is_ad ? std::get<2>(it->second).get() : std::get<1>(it->second).get();
1395  auto * const existing_wrapper = dynamic_cast<Moose::Functor<T> *>(existing_wrapper_base);
1396  if (existing_wrapper && existing_wrapper->template wrapsType<Moose::NullFunctor<T>>())
1397  {
1398  // Sanity check
1399  auto [request_info_it, request_info_end_it] = functor_to_request_info.equal_range(name);
1400  if (request_info_it == request_info_end_it)
1401  mooseError("We are wrapping a NullFunctor but we don't have any unfilled functor request "
1402  "info. This doesn't make sense.");
1403 
1404  // Check for valid requests
1405  while (request_info_it != request_info_end_it)
1406  {
1407  auto & [requested_functor_is_ad, requestor_is_ad] = request_info_it->second;
1408  if (!requested_functor_is_ad && requestor_is_ad && added_functor_is_ad)
1409  mooseError("We are requesting a non-AD functor '" + name +
1410  "' from an AD object, but the true functor is AD. This means we could be "
1411  "dropping important derivatives. We will not allow this");
1412  // We're going to eventually check whether we've fulfilled all functor requests and our
1413  // check will be that the multimap is empty. This request is fulfilled, so erase it from the
1414  // map now
1415  request_info_it = functor_to_request_info.erase(request_info_it);
1416  }
1417 
1418  // Ok we didn't have the functor before, so we will add it now
1419  std::get<0>(it->second) =
1421  existing_wrapper->assign(functor);
1422  // Finally we create the non-AD or AD complement of the just added functor
1423  if constexpr (added_functor_is_ad)
1424  {
1425  typedef typename MetaPhysicL::RawType<T>::value_type NonADType;
1426  auto * const existing_non_ad_wrapper_base = std::get<1>(it->second).get();
1427  auto * const existing_non_ad_wrapper =
1428  dynamic_cast<Moose::Functor<NonADType> *>(existing_non_ad_wrapper_base);
1429  mooseAssert(existing_non_ad_wrapper->template wrapsType<Moose::NullFunctor<NonADType>>(),
1430  "Both members of pair should have been wrapping a NullFunctor");
1431  existing_non_ad_wrapper->assign(
1432  std::make_unique<Moose::RawValueFunctor<NonADType>>(functor));
1433  }
1434  else
1435  {
1436  typedef typename Moose::ADType<T>::type ADType;
1437  auto * const existing_ad_wrapper_base = std::get<2>(it->second).get();
1438  auto * const existing_ad_wrapper =
1439  dynamic_cast<Moose::Functor<ADType> *>(existing_ad_wrapper_base);
1440  mooseAssert(existing_ad_wrapper->template wrapsType<Moose::NullFunctor<ADType>>(),
1441  "Both members of pair should have been wrapping a NullFunctor");
1442  existing_ad_wrapper->assign(std::make_unique<Moose::ADWrapperFunctor<ADType>>(functor));
1443  }
1444  return;
1445  }
1446  else if (!existing_wrapper)
1447  {
1448  // Functor was emplaced but the cast failed. This could be a double definition with
1449  // different types, or it could be a request with one type then a definition with another
1450  // type. Either way it is going to error later, but it is cleaner to catch it now
1451  mooseError("Functor '",
1452  name,
1453  "' is being added with return type '",
1454  MooseUtils::prettyCppType<T>(),
1455  "' but it has already been defined or requested with return type '",
1456  existing_wrapper_base->returnType(),
1457  "'.");
1458  }
1459  }
1460 
1461  // We are a new functor, create the opposite ADType one and store it with other functors
1462  if constexpr (added_functor_is_ad)
1463  {
1464  typedef typename MetaPhysicL::RawType<T>::value_type NonADType;
1465  auto new_non_ad_wrapper = std::make_unique<Moose::Functor<NonADType>>(
1466  std::make_unique<Moose::RawValueFunctor<NonADType>>(functor));
1467  auto new_ad_wrapper = std::make_unique<Moose::Functor<T>>(functor);
1468  _functors[tid].emplace("wraps_" + name,
1469  std::make_tuple(SubProblem::TrueFunctorIs::AD,
1470  std::move(new_non_ad_wrapper),
1471  std::move(new_ad_wrapper)));
1472  }
1473  else
1474  {
1475  typedef typename Moose::ADType<T>::type ADType;
1476  auto new_non_ad_wrapper = std::make_unique<Moose::Functor<T>>((functor));
1477  auto new_ad_wrapper = std::make_unique<Moose::Functor<ADType>>(
1478  std::make_unique<Moose::ADWrapperFunctor<ADType>>(functor));
1479  _functors[tid].emplace("wraps_" + name,
1480  std::make_tuple(SubProblem::TrueFunctorIs::NONAD,
1481  std::move(new_non_ad_wrapper),
1482  std::move(new_ad_wrapper)));
1483  }
1484 }
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
Definition: MooseUtils.h:1133
This is a wrapper that forwards calls to the implementation, which can be switched out at any time wi...
Wraps non-AD functors such that they can be used in objects that have requested the functor as AD...
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::vector< std::multimap< std::string, std::pair< bool, bool > > > _functor_to_request_info
A multimap (for each thread) from unfilled functor requests to whether the requests were for AD funct...
Definition: SubProblem.h:1161
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
std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > > _functors
A container holding pointers to all the functors in our problem.
Definition: SubProblem.h:1144
A functor that serves as a placeholder during the simulation setup phase if a functor consumer reques...

◆ addFunctorMaterial()

void MFEMProblem::addFunctorMaterial ( const std::string &  material_name,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Reimplemented from FEProblemBase.

Definition at line 138 of file MFEMProblem.C.

141 {
143  getUserObject<MFEMFunctorMaterial>(name);
144 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)

◆ addFVBC()

void FEProblemBase::addFVBC ( const std::string &  fv_bc_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3451 of file FEProblemBase.C.

Referenced by DiffusionFV::addFVBCs().

3454 {
3455  addObject<FVBoundaryCondition>(fv_bc_name, name, parameters);
3456 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ addFVInitialCondition()

void FEProblemBase::addFVInitialCondition ( const std::string &  ic_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Add an initial condition for a finite volume variables.

Parameters
ic_nameThe name of the boundary condition object
nameThe user-defined name from the input file
parametersThe input parameters for construction

Definition at line 3620 of file FEProblemBase.C.

3623 {
3624  parallel_object_only();
3625 
3626  // before we start to mess with the initial condition, we need to check parameters for errors.
3628  const std::string & var_name = parameters.get<VariableName>("variable");
3629 
3630  // Forbid initial conditions on a restarted problem, as they would override the restart
3631  checkICRestartError(ic_name, name, var_name);
3632 
3633  parameters.set<SubProblem *>("_subproblem") = this;
3634 
3635  // field IC
3636  if (hasVariable(var_name))
3637  {
3638  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
3639  {
3640  auto & var = getVariable(
3642  parameters.set<SystemBase *>("_sys") = &var.sys();
3643  std::shared_ptr<FVInitialConditionBase> ic;
3644  if (var.isFV())
3645  ic = _factory.create<FVInitialCondition>(ic_name, name, parameters, tid);
3646  else
3647  mooseError(
3648  "Your variable for an FVInitialCondition needs to be an a finite volume variable!");
3649  _fv_ics.addObject(ic, tid);
3650  }
3651  }
3652  else
3653  mooseError("Variable '",
3654  var_name,
3655  "' requested in finite volume initial condition '",
3656  name,
3657  "' does not exist.");
3658 }
virtual bool hasVariable(const std::string &var_name) const override
Whether or not this problem has the variable.
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
unsigned int n_threads()
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Base class for a system (of equations)
Definition: SystemBase.h:84
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...
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::unique_ptr< Base > create()=0
void checkParams(const std::string &parsing_syntax)
This function checks parameters stored in the object to make sure they are in the correct state as th...
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
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...
void addObject(std::shared_ptr< FVInitialConditionBase > object, THREAD_ID tid, bool recurse=true)
Add object to the warehouse.
FVInitialConditionWarehouse _fv_ics
This is a template class that implements the workhorse compute and computeNodal methods.
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ addFVInterfaceKernel()

void FEProblemBase::addFVInterfaceKernel ( const std::string &  fv_ik_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

We assume that variable1 and variable2 can live on different systems, in this case the user needs to create two interface kernels with flipped variables and parameters

Definition at line 3459 of file FEProblemBase.C.

3462 {
3465  addObject<FVInterfaceKernel>(
3466  fv_ik_name, name, parameters, /*threaded=*/true, /*variable_param_name=*/"variable1");
3467 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ addFVKernel()

void FEProblemBase::addFVKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3437 of file FEProblemBase.C.

Referenced by DiffusionFV::addFVKernels().

3440 {
3441  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3442  // FVElementalKernels are computed in the historically finite element threaded loops. They rely
3443  // on Assembly data like _current_elem. When we call reinit on the FEProblemBase we will only
3444  // reinit the DisplacedProblem and its associated Assembly objects if we mark this boolean as
3445  // true
3446  _reinit_displaced_elem = true;
3447  addObject<FVKernel>(fv_kernel_name, name, parameters);
3448 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addGhostedBoundary()

void FEProblemBase::addGhostedBoundary ( BoundaryID  boundary_id)
overridevirtualinherited

Will make sure that all necessary elements from boundary_id are ghosted to this processor.

Implements SubProblem.

Definition at line 2125 of file FEProblemBase.C.

Referenced by DisplacedProblem::addGhostedBoundary().

2126 {
2127  _mesh.addGhostedBoundary(boundary_id);
2128  if (_displaced_problem)
2129  _displaced_mesh->addGhostedBoundary(boundary_id);
2130 }
MooseMesh & _mesh
std::shared_ptr< DisplacedProblem > _displaced_problem
void addGhostedBoundary(BoundaryID boundary_id)
This will add the boundary ids to be ghosted to this processor.
Definition: MooseMesh.C:3269
MooseMesh * _displaced_mesh

◆ addGhostedElem()

void FEProblemBase::addGhostedElem ( dof_id_type  elem_id)
overridevirtualinherited

Will make sure that all dofs connected to elem_id are ghosted to this processor.

Implements SubProblem.

Definition at line 2118 of file FEProblemBase.C.

Referenced by DisplacedProblem::addGhostedElem(), and NodalPatchRecovery::NodalPatchRecovery().

2119 {
2120  if (_mesh.elemPtr(elem_id)->processor_id() != processor_id())
2121  _ghosted_elems.insert(elem_id);
2122 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
Definition: SubProblem.h:1093
MooseMesh & _mesh
processor_id_type processor_id() const
processor_id_type processor_id() const

◆ addGridFunction()

void MFEMProblem::addGridFunction ( const std::string &  var_type,
const std::string &  var_name,
InputParameters parameters 
)

Adds one MFEM GridFunction to be used in the MFEM solve.

Definition at line 173 of file MFEMProblem.C.

Referenced by addAuxVariable(), and addVariable().

176 {
177  if (var_type == "MFEMVariable")
178  {
179  // Add MFEM variable directly.
180  FEProblemBase::addUserObject(var_type, var_name, parameters);
181  }
182  else
183  {
184  // Add MOOSE variable.
185  FEProblemBase::addVariable(var_type, var_name, parameters);
186 
187  // Add MFEM variable indirectly ("gridfunction").
189  FEProblemBase::addUserObject("MFEMVariable", var_name, mfem_variable_params);
190  }
191 
192  // Register gridfunction.
193  MFEMVariable & mfem_variable = getUserObject<MFEMVariable>(var_name);
194  getProblemData().gridfunctions.Register(var_name, mfem_variable.getGridFunction());
195  if (mfem_variable.getFESpace().isScalar())
196  getCoefficients().declareScalar<mfem::GridFunctionCoefficient>(
197  var_name, mfem_variable.getGridFunction().get());
198  else
199  getCoefficients().declareVector<mfem::VectorGridFunctionCoefficient>(
200  var_name, mfem_variable.getGridFunction().get());
201 }
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
InputParameters addMFEMFESpaceFromMOOSEVariable(InputParameters &moosevar_params)
Method used to get an mfem FEC depending on the variable family specified in the input file...
Definition: MFEMProblem.C:376
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Constructs and stores an mfem::ParGridFunction object.
Definition: MFEMVariable.h:20
virtual bool isScalar() const =0
mfem::Coefficient & declareScalar(const std::string &name, const std::string &existing_or_literal)
Declare an alias to an existing scalar coefficient or, if it does not exist, try interpreting the nam...
mfem::VectorCoefficient & declareVector(const std::string &name, const std::string &existing_or_literal)
Declare an alias to an existing vector coefficientor or, if it does not exist, try interpreting the n...
Moose::MFEM::CoefficientManager & getCoefficients()
Method to get the PropertyManager object for storing material properties and converting them to MFEM ...
Definition: MFEMProblem.h:180
const MFEMFESpace & getFESpace() const
Returns a reference to the fespace used by the gridfunction.
Definition: MFEMVariable.h:31
std::shared_ptr< mfem::ParGridFunction > getGridFunction() const
Returns a shared pointer to the constructed gridfunction.
Definition: MFEMVariable.h:28
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters &params)
Canonical method for adding a non-linear variable.
void Register(const std::string &field_name, FieldArgs &&... args)
Construct new field with name field_name and register.
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
Moose::MFEM::GridFunctions gridfunctions

◆ addHDGKernel()

void FEProblemBase::addHDGKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 2993 of file FEProblemBase.C.

2996 {
2997  parallel_object_only();
2998  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
2999  if (!isSolverSystemNonlinear(nl_sys_num))
3000  mooseError("You are trying to add a HDGKernel to a linear variable/system, which is not "
3001  "supported at the moment!");
3003  kernel_name, name, parameters, nl_sys_num, "HDGKernel", _reinit_displaced_elem);
3004 
3005  _nl[nl_sys_num]->addHDGKernel(kernel_name, name, parameters);
3006 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
void setResidualObjectParamsAndLog(const std::string &ro_name, const std::string &name, InputParameters &params, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
Set the subproblem and system parameters for residual objects and log their addition.
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
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.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
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

◆ addIndicator()

void FEProblemBase::addIndicator ( const std::string &  indicator_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 5321 of file FEProblemBase.C.

5324 {
5325  parallel_object_only();
5326 
5327  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
5328  {
5329  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
5330  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
5331  _reinit_displaced_elem = true;
5332  }
5333  else
5334  {
5335  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
5336  {
5337  // We allow Indicators to request that they use_displaced_mesh,
5338  // but then be overridden when no displacements variables are
5339  // provided in the Mesh block. If that happened, update the value
5340  // of use_displaced_mesh appropriately for this Indicator.
5341  if (parameters.have_parameter<bool>("use_displaced_mesh"))
5342  parameters.set<bool>("use_displaced_mesh") = false;
5343  }
5344 
5345  parameters.set<SubProblem *>("_subproblem") = this;
5346  parameters.set<SystemBase *>("_sys") = _aux.get();
5347  }
5348 
5349  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
5350  {
5351  std::shared_ptr<Indicator> indicator =
5352  _factory.create<Indicator>(indicator_name, name, parameters, tid);
5353  logAdd("Indicator", name, indicator_name, parameters);
5354  std::shared_ptr<InternalSideIndicatorBase> isi =
5356  if (isi)
5358  else
5359  _indicators.addObject(indicator, tid);
5360  }
5361 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
unsigned int n_threads()
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
Base class for a system (of equations)
Definition: SystemBase.h:84
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::unique_ptr< Base > create()=0
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseObjectWarehouse< Indicator > _indicators
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ addInitialCondition()

void MFEMProblem::addInitialCondition ( const std::string &  ic_name,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Reimplemented from FEProblemBase.

Definition at line 508 of file MFEMProblem.C.

511 {
513  getUserObject<MFEMInitialCondition>(name); // error check
514 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)

◆ addInterfaceKernel()

void FEProblemBase::addInterfaceKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3488 of file FEProblemBase.C.

3491 {
3492  parallel_object_only();
3493 
3494  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3495  if (!isSolverSystemNonlinear(nl_sys_num))
3496  mooseError("You are trying to add a InterfaceKernel to a linear variable/system, which is not "
3497  "supported at the moment!");
3498 
3499  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3500  {
3501  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3502  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3504  }
3505  else
3506  {
3507  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3508  {
3509  // We allow InterfaceKernels to request that they use_displaced_mesh,
3510  // but then be overridden when no displacements variables are
3511  // provided in the Mesh block. If that happened, update the value
3512  // of use_displaced_mesh appropriately for this InterfaceKernel.
3513  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3514  parameters.set<bool>("use_displaced_mesh") = false;
3515  }
3516 
3517  parameters.set<SubProblem *>("_subproblem") = this;
3518  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3519  }
3520 
3521  logAdd("InterfaceKernel", name, interface_kernel_name, parameters);
3522  _nl[nl_sys_num]->addInterfaceKernel(interface_kernel_name, name, parameters);
3523 
3525 }
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
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.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
std::shared_ptr< DisplacedProblem > _displaced_problem
bool _has_internal_edge_residual_objects
Whether the problem has dgkernels or interface kernels.

◆ addInterfaceMaterial()

void FEProblemBase::addInterfaceMaterial ( const std::string &  material_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3984 of file FEProblemBase.C.

3987 {
3989 }
virtual void addMaterialHelper(std::vector< MaterialWarehouse *> warehouse, const std::string &material_name, const std::string &name, InputParameters &parameters)
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
MaterialWarehouse _interface_materials
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ addJacobian()

void FEProblemBase::addJacobian ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 1962 of file FEProblemBase.C.

Referenced by ComputeDiracThread::postElement().

1963 {
1964  _assembly[tid][_current_nl_sys->number()]->addJacobian(Assembly::GlobalDataKey{});
1966  _assembly[tid][_current_nl_sys->number()]->addJacobianNonlocal(Assembly::GlobalDataKey{});
1967  if (_displaced_problem)
1968  {
1969  _displaced_problem->addJacobian(tid);
1971  _displaced_problem->addJacobianNonlocal(tid);
1972  }
1973 }
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addJacobianBlockTags()

void FEProblemBase::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 
)
virtualinherited

Definition at line 2037 of file FEProblemBase.C.

Referenced by ComputeJacobianBlocksThread::postElement().

2044 {
2045  _assembly[tid][_current_nl_sys->number()]->addJacobianBlockTags(
2046  jacobian, ivar, jvar, dof_map, dof_indices, Assembly::GlobalDataKey{}, tags);
2047 
2049  if (_nonlocal_cm[_current_nl_sys->number()](ivar, jvar) != 0)
2050  {
2051  MooseVariableFEBase & jv = _current_nl_sys->getVariable(tid, jvar);
2052  _assembly[tid][_current_nl_sys->number()]->addJacobianBlockNonlocalTags(
2053  jacobian,
2054  ivar,
2055  jvar,
2056  dof_map,
2057  dof_indices,
2058  jv.allDofIndices(),
2060  tags);
2061  }
2062 
2063  if (_displaced_problem)
2064  {
2065  _displaced_problem->addJacobianBlockTags(jacobian, ivar, jvar, dof_map, dof_indices, tags, tid);
2067  if (_nonlocal_cm[_current_nl_sys->number()](ivar, jvar) != 0)
2068  {
2069  MooseVariableFEBase & jv = _current_nl_sys->getVariable(tid, jvar);
2070  _displaced_problem->addJacobianBlockNonlocal(
2071  jacobian, ivar, jvar, dof_map, dof_indices, jv.allDofIndices(), tags, tid);
2072  }
2073  }
2074 }
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
This class provides an interface for common operations on field variables of both FE and FV types wit...
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
const std::vector< dof_id_type > & allDofIndices() const
Get all global dofindices for the variable.
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseVariableFieldBase & getVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a variable of with specified name.
Definition: SystemBase.C:90
std::vector< libMesh::CouplingMatrix > _nonlocal_cm
nonlocal coupling matrix
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addJacobianLowerD()

void FEProblemBase::addJacobianLowerD ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 1992 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulateLower(), and ComputeJacobianThread::accumulateLower().

1993 {
1994  _assembly[tid][_current_nl_sys->number()]->addJacobianLowerD(Assembly::GlobalDataKey{});
1995  if (_displaced_problem)
1996  _displaced_problem->addJacobianLowerD(tid);
1997 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addJacobianNeighbor() [1/3]

virtual void SubProblem::addJacobianNeighbor ( libMesh::SparseMatrix< libMesh::Number > &  jacobian,
unsigned int  ivar,
unsigned int  jvar,
const libMesh::DofMap dof_map,
std::vector< dof_id_type > &  dof_indices,
std::vector< dof_id_type > &  neighbor_dof_indices,
const std::set< TagID > &  tags,
const THREAD_ID  tid 
)
pure virtualinherited

Implemented in DisplacedProblem.

◆ addJacobianNeighbor() [2/3]

void FEProblemBase::addJacobianNeighbor ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 1976 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulateNeighbor(), ComputeJacobianThread::accumulateNeighbor(), and ComputeJacobianBlocksThread::postInternalSide().

1977 {
1978  _assembly[tid][_current_nl_sys->number()]->addJacobianNeighbor(Assembly::GlobalDataKey{});
1979  if (_displaced_problem)
1980  _displaced_problem->addJacobianNeighbor(tid);
1981 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addJacobianNeighbor() [3/3]

virtual void FEProblemBase::addJacobianNeighbor ( libMesh::SparseMatrix< libMesh::Number > &  jacobian,
unsigned int  ivar,
unsigned int  jvar,
const DofMap &  dof_map,
std::vector< dof_id_type > &  dof_indices,
std::vector< dof_id_type > &  neighbor_dof_indices,
const std::set< TagID > &  tags,
const THREAD_ID  tid 
)
overridevirtualinherited

◆ addJacobianNeighborLowerD()

void FEProblemBase::addJacobianNeighborLowerD ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 1984 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulateNeighborLower(), and ComputeJacobianThread::accumulateNeighborLower().

1985 {
1986  _assembly[tid][_current_nl_sys->number()]->addJacobianNeighborLowerD(Assembly::GlobalDataKey{});
1987  if (_displaced_problem)
1988  _displaced_problem->addJacobianNeighborLowerD(tid);
1989 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addJacobianOffDiagScalar()

void FEProblemBase::addJacobianOffDiagScalar ( unsigned int  ivar,
const THREAD_ID  tid = 0 
)
virtualinherited

Definition at line 2006 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

2007 {
2008  _assembly[tid][_current_nl_sys->number()]->addJacobianOffDiagScalar(ivar,
2010 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addJacobianScalar()

void FEProblemBase::addJacobianScalar ( const THREAD_ID  tid = 0)
virtualinherited

Definition at line 2000 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

2001 {
2002  _assembly[tid][_current_nl_sys->number()]->addJacobianScalar(Assembly::GlobalDataKey{});
2003 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addKernel()

void MFEMProblem::addKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Override of ExternalProblem::addKernel.

Uses ExternalProblem::addKernel to create a MFEMGeneralUserObject representing the kernel in MOOSE, and creates corresponding MFEM kernel to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 222 of file MFEMProblem.C.

225 {
227  const UserObject * kernel_uo = &(getUserObjectBase(name));
228 
229  if (dynamic_cast<const MFEMKernel *>(kernel_uo) != nullptr)
230  {
231  auto object_ptr = getUserObject<MFEMKernel>(name).getSharedPtr();
232  auto kernel = std::dynamic_pointer_cast<MFEMKernel>(object_ptr);
234  {
235  getProblemData().eqn_system->AddKernel(std::move(kernel));
236  }
237  else
238  {
239  mooseError("Cannot add kernel with name '" + name +
240  "' because there is no corresponding equation system.");
241  }
242  }
243  else
244  {
245  mooseError("Unsupported kernel of type '", kernel_name, "' and name '", name, "' detected.");
246  }
247 }
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
std::shared_ptr< MooseObject > getSharedPtr()
Get another shared pointer to this object that has the same ownership group.
Definition: MooseObject.C:68
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< Moose::MFEM::EquationSystem > eqn_system
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
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
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.
Class to construct an MFEM integrator to apply to the equation system.
Definition: MFEMKernel.h:21
Base class for user-specific data.
Definition: UserObject.h:40

◆ addKokkosBoundaryCondition()

virtual void FEProblemBase::addKokkosBoundaryCondition ( const std::string &  bc_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

◆ addKokkosKernel()

virtual void FEProblemBase::addKokkosKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

◆ addKokkosMaterial()

virtual void FEProblemBase::addKokkosMaterial ( const std::string &  material_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

◆ addKokkosNodalKernel()

virtual void FEProblemBase::addKokkosNodalKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

◆ addLinearFVBC()

void FEProblemBase::addLinearFVBC ( const std::string &  fv_bc_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3478 of file FEProblemBase.C.

3481 {
3482  addObject<LinearFVBoundaryCondition>(bc_name, name, parameters);
3483 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ addLinearFVKernel()

void FEProblemBase::addLinearFVKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3470 of file FEProblemBase.C.

3473 {
3474  addObject<LinearFVKernel>(kernel_name, name, parameters);
3475 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ addLineSearch()

virtual void FEProblemBase::addLineSearch ( const InputParameters )
inlinevirtualinherited

add a MOOSE line search

Reimplemented in DumpObjectsProblem, and FEProblem.

Definition at line 736 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

737  {
738  mooseError("Line search not implemented for this problem type yet.");
739  }
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

◆ addMarker()

void FEProblemBase::addMarker ( const std::string &  marker_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 5364 of file FEProblemBase.C.

5367 {
5368  parallel_object_only();
5369 
5370  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
5371  {
5372  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
5373  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
5374  _reinit_displaced_elem = true;
5375  }
5376  else
5377  {
5378  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
5379  {
5380  // We allow Markers to request that they use_displaced_mesh,
5381  // but then be overridden when no displacements variables are
5382  // provided in the Mesh block. If that happened, update the value
5383  // of use_displaced_mesh appropriately for this Marker.
5384  if (parameters.have_parameter<bool>("use_displaced_mesh"))
5385  parameters.set<bool>("use_displaced_mesh") = false;
5386  }
5387 
5388  parameters.set<SubProblem *>("_subproblem") = this;
5389  parameters.set<SystemBase *>("_sys") = _aux.get();
5390  }
5391 
5392  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
5393  {
5394  std::shared_ptr<Marker> marker = _factory.create<Marker>(marker_name, name, parameters, tid);
5395  logAdd("Marker", name, marker_name, parameters);
5396  _markers.addObject(marker, tid);
5397  }
5398 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
unsigned int n_threads()
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition: Marker.h:41
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::unique_ptr< Base > create()=0
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
MooseObjectWarehouse< Marker > _markers
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ addMaterial()

void MFEMProblem::addMaterial ( const std::string &  material_name,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Reimplemented from FEProblemBase.

Definition at line 131 of file MFEMProblem.C.

132 {
133  mooseError(
134  "MFEM materials must be added through the 'FunctorMaterials' block and not 'Materials'");
135 }
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

◆ addMaterialHelper()

void FEProblemBase::addMaterialHelper ( std::vector< MaterialWarehouse *>  warehouse,
const std::string &  material_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3992 of file FEProblemBase.C.

Referenced by FEProblemBase::addInterfaceMaterial(), and FEProblemBase::addMaterial().

3996 {
3997  parallel_object_only();
3998 
3999  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
4000  {
4001  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
4003  }
4004  else
4005  {
4006  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
4007  {
4008  // We allow Materials to request that they use_displaced_mesh,
4009  // but then be overridden when no displacements variables are
4010  // provided in the Mesh block. If that happened, update the value
4011  // of use_displaced_mesh appropriately for this Material.
4012  if (parameters.have_parameter<bool>("use_displaced_mesh"))
4013  parameters.set<bool>("use_displaced_mesh") = false;
4014  }
4015 
4016  parameters.set<SubProblem *>("_subproblem") = this;
4017  }
4018 
4019  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
4020  {
4021  // Create the general Block/Boundary MaterialBase object
4022  std::shared_ptr<MaterialBase> material =
4023  _factory.create<MaterialBase>(mat_name, name, parameters, tid);
4024  logAdd("Material", name, mat_name, parameters);
4025  bool discrete = !material->getParam<bool>("compute");
4026 
4027  // If the object is boundary restricted or if it is a functor material we do not create the
4028  // neighbor and face objects
4029  if (material->boundaryRestricted() || dynamic_cast<FunctorMaterial *>(material.get()))
4030  {
4031  _all_materials.addObject(material, tid);
4032  if (discrete)
4033  _discrete_materials.addObject(material, tid);
4034  else
4035  for (auto && warehouse : warehouses)
4036  warehouse->addObject(material, tid);
4037  }
4038 
4039  // Non-boundary restricted require face and neighbor objects
4040  else
4041  {
4042  // TODO: we only need to do this if we have needs for face materials (e.g.
4043  // FV, DG, etc.) - but currently we always do it. Figure out how to fix
4044  // this.
4045 
4046  // The name of the object being created, this is changed multiple times as objects are
4047  // created below
4048  std::string object_name;
4049 
4050  // Create a copy of the supplied parameters to the setting for "_material_data_type" isn't
4051  // used from a previous tid loop
4052  InputParameters current_parameters = parameters;
4053 
4054  // face material
4055  current_parameters.set<Moose::MaterialDataType>("_material_data_type") =
4057  object_name = name + "_face";
4058  std::shared_ptr<MaterialBase> face_material =
4059  _factory.create<MaterialBase>(mat_name, object_name, current_parameters, tid);
4060 
4061  // neighbor material
4062  current_parameters.set<Moose::MaterialDataType>("_material_data_type") =
4064  current_parameters.set<bool>("_neighbor") = true;
4065  object_name = name + "_neighbor";
4066  std::shared_ptr<MaterialBase> neighbor_material =
4067  _factory.create<MaterialBase>(mat_name, object_name, current_parameters, tid);
4068 
4069  // Store the material objects
4070  _all_materials.addObjects(material, neighbor_material, face_material, tid);
4071 
4072  if (discrete)
4073  _discrete_materials.addObjects(material, neighbor_material, face_material, tid);
4074  else
4075  for (auto && warehouse : warehouses)
4076  warehouse->addObjects(material, neighbor_material, face_material, tid);
4077 
4078  // Names of all controllable parameters for this Material object
4079  const std::string & base = parameters.getBase();
4080  MooseObjectParameterName name(MooseObjectName(base, material->name()), "*");
4081  const auto param_names =
4083 
4084  // Connect parameters of the primary Material object to those on the face and neighbor
4085  // objects
4086  for (const auto & p_name : param_names)
4087  {
4088  MooseObjectParameterName primary_name(MooseObjectName(base, material->name()),
4089  p_name.parameter());
4090  MooseObjectParameterName face_name(MooseObjectName(base, face_material->name()),
4091  p_name.parameter());
4092  MooseObjectParameterName neighbor_name(MooseObjectName(base, neighbor_material->name()),
4093  p_name.parameter());
4095  primary_name, face_name, false);
4097  primary_name, neighbor_name, false);
4098  }
4099  }
4100  }
4101 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
void addControllableParameterConnection(const MooseObjectParameterName &primary, const MooseObjectParameterName &secondary, bool error_on_empty=true)
Method for linking control parameters of different names.
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
unsigned int n_threads()
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition: MooseApp.C:2938
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
MaterialDataType
MaterialData types.
Definition: MooseTypes.h:692
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void logAdd(const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const
Output information about the object just added to the problem.
const std::string & getBase() const
std::vector< MooseObjectParameterName > getControllableParameterNames(const MooseObjectParameterName &input) const
Return a vector of parameters names matching the supplied name.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
FunctorMaterials compute functor material properties.
virtual std::unique_ptr< Base > create()=0
void addObjects(std::shared_ptr< MaterialBase > block, std::shared_ptr< MaterialBase > neighbor, std::shared_ptr< MaterialBase > face, THREAD_ID tid=0)
A special method unique to this class for adding Block, Neighbor, and Face material objects...
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
MaterialWarehouse _discrete_materials
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
std::shared_ptr< DisplacedProblem > _displaced_problem
A class for storing an input parameter name.
A class for storing the names of MooseObject by tag and object name.
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
MaterialBases compute MaterialProperties.
Definition: MaterialBase.h:62
MaterialWarehouse _all_materials
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ addMatrixTag()

TagID SubProblem::addMatrixTag ( TagName  tag_name)
virtualinherited

Create a Tag.

Tags can be associated with Vectors and Matrices and allow objects (such as Kernels) to arbitrarily contribute values to any set of vectors/matrics

Note: If the tag is already present then this will simply return the TagID of that Tag

Parameters
tag_nameThe name of the tag to create, the TagID will get automatically generated

Reimplemented in DisplacedProblem.

Definition at line 311 of file SubProblem.C.

Referenced by DisplacedProblem::addMatrixTag(), FEProblemBase::createTagMatrices(), LinearSystem::LinearSystem(), and NonlinearSystemBase::NonlinearSystemBase().

312 {
313  auto tag_name_upper = MooseUtils::toUpper(tag_name);
314  auto existing_tag = _matrix_tag_name_to_tag_id.find(tag_name_upper);
315  if (existing_tag == _matrix_tag_name_to_tag_id.end())
316  {
317  auto tag_id = _matrix_tag_name_to_tag_id.size();
318 
319  _matrix_tag_name_to_tag_id[tag_name_upper] = tag_id;
320 
321  _matrix_tag_id_to_tag_name[tag_id] = tag_name_upper;
322  }
323 
324  return _matrix_tag_name_to_tag_id.at(tag_name_upper);
325 }
std::map< TagName, TagID > _matrix_tag_name_to_tag_id
The currently declared tags.
Definition: SubProblem.h:1041
std::string toUpper(std::string name)
Convert supplied string to upper case.
std::map< TagID, TagName > _matrix_tag_id_to_tag_name
Reverse map.
Definition: SubProblem.h:1044

◆ addMeshDivision()

void FEProblemBase::addMeshDivision ( const std::string &  type,
const std::string &  name,
InputParameters params 
)
virtualinherited

Add a MeshDivision.

Definition at line 2675 of file FEProblemBase.C.

2678 {
2679  parallel_object_only();
2680  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
2681  parameters.set<SubProblem *>("_subproblem") = this;
2682  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
2683  {
2684  std::shared_ptr<MeshDivision> func = _factory.create<MeshDivision>(type, name, parameters, tid);
2685  _mesh_divisions.addObject(func, tid);
2686  }
2687 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
unsigned int n_threads()
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Base class for MeshDivision objects.
Definition: MeshDivision.h:35
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::unique_ptr< Base > create()=0
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MooseObjectWarehouse< MeshDivision > _mesh_divisions
Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the ...
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ addMFEMFESpaceFromMOOSEVariable()

InputParameters MFEMProblem::addMFEMFESpaceFromMOOSEVariable ( InputParameters moosevar_params)

Method used to get an mfem FEC depending on the variable family specified in the input file.

This method is used in addAuxVariable to help create the MFEM grid function that corresponds to a given MOOSE aux-variable.

Definition at line 376 of file MFEMProblem.C.

Referenced by addGridFunction().

377 {
378 
379  InputParameters fespace_params = _factory.getValidParams("MFEMGenericFESpace");
380  InputParameters mfem_variable_params = _factory.getValidParams("MFEMVariable");
381 
382  auto moose_fe_type =
383  FEType(Utility::string_to_enum<Order>(parameters.get<MooseEnum>("order")),
384  Utility::string_to_enum<FEFamily>(parameters.get<MooseEnum>("family")));
385 
386  std::string mfem_family;
387  int mfem_vdim = 1;
388 
389  switch (moose_fe_type.family)
390  {
391  case FEFamily::LAGRANGE:
392  mfem_family = "H1";
393  mfem_vdim = 1;
394  break;
395  case FEFamily::LAGRANGE_VEC:
396  mfem_family = "H1";
397  mfem_vdim = 3;
398  break;
399  case FEFamily::MONOMIAL:
400  mfem_family = "L2";
401  mfem_vdim = 1;
402  break;
403  case FEFamily::MONOMIAL_VEC:
404  mfem_family = "L2";
405  mfem_vdim = 3;
406  break;
407  default:
408  mooseError("Unable to set MFEM FESpace for MOOSE variable");
409  break;
410  }
411 
412  // Create fespace name. If this already exists, we will reuse this for
413  // the mfem variable ("gridfunction").
414  const std::string fespace_name = mfem_family + "_" +
415  std::to_string(mesh().getMFEMParMesh().Dimension()) + "D_P" +
416  std::to_string(moose_fe_type.order.get_order());
417 
418  // Set all fespace parameters.
419  fespace_params.set<std::string>("fec_name") = fespace_name;
420  fespace_params.set<int>("vdim") = mfem_vdim;
421 
422  if (!hasUserObject(fespace_name)) // Create the fespace (implicit).
423  {
424  addFESpace("MFEMGenericFESpace", fespace_name, fespace_params);
425  }
426 
427  mfem_variable_params.set<UserObjectName>("fespace") = fespace_name;
428 
429  return mfem_variable_params;
430 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
virtual MFEMMesh & mesh() override
Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMes...
Definition: MFEMProblem.C:465
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition: Factory.C:68
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
bool hasUserObject(const std::string &name) const
Check if there if a user object of given name.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
void addFESpace(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
Add an MFEM FESpace to the problem.
Definition: MFEMProblem.C:147
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

◆ addMFEMNonlinearSolver()

void MFEMProblem::addMFEMNonlinearSolver ( )

Add the nonlinear solver to the system.

TODO: allow user to specify solver options, similar to the linear solvers.

Definition at line 77 of file MFEMProblem.C.

Referenced by initialSetup().

78 {
79  auto nl_solver = std::make_shared<mfem::NewtonSolver>(getProblemData().comm);
80 
81  // Defaults to one iteration, without further nonlinear iterations
82  nl_solver->SetRelTol(0.0);
83  nl_solver->SetAbsTol(0.0);
84  nl_solver->SetMaxIter(1);
85 
86  getProblemData().nonlinear_solver = nl_solver;
87 }
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
std::shared_ptr< mfem::NewtonSolver > nonlinear_solver

◆ addMFEMPreconditioner()

void MFEMProblem::addMFEMPreconditioner ( const std::string &  user_object_name,
const std::string &  name,
InputParameters parameters 
)

Method called in AddMFEMPreconditionerAction which will create the solver.

Definition at line 58 of file MFEMProblem.C.

Referenced by AddMFEMPreconditionerAction::act().

61 {
62  FEProblemBase::addUserObject(user_object_name, name, parameters);
63 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)

◆ addMFEMSolver()

void MFEMProblem::addMFEMSolver ( const std::string &  user_object_name,
const std::string &  name,
InputParameters parameters 
)

Method called in AddMFEMSolverAction which will create the solver.

Definition at line 66 of file MFEMProblem.C.

Referenced by AddMFEMSolverAction::act().

69 {
70  FEProblemBase::addUserObject(user_object_name, name, parameters);
71  auto object_ptr = getUserObject<MFEMSolverBase>(name).getSharedPtr();
72 
74 }
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
std::shared_ptr< MooseObject > getSharedPtr()
Get another shared pointer to this object that has the same ownership group.
Definition: MooseObject.C:68
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
Base class for wrapping mfem::Solver-derived classes.
std::shared_ptr< MFEMSolverBase > jacobian_solver

◆ addMultiApp()

void FEProblemBase::addMultiApp ( const std::string &  multi_app_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Add a MultiApp to the problem.

Definition at line 5401 of file FEProblemBase.C.

5404 {
5405  parallel_object_only();
5406 
5407  parameters.set<MPI_Comm>("_mpi_comm") = _communicator.get();
5408 
5409  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
5410  {
5411  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
5412  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
5413  _reinit_displaced_elem = true;
5414  }
5415  else
5416  {
5417  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
5418  {
5419  // We allow MultiApps to request that they use_displaced_mesh,
5420  // but then be overridden when no displacements variables are
5421  // provided in the Mesh block. If that happened, update the value
5422  // of use_displaced_mesh appropriately for this MultiApp.
5423  if (parameters.have_parameter<bool>("use_displaced_mesh"))
5424  parameters.set<bool>("use_displaced_mesh") = false;
5425  }
5426 
5427  parameters.set<SubProblem *>("_subproblem") = this;
5428  parameters.set<SystemBase *>("_sys") = _aux.get();
5429  }
5430 
5431  std::shared_ptr<MultiApp> multi_app = _factory.create<MultiApp>(multi_app_name, name, parameters);
5432  logAdd("MultiApp", name, multi_app_name, parameters);
5433  multi_app->setupPositions();
5434 
5435  _multi_apps.addObject(multi_app);
5436 
5437  // Store TransientMultiApp objects in another container, this is needed for calling computeDT
5438  std::shared_ptr<TransientMultiApp> trans_multi_app =
5440  if (trans_multi_app)
5441  _transient_multi_apps.addObject(trans_multi_app);
5442 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
MultiApp Implementation for Transient Apps.
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
const Parallel::Communicator & _communicator
ExecuteMooseObjectWarehouse< TransientMultiApp > _transient_multi_apps
Storage for TransientMultiApps (only needed for calling &#39;computeDT&#39;)
Base class for a system (of equations)
Definition: SystemBase.h:84
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::unique_ptr< Base > create()=0
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
std::shared_ptr< DisplacedProblem > _displaced_problem
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:112

◆ addNodalKernel()

void FEProblemBase::addNodalKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3009 of file FEProblemBase.C.

3012 {
3013  parallel_object_only();
3014 
3015  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3016  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3017  {
3018  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3019  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3020  _reinit_displaced_elem = true;
3021  }
3022  else
3023  {
3024  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3025  {
3026  // We allow NodalKernels to request that they use_displaced_mesh,
3027  // but then be overridden when no displacements variables are
3028  // provided in the Mesh block. If that happened, update the value
3029  // of use_displaced_mesh appropriately for this NodalKernel.
3030  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3031  parameters.set<bool>("use_displaced_mesh") = false;
3032  }
3033 
3034  parameters.set<SubProblem *>("_subproblem") = this;
3035  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3036  }
3037  logAdd("NodalKernel", name, kernel_name, parameters);
3038  _nl[nl_sys_num]->addNodalKernel(kernel_name, name, parameters);
3039 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
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.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addNotZeroedVectorTag()

void SubProblem::addNotZeroedVectorTag ( const TagID  tag)
inherited

Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are.

Parameters
tagthe TagID of the vector that will be manually managed

Definition at line 149 of file SubProblem.C.

Referenced by FEProblemBase::createTagVectors().

150 {
151  _not_zeroed_tagged_vectors.insert(tag);
152 }
std::unordered_set< TagID > _not_zeroed_tagged_vectors
the list of vector tags that will not be zeroed when all other tags are
Definition: SubProblem.h:1117

◆ addObject()

template<typename T >
std::vector< std::shared_ptr< T > > FEProblemBase::addObject ( const std::string &  type,
const std::string &  name,
InputParameters parameters,
const bool  threaded = true,
const std::string &  var_param_name = "variable" 
)
inherited

Method for creating and adding an object to the warehouse.

Template Parameters
TThe base object type (registered in the Factory)
Parameters
typeString type of the object (registered in the Factory)
nameName for the object to be created
parametersInputParameters for the object
threadedWhether or not to create n_threads copies of the object
var_param_nameThe name of the parameter on the object which holds the primary variable.
Returns
A vector of shared_ptrs to the added objects

Definition at line 3329 of file FEProblemBase.h.

3334 {
3335  parallel_object_only();
3336 
3337  logAdd(MooseUtils::prettyCppType<T>(), name, type, parameters);
3338  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
3339  addObjectParamsHelper(parameters, name, var_param_name);
3340 
3341  const auto n_threads = threaded ? libMesh::n_threads() : 1;
3342  std::vector<std::shared_ptr<T>> objects(n_threads);
3343  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
3344  {
3345  std::shared_ptr<T> obj = _factory.create<T>(type, name, parameters, tid);
3346  theWarehouse().add(obj);
3347  objects[tid] = std::move(obj);
3348  }
3349 
3350  return objects;
3351 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
unsigned int n_threads()
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
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
std::shared_ptr< MooseObject > create(const std::string &obj_name, const std::string &name, const InputParameters &parameters, THREAD_ID tid=0, bool print_deprecated=true)
Definition: Factory.C:111
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.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
TheWarehouse & theWarehouse() const
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
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().
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ addObjectParamsHelper()

void FEProblemBase::addObjectParamsHelper ( InputParameters params,
const std::string &  object_name,
const std::string &  var_param_name = "variable" 
)
protectedinherited

Helper for setting the "_subproblem" and "_sys" parameters in addObject() and in addUserObject().

This is needed due to header includes/forward declaration issues

Definition at line 4334 of file FEProblemBase.C.

Referenced by FEProblemBase::addObject(), and FEProblemBase::addUserObject().

4337 {
4338  // Due to objects like SolutionUserObject which manipulate libmesh objects
4339  // and variables directly at the back end, we need a default option here
4340  // which is going to be the pointer to the first solver system within this
4341  // problem
4342  unsigned int sys_num = 0;
4343  if (parameters.isParamValid(var_param_name))
4344  {
4345  const auto variable_name = parameters.varName(var_param_name, object_name);
4346  if (this->hasVariable(variable_name) || this->hasScalarVariable(variable_name))
4347  sys_num = getSystem(variable_name).number();
4348  }
4349  if (parameters.isParamValid("solver_sys"))
4350  {
4351  const auto var_sys_num = sys_num;
4352  sys_num = getSystemBase(parameters.get<SolverSystemName>("solver_sys")).number();
4353  if (sys_num != var_sys_num && parameters.isParamValid(var_param_name))
4354  mooseError("We dont support setting 'variable' to a variable that is not set to the same "
4355  "system as the 'solver_sys' parameter");
4356  }
4357 
4358  if (_displaced_problem && parameters.have_parameter<bool>("use_displaced_mesh") &&
4359  parameters.get<bool>("use_displaced_mesh"))
4360  {
4361  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
4362  if (sys_num == _aux->number())
4363  parameters.set<SystemBase *>("_sys") = &_displaced_problem->systemBaseAuxiliary();
4364  else
4365  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(sys_num);
4366  }
4367  else
4368  {
4369  // The object requested use_displaced_mesh, but it was overridden
4370  // due to there being no displacements variables in the [Mesh] block.
4371  // If that happened, update the value of use_displaced_mesh appropriately.
4372  if (!_displaced_problem && parameters.have_parameter<bool>("use_displaced_mesh") &&
4373  parameters.get<bool>("use_displaced_mesh"))
4374  parameters.set<bool>("use_displaced_mesh") = false;
4375 
4376  parameters.set<SubProblem *>("_subproblem") = this;
4377 
4378  if (sys_num == _aux->number())
4379  parameters.set<SystemBase *>("_sys") = _aux.get();
4380  else
4381  parameters.set<SystemBase *>("_sys") = _solver_systems[sys_num].get();
4382  }
4383 }
virtual bool hasVariable(const std::string &var_name) const override
Whether or not this problem has the variable.
virtual libMesh::System & getSystem(const std::string &var_name) override
Returns the equation system containing the variable provided.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
virtual bool hasScalarVariable(const std::string &var_name) const override
Returns a Boolean indicating whether any system contains a variable with the name provided...
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
Base class for a system (of equations)
Definition: SystemBase.h:84
unsigned int number() const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
virtual const SystemBase & getSystemBase(const unsigned int sys_num) const
Get constant reference to a system in this problem.
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
std::shared_ptr< DisplacedProblem > _displaced_problem
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ addOutput()

void FEProblemBase::addOutput ( const std::string &  object_type,
const std::string &  object_name,
InputParameters parameters 
)
inherited

Adds an Output object.

Definition at line 8980 of file FEProblemBase.C.

8983 {
8984  parallel_object_only();
8985 
8986  // Get a reference to the OutputWarehouse
8987  OutputWarehouse & output_warehouse = _app.getOutputWarehouse();
8988 
8989  // Reject the reserved names for objects not built by MOOSE
8990  if (!parameters.get<bool>("_built_by_moose") && output_warehouse.isReservedName(object_name))
8991  mooseError("The name '", object_name, "' is a reserved name for output objects");
8992 
8993  // Check that an object by the same name does not already exist; this must be done before the
8994  // object is created to avoid getting misleading errors from the Parser
8995  if (output_warehouse.hasOutput(object_name))
8996  mooseError("An output object named '", object_name, "' already exists");
8997 
8998  // Add a pointer to the FEProblemBase class
8999  parameters.addPrivateParam<FEProblemBase *>("_fe_problem_base", this);
9000 
9001  // Create common parameter exclude list
9002  std::vector<std::string> exclude;
9003  if (object_type == "Console")
9004  {
9005  exclude.push_back("execute_on");
9006 
9007  // --show-input should enable the display of the input file on the screen
9008  if (_app.getParam<bool>("show_input") && parameters.get<bool>("output_screen"))
9009  parameters.set<ExecFlagEnum>("execute_input_on") = EXEC_INITIAL;
9010  }
9011  // Need this because Checkpoint::validParams changes the default value of
9012  // execute_on
9013  else if (object_type == "Checkpoint")
9014  exclude.push_back("execute_on");
9015 
9016  // Apply the common parameters loaded with Outputs input syntax
9017  const InputParameters * common = output_warehouse.getCommonParameters();
9018  if (common)
9019  parameters.applyParameters(*common, exclude);
9020  if (common && std::find(exclude.begin(), exclude.end(), "execute_on") != exclude.end() &&
9021  common->isParamSetByUser("execute_on") && object_type != "Console")
9023  "'execute_on' parameter specified in [Outputs] block is ignored for object '" +
9024  object_name +
9025  "'.\nDefine this object in its own sub-block of [Outputs] to modify its "
9026  "execution schedule.");
9027 
9028  // Set the correct value for the binary flag for XDA/XDR output
9029  if (object_type == "XDR")
9030  parameters.set<bool>("_binary") = true;
9031  else if (object_type == "XDA")
9032  parameters.set<bool>("_binary") = false;
9033 
9034  // Adjust the checkpoint suffix if auto recovery was enabled
9035  if (object_name == "auto_recovery_checkpoint")
9036  parameters.set<std::string>("suffix") = "auto_recovery";
9037 
9038  // Create the object and add it to the warehouse
9039  std::shared_ptr<Output> output = _factory.create<Output>(object_type, object_name, parameters);
9040  logAdd("Output", object_name, object_type, parameters);
9041  output_warehouse.addOutput(output);
9042 }
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:30
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:21
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBase.h:388
void addPrivateParam(const std::string &name, const T &value)
These method add a parameter to the InputParameters object which can be retrieved like any other para...
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
bool isReservedName(const std::string &name)
Test if the given name is reserved.
bool hasOutput(const std::string &name) const
Returns true if the output object exists.
void mooseInfoRepeated(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
Definition: MooseError.h:398
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Method for applying common parameters.
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.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Based class for output objects.
Definition: Output.h:43
virtual std::unique_ptr< Base > create()=0
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
Class for storing and utilizing output objects.
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.
const InputParameters * getCommonParameters() const
Get a reference to the common output parameters.
void addOutput(std::shared_ptr< Output > output)
Adds an existing output object to the warehouse.
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
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:30

◆ addPiecewiseByBlockLambdaFunctor()

template<typename T , typename PolymorphicLambda >
const Moose::FunctorBase< T > & SubProblem::addPiecewiseByBlockLambdaFunctor ( const std::string &  name,
PolymorphicLambda  my_lammy,
const std::set< ExecFlagType > &  clearance_schedule,
const MooseMesh mesh,
const std::set< SubdomainID > &  block_ids,
const THREAD_ID  tid 
)
inherited

Add a functor that has block-wise lambda definitions, e.g.

the evaluations of the functor are based on a user-provided lambda expression.

Parameters
nameThe name of the functor to add
my_lammyThe lambda expression that will be called when the functor is evaluated
clearance_scheduleHow often to clear functor evaluations. The default value is always, which means that the functor will be re-evaluated every time it is called. If it is something other than always, than cached values may be returned
meshThe mesh on which this functor operates
block_idsThe blocks on which the lambda expression is defined
tidThe thread on which the functor we are adding will run
Returns
The added functor

Definition at line 1338 of file SubProblem.h.

Referenced by FunctorMaterial::addFunctorPropertyByBlocks().

1344 {
1345  auto & pbblf_functors = _pbblf_functors[tid];
1346 
1347  auto [it, first_time_added] =
1348  pbblf_functors.emplace(name,
1349  std::make_unique<PiecewiseByBlockLambdaFunctor<T>>(
1350  name, my_lammy, clearance_schedule, mesh, block_ids));
1351 
1352  auto * functor = dynamic_cast<PiecewiseByBlockLambdaFunctor<T> *>(it->second.get());
1353  if (!functor)
1354  {
1355  if (first_time_added)
1356  mooseError("This should be impossible. If this was the first time we added the functor, then "
1357  "the dynamic cast absolutely should have succeeded");
1358  else
1359  mooseError("Attempted to add a lambda functor with the name '",
1360  name,
1361  "' but another lambda functor of that name returns a different type");
1362  }
1363 
1364  if (first_time_added)
1365  addFunctor(name, *functor, tid);
1366  else
1367  // The functor already exists
1368  functor->setFunctor(mesh, block_ids, my_lammy);
1369 
1370  return *functor;
1371 }
virtual MooseMesh & mesh()=0
A material property that is evaluated on-the-fly via calls to various overloads of operator() ...
void addFunctor(const std::string &name, const Moose::FunctorBase< T > &functor, const THREAD_ID tid)
add a functor to the problem functor container
Definition: SubProblem.h:1375
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::vector< std::map< std::string, std::unique_ptr< Moose::FunctorAbstract > > > _pbblf_functors
Container to hold PiecewiseByBlockLambdaFunctors.
Definition: SubProblem.h:1147
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

◆ addPostprocessor()

void MFEMProblem::addPostprocessor ( const std::string &  type,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Override of ExternalProblem::addPostprocessor.

In addition to creating the postprocessor object, it will create a coefficient that will hold its value.

Reimplemented from FEProblemBase.

Definition at line 364 of file MFEMProblem.C.

367 {
368  // For some reason this isn't getting called
371  getCoefficients().declareScalar<mfem::FunctionCoefficient>(
372  name, [&val](const mfem::Vector &, double) -> mfem::real_t { return val; });
373 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
virtual void addPostprocessor(const std::string &pp_name, const std::string &name, InputParameters &parameters)
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
mfem::Coefficient & declareScalar(const std::string &name, const std::string &existing_or_literal)
Declare an alias to an existing scalar coefficient or, if it does not exist, try interpreting the nam...
Real PostprocessorValue
various MOOSE typedefs
Definition: MooseTypes.h:202
Moose::MFEM::CoefficientManager & getCoefficients()
Method to get the PropertyManager object for storing material properties and converting them to MFEM ...
Definition: MFEMProblem.h:180
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
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.

◆ addPredictor()

void FEProblemBase::addPredictor ( const std::string &  type,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 6953 of file FEProblemBase.C.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector().

6956 {
6957  parallel_object_only();
6958 
6960  mooseError("Vector bounds cannot be used with LinearSystems!");
6961 
6962  parameters.set<SubProblem *>("_subproblem") = this;
6963  std::shared_ptr<Predictor> predictor = _factory.create<Predictor>(type, name, parameters);
6964  logAdd("Predictor", name, type, parameters);
6965 
6966  for (auto & nl : _nl)
6967  nl->setPredictor(predictor);
6968 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
virtual std::size_t numNonlinearSystems() const override
Base class for predictors.
Definition: Predictor.h:28
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::unique_ptr< Base > create()=0
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
virtual std::size_t numLinearSystems() const override

◆ addReporter()

void FEProblemBase::addReporter ( const std::string &  type,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Add a Reporter object to the simulation.

Parameters
typeC++ object type to construct
nameA uniquely identifying object name
parametersComplete parameters for the object to be created.

For an example use, refer to AddReporterAction.C/h

Definition at line 4414 of file FEProblemBase.C.

Referenced by MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer().

4417 {
4418  // Check for name collision
4419  if (hasUserObject(name))
4420  mooseError("A ",
4422  " already exists. You may not add a Reporter by the same name.");
4423 
4425 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
bool hasUserObject(const std::string &name) const
Check if there if a user object of given name.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
std::string typeAndName() const
Get the class&#39;s combined type and name; useful in error handling.
Definition: MooseBase.C:57
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
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
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.

◆ addResidual()

void FEProblemBase::addResidual ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 1862 of file FEProblemBase.C.

Referenced by ComputeDiracThread::postElement().

1863 {
1864  _assembly[tid][_current_nl_sys->number()]->addResidual(Assembly::GlobalDataKey{},
1866 
1867  if (_displaced_problem)
1868  _displaced_problem->addResidual(tid);
1869 }
virtual const std::vector< VectorTag > & currentResidualVectorTags() const override
Return the residual vector tags we are currently computing.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addResidualLower()

void FEProblemBase::addResidualLower ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 1882 of file FEProblemBase.C.

Referenced by ComputeResidualThread::accumulateLower(), ComputeResidualAndJacobianThread::accumulateLower(), ComputeResidualThread::accumulateNeighborLower(), and ComputeResidualAndJacobianThread::accumulateNeighborLower().

1883 {
1884  _assembly[tid][_current_nl_sys->number()]->addResidualLower(Assembly::GlobalDataKey{},
1886 
1887  if (_displaced_problem)
1888  _displaced_problem->addResidualLower(tid);
1889 }
virtual const std::vector< VectorTag > & currentResidualVectorTags() const override
Return the residual vector tags we are currently computing.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addResidualNeighbor()

void FEProblemBase::addResidualNeighbor ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 1872 of file FEProblemBase.C.

Referenced by ComputeResidualThread::accumulateNeighbor(), ComputeResidualAndJacobianThread::accumulateNeighbor(), ComputeResidualThread::accumulateNeighborLower(), and ComputeResidualAndJacobianThread::accumulateNeighborLower().

1873 {
1874  _assembly[tid][_current_nl_sys->number()]->addResidualNeighbor(Assembly::GlobalDataKey{},
1876 
1877  if (_displaced_problem)
1878  _displaced_problem->addResidualNeighbor(tid);
1879 }
virtual const std::vector< VectorTag > & currentResidualVectorTags() const override
Return the residual vector tags we are currently computing.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addResidualScalar()

void FEProblemBase::addResidualScalar ( const THREAD_ID  tid = 0)
virtualinherited

Definition at line 1892 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeResidualInternal().

1893 {
1894  _assembly[tid][_current_nl_sys->number()]->addResidualScalar(Assembly::GlobalDataKey{},
1896 }
virtual const std::vector< VectorTag > & currentResidualVectorTags() const override
Return the residual vector tags we are currently computing.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ addSampler()

void FEProblemBase::addSampler ( const std::string &  type,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

The following functions will enable MOOSE to have the capability to import Samplers.

Definition at line 2743 of file FEProblemBase.C.

2746 {
2747  const auto samplers = addObject<Sampler>(type, name, parameters);
2748  for (auto & sampler : samplers)
2749  sampler->init();
2750 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

◆ addScalarKernel()

void FEProblemBase::addScalarKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 3042 of file FEProblemBase.C.

3045 {
3046  parallel_object_only();
3047 
3048  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3049  if (!isSolverSystemNonlinear(nl_sys_num))
3050  mooseError("You are trying to add a ScalarKernel to a linear variable/system, which is not "
3051  "supported at the moment!");
3052 
3053  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3054  {
3055  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3056  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3057  }
3058  else
3059  {
3060  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3061  {
3062  // We allow ScalarKernels to request that they use_displaced_mesh,
3063  // but then be overridden when no displacements variables are
3064  // provided in the Mesh block. If that happened, update the value
3065  // of use_displaced_mesh appropriately for this ScalarKernel.
3066  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3067  parameters.set<bool>("use_displaced_mesh") = false;
3068  }
3069 
3070  parameters.set<SubProblem *>("_subproblem") = this;
3071  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3072  }
3073 
3074  logAdd("ScalarKernel", name, kernel_name, parameters);
3075  _nl[nl_sys_num]->addScalarKernel(kernel_name, name, parameters);
3076 }
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
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.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
Base class for a system (of equations)
Definition: SystemBase.h:84
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string varName(const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
Determine the actual variable name from the given variable parameter name.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
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
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addSubMesh()

void MFEMProblem::addSubMesh ( const std::string &  user_object_name,
const std::string &  name,
InputParameters parameters 
)

Add an MFEM SubMesh to the problem.

Definition at line 479 of file MFEMProblem.C.

Referenced by AddMFEMSubMeshAction::act().

482 {
483  // Add MFEM SubMesh.
484  FEProblemBase::addUserObject(var_type, var_name, parameters);
485  // Register submesh.
486  MFEMSubMesh & mfem_submesh = getUserObject<MFEMSubMesh>(var_name);
487  getProblemData().submeshes.Register(var_name, mfem_submesh.getSubMesh());
488 }
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
Moose::MFEM::SubMeshes submeshes
Base class for construction of a mfem::ParSubMesh object.
Definition: MFEMSubMesh.h:22
std::shared_ptr< mfem::ParSubMesh > getSubMesh()
Returns a shared pointer to the constructed fespace.
Definition: MFEMSubMesh.h:30
void Register(const std::string &field_name, FieldArgs &&... args)
Construct new field with name field_name and register.
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)

◆ addTimeIntegrator()

void FEProblemBase::addTimeIntegrator ( const std::string &  type,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 6918 of file FEProblemBase.C.

Referenced by TransientBase::setupTimeIntegrator().

6921 {
6922  parallel_object_only();
6923 
6924  parameters.set<SubProblem *>("_subproblem") = this;
6925  logAdd("TimeIntegrator", name, type, parameters);
6926  _aux->addTimeIntegrator(type, name + ":aux", parameters);
6927  for (auto & sys : _solver_systems)
6928  sys->addTimeIntegrator(type, name + ":" + sys->name(), parameters);
6929  _has_time_integrator = true;
6930 
6931  // add vectors to store u_dot, u_dotdot, udot_old, u_dotdot_old and
6932  // solution vectors older than 2 time steps, if requested by the time
6933  // integrator
6934  _aux->addDotVectors();
6935  for (auto & nl : _nl)
6936  {
6937  nl->addDotVectors();
6938 
6939  auto tag_udot = nl->getTimeIntegrators()[0]->uDotFactorTag();
6940  if (!nl->hasVector(tag_udot))
6941  nl->associateVectorToTag(*nl->solutionUDot(), tag_udot);
6942  auto tag_udotdot = nl->getTimeIntegrators()[0]->uDotDotFactorTag();
6943  if (!nl->hasVector(tag_udotdot) && uDotDotRequested())
6944  nl->associateVectorToTag(*nl->solutionUDotDot(), tag_udotdot);
6945  }
6946 
6947  if (_displaced_problem)
6948  // Time integrator does not exist when displaced problem is created.
6949  _displaced_problem->addTimeIntegrator();
6950 }
virtual bool uDotDotRequested()
Get boolean flag to check whether solution second time derivative needs to be stored.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
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.
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
bool _has_time_integrator
Indicates whether or not this executioner has a time integrator (during setup)
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addTransfer()

void MFEMProblem::addTransfer ( const std::string &  transfer_name,
const std::string &  name,
InputParameters parameters 
)
overridevirtual

Add transfers between MultiApps and/or MFEM SubMeshes.

Reimplemented from FEProblemBase.

Definition at line 491 of file MFEMProblem.C.

494 {
495  if (parameters.getBase() == "MFEMSubMeshTransfer")
497  else
498  FEProblemBase::addTransfer(transfer_name, name, parameters);
499 }
virtual void addTransfer(const std::string &transfer_name, const std::string &name, InputParameters &parameters)
Add a Transfer to the problem.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
const std::string & getBase() const
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)

◆ addUserObject()

std::vector< std::shared_ptr< UserObject > > FEProblemBase::addUserObject ( const std::string &  user_object_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 4428 of file FEProblemBase.C.

Referenced by addAuxKernel(), addBoundaryCondition(), addFESpace(), addFunctorMaterial(), addGridFunction(), addInitialCondition(), addKernel(), addMFEMPreconditioner(), addMFEMSolver(), FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), addSubMesh(), addTransfer(), and FEProblemBase::addVectorPostprocessor().

4431 {
4432  parallel_object_only();
4433 
4434  std::vector<std::shared_ptr<UserObject>> uos;
4435 
4436  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
4438 
4439  for (const auto tid : make_range(libMesh::n_threads()))
4440  {
4441  // Create the UserObject
4442  std::shared_ptr<UserObject> user_object =
4443  _factory.create<UserObject>(user_object_name, name, parameters, tid);
4444  logAdd("UserObject", name, user_object_name, parameters);
4445  uos.push_back(user_object);
4446 
4447  if (tid != 0)
4448  user_object->setPrimaryThreadCopy(uos[0].get());
4449 
4450  // TODO: delete this line after apps have been updated to not call getUserObjects
4451  _all_user_objects.addObject(user_object, tid);
4452 
4453  theWarehouse().add(user_object);
4454 
4455  // Attempt to create all the possible UserObject types
4456  auto euo = std::dynamic_pointer_cast<ElementUserObject>(user_object);
4457  auto suo = std::dynamic_pointer_cast<SideUserObject>(user_object);
4458  auto isuo = std::dynamic_pointer_cast<InternalSideUserObject>(user_object);
4459  auto iuo = std::dynamic_pointer_cast<InterfaceUserObjectBase>(user_object);
4460  auto nuo = std::dynamic_pointer_cast<NodalUserObject>(user_object);
4461  auto duo = std::dynamic_pointer_cast<DomainUserObject>(user_object);
4462  auto guo = std::dynamic_pointer_cast<GeneralUserObject>(user_object);
4463  auto tguo = std::dynamic_pointer_cast<ThreadedGeneralUserObject>(user_object);
4464  auto muo = std::dynamic_pointer_cast<MortarUserObject>(user_object);
4465 
4466  // Account for displaced mesh use
4467  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
4468  {
4469  // Whether to re-init or not depends on the attributes of the base classes.
4470  // For example, InterfaceUOBase has "_current_side_elem" and "_neighbor_elem"
4471  // so it needs to reinit on displaced neighbors and faces
4472  // _reinit_displaced_elem -> _current_elem will be reinited
4473  // _reinit_displaced_face -> _current_elem, lowerD if any and _current_side_elem to be
4474  // reinited _reinit_displaced_neighbor -> _current_elem, lowerD if any and _current_neighbor
4475  // to be reinited Note that as soon as you use materials on the displaced mesh, all three get
4476  // turned on.
4477  if (euo || nuo || duo)
4478  _reinit_displaced_elem = true;
4479  if (suo || duo || isuo || iuo)
4480  _reinit_displaced_face = true;
4481  if (iuo || duo || isuo)
4483  }
4484 
4485  // These objects only require one thread
4486  if ((guo && !tguo) || muo)
4487  break;
4488  }
4489 
4490  // Add as a Functor if it is one. We usually need to add the user object from thread 0 as the
4491  // registered functor for all threads because when user objects are thread joined, generally only
4492  // the primary thread copy ends up with all the data
4493  for (const auto tid : make_range(libMesh::n_threads()))
4494  {
4495  const decltype(uos)::size_type uo_index = uos.front()->needThreadedCopy() ? tid : 0;
4496  if (const auto functor = dynamic_cast<Moose::FunctorBase<Real> *>(uos[uo_index].get()))
4497  {
4498  this->addFunctor(name, *functor, tid);
4499  if (_displaced_problem)
4500  _displaced_problem->addFunctor(name, *functor, tid);
4501  }
4502  }
4503 
4504  return uos;
4505 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
unsigned int n_threads()
Base class for implementing interface user objects.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
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
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
void addFunctor(const std::string &name, const Moose::FunctorBase< T > &functor, const THREAD_ID tid)
add a functor to the problem functor container
Definition: SubProblem.h:1375
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.
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
Base class for user objects executed one or more sidesets, which may be on the outer boundary of the ...
This user object allows related evaluations on elements, boundaries, internal sides, interfaces in one single place.
Base class for creating new nodally-based mortar user objects.
ExecuteMooseObjectWarehouse< UserObject > _all_user_objects
A user object that runs over all the nodes and does an aggregation step to compute a single value...
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::unique_ptr< Base > create()=0
TheWarehouse & theWarehouse() const
Base class for user objects executed on all element sides internal to one or more blocks...
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
IntRange< T > make_range(T beg, T end)
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().
std::shared_ptr< DisplacedProblem > _displaced_problem
Base class for user-specific data.
Definition: UserObject.h:40
An instance of this object type has one copy per thread that runs on each thread. ...

◆ addVariable()

void MFEMProblem::addVariable ( const std::string &  var_type,
const std::string &  var_name,
InputParameters parameters 
)
overridevirtual

Override of ExternalProblem::addVariable.

Sets a MFEM grid function (and time derivative, for transient problems) to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 160 of file MFEMProblem.C.

163 {
164  addGridFunction(var_type, var_name, parameters);
165  // MOOSE variables store DoFs for the trial variable and its time derivatives up to second order;
166  // MFEM GridFunctions store data for only one set of DoFs each, so we must add additional
167  // GridFunctions for time derivatives.
168  if (isTransient())
170 }
void addGridFunction(const std::string &var_type, const std::string &var_name, InputParameters &parameters)
Adds one MFEM GridFunction to be used in the MFEM solve.
Definition: MFEMProblem.C:173
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
std::string GetTimeDerivativeName(std::string name)
virtual bool isTransient() const override

◆ addVectorPostprocessor()

void FEProblemBase::addVectorPostprocessor ( const std::string &  pp_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Definition at line 4400 of file FEProblemBase.C.

Referenced by ExtraIDIntegralReporter::ExtraIDIntegralReporter().

4403 {
4404  // Check for name collision
4405  if (hasUserObject(name))
4406  mooseError("A ",
4408  " already exists. You may not add a VectorPostprocessor by the same name.");
4409 
4410  addUserObject(pp_name, name, parameters);
4411 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
bool hasUserObject(const std::string &name) const
Check if there if a user object of given name.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::string typeAndName() const
Get the class&#39;s combined type and name; useful in error handling.
Definition: MooseBase.C:57
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters &parameters)
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
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.

◆ addVectorTag()

TagID SubProblem::addVectorTag ( const TagName &  tag_name,
const Moose::VectorTagType  type = Moose::VECTOR_TAG_RESIDUAL 
)
virtualinherited

Create a Tag.

Tags can be associated with Vectors and Matrices and allow objects (such as Kernels) to arbitrarily contribute values to any set of vectors/matrics

Note: If the tag is already present then this will simply return the TagID of that Tag, but the type must be the same.

Parameters
tag_nameThe name of the tag to create, the TagID will get automatically generated
typeThe type of the tag

Reimplemented in DisplacedProblem.

Definition at line 92 of file SubProblem.C.

Referenced by DisplacedProblem::addVectorTag(), SecantSolve::allocateStorage(), SteffensenSolve::allocateStorage(), PicardSolve::allocateStorage(), FEProblemBase::createTagSolutions(), FEProblemBase::createTagVectors(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), LinearSystem::LinearSystem(), SystemBase::needSolutionState(), and NonlinearSystemBase::NonlinearSystemBase().

94 {
96  mooseError("Vector tag type cannot be VECTOR_TAG_ANY");
97 
98  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
99 
100  // First, see if the tag exists already
101  for (const auto & vector_tag : _vector_tags)
102  {
103  mooseAssert(_vector_tags[vector_tag._id] == vector_tag, "Vector tags index mismatch");
104  if (vector_tag._name == tag_name_upper)
105  {
106  if (vector_tag._type != type)
107  mooseError("While attempting to add vector tag with name '",
108  tag_name_upper,
109  "' and type ",
110  type,
111  ",\na tag with the same name but type ",
112  vector_tag._type,
113  " was found.\n\nA tag can only exist with one type.");
114 
115  return vector_tag._id;
116  }
117  }
118 
119  // Doesn't exist - create it
120  const TagID new_tag_id = _vector_tags.size();
121  const TagTypeID new_tag_type_id = _typed_vector_tags[type].size();
122  // Primary storage for all tags where the index in the vector == the tag ID
123  _vector_tags.emplace_back(new_tag_id, new_tag_type_id, tag_name_upper, type);
124  // Secondary storage for each type so that we can have quick access to all tags of a type
125  _typed_vector_tags[type].emplace_back(new_tag_id, new_tag_type_id, tag_name_upper, type);
126  // Name map storage for quick name access
127  _vector_tags_name_map.emplace(tag_name_upper, new_tag_id);
128 
129  // Make sure that _vector_tags, _typed_vector_tags, and _vector_tags_name_map are sane
131 
132  return new_tag_id;
133 }
unsigned int TagTypeID
Definition: MooseTypes.h:211
unsigned int TagID
Definition: MooseTypes.h:210
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1167
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
std::string toUpper(std::string name)
Convert supplied string to upper case.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
std::map< TagName, TagID > _vector_tags_name_map
Map of vector tag TagName to TagID.
Definition: SubProblem.h:1177
std::vector< std::vector< VectorTag > > _typed_vector_tags
The vector tags associated with each VectorTagType This is kept separate from _vector_tags for quick ...
Definition: SubProblem.h:1174
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

◆ advanceMultiApps()

void FEProblemBase::advanceMultiApps ( ExecFlagType  type)
inlineinherited

Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep depending on your purpose.

Definition at line 1426 of file FEProblemBase.h.

1427  {
1428  mooseDeprecated("Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep "
1429  "depending on your purpose");
1431  }
void finishMultiAppStep(ExecFlagType type, bool recurse_through_multiapp_levels=false)
Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

◆ advanceState()

void FEProblemBase::advanceState ( )
virtualinherited

Advance all of the state holding vectors / datastructures so that we can move to the next timestep.

Reimplemented in DumpObjectsProblem.

Definition at line 6757 of file FEProblemBase.C.

Referenced by MFEMSteady::execute(), SteadyBase::execute(), Eigenvalue::execute(), TransientBase::incrementStepOrReject(), NonlinearEigen::init(), TransientMultiApp::setupApp(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), NonlinearEigen::takeStep(), and InversePowerMethod::takeStep().

6758 {
6759  TIME_SECTION("advanceState", 5, "Advancing State");
6760 
6761  for (auto & sys : _solver_systems)
6762  sys->copyOldSolutions();
6763  _aux->copyOldSolutions();
6764 
6765  if (_displaced_problem)
6766  {
6767  for (const auto i : index_range(_solver_systems))
6768  _displaced_problem->solverSys(i).copyOldSolutions();
6769  _displaced_problem->auxSys().copyOldSolutions();
6770  }
6771 
6773 
6775 
6778 
6781 
6784 
6785 #ifdef MOOSE_KOKKOS_ENABLED
6788 
6791 
6794 #endif
6795 }
void shift()
Shift the material properties in time.
MaterialPropertyStorage & _bnd_material_props
void shift()
Shift current, old, and older material property data storages.
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
void copyValuesBack()
Copies current chain control data values into old values.
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:87
ReporterData _reporter_data
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
void copyValuesBack()
At the end of a timestep this method is called to copy the values back in time in preparation for the...
Definition: ReporterData.C:17
Moose::Kokkos::MaterialPropertyStorage & _kokkos_material_props
ChainControlDataSystem & getChainControlDataSystem()
Gets the system that manages the ChainControls.
Definition: MooseApp.h:845
std::shared_ptr< DisplacedProblem > _displaced_problem
MaterialPropertyStorage & _neighbor_material_props
Moose::Kokkos::MaterialPropertyStorage & _kokkos_bnd_material_props
MaterialPropertyStorage & _material_props
Moose::Kokkos::MaterialPropertyStorage & _kokkos_neighbor_material_props
auto index_range(const T &sizable)

◆ allowInvalidSolution()

bool FEProblemBase::allowInvalidSolution ( ) const
inlineinherited

Whether to accept / allow an invalid solution.

Definition at line 2135 of file FEProblemBase.h.

Referenced by FEProblemBase::acceptInvalidSolution().

2135 { return _allow_invalid_solution; }
const bool _allow_invalid_solution

◆ allowOutput() [1/2]

void FEProblemBase::allowOutput ( bool  state)
inherited

Ability to enable/disable all output calls.

This is needed by Multiapps and applications to disable output for cases when executioners call other executions and when Multiapps are sub cycling.

Definition at line 6864 of file FEProblemBase.C.

Referenced by TransientMultiApp::resetApp(), and TransientMultiApp::solveStep().

6865 {
6867 }
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
void allowOutput(bool state)
Ability to enable/disable output calls This is private, users should utilize FEProblemBase::allowOutp...
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480

◆ allowOutput() [2/2]

template<typename T >
void FEProblemBase::allowOutput ( bool  state)
inherited

Definition at line 3280 of file FEProblemBase.h.

3281 {
3282  _app.getOutputWarehouse().allowOutput<T>(state);
3283 }
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
void allowOutput(bool state)
Ability to enable/disable output calls This is private, users should utilize FEProblemBase::allowOutp...
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480

◆ areCoupled()

bool FEProblemBase::areCoupled ( const unsigned int  ivar,
const unsigned int  jvar,
const unsigned int  nl_sys_num 
) const
inherited

Definition at line 6297 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians().

6300 {
6301  return (*_cm[nl_sys])(ivar, jvar);
6302 }
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
Coupling matrix for variables.

◆ assembly() [1/2]

Assembly & FEProblemBase::assembly ( const THREAD_ID  tid,
const unsigned int  sys_num 
)
inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 3428 of file FEProblemBase.h.

Referenced by ArrayNodalBC::computeJacobian(), VectorNodalBC::computeJacobian(), NodalBC::computeJacobian(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), VectorNodalBC::computeOffDiagJacobian(), ArrayNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), NonlinearSystemBase::constraintJacobians(), FEProblemBase::initialSetup(), ComputeBoundaryInitialConditionThread::onNode(), MaxQpsThread::operator()(), and FEProblemBase::reinitScalars().

3429 {
3430  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3431  mooseAssert(sys_num < _assembly[tid].size(),
3432  "System number larger than the assembly container size");
3433  return *_assembly[tid][sys_num];
3434 }
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.

◆ assembly() [2/2]

const Assembly & FEProblemBase::assembly ( const THREAD_ID  tid,
const unsigned int  sys_num 
) const
inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 3437 of file FEProblemBase.h.

3438 {
3439  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3440  mooseAssert(sys_num < _assembly[tid].size(),
3441  "System number larger than the assembly container size");
3442  return *_assembly[tid][sys_num];
3443 }
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.

◆ automaticScaling() [1/4]

bool SubProblem::automaticScaling ( ) const
inherited

Automatic scaling getter.

Returns
A boolean representing whether we are performing automatic scaling

Definition at line 1162 of file SubProblem.C.

Referenced by FEProblemBase::automaticScaling(), and DisplacedProblem::DisplacedProblem().

1163 {
1164  // Currently going to assume that we are applying or not applying automatic scaling consistently
1165  // across nonlinear systems
1167 }
virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const =0
Return the nonlinear system object as a base class reference given the system number.
bool automaticScaling() const
Getter for whether we are performing automatic scaling.
Definition: SystemBase.h:122

◆ automaticScaling() [2/4]

void SubProblem::automaticScaling
inherited

Automatic scaling setter.

Parameters
automatic_scalingA boolean representing whether we are performing automatic scaling

Definition at line 1155 of file SubProblem.C.

1156 {
1157  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
1158  systemBaseNonlinear(nl_sys_num).automaticScaling(automatic_scaling);
1159 }
virtual std::size_t numNonlinearSystems() const override
bool automaticScaling() const
Getter for whether we are performing automatic scaling.
Definition: SystemBase.h:122
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.
IntRange< T > make_range(T beg, T end)

◆ automaticScaling() [3/4]

bool SubProblem::automaticScaling
inherited

Automatic scaling getter.

Returns
A boolean representing whether we are performing automatic scaling

Definition at line 1162 of file SubProblem.C.

1163 {
1164  // Currently going to assume that we are applying or not applying automatic scaling consistently
1165  // across nonlinear systems
1167 }
bool automaticScaling() const
Getter for whether we are performing automatic scaling.
Definition: SystemBase.h:122
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.

◆ automaticScaling() [4/4]

void FEProblemBase::automaticScaling ( bool  automatic_scaling)
overridevirtualinherited

Automatic scaling setter.

Parameters
automatic_scalingA boolean representing whether we are performing automatic scaling

Reimplemented from SubProblem.

Definition at line 9175 of file FEProblemBase.C.

Referenced by DisplacedProblem::DisplacedProblem(), and FEProblemSolve::FEProblemSolve().

9176 {
9177  if (_displaced_problem)
9178  _displaced_problem->automaticScaling(automatic_scaling);
9179 
9180  SubProblem::automaticScaling(automatic_scaling);
9181 }
bool automaticScaling() const
Automatic scaling getter.
Definition: SubProblem.C:1162
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ backupMultiApps()

void FEProblemBase::backupMultiApps ( ExecFlagType  type)
inherited

Backup the MultiApps associated with the ExecFlagType.

Definition at line 5668 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), MFEMProblemSolve::solve(), and FixedPointSolve::solve().

5669 {
5670  const auto & multi_apps = _multi_apps[type].getActiveObjects();
5671 
5672  if (multi_apps.size())
5673  {
5674  TIME_SECTION("backupMultiApps", 5, "Backing Up MultiApp");
5675 
5676  if (_verbose_multiapps)
5677  _console << COLOR_CYAN << "\nBacking Up MultiApps on " << type.name() << COLOR_DEFAULT
5678  << std::endl;
5679 
5680  for (const auto & multi_app : multi_apps)
5681  multi_app->backup();
5682 
5684 
5685  if (_verbose_multiapps)
5686  _console << COLOR_CYAN << "Finished Backing Up MultiApps on " << type.name() << "\n"
5687  << COLOR_DEFAULT << std::endl;
5688  }
5689 }
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.
const Parallel::Communicator & _communicator
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...
void parallelBarrierNotify(const libMesh::Parallel::Communicator &comm, bool messaging=true)
This function implements a parallel barrier function but writes progress to stdout.
Definition: MooseUtils.C:323
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool _verbose_multiapps
Whether or not to be verbose with multiapps.

◆ bumpAllQRuleOrder()

void FEProblemBase::bumpAllQRuleOrder ( libMesh::Order  order,
SubdomainID  block 
)
inherited

Definition at line 6154 of file FEProblemBase.C.

6155 {
6156  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
6157  for (const auto i : index_range(_nl))
6158  _assembly[tid][i]->bumpAllQRuleOrder(order, block);
6159 
6160  if (_displaced_problem)
6161  _displaced_problem->bumpAllQRuleOrder(order, block);
6162 
6163  updateMaxQps();
6164 }
unsigned int n_threads()
void bumpAllQRuleOrder(libMesh::Order order, SubdomainID block)
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
auto index_range(const T &sizable)

◆ bumpVolumeQRuleOrder()

void FEProblemBase::bumpVolumeQRuleOrder ( libMesh::Order  order,
SubdomainID  block 
)
inherited

Increases the element/volume quadrature order for the specified mesh block if and only if the current volume quadrature order is lower.

This can only cause the quadrature level to increase. If volume_order is lower than or equal to the current volume/elem quadrature rule order, then nothing is done (i.e. this function is idempotent).

Definition at line 6141 of file FEProblemBase.C.

6142 {
6143  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
6144  for (const auto i : index_range(_nl))
6145  _assembly[tid][i]->bumpVolumeQRuleOrder(order, block);
6146 
6147  if (_displaced_problem)
6148  _displaced_problem->bumpVolumeQRuleOrder(order, block);
6149 
6150  updateMaxQps();
6151 }
unsigned int n_threads()
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
void bumpVolumeQRuleOrder(libMesh::Order order, SubdomainID block)
Increases the element/volume quadrature order for the specified mesh block if and only if the current...
std::shared_ptr< DisplacedProblem > _displaced_problem
auto index_range(const T &sizable)

◆ cacheJacobian()

void FEProblemBase::cacheJacobian ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2013 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulate(), NonlinearSystemBase::constraintJacobians(), and ComputeJacobianThread::postElement().

2014 {
2016  if (_displaced_problem)
2017  _displaced_problem->cacheJacobian(tid);
2018 }
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual void cacheJacobian(const THREAD_ID tid)
Definition: SubProblem.C:1312

◆ cacheJacobianNeighbor()

void FEProblemBase::cacheJacobianNeighbor ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2021 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians().

2022 {
2024  if (_displaced_problem)
2025  _displaced_problem->cacheJacobianNeighbor(tid);
2026 }
virtual void cacheJacobianNeighbor(const THREAD_ID tid)
Definition: SubProblem.C:1320
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ cacheResidual()

void FEProblemBase::cacheResidual ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1899 of file FEProblemBase.C.

Referenced by ComputeResidualThread::accumulate(), ComputeResidualAndJacobianThread::accumulate(), and NonlinearSystemBase::constraintResiduals().

1900 {
1902  if (_displaced_problem)
1903  _displaced_problem->cacheResidual(tid);
1904 }
virtual void cacheResidual(const THREAD_ID tid)
Definition: SubProblem.C:1291
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ cacheResidualNeighbor()

void FEProblemBase::cacheResidualNeighbor ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1907 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals().

1908 {
1910  if (_displaced_problem)
1911  _displaced_problem->cacheResidualNeighbor(tid);
1912 }
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual void cacheResidualNeighbor(const THREAD_ID tid)
Definition: SubProblem.C:1298

◆ callMooseError() [1/2]

void MooseBase::callMooseError ( std::string  msg,
const bool  with_prefix,
const hit::Node *  node = nullptr 
) const
inherited

External method for calling moose error with added object context.

Parameters
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix

Definition at line 105 of file MooseBase.C.

Referenced by InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

108 {
109  callMooseError(&_app, _pars, msg, with_prefix, node);
110 }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357

◆ callMooseError() [2/2]

void MooseBase::callMooseError ( MooseApp *const  app,
const InputParameters params,
std::string  msg,
const bool  with_prefix,
const hit::Node *  node 
)
staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters
appThe app pointer (if available); adds multiapp context and clears the console
paramsThe parameters, needed to obtain object information
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix

Definition at line 113 of file MooseBase.C.

118 {
119  if (!node)
120  node = MooseBase::getHitNode(params);
121 
122  std::string multiapp_prefix = "";
123  if (app)
124  {
125  if (!app->isUltimateMaster())
126  multiapp_prefix = app->name();
128  }
129 
130  if (with_prefix)
131  // False here because the hit context will get processed by the node
132  msg = messagePrefix(params, false) + msg;
133 
134  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node);
135 }
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:820
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
void mooseErrorRaw(std::string msg, const std::string &prefix="", const hit::Node *node=nullptr)
Main callback for emitting a moose error.
Definition: MooseError.C:53
void mooseConsole()
Send current output buffer to Console output objects.
const hit::Node * getHitNode() const
Definition: MooseBase.h:136
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

◆ checkBlockMatProps()

void SubProblem::checkBlockMatProps ( )
virtualinherited

Checks block material properties integrity.

See also
FEProblemBase::checkProblemIntegrity

Definition at line 623 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

624 {
625  // Variable for storing all available blocks/boundaries from the mesh
626  std::set<SubdomainID> all_ids(mesh().meshSubdomains());
627 
628  std::stringstream errors;
629 
630  // Loop through the properties to check
631  for (const auto & check_it : _map_block_material_props_check)
632  {
633  // The current id for the property being checked (BoundaryID || BlockID)
634  SubdomainID check_id = check_it.first;
635 
636  std::set<SubdomainID> check_ids = {check_id};
637 
638  // Loop through all the block/boundary ids
639  for (const auto & id : check_ids)
640  {
641  // Loop through all the stored properties
642  for (const auto & prop_it : check_it.second)
643  {
644  // Produce an error if the material property is not defined on the current block/boundary
645  // and any block/boundary
646  // and not is not a zero material property.
647  if (_map_block_material_props[id].count(prop_it.second) == 0 &&
648  _zero_block_material_props[id].count(prop_it.second) == 0)
649  {
650  std::string check_name = restrictionSubdomainCheckName(id);
651  if (check_name.empty())
652  check_name = std::to_string(id);
653  errors << "Material property '" << prop_it.second << "', requested by '" << prop_it.first
654  << "' is not defined on block " << check_name << "\n";
655  }
656  }
657  }
658  }
659 
660  if (!errors.str().empty())
661  mooseError(errors.str());
662 }
virtual MooseMesh & mesh()=0
std::string restrictionSubdomainCheckName(SubdomainID check_id)
Helper functions for checking MaterialProperties.
Definition: SubProblem.C:772
std::map< SubdomainID, std::set< MaterialPropertyName > > _zero_block_material_props
Set of properties returned as zero properties.
Definition: SubProblem.h:1058
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
std::map< SubdomainID, std::multimap< std::string, std::string > > _map_block_material_props_check
Data structures of the requested material properties.
Definition: SubProblem.h:1070
std::map< SubdomainID, std::set< std::string > > _map_block_material_props
Map of material properties (block_id -> list of properties)
Definition: SubProblem.h:1052

◆ checkBoundaryMatProps()

void SubProblem::checkBoundaryMatProps ( )
virtualinherited

Checks boundary material properties integrity.

See also
FEProblemBase::checkProblemIntegrity

Definition at line 665 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

666 {
667  // Variable for storing the value for ANY_BOUNDARY_ID
669 
670  // Variable for storing all available blocks/boundaries from the mesh
671  std::set<BoundaryID> all_ids(mesh().getBoundaryIDs());
672 
673  std::stringstream errors;
674 
675  // Loop through the properties to check
676  for (const auto & check_it : _map_boundary_material_props_check)
677  {
678  // The current id for the property being checked (BoundaryID || BlockID)
679  BoundaryID check_id = check_it.first;
680 
681  // In the case when the material being checked has an ID is set to ANY, then loop through all
682  // the possible ids and verify that the material property is defined.
683  std::set<BoundaryID> check_ids{check_id};
684  if (check_id == any_id)
685  check_ids = all_ids;
686 
687  // Loop through all the block/boundary ids
688  for (const auto & id : check_ids)
689  {
690  // Loop through all the stored properties
691  for (const auto & prop_it : check_it.second)
692  {
693  // Produce an error if the material property is not defined on the current block/boundary
694  // and any block/boundary
695  // and not is not a zero material property.
696  if (_map_boundary_material_props[id].count(prop_it.second) == 0 &&
697  _map_boundary_material_props[any_id].count(prop_it.second) == 0 &&
698  _zero_boundary_material_props[id].count(prop_it.second) == 0 &&
699  _zero_boundary_material_props[any_id].count(prop_it.second) == 0)
700  {
701  std::string check_name = restrictionBoundaryCheckName(id);
702  if (check_name.empty())
703  check_name = std::to_string(id);
704  errors << "Material property '" << prop_it.second << "', requested by '" << prop_it.first
705  << "' is not defined on boundary " << check_name << "\n";
706  }
707  }
708  }
709  }
710 
711  if (!errors.str().empty())
712  mooseError(errors.str());
713 }
virtual MooseMesh & mesh()=0
std::map< BoundaryID, std::multimap< std::string, std::string > > _map_boundary_material_props_check
Definition: SubProblem.h:1071
std::string restrictionBoundaryCheckName(BoundaryID check_id)
Definition: SubProblem.C:783
std::map< BoundaryID, std::set< MaterialPropertyName > > _zero_boundary_material_props
Definition: SubProblem.h:1059
std::map< BoundaryID, std::set< std::string > > _map_boundary_material_props
Map for boundary material properties (boundary_id -> list of properties)
Definition: SubProblem.h:1055
boundary_id_type BoundaryID
std::vector< BoundaryID > getBoundaryIDs(const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
Gets the boundary IDs with their names.
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
const BoundaryID ANY_BOUNDARY_ID
Definition: MooseTypes.C:21

◆ checkCoordinateSystems()

void FEProblemBase::checkCoordinateSystems ( )
protectedinherited

Verify that there are no element type/coordinate type conflicts.

Definition at line 8792 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

8793 {
8795 }
MooseMesh & _mesh
void checkCoordinateSystems()
Performs a sanity check for every element in the mesh.
Definition: MooseMesh.C:4347

◆ checkDependMaterialsHelper()

void FEProblemBase::checkDependMaterialsHelper ( const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase >>> &  materials_map)
protectedinherited

Helper method for checking Material object dependency.

See also
checkProblemIntegrity

These two sets are used to make sure that all dependent props on a block are actually supplied

Definition at line 8671 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

8673 {
8674  for (const auto & it : materials_map)
8675  {
8677  std::set<std::string> block_depend_props, block_supplied_props;
8678 
8679  for (const auto & mat1 : it.second)
8680  {
8681  auto & alldeps = mat1->getMatPropDependencies(); // includes requested stateful props
8682  for (auto & dep : alldeps)
8683  block_depend_props.insert(_material_prop_registry.getName(dep));
8684 
8685  // See if any of the active materials supply this property
8686  for (const auto & mat2 : it.second)
8687  {
8688  const std::set<std::string> & supplied_props = mat2->MaterialBase::getSuppliedItems();
8689  block_supplied_props.insert(supplied_props.begin(), supplied_props.end());
8690  }
8691  }
8692 
8693  // Add zero material properties specific to this block and unrestricted
8694  block_supplied_props.insert(_zero_block_material_props[it.first].begin(),
8695  _zero_block_material_props[it.first].end());
8696 
8697  // Error check to make sure all properties consumed by materials are supplied on this block
8698  std::set<std::string> difference;
8699  std::set_difference(block_depend_props.begin(),
8700  block_depend_props.end(),
8701  block_supplied_props.begin(),
8702  block_supplied_props.end(),
8703  std::inserter(difference, difference.end()));
8704 
8705  if (!difference.empty())
8706  {
8707  std::ostringstream oss;
8708  oss << "One or more Material Properties were not supplied on block ";
8709  const std::string & subdomain_name = _mesh.getSubdomainName(it.first);
8710  if (subdomain_name.length() > 0)
8711  oss << subdomain_name << " (" << it.first << ")";
8712  else
8713  oss << it.first;
8714  oss << ":\n";
8715  for (const auto & name : difference)
8716  oss << name << "\n";
8717  mooseError(oss.str());
8718  }
8719  }
8720 
8721  // This loop checks that materials are not supplied by multiple Material objects
8722  for (const auto & it : materials_map)
8723  {
8724  const auto & materials = it.second;
8725  std::set<std::string> inner_supplied, outer_supplied;
8726 
8727  for (const auto & outer_mat : materials)
8728  {
8729  // Storage for properties for this material (outer) and all other materials (inner)
8730  outer_supplied = outer_mat->getSuppliedItems();
8731  inner_supplied.clear();
8732 
8733  // Property to material map for error reporting
8734  std::map<std::string, std::set<std::string>> prop_to_mat;
8735  for (const auto & name : outer_supplied)
8736  prop_to_mat[name].insert(outer_mat->name());
8737 
8738  for (const auto & inner_mat : materials)
8739  {
8740  if (outer_mat == inner_mat)
8741  continue;
8742 
8743  // Check whether these materials are an AD pair
8744  auto outer_mat_type = outer_mat->type();
8745  auto inner_mat_type = inner_mat->type();
8746  removeSubstring(outer_mat_type, "<RESIDUAL>");
8747  removeSubstring(outer_mat_type, "<JACOBIAN>");
8748  removeSubstring(inner_mat_type, "<RESIDUAL>");
8749  removeSubstring(inner_mat_type, "<JACOBIAN>");
8750  if (outer_mat_type == inner_mat_type && outer_mat_type != outer_mat->type() &&
8751  inner_mat_type != inner_mat->type())
8752  continue;
8753 
8754  inner_supplied.insert(inner_mat->getSuppliedItems().begin(),
8755  inner_mat->getSuppliedItems().end());
8756 
8757  for (const auto & inner_supplied_name : inner_supplied)
8758  prop_to_mat[inner_supplied_name].insert(inner_mat->name());
8759  }
8760 
8761  // Test that a property isn't supplied on multiple blocks
8762  std::set<std::string> intersection;
8763  std::set_intersection(outer_supplied.begin(),
8764  outer_supplied.end(),
8765  inner_supplied.begin(),
8766  inner_supplied.end(),
8767  std::inserter(intersection, intersection.end()));
8768 
8769  if (!intersection.empty())
8770  {
8771  std::ostringstream oss;
8772  oss << "The following material properties are declared on block " << it.first
8773  << " by multiple materials:\n";
8774  oss << ConsoleUtils::indent(2) << std::setw(30) << std::left << "Material Property"
8775  << "Material Objects\n";
8776  for (const auto & outer_name : intersection)
8777  {
8778  oss << ConsoleUtils::indent(2) << std::setw(30) << std::left << outer_name;
8779  for (const auto & inner_name : prop_to_mat[outer_name])
8780  oss << inner_name << " ";
8781  oss << '\n';
8782  }
8783 
8784  mooseError(oss.str());
8785  break;
8786  }
8787  }
8788  }
8789 }
std::string indent(unsigned int spaces)
Create empty string for indenting.
Definition: ConsoleUtils.C:41
MaterialPropertyRegistry _material_prop_registry
const std::string & getSubdomainName(SubdomainID subdomain_id) const
Return the name of a block given an id.
Definition: MooseMesh.C:1801
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseMesh & _mesh
void removeSubstring(std::string &main, const std::string &sub)
find, erase, length algorithm for removing a substring from a string
Definition: MooseUtils.C:1197
std::map< SubdomainID, std::set< MaterialPropertyName > > _zero_block_material_props
Set of properties returned as zero properties.
Definition: SubProblem.h:1058
const std::string & getName(const unsigned int id) const
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
for(PetscInt i=0;i< nvars;++i)

◆ checkDisplacementOrders()

void FEProblemBase::checkDisplacementOrders ( )
protectedinherited

Verify that SECOND order mesh uses SECOND order displacements.

Definition at line 8595 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

8596 {
8597  if (_displaced_problem)
8598  {
8599  bool mesh_has_second_order_elements = false;
8600  for (const auto & elem : as_range(_displaced_mesh->activeLocalElementsBegin(),
8602  {
8603  if (elem->default_order() == SECOND)
8604  {
8605  mesh_has_second_order_elements = true;
8606  break;
8607  }
8608  }
8609 
8610  // We checked our local elements, so take the max over all processors.
8611  _displaced_mesh->comm().max(mesh_has_second_order_elements);
8612 
8613  // If the Mesh has second order elements, make sure the
8614  // displacement variables are second-order.
8615  if (mesh_has_second_order_elements)
8616  {
8617  const std::vector<std::string> & displacement_variables =
8618  _displaced_problem->getDisplacementVarNames();
8619 
8620  for (const auto & var_name : displacement_variables)
8621  {
8622  MooseVariableFEBase & mv =
8623  _displaced_problem->getVariable(/*tid=*/0,
8624  var_name,
8627  if (mv.order() != SECOND)
8628  mooseError("Error: mesh has SECOND order elements, so all displacement variables must be "
8629  "SECOND order.");
8630  }
8631  }
8632  }
8633 }
const Parallel::Communicator & comm() const
This class provides an interface for common operations on field variables of both FE and FV types wit...
SECOND
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
MeshBase::element_iterator activeLocalElementsBegin()
Calls active_local_nodes_begin/end() on the underlying libMesh mesh object.
Definition: MooseMesh.C:3091
libMesh::Order order() const
Get the order of this variable Note: Order enum can be implicitly converted to unsigned int...
void max(const T &r, T &o, Request &req) const
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
std::shared_ptr< DisplacedProblem > _displaced_problem
const MeshBase::element_iterator activeLocalElementsEnd()
Definition: MooseMesh.C:3097
MooseMesh * _displaced_mesh

◆ checkDuplicatePostprocessorVariableNames()

void FEProblemBase::checkDuplicatePostprocessorVariableNames ( )
inherited

Definition at line 1514 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

1515 {
1516  for (const auto & pp : _reporter_data.getPostprocessorNames())
1517  if (hasScalarVariable(pp))
1518  mooseError("Postprocessor \"" + pp +
1519  "\" has the same name as a scalar variable in the system.");
1520 }
virtual bool hasScalarVariable(const std::string &var_name) const override
Returns a Boolean indicating whether any system contains a variable with the name provided...
ReporterData _reporter_data
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
std::set< std::string > getPostprocessorNames() const
Return a list of all postprocessor names.
Definition: ReporterData.C:71

◆ checkExceptionAndStopSolve()

void FEProblemBase::checkExceptionAndStopSolve ( bool  print_message = true)
virtualinherited

Check to see if an exception has occurred on any processor and, if possible, force the solve to fail, which will result in the time step being cut.

Notes:

  • The exception have be registered by calling setException() prior to calling this.
  • This is collective on MPI, and must be called simultaneously by all processors!
  • If called when the solve can be interruped, it will do so and also throw a MooseException, which must be handled.
  • If called at a stage in the execution when the solve cannot be interupted (i.e., there is no solve active), it will generate an error and terminate the application.
  • DO NOT CALL THIS IN A THREADED REGION! This is meant to be called just after a threaded section.
Parameters
print_messagewhether to print a message with exception information

Definition at line 6585 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::handleException(), and DisplacedProblem::updateMesh().

6586 {
6588  return;
6589 
6590  TIME_SECTION("checkExceptionAndStopSolve", 5);
6591 
6592  // See if any processor had an exception. If it did, get back the
6593  // processor that the exception occurred on.
6594  unsigned int processor_id;
6595 
6597 
6598  if (_has_exception)
6599  {
6601 
6604  {
6605  // Print the message
6606  if (_communicator.rank() == 0 && print_message)
6607  {
6608  _console << "\n" << _exception_message << "\n";
6609  if (isTransient())
6610  _console
6611  << "To recover, the solution will fail and then be re-attempted with a reduced time "
6612  "step.\n"
6613  << std::endl;
6614  }
6615 
6616  // Stop the solve -- this entails setting
6617  // SNESSetFunctionDomainError() or directly inserting NaNs in the
6618  // residual vector to let PETSc >= 3.6 return DIVERGED_NANORINF.
6619  if (_current_nl_sys)
6621 
6622  if (_current_linear_sys)
6624 
6625  // and close Aux system (we MUST do this here; see #11525)
6626  _aux->solution().close();
6627 
6628  // We've handled this exception, so we no longer have one.
6629  _has_exception = false;
6630 
6631  // Force the next non-linear convergence check to fail (and all further residual evaluation
6632  // to be skipped).
6634 
6635  // Repropagate the exception, so it can be caught at a higher level, typically
6636  // this is NonlinearSystem::computeResidual().
6638  }
6639  else
6640  mooseError("The following parallel-communicated exception was detected during " +
6641  Moose::stringify(_current_execute_on_flag) + " evaluation:\n" +
6643  "\nBecause this did not occur during residual evaluation, there"
6644  " is no way to handle this, so the solution is aborting.\n");
6645  }
6646 }
virtual void stopSolve(const ExecFlagType &exec_flag, const std::set< TagID > &vector_tags_to_close) override
Quit the current solve as soon as possible.
Definition: LinearSystem.C:326
bool _skip_exception_check
If or not skip &#39;exception and stop solve&#39;.
ExecFlagType _current_execute_on_flag
Current execute_on flag.
processor_id_type rank() const
bool _has_exception
Whether or not an exception has occurred.
const Parallel::Communicator & _communicator
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
LinearSystem * _current_linear_sys
The current linear system that we are solving.
void maxloc(T &r, unsigned int &max_id) const
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
std::string _exception_message
The error message to go with an exception.
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
const ExecFlagType EXEC_POSTCHECK
Definition: Moose.C:35
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
Provides a way for users to bail out of the current solve.
virtual void stopSolve(const ExecFlagType &exec_flag, const std::set< TagID > &vector_tags_to_close)=0
Quit the current solve as soon as possible.
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
std::set< TagID > _fe_vector_tags
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
virtual bool isTransient() const override
bool _fail_next_system_convergence_check
processor_id_type processor_id() const

◆ checkingUOAuxState()

bool FEProblemBase::checkingUOAuxState ( ) const
inlineinherited

Return a flag to indicate whether we are executing user objects and auxliary kernels for state check Note: This function can return true only when hasUOAuxStateCheck() returns true, i.e.

the check has been activated by users through Problem/check_uo_aux_state input parameter.

Definition at line 209 of file FEProblemBase.h.

Referenced by MemoryUsage::execute(), VectorMemoryUsage::execute(), PerfGraphData::finalize(), MemoryUsage::finalize(), and VectorMemoryUsage::finalize().

209 { return _checking_uo_aux_state; }
bool _checking_uo_aux_state
Flag used to indicate whether we are doing the uo/aux state check in execute.

◆ checkNonlocalCoupling()

void FEProblemBase::checkNonlocalCoupling ( )
inherited
Returns
Flag indicating nonlocal coupling exists or not.

Definition at line 1639 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

1640 {
1641  TIME_SECTION("checkNonlocalCoupling", 5, "Checking Nonlocal Coupling");
1642 
1643  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
1644  for (auto & nl : _nl)
1645  {
1646  const auto & all_kernels = nl->getKernelWarehouse();
1647  const auto & kernels = all_kernels.getObjects(tid);
1648  for (const auto & kernel : kernels)
1649  {
1650  std::shared_ptr<NonlocalKernel> nonlocal_kernel =
1652  if (nonlocal_kernel)
1653  {
1656  _nonlocal_kernels.addObject(kernel, tid);
1657  }
1658  }
1659  const MooseObjectWarehouse<IntegratedBCBase> & all_integrated_bcs =
1660  nl->getIntegratedBCWarehouse();
1661  const auto & integrated_bcs = all_integrated_bcs.getObjects(tid);
1662  for (const auto & integrated_bc : integrated_bcs)
1663  {
1664  std::shared_ptr<NonlocalIntegratedBC> nonlocal_integrated_bc =
1666  if (nonlocal_integrated_bc)
1667  {
1670  _nonlocal_integrated_bcs.addObject(integrated_bc, tid);
1671  }
1672  }
1673  }
1674 }
unsigned int n_threads()
NonlocalIntegratedBC is used for solving integral terms in integro-differential equations.
bool _requires_nonlocal_coupling
nonlocal coupling requirement flag
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
bool _calculate_jacobian_in_uo
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::vector< std::shared_ptr< T > > & getObjects(THREAD_ID tid=0) const
Retrieve complete vector to the all/block/boundary restricted objects for a given thread...
NonlocalKernel is used for solving integral terms in integro-differential equations.
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
unsigned int THREAD_ID
Definition: MooseTypes.h:209
MooseObjectWarehouse< IntegratedBCBase > _nonlocal_integrated_bcs
nonlocal integrated_bcs
MooseObjectWarehouse< KernelBase > _nonlocal_kernels
nonlocal kernels

◆ checkNonlocalCouplingRequirement()

bool FEProblemBase::checkNonlocalCouplingRequirement ( ) const
overridevirtualinherited
Returns
whether there will be nonlocal coupling at any point in the simulation, e.g. whether there are any active or inactive nonlocal kernels or boundary conditions

Implements SubProblem.

Definition at line 9605 of file FEProblemBase.C.

Referenced by DisplacedProblem::checkNonlocalCouplingRequirement(), ComputeJacobianThread::compute(), ComputeFullJacobianThread::computeOnBoundary(), and ComputeFullJacobianThread::computeOnElement().

9606 {
9608 }
bool _requires_nonlocal_coupling
nonlocal coupling requirement flag

◆ checkProblemIntegrity()

void FEProblemBase::checkProblemIntegrity ( )
virtualinherited

Method called to perform a series of sanity checks before a simulation is run.

This method doesn't return when errors are found, instead it generally calls mooseError() directly.

If a material is specified for any block in the simulation, then all blocks must have a material specified.

unsigned int is necessary to print SubdomainIDs in the statement below

vector is necessary to get the subdomain names

Reimplemented in EigenProblem.

Definition at line 8423 of file FEProblemBase.C.

Referenced by EigenProblem::checkProblemIntegrity().

8424 {
8425  TIME_SECTION("checkProblemIntegrity", 5);
8426 
8427  // Subdomains specified by the "Problem/block" parameter
8428  const auto & subdomain_names = getParam<std::vector<SubdomainName>>("block");
8429  auto mesh_subdomains_vec = MooseMeshUtils::getSubdomainIDs(_mesh, subdomain_names);
8430  std::set<SubdomainID> mesh_subdomains(mesh_subdomains_vec.begin(), mesh_subdomains_vec.end());
8431 
8432  // Check kernel coverage of subdomains (blocks) in the mesh
8435  {
8436  std::set<SubdomainID> blocks;
8439  blocks = mesh_subdomains;
8441  {
8442  blocks = mesh_subdomains;
8443  for (const auto & subdomain_name : _kernel_coverage_blocks)
8444  {
8445  const auto id = _mesh.getSubdomainID(subdomain_name);
8446  if (id == Moose::INVALID_BLOCK_ID)
8447  paramError("kernel_coverage_block_list",
8448  "Subdomain \"",
8449  subdomain_name,
8450  "\" not found in mesh.");
8451  blocks.erase(id);
8452  }
8453  }
8455  for (const auto & subdomain_name : _kernel_coverage_blocks)
8456  {
8457  const auto id = _mesh.getSubdomainID(subdomain_name);
8458  if (id == Moose::INVALID_BLOCK_ID)
8459  paramError("kernel_coverage_block_list",
8460  "Subdomain \"",
8461  subdomain_name,
8462  "\" not found in mesh.");
8463  blocks.insert(id);
8464  }
8465  if (!blocks.empty())
8466  for (auto & nl : _nl)
8467  nl->checkKernelCoverage(blocks);
8468  }
8469 
8470  // Check materials
8471  {
8472 #ifdef LIBMESH_ENABLE_AMR
8473  if ((_adaptivity.isOn() || _num_grid_steps) &&
8476  {
8477  _console << "Using EXPERIMENTAL Stateful Material Property projection with Adaptivity!\n"
8478  << std::flush;
8479  }
8480 #endif
8481 
8482  std::set<SubdomainID> local_mesh_subs(mesh_subdomains);
8483 
8486  {
8491  bool check_material_coverage = false;
8492  std::set<SubdomainID> ids = _all_materials.getActiveBlocks();
8493  for (const auto & id : ids)
8494  {
8495  local_mesh_subs.erase(id);
8496  check_material_coverage = true;
8497  }
8498 
8499  // did the user limit the subdomains to be checked?
8501  {
8502  for (const auto & subdomain_name : _material_coverage_blocks)
8503  {
8504  const auto id = _mesh.getSubdomainID(subdomain_name);
8505  if (id == Moose::INVALID_BLOCK_ID)
8506  paramError("material_coverage_block_list",
8507  "Subdomain \"" + subdomain_name + "\" not found in mesh.");
8508  local_mesh_subs.erase(id);
8509  }
8510  }
8512  {
8513  std::set<SubdomainID> blocks(local_mesh_subs);
8514  for (const auto & subdomain_name : _material_coverage_blocks)
8515  {
8516  const auto id = _mesh.getSubdomainID(subdomain_name);
8517  if (id == Moose::INVALID_BLOCK_ID)
8518  paramError("material_coverage_block_list",
8519  "Subdomain \"" + subdomain_name + "\" not found in mesh.");
8520  blocks.erase(id);
8521  }
8522  for (const auto id : blocks)
8523  local_mesh_subs.erase(id);
8524  }
8525 
8526  // also exclude mortar spaces from the material check
8527  auto && mortar_subdomain_ids = _mortar_data.getMortarSubdomainIDs();
8528  for (auto subdomain_id : mortar_subdomain_ids)
8529  local_mesh_subs.erase(subdomain_id);
8530 
8531  // Check Material Coverage
8532  if (check_material_coverage && !local_mesh_subs.empty())
8533  {
8534  std::stringstream extra_subdomain_ids;
8536  std::copy(local_mesh_subs.begin(),
8537  local_mesh_subs.end(),
8538  std::ostream_iterator<unsigned int>(extra_subdomain_ids, " "));
8540  std::vector<SubdomainID> local_mesh_subs_vec(local_mesh_subs.begin(),
8541  local_mesh_subs.end());
8542 
8543  mooseError("The following blocks from your input mesh do not contain an active material: " +
8544  extra_subdomain_ids.str() +
8545  "(names: " + Moose::stringify(_mesh.getSubdomainNames(local_mesh_subs_vec)) +
8546  ")\nWhen ANY mesh block contains a Material object, "
8547  "all blocks must contain a Material object.\n");
8548  }
8549  }
8550 
8551  // Check material properties on blocks and boundaries
8554 
8555  // Check that material properties exist when requested by other properties on a given block
8556  const auto & materials = _all_materials.getActiveObjects();
8557  for (const auto & material : materials)
8558  material->checkStatefulSanity();
8559 
8560  // auto mats_to_check = _materials.getActiveBlockObjects();
8561  // const auto & discrete_materials = _discrete_materials.getActiveBlockObjects();
8562  // for (const auto & map_it : discrete_materials)
8563  // for (const auto & container_element : map_it.second)
8564  // mats_to_check[map_it.first].push_back(container_element);
8567  }
8568 
8569  checkUserObjects();
8570 
8571  // Verify that we don't have any Element type/Coordinate Type conflicts
8573 
8574  // Coordinate transforms are only intended for use with MultiApps at this time. If you are not
8575  // using multiapps but still require these, contact a moose developer
8577  !hasMultiApps())
8578  mooseError("Coordinate transformation parameters, listed below, are only to be used in the "
8579  "context of application to application field transfers at this time. The mesh is "
8580  "not modified by these parameters within an application.\n"
8581  "You should likely use a 'TransformGenerator' in the [Mesh] block to achieve the "
8582  "desired mesh modification.\n\n",
8584 
8585  // If using displacements, verify that the order of the displacement
8586  // variables matches the order of the elements in the displaced
8587  // mesh.
8589 
8590  // Check for postprocessor names with same name as a scalar variable
8592 }
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:820
MaterialPropertyStorage & _bnd_material_props
void checkDependMaterialsHelper(const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase >>> &materials_map)
Helper method for checking Material object dependency.
static InputParameters validParams()
Describes the parameters this object can take to setup transformations.
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition: MooseBase.h:439
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
char ** blocks
std::vector< SubdomainName > _kernel_coverage_blocks
std::vector< SubdomainName > _material_coverage_blocks
unsigned int _num_grid_steps
Number of steps in a grid sequence.
std::vector< subdomain_id_type > getSubdomainIDs(const libMesh::MeshBase &mesh, const std::vector< SubdomainName > &subdomain_name)
Get the associated subdomainIDs for the subdomain names that are passed in.
bool isOn()
Is adaptivity on?
Definition: Adaptivity.h:179
const bool _skip_nl_system_check
const SubdomainID INVALID_BLOCK_ID
Definition: MooseTypes.C:20
virtual void checkBoundaryMatProps()
Checks boundary material properties integrity.
Definition: SubProblem.C:665
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
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...
const bool & _solve
Whether or not to actually solve the nonlinear system.
std::set< SubdomainID > getActiveBlocks(THREAD_ID tid=0) const
Return a set of active SubdomainsIDs.
bool hasScalingOrRotationTransformation() const
Returns true if the app has scaling and/or rotation transformation.
void checkUserObjects()
void checkDisplacementOrders()
Verify that SECOND order mesh uses SECOND order displacements.
MortarData _mortar_data
MooseMesh & _mesh
virtual void checkBlockMatProps()
Checks block material properties integrity.
Definition: SubProblem.C:623
Adaptivity _adaptivity
const std::set< SubdomainID > & getMortarSubdomainIDs() const
Returns the mortar covered subdomains.
Definition: MortarData.h:84
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
std::vector< SubdomainName > getSubdomainNames(const std::vector< SubdomainID > &subdomain_ids) const
Get the associated subdomainNames for the subdomain ids that are passed in.
Definition: MooseMesh.C:1807
MooseAppCoordTransform & coordTransform()
Definition: MooseMesh.h:1931
void checkDuplicatePostprocessorVariableNames()
const bool _material_dependency_check
Determines whether a check to verify material dependencies on every subdomain.
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
CoverageCheckMode _material_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active material...
MaterialPropertyStorage & _neighbor_material_props
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool hasMultiApps() const
Returns whether or not the current simulation has any multiapps.
CoverageCheckMode _kernel_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active kernel...
MaterialPropertyStorage & _material_props
MaterialWarehouse _all_materials
SubdomainID getSubdomainID(const SubdomainName &subdomain_name) const
Get the associated subdomain ID for the subdomain name.
Definition: MooseMesh.C:1769
void checkCoordinateSystems()
Verify that there are no element type/coordinate type conflicts.

◆ checkUserObjectJacobianRequirement()

void FEProblemBase::checkUserObjectJacobianRequirement ( THREAD_ID  tid)
inherited

Definition at line 1677 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

1678 {
1679  std::set<const MooseVariableFEBase *> uo_jacobian_moose_vars;
1680  {
1681  std::vector<ShapeElementUserObject *> objs;
1682  theWarehouse()
1683  .query()
1685  .condition<AttribThread>(tid)
1686  .queryInto(objs);
1687 
1688  for (const auto & uo : objs)
1689  {
1690  _calculate_jacobian_in_uo = uo->computeJacobianFlag();
1691  const auto & mv_deps = uo->jacobianMooseVariables();
1692  uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
1693  }
1694  }
1695  {
1696  std::vector<ShapeSideUserObject *> objs;
1697  theWarehouse()
1698  .query()
1700  .condition<AttribThread>(tid)
1701  .queryInto(objs);
1702  for (const auto & uo : objs)
1703  {
1704  _calculate_jacobian_in_uo = uo->computeJacobianFlag();
1705  const auto & mv_deps = uo->jacobianMooseVariables();
1706  uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
1707  }
1708  }
1709 
1710  _uo_jacobian_moose_vars[tid].assign(uo_jacobian_moose_vars.begin(), uo_jacobian_moose_vars.end());
1711  std::sort(
1712  _uo_jacobian_moose_vars[tid].begin(), _uo_jacobian_moose_vars[tid].end(), sortMooseVariables);
1713 }
bool _calculate_jacobian_in_uo
TheWarehouse & theWarehouse() const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ checkUserObjects()

void FEProblemBase::checkUserObjects ( )
protectedinherited

Definition at line 8636 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

8637 {
8638  // Check user_objects block coverage
8639  std::set<SubdomainID> mesh_subdomains = _mesh.meshSubdomains();
8640  std::set<SubdomainID> user_objects_blocks;
8641 
8642  // gather names of all user_objects that were defined in the input file
8643  // and the blocks that they are defined on
8644  std::set<std::string> names;
8645 
8646  std::vector<UserObject *> objects;
8648 
8649  for (const auto & obj : objects)
8650  names.insert(obj->name());
8651 
8652  // See if all referenced blocks are covered
8653  std::set<SubdomainID> difference;
8654  std::set_difference(user_objects_blocks.begin(),
8655  user_objects_blocks.end(),
8656  mesh_subdomains.begin(),
8657  mesh_subdomains.end(),
8658  std::inserter(difference, difference.end()));
8659 
8660  if (!difference.empty())
8661  {
8662  std::ostringstream oss;
8663  oss << "One or more UserObjects is referencing a nonexistent block:\n";
8664  for (const auto & id : difference)
8665  oss << id << "\n";
8666  mooseError(oss.str());
8667  }
8668 }
TheWarehouse & theWarehouse() const
MooseMesh & _mesh
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
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
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284
const std::set< SubdomainID > & meshSubdomains() const
Returns a read-only reference to the set of subdomains currently present in the Mesh.
Definition: MooseMesh.C:3211

◆ clearActiveElementalMooseVariables()

void FEProblemBase::clearActiveElementalMooseVariables ( const THREAD_ID  tid)
overridevirtualinherited

Clear the active elemental MooseVariableFEBase.

If there are no active variables then they will all be reinited. Call this after finishing the computation that was using a restricted set of MooseVariableFEBases

Parameters
tidThe thread id

Reimplemented from SubProblem.

Definition at line 5983 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::post(), ComputeMarkerThread::post(), ComputeDiracThread::post(), ComputeIndicatorThread::post(), and ComputeUserObjectsThread::post().

5984 {
5986 
5987  if (_displaced_problem)
5988  _displaced_problem->clearActiveElementalMooseVariables(tid);
5989 }
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid)
Clear the active elemental MooseVariableFieldBase.
Definition: SubProblem.C:466
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearActiveFEVariableCoupleableMatrixTags()

void FEProblemBase::clearActiveFEVariableCoupleableMatrixTags ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 5992 of file FEProblemBase.C.

5993 {
5995 
5996  if (_displaced_problem)
5997  _displaced_problem->clearActiveFEVariableCoupleableMatrixTags(tid);
5998 }
virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid)
Definition: SubProblem.C:384
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearActiveFEVariableCoupleableVectorTags()

void FEProblemBase::clearActiveFEVariableCoupleableVectorTags ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6001 of file FEProblemBase.C.

6002 {
6004 
6005  if (_displaced_problem)
6006  _displaced_problem->clearActiveFEVariableCoupleableVectorTags(tid);
6007 }
virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid)
Definition: SubProblem.C:378
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearActiveMaterialProperties()

void FEProblemBase::clearActiveMaterialProperties ( const THREAD_ID  tid)
inherited

Clear the active material properties.

Should be called at the end of every computing thread

Parameters
tidThe thread id

Definition at line 6049 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), ComputeDiracThread::post(), ComputeIndicatorThread::post(), and ComputeUserObjectsThread::post().

6050 {
6052 }
std::vector< unsigned char > _has_active_material_properties
Whether there are active material properties on each thread.

◆ clearActiveScalarVariableCoupleableMatrixTags()

void FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6010 of file FEProblemBase.C.

Referenced by AuxiliarySystem::clearScalarVariableCoupleableTags().

6011 {
6013 
6014  if (_displaced_problem)
6015  _displaced_problem->clearActiveScalarVariableCoupleableMatrixTags(tid);
6016 }
virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid)
Definition: SubProblem.C:425
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearActiveScalarVariableCoupleableVectorTags()

void FEProblemBase::clearActiveScalarVariableCoupleableVectorTags ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6019 of file FEProblemBase.C.

Referenced by AuxiliarySystem::clearScalarVariableCoupleableTags().

6020 {
6022 
6023  if (_displaced_problem)
6024  _displaced_problem->clearActiveScalarVariableCoupleableVectorTags(tid);
6025 }
virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid)
Definition: SubProblem.C:419
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearAllDofIndices()

void SubProblem::clearAllDofIndices ( )
inherited

Clear dof indices from variables in nl and aux systems.

Definition at line 1177 of file SubProblem.C.

Referenced by FEProblemBase::solve().

1178 {
1179  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
1182 }
virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const =0
Return the nonlinear system object as a base class reference given the system number.
virtual const SystemBase & systemBaseAuxiliary() const =0
Return the auxiliary system object as a base class reference.
IntRange< T > make_range(T beg, T end)
virtual std::size_t numNonlinearSystems() const =0
void clearAllDofIndices()
Clear all dof indices from moose variables.
Definition: SystemBase.C:1613

◆ clearCurrentJacobianMatrixTags()

void FEProblemBase::clearCurrentJacobianMatrixTags ( )
inlineinherited

Clear the current Jacobian matrix tag data structure ...

if someone creates it

Definition at line 2614 of file FEProblemBase.h.

Referenced by FEProblemBase::resetState().

2614 {}

◆ clearCurrentResidualVectorTags()

void FEProblemBase::clearCurrentResidualVectorTags ( )
inlineinherited

Clear the current residual vector tag data structure.

Definition at line 3474 of file FEProblemBase.h.

Referenced by CrankNicolson::init(), and FEProblemBase::resetState().

3475 {
3477 }
std::vector< VectorTag > _current_residual_vector_tags
A data member to store the residual vector tag(s) passed into computeResidualTag(s).

◆ clearDiracInfo()

void FEProblemBase::clearDiracInfo ( )
overridevirtualinherited

Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in.

Implements SubProblem.

Definition at line 2498 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDiracContributions().

2499 {
2501 
2502  if (_displaced_problem)
2503  _displaced_problem->clearDiracInfo();
2504 }
void clearPoints()
Remove all of the current points and elements.
std::shared_ptr< DisplacedProblem > _displaced_problem
DiracKernelInfo _dirac_kernel_info
Definition: SubProblem.h:1049

◆ computeBounds()

void FEProblemBase::computeBounds ( libMesh::NonlinearImplicitSystem sys,
NumericVector< libMesh::Number > &  lower,
NumericVector< libMesh::Number > &  upper 
)
virtualinherited

Definition at line 7604 of file FEProblemBase.C.

Referenced by Moose::compute_bounds().

7607 {
7608  try
7609  {
7610  try
7611  {
7612  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7613  "I expect these system numbers to be the same");
7614 
7615  if (!_current_nl_sys->hasVector("lower_bound") || !_current_nl_sys->hasVector("upper_bound"))
7616  return;
7617 
7618  TIME_SECTION("computeBounds", 1, "Computing Bounds");
7619 
7620  NumericVector<Number> & _lower = _current_nl_sys->getVector("lower_bound");
7621  NumericVector<Number> & _upper = _current_nl_sys->getVector("upper_bound");
7622  _lower.swap(lower);
7623  _upper.swap(upper);
7624  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
7626 
7627  _aux->residualSetup();
7629  _lower.swap(lower);
7630  _upper.swap(upper);
7631  }
7632  catch (...)
7633  {
7634  handleException("computeBounds");
7635  }
7636  }
7637  catch (MooseException & e)
7638  {
7639  mooseError("Irrecoverable exception: " + std::string(e.what()));
7640  }
7641  catch (...)
7642  {
7643  mooseError("Unexpected exception type");
7644  }
7645 }
virtual const char * what() const
Get out the error message.
unsigned int n_threads()
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
Definition: SystemBase.C:924
unsigned int number() const
void handleException(const std::string &calling_method)
Handle exceptions.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
Provides a way for users to bail out of the current solve.
virtual void swap(NumericVector< T > &v)
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
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
Definition: SystemBase.C:933
MaterialWarehouse _all_materials
void computeSystems(const ExecFlagType &type)
Do generic system computations.
unsigned int THREAD_ID
Definition: MooseTypes.h:209
virtual void residualSetup(THREAD_ID tid=0) const

◆ computeDamping()

Real FEProblemBase::computeDamping ( const NumericVector< libMesh::Number > &  soln,
const NumericVector< libMesh::Number > &  update 
)
virtualinherited

Definition at line 7883 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck().

7885 {
7886  // Default to no damping
7887  Real damping = 1.0;
7888 
7889  if (_has_dampers)
7890  {
7891  TIME_SECTION("computeDamping", 1, "Computing Damping");
7892 
7893  // Save pointer to the current solution
7894  const NumericVector<Number> * _saved_current_solution = _current_nl_sys->currentSolution();
7895 
7897  // For now, do not re-compute auxiliary variables. Doing so allows a wild solution increment
7898  // to get to the material models, which may not be able to cope with drastically different
7899  // values. Once more complete dependency checking is in place, auxiliary variables (and
7900  // material properties) will be computed as needed by dampers.
7901  // _aux.compute();
7902  damping = _current_nl_sys->computeDamping(soln, update);
7903 
7904  // restore saved solution
7905  _current_nl_sys->setSolution(*_saved_current_solution);
7906  }
7907 
7908  return damping;
7909 }
Real computeDamping(const NumericVector< Number > &solution, const NumericVector< Number > &update)
Compute damping.
bool _has_dampers
Whether or not this system has any Dampers associated with it.
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
Definition: SolverSystem.C:67
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
virtual const NumericVector< Number > *const & currentSolution() const override final
The solution vector that is currently being operated on.
Definition: SolverSystem.h:117
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ computeIndicators()

void FEProblemBase::computeIndicators ( )
virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 4627 of file FEProblemBase.C.

Referenced by FEProblemBase::computeIndicatorsAndMarkers(), TransientBase::endStep(), MFEMSteady::execute(), SteadyBase::execute(), Eigenvalue::execute(), and FEProblemBase::initialAdaptMesh().

4628 {
4629  // Initialize indicator aux variable fields
4631  {
4632  TIME_SECTION("computeIndicators", 1, "Computing Indicators");
4633 
4634  // Internal side indicators may lead to creating a much larger sparsity pattern than dictated by
4635  // the actual finite element scheme (e.g. CFEM)
4636  const auto old_do_derivatives = ADReal::do_derivatives;
4637  ADReal::do_derivatives = false;
4638 
4639  std::vector<std::string> fields;
4640 
4641  // Indicator Fields
4642  const auto & indicators = _indicators.getActiveObjects();
4643  for (const auto & indicator : indicators)
4644  fields.push_back(indicator->name());
4645 
4646  // InternalSideIndicator Fields
4647  const auto & internal_indicators = _internal_side_indicators.getActiveObjects();
4648  for (const auto & internal_indicator : internal_indicators)
4649  fields.push_back(internal_indicator->name());
4650 
4651  _aux->zeroVariables(fields);
4652 
4653  // compute Indicators
4654  ComputeIndicatorThread cit(*this);
4656  _aux->solution().close();
4657  _aux->update();
4658 
4659  ComputeIndicatorThread finalize_cit(*this, true);
4661  _aux->solution().close();
4662  _aux->update();
4663 
4664  ADReal::do_derivatives = old_do_derivatives;
4665  }
4666 }
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
Definition: MooseMesh.C:1276
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
void parallel_reduce(const Range &range, Body &body, const Partitioner &)
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...
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
MooseObjectWarehouse< Indicator > _indicators
PetscErrorCode PetscInt const PetscInt fields[]
bool hasActiveObjects(THREAD_ID tid=0) const

◆ computeIndicatorsAndMarkers()

void FEProblemBase::computeIndicatorsAndMarkers ( )
virtualinherited

Definition at line 4620 of file FEProblemBase.C.

4621 {
4623  computeMarkers();
4624 }
virtual void computeMarkers()
virtual void computeIndicators()

◆ computeJacobian()

void FEProblemBase::computeJacobian ( const NumericVector< libMesh::Number > &  soln,
libMesh::SparseMatrix< libMesh::Number > &  jacobian,
const unsigned int  nl_sys_num 
)
virtualinherited

Form a Jacobian matrix with the default tag (system).

Definition at line 7439 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianSys().

7442 {
7443  setCurrentNonlinearSystem(nl_sys_num);
7444 
7445  _fe_matrix_tags.clear();
7446 
7447  auto & tags = getMatrixTags();
7448  for (auto & tag : tags)
7449  _fe_matrix_tags.insert(tag.second);
7450 
7451  computeJacobianInternal(soln, jacobian, _fe_matrix_tags);
7452 }
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
virtual void computeJacobianInternal(const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const std::set< TagID > &tags)
Form a Jacobian matrix for multiple tags.
virtual std::map< TagName, TagID > & getMatrixTags()
Return all matrix tags in the system, where a tag is represented by a map from name to ID...
Definition: SubProblem.h:253
std::set< TagID > _fe_matrix_tags

◆ computeJacobianBlock()

void FEProblemBase::computeJacobianBlock ( libMesh::SparseMatrix< libMesh::Number > &  jacobian,
libMesh::System precond_system,
unsigned int  ivar,
unsigned int  jvar 
)
virtualinherited

Really not a good idea to use this.

It computes just one block of the Jacobian into a smaller matrix. Calling this in a loop is EXTREMELY ineffecient! Try to use computeJacobianBlocks() instead!

Parameters
jacobianThe matrix you want to fill
precond_systemThe libMesh::system of the preconditioning system
ivarthe block-row of the Jacobian
jvarthe block-column of the Jacobian

Definition at line 7592 of file FEProblemBase.C.

7596 {
7597  JacobianBlock jac_block(precond_system, jacobian, ivar, jvar);
7598  std::vector<JacobianBlock *> blocks = {&jac_block};
7599  mooseAssert(_current_nl_sys, "This should be non-null");
7601 }
Helper class for holding the preconditioning blocks to fill.
char ** blocks
virtual void computeJacobianBlocks(std::vector< JacobianBlock *> &blocks, const unsigned int nl_sys_num)
Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditio...
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157

◆ computeJacobianBlocks()

void FEProblemBase::computeJacobianBlocks ( std::vector< JacobianBlock *> &  blocks,
const unsigned int  nl_sys_num 
)
virtualinherited

Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices.

Used by Physics-based preconditioning

Parameters
blocksThe blocks to fill in (JacobianBlock is defined in ComputeJacobianBlocksThread)

Reimplemented in EigenProblem.

Definition at line 7572 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianBlock(), and PhysicsBasedPreconditioner::setup().

7574 {
7575  TIME_SECTION("computeTransientImplicitJacobian", 2);
7576  setCurrentNonlinearSystem(nl_sys_num);
7577 
7578  if (_displaced_problem)
7579  {
7581  _displaced_problem->updateMesh();
7582  }
7583 
7585 
7589 }
void computeJacobianBlocks(std::vector< JacobianBlock *> &blocks)
Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditio...
char ** blocks
bool _currently_computing_jacobian
Flag to determine whether the problem is currently computing Jacobian.
Definition: SubProblem.h:1096
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
const ExecFlagType EXEC_PRE_DISPLACE
Definition: Moose.C:52
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
std::shared_ptr< DisplacedProblem > _displaced_problem
void computeSystems(const ExecFlagType &type)
Do generic system computations.

◆ computeJacobianInternal()

void FEProblemBase::computeJacobianInternal ( const NumericVector< libMesh::Number > &  soln,
libMesh::SparseMatrix< libMesh::Number > &  jacobian,
const std::set< TagID > &  tags 
)
virtualinherited

Form a Jacobian matrix for multiple tags.

It should not be called directly by users.

Definition at line 7455 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobian().

7458 {
7459  TIME_SECTION("computeJacobianInternal", 1);
7460 
7462 
7464 
7465  computeJacobianTags(tags);
7466 
7468 }
TagID systemMatrixTag() const override
Return the Matrix Tag ID for System.
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
Definition: SolverSystem.C:67
virtual void associateMatrixToTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Associate a matrix to a tag.
Definition: SystemBase.C:1076
virtual void disassociateMatrixFromTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Disassociate a matrix from a tag.
Definition: SystemBase.C:1088
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
virtual void computeJacobianTags(const std::set< TagID > &tags)
Form multiple matrices, and each is associated with a tag.

◆ computeJacobianSys()

void FEProblemBase::computeJacobianSys ( libMesh::NonlinearImplicitSystem sys,
const NumericVector< libMesh::Number > &  soln,
libMesh::SparseMatrix< libMesh::Number > &  jacobian 
)
virtualinherited

Form a Jacobian matrix.

It is called by Libmesh.

Definition at line 7417 of file FEProblemBase.C.

Referenced by Moose::compute_jacobian(), and NonlinearSystem::computeScalingJacobian().

7420 {
7421  computeJacobian(soln, jacobian, sys.number());
7422 }
unsigned int number() const
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).

◆ computeJacobianTag()

void FEProblemBase::computeJacobianTag ( const NumericVector< libMesh::Number > &  soln,
libMesh::SparseMatrix< libMesh::Number > &  jacobian,
TagID  tag 
)
virtualinherited

Form a Jacobian matrix for a given tag.

Definition at line 7425 of file FEProblemBase.C.

Referenced by ActuallyExplicitEuler::solve(), and ExplicitSSPRungeKutta::solveStage().

7428 {
7430 
7431  _current_nl_sys->associateMatrixToTag(jacobian, tag);
7432 
7433  computeJacobianTags({tag});
7434 
7436 }
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
Definition: SolverSystem.C:67
virtual void associateMatrixToTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Associate a matrix to a tag.
Definition: SystemBase.C:1076
virtual void disassociateMatrixFromTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Disassociate a matrix from a tag.
Definition: SystemBase.C:1088
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
virtual void computeJacobianTags(const std::set< TagID > &tags)
Form multiple matrices, and each is associated with a tag.

◆ computeJacobianTags()

void FEProblemBase::computeJacobianTags ( const std::set< TagID > &  tags)
virtualinherited

Form multiple matrices, and each is associated with a tag.

Definition at line 7471 of file FEProblemBase.C.

Referenced by EigenProblem::computeJacobianAB(), FEProblemBase::computeJacobianInternal(), EigenProblem::computeJacobianTag(), FEProblemBase::computeJacobianTag(), and EigenProblem::computeMatricesTags().

7472 {
7473  try
7474  {
7475  try
7476  {
7477  if (!_has_jacobian || !_const_jacobian)
7478  {
7479  TIME_SECTION("computeJacobianTags", 5, "Computing Jacobian");
7480 
7481  for (auto tag : tags)
7482  if (_current_nl_sys->hasMatrix(tag))
7483  {
7484  auto & matrix = _current_nl_sys->getMatrix(tag);
7487  else
7488  matrix.zero();
7490  // PETSc algorithms require diagonal allocations regardless of whether there is
7491  // non-zero diagonal dependence. With global AD indexing we only add non-zero
7492  // dependence, so PETSc will scream at us unless we artificially add the diagonals.
7493  for (auto index : make_range(matrix.row_start(), matrix.row_stop()))
7494  matrix.add(index, index, 0);
7495  }
7496 
7497  _aux->zeroVariablesForJacobian();
7498 
7499  unsigned int n_threads = libMesh::n_threads();
7500 
7501  // Random interface objects
7502  for (const auto & it : _random_data_objects)
7503  it.second->updateSeeds(EXEC_NONLINEAR);
7504 
7507  if (_displaced_problem)
7508  _displaced_problem->setCurrentlyComputingJacobian(true);
7509 
7512 
7513  for (unsigned int tid = 0; tid < n_threads; tid++)
7514  reinitScalars(tid);
7515 
7517 
7518  _aux->jacobianSetup();
7519 
7520  if (_displaced_problem)
7521  {
7523  _displaced_problem->updateMesh();
7524  }
7525 
7526  for (unsigned int tid = 0; tid < n_threads; tid++)
7527  {
7530  }
7531 
7533 
7535 
7537 
7539 
7541 
7543 
7544  // For explicit Euler calculations for example we often compute the Jacobian one time and
7545  // then re-use it over and over. If we're performing automatic scaling, we don't want to
7546  // use that kernel, diagonal-block only Jacobian for our actual matrix when performing
7547  // solves!
7549  _has_jacobian = true;
7550  }
7551  }
7552  catch (...)
7553  {
7554  handleException("computeJacobianTags");
7555  }
7556  }
7557  catch (const MooseException &)
7558  {
7559  // The buck stops here, we have already handled the exception by
7560  // calling the system's stopSolve() method, it is now up to PETSc to return a
7561  // "diverged" reason during the next solve.
7562  }
7563  catch (...)
7564  {
7565  mooseError("Unexpected exception type");
7566  }
7567 
7568  resetState();
7569 }
virtual void restore_original_nonzero_pattern()
unsigned int n_threads()
ExecFlagType _current_execute_on_flag
Current execute_on flag.
bool _has_jacobian
Indicates if the Jacobian was computed.
bool _currently_computing_jacobian
Flag to determine whether the problem is currently computing Jacobian.
Definition: SubProblem.h:1096
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
bool computingScalingJacobian() const
Whether we are computing an initial Jacobian for automatic variable scaling.
Definition: SystemBase.C:1552
virtual bool hasMatrix(TagID tag) const
Check if the tagged matrix exists in the system.
Definition: SystemBase.h:360
bool has_static_condensation() const
virtual void resetState()
Reset state of this object in preparation for the next evaluation.
void jacobianSetup()
Calls the jacobianSetup function for each of the output objects.
virtual void jacobianSetup(THREAD_ID tid=0) const
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
void handleException(const std::string &calling_method)
Handle exceptions.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
void computeJacobianTags(const std::set< TagID > &tags)
Computes multiple (tag associated) Jacobian matricese.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
bool haveADObjects() const
Method for reading wehther we have any ad objects.
Definition: SubProblem.h:771
virtual void jacobianSetup(THREAD_ID tid=0) const
const ExecFlagType EXEC_PRE_DISPLACE
Definition: Moose.C:52
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
Provides a way for users to bail out of the current solve.
const bool _restore_original_nonzero_pattern
Whether we should restore the original nonzero pattern for every Jacobian evaluation.
virtual libMesh::SparseMatrix< Number > & getMatrix(TagID tag)
Get a raw SparseMatrix.
Definition: SystemBase.C:1024
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
IntRange< T > make_range(T beg, T end)
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
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseObjectWarehouse< Function > _functions
functions
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
bool _const_jacobian
true if the Jacobian is constant
bool _safe_access_tagged_matrices
Is it safe to retrieve data from tagged matrices.
Definition: SubProblem.h:1108
MaterialWarehouse _all_materials
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480
void computeSystems(const ExecFlagType &type)
Do generic system computations.
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
virtual libMesh::System & system() override
Get the reference to the libMesh system.

◆ computeLinearSystemSys()

void FEProblemBase::computeLinearSystemSys ( libMesh::LinearImplicitSystem sys,
libMesh::SparseMatrix< libMesh::Number > &  system_matrix,
NumericVector< libMesh::Number > &  rhs,
const bool  compute_gradients = true 
)
virtualinherited

Assemble both the right hand side and the system matrix of a given linear system.

Parameters
sysThe linear system which should be assembled
system_matrixThe sparse matrix which should hold the system matrix
rhsThe vector which should hold the right hand side
compute_gradientsA flag to disable the computation of new gradients during the assembly, can be used to lag gradients

Definition at line 7648 of file FEProblemBase.C.

Referenced by Moose::compute_linear_system(), and FEProblemBase::computeResidualL2Norm().

7652 {
7653  TIME_SECTION("computeLinearSystemSys", 5);
7654 
7656 
7659 
7660  // We are using the residual tag system for right hand sides so we fetch everything
7661  const auto & vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
7662 
7663  // We filter out tags which do not have associated vectors in the current
7664  // system. This is essential to be able to use system-dependent vector tags.
7667 
7671  compute_gradients);
7672 
7677  // We reset the tags to the default containers for further operations
7682 }
TagID rightHandSideVectorTag() const
Definition: LinearSystem.h:114
virtual TagID systemMatrixTag() const override
Return the Matrix Tag ID for System.
Definition: LinearSystem.h:115
virtual void associateVectorToTag(NumericVector< Number > &vec, TagID tag)
Associate a vector for a given tag.
Definition: SystemBase.C:981
static void selectVectorTagsFromSystem(const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)
Select the vector tags which belong to a specific system.
Definition: SubProblem.C:289
virtual void associateMatrixToTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Associate a matrix to a tag.
Definition: SystemBase.C:1076
SparseMatrix< Number > & getSystemMatrix()
Fetching the system matrix from the libmesh system.
Definition: LinearSystem.h:126
std::set< TagID > _linear_matrix_tags
Temporary storage for filtered matrix tags for linear systems.
virtual void disassociateMatrixFromTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Disassociate a matrix from a tag.
Definition: SystemBase.C:1088
virtual const NumericVector< Number > *const & currentSolution() const override final
The solution vector that is currently being operated on.
Definition: SolverSystem.h:117
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Definition: SubProblem.C:172
virtual void disassociateVectorFromTag(NumericVector< Number > &vec, TagID tag)
Disassociate a given vector from a given tag.
LinearSystem * _current_linear_sys
The current linear system that we are solving.
virtual std::map< TagName, TagID > & getMatrixTags()
Return all matrix tags in the system, where a tag is represented by a map from name to ID...
Definition: SubProblem.h:253
NumericVector< Number > & getRightHandSideVector()
Fetching the right hand side vector from the libmesh system.
Definition: LinearSystem.h:119
void setCurrentLinearSystem(unsigned int sys_num)
Set the current linear system pointer.
static void selectMatrixTagsFromSystem(const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)
Select the matrix tags which belong to a specific system.
Definition: SubProblem.C:300
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.
unsigned int linearSysNum(const LinearSystemName &linear_sys_name) const override
const std::string & name() const
std::set< TagID > _linear_vector_tags
Temporary storage for filtered vector tags for linear systems.

◆ computeLinearSystemTags()

void FEProblemBase::computeLinearSystemTags ( const NumericVector< libMesh::Number > &  soln,
const std::set< TagID > &  vector_tags,
const std::set< TagID > &  matrix_tags,
const bool  compute_gradients = true 
)
inherited

Assemble the current linear system given a set of vector and matrix tags.

Parameters
solnThe solution which should be used for the system assembly
vector_tagsThe vector tags for the right hand side
matrix_tagsThe matrix tags for the matrix
compute_gradientsA flag to disable the computation of new gradients during the assembly, can be used to lag gradients

Definition at line 7685 of file FEProblemBase.C.

Referenced by FEProblemBase::computeLinearSystemSys().

7689 {
7690  TIME_SECTION("computeLinearSystemTags", 5, "Computing Linear System");
7691 
7693 
7694  for (auto tag : matrix_tags)
7695  {
7696  auto & matrix = _current_linear_sys->getMatrix(tag);
7697  matrix.zero();
7698  }
7699 
7700  unsigned int n_threads = libMesh::n_threads();
7701 
7703 
7704  // Random interface objects
7705  for (const auto & it : _random_data_objects)
7706  it.second->updateSeeds(EXEC_NONLINEAR);
7707 
7710 
7712 
7713  _aux->jacobianSetup();
7714 
7715  for (THREAD_ID tid = 0; tid < n_threads; tid++)
7716  {
7718  }
7719 
7720  try
7721  {
7723  }
7724  catch (MooseException & e)
7725  {
7726  _console << "\nA MooseException was raised during Auxiliary variable computation.\n"
7727  << "The next solve will fail, the timestep will be reduced, and we will try again.\n"
7728  << std::endl;
7729 
7730  // We know the next solve is going to fail, so there's no point in
7731  // computing anything else after this. Plus, using incompletely
7732  // computed AuxVariables in subsequent calculations could lead to
7733  // other errors or unhandled exceptions being thrown.
7734  return;
7735  }
7736 
7739 
7741 
7742  _current_linear_sys->computeLinearSystemTags(vector_tags, matrix_tags, compute_gradients);
7743 
7744  // Reset execution flag as after this point we are no longer on LINEAR
7746 
7747  // These are the relevant parts of resetState()
7750 }
unsigned int n_threads()
ExecFlagType _current_execute_on_flag
Current execute_on flag.
const ExecFlagType EXEC_NONE
Definition: Moose.C:29
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
Definition: SolverSystem.C:67
void jacobianSetup()
Calls the jacobianSetup function for each of the output objects.
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
virtual void zero()=0
bool _safe_access_tagged_vectors
Is it safe to retrieve data from tagged vectors.
Definition: SubProblem.h:1111
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
LinearSystem * _current_linear_sys
The current linear system that we are solving.
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
virtual void jacobianSetup(THREAD_ID tid=0) const
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
Provides a way for users to bail out of the current solve.
virtual libMesh::SparseMatrix< Number > & getMatrix(TagID tag)
Get a raw SparseMatrix.
Definition: SystemBase.C:1024
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
MooseObjectWarehouse< Function > _functions
functions
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
bool _safe_access_tagged_matrices
Is it safe to retrieve data from tagged matrices.
Definition: SubProblem.h:1108
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480
void computeSystems(const ExecFlagType &type)
Do generic system computations.
void computeLinearSystemTags(const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
Compute the right hand side and the system matrix of the system for given tags.
Definition: LinearSystem.C:141
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ computeMarkers()

void FEProblemBase::computeMarkers ( )
virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 4669 of file FEProblemBase.C.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::computeIndicatorsAndMarkers(), TransientBase::endStep(), MFEMSteady::execute(), SteadyBase::execute(), Eigenvalue::execute(), and FEProblemBase::initialAdaptMesh().

4670 {
4671  if (_markers.hasActiveObjects())
4672  {
4673  TIME_SECTION("computeMarkers", 1, "Computing Markers");
4674 
4675  std::vector<std::string> fields;
4676 
4677  // Marker Fields
4678  const auto & markers = _markers.getActiveObjects();
4679  for (const auto & marker : markers)
4680  fields.push_back(marker->name());
4681 
4682  _aux->zeroVariables(fields);
4683 
4685 
4686  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
4687  {
4688  const auto & markers = _markers.getActiveObjects(tid);
4689  for (const auto & marker : markers)
4690  marker->markerSetup();
4691  }
4692 
4693  ComputeMarkerThread cmt(*this);
4695 
4696  _aux->solution().close();
4697  _aux->update();
4698  }
4699 }
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
Definition: MooseMesh.C:1276
unsigned int n_threads()
void parallel_reduce(const Range &range, Body &body, const Partitioner &)
void updateErrorVectors()
Update the ErrorVectors that have been requested through calls to getErrorVector().
Definition: Adaptivity.C:372
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...
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
Adaptivity _adaptivity
PetscErrorCode PetscInt const PetscInt fields[]
bool hasActiveObjects(THREAD_ID tid=0) const
MooseObjectWarehouse< Marker > _markers
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ computeMultiAppsDT()

Real FEProblemBase::computeMultiAppsDT ( ExecFlagType  type)
inherited

Find the smallest timestep over all MultiApps.

Definition at line 5720 of file FEProblemBase.C.

Referenced by TransientBase::constrainDTFromMultiApp().

5721 {
5722  const auto & multi_apps = _transient_multi_apps[type].getActiveObjects();
5723 
5724  Real smallest_dt = std::numeric_limits<Real>::max();
5725 
5726  for (const auto & multi_app : multi_apps)
5727  smallest_dt = std::min(smallest_dt, multi_app->computeDT());
5728 
5729  return smallest_dt;
5730 }
ExecuteMooseObjectWarehouse< TransientMultiApp > _transient_multi_apps
Storage for TransientMultiApps (only needed for calling &#39;computeDT&#39;)
auto max(const L &left, const R &right)
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...
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
auto min(const L &left, const R &right)

◆ computeNearNullSpace()

void FEProblemBase::computeNearNullSpace ( libMesh::NonlinearImplicitSystem sys,
std::vector< NumericVector< libMesh::Number > *> &  sp 
)
virtualinherited

Definition at line 7753 of file FEProblemBase.C.

Referenced by Moose::compute_nearnullspace().

7755 {
7756  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7757  "I expect these system numbers to be the same");
7758 
7759  sp.clear();
7760  for (unsigned int i = 0; i < subspaceDim("NearNullSpace"); ++i)
7761  {
7762  std::stringstream postfix;
7763  postfix << "_" << i;
7764  std::string modename = "NearNullSpace" + postfix.str();
7765  sp.push_back(&_current_nl_sys->getVector(modename));
7766  }
7767 }
unsigned int subspaceDim(const std::string &prefix) const
Dimension of the subspace spanned by vectors with a given prefix.
unsigned int number() const
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
Definition: SystemBase.C:933

◆ computeNullSpace()

void FEProblemBase::computeNullSpace ( libMesh::NonlinearImplicitSystem sys,
std::vector< NumericVector< libMesh::Number > *> &  sp 
)
virtualinherited

Definition at line 7770 of file FEProblemBase.C.

Referenced by Moose::compute_nullspace().

7772 {
7773  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7774  "I expect these system numbers to be the same");
7775  sp.clear();
7776  for (unsigned int i = 0; i < subspaceDim("NullSpace"); ++i)
7777  {
7778  std::stringstream postfix;
7779  postfix << "_" << i;
7780  sp.push_back(&_current_nl_sys->getVector("NullSpace" + postfix.str()));
7781  }
7782 }
unsigned int subspaceDim(const std::string &prefix) const
Dimension of the subspace spanned by vectors with a given prefix.
unsigned int number() const
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
Definition: SystemBase.C:933

◆ computePostCheck()

void FEProblemBase::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 
)
virtualinherited

Definition at line 7800 of file FEProblemBase.C.

Referenced by Moose::compute_postcheck().

7806 {
7807  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7808  "I expect these system numbers to be the same");
7809 
7810  // This function replaces the old PetscSupport::dampedCheck() function.
7811  //
7812  // 1.) Recreate code in PetscSupport::dampedCheck() for constructing
7813  // ghosted "soln" and "update" vectors.
7814  // 2.) Call FEProblemBase::computeDamping() with these ghost vectors.
7815  // 3.) Recreate the code in PetscSupport::dampedCheck() to actually update
7816  // the solution vector based on the damping, and set the "changed" flags
7817  // appropriately.
7818 
7819  TIME_SECTION("computePostCheck", 2, "Computing Post Check");
7820 
7822 
7823  // MOOSE's FEProblemBase doesn't update the solution during the
7824  // postcheck, but FEProblemBase-derived classes might.
7826  {
7827  // We need ghosted versions of new_soln and search_direction (the
7828  // ones we get from libmesh/PETSc are PARALLEL vectors. To make
7829  // our lives simpler, we use the same ghosting pattern as the
7830  // system's current_local_solution to create new ghosted vectors.
7831 
7832  // Construct zeroed-out clones with the same ghosted dofs as the
7833  // System's current_local_solution.
7834  std::unique_ptr<NumericVector<Number>> ghosted_solution =
7835  sys.current_local_solution->zero_clone(),
7836  ghosted_search_direction =
7837  sys.current_local_solution->zero_clone();
7838 
7839  // Copy values from input vectors into clones with ghosted values.
7840  *ghosted_solution = new_soln;
7841  *ghosted_search_direction = search_direction;
7842 
7843  if (_has_dampers)
7844  {
7845  // Compute the damping coefficient using the ghosted vectors
7846  Real damping = computeDamping(*ghosted_solution, *ghosted_search_direction);
7847 
7848  // If some non-trivial damping was computed, update the new_soln
7849  // vector accordingly.
7850  if (damping < 1.0)
7851  {
7852  new_soln = old_soln;
7853  new_soln.add(-damping, search_direction);
7854  changed_new_soln = true;
7855  }
7856  }
7857 
7858  if (shouldUpdateSolution())
7859  {
7860  // Update the ghosted copy of the new solution, if necessary.
7861  if (changed_new_soln)
7862  *ghosted_solution = new_soln;
7863 
7864  bool updated_solution = updateSolution(new_soln, *ghosted_solution);
7865  if (updated_solution)
7866  changed_new_soln = true;
7867  }
7868  }
7869 
7871  {
7873  _aux->copyCurrentIntoPreviousNL();
7874  }
7875 
7876  // MOOSE doesn't change the search_direction
7877  changed_search_direction = false;
7878 
7880 }
ExecFlagType _current_execute_on_flag
Current execute_on flag.
virtual void setPreviousNewtonSolution(const NumericVector< Number > &soln)
bool _has_dampers
Whether or not this system has any Dampers associated with it.
const ExecFlagType EXEC_NONE
Definition: Moose.C:29
unsigned int number() const
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
virtual bool shouldUpdateSolution()
Check to see whether the problem should update the solution.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
const ExecFlagType EXEC_POSTCHECK
Definition: Moose.C:35
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::unique_ptr< NumericVector< Number > > current_local_solution
virtual bool updateSolution(NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)
Update the solution.
virtual void add(const numeric_index_type i, const T value)=0
const TagName PREVIOUS_NL_SOLUTION_TAG
Definition: MooseTypes.C:28
virtual Real computeDamping(const NumericVector< libMesh::Number > &soln, const NumericVector< libMesh::Number > &update)

◆ computeResidual() [1/2]

void FEProblemBase::computeResidual ( libMesh::NonlinearImplicitSystem sys,
const NumericVector< libMesh::Number > &  soln,
NumericVector< libMesh::Number > &  residual 
)
inherited

This function is called by Libmesh to form a residual.

This is deprecated. We should remove this as soon as RattleSnake is fixed.

Referenced by FEProblemBase::computeResidualL2Norm(), FEProblemBase::computeResidualSys(), ActuallyExplicitEuler::solve(), and ExplicitSSPRungeKutta::solveStage().

◆ computeResidual() [2/2]

virtual void FEProblemBase::computeResidual ( const NumericVector< libMesh::Number > &  soln,
NumericVector< libMesh::Number > &  residual,
const unsigned int  nl_sys_num 
)
virtualinherited

Form a residual with default tags (nontime, time, residual).

◆ computeResidualAndJacobian()

void FEProblemBase::computeResidualAndJacobian ( const NumericVector< libMesh::Number > &  soln,
NumericVector< libMesh::Number > &  residual,
libMesh::SparseMatrix< libMesh::Number > &  jacobian 
)
inherited

Form a residual and Jacobian with default tags.

Definition at line 7062 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobian::residual_and_jacobian().

7065 {
7066  try
7067  {
7068  try
7069  {
7070  // vector tags
7072  const auto & residual_vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
7073 
7074  mooseAssert(_fe_vector_tags.empty(),
7075  "This should be empty indicating a clean starting state");
7076  // We filter out tags which do not have associated vectors in the current nonlinear
7077  // system. This is essential to be able to use system-dependent residual tags.
7079 
7081 
7082  // matrix tags
7083  {
7084  _fe_matrix_tags.clear();
7085 
7086  auto & tags = getMatrixTags();
7087  for (auto & tag : tags)
7088  _fe_matrix_tags.insert(tag.second);
7089  }
7090 
7092 
7095 
7096  for (const auto tag : _fe_matrix_tags)
7097  if (_current_nl_sys->hasMatrix(tag))
7098  {
7099  auto & matrix = _current_nl_sys->getMatrix(tag);
7100  matrix.zero();
7102  // PETSc algorithms require diagonal allocations regardless of whether there is non-zero
7103  // diagonal dependence. With global AD indexing we only add non-zero
7104  // dependence, so PETSc will scream at us unless we artificially add the diagonals.
7105  for (auto index : make_range(matrix.row_start(), matrix.row_stop()))
7106  matrix.add(index, index, 0);
7107  }
7108 
7109  _aux->zeroVariablesForResidual();
7110 
7111  unsigned int n_threads = libMesh::n_threads();
7112 
7114 
7115  // Random interface objects
7116  for (const auto & it : _random_data_objects)
7117  it.second->updateSeeds(EXEC_LINEAR);
7118 
7122  if (_displaced_problem)
7123  {
7124  _displaced_problem->setCurrentlyComputingResidual(true);
7125  _displaced_problem->setCurrentlyComputingJacobian(true);
7126  _displaced_problem->setCurrentlyComputingResidualAndJacobian(true);
7127  }
7128 
7130 
7132 
7133  for (unsigned int tid = 0; tid < n_threads; tid++)
7134  reinitScalars(tid);
7135 
7137 
7138  _aux->residualSetup();
7139 
7140  if (_displaced_problem)
7141  {
7143  _displaced_problem->updateMesh();
7145  updateMortarMesh();
7146  }
7147 
7148  for (THREAD_ID tid = 0; tid < n_threads; tid++)
7149  {
7152  }
7153 
7155 
7157 
7159 
7161 
7164 
7166 
7169  }
7170  catch (...)
7171  {
7172  handleException("computeResidualAndJacobian");
7173  }
7174  }
7175  catch (const MooseException &)
7176  {
7177  // The buck stops here, we have already handled the exception by
7178  // calling the system's stopSolve() method, it is now up to PETSc to return a
7179  // "diverged" reason during the next solve.
7180  }
7181  catch (...)
7182  {
7183  mooseError("Unexpected exception type");
7184  }
7185 
7186  resetState();
7187  _fe_vector_tags.clear();
7188  _fe_matrix_tags.clear();
7189 }
virtual void residualSetup(THREAD_ID tid=0) const
unsigned int n_threads()
ExecFlagType _current_execute_on_flag
Current execute_on flag.
TagID systemMatrixTag() const override
Return the Matrix Tag ID for System.
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
void setCurrentlyComputingResidual(bool currently_computing_residual) final
Set whether or not the problem is in the process of computing the residual.
virtual void associateVectorToTag(NumericVector< Number > &vec, TagID tag)
Associate a vector for a given tag.
Definition: SystemBase.C:981
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
Definition: SolverSystem.C:67
virtual bool hasMatrix(TagID tag) const
Check if the tagged matrix exists in the system.
Definition: SystemBase.h:360
static void selectVectorTagsFromSystem(const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)
Select the vector tags which belong to a specific system.
Definition: SubProblem.C:289
virtual void associateMatrixToTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Associate a matrix to a tag.
Definition: SystemBase.C:1076
bool has_static_condensation() const
void setCurrentlyComputingResidualAndJacobian(bool currently_computing_residual_and_jacobian)
Set whether or not the problem is in the process of computing the Jacobian.
Definition: SubProblem.h:1493
virtual void disassociateMatrixFromTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Disassociate a matrix from a tag.
Definition: SystemBase.C:1088
void setCurrentlyComputingJacobian(const bool currently_computing_jacobian)
Set whether or not the problem is in the process of computing the Jacobian.
Definition: SubProblem.h:689
virtual void resetState()
Reset state of this object in preparation for the next evaluation.
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
void computeResidualAndJacobianTags(const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
Form possibly multiple tag-associated vectors and matrices.
void handleException(const std::string &calling_method)
Handle exceptions.
virtual void zero()=0
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
bool _safe_access_tagged_vectors
Is it safe to retrieve data from tagged vectors.
Definition: SubProblem.h:1111
MortarData _mortar_data
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Definition: SubProblem.C:172
virtual void disassociateVectorFromTag(NumericVector< Number > &vec, TagID tag)
Disassociate a given vector from a given tag.
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
bool haveADObjects() const
Method for reading wehther we have any ad objects.
Definition: SubProblem.h:771
virtual std::map< TagName, TagID > & getMatrixTags()
Return all matrix tags in the system, where a tag is represented by a map from name to ID...
Definition: SubProblem.h:253
TagID residualVectorTag() const override
void residualSetup()
Calls the residualSetup function for each of the output objects.
const ExecFlagType EXEC_PRE_DISPLACE
Definition: Moose.C:52
virtual void updateMortarMesh()
std::set< TagID > _fe_matrix_tags
Provides a way for users to bail out of the current solve.
virtual libMesh::SparseMatrix< Number > & getMatrix(TagID tag)
Get a raw SparseMatrix.
Definition: SystemBase.C:1024
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
bool hasDisplacedObjects() const
Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh...
Definition: MortarData.h:99
IntRange< T > make_range(T beg, T end)
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
std::set< TagID > _fe_vector_tags
std::shared_ptr< DisplacedProblem > _displaced_problem
void setCurrentResidualVectorTags(const std::set< TagID > &vector_tags)
Set the current residual vector tag data structure based on the passed in tag IDs.
MooseObjectWarehouse< Function > _functions
functions
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
bool _safe_access_tagged_matrices
Is it safe to retrieve data from tagged matrices.
Definition: SubProblem.h:1108
MaterialWarehouse _all_materials
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480
void computeSystems(const ExecFlagType &type)
Do generic system computations.
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
unsigned int THREAD_ID
Definition: MooseTypes.h:209
virtual void residualSetup(THREAD_ID tid=0) const
virtual libMesh::System & system() override
Get the reference to the libMesh system.

◆ computeResidualInternal()

void FEProblemBase::computeResidualInternal ( const NumericVector< libMesh::Number > &  soln,
NumericVector< libMesh::Number > &  residual,
const std::set< TagID > &  tags 
)
virtualinherited

Form a residual vector for a set of tags.

It should not be called directly by users.

Definition at line 7221 of file FEProblemBase.C.

7224 {
7225  parallel_object_only();
7226 
7227  TIME_SECTION("computeResidualInternal", 1);
7228 
7229  try
7230  {
7232 
7234 
7235  computeResidualTags(tags);
7236 
7238  }
7239  catch (MooseException & e)
7240  {
7241  // If a MooseException propagates all the way to here, it means
7242  // that it was thrown from a MOOSE system where we do not
7243  // (currently) properly support the throwing of exceptions, and
7244  // therefore we have no choice but to error out. It may be
7245  // *possible* to handle exceptions from other systems, but in the
7246  // meantime, we don't want to silently swallow any unhandled
7247  // exceptions here.
7248  mooseError("An unhandled MooseException was raised during residual computation. Please "
7249  "contact the MOOSE team for assistance.");
7250  }
7251 }
virtual void associateVectorToTag(NumericVector< Number > &vec, TagID tag)
Associate a vector for a given tag.
Definition: SystemBase.C:981
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
Definition: SolverSystem.C:67
virtual void computeResidualTags(const std::set< TagID > &tags)
Form multiple residual vectors and each is associated with one tag.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
virtual void disassociateVectorFromTag(NumericVector< Number > &vec, TagID tag)
Disassociate a given vector from a given tag.
TagID residualVectorTag() const override
Provides a way for users to bail out of the current solve.
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

◆ computeResidualL2Norm() [1/3]

Real FEProblemBase::computeResidualL2Norm ( NonlinearSystemBase sys)
inherited

Computes the residual of a nonlinear system using whatever is sitting in the current solution vector then returns the L2 norm.

Definition at line 6971 of file FEProblemBase.C.

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), Residual::getValue(), DefaultMultiAppFixedPointConvergence::initialize(), and DefaultMultiAppFixedPointConvergence::preExecute().

6972 {
6973  _current_nl_sys = &sys;
6974  computeResidual(*sys.currentSolution(), sys.RHS(), sys.number());
6975  return sys.RHS().l2_norm();
6976 }
virtual Real l2_norm() const=0
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
virtual const NumericVector< Number > *const & currentSolution() const override final
The solution vector that is currently being operated on.
Definition: SolverSystem.h:117
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
void computeResidual(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
This function is called by Libmesh to form a residual.
virtual NumericVector< Number > & RHS()=0

◆ computeResidualL2Norm() [2/3]

Real FEProblemBase::computeResidualL2Norm ( LinearSystem sys)
inherited

Computes the residual of a linear system using whatever is sitting in the current solution vector then returns the L2 norm.

Definition at line 6979 of file FEProblemBase.C.

6980 {
6981  _current_linear_sys = &sys;
6982 
6983  // We assemble the current system to check the current residual
6986  *sys.linearImplicitSystem().rhs,
6987  /*compute fresh gradients*/ true);
6988 
6989  // Unfortunate, but we have to allocate a new vector for the residual
6990  auto residual = sys.linearImplicitSystem().rhs->clone();
6991  residual->scale(-1.0);
6992  residual->add_vector(*sys.currentSolution(), *sys.linearImplicitSystem().matrix);
6993  return residual->l2_norm();
6994 }
libMesh::LinearImplicitSystem & linearImplicitSystem()
Return a reference to the stored linear implicit system.
Definition: LinearSystem.h:86
NumericVector< Number > * rhs
virtual std::unique_ptr< NumericVector< T > > clone() const=0
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. ...
virtual const NumericVector< Number > *const & currentSolution() const override final
The solution vector that is currently being operated on.
Definition: SolverSystem.h:117
LinearSystem * _current_linear_sys
The current linear system that we are solving.
SparseMatrix< Number > * matrix

◆ computeResidualL2Norm() [3/3]

Real FEProblemBase::computeResidualL2Norm ( )
virtualinherited

Computes the residual using whatever is sitting in the current solution vector then returns the L2 norm.

Returns
The L2 norm of the residual

Reimplemented in EigenProblem.

Definition at line 6997 of file FEProblemBase.C.

6998 {
6999  TIME_SECTION("computeResidualL2Norm", 2, "Computing L2 Norm of Residual");
7000 
7001  // We use sum the squared norms of the individual systems and then take the square root of it
7002  Real l2_norm = 0.0;
7003  for (auto sys : _nl)
7004  {
7005  const auto norm = computeResidualL2Norm(*sys);
7006  l2_norm += norm * norm;
7007  }
7008 
7009  for (auto sys : _linear_systems)
7010  {
7011  const auto norm = computeResidualL2Norm(*sys);
7012  l2_norm += norm * norm;
7013  }
7014 
7015  return std::sqrt(l2_norm);
7016 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
auto norm(const T &a) -> decltype(std::abs(a))
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sqrt(_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh
virtual Real computeResidualL2Norm()
Computes the residual using whatever is sitting in the current solution vector then returns the L2 no...
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.

◆ computeResidualSys()

void FEProblemBase::computeResidualSys ( libMesh::NonlinearImplicitSystem sys,
const NumericVector< libMesh::Number > &  soln,
NumericVector< libMesh::Number > &  residual 
)
virtualinherited

This function is called by Libmesh to form a residual.

Definition at line 7019 of file FEProblemBase.C.

Referenced by NonlinearSystem::computeScalingResidual(), ComputeResidualFunctor::residual(), ComputeFDResidualFunctor::residual(), and NonlinearSystem::solve().

7022 {
7023  parallel_object_only();
7024 
7025  TIME_SECTION("computeResidualSys", 5);
7026 
7027  computeResidual(soln, residual, sys.number());
7028 }
unsigned int number() const
void computeResidual(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
This function is called by Libmesh to form a residual.

◆ computeResidualTag()

void FEProblemBase::computeResidualTag ( const NumericVector< libMesh::Number > &  soln,
NumericVector< libMesh::Number > &  residual,
TagID  tag 
)
virtualinherited

Form a residual vector for a given tag.

Definition at line 7192 of file FEProblemBase.C.

7195 {
7196  try
7197  {
7199 
7200  _current_nl_sys->associateVectorToTag(residual, tag);
7201 
7202  computeResidualTags({tag});
7203 
7205  }
7206  catch (MooseException & e)
7207  {
7208  // If a MooseException propagates all the way to here, it means
7209  // that it was thrown from a MOOSE system where we do not
7210  // (currently) properly support the throwing of exceptions, and
7211  // therefore we have no choice but to error out. It may be
7212  // *possible* to handle exceptions from other systems, but in the
7213  // meantime, we don't want to silently swallow any unhandled
7214  // exceptions here.
7215  mooseError("An unhandled MooseException was raised during residual computation. Please "
7216  "contact the MOOSE team for assistance.");
7217  }
7218 }
virtual void associateVectorToTag(NumericVector< Number > &vec, TagID tag)
Associate a vector for a given tag.
Definition: SystemBase.C:981
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
Definition: SolverSystem.C:67
virtual void computeResidualTags(const std::set< TagID > &tags)
Form multiple residual vectors and each is associated with one tag.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
virtual void disassociateVectorFromTag(NumericVector< Number > &vec, TagID tag)
Disassociate a given vector from a given tag.
Provides a way for users to bail out of the current solve.
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

◆ computeResidualTags()

void FEProblemBase::computeResidualTags ( const std::set< TagID > &  tags)
virtualinherited

Form multiple residual vectors and each is associated with one tag.

Definition at line 7337 of file FEProblemBase.C.

Referenced by EigenProblem::computeResidualAB(), FEProblemBase::computeResidualInternal(), EigenProblem::computeResidualTag(), FEProblemBase::computeResidualTag(), and FEProblemBase::computeResidualType().

7338 {
7339  parallel_object_only();
7340 
7341  try
7342  {
7343  try
7344  {
7345  TIME_SECTION("computeResidualTags", 5, "Computing Residual");
7346 
7347  ADReal::do_derivatives = false;
7348 
7350 
7351  _aux->zeroVariablesForResidual();
7352 
7353  unsigned int n_threads = libMesh::n_threads();
7354 
7356 
7357  // Random interface objects
7358  for (const auto & it : _random_data_objects)
7359  it.second->updateSeeds(EXEC_LINEAR);
7360 
7362 
7364 
7365  for (unsigned int tid = 0; tid < n_threads; tid++)
7366  reinitScalars(tid);
7367 
7369 
7370  _aux->residualSetup();
7371 
7372  if (_displaced_problem)
7373  {
7375  _displaced_problem->updateMesh();
7377  updateMortarMesh();
7378  }
7379 
7380  for (THREAD_ID tid = 0; tid < n_threads; tid++)
7381  {
7384  }
7385 
7387 
7389 
7391 
7393 
7396  }
7397  catch (...)
7398  {
7399  handleException("computeResidualTags");
7400  }
7401  }
7402  catch (const MooseException &)
7403  {
7404  // The buck stops here, we have already handled the exception by
7405  // calling the system's stopSolve() method, it is now up to PETSc to return a
7406  // "diverged" reason during the next solve.
7407  }
7408  catch (...)
7409  {
7410  mooseError("Unexpected exception type");
7411  }
7412 
7413  resetState();
7414 }
virtual void residualSetup(THREAD_ID tid=0) const
unsigned int n_threads()
ExecFlagType _current_execute_on_flag
Current execute_on flag.
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
void computeResidualTags(const std::set< TagID > &tags)
Form multiple tag-associated residual vectors for all the given tags.
virtual void resetState()
Reset state of this object in preparation for the next evaluation.
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
void handleException(const std::string &calling_method)
Handle exceptions.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
bool _safe_access_tagged_vectors
Is it safe to retrieve data from tagged vectors.
Definition: SubProblem.h:1111
MortarData _mortar_data
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
void residualSetup()
Calls the residualSetup function for each of the output objects.
const ExecFlagType EXEC_PRE_DISPLACE
Definition: Moose.C:52
virtual void updateMortarMesh()
Provides a way for users to bail out of the current solve.
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
bool hasDisplacedObjects() const
Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh...
Definition: MortarData.h:99
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
std::shared_ptr< DisplacedProblem > _displaced_problem
void setCurrentResidualVectorTags(const std::set< TagID > &vector_tags)
Set the current residual vector tag data structure based on the passed in tag IDs.
MooseObjectWarehouse< Function > _functions
functions
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
MaterialWarehouse _all_materials
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480
void computeSystems(const ExecFlagType &type)
Do generic system computations.
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
unsigned int THREAD_ID
Definition: MooseTypes.h:209
virtual void residualSetup(THREAD_ID tid=0) const

◆ computeResidualType()

void FEProblemBase::computeResidualType ( const NumericVector< libMesh::Number > &  soln,
NumericVector< libMesh::Number > &  residual,
TagID  tag 
)
virtualinherited

Form a residual vector for a given tag and "residual" tag.

Definition at line 7254 of file FEProblemBase.C.

7257 {
7258  TIME_SECTION("computeResidualType", 5);
7259 
7260  try
7261  {
7263 
7265 
7267 
7269  }
7270  catch (MooseException & e)
7271  {
7272  // If a MooseException propagates all the way to here, it means
7273  // that it was thrown from a MOOSE system where we do not
7274  // (currently) properly support the throwing of exceptions, and
7275  // therefore we have no choice but to error out. It may be
7276  // *possible* to handle exceptions from other systems, but in the
7277  // meantime, we don't want to silently swallow any unhandled
7278  // exceptions here.
7279  mooseError("An unhandled MooseException was raised during residual computation. Please "
7280  "contact the MOOSE team for assistance.");
7281  }
7282 }
virtual void associateVectorToTag(NumericVector< Number > &vec, TagID tag)
Associate a vector for a given tag.
Definition: SystemBase.C:981
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
Definition: SolverSystem.C:67
virtual void computeResidualTags(const std::set< TagID > &tags)
Form multiple residual vectors and each is associated with one tag.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
virtual void disassociateVectorFromTag(NumericVector< Number > &vec, TagID tag)
Disassociate a given vector from a given tag.
TagID residualVectorTag() const override
Provides a way for users to bail out of the current solve.
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

◆ computeSystems()

void FEProblemBase::computeSystems ( const ExecFlagType type)
protectedinherited

Do generic system computations.

Definition at line 9506 of file FEProblemBase.C.

Referenced by FEProblemBase::computeBounds(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and FEProblemBase::execute().

9507 {
9508  // When performing an adjoint solve in the optimization module, the current solver system is the
9509  // adjoint. However, the adjoint solve requires having accurate time derivative calculations for
9510  // the forward system. The cleanest way to handle such uses is just to compute the time
9511  // derivatives for all solver systems instead of trying to guess which ones we need and don't need
9512  for (auto & solver_sys : _solver_systems)
9513  solver_sys->compute(type);
9514 
9515  _aux->compute(type);
9516 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

◆ computeTransposeNullSpace()

void FEProblemBase::computeTransposeNullSpace ( libMesh::NonlinearImplicitSystem sys,
std::vector< NumericVector< libMesh::Number > *> &  sp 
)
virtualinherited

Definition at line 7785 of file FEProblemBase.C.

Referenced by Moose::compute_transpose_nullspace().

7787 {
7788  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7789  "I expect these system numbers to be the same");
7790  sp.clear();
7791  for (unsigned int i = 0; i < subspaceDim("TransposeNullSpace"); ++i)
7792  {
7793  std::stringstream postfix;
7794  postfix << "_" << i;
7795  sp.push_back(&_current_nl_sys->getVector("TransposeNullSpace" + postfix.str()));
7796  }
7797 }
unsigned int subspaceDim(const std::string &prefix) const
Dimension of the subspace spanned by vectors with a given prefix.
unsigned int number() const
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
Definition: SystemBase.C:933

◆ computeUserObjectByName()

void FEProblemBase::computeUserObjectByName ( const ExecFlagType type,
const Moose::AuxGroup group,
const std::string &  name 
)
virtualinherited

Compute an user object with the given name.

Definition at line 4919 of file FEProblemBase.C.

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), and MultiAppConservativeTransfer::postExecute().

4922 {
4923  const auto old_exec_flag = _current_execute_on_flag;
4926  .query()
4927  .condition<AttribSystem>("UserObject")
4928  .condition<AttribExecOns>(type)
4929  .condition<AttribName>(name);
4930  computeUserObjectsInternal(type, group, query);
4931  _current_execute_on_flag = old_exec_flag;
4932 }
ExecFlagType _current_execute_on_flag
Current execute_on flag.
QueryCache is a convenient way to construct and pass around (possible partially constructed) warehous...
Definition: TheWarehouse.h:208
void computeUserObjectsInternal(const ExecFlagType &type, const Moose::AuxGroup &group, TheWarehouse::Query &query)
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
TheWarehouse & theWarehouse() const
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
query_obj query
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ computeUserObjects()

void FEProblemBase::computeUserObjects ( const ExecFlagType type,
const Moose::AuxGroup group 
)
virtualinherited

Call compute methods on UserObjects.

Definition at line 4935 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::execute(), and FEProblemBase::initialSetup().

4936 {
4938  theWarehouse().query().condition<AttribSystem>("UserObject").condition<AttribExecOns>(type);
4939  computeUserObjectsInternal(type, group, query);
4940 }
QueryCache is a convenient way to construct and pass around (possible partially constructed) warehous...
Definition: TheWarehouse.h:208
void computeUserObjectsInternal(const ExecFlagType &type, const Moose::AuxGroup &group, TheWarehouse::Query &query)
TheWarehouse & theWarehouse() const
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
query_obj query
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ computeUserObjectsInternal()

void FEProblemBase::computeUserObjectsInternal ( const ExecFlagType type,
const Moose::AuxGroup group,
TheWarehouse::Query query 
)
protectedinherited

Definition at line 4943 of file FEProblemBase.C.

Referenced by FEProblemBase::computeUserObjectByName(), and FEProblemBase::computeUserObjects().

4946 {
4947  try
4948  {
4949  TIME_SECTION("computeUserObjects", 1, "Computing User Objects");
4950 
4951  // Add group to query
4952  if (group == Moose::PRE_IC)
4953  primary_query.condition<AttribPreIC>(true);
4954  else if (group == Moose::PRE_AUX)
4955  primary_query.condition<AttribPreAux>(type);
4956  else if (group == Moose::POST_AUX)
4957  primary_query.condition<AttribPostAux>(type);
4958 
4959  // query everything first to obtain a list of execution groups
4960  std::vector<UserObject *> uos;
4961  primary_query.clone().queryIntoUnsorted(uos);
4962  std::set<int> execution_groups;
4963  for (const auto & uo : uos)
4964  execution_groups.insert(uo->getParam<int>("execution_order_group"));
4965 
4966  // iterate over execution order groups
4967  for (const auto execution_group : execution_groups)
4968  {
4969  auto query = primary_query.clone().condition<AttribExecutionOrderGroup>(execution_group);
4970 
4971  std::vector<GeneralUserObject *> genobjs;
4972  query.clone().condition<AttribInterfaces>(Interfaces::GeneralUserObject).queryInto(genobjs);
4973 
4974  std::vector<UserObject *> userobjs;
4975  query.clone()
4980  .queryInto(userobjs);
4981 
4982  std::vector<UserObject *> tgobjs;
4983  query.clone()
4985  .queryInto(tgobjs);
4986 
4987  std::vector<UserObject *> nodal;
4988  query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject).queryInto(nodal);
4989 
4990  std::vector<MortarUserObject *> mortar;
4991  query.clone().condition<AttribInterfaces>(Interfaces::MortarUserObject).queryInto(mortar);
4992 
4993  if (userobjs.empty() && genobjs.empty() && tgobjs.empty() && nodal.empty() && mortar.empty())
4994  continue;
4995 
4996  // Start the timer here since we have at least one active user object
4997  std::string compute_uo_tag = "computeUserObjects(" + Moose::stringify(type) + ")";
4998 
4999  // Perform Residual/Jacobian setups
5000  if (type == EXEC_LINEAR)
5001  {
5002  for (auto obj : userobjs)
5003  obj->residualSetup();
5004  for (auto obj : nodal)
5005  obj->residualSetup();
5006  for (auto obj : mortar)
5007  obj->residualSetup();
5008  for (auto obj : tgobjs)
5009  obj->residualSetup();
5010  for (auto obj : genobjs)
5011  obj->residualSetup();
5012  }
5013  else if (type == EXEC_NONLINEAR)
5014  {
5015  for (auto obj : userobjs)
5016  obj->jacobianSetup();
5017  for (auto obj : nodal)
5018  obj->jacobianSetup();
5019  for (auto obj : mortar)
5020  obj->jacobianSetup();
5021  for (auto obj : tgobjs)
5022  obj->jacobianSetup();
5023  for (auto obj : genobjs)
5024  obj->jacobianSetup();
5025  }
5026 
5027  for (auto obj : userobjs)
5028  obj->initialize();
5029 
5030  // Execute Side/InternalSide/Interface/Elemental/DomainUserObjects
5031  if (!userobjs.empty())
5032  {
5033  // non-nodal user objects have to be run separately before the nodal user objects run
5034  // because some nodal user objects (NodalNormal related) depend on elemental user objects
5035  // :-(
5036  ComputeUserObjectsThread cppt(*this, query);
5038 
5039  // There is one instance in rattlesnake where an elemental user object's finalize depends
5040  // on a side user object having been finalized first :-(
5047  }
5048 
5049  // if any userobject may have written to variables we need to close the aux solution
5050  for (const auto & uo : userobjs)
5051  if (auto euo = dynamic_cast<const ElementUserObject *>(uo);
5052  euo && euo->hasWritableCoupledVariables())
5053  {
5054  _aux->solution().close();
5055  _aux->system().update();
5056  break;
5057  }
5058 
5059  // Execute NodalUserObjects
5060  // BISON has an axial reloc elemental user object that has a finalize func that depends on a
5061  // nodal user object's prev value. So we can't initialize this until after elemental objects
5062  // have been finalized :-(
5063  for (auto obj : nodal)
5064  obj->initialize();
5065  if (query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject).count() > 0)
5066  {
5067  ComputeNodalUserObjectsThread cnppt(*this, query);
5070  }
5071 
5072  // if any userobject may have written to variables we need to close the aux solution
5073  for (const auto & uo : nodal)
5074  if (auto nuo = dynamic_cast<const NodalUserObject *>(uo);
5075  nuo && nuo->hasWritableCoupledVariables())
5076  {
5077  _aux->solution().close();
5078  _aux->system().update();
5079  break;
5080  }
5081 
5082  // Execute MortarUserObjects
5083  {
5084  for (auto obj : mortar)
5085  obj->initialize();
5086  if (!mortar.empty())
5087  {
5088  auto create_and_run_mortar_functors = [this, type, &mortar](const bool displaced)
5089  {
5090  // go over mortar interfaces and construct functors
5091  const auto & mortar_interfaces = getMortarInterfaces(displaced);
5092  for (const auto & mortar_interface : mortar_interfaces)
5093  {
5094  const auto primary_secondary_boundary_pair = mortar_interface.first;
5095  auto mortar_uos_to_execute =
5096  getMortarUserObjects(primary_secondary_boundary_pair.first,
5097  primary_secondary_boundary_pair.second,
5098  displaced,
5099  mortar);
5100  const auto & mortar_generation_object = mortar_interface.second;
5101 
5102  auto * const subproblem = displaced
5103  ? static_cast<SubProblem *>(_displaced_problem.get())
5104  : static_cast<SubProblem *>(this);
5105  MortarUserObjectThread muot(mortar_uos_to_execute,
5106  mortar_generation_object,
5107  *subproblem,
5108  *this,
5109  displaced,
5110  subproblem->assembly(0, 0));
5111 
5112  muot();
5113  }
5114  };
5115 
5116  create_and_run_mortar_functors(false);
5117  if (_displaced_problem)
5118  create_and_run_mortar_functors(true);
5119  }
5120  for (auto obj : mortar)
5121  obj->finalize();
5122  }
5123 
5124  // Execute threaded general user objects
5125  for (auto obj : tgobjs)
5126  obj->initialize();
5127  std::vector<GeneralUserObject *> tguos_zero;
5128  query.clone()
5129  .condition<AttribThread>(0)
5130  .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject)
5131  .queryInto(tguos_zero);
5132  for (auto obj : tguos_zero)
5133  {
5134  std::vector<GeneralUserObject *> tguos;
5135  auto q = query.clone()
5136  .condition<AttribName>(obj->name())
5137  .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject);
5138  q.queryInto(tguos);
5139 
5141  Threads::parallel_reduce(GeneralUserObjectRange(tguos.begin(), tguos.end()), ctguot);
5142  joinAndFinalize(q);
5143  }
5144 
5145  // Execute general user objects
5147  true);
5148  }
5149  }
5150  catch (...)
5151  {
5152  handleException("computeUserObjectsInternal");
5153  }
5154 }
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
Definition: MooseMesh.C:1276
void joinAndFinalize(TheWarehouse::Query query, bool isgen=false)
void parallel_reduce(const Range &range, Body &body, const Partitioner &)
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
Definition: Attributes.h:313
Thread to compute threaded general user objects.
libMesh::ConstNodeRange * getLocalNodeRange()
Definition: MooseMesh.C:1313
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
Definition: Attributes.h:294
void handleException(const std::string &calling_method)
Handle exceptions.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
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...
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
StoredRange< std::vector< GeneralUserObject * >::iterator, GeneralUserObject * > GeneralUserObjectRange
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
Definition: Attributes.h:344
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
query_obj query
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
Class for threaded computation of UserObjects.
std::shared_ptr< DisplacedProblem > _displaced_problem
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > & getMortarInterfaces(bool on_displaced) const
virtual std::unique_ptr< Attribute > clone() const =0
clone creates and returns and identical (deep) copy of this attribute - i.e.

◆ computingNonlinearResid() [1/4]

bool SubProblem::computingNonlinearResid ( ) const
inlineinherited

Returns true if the problem is in the process of computing the nonlinear residual.

Definition at line 707 of file SubProblem.h.

bool _computing_nonlinear_residual
Whether the non-linear residual is being evaluated.
Definition: SubProblem.h:1102

◆ computingNonlinearResid() [2/4]

bool SubProblem::computingNonlinearResid
inlineinherited

Returns true if the problem is in the process of computing the nonlinear residual.

Definition at line 707 of file SubProblem.h.

bool _computing_nonlinear_residual
Whether the non-linear residual is being evaluated.
Definition: SubProblem.h:1102

◆ computingNonlinearResid() [3/4]

virtual void SubProblem::computingNonlinearResid
inlineinherited

Set whether or not the problem is in the process of computing the nonlinear residual.

Definition at line 712 of file SubProblem.h.

713  {
714  _computing_nonlinear_residual = computing_nonlinear_residual;
715  }
bool _computing_nonlinear_residual
Whether the non-linear residual is being evaluated.
Definition: SubProblem.h:1102

◆ computingNonlinearResid() [4/4]

void FEProblemBase::computingNonlinearResid ( bool  computing_nonlinear_residual)
finalvirtualinherited

Set whether or not the problem is in the process of computing the nonlinear residual.

Reimplemented from SubProblem.

Definition at line 9141 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScaling(), ComputeResidualFunctor::residual(), ComputeFDResidualFunctor::residual(), and ComputeResidualAndJacobian::residual_and_jacobian().

9142 {
9143  parallel_object_only();
9144 
9145  if (_displaced_problem)
9146  _displaced_problem->computingNonlinearResid(computing_nonlinear_residual);
9147  _computing_nonlinear_residual = computing_nonlinear_residual;
9148 }
bool _computing_nonlinear_residual
Whether the non-linear residual is being evaluated.
Definition: SubProblem.h:1102
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ computingPreSMOResidual()

bool FEProblemBase::computingPreSMOResidual ( const unsigned int  nl_sys_num) const
overridevirtualinherited

Returns true if the problem is in the process of computing it's initial residual.

Returns
Whether or not the problem is currently computing the initial residual.

Implements SubProblem.

Definition at line 6741 of file FEProblemBase.C.

Referenced by DisplacedProblem::computingPreSMOResidual().

6742 {
6743  return _nl[nl_sys_num]->computingPreSMOResidual();
6744 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ computingScalingJacobian() [1/2]

void FEProblemBase::computingScalingJacobian ( bool  computing_scaling_jacobian)
inlineinherited

Setter for whether we're computing the scaling jacobian.

Definition at line 2494 of file FEProblemBase.h.

Referenced by ComputeJacobianThread::compute(), SolverSystem::compute(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeScaling(), and DisplacedProblem::computingScalingJacobian().

2495  {
2496  _computing_scaling_jacobian = computing_scaling_jacobian;
2497  }
bool _computing_scaling_jacobian
Flag used to indicate whether we are computing the scaling Jacobian.

◆ computingScalingJacobian() [2/2]

bool FEProblemBase::computingScalingJacobian ( ) const
inlinefinaloverridevirtualinherited

Getter for whether we're computing the scaling jacobian.

Implements SubProblem.

Definition at line 2499 of file FEProblemBase.h.

2499 { return _computing_scaling_jacobian; }
bool _computing_scaling_jacobian
Flag used to indicate whether we are computing the scaling Jacobian.

◆ computingScalingResidual() [1/2]

void FEProblemBase::computingScalingResidual ( bool  computing_scaling_residual)
inlineinherited

Setter for whether we're computing the scaling residual.

Definition at line 2504 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::computeScaling(), and DisplacedProblem::computingScalingResidual().

2505  {
2506  _computing_scaling_residual = computing_scaling_residual;
2507  }
bool _computing_scaling_residual
Flag used to indicate whether we are computing the scaling Residual.

◆ computingScalingResidual() [2/2]

bool FEProblemBase::computingScalingResidual ( ) const
inlinefinaloverridevirtualinherited
Returns
whether we are currently computing a residual for automatic scaling purposes

Implements SubProblem.

Definition at line 2512 of file FEProblemBase.h.

2512 { return _computing_scaling_residual; }
bool _computing_scaling_residual
Flag used to indicate whether we are computing the scaling Residual.

◆ connectControllableParams()

void MooseBase::connectControllableParams ( const std::string &  parameter,
const std::string &  object_type,
const std::string &  object_name,
const std::string &  object_parameter 
) const
inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters
parameterName of the controllable parameter of this action
object_typeType of the object added by this action.
object_nameName of the object added by this action.
object_parameterName of the parameter of the object.

Definition at line 77 of file MooseBase.C.

81 {
82  auto & factory = _app.getFactory();
83  auto & ip_warehouse = _app.getInputParameterWarehouse();
84 
85  MooseObjectParameterName primary_name(uniqueName(), parameter);
86  const auto base_type = factory.getValidParams(object_type).getBase();
87  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
88  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
89 
90  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
91  for (const auto & tag : tags)
92  {
93  if (!tag.empty())
94  {
95  // Only adds the parameter with the different control tags if the derived class
96  // properly registers the parameter to its own syntax
97  MooseObjectParameterName tagged_name(tag, name(), parameter);
98  ip_warehouse.addControllableParameterConnection(
99  tagged_name, secondary_name, /*error_on_empty=*/false);
100  }
101  }
102 }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition: MooseApp.C:2938
MooseObjectName uniqueName() const
Definition: MooseBase.C:69
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition: MooseApp.h:401
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
A class for storing an input parameter name.

◆ console()

const ConsoleStream& Problem::console ( ) const
inlineinherited

Return console handle.

Definition at line 48 of file Problem.h.

Referenced by Moose::SlepcSupport::mooseSlepcEPSMonitor(), ComputeMarkerThread::printBlockExecutionInformation(), ComputeDiracThread::printBlockExecutionInformation(), ComputeIndicatorThread::printBlockExecutionInformation(), ComputeUserObjectsThread::printBlockExecutionInformation(), ComputeLinearFVElementalThread::printBlockExecutionInformation(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), NonlinearThread::printBlockExecutionInformation(), NonlinearThread::printBoundaryExecutionInformation(), ComputeFVInitialConditionThread::printGeneralExecutionInformation(), ComputeInitialConditionThread::printGeneralExecutionInformation(), ComputeNodalUserObjectsThread::printGeneralExecutionInformation(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeNodalKernelsThread::printGeneralExecutionInformation(), ComputeElemDampingThread::printGeneralExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), ComputeNodalDampingThread::printGeneralExecutionInformation(), ComputeMarkerThread::printGeneralExecutionInformation(), ComputeDiracThread::printGeneralExecutionInformation(), ComputeIndicatorThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), ComputeThreadedGeneralUserObjectsThread::printGeneralExecutionInformation(), ComputeUserObjectsThread::printGeneralExecutionInformation(), ComputeLinearFVElementalThread::printGeneralExecutionInformation(), ComputeLinearFVFaceThread::printGeneralExecutionInformation(), and NonlinearThread::printGeneralExecutionInformation().

48 { return _console; }
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.

◆ constJacobian()

bool FEProblemBase::constJacobian ( ) const
inherited

Returns _const_jacobian (whether a MOOSE object has specified that the Jacobian is the same as the previous time it was computed)

Definition at line 8974 of file FEProblemBase.C.

Referenced by Moose::SlepcSupport::moosePetscSNESFormMatricesTags(), and Moose::SlepcSupport::moosePetscSNESFormMatrixTag().

8975 {
8976  return _const_jacobian;
8977 }
bool _const_jacobian
true if the Jacobian is constant

◆ converged()

virtual bool SubProblem::converged ( const unsigned int  sys_num)
inlinevirtualinherited

Eventually we want to convert this virtual over to taking a solver system number argument.

We will have to first convert apps to use solverSystemConverged, and then once that is done, we can change this signature. Then we can go through the apps again and convert back to this changed API

Definition at line 113 of file SubProblem.h.

Referenced by FEProblemBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), EigenExecutionerBase::nonlinearSolve(), FEProblemSolve::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), DisplacedProblem::solverSystemConverged(), SubProblem::solverSystemConverged(), and AB2PredictorCorrector::step().

113 { return solverSystemConverged(sys_num); }
virtual bool solverSystemConverged(const unsigned int sys_num)
Definition: SubProblem.h:100

◆ coordTransform()

MooseAppCoordTransform & FEProblemBase::coordTransform ( )
inherited
Returns
the coordinate transformation object that describes how to transform this problem's coordinate system into the canonical/reference coordinate system

Definition at line 9377 of file FEProblemBase.C.

9378 {
9379  return mesh().coordTransform();
9380 }
MooseAppCoordTransform & coordTransform()
Definition: MooseMesh.h:1931
virtual MooseMesh & mesh() override

◆ copySolutionsBackwards()

void FEProblemBase::copySolutionsBackwards ( )
virtualinherited

Definition at line 6747 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

6748 {
6749  TIME_SECTION("copySolutionsBackwards", 3, "Copying Solutions Backward");
6750 
6751  for (auto & sys : _solver_systems)
6752  sys->copySolutionsBackwards();
6753  _aux->copySolutionsBackwards();
6754 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ coupling()

Moose::CouplingType FEProblemBase::coupling ( ) const
inlineinherited

Definition at line 177 of file FEProblemBase.h.

Referenced by DiffusionLHDGAssemblyHelper::checkCoupling(), and NonlinearSystemBase::computeJacobianInternal().

177 { return _coupling; }
Moose::CouplingType _coupling
Type of variable coupling.

◆ couplingEntries()

std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & FEProblemBase::couplingEntries ( const THREAD_ID  tid,
const unsigned int  nl_sys_num 
)
inherited

◆ couplingMatrix()

const libMesh::CouplingMatrix * FEProblemBase::couplingMatrix ( const unsigned int  nl_sys_num) const
inlineoverridevirtualinherited

The coupling matrix defining what blocks exist in the preconditioning matrix.

Implements SubProblem.

Definition at line 3446 of file FEProblemBase.h.

Referenced by DiffusionLHDGAssemblyHelper::checkCoupling(), DisplacedProblem::couplingMatrix(), and DisplacedProblem::init().

3447 {
3448  return _cm[i].get();
3449 }
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
Coupling matrix for variables.

◆ createMortarInterface()

void FEProblemBase::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 
)
inherited

Definition at line 7960 of file FEProblemBase.C.

7968 {
7969  _has_mortar = true;
7970 
7971  if (on_displaced)
7972  return _mortar_data.createMortarInterface(primary_secondary_boundary_pair,
7973  primary_secondary_subdomain_pair,
7975  on_displaced,
7976  periodic,
7977  debug,
7978  correct_edge_dropping,
7979  minimum_projection_angle);
7980  else
7981  return _mortar_data.createMortarInterface(primary_secondary_boundary_pair,
7982  primary_secondary_subdomain_pair,
7983  *this,
7984  on_displaced,
7985  periodic,
7986  debug,
7987  correct_edge_dropping,
7988  minimum_projection_angle);
7989 }
void createMortarInterface(const std::pair< BoundaryID, BoundaryID > &boundary_key, const std::pair< SubdomainID, SubdomainID > &subdomain_key, SubProblem &subproblem, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle)
Create mortar generation object.
Definition: MortarData.C:22
MortarData _mortar_data
std::shared_ptr< DisplacedProblem > _displaced_problem
bool _has_mortar
Whether the simulation requires mortar coupling.

◆ createQRules()

void FEProblemBase::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 
)
virtualinherited

Definition at line 6167 of file FEProblemBase.C.

6173 {
6174  if (order == INVALID_ORDER)
6175  {
6176  // automatically determine the integration order
6177  order = _solver_systems[0]->getMinQuadratureOrder();
6178  for (const auto i : make_range(std::size_t(1), _solver_systems.size()))
6179  if (order < _solver_systems[i]->getMinQuadratureOrder())
6180  order = _solver_systems[i]->getMinQuadratureOrder();
6181  if (order < _aux->getMinQuadratureOrder())
6182  order = _aux->getMinQuadratureOrder();
6183  }
6184 
6185  if (volume_order == INVALID_ORDER)
6186  volume_order = order;
6187 
6188  if (face_order == INVALID_ORDER)
6189  face_order = order;
6190 
6191  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
6192  for (const auto i : index_range(_solver_systems))
6193  _assembly[tid][i]->createQRules(
6194  type, order, volume_order, face_order, block, allow_negative_qweights);
6195 
6196  if (_displaced_problem)
6197  _displaced_problem->createQRules(
6198  type, order, volume_order, face_order, block, allow_negative_qweights);
6199 
6200  updateMaxQps();
6201 }
unsigned int n_threads()
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
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)
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
IntRange< T > make_range(T beg, T end)
std::shared_ptr< DisplacedProblem > _displaced_problem
auto index_range(const T &sizable)

◆ createTagMatrices()

void FEProblemBase::createTagMatrices ( CreateTaggedMatrixKey  )
inherited

Definition at line 694 of file FEProblemBase.C.

695 {
696  auto & matrices = getParam<std::vector<std::vector<TagName>>>("extra_tag_matrices");
697  for (const auto sys_num : index_range(matrices))
698  for (auto & matrix : matrices[sys_num])
699  {
700  auto tag = addMatrixTag(matrix);
701  _solver_systems[sys_num]->addMatrix(tag);
702  }
703 
704  for (auto & sys : _solver_systems)
705  sys->sizeVariableMatrixData();
706  _aux->sizeVariableMatrixData();
707 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
virtual TagID addMatrixTag(TagName tag_name)
Create a Tag.
Definition: SubProblem.C:311
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
auto index_range(const T &sizable)

◆ createTagSolutions()

void FEProblemBase::createTagSolutions ( )
protectedinherited

Create extra tagged solution vectors.

Definition at line 710 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), and FEProblem::FEProblem().

711 {
712  for (auto & vector : getParam<std::vector<TagName>>("extra_tag_solutions"))
713  {
714  auto tag = addVectorTag(vector, Moose::VECTOR_TAG_SOLUTION);
715  for (auto & sys : _solver_systems)
716  sys->addVector(tag, false, libMesh::GHOSTED);
717  _aux->addVector(tag, false, libMesh::GHOSTED);
718  }
719 
721  {
722  // We'll populate the zeroth state of the nonlinear iterations with the current solution for
723  // ease of use in doing things like copying solutions backwards. We're just storing pointers in
724  // the solution states containers so populating the zeroth state does not cost us the memory of
725  // a new vector
727  }
728 
730  for (auto & sys : _solver_systems)
731  sys->associateVectorToTag(*sys->system().current_local_solution.get(), tag);
732  _aux->associateVectorToTag(*_aux->system().current_local_solution.get(), tag);
733 }
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBase.h:388
virtual TagID addVectorTag(const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
Create a Tag.
Definition: SubProblem.C:92
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
bool _previous_nl_solution_required
Indicates we need to save the previous NL iteration variable values.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
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...
const TagName SOLUTION_TAG
Definition: MooseTypes.C:25

◆ createTagVectors()

void FEProblemBase::createTagVectors ( )
protectedinherited

Create extra tagged vectors and matrices.

Definition at line 672 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), and FEProblem::FEProblem().

673 {
674  // add vectors and their tags to system
675  auto & vectors = getParam<std::vector<std::vector<TagName>>>("extra_tag_vectors");
676  for (const auto sys_num : index_range(vectors))
677  for (auto & vector : vectors[sys_num])
678  {
679  auto tag = addVectorTag(vector);
680  _solver_systems[sys_num]->addVector(tag, false, libMesh::GHOSTED);
681  }
682 
683  auto & not_zeroed_vectors = getParam<std::vector<std::vector<TagName>>>("not_zeroed_tag_vectors");
684  for (const auto sys_num : index_range(not_zeroed_vectors))
685  for (auto & vector : not_zeroed_vectors[sys_num])
686  {
687  auto tag = addVectorTag(vector);
688  _solver_systems[sys_num]->addVector(tag, false, GHOSTED);
690  }
691 }
virtual TagID addVectorTag(const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
Create a Tag.
Definition: SubProblem.C:92
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
auto index_range(const T &sizable)
void addNotZeroedVectorTag(const TagID tag)
Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are...
Definition: SubProblem.C:149

◆ currentLinearSysNum()

unsigned int FEProblemBase::currentLinearSysNum ( ) const
overridevirtualinherited
Returns
the current linear system number

Implements SubProblem.

Definition at line 9394 of file FEProblemBase.C.

Referenced by DisplacedProblem::currentLinearSysNum().

9395 {
9396  // If we don't have linear systems this should be an invalid number
9397  unsigned int current_linear_sys_num = libMesh::invalid_uint;
9398  if (_linear_systems.size())
9399  current_linear_sys_num = currentLinearSystem().number();
9400 
9401  return current_linear_sys_num;
9402 }
const unsigned int invalid_uint
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
LinearSystem & currentLinearSystem()
Get a non-constant reference to the current linear system.
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.

◆ currentLinearSystem() [1/2]

LinearSystem & FEProblemBase::currentLinearSystem ( )
inlineinherited

Get a non-constant reference to the current linear system.

Definition at line 3414 of file FEProblemBase.h.

Referenced by FEProblemBase::currentLinearSysNum(), and Moose::PetscSupport::petscLinearConverged().

3415 {
3416  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3417  return *_current_linear_sys;
3418 }
LinearSystem * _current_linear_sys
The current linear system that we are solving.

◆ currentLinearSystem() [2/2]

const LinearSystem & FEProblemBase::currentLinearSystem ( ) const
inlineinherited

Get a constant reference to the current linear system.

Definition at line 3421 of file FEProblemBase.h.

3422 {
3423  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3424  return *_current_linear_sys;
3425 }
LinearSystem * _current_linear_sys
The current linear system that we are solving.

◆ currentlyComputingJacobian()

const bool& SubProblem::currentlyComputingJacobian ( ) const
inlineinherited

Returns true if the problem is in the process of computing the Jacobian.

Definition at line 684 of file SubProblem.h.

Referenced by PenetrationLocator::detectPenetration(), ComputeUserObjectsThread::onBoundary(), ComputeUserObjectsThread::onElement(), ComputeUserObjectsThread::printBlockExecutionInformation(), SubProblem::reinitElemFaceRef(), and NEML2Utils::shouldCompute().

bool _currently_computing_jacobian
Flag to determine whether the problem is currently computing Jacobian.
Definition: SubProblem.h:1096

◆ currentlyComputingResidual() [1/2]

const bool& SubProblem::currentlyComputingResidual ( ) const
inlineinherited

Returns true if the problem is in the process of computing the residual.

Definition at line 720 of file SubProblem.h.

bool _currently_computing_residual
Whether the residual is being evaluated.
Definition: SubProblem.h:1105

◆ currentlyComputingResidual() [2/2]

const bool& SubProblem::currentlyComputingResidual
inlineinherited

Returns true if the problem is in the process of computing the residual.

Definition at line 720 of file SubProblem.h.

bool _currently_computing_residual
Whether the residual is being evaluated.
Definition: SubProblem.h:1105

◆ currentlyComputingResidualAndJacobian()

const bool & SubProblem::currentlyComputingResidualAndJacobian ( ) const
inlineinherited

Returns true if the problem is in the process of computing the residual and the Jacobian.

Definition at line 1487 of file SubProblem.h.

Referenced by SubProblem::reinitElemFaceRef(), and NEML2Utils::shouldCompute().

1488 {
1490 }
bool _currently_computing_residual_and_jacobian
Flag to determine whether the problem is currently computing the residual and Jacobian.
Definition: SubProblem.h:1099

◆ currentNlSysNum()

unsigned int FEProblemBase::currentNlSysNum ( ) const
overridevirtualinherited
Returns
the current nonlinear system number

Implements SubProblem.

Definition at line 9383 of file FEProblemBase.C.

Referenced by DisplacedProblem::currentNlSysNum(), FEProblemBase::jacobianSetup(), and FEProblemBase::residualSetup().

9384 {
9385  // If we don't have nonlinear systems this should be an invalid number
9386  unsigned int current_nl_sys_num = libMesh::invalid_uint;
9387  if (_nl.size())
9388  current_nl_sys_num = currentNonlinearSystem().number();
9389 
9390  return current_nl_sys_num;
9391 }
const unsigned int invalid_uint
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
NonlinearSystemBase & currentNonlinearSystem()
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157

◆ currentNonlinearSystem() [1/2]

NonlinearSystemBase & FEProblemBase::currentNonlinearSystem ( )
inlineinherited

◆ currentNonlinearSystem() [2/2]

const NonlinearSystemBase & FEProblemBase::currentNonlinearSystem ( ) const
inlineinherited

Definition at line 3391 of file FEProblemBase.h.

3392 {
3393  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3394  return *_current_nl_sys;
3395 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.

◆ currentResidualVectorTags()

const std::vector< VectorTag > & FEProblemBase::currentResidualVectorTags ( ) const
inlineoverridevirtualinherited

Return the residual vector tags we are currently computing.

Implements SubProblem.

Definition at line 3462 of file FEProblemBase.h.

Referenced by FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), and DisplacedProblem::currentResidualVectorTags().

3463 {
3465 }
std::vector< VectorTag > _current_residual_vector_tags
A data member to store the residual vector tag(s) passed into computeResidualTag(s).

◆ customSetup()

void FEProblemBase::customSetup ( const ExecFlagType exec_type)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 4719 of file FEProblemBase.C.

Referenced by FEProblemBase::execute().

4720 {
4721  SubProblem::customSetup(exec_type);
4722 
4723  if (_line_search)
4724  _line_search->customSetup(exec_type);
4725 
4726  unsigned int n_threads = libMesh::n_threads();
4727  for (THREAD_ID tid = 0; tid < n_threads; tid++)
4728  {
4729  _all_materials.customSetup(exec_type, tid);
4730  _functions.customSetup(exec_type, tid);
4731  }
4732 
4733  _aux->customSetup(exec_type);
4734  for (auto & nl : _nl)
4735  nl->customSetup(exec_type);
4736 
4737  if (_displaced_problem)
4738  _displaced_problem->customSetup(exec_type);
4739 
4740  for (THREAD_ID tid = 0; tid < n_threads; tid++)
4741  {
4742  _internal_side_indicators.customSetup(exec_type, tid);
4743  _indicators.customSetup(exec_type, tid);
4744  _markers.customSetup(exec_type, tid);
4745  }
4746 
4747  std::vector<UserObject *> userobjs;
4748  theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(userobjs);
4749  for (auto obj : userobjs)
4750  obj->customSetup(exec_type);
4751 
4752  _app.getOutputWarehouse().customSetup(exec_type);
4753 }
unsigned int n_threads()
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
virtual void customSetup(const ExecFlagType &exec_type, THREAD_ID tid=0) const
void customSetup(const ExecFlagType &exec_type)
Calls the setup function for each of the output objects.
virtual void customSetup(const ExecFlagType &exec_type)
Definition: SubProblem.C:1193
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
TheWarehouse & theWarehouse() const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
MooseObjectWarehouse< Indicator > _indicators
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseObjectWarehouse< Function > _functions
functions
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284
MooseObjectWarehouse< Marker > _markers
MaterialWarehouse _all_materials
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480
unsigned int THREAD_ID
Definition: MooseTypes.h:209
std::shared_ptr< LineSearch > _line_search

◆ declareManagedRestartableDataWithContext()

template<typename T , typename... Args>
Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext ( const std::string &  data_name,
void context,
Args &&...  args 
)
protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

286 {
287  auto & data_ptr =
288  declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
289  return Restartable::ManagedValue<T>(data_ptr);
290 }
Wrapper class for restartable data that is "managed.
Definition: Restartable.h:42

◆ declareRecoverableData()

template<typename T , typename... Args>
T & Restartable::declareRecoverableData ( const std::string &  data_name,
Args &&...  args 
)
protectedinherited

Declare a piece of data as "recoverable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
argsArguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

359 {
360  const auto full_name = restartableName(data_name);
361 
363 
364  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
365 }
std::string restartableName(const std::string &data_name) const
Gets the name of a piece of restartable data given a data name, adding the system name and object nam...
Definition: Restartable.C:78
void registerRestartableNameWithFilterOnApp(const std::string &name, Moose::RESTARTABLE_FILTER filter)
Helper function for actually registering the restartable data.
Definition: Restartable.C:71

◆ declareRestartableData()

template<typename T , typename... Args>
T & Restartable::declareRestartableData ( const std::string &  data_name,
Args &&...  args 
)
protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
argsArguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

277 {
278  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
279 }

◆ declareRestartableDataWithContext()

template<typename T , typename... Args>
T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name,
void context,
Args &&...  args 
)
protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
contextContext pointer that will be passed to the load and store functions
argsArguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

304 {
305  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
306 }

◆ declareRestartableDataWithObjectName()

template<typename T , typename... Args>
T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name,
const std::string &  object_name,
Args &&...  args 
)
protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
object_nameA supplied name for the object that is declaring this data.
argsArguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

333 {
334  return declareRestartableDataWithObjectNameWithContext<T>(
335  data_name, object_name, nullptr, std::forward<Args>(args)...);
336 }

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>
T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name,
const std::string &  object_name,
void context,
Args &&...  args 
)
protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
object_nameA supplied name for the object that is declaring this data.
contextContext pointer that will be passed to the load and store functions
argsArguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

344 {
345  std::string old_name = _restartable_name;
346 
347  _restartable_name = object_name;
348 
349  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);
350 
351  _restartable_name = old_name;
352 
353  return value;
354 }
std::string _restartable_name
The name of the object.
Definition: Restartable.h:250
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ defaultGhosting()

bool SubProblem::defaultGhosting ( )
inlineinherited

Whether or not the user has requested default ghosting ot be on.

Definition at line 144 of file SubProblem.h.

Referenced by AuxiliarySystem::AuxiliarySystem(), DisplacedSystem::DisplacedSystem(), and NonlinearSystemBase::NonlinearSystemBase().

144 { return _default_ghosting; }
bool _default_ghosting
Whether or not to use default libMesh coupling.
Definition: SubProblem.h:1090

◆ diracKernelInfo()

DiracKernelInfo & SubProblem::diracKernelInfo ( )
virtualinherited

Definition at line 748 of file SubProblem.C.

749 {
750  return _dirac_kernel_info;
751 }
DiracKernelInfo _dirac_kernel_info
Definition: SubProblem.h:1049

◆ displaceMesh()

void MFEMProblem::displaceMesh ( )

Displace the mesh, if mesh displacement is enabled.

Definition at line 433 of file MFEMProblem.C.

Referenced by MFEMProblemSolve::solve().

434 {
435  // Displace mesh
436  if (mesh().shouldDisplace())
437  {
438  mesh().displace(static_cast<mfem::GridFunction const &>(*getMeshDisplacementGridFunction()));
439  // TODO: update FESpaces GridFunctions etc for transient solves
440  }
441 }
virtual MFEMMesh & mesh() override
Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMes...
Definition: MFEMProblem.C:465
void displace(mfem::GridFunction const &displacement)
Displace the nodes of the mesh by the given displacement.
Definition: MFEMMesh.C:76
std::optional< std::reference_wrapper< mfem::ParGridFunction const > > getMeshDisplacementGridFunction()
Returns optional reference to the displacement GridFunction to apply to nodes.
Definition: MFEMProblem.C:444

◆ doingPRefinement()

bool SubProblem::doingPRefinement ( ) const
inherited
Returns
whether we're doing p-refinement

Definition at line 1361 of file SubProblem.C.

Referenced by FEProblemBase::meshChanged().

1362 {
1363  return mesh().doingPRefinement();
1364 }
virtual MooseMesh & mesh()=0
void doingPRefinement(bool doing_p_refinement)
Indicate whether the kind of adaptivity we&#39;re doing is p-refinement.
Definition: MooseMesh.h:1373

◆ dt()

virtual Real& FEProblemBase::dt ( ) const
inlinevirtualinherited

◆ dtOld()

virtual Real& FEProblemBase::dtOld ( ) const
inlinevirtualinherited

Definition at line 542 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep().

542 { return _dt_old; }

◆ duplicateVariableCheck()

bool FEProblemBase::duplicateVariableCheck ( const std::string &  var_name,
const libMesh::FEType type,
bool  is_aux,
const std::set< SubdomainID > *const  active_subdomains 
)
protectedinherited

Helper to check for duplicate variable names across systems or within a single system.

Definition at line 2771 of file FEProblemBase.C.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), and FEProblemBase::addVariable().

2775 {
2776  std::set<SubdomainID> subdomainIDs;
2777  if (active_subdomains->size() == 0)
2778  {
2779  const auto subdomains = _mesh.meshSubdomains();
2780  subdomainIDs.insert(subdomains.begin(), subdomains.end());
2781  }
2782  else
2783  subdomainIDs.insert(active_subdomains->begin(), active_subdomains->end());
2784 
2785  for (auto & sys : _solver_systems)
2786  {
2787  SystemBase * curr_sys_ptr = sys.get();
2788  SystemBase * other_sys_ptr = _aux.get();
2789  std::string error_prefix = "";
2790  if (is_aux)
2791  {
2792  curr_sys_ptr = _aux.get();
2793  other_sys_ptr = sys.get();
2794  error_prefix = "aux";
2795  }
2796 
2797  if (other_sys_ptr->hasVariable(var_name))
2798  mooseError("Cannot have an auxiliary variable and a solver variable with the same name: ",
2799  var_name);
2800 
2801  if (curr_sys_ptr->hasVariable(var_name))
2802  {
2803  const Variable & var =
2804  curr_sys_ptr->system().variable(curr_sys_ptr->system().variable_number(var_name));
2805 
2806  // variable type
2807  if (var.type() != type)
2808  {
2809  const auto stringifyType = [](FEType t)
2810  { return Moose::stringify(t.family) + " of order " + Moose::stringify(t.order); };
2811 
2812  mooseError("Mismatching types are specified for ",
2813  error_prefix,
2814  "variable with name '",
2815  var_name,
2816  "': '",
2817  stringifyType(var.type()),
2818  "' and '",
2819  stringifyType(type),
2820  "'");
2821  }
2822 
2823  // block-restriction
2824  if (!(active_subdomains->size() == 0 && var.active_subdomains().size() == 0))
2825  {
2826  const auto varActiveSubdomains = var.active_subdomains();
2827  std::set<SubdomainID> varSubdomainIDs;
2828  if (varActiveSubdomains.size() == 0)
2829  {
2830  const auto subdomains = _mesh.meshSubdomains();
2831  varSubdomainIDs.insert(subdomains.begin(), subdomains.end());
2832  }
2833  else
2834  varSubdomainIDs.insert(varActiveSubdomains.begin(), varActiveSubdomains.end());
2835 
2836  // Is subdomainIDs a subset of varSubdomainIDs? With this we allow the case that the newly
2837  // requested block restriction is only a subset of the existing one.
2838  const auto isSubset = std::includes(varSubdomainIDs.begin(),
2839  varSubdomainIDs.end(),
2840  subdomainIDs.begin(),
2841  subdomainIDs.end());
2842 
2843  if (!isSubset)
2844  {
2845  // helper function: make a string from a set of subdomain ids
2846  const auto stringifySubdomains = [this](std::set<SubdomainID> subdomainIDs)
2847  {
2848  std::stringstream s;
2849  for (auto const i : subdomainIDs)
2850  {
2851  // do we need to insert a comma?
2852  if (s.tellp() != 0)
2853  s << ", ";
2854 
2855  // insert subdomain name and id -or- only the id (if no name is given)
2856  const auto subdomainName = _mesh.getSubdomainName(i);
2857  if (subdomainName.empty())
2858  s << i;
2859  else
2860  s << subdomainName << " (" << i << ")";
2861  }
2862  return s.str();
2863  };
2864 
2865  const std::string msg = "Mismatching block-restrictions are specified for " +
2866  error_prefix + "variable with name '" + var_name + "': {" +
2867  stringifySubdomains(varSubdomainIDs) + "} and {" +
2868  stringifySubdomains(subdomainIDs) + "}";
2869 
2870  mooseError(msg);
2871  }
2872  }
2873 
2874  return true;
2875  }
2876  }
2877 
2878  return false;
2879 }
const Variable & variable(unsigned int var) const
virtual libMesh::System & system()=0
Get the reference to the libMesh system.
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
Base class for a system (of equations)
Definition: SystemBase.h:84
const std::string & getSubdomainName(SubdomainID subdomain_id) const
Return the name of a block given an id.
Definition: MooseMesh.C:1801
unsigned int variable_number(std::string_view var) const
const std::set< subdomain_id_type > & active_subdomains() const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
Definition: SystemBase.C:851
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
const std::set< SubdomainID > & meshSubdomains() const
Returns a read-only reference to the set of subdomains currently present in the Mesh.
Definition: MooseMesh.C:3211
const FEType & type() const

◆ enabled()

virtual bool MooseObject::enabled ( ) const
inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 46 of file MooseObject.h.

Referenced by EigenKernel::enabled().

46 { return _enabled; }
const bool & _enabled
Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.
Definition: MooseObject.h:80

◆ errorOnJacobianNonzeroReallocation()

bool FEProblemBase::errorOnJacobianNonzeroReallocation ( ) const
inlineinherited

Will return True if the user wants to get an error when a nonzero is reallocated in the Jacobian by PETSc.

Definition at line 2095 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::constraintJacobians().

2096  {
2098  }
bool _error_on_jacobian_nonzero_reallocation
Whether to error when the Jacobian is re-allocated, usually because the sparsity pattern changed...

◆ errorPrefix()

std::string MooseBase::errorPrefix ( const std::string &  ) const
inlineinherited

Deprecated message prefix; the error type is no longer used.

Definition at line 264 of file MooseBase.h.

264 { return messagePrefix(); }
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

◆ es()

virtual libMesh::EquationSystems& FEProblemBase::es ( )
inlineoverridevirtualinherited

◆ execMultiApps()

bool FEProblemBase::execMultiApps ( ExecFlagType  type,
bool  auto_advance = true 
)
inherited

Execute the MultiApps associated with the ExecFlagType.

Definition at line 5563 of file FEProblemBase.C.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), MFEMSteady::execute(), TransientBase::execute(), SteadyBase::execute(), Eigenvalue::execute(), FEProblemBase::initialSetup(), EigenExecutionerBase::postExecute(), MFEMProblemSolve::solve(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

5564 {
5565  // Active MultiApps
5566  const std::vector<MooseSharedPointer<MultiApp>> & multi_apps =
5568 
5569  // Do anything that needs to be done to Apps before transfers
5570  for (const auto & multi_app : multi_apps)
5571  multi_app->preTransfer(_dt, _time);
5572 
5573  // Execute Transfers _to_ MultiApps
5575 
5576  // Execute Transfers _between_ Multiapps
5578 
5579  // Execute MultiApps
5580  if (multi_apps.size())
5581  {
5582  TIME_SECTION("execMultiApps", 1, "Executing MultiApps", false);
5583 
5584  if (_verbose_multiapps)
5585  _console << COLOR_CYAN << "\nExecuting MultiApps on " << Moose::stringify(type)
5586  << COLOR_DEFAULT << std::endl;
5587 
5588  bool success = true;
5589 
5590  for (const auto & multi_app : multi_apps)
5591  {
5592  success = multi_app->solveStep(_dt, _time, auto_advance);
5593  // no need to finish executing the subapps if one fails
5594  if (!success)
5595  break;
5596  }
5597 
5599 
5600  _communicator.min(success);
5601 
5602  if (!success)
5603  return false;
5604 
5605  if (_verbose_multiapps)
5606  _console << COLOR_CYAN << "Finished Executing MultiApps on " << Moose::stringify(type) << "\n"
5607  << COLOR_DEFAULT << std::endl;
5608  }
5609 
5610  // Execute Transfers _from_ MultiApps
5612 
5613  // If we made it here then everything passed
5614  return true;
5615 }
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.
const Parallel::Communicator & _communicator
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...
void min(const T &r, T &o, Request &req) const
void parallelBarrierNotify(const libMesh::Parallel::Communicator &comm, bool messaging=true)
This function implements a parallel barrier function but writes progress to stdout.
Definition: MooseUtils.C:323
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
void execMultiAppTransfers(ExecFlagType type, Transfer::DIRECTION direction)
Execute MultiAppTransfers associated with execution flag and direction.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool _verbose_multiapps
Whether or not to be verbose with multiapps.

◆ execMultiAppTransfers()

void FEProblemBase::execMultiAppTransfers ( ExecFlagType  type,
Transfer::DIRECTION  direction 
)
inherited

Execute MultiAppTransfers associated with execution flag and direction.

Parameters
typeThe execution flag to execute.
directionThe direction (to or from) to transfer.

Definition at line 5463 of file FEProblemBase.C.

Referenced by FEProblemBase::execMultiApps().

5464 {
5465  bool to_multiapp = direction == MultiAppTransfer::TO_MULTIAPP;
5466  bool from_multiapp = direction == MultiAppTransfer::FROM_MULTIAPP;
5467  std::string string_direction;
5468  if (to_multiapp)
5469  string_direction = " To ";
5470  else if (from_multiapp)
5471  string_direction = " From ";
5472  else
5473  string_direction = " Between ";
5474 
5475  const MooseObjectWarehouse<Transfer> & wh = to_multiapp ? _to_multi_app_transfers[type]
5476  : from_multiapp ? _from_multi_app_transfers[type]
5478 
5479  if (wh.hasActiveObjects())
5480  {
5481  TIME_SECTION("execMultiAppTransfers", 1, "Executing Transfers");
5482 
5483  const auto & transfers = wh.getActiveObjects();
5484 
5485  if (_verbose_multiapps)
5486  {
5487  _console << COLOR_CYAN << "\nTransfers on " << Moose::stringify(type) << string_direction
5488  << "MultiApps" << COLOR_DEFAULT << ":" << std::endl;
5489 
5491  {"Name", "Type", "From", "To"});
5492 
5493  // Build Table of Transfer Info
5494  for (const auto & transfer : transfers)
5495  {
5496  auto multiapp_transfer = dynamic_cast<MultiAppTransfer *>(transfer.get());
5497 
5498  table.addRow(multiapp_transfer->name(),
5499  multiapp_transfer->type(),
5500  multiapp_transfer->getFromName(),
5501  multiapp_transfer->getToName());
5502  }
5503 
5504  // Print it
5505  table.print(_console);
5506  }
5507 
5508  for (const auto & transfer : transfers)
5509  {
5510  transfer->setCurrentDirection(direction);
5511  transfer->execute();
5512  }
5513 
5515 
5516  if (_verbose_multiapps)
5517  _console << COLOR_CYAN << "Transfers on " << Moose::stringify(type) << " Are Finished\n"
5518  << COLOR_DEFAULT << std::endl;
5519  }
5520  else if (_multi_apps[type].getActiveObjects().size())
5521  {
5522  if (_verbose_multiapps)
5523  _console << COLOR_CYAN << "\nNo Transfers on " << Moose::stringify(type) << string_direction
5524  << "MultiApps\n"
5525  << COLOR_DEFAULT << std::endl;
5526  }
5527 }
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.
A class for "pretty printing" a table of data.
Definition: PerfGraph.h:34
void setCurrentDirection(const int direction)
Set this Transfer to be executed in a given direction.
Definition: Transfer.h:89
const Parallel::Communicator & _communicator
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
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...
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
void parallelBarrierNotify(const libMesh::Parallel::Communicator &comm, bool messaging=true)
This function implements a parallel barrier function but writes progress to stdout.
Definition: MooseUtils.C:323
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
bool hasActiveObjects(THREAD_ID tid=0) const
Base class for all MultiAppTransfer objects.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.
bool _verbose_multiapps
Whether or not to be verbose with multiapps.

◆ execTransfers()

void FEProblemBase::execTransfers ( ExecFlagType  type)
inherited

Execute the Transfers associated with the ExecFlagType.

Note: This does not execute MultiApp Transfers! Those are executed automatically when MultiApps are executed.

Definition at line 5733 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::initialSetup(), FixedPointSolve::solve(), MFEMProblemSolve::solve(), and FixedPointSolve::solveStep().

5734 {
5735  if (_transfers[type].hasActiveObjects())
5736  {
5737  TIME_SECTION("execTransfers", 3, "Executing Transfers");
5738 
5739  const auto & transfers = _transfers[type].getActiveObjects();
5740 
5741  for (const auto & transfer : transfers)
5742  transfer->execute();
5743  }
5744 }
ExecuteMooseObjectWarehouse< Transfer > _transfers
Normal Transfers.
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...
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

◆ execute()

void FEProblemBase::execute ( const ExecFlagType exec_type)
virtualinherited

Convenience function for performing execution of MOOSE systems.

Reimplemented in EigenProblem, and DumpObjectsProblem.

Definition at line 4756 of file FEProblemBase.C.

Referenced by EigenExecutionerBase::chebyshev(), FixedPointSolve::examineFixedPointConvergence(), MFEMSteady::execute(), SteadyBase::execute(), TransientBase::execute(), EigenProblem::execute(), NonlinearEigen::init(), MFEMSteady::init(), Steady::init(), EigenExecutionerBase::init(), TransientBase::init(), FEProblemBase::initialSetup(), EigenExecutionerBase::makeBXConsistent(), EigenExecutionerBase::normalizeSolution(), Moose::PetscSupport::petscLinearConverged(), Moose::PetscSupport::petscNonlinearConverged(), EigenExecutionerBase::postExecute(), FixedPointSolve::solve(), MFEMProblemSolve::solve(), FixedPointSolve::solveStep(), InversePowerMethod::takeStep(), and NonlinearEigen::takeStep().

4757 {
4758  // Set the current flag
4759  setCurrentExecuteOnFlag(exec_type);
4760 
4761  if (exec_type != EXEC_INITIAL)
4762  executeControls(exec_type);
4763 
4764  // intentially call this after executing controls because the setups may rely on the controls
4765  // FIXME: we skip the following flags because they have dedicated setup functions in
4766  // SetupInterface and it may not be appropriate to call them here.
4767  if (!(exec_type == EXEC_INITIAL || exec_type == EXEC_TIMESTEP_BEGIN ||
4768  exec_type == EXEC_SUBDOMAIN || exec_type == EXEC_NONLINEAR || exec_type == EXEC_LINEAR))
4769  customSetup(exec_type);
4770 
4771  // Samplers; EXEC_INITIAL is not called because the Sampler::init() method that is called after
4772  // construction makes the first Sampler::execute() call. This ensures that the random number
4773  // generator object is the correct state prior to any other object (e.g., Transfers) attempts to
4774  // extract data from the Sampler. That is, if the Sampler::execute() call is delayed to here
4775  // then it is not in the correct state for other objects.
4776  if (exec_type != EXEC_INITIAL)
4777  executeSamplers(exec_type);
4778 
4779  // Pre-aux UserObjects
4780  computeUserObjects(exec_type, Moose::PRE_AUX);
4781 
4782  // Systems (includes system time derivative and aux kernel calculations)
4783  computeSystems(exec_type);
4784  // With the auxiliary system solution computed, sync the displaced problem auxiliary solution
4785  // before computation of post-aux user objects. The undisplaced auxiliary system current local
4786  // solution is updated (via System::update) within the AuxiliarySystem class's variable
4787  // computation methods (e.g. computeElementalVarsHelper, computeNodalVarsHelper), so it is safe to
4788  // use it here
4789  if (_displaced_problem)
4790  _displaced_problem->syncAuxSolution(*getAuxiliarySystem().currentSolution());
4791 
4792  // Post-aux UserObjects
4793  computeUserObjects(exec_type, Moose::POST_AUX);
4794 
4795  // Return the current flag to None
4797 
4799  {
4800  // we will only check aux variables and postprocessors
4801  // checking more reporter data can be added in the future if needed
4802  std::unique_ptr<NumericVector<Number>> x = _aux->currentSolution()->clone();
4804 
4805  // call THIS execute one more time for checking the possible states
4806  _checking_uo_aux_state = true;
4807  FEProblemBase::execute(exec_type);
4808  _checking_uo_aux_state = false;
4809 
4810  const Real check_tol = 1e-8;
4811 
4812  const Real xnorm = x->l2_norm();
4813  *x -= *_aux->currentSolution();
4814  if (x->l2_norm() > check_tol * xnorm)
4815  {
4816  const auto & sys = _aux->system();
4817  const unsigned int n_vars = sys.n_vars();
4818  std::multimap<Real, std::string, std::greater<Real>> ordered_map;
4819  for (const auto i : make_range(n_vars))
4820  {
4821  const Real vnorm = sys.calculate_norm(*x, i, DISCRETE_L2);
4822  ordered_map.emplace(vnorm, sys.variable_name(i));
4823  }
4824 
4825  std::ostringstream oss;
4826  for (const auto & [error_norm, var_name] : ordered_map)
4827  oss << " {" << var_name << ", " << error_norm << "},\n";
4828 
4829  mooseError("Aux kernels, user objects appear to have states for aux variables on ",
4830  exec_type,
4831  ".\nVariable error norms in descending order:\n",
4832  oss.str());
4833  }
4834 
4836  if (pp_values.size() != new_pp_values.size())
4837  mooseError("Second execution for uo/aux state check should not change the number of "
4838  "real reporter values");
4839 
4840  const Real ppnorm = pp_values.l2_norm();
4841  pp_values -= new_pp_values;
4842  if (pp_values.l2_norm() > check_tol * ppnorm)
4843  {
4844  const auto pp_names = getReporterData().getAllRealReporterFullNames();
4845  std::multimap<Real, std::string, std::greater<Real>> ordered_map;
4846  for (const auto i : index_range(pp_names))
4847  ordered_map.emplace(std::abs(pp_values(i)), pp_names[i]);
4848 
4849  std::ostringstream oss;
4850  for (const auto & [error_norm, pp_name] : ordered_map)
4851  oss << " {" << pp_name << ", " << error_norm << "},\n";
4852 
4853  mooseError("Aux kernels, user objects appear to have states for real reporter values on ",
4854  exec_type,
4855  ".\nErrors of real reporter values in descending order:\n",
4856  oss.str());
4857  }
4858  }
4859 }
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:42
const bool _uo_aux_state_check
Whether or not checking the state of uo/aux evaluation.
const ExecFlagType EXEC_NONE
Definition: Moose.C:29
void setCurrentExecuteOnFlag(const ExecFlagType &)
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
const ReporterData & getReporterData() const
Provides const access the ReporterData object.
DenseVector< Real > getAllRealReporterValues() const
Get all real reporter values including postprocessor and vector postprocessor values into a dense vec...
Definition: ReporterData.C:81
unsigned int n_vars
Real l2_norm() const
std::vector< std::string > getAllRealReporterFullNames() const
Get full names of all real reporter values Note: For a postprocessor, the full name is the postproces...
Definition: ReporterData.C:106
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
void executeSamplers(const ExecFlagType &exec_type)
Performs setup and execute calls for Sampler objects.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
AuxiliarySystem & getAuxiliarySystem()
bool _checking_uo_aux_state
Flag used to indicate whether we are doing the uo/aux state check in execute.
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void customSetup(const ExecFlagType &exec_type) override
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
IntRange< T > make_range(T beg, T end)
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
virtual unsigned int size() const override final
std::shared_ptr< DisplacedProblem > _displaced_problem
const ExecFlagType EXEC_SUBDOMAIN
Definition: Moose.C:50
auto index_range(const T &sizable)
void computeSystems(const ExecFlagType &type)
Do generic system computations.
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:30

◆ executeAllObjects()

void FEProblemBase::executeAllObjects ( const ExecFlagType exec_type)
virtualinherited

Definition at line 4714 of file FEProblemBase.C.

Referenced by Executor::exec().

4715 {
4716 }

◆ executeControls()

void FEProblemBase::executeControls ( const ExecFlagType exec_type)
inherited

Performs setup and execute calls for Control objects.

Definition at line 5157 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::execute(), and FEProblemBase::initialSetup().

5158 {
5159  if (_control_warehouse[exec_type].hasActiveObjects())
5160  {
5161  TIME_SECTION("executeControls", 1, "Executing Controls");
5162 
5164 
5165  auto controls_wh = _control_warehouse[exec_type];
5166  // Add all of the dependencies into the resolver and sort them
5167  for (const auto & it : controls_wh.getActiveObjects())
5168  {
5169  // Make sure an item with no dependencies comes out too!
5170  resolver.addItem(it);
5171 
5172  std::vector<std::string> & dependent_controls = it->getDependencies();
5173  for (const auto & depend_name : dependent_controls)
5174  {
5175  if (controls_wh.hasActiveObject(depend_name))
5176  {
5177  auto dep_control = controls_wh.getActiveObject(depend_name);
5178  resolver.addEdge(dep_control, it);
5179  }
5180  else
5181  mooseError("The Control \"",
5182  depend_name,
5183  "\" was not created, did you make a "
5184  "spelling mistake or forget to include it "
5185  "in your input file?");
5186  }
5187  }
5188 
5189  const auto & ordered_controls = resolver.getSortedValues();
5190 
5191  if (!ordered_controls.empty())
5192  {
5193  _control_warehouse.setup(exec_type);
5194  // Run the controls in the proper order
5195  for (const auto & control : ordered_controls)
5196  control->execute();
5197  }
5198  }
5199 }
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.
const std::vector< T > & getSortedValues()
This function also returns dependency resolved values but with a simpler single vector interface...
void setup(const ExecFlagType &exec_flag, THREAD_ID tid=0) const
void addEdge(const T &a, const T &b)
Add an edge between nodes &#39;a&#39; and &#39;b&#39;.
void addItem(const T &value)
Add an independent item to the set.
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
Class that represents the dependecy as a graph.

◆ executeSamplers()

void FEProblemBase::executeSamplers ( const ExecFlagType exec_type)
inherited

Performs setup and execute calls for Sampler objects.

Definition at line 5202 of file FEProblemBase.C.

Referenced by FEProblemBase::execute().

5203 {
5204  // TODO: This should be done in a threaded loop, but this should be super quick so for now
5205  // do a serial loop.
5206  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
5207  {
5208  std::vector<Sampler *> objects;
5209  theWarehouse()
5210  .query()
5211  .condition<AttribSystem>("Sampler")
5212  .condition<AttribThread>(tid)
5213  .condition<AttribExecOns>(exec_type)
5214  .queryInto(objects);
5215 
5216  if (!objects.empty())
5217  {
5218  TIME_SECTION("executeSamplers", 1, "Executing Samplers");
5219  FEProblemBase::objectSetupHelper<Sampler>(objects, exec_type);
5220  FEProblemBase::objectExecuteHelper<Sampler>(objects);
5221  }
5222  }
5223 }
unsigned int n_threads()
TheWarehouse & theWarehouse() const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ externalSolve()

virtual void MFEMProblem::externalSolve ( )
inlineoverridevirtual

New interface for solving an External problem.

"solve()" is finalized here to provide callbacks for solution syncing.

Implements ExternalProblem.

Definition at line 26 of file MFEMProblem.h.

26 {}

◆ feBackend()

Moose::FEBackend MFEMProblem::feBackend ( ) const
inlineoverridevirtual

Reimplemented from FEProblemBase.

Definition at line 199 of file MFEMProblem.h.

◆ finalizeMultiApps()

void FEProblemBase::finalizeMultiApps ( )
inherited

Definition at line 5618 of file FEProblemBase.C.

Referenced by MFEMSteady::execute(), SteadyBase::execute(), TransientBase::execute(), and Eigenvalue::execute().

5619 {
5620  const auto & multi_apps = _multi_apps.getActiveObjects();
5621 
5622  for (const auto & multi_app : multi_apps)
5623  multi_app->finalize();
5624 }
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...
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.

◆ finalNonlinearResidual()

Real FEProblemBase::finalNonlinearResidual ( const unsigned int  nl_sys_num) const
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6735 of file FEProblemBase.C.

6736 {
6737  return _nl[nl_sys_num]->finalNonlinearResidual();
6738 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ finishMultiAppStep()

void FEProblemBase::finishMultiAppStep ( ExecFlagType  type,
bool  recurse_through_multiapp_levels = false 
)
inherited

Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.

Optionally recurse through all multi-app levels

Definition at line 5646 of file FEProblemBase.C.

Referenced by FEProblemBase::advanceMultiApps(), TransientBase::execute(), TransientMultiApp::finishStep(), and TransientBase::incrementStepOrReject().

5647 {
5648  const auto & multi_apps = _multi_apps[type].getActiveObjects();
5649 
5650  if (multi_apps.size())
5651  {
5652  if (_verbose_multiapps)
5653  _console << COLOR_CYAN << "\nAdvancing MultiApps on " << type.name() << COLOR_DEFAULT
5654  << std::endl;
5655 
5656  for (const auto & multi_app : multi_apps)
5657  multi_app->finishStep(recurse_through_multiapp_levels);
5658 
5660 
5661  if (_verbose_multiapps)
5662  _console << COLOR_CYAN << "Finished Advancing MultiApps on " << type.name() << "\n"
5663  << COLOR_DEFAULT << std::endl;
5664  }
5665 }
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.
const Parallel::Communicator & _communicator
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...
void parallelBarrierNotify(const libMesh::Parallel::Communicator &comm, bool messaging=true)
This function implements a parallel barrier function but writes progress to stdout.
Definition: MooseUtils.C:323
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool _verbose_multiapps
Whether or not to be verbose with multiapps.

◆ forceOutput()

void FEProblemBase::forceOutput ( )
inherited

Indicates that the next call to outputStep should be forced.

This is needed by the MultiApp system, if forceOutput is called the next call to outputStep, regardless of the type supplied to the call, will be executed with EXEC_FORCED.

Forced output will NOT override the allowOutput flag.

Definition at line 6870 of file FEProblemBase.C.

Referenced by TransientMultiApp::solveStep().

6871 {
6873 }
void forceOutput()
Indicates that the next call to outputStep should be forced This is private, users should utilize FEP...
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480

◆ fvBCsIntegrityCheck() [1/2]

bool FEProblemBase::fvBCsIntegrityCheck ( ) const
inlineinherited
Returns
whether to perform a boundary condition integrity check for finite volume

Definition at line 2423 of file FEProblemBase.h.

2423 { return _fv_bcs_integrity_check; }
bool _fv_bcs_integrity_check
Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset...

◆ fvBCsIntegrityCheck() [2/2]

void FEProblemBase::fvBCsIntegrityCheck ( bool  fv_bcs_integrity_check)
inlineinherited
Parameters
fv_bcs_integrity_checkWhether to perform a boundary condition integrity check for finite volume

Definition at line 3452 of file FEProblemBase.h.

3453 {
3455  // the user has requested that we don't check integrity so we will honor that
3456  return;
3457 
3458  _fv_bcs_integrity_check = fv_bcs_integrity_check;
3459 }
bool _fv_bcs_integrity_check
Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset...

◆ geomSearchData()

virtual GeometricSearchData& FEProblemBase::geomSearchData ( )
inlineoverridevirtualinherited

◆ getActiveElementalMooseVariables()

const std::set< MooseVariableFEBase * > & SubProblem::getActiveElementalMooseVariables ( const THREAD_ID  tid) const
virtualinherited

Get the MOOSE variables to be reinited on each element.

Parameters
tidThe thread id

Definition at line 454 of file SubProblem.C.

Referenced by SystemBase::prepare(), SystemBase::prepareFace(), FEProblemBase::prepareMaterials(), and SystemBase::reinitElem().

455 {
457 }
std::vector< std::set< MooseVariableFieldBase * > > _active_elemental_moose_variables
This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem) ...
Definition: SubProblem.h:1075

◆ getActiveFEVariableCoupleableMatrixTags()

const std::set< TagID > & SubProblem::getActiveFEVariableCoupleableMatrixTags ( const THREAD_ID  tid) const
inherited

Definition at line 390 of file SubProblem.C.

391 {
393 }
std::vector< std::set< TagID > > _active_fe_var_coupleable_matrix_tags
Definition: SubProblem.h:1081

◆ getActiveFEVariableCoupleableVectorTags()

const std::set< TagID > & SubProblem::getActiveFEVariableCoupleableVectorTags ( const THREAD_ID  tid) const
inherited

Definition at line 396 of file SubProblem.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

397 {
399 }
std::vector< std::set< TagID > > _active_fe_var_coupleable_vector_tags
Definition: SubProblem.h:1083

◆ getActiveScalarVariableCoupleableMatrixTags()

const std::set< TagID > & SubProblem::getActiveScalarVariableCoupleableMatrixTags ( const THREAD_ID  tid) const
inherited

Definition at line 431 of file SubProblem.C.

Referenced by MooseVariableScalar::reinit().

432 {
434 }
std::vector< std::set< TagID > > _active_sc_var_coupleable_matrix_tags
Definition: SubProblem.h:1085

◆ getActiveScalarVariableCoupleableVectorTags()

const std::set< TagID > & SubProblem::getActiveScalarVariableCoupleableVectorTags ( const THREAD_ID  tid) const
inherited

Definition at line 437 of file SubProblem.C.

438 {
440 }
std::vector< std::set< TagID > > _active_sc_var_coupleable_vector_tags
Definition: SubProblem.h:1087

◆ getActualFieldVariable()

MooseVariableFieldBase & FEProblemBase::getActualFieldVariable ( const THREAD_ID  tid,
const std::string &  var_name 
)
overridevirtualinherited

Returns the variable reference for requested MooseVariableField which may be in any system.

Implements SubProblem.

Definition at line 5863 of file FEProblemBase.C.

Referenced by MultiAppVariableValueSampleTransfer::execute().

5864 {
5865  for (auto & sys : _solver_systems)
5866  if (sys->hasVariable(var_name))
5867  return sys->getActualFieldVariable<Real>(tid, var_name);
5868  if (_aux->hasVariable(var_name))
5869  return _aux->getActualFieldVariable<Real>(tid, var_name);
5870 
5871  mooseError("Unknown variable " + var_name);
5872 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
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

◆ getArrayVariable()

ArrayMooseVariable & FEProblemBase::getArrayVariable ( const THREAD_ID  tid,
const std::string &  var_name 
)
overridevirtualinherited

Returns the variable reference for requested ArrayMooseVariable which may be in any system.

Implements SubProblem.

Definition at line 5887 of file FEProblemBase.C.

Referenced by CoupleableMooseVariableDependencyIntermediateInterface::coupledArrayValueByName(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), and PointwiseRenormalizeVector::PointwiseRenormalizeVector().

5888 {
5889  for (auto & sys : _solver_systems)
5890  if (sys->hasVariable(var_name))
5891  return sys->getFieldVariable<RealEigenVector>(tid, var_name);
5892  if (_aux->hasVariable(var_name))
5893  return _aux->getFieldVariable<RealEigenVector>(tid, var_name);
5894 
5895  mooseError("Unknown variable " + var_name);
5896 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
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
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
Definition: MooseTypes.h:146

◆ getAuxiliarySystem()

AuxiliarySystem& FEProblemBase::getAuxiliarySystem ( )
inlineinherited

◆ getAuxVariableNames()

std::vector< VariableName > MFEMProblem::getAuxVariableNames ( )
virtual

Returns all the variable names from the auxiliary system base.

This is helpful in the syncSolutions() method when transferring variable data.

Definition at line 459 of file MFEMProblem.C.

460 {
462 }
virtual const SystemBase & systemBaseAuxiliary() const override
Return the auxiliary system object as a base class reference.
const std::vector< VariableName > & getVariableNames() const
Definition: SystemBase.h:860

◆ getAxisymmetricRadialCoord()

unsigned int SubProblem::getAxisymmetricRadialCoord ( ) const
inherited

Returns the desired radial direction for RZ coordinate transformation.

Returns
The coordinate direction for the radial direction

Definition at line 796 of file SubProblem.C.

797 {
798  return mesh().getAxisymmetricRadialCoord();
799 }
virtual MooseMesh & mesh()=0
unsigned int getAxisymmetricRadialCoord() const
Returns the desired radial direction for RZ coordinate transformation.
Definition: MooseMesh.C:4334

◆ getBase()

const std::string& MooseBase::getBase ( ) const
inlineinherited
Returns
The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

147 { return _pars.getBase(); }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
const std::string & getBase() const

◆ getBndMaterialPropertyStorage()

const MaterialPropertyStorage& FEProblemBase::getBndMaterialPropertyStorage ( )
inlineinherited

Definition at line 1793 of file FEProblemBase.h.

1793 { return _bnd_material_props; }
MaterialPropertyStorage & _bnd_material_props

◆ getCheckedPointerParam()

template<typename T >
T MooseBase::getCheckedPointerParam ( const std::string &  name,
const std::string &  error_string = "" 
) const
inherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 432 of file MooseBase.h.

433 {
434  return _pars.getCheckedPointerParam<T>(name, error_string);
435 }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
T getCheckedPointerParam(const std::string &name, const std::string &error_string="") const
Verifies that the requested parameter exists and is not NULL and returns it to the caller...
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ getCoefficients()

Moose::MFEM::CoefficientManager& MFEMProblem::getCoefficients ( )
inline

Method to get the PropertyManager object for storing material properties and converting them to MFEM coefficients.

This is used by Material and Kernel classes (among others).

Definition at line 180 of file MFEMProblem.h.

Referenced by addFunction(), addGridFunction(), addPostprocessor(), MFEMGeneralUserObject::getMatrixCoefficientByName(), MFEMGeneralUserObject::getScalarCoefficientByName(), and MFEMGeneralUserObject::getVectorCoefficientByName().

180 { return _problem_data.coefficients; }
MFEMProblemData _problem_data
Definition: MFEMProblem.h:209
Moose::MFEM::CoefficientManager coefficients

◆ getConsumedPropertyMap()

const std::map< MooseObjectName, std::set< std::string > > & SubProblem::getConsumedPropertyMap ( ) const
inherited

Return the map that tracks the object with consumed material properties.

Definition at line 742 of file SubProblem.C.

Referenced by MaterialPropertyDebugOutput::output().

743 {
745 }
std::map< MooseObjectName, std::set< std::string > > _consumed_material_properties
Definition: SubProblem.h:1185

◆ getControlWarehouse()

ExecuteMooseObjectWarehouse<Control>& FEProblemBase::getControlWarehouse ( )
inlineinherited

Reference to the control logic warehouse.

Definition at line 2215 of file FEProblemBase.h.

Referenced by LibtorchArtificialNeuralNetParameters::initialSetup(), and LibtorchControlValuePostprocessor::initialSetup().

2215 { return _control_warehouse; }
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.

◆ getConvergence()

Convergence & FEProblemBase::getConvergence ( const std::string &  name,
const THREAD_ID  tid = 0 
) const
virtualinherited

Gets a Convergence object.

Definition at line 2659 of file FEProblemBase.C.

Referenced by TransientBase::convergedToSteadyState(), FEProblemSolve::convergenceSetup(), FixedPointSolve::examineFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), TransientBase::init(), ParsedConvergence::initializeConvergenceSymbol(), SteffensenSolve::initialSetup(), FixedPointSolve::initialSetup(), Moose::PetscSupport::petscLinearConverged(), Moose::PetscSupport::petscNonlinearConverged(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

2660 {
2661  auto * const ret = dynamic_cast<Convergence *>(_convergences.getActiveObject(name, tid).get());
2662  if (!ret)
2663  mooseError("The Convergence object '", name, "' does not exist.");
2664 
2665  return *ret;
2666 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseObjectWarehouse< Convergence > _convergences
convergence warehouse
std::shared_ptr< T > getActiveObject(const std::string &name, THREAD_ID tid=0) const
Base class for convergence criteria.
Definition: Convergence.h:21
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

◆ getConvergenceObjects()

const std::vector< std::shared_ptr< Convergence > > & FEProblemBase::getConvergenceObjects ( const THREAD_ID  tid = 0) const
virtualinherited

Gets the Convergence objects.

Definition at line 2669 of file FEProblemBase.C.

2670 {
2671  return _convergences.getActiveObjects(tid);
2672 }
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...
MooseObjectWarehouse< Convergence > _convergences
convergence warehouse

◆ getCoordSystem()

Moose::CoordinateSystemType SubProblem::getCoordSystem ( SubdomainID  sid) const
inherited

Definition at line 1278 of file SubProblem.C.

Referenced by BlockRestrictable::getBlockCoordSystem(), MultiApp::getBoundingBox(), Assembly::reinitLowerDElem(), Assembly::reinitNeighborLowerDElem(), and Assembly::setCoordinateTransformation().

1279 {
1280  return mesh().getCoordSystem(sid);
1281 }
virtual MooseMesh & mesh()=0
Moose::CoordinateSystemType getCoordSystem(SubdomainID sid) const
Get the coordinate system type, e.g.
Definition: MooseMesh.C:4215

◆ getCurrentAlgebraicBndNodeRange()

const ConstBndNodeRange & FEProblemBase::getCurrentAlgebraicBndNodeRange ( )
inherited

Definition at line 9535 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearSystemBase::computeResidualInternal(), and NonlinearSystemBase::setInitialSolution().

9536 {
9538  return *_mesh.getBoundaryNodeRange();
9539 
9541 }
MooseMesh & _mesh
std::unique_ptr< ConstBndNodeRange > _current_algebraic_bnd_node_range
libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > * getBoundaryNodeRange()
Definition: MooseMesh.C:1327

◆ getCurrentAlgebraicElementRange()

const ConstElemRange & FEProblemBase::getCurrentAlgebraicElementRange ( )
inherited

These are the element and nodes that contribute to the jacobian and residual for this local processor.

getCurrentAlgebraicElementRange() returns the element range that contributes to the system getCurrentAlgebraicNodeRange() returns the node range that contributes to the system getCurrentAlgebraicBndNodeRange returns the boundary node ranges that contributes to the system

Definition at line 9519 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), and NonlinearSystemBase::computeScaling().

9520 {
9523 
9525 }
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
Definition: MooseMesh.C:1276
std::unique_ptr< libMesh::ConstElemRange > _current_algebraic_elem_range
MooseMesh & _mesh

◆ getCurrentAlgebraicNodeRange()

const ConstNodeRange & FEProblemBase::getCurrentAlgebraicNodeRange ( )
inherited

Definition at line 9527 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

9528 {
9530  return *_mesh.getLocalNodeRange();
9531 
9533 }
std::unique_ptr< libMesh::ConstNodeRange > _current_algebraic_node_range
libMesh::ConstNodeRange * getLocalNodeRange()
Definition: MooseMesh.C:1313
MooseMesh & _mesh

◆ getCurrentExecuteOnFlag()

const ExecFlagType & FEProblemBase::getCurrentExecuteOnFlag ( ) const
inherited

Return/set the current execution flag.

Returns EXEC_NONE when not being executed.

See also
FEProblemBase::execute

Definition at line 4702 of file FEProblemBase.C.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), MultiAppGeneralFieldTransfer::closestToPosition(), MultiAppGeneralFieldNearestLocationTransfer::computeNumSources(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), NearestPositionsDivision::divisionIndex(), PositionsFunctorValueSampler::execute(), PIDTransientControl::execute(), Terminator::execute(), Control::getControllableParameterByName(), Material::getMaterialByName(), MultiAppGeneralFieldNearestLocationTransfer::getNumDivisions(), NumPositions::getValue(), PositionsFunctorValueSampler::initialize(), DistributedPositions::initialize(), TransformedPositions::initialize(), ParsedDownSelectionPositions::initialize(), MultiAppGeneralFieldTransfer::locatePointReceivers(), ComputeUserObjectsThread::printBlockExecutionInformation(), ComputeFVInitialConditionThread::printGeneralExecutionInformation(), ComputeInitialConditionThread::printGeneralExecutionInformation(), ComputeNodalUserObjectsThread::printGeneralExecutionInformation(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeElemDampingThread::printGeneralExecutionInformation(), ComputeNodalKernelsThread::printGeneralExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), ComputeMarkerThread::printGeneralExecutionInformation(), ComputeNodalDampingThread::printGeneralExecutionInformation(), ComputeDiracThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), ComputeIndicatorThread::printGeneralExecutionInformation(), ComputeThreadedGeneralUserObjectsThread::printGeneralExecutionInformation(), ComputeUserObjectsThread::printGeneralExecutionInformation(), ComputeLinearFVElementalThread::printGeneralExecutionInformation(), ComputeLinearFVFaceThread::printGeneralExecutionInformation(), NonlinearThread::printGeneralExecutionInformation(), MultiApp::restore(), SolutionInvalidityOutput::shouldOutput(), NodalReporter::shouldStore(), ElementReporter::shouldStore(), GeneralReporter::shouldStore(), and WebServerControl::startServer().

4703 {
4704  return _current_execute_on_flag;
4705 }
ExecFlagType _current_execute_on_flag
Current execute_on flag.

◆ getCurrentICState()

unsigned short FEProblemBase::getCurrentICState ( )
inherited

Retrieves the current initial condition state.

Returns
current initial condition state

Definition at line 9578 of file FEProblemBase.C.

Referenced by ComputeInitialConditionThread::operator()().

9579 {
9580  return _current_ic_state;
9581 }
unsigned short _current_ic_state

◆ getDataFileName()

std::string DataFileInterface::getDataFileName ( const std::string &  param) const
inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

22 {
23  _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
24  "within the InputParameters.\nUse getParam<DataFileName>(\"",
25  param,
26  "\") instead.");
27  return _parent.getParam<DataFileName>(param);
28 }
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBase.h:388
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
const ParallelParamObject & _parent

◆ getDataFileNameByName()

std::string DataFileInterface::getDataFileNameByName ( const std::string &  relative_path) const
inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

32 {
33  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
34  relative_path,
35  "\") instead.");
36  return getDataFilePath(relative_path);
37 }
std::string getDataFilePath(const std::string &relative_path) const
Returns the path of a data file for a given relative file path.
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
const ParallelParamObject & _parent

◆ getDataFilePath()

std::string DataFileInterface::getDataFilePath ( const std::string &  relative_path) const
inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

Referenced by DataFileInterface::getDataFileNameByName().

41 {
42  // This should only ever be used with relative paths. There is no point to
43  // use this search path with an absolute path.
44  if (std::filesystem::path(relative_path).is_absolute())
45  _parent.mooseWarning("While using getDataFilePath(\"",
46  relative_path,
47  "\"): This API should not be used for absolute paths.");
48 
49  // This will search the data paths for this relative path
50  std::optional<std::string> error;
51  Moose::DataFileUtils::Path found_path;
52  {
53  // Throw on error so that if getPath() fails, we can throw an error
54  // with the context of _parent.mooseError()
55  Moose::ScopedThrowOnError scoped_throw_on_error;
56 
57  try
58  {
59  found_path = Moose::DataFileUtils::getPath(relative_path);
60  }
61  catch (std::exception & e)
62  {
63  error = e.what();
64  }
65  }
66 
67  if (error)
68  _parent.mooseError(*error);
69 
70  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
71  "Should only ever obtain data");
72  mooseAssert(found_path.data_name, "Should be set");
73 
74  const std::string msg =
75  "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
76  _parent.mooseInfo(msg);
77 
78  return found_path.path;
79 }
void mooseInfo(Args &&... args) const
Definition: MooseBase.h:321
Context context
Context for the file (where it came from)
Definition: DataFileUtils.h:48
Representation of a data file path.
Definition: DataFileUtils.h:36
Path getPath(std::string path, const std::optional< std::string > &base=std::optional< std::string >())
Get the data path for a given path, searching the registered data.
Definition: DataFileUtils.C:22
std::optional< std::string > data_name
The name of the data registry the file came from (with context == DATA)
Definition: DataFileUtils.h:50
Scoped helper for setting Moose::_throw_on_error during this scope.
Definition: Moose.h:294
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:299
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
const ParallelParamObject & _parent

◆ getDiracElements()

void FEProblemBase::getDiracElements ( std::set< const Elem *> &  elems)
overridevirtualinherited

Fills "elems" with the elements that should be looped over for Dirac Kernels.

Implements SubProblem.

Definition at line 2479 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDiracContributions().

2480 {
2481  // First add in the undisplaced elements
2482  elems = _dirac_kernel_info.getElements();
2483 
2484  if (_displaced_problem)
2485  {
2486  std::set<const Elem *> displaced_elements;
2487  _displaced_problem->getDiracElements(displaced_elements);
2488 
2489  { // Use the ids from the displaced elements to get the undisplaced elements
2490  // and add them to the list
2491  for (const auto & elem : displaced_elements)
2492  elems.insert(_mesh.elemPtr(elem->id()));
2493  }
2494  }
2495 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
MooseMesh & _mesh
std::shared_ptr< DisplacedProblem > _displaced_problem
std::set< const Elem * > & getElements()
Returns a writeable reference to the _elements container.
DiracKernelInfo _dirac_kernel_info
Definition: SubProblem.h:1049

◆ getDiscreteMaterialWarehouse()

const MaterialWarehouse& FEProblemBase::getDiscreteMaterialWarehouse ( ) const
inlineinherited

Definition at line 2035 of file FEProblemBase.h.

2035 { return _discrete_materials; }
MaterialWarehouse _discrete_materials

◆ getDisplacedProblem() [1/2]

virtual std::shared_ptr<const DisplacedProblem> FEProblemBase::getDisplacedProblem ( ) const
inlinevirtualinherited

◆ getDisplacedProblem() [2/2]

virtual std::shared_ptr<DisplacedProblem> FEProblemBase::getDisplacedProblem ( )
inlinevirtualinherited

Definition at line 1735 of file FEProblemBase.h.

1735 { return _displaced_problem; }
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ getDistribution()

Distribution & FEProblemBase::getDistribution ( const std::string &  name)
virtualinherited

Definition at line 2729 of file FEProblemBase.C.

Referenced by DistributionInterface::getDistribution(), and DistributionInterface::getDistributionByName().

2730 {
2731  std::vector<Distribution *> objs;
2732  theWarehouse()
2733  .query()
2734  .condition<AttribSystem>("Distribution")
2735  .condition<AttribName>(name)
2736  .queryInto(objs);
2737  if (objs.empty())
2738  mooseError("Unable to find Distribution with name '" + name + "'");
2739  return *(objs[0]);
2740 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
TheWarehouse & theWarehouse() const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
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
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ getEvaluableElementRange()

const ConstElemRange & FEProblemBase::getEvaluableElementRange ( )
inherited

In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}.

That is, the number of evaluable elements does NOT necessarily equal to the number of local and algebraic ghosting elements. For example, if using a Lagrange basis for all variables, if a non-local, non-algebraically-ghosted element is surrounded by neighbors which are local or algebraically ghosted, then all the nodal (Lagrange) degrees of freedom associated with the non-local, non-algebraically-ghosted element will be evaluable, and hence that element will be considered evaluable.

getNonlinearEvaluableElementRange() returns the evaluable element range based on the nonlinear system dofmap; getAuxliaryEvaluableElementRange() returns the evaluable element range based on the auxiliary system dofmap; getEvaluableElementRange() returns the element range that is evaluable based on both the nonlinear dofmap and the auxliary dofmap.

Definition at line 849 of file FEProblemBase.C.

Referenced by NodalPatchRecoveryBase::gatherRequestList().

850 {
852  {
853  std::vector<const DofMap *> dof_maps(es().n_systems());
854  for (const auto i : make_range(es().n_systems()))
855  {
856  const auto & sys = es().get_system(i);
857  dof_maps[i] = &sys.get_dof_map();
858  }
860  std::make_unique<ConstElemRange>(_mesh.getMesh().multi_evaluable_elements_begin(dof_maps),
861  _mesh.getMesh().multi_evaluable_elements_end(dof_maps));
862  }
864 }
const T_sys & get_system(std::string_view name) const
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition: MooseMesh.C:3488
virtual libMesh::EquationSystems & es() override
MooseMesh & _mesh
IntRange< T > make_range(T beg, T end)
std::unique_ptr< libMesh::ConstElemRange > _evaluable_local_elem_range

◆ getExecutor()

virtual Executor& FEProblemBase::getExecutor ( const std::string &  name)
inlinevirtualinherited

Definition at line 2167 of file FEProblemBase.h.

2167 { return _app.getExecutor(name); }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
Executor * getExecutor() const
Definition: MooseApp.h:335

◆ getFailNextNonlinearConvergenceCheck()

bool FEProblemBase::getFailNextNonlinearConvergenceCheck ( ) const
inlineinherited

Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s)

Definition at line 2555 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeScaling(), NonlinearSystem::converged(), Moose::PetscSupport::petscNonlinearConverged(), and ComputeResidualFunctor::residual().

bool getFailNextSystemConvergenceCheck() const
Whether it will fail the next system convergence check(s), triggering failed step behavior...

◆ getFailNextSystemConvergenceCheck()

bool FEProblemBase::getFailNextSystemConvergenceCheck ( ) const
inlineinherited

Whether it will fail the next system convergence check(s), triggering failed step behavior.

Definition at line 2557 of file FEProblemBase.h.

Referenced by FEProblemBase::getFailNextNonlinearConvergenceCheck(), and Moose::PetscSupport::petscLinearConverged().

bool _fail_next_system_convergence_check

◆ getFunction()

Function & FEProblemBase::getFunction ( const std::string &  name,
const THREAD_ID  tid = 0 
)
virtualinherited

Definition at line 2608 of file FEProblemBase.C.

Referenced by addFunction(), FunctionInterface::getFunction(), FunctionInterface::getFunctionByName(), IterationAdaptiveDT::init(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), and ParsedConvergence::initializeFunctionSymbol().

2609 {
2610  // This thread lock is necessary since this method will create functions
2611  // for all threads if one is missing.
2612  Threads::spin_mutex::scoped_lock lock(get_function_mutex);
2613 
2614  if (!hasFunction(name, tid))
2615  {
2616  // If we didn't find a function, it might be a default function, attempt to construct one now
2617  std::istringstream ss(name);
2618  Real real_value;
2619 
2620  // First see if it's just a constant. If it is, build a ConstantFunction
2621  if (ss >> real_value && ss.eof())
2622  {
2623  InputParameters params = _factory.getValidParams("ConstantFunction");
2624  params.set<Real>("value") = real_value;
2625  addFunction("ConstantFunction", ss.str(), params);
2626  }
2627  else
2628  {
2630  std::string vars = "x,y,z,t,NaN,pi,e";
2631  if (fp.Parse(name, vars) == -1) // -1 for success
2632  {
2633  // It parsed ok, so build a MooseParsedFunction
2634  InputParameters params = _factory.getValidParams("ParsedFunction");
2635  params.set<std::string>("expression") = name;
2636  addFunction("ParsedFunction", name, params);
2637  }
2638  }
2639 
2640  // Try once more
2641  if (!hasFunction(name, tid))
2642  mooseError("Unable to find function " + name);
2643  }
2644 
2645  auto * const ret = dynamic_cast<Function *>(_functions.getActiveObject(name, tid).get());
2646  if (!ret)
2647  mooseError("No function named ", name, " of appropriate type");
2648 
2649  return *ret;
2650 }
Base class for function objects.
Definition: Function.h:36
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1047
Threads::spin_mutex get_function_mutex
char ** vars
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< T > getActiveObject(const std::string &name, THREAD_ID tid=0) const
virtual void addFunction(const std::string &type, const std::string &name, InputParameters &parameters)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
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
MooseObjectWarehouse< Function > _functions
functions
virtual bool hasFunction(const std::string &name, const THREAD_ID tid=0)

◆ getFunctor()

template<typename T >
const Moose::Functor< T > & SubProblem::getFunctor ( const std::string &  name,
const THREAD_ID  tid,
const std::string &  requestor_name,
bool  requestor_is_ad 
)
inherited
Template Parameters
TThe type that the functor will return when evaluated, e.g. ADReal or Real
Parameters
nameThe name of the functor to retrieve
tidThe thread ID that we are retrieving the functor property for
requestor_nameThe name of the object that is requesting this functor property
requestor_is_adWhether the requesting object is an AD object
Returns
a constant reference to the functor

Definition at line 1214 of file SubProblem.h.

Referenced by FunctorInterface::getFunctorByName().

1218 {
1219  mooseAssert(tid < _functors.size(), "Too large a thread ID");
1220 
1221  // Log the requestor
1222  _functor_to_requestors["wraps_" + name].insert(requestor_name);
1223 
1224  constexpr bool requested_functor_is_ad =
1225  !std::is_same<T, typename MetaPhysicL::RawType<T>::value_type>::value;
1226 
1227  auto & functor_to_request_info = _functor_to_request_info[tid];
1228 
1229  // Get the requested functor if we already have it
1230  auto & functors = _functors[tid];
1231  if (auto find_ret = functors.find("wraps_" + name); find_ret != functors.end())
1232  {
1233  if (functors.count("wraps_" + name) > 1)
1234  mooseError("Attempted to get a functor with the name '",
1235  name,
1236  "' but multiple (" + std::to_string(functors.count("wraps_" + name)) +
1237  ") functors match. Make sure that you do not have functor material "
1238  "properties, functions, postprocessors or variables with the same names.");
1239 
1240  auto & [true_functor_is, non_ad_functor, ad_functor] = find_ret->second;
1241  auto & functor_wrapper = requested_functor_is_ad ? *ad_functor : *non_ad_functor;
1242 
1243  auto * const functor = dynamic_cast<Moose::Functor<T> *>(&functor_wrapper);
1244  if (!functor)
1245  mooseError("A call to SubProblem::getFunctor requested a functor named '",
1246  name,
1247  "' that returns the type: '",
1248  libMesh::demangle(typeid(T).name()),
1249  "'. However, that functor already exists and returns a different type: '",
1250  functor_wrapper.returnType(),
1251  "'");
1252 
1253  if (functor->template wrapsType<Moose::NullFunctor<T>>())
1254  // Store for future checking when the actual functor gets added
1255  functor_to_request_info.emplace(name,
1256  std::make_pair(requested_functor_is_ad, requestor_is_ad));
1257  else
1258  {
1259  // We already have the actual functor
1260  if (true_functor_is == SubProblem::TrueFunctorIs::UNSET)
1261  mooseError("We already have the functor; it should not be unset");
1262 
1263  // Check for whether this is a valid request
1264  // We allow auxiliary variables and linear variables to be retrieved as non AD
1265  if (!requested_functor_is_ad && requestor_is_ad &&
1266  true_functor_is == SubProblem::TrueFunctorIs::AD &&
1268  mooseError("The AD object '",
1269  requestor_name,
1270  "' is requesting the functor '",
1271  name,
1272  "' as a non-AD functor even though it is truly an AD functor, which is not "
1273  "allowed, since this may unintentionally drop derivatives.");
1274  }
1275 
1276  return *functor;
1277  }
1278 
1279  // We don't have the functor yet but we could have it in the future. We'll create null functors
1280  // for now
1281  functor_to_request_info.emplace(name, std::make_pair(requested_functor_is_ad, requestor_is_ad));
1282  if constexpr (requested_functor_is_ad)
1283  {
1284  typedef typename MetaPhysicL::RawType<T>::value_type NonADType;
1285  typedef T ADType;
1286 
1287  auto emplace_ret =
1288  functors.emplace("wraps_" + name,
1289  std::make_tuple(SubProblem::TrueFunctorIs::UNSET,
1290  std::make_unique<Moose::Functor<NonADType>>(
1291  std::make_unique<Moose::NullFunctor<NonADType>>()),
1292  std::make_unique<Moose::Functor<ADType>>(
1293  std::make_unique<Moose::NullFunctor<ADType>>())));
1294 
1295  return static_cast<Moose::Functor<T> &>(*(requested_functor_is_ad
1296  ? std::get<2>(emplace_ret->second)
1297  : std::get<1>(emplace_ret->second)));
1298  }
1299  else
1300  {
1301  typedef T NonADType;
1302  typedef typename Moose::ADType<T>::type ADType;
1303 
1304  auto emplace_ret =
1305  functors.emplace("wraps_" + name,
1306  std::make_tuple(SubProblem::TrueFunctorIs::UNSET,
1307  std::make_unique<Moose::Functor<NonADType>>(
1308  std::make_unique<Moose::NullFunctor<NonADType>>()),
1309  std::make_unique<Moose::Functor<ADType>>(
1310  std::make_unique<Moose::NullFunctor<ADType>>())));
1311 
1312  return static_cast<Moose::Functor<T> &>(*(requested_functor_is_ad
1313  ? std::get<2>(emplace_ret->second)
1314  : std::get<1>(emplace_ret->second)));
1315  }
1316 }
std::map< std::string, std::set< std::string > > _functor_to_requestors
The requestors of functors where the key is the prop name and the value is a set of names of requesto...
Definition: SubProblem.h:1157
This is a wrapper that forwards calls to the implementation, which can be switched out at any time wi...
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::vector< std::multimap< std::string, std::pair< bool, bool > > > _functor_to_request_info
A multimap (for each thread) from unfilled functor requests to whether the requests were for AD funct...
Definition: SubProblem.h:1161
std::string demangle(const char *name)
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
std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > > _functors
A container holding pointers to all the functors in our problem.
Definition: SubProblem.h:1144
virtual bool hasLinearVariable(const std::string &var_name) const
Whether or not this problem has this linear variable.
Definition: SubProblem.C:802
A functor that serves as a placeholder during the simulation setup phase if a functor consumer reques...
virtual bool hasAuxiliaryVariable(const std::string &var_name) const
Whether or not this problem has this auxiliary variable.
Definition: SubProblem.C:811

◆ getFVInitialConditionWarehouse()

const FVInitialConditionWarehouse& FEProblemBase::getFVInitialConditionWarehouse ( ) const
inlineinherited

Return FVInitialCondition storage.

Definition at line 1835 of file FEProblemBase.h.

Referenced by ComputeFVInitialConditionThread::operator()(), and ComputeFVInitialConditionThread::printGeneralExecutionInformation().

1835 { return _fv_ics; }
FVInitialConditionWarehouse _fv_ics

◆ getFVMatsAndDependencies()

void FEProblemBase::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 
)
inherited

Get the materials and variables potentially needed for FV.

Parameters
block_idSubdomainID The subdomain id that we want to retrieve materials for
face_materialsThe face materials container that we will fill
neighbor_materialsThe neighbor materials container that we will fill
variablesThe variables container that we will fill that our materials depend on
tidThe thread id

Definition at line 9214 of file FEProblemBase.C.

9220 {
9221  if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
9222  {
9223  auto & this_face_mats =
9225  for (std::shared_ptr<MaterialBase> face_mat : this_face_mats)
9226  if (face_mat->ghostable())
9227  {
9228  face_materials.push_back(face_mat);
9229  auto & var_deps = face_mat->getMooseVariableDependencies();
9230  for (auto * var : var_deps)
9231  {
9232  if (!var->isFV())
9233  mooseError(
9234  "Ghostable materials should only have finite volume variables coupled into them.");
9235  else if (face_mat->hasStatefulProperties())
9236  mooseError("Finite volume materials do not currently support stateful properties.");
9237  variables.insert(var);
9238  }
9239  }
9240  }
9241 
9242  if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
9243  {
9244  auto & this_neighbor_mats =
9246  for (std::shared_ptr<MaterialBase> neighbor_mat : this_neighbor_mats)
9247  if (neighbor_mat->ghostable())
9248  {
9249  neighbor_materials.push_back(neighbor_mat);
9250 #ifndef NDEBUG
9251  auto & var_deps = neighbor_mat->getMooseVariableDependencies();
9252  for (auto * var : var_deps)
9253  {
9254  if (!var->isFV())
9255  mooseError(
9256  "Ghostable materials should only have finite volume variables coupled into them.");
9257  else if (neighbor_mat->hasStatefulProperties())
9258  mooseError("Finite volume materials do not currently support stateful properties.");
9259  auto pr = variables.insert(var);
9260  mooseAssert(!pr.second,
9261  "We should not have inserted any new variables dependencies from our "
9262  "neighbor materials that didn't exist for our face materials");
9263  }
9264 #endif
9265  }
9266  }
9267 }
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
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
MaterialWarehouse _materials

◆ getGridFunction()

std::shared_ptr< mfem::ParGridFunction > MFEMProblem::getGridFunction ( const std::string &  name)
Returns
a shared pointer to an MFEM parallel grid function

Definition at line 502 of file MFEMProblem.C.

Referenced by MFEMScalarIC::execute(), MFEMVectorIC::execute(), and MFEMScalarBoundaryIC::execute().

503 {
504  return getUserObject<MFEMVariable>(name).getGridFunction();
505 }
std::shared_ptr< mfem::ParGridFunction > getGridFunction(const std::string &name)
Definition: MFEMProblem.C:502
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ getHitNode()

const hit::Node* MooseBase::getHitNode ( ) const
inlineinherited
Returns
The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

136 { return getHitNode(_pars); }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
const hit::Node * getHitNode() const
Definition: MooseBase.h:136

◆ getIndicatorWarehouse()

const MooseObjectWarehouse<Indicator>& FEProblemBase::getIndicatorWarehouse ( )
inlineinherited

Return indicator/marker storage.

Definition at line 1819 of file FEProblemBase.h.

1819 { return _indicators; }
MooseObjectWarehouse< Indicator > _indicators

◆ getInitialConditionWarehouse()

const InitialConditionWarehouse& FEProblemBase::getInitialConditionWarehouse ( ) const
inlineinherited

Return InitialCondition storage.

Definition at line 1830 of file FEProblemBase.h.

Referenced by ComputeBoundaryInitialConditionThread::onNode(), ComputeInitialConditionThread::operator()(), and ComputeInitialConditionThread::printGeneralExecutionInformation().

1830 { return _ics; }
InitialConditionWarehouse _ics

◆ getInterfaceMaterialsWarehouse()

const MaterialWarehouse& FEProblemBase::getInterfaceMaterialsWarehouse ( ) const
inlineinherited

Definition at line 2036 of file FEProblemBase.h.

2036 { return _interface_materials; }
MaterialWarehouse _interface_materials

◆ getInternalSideIndicatorWarehouse()

const MooseObjectWarehouse<InternalSideIndicatorBase>& FEProblemBase::getInternalSideIndicatorWarehouse ( )
inlineinherited

Definition at line 1820 of file FEProblemBase.h.

1821  {
1823  }
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators

◆ getKokkosBndMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::getKokkosBndMaterialPropertyStorage ( )
inlineinherited

Definition at line 1804 of file FEProblemBase.h.

1805  {
1807  }
Moose::Kokkos::MaterialPropertyStorage & _kokkos_bnd_material_props

◆ getKokkosMaterialData()

MaterialData& FEProblemBase::getKokkosMaterialData ( Moose::MaterialDataType  type,
const MooseObject object = nullptr 
) const
inherited
Returns
The Kokkos MaterialData for the type type for thread tid

Referenced by BlockRestrictable::initializeBlockRestrictable().

◆ getKokkosMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::getKokkosMaterialPropertyStorage ( )
inlineinherited

Definition at line 1800 of file FEProblemBase.h.

1801  {
1802  return _kokkos_material_props;
1803  }
Moose::Kokkos::MaterialPropertyStorage & _kokkos_material_props

◆ getKokkosMaterialPropertyStorageConsumers()

const std::set<const MooseObject *>& FEProblemBase::getKokkosMaterialPropertyStorageConsumers ( Moose::MaterialDataType  type) const
inherited
Returns
The consumers of the Kokkos MaterialPropertyStorage for the type type

◆ getKokkosMaterialsWarehouse()

const MaterialWarehouse& FEProblemBase::getKokkosMaterialsWarehouse ( ) const
inlineinherited

Definition at line 2042 of file FEProblemBase.h.

2042 { return _kokkos_materials; }
MaterialWarehouse _kokkos_materials

◆ getKokkosNeighborMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::getKokkosNeighborMaterialPropertyStorage ( )
inlineinherited

Definition at line 1808 of file FEProblemBase.h.

1809  {
1811  }
Moose::Kokkos::MaterialPropertyStorage & _kokkos_neighbor_material_props

◆ getKokkosSystems() [1/2]

Moose::Kokkos::Array<Moose::Kokkos::System>& FEProblemBase::getKokkosSystems ( )
inlineinherited

Get all Kokkos systems that are associated with MOOSE nonlinear and auxiliary systems.

Returns
The array of Kokkos systems{@

Definition at line 789 of file FEProblemBase.h.

789 { return _kokkos_systems; }
Moose::Kokkos::Array< Moose::Kokkos::System > _kokkos_systems

◆ getKokkosSystems() [2/2]

const Moose::Kokkos::Array<Moose::Kokkos::System>& FEProblemBase::getKokkosSystems ( ) const
inlineinherited

Definition at line 790 of file FEProblemBase.h.

791  {
792  return _kokkos_systems;
793  }
Moose::Kokkos::Array< Moose::Kokkos::System > _kokkos_systems

◆ getLinearConvergenceNames()

const std::vector< ConvergenceName > & FEProblemBase::getLinearConvergenceNames ( ) const
inherited

Gets the linear convergence object name(s).

Definition at line 9323 of file FEProblemBase.C.

Referenced by Moose::PetscSupport::petscLinearConverged().

9324 {
9326  return *_linear_convergence_names;
9327  mooseError("The linear convergence name(s) have not been set.");
9328 }
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
std::optional< std::vector< ConvergenceName > > _linear_convergence_names
Linear system(s) convergence name(s) (if any)

◆ getLinearSystem() [1/2]

LinearSystem & FEProblemBase::getLinearSystem ( unsigned int  sys_num)
inlineinherited

Get non-constant reference to a linear system.

Parameters
sys_numThe number of the linear system

Definition at line 3398 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep(), Moose::compute_linear_system(), ComputeLinearFVGreenGaussGradientFaceThread::operator()(), ComputeLinearFVGreenGaussGradientVolumeThread::operator()(), Moose::PetscSupport::petscSetDefaults(), and FEProblemSolve::solve().

3399 {
3400  mooseAssert(sys_num < _linear_systems.size(),
3401  "System number greater than the number of linear systems");
3402  return *_linear_systems[sys_num];
3403 }
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.

◆ getLinearSystem() [2/2]

const LinearSystem & FEProblemBase::getLinearSystem ( unsigned int  sys_num) const
inlineinherited

Get a constant reference to a linear system.

Parameters
sys_numThe number of the linear system

Definition at line 3406 of file FEProblemBase.h.

3407 {
3408  mooseAssert(sys_num < _linear_systems.size(),
3409  "System number greater than the number of linear systems");
3410  return *_linear_systems[sys_num];
3411 }
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.

◆ getLinearSystemNames()

const std::vector<LinearSystemName>& FEProblemBase::getLinearSystemNames ( ) const
inlineinherited
Returns
the linear system names in the problem

Definition at line 2636 of file FEProblemBase.h.

Referenced by PhysicsBase::initializePhysics(), and MultiSystemSolveObject::MultiSystemSolveObject().

2636 { return _linear_sys_names; }
const std::vector< LinearSystemName > _linear_sys_names
The linear system names.

◆ getLineSearch()

LineSearch* FEProblemBase::getLineSearch ( )
inlineoverridevirtualinherited

getter for the MOOSE line search

Implements SubProblem.

Definition at line 749 of file FEProblemBase.h.

Referenced by DisplacedProblem::getLineSearch().

749 { return _line_search.get(); }
std::shared_ptr< LineSearch > _line_search

◆ getMarkerWarehouse()

const MooseObjectWarehouse<Marker>& FEProblemBase::getMarkerWarehouse ( )
inlineinherited

Definition at line 1824 of file FEProblemBase.h.

1824 { return _markers; }
MooseObjectWarehouse< Marker > _markers

◆ getMaterial()

std::shared_ptr< MaterialBase > FEProblemBase::getMaterial ( std::string  name,
Moose::MaterialDataType  type,
const THREAD_ID  tid = 0,
bool  no_warn = false 
)
inherited

Return a pointer to a MaterialBase object.

If no_warn is true, suppress warning about retrieving a material reference potentially during the material's calculation.

This will return enabled or disabled objects, the main purpose is for iterative materials.

Definition at line 3854 of file FEProblemBase.C.

Referenced by MaterialPropertyInterface::getMaterialByName().

3858 {
3859  switch (type)
3860  {
3862  name += "_neighbor";
3863  break;
3865  name += "_face";
3866  break;
3867  default:
3868  break;
3869  }
3870 
3871  std::shared_ptr<MaterialBase> material = _all_materials[type].getActiveObject(name, tid);
3872  if (!no_warn && material->getParam<bool>("compute") && type == Moose::BLOCK_MATERIAL_DATA)
3873  mooseWarning("You are retrieving a Material object (",
3874  material->name(),
3875  "), but its compute flag is set to true. This indicates that MOOSE is "
3876  "computing this property which may not be desired and produce un-expected "
3877  "results.");
3878 
3879  return material;
3880 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< T > getActiveObject(const std::string &name, THREAD_ID tid=0) const
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:299
MaterialWarehouse _all_materials

◆ getMaterialData()

MaterialData & FEProblemBase::getMaterialData ( Moose::MaterialDataType  type,
const THREAD_ID  tid = 0,
const MooseObject object = nullptr 
) const
inherited
Returns
The MaterialData for the type type for thread tid

Definition at line 3883 of file FEProblemBase.C.

Referenced by BlockRestrictable::initializeBlockRestrictable(), and FEProblemBase::resizeMaterialData().

3886 {
3887  switch (type)
3888  {
3890  if (object)
3891  _material_props.addConsumer(type, object);
3892  return _material_props.getMaterialData(tid);
3894  if (object)
3900  if (object)
3903  }
3904 
3905  mooseError("FEProblemBase::getMaterialData(): Invalid MaterialDataType ", type);
3906 }
MaterialPropertyStorage & _bnd_material_props
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
void addConsumer(Moose::MaterialDataType type, const MooseObject *object)
Add object as the consumer of storage of type type.
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
MaterialPropertyStorage & _neighbor_material_props
const MaterialData & getMaterialData(const THREAD_ID tid) const
MaterialPropertyStorage & _material_props

◆ getMaterialPropertyBlockNames()

std::vector< SubdomainName > SubProblem::getMaterialPropertyBlockNames ( const std::string &  prop_name)
virtualinherited

Get a vector of block id equivalences that the material property is defined on.

Definition at line 489 of file SubProblem.C.

Referenced by MaterialPropertyInterface::getMaterialPropertyBlockNames().

490 {
491  std::set<SubdomainID> blocks = getMaterialPropertyBlocks(prop_name);
492  std::vector<SubdomainName> block_names;
493  block_names.reserve(blocks.size());
494  for (const auto & block_id : blocks)
495  {
496  SubdomainName name;
497  name = mesh().getMesh().subdomain_name(block_id);
498  if (name.empty())
499  {
500  std::ostringstream oss;
501  oss << block_id;
502  name = oss.str();
503  }
504  block_names.push_back(name);
505  }
506 
507  return block_names;
508 }
virtual MooseMesh & mesh()=0
char ** blocks
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition: MooseMesh.C:3488
std::string & subdomain_name(subdomain_id_type id)
virtual std::set< SubdomainID > getMaterialPropertyBlocks(const std::string &prop_name)
Get a vector containing the block ids the material property is defined on.
Definition: SubProblem.C:473

◆ getMaterialPropertyBlocks()

std::set< SubdomainID > SubProblem::getMaterialPropertyBlocks ( const std::string &  prop_name)
virtualinherited

Get a vector containing the block ids the material property is defined on.

Definition at line 473 of file SubProblem.C.

Referenced by SubProblem::getMaterialPropertyBlockNames(), and MaterialPropertyInterface::getMaterialPropertyBlocks().

474 {
475  std::set<SubdomainID> blocks;
476 
477  for (const auto & it : _map_block_material_props)
478  {
479  const std::set<std::string> & prop_names = it.second;
480  std::set<std::string>::iterator name_it = prop_names.find(prop_name);
481  if (name_it != prop_names.end())
482  blocks.insert(it.first);
483  }
484 
485  return blocks;
486 }
char ** blocks
std::map< SubdomainID, std::set< std::string > > _map_block_material_props
Map of material properties (block_id -> list of properties)
Definition: SubProblem.h:1052

◆ getMaterialPropertyBoundaryIDs()

std::set< BoundaryID > SubProblem::getMaterialPropertyBoundaryIDs ( const std::string &  prop_name)
virtualinherited

Get a vector containing the block ids the material property is defined on.

Definition at line 525 of file SubProblem.C.

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryIDs(), and SubProblem::getMaterialPropertyBoundaryNames().

526 {
527  std::set<BoundaryID> boundaries;
528 
529  for (const auto & it : _map_boundary_material_props)
530  {
531  const std::set<std::string> & prop_names = it.second;
532  std::set<std::string>::iterator name_it = prop_names.find(prop_name);
533  if (name_it != prop_names.end())
534  boundaries.insert(it.first);
535  }
536 
537  return boundaries;
538 }
std::map< BoundaryID, std::set< std::string > > _map_boundary_material_props
Map for boundary material properties (boundary_id -> list of properties)
Definition: SubProblem.h:1055

◆ getMaterialPropertyBoundaryNames()

std::vector< BoundaryName > SubProblem::getMaterialPropertyBoundaryNames ( const std::string &  prop_name)
virtualinherited

Get a vector of block id equivalences that the material property is defined on.

Definition at line 541 of file SubProblem.C.

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryNames().

542 {
543  std::set<BoundaryID> boundaries = getMaterialPropertyBoundaryIDs(prop_name);
544  std::vector<BoundaryName> boundary_names;
545  boundary_names.reserve(boundaries.size());
546  const BoundaryInfo & boundary_info = mesh().getMesh().get_boundary_info();
547 
548  for (const auto & bnd_id : boundaries)
549  {
550  BoundaryName name;
551  if (bnd_id == Moose::ANY_BOUNDARY_ID)
552  name = "ANY_BOUNDARY_ID";
553  else
554  {
555  name = boundary_info.get_sideset_name(bnd_id);
556  if (name.empty())
557  {
558  std::ostringstream oss;
559  oss << bnd_id;
560  name = oss.str();
561  }
562  }
563  boundary_names.push_back(name);
564  }
565 
566  return boundary_names;
567 }
virtual MooseMesh & mesh()=0
virtual std::set< BoundaryID > getMaterialPropertyBoundaryIDs(const std::string &prop_name)
Get a vector containing the block ids the material property is defined on.
Definition: SubProblem.C:525
const BoundaryInfo & get_boundary_info() const
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition: MooseMesh.C:3488
const std::string & get_sideset_name(boundary_id_type id) const
const BoundaryID ANY_BOUNDARY_ID
Definition: MooseTypes.C:21

◆ getMaterialPropertyRegistry()

const MaterialPropertyRegistry& FEProblemBase::getMaterialPropertyRegistry ( ) const
inlineinherited
Returns
A reference to the material property registry

Definition at line 1782 of file FEProblemBase.h.

Referenced by MaterialBase::checkStatefulSanity().

1783  {
1784  return _material_prop_registry;
1785  }
MaterialPropertyRegistry _material_prop_registry

◆ getMaterialPropertyStorage()

const MaterialPropertyStorage& FEProblemBase::getMaterialPropertyStorage ( )
inlineinherited

Return a reference to the material property storage.

Returns
A const reference to the material property storage

Definition at line 1792 of file FEProblemBase.h.

1792 { return _material_props; }
MaterialPropertyStorage & _material_props

◆ getMaterialPropertyStorageConsumers()

const std::set< const MooseObject * > & FEProblemBase::getMaterialPropertyStorageConsumers ( Moose::MaterialDataType  type) const
inherited
Returns
The consumers of the MaterialPropertyStorage for the type type

Definition at line 3909 of file FEProblemBase.C.

3910 {
3911  switch (type)
3912  {
3921  }
3922 
3923  mooseError("FEProblemBase::getMaterialPropertyStorageConsumers(): Invalid MaterialDataType ",
3924  type);
3925 }
MaterialPropertyStorage & _bnd_material_props
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
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
const std::set< const MooseObject * > & getConsumers(Moose::MaterialDataType type) const
MaterialPropertyStorage & _neighbor_material_props
MaterialPropertyStorage & _material_props

◆ getMaterialWarehouse()

const MaterialWarehouse& FEProblemBase::getMaterialWarehouse ( ) const
inlineinherited

◆ getMatrixTagID()

TagID SubProblem::getMatrixTagID ( const TagName &  tag_name) const
virtualinherited

Get a TagID from a TagName.

Reimplemented in DisplacedProblem.

Definition at line 342 of file SubProblem.C.

Referenced by Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), ExplicitTimeIntegrator::ExplicitTimeIntegrator(), DisplacedProblem::getMatrixTagID(), TaggingInterface::TaggingInterface(), and TaggingInterface::useMatrixTag().

343 {
344  auto tag_name_upper = MooseUtils::toUpper(tag_name);
345 
346  if (!matrixTagExists(tag_name))
347  mooseError("Matrix tag: ",
348  tag_name,
349  " does not exist. ",
350  "If this is a TimeKernel then this may have happened because you didn't "
351  "specify a Transient Executioner.");
352 
353  return _matrix_tag_name_to_tag_id.at(tag_name_upper);
354 }
std::map< TagName, TagID > _matrix_tag_name_to_tag_id
The currently declared tags.
Definition: SubProblem.h:1041
std::string toUpper(std::string name)
Convert supplied string to upper case.
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
virtual bool matrixTagExists(const TagName &tag_name) const
Check to see if a particular Tag exists.
Definition: SubProblem.C:328

◆ getMatrixTags()

virtual std::map<TagName, TagID>& SubProblem::getMatrixTags ( )
inlinevirtualinherited

Return all matrix tags in the system, where a tag is represented by a map from name to ID.

Definition at line 253 of file SubProblem.h.

Referenced by NonlinearSystemBase::computeJacobian(), FEProblemBase::computeJacobian(), EigenProblem::computeJacobianAB(), NonlinearSystemBase::computeJacobianBlocks(), EigenProblem::computeJacobianTag(), FEProblemBase::computeLinearSystemSys(), and FEProblemBase::computeResidualAndJacobian().

253 { return _matrix_tag_name_to_tag_id; }
std::map< TagName, TagID > _matrix_tag_name_to_tag_id
The currently declared tags.
Definition: SubProblem.h:1041

◆ getMaxQps()

unsigned int FEProblemBase::getMaxQps ( ) const
inherited
Returns
The maximum number of quadrature points in use on any element in this problem.

Definition at line 1625 of file FEProblemBase.C.

Referenced by MaterialBase::getMaxQps(), MaterialPropertyInterface::getMaxQps(), FEProblemBase::initialSetup(), FEProblemBase::reinitDirac(), Material::subdomainSetup(), and FEProblemBase::updateMaxQps().

1626 {
1628  mooseError("Max QPS uninitialized");
1629  return _max_qps;
1630 }
auto max(const L &left, const R &right)
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:271
unsigned int _max_qps
Maximum number of quadrature points used in the problem.

◆ getMaxScalarOrder()

Order FEProblemBase::getMaxScalarOrder ( ) const
inherited
Returns
The maximum order for all scalar variables in this problem's systems.

Definition at line 1633 of file FEProblemBase.C.

Referenced by ScalarCoupleable::coupledScalarOrder(), ScalarCoupleable::getADDefaultValue(), and ScalarCoupleable::getDefaultValue().

1634 {
1635  return _max_scalar_order;
1636 }
libMesh::Order _max_scalar_order
Maximum scalar variable order.

◆ getMeshDisplacementGridFunction()

std::optional< std::reference_wrapper< mfem::ParGridFunction const > > MFEMProblem::getMeshDisplacementGridFunction ( )

Returns optional reference to the displacement GridFunction to apply to nodes.

Definition at line 444 of file MFEMProblem.C.

Referenced by displaceMesh().

445 {
446  // If C++23 transform were available this would be easier
447  auto const displacement_variable = mesh().getMeshDisplacementVariable();
448  if (displacement_variable)
449  {
450  return *_problem_data.gridfunctions.Get(displacement_variable.value());
451  }
452  else
453  {
454  return std::nullopt;
455  }
456 }
std::optional< std::reference_wrapper< std::string const > > getMeshDisplacementVariable() const
Returns an optional reference to displacement variable name.
Definition: MFEMMesh.h:62
virtual MFEMMesh & mesh() override
Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMes...
Definition: MFEMProblem.C:465
MFEMProblemData _problem_data
Definition: MFEMProblem.h:209
T * Get(const std::string &field_name) const
Returns a non-owning pointer to the field. This is guaranteed to return a non-null pointer...
Moose::MFEM::GridFunctions gridfunctions

◆ getMeshDivision()

MeshDivision & FEProblemBase::getMeshDivision ( const std::string &  name,
const THREAD_ID  tid = 0 
) const
inherited

Get a MeshDivision.

Definition at line 2690 of file FEProblemBase.C.

Referenced by NestedDivision::NestedDivision().

2691 {
2692  auto * const ret = dynamic_cast<MeshDivision *>(_mesh_divisions.getActiveObject(name, tid).get());
2693  if (!ret)
2694  mooseError("No MeshDivision object named ", name, " of appropriate type");
2695  return *ret;
2696 }
Base class for MeshDivision objects.
Definition: MeshDivision.h:35
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< T > getActiveObject(const std::string &name, THREAD_ID tid=0) const
MooseObjectWarehouse< MeshDivision > _mesh_divisions
Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the ...
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

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const
inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), DefaultConvergenceBase::getSharedExecutionerParam(), ChainControlDataPostprocessor::initialSetup(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

87 { return _app; }
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357

◆ getMortarInterface() [1/2]

const AutomaticMortarGeneration & FEProblemBase::getMortarInterface ( const std::pair< BoundaryID, BoundaryID > &  primary_secondary_boundary_pair,
const std::pair< SubdomainID, SubdomainID > &  primary_secondary_subdomain_pair,
bool  on_displaced 
) const
inherited

Return the undisplaced or displaced mortar generation object associated with the provided boundaries and subdomains.

Definition at line 7992 of file FEProblemBase.C.

7996 {
7998  primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
7999 }
const AutomaticMortarGeneration & getMortarInterface(const std::pair< BoundaryID, BoundaryID > &boundary_key, const std::pair< SubdomainID, SubdomainID > &, bool on_displaced) const
Getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and subdomain k...
Definition: MortarData.C:116
MortarData _mortar_data

◆ getMortarInterface() [2/2]

AutomaticMortarGeneration & FEProblemBase::getMortarInterface ( const std::pair< BoundaryID, BoundaryID > &  primary_secondary_boundary_pair,
const std::pair< SubdomainID, SubdomainID > &  primary_secondary_subdomain_pair,
bool  on_displaced 
)
inherited

Definition at line 8002 of file FEProblemBase.C.

8006 {
8008  primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
8009 }
const AutomaticMortarGeneration & getMortarInterface(const std::pair< BoundaryID, BoundaryID > &boundary_key, const std::pair< SubdomainID, SubdomainID > &, bool on_displaced) const
Getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and subdomain k...
Definition: MortarData.C:116
MortarData _mortar_data

◆ getMortarInterfaces()

const std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > & FEProblemBase::getMortarInterfaces ( bool  on_displaced) const
inherited

Definition at line 8012 of file FEProblemBase.C.

Referenced by FEProblemBase::computeUserObjectsInternal(), and NonlinearSystemBase::initialSetup().

8013 {
8014  return _mortar_data.getMortarInterfaces(on_displaced);
8015 }
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > & getMortarInterfaces(bool on_displaced) const
Return all automatic mortar generation objects on either the displaced or undisplaced mesh...
Definition: MortarData.h:73
MortarData _mortar_data

◆ getMultiApp()

std::shared_ptr< MultiApp > FEProblemBase::getMultiApp ( const std::string &  multi_app_name) const
inherited

Get a MultiApp object by name.

Definition at line 5457 of file FEProblemBase.C.

Referenced by FEProblemBase::addTransfer(), MultiAppPositions::initialize(), and MultiAppTransfer::MultiAppTransfer().

5458 {
5459  return _multi_apps.getObject(multi_app_name);
5460 }
std::shared_ptr< T > getObject(const std::string &name, THREAD_ID tid=0) const
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.

◆ getMultiAppFixedPointConvergenceName()

const ConvergenceName & FEProblemBase::getMultiAppFixedPointConvergenceName ( ) const
inherited

Gets the MultiApp fixed point convergence object name.

Definition at line 9331 of file FEProblemBase.C.

Referenced by FEProblemBase::addDefaultMultiAppFixedPointConvergence(), FixedPointSolve::examineFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), SteffensenSolve::initialSetup(), FixedPointSolve::initialSetup(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

9332 {
9335  else
9336  mooseError("The fixed point convergence name has not been set.");
9337 }
std::optional< ConvergenceName > _multiapp_fixed_point_convergence_name
MultiApp fixed point convergence name.
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

◆ getMultiAppTransferWarehouse()

const ExecuteMooseObjectWarehouse< Transfer > & FEProblemBase::getMultiAppTransferWarehouse ( Transfer::DIRECTION  direction) const
inherited

Return the complete warehouse for MultiAppTransfer object for the given direction.

Definition at line 5552 of file FEProblemBase.C.

5553 {
5554  if (direction == MultiAppTransfer::TO_MULTIAPP)
5555  return _to_multi_app_transfers;
5556  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
5558  else
5560 }
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.

◆ getMultiAppWarehouse()

ExecuteMooseObjectWarehouse<MultiApp>& FEProblemBase::getMultiAppWarehouse ( )
inlineinherited

Definition at line 2239 of file FEProblemBase.h.

Referenced by MooseApp::errorCheck().

2239 { return _multi_apps; }
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.

◆ getNeighborMaterialPropertyStorage()

const MaterialPropertyStorage& FEProblemBase::getNeighborMaterialPropertyStorage ( )
inlineinherited

Definition at line 1794 of file FEProblemBase.h.

1795  {
1796  return _neighbor_material_props;
1797  }
MaterialPropertyStorage & _neighbor_material_props

◆ getNonlinearConvergenceNames()

const std::vector< ConvergenceName > & FEProblemBase::getNonlinearConvergenceNames ( ) const
inherited

Gets the nonlinear system convergence object name(s).

Definition at line 9299 of file FEProblemBase.C.

Referenced by ReferenceResidualProblem::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), FEProblemSolve::convergenceSetup(), and Moose::PetscSupport::petscNonlinearConverged().

9300 {
9303  mooseError("The nonlinear system convergence name(s) have not been set.");
9304 }
std::optional< std::vector< ConvergenceName > > _nonlinear_convergence_names
Nonlinear system(s) convergence name(s)
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

◆ getNonlinearEvaluableElementRange()

const ConstElemRange & FEProblemBase::getNonlinearEvaluableElementRange ( )
inherited

Definition at line 867 of file FEProblemBase.C.

Referenced by ElemSideNeighborLayersTester::execute().

868 {
870  {
871  std::vector<const DofMap *> dof_maps(_nl.size());
872  for (const auto i : index_range(dof_maps))
873  dof_maps[i] = &_nl[i]->dofMap();
875  std::make_unique<ConstElemRange>(_mesh.getMesh().multi_evaluable_elements_begin(dof_maps),
876  _mesh.getMesh().multi_evaluable_elements_end(dof_maps));
877  }
878 
880 }
std::unique_ptr< libMesh::ConstElemRange > _nl_evaluable_local_elem_range
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition: MooseMesh.C:3488
MooseMesh & _mesh
auto index_range(const T &sizable)

◆ getNonlinearSystem()

NonlinearSystem & FEProblemBase::getNonlinearSystem ( const unsigned int  sys_num)
virtualinherited

Reimplemented in FEProblem.

Definition at line 2705 of file FEProblemBase.C.

Referenced by PNGOutput::calculateRescalingValues(), and PNGOutput::makeMeshFunc().

2706 {
2707  mooseDeprecated("FEProblemBase::getNonlinearSystem() is deprecated, please use "
2708  "FEProblemBase::getNonlinearSystemBase() \n");
2709 
2710  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
2711  auto nl_sys = std::dynamic_pointer_cast<NonlinearSystem>(_nl[sys_num]);
2712 
2713  if (!nl_sys)
2714  mooseError("This is not a NonlinearSystem");
2715 
2716  return *nl_sys;
2717 }
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
Nonlinear system to be solved.
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

◆ getNonlinearSystemBase() [1/2]

NonlinearSystemBase & FEProblemBase::getNonlinearSystemBase ( const unsigned int  sys_num)
inlineinherited

Definition at line 3354 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep(), Adaptivity::adaptMesh(), DisplacedProblem::addTimeIntegrator(), ADKernelTempl< T >::ADKernelTempl(), ElementSubdomainModifierBase::applyIC(), ArrayKernel::ArrayKernel(), Eigenvalue::checkIntegrity(), PseudoTimestep::currentResidualNorm(), DisplacedProblem::DisplacedProblem(), AB2PredictorCorrector::estimateTimeError(), VariableResidual::execute(), MatrixSymmetryCheck::execute(), GreaterThanLessThanPostprocessor::execute(), Executioner::Executioner(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), NumResidualEvaluations::getValue(), Residual::getValue(), Adaptivity::init(), ReferenceResidualConvergence::initialSetup(), ActivateElementsUserObjectBase::initSolutions(), Kernel::Kernel(), BoundaryElemIntegrityCheckThread::operator()(), DOFMapOutput::output(), SolutionHistory::output(), ConsoleUtils::outputExecutionInformation(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Moose::PetscSupport::setLineSearchFromParams(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), AB2PredictorCorrector::step(), DisplacedProblem::syncSolutions(), and Console::writeVariableNorms().

3355 {
3356  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3357  return *_nl[sys_num];
3358 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ getNonlinearSystemBase() [2/2]

const NonlinearSystemBase & FEProblemBase::getNonlinearSystemBase ( const unsigned int  sys_num) const
inlineinherited

Definition at line 3361 of file FEProblemBase.h.

3362 {
3363  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3364  return *_nl[sys_num];
3365 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ getNonlinearSystemNames()

const std::vector<NonlinearSystemName>& FEProblemBase::getNonlinearSystemNames ( ) const
inlineinherited
Returns
the nolinear system names in the problem

Definition at line 2632 of file FEProblemBase.h.

Referenced by PhysicsBase::initializePhysics(), Console::meshChanged(), MultiSystemSolveObject::MultiSystemSolveObject(), ConsoleUtils::outputExecutionInformation(), and Console::outputSystemInformation().

2632 { return _nl_sys_names; }
const std::vector< NonlinearSystemName > _nl_sys_names
The nonlinear system names.

◆ getNumCyclesCompleted()

unsigned int FEProblemBase::getNumCyclesCompleted ( )
inlineinherited
Returns
The number of adaptivity cycles completed.

Definition at line 1860 of file FEProblemBase.h.

1860 { return _cycles_completed; }
unsigned int _cycles_completed

◆ getParam() [1/2]

template<typename T >
const T & MooseBase::getParam ( const std::string &  name) const
inherited

Retrieve a parameter for the object.

Parameters
nameThe name of the parameter
Returns
The value of the parameter

Definition at line 388 of file MooseBase.h.

Referenced by CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FEProblemBase::addOutput(), DiffusionPhysicsBase::addPostprocessors(), ADNodalKernel::ADNodalKernel(), ArrayParsedAux::ArrayParsedAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), ComponentPhysicsInterface::ComponentPhysicsInterface(), FunctorAux::computeValue(), Console::Console(), FEProblemBase::createTagSolutions(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), AccumulateReporter::declareLateValues(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), FEProblemSolve::FEProblemSolve(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ParsedSubdomainGeneratorBase::functionInitialize(), FVInterfaceKernel::FVInterfaceKernel(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), MeshExtruderGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), GhostingUserObject::GhostingUserObject(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), IterationAdaptiveDT::init(), AdvancedOutput::init(), AttribThread::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MultiSystemSolveObject::MultiSystemSolveObject(), NEML2ModelExecutor::NEML2ModelExecutor(), NestedDivision::NestedDivision(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), Output::setWallTimeIntervalFromCommandLineParam(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

389 {
390  return InputParameters::getParamHelper<T>(name, _pars);
391 }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ getParam() [2/2]

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > > MooseBase::getParam ( const std::string &  param1,
const std::string &  param2 
) const
inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters
param1The name of first parameter
param2The name of second parameter
Returns
Vector of pairs of first and second parameters

Definition at line 425 of file MooseBase.h.

426 {
427  return _pars.get<T1, T2>(param1, param2);
428 }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.

◆ getPetscOptions()

Moose::PetscSupport::PetscOptions& FEProblemBase::getPetscOptions ( )
inlineinherited

◆ getPositionsObject()

const Positions & FEProblemBase::getPositionsObject ( const std::string &  name) const
inherited

Get the Positions object by its name.

Parameters
nameThe name of the Positions object being retrieved
Returns
Const reference to the Positions object

Definition at line 4524 of file FEProblemBase.C.

Referenced by DistributedPositions::DistributedPositions(), MultiApp::fillPositions(), ParsedDownSelectionPositions::initialize(), Positions::initialized(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), and TransformedPositions::TransformedPositions().

4525 {
4526  std::vector<Positions *> objs;
4527  theWarehouse()
4528  .query()
4529  .condition<AttribSystem>("UserObject")
4530  .condition<AttribName>(name)
4531  .queryInto(objs);
4532  if (objs.empty())
4533  mooseError("Unable to find Positions object with name '" + name + "'");
4534  mooseAssert(objs.size() == 1, "Should only find one Positions");
4535  return *(objs[0]);
4536 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
TheWarehouse & theWarehouse() const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
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
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ getPostprocessorValueByName()

const PostprocessorValue & FEProblemBase::getPostprocessorValueByName ( const PostprocessorName &  name,
std::size_t  t_index = 0 
) const
inherited

Get a read-only reference to the value associated with a Postprocessor that exists.

Parameters
nameThe name of the post-processor
t_indexFlag for getting current (0), old (1), or older (2) values
Returns
The reference to the value at the given time index

Note: This method is only for retrieving values that already exist, the Postprocessor and PostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

Definition at line 4558 of file FEProblemBase.C.

Referenced by addPostprocessor(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiApp::appPostprocessorValue(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), EigenProblem::formNorm(), MooseParsedFunctionWrapper::initialize(), ParsedConvergence::initializePostprocessorSymbol(), EigenExecutionerBase::inversePowerIteration(), Exodus::outputPostprocessors(), TableOutput::outputPostprocessorsRow(), EigenProblem::postScaleEigenVector(), and TableOutput::shouldOutputPostprocessorsRow().

4560 {
4562  t_index);
4563 }
ReporterData _reporter_data
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const T & getReporterValue(const ReporterName &reporter_name, const MooseObject &consumer, const ReporterMode &mode, const std::size_t time_index=0) const
Method for returning read only references to Reporter values.
Definition: ReporterData.h:388
Real PostprocessorValue
various MOOSE typedefs
Definition: MooseTypes.h:202
A ReporterName that represents a Postprocessor.
Definition: ReporterName.h:143

◆ getProblemData()

MFEMProblemData& MFEMProblem::getProblemData ( )
inline

Method to get the current MFEMProblemData object storing the current data specifying the FE problem.

Definition at line 186 of file MFEMProblem.h.

Referenced by addBoundaryCondition(), addFESpace(), addGridFunction(), addKernel(), addMFEMNonlinearSolver(), addMFEMSolver(), addSubMesh(), setMesh(), solverTypeString(), and MultiAppMFEMCopyTransfer::transfer().

186 { return _problem_data; }
MFEMProblemData _problem_data
Definition: MFEMProblem.h:209

◆ getRegularMaterialsWarehouse()

const MaterialWarehouse& FEProblemBase::getRegularMaterialsWarehouse ( ) const
inlineinherited

Definition at line 2034 of file FEProblemBase.h.

Referenced by Moose::Mortar::setupMortarMaterials().

2034 { return _materials; }
MaterialWarehouse _materials

◆ getRenamedParam()

template<typename T >
const T & MooseBase::getRenamedParam ( const std::string &  old_name,
const std::string &  new_name 
) const
inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters
old_namethe old name for the parameter
new_namethe new name for the parameter

Definition at line 402 of file MooseBase.h.

403 {
404  // Most important: accept new parameter
405  if (isParamSetByUser(new_name) && !isParamValid(old_name))
406  return getParam<T>(new_name);
407  // Second most: accept old parameter
408  if (isParamValid(old_name) && !isParamSetByUser(new_name))
409  return getParam<T>(old_name);
410  // Third most: accept default for new parameter
411  if (isParamValid(new_name) && !isParamValid(old_name))
412  return getParam<T>(new_name);
413  // Refuse: no default, no value passed
414  if (!isParamValid(old_name) && !isParamValid(new_name))
415  mooseError("parameter '" + new_name +
416  "' is being retrieved without being set.\nDid you misspell it?");
417  // Refuse: both old and new parameters set by user
418  else
419  mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
420  old_name + "'");
421 }
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
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:199
bool isParamSetByUser(const std::string &name) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
Definition: MooseBase.h:205

◆ getReporterData() [1/2]

const ReporterData& FEProblemBase::getReporterData ( ) const
inlineinherited

Provides const access the ReporterData object.

NOTE: There is a private non-const version of this function that uses a key object only constructable by the correct interfaces. This was done by design to encourage the use of the Reporter and ReporterInterface classes.

Definition at line 1202 of file FEProblemBase.h.

Referenced by ReporterTransferInterface::addReporterTransferMode(), ReporterTransferInterface::checkHasReporterValue(), ReporterTransferInterface::clearVectorReporter(), ConstantPostprocessor::ConstantPostprocessor(), AccumulateReporter::declareAccumulateHelper(), ReporterTransferInterface::declareClone(), AccumulateReporter::declareLateValues(), VectorPostprocessor::declareVector(), ReporterTransferInterface::declareVectorClone(), FEProblemBase::execute(), PostprocessorInterface::getPostprocessorValueByNameInternal(), VectorPostprocessorInterface::getVectorPostprocessorByNameHelper(), VectorPostprocessorInterface::getVectorPostprocessorContextByNameHelper(), PostprocessorInterface::hasPostprocessorByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), ReporterPositions::initialize(), ReporterTimes::initialize(), MooseParsedFunctionWrapper::initialize(), ParsedConvergence::initializeSymbols(), JSONOutput::initialSetup(), PostprocessorInterface::isDefaultPostprocessorValueByName(), ReporterDebugOutput::output(), Receiver::Receiver(), ReporterTransferInterface::resizeReporter(), ReporterTransferInterface::sumVectorReporter(), ReporterTransferInterface::transferFromVectorReporter(), ReporterTransferInterface::transferReporter(), and ReporterTransferInterface::transferToVectorReporter().

1202 { return _reporter_data; }
ReporterData _reporter_data

◆ getReporterData() [2/2]

ReporterData& FEProblemBase::getReporterData ( ReporterData::WriteKey  )
inlineinherited

Provides non-const access the ReporterData object that is used to store reporter values.

see ReporterData.h

Definition at line 1209 of file FEProblemBase.h.

1209 { return _reporter_data; }
ReporterData _reporter_data

◆ getRestartableData()

template<typename T , typename... Args>
const T & Restartable::getRestartableData ( const std::string &  data_name) const
protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

NOTE: This returns a const reference! Make sure you store it in a const reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)

Definition at line 294 of file Restartable.h.

295 {
296  return declareRestartableDataHelper<T>(data_name, nullptr).get();
297 }

◆ getSampler()

Sampler & FEProblemBase::getSampler ( const std::string &  name,
const THREAD_ID  tid = 0 
)
virtualinherited

Definition at line 2753 of file FEProblemBase.C.

Referenced by SamplerInterface::getSampler(), and SamplerInterface::getSamplerByName().

2754 {
2755  std::vector<Sampler *> objs;
2756  theWarehouse()
2757  .query()
2758  .condition<AttribSystem>("Sampler")
2759  .condition<AttribThread>(tid)
2760  .condition<AttribName>(name)
2761  .queryInto(objs);
2762  if (objs.empty())
2763  mooseError(
2764  "Unable to find Sampler with name '" + name +
2765  "', if you are attempting to access this object in the constructor of another object then "
2766  "the object being retrieved must occur prior to the caller within the input file.");
2767  return *(objs[0]);
2768 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
TheWarehouse & theWarehouse() const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
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
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ getScalarVariable()

MooseVariableScalar & FEProblemBase::getScalarVariable ( const THREAD_ID  tid,
const std::string &  var_name 
)
overridevirtualinherited

Returns the scalar variable reference from whichever system contains it.

Implements SubProblem.

Definition at line 5911 of file FEProblemBase.C.

Referenced by FEProblemBase::addInitialCondition(), EigenProblem::adjustEigenVector(), MultiAppScalarToAuxScalarTransfer::execute(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), TableOutput::outputScalarVariables(), and Exodus::outputScalarVariables().

5912 {
5913  for (auto & sys : _solver_systems)
5914  if (sys->hasScalarVariable(var_name))
5915  return sys->getScalarVariable(tid, var_name);
5916  if (_aux->hasScalarVariable(var_name))
5917  return _aux->getScalarVariable(tid, var_name);
5918 
5919  mooseError("Unknown variable " + var_name);
5920 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
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

◆ getSharedPtr() [1/2]

std::shared_ptr< MooseObject > MooseObject::getSharedPtr ( )
inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 68 of file MooseObject.C.

Referenced by addBoundaryCondition(), addKernel(), and addMFEMSolver().

69 {
70  try
71  {
72  return shared_from_this();
73  }
74  catch (std::bad_weak_ptr &)
75  {
76  mooseError(not_shared_error);
77  }
78 }
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

◆ getSharedPtr() [2/2]

std::shared_ptr< const MooseObject > MooseObject::getSharedPtr ( ) const
inherited

Definition at line 81 of file MooseObject.C.

82 {
83  try
84  {
85  return shared_from_this();
86  }
87  catch (std::bad_weak_ptr &)
88  {
89  mooseError(not_shared_error);
90  }
91 }
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

◆ getSolverSystem() [1/2]

SolverSystem & FEProblemBase::getSolverSystem ( unsigned int  sys_num)
inlineinherited

Get non-constant reference to a solver system.

Parameters
sys_numThe number of the solver system

Definition at line 3368 of file FEProblemBase.h.

Referenced by MooseApp::attachRelationshipManagers(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), MultiSystemSolveObject::MultiSystemSolveObject(), ConsoleUtils::outputSolverSystemInformation(), Moose::PetscSupport::petscSetDefaultKSPNormType(), and Moose::PetscSupport::petscSetDefaultPCSide().

3369 {
3370  mooseAssert(sys_num < _solver_systems.size(),
3371  "System number greater than the number of solver systems");
3372  return *_solver_systems[sys_num];
3373 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.

◆ getSolverSystem() [2/2]

const SolverSystem & FEProblemBase::getSolverSystem ( unsigned int  sys_num) const
inlineinherited

Get a constant reference to a solver system.

Parameters
sys_numThe number of the solver system

Definition at line 3376 of file FEProblemBase.h.

3377 {
3378  mooseAssert(sys_num < _solver_systems.size(),
3379  "System number greater than the number of solver systems");
3380  return *_solver_systems[sys_num];
3381 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.

◆ getSolverSystemNames()

const std::vector<SolverSystemName>& FEProblemBase::getSolverSystemNames ( ) const
inlineinherited
Returns
the solver system names in the problem

Definition at line 2640 of file FEProblemBase.h.

Referenced by ConsoleUtils::outputExecutionInformation().

2640 { return _solver_sys_names; }
std::vector< SolverSystemName > _solver_sys_names
The union of nonlinear and linear system names.

◆ getStandardVariable()

MooseVariable & FEProblemBase::getStandardVariable ( const THREAD_ID  tid,
const std::string &  var_name 
)
overridevirtualinherited

Returns the variable reference for requested MooseVariable which may be in any system.

Implements SubProblem.

Definition at line 5851 of file FEProblemBase.C.

Referenced by CoupleableMooseVariableDependencyIntermediateInterface::coupledValueByName(), FEProblemBase::projectFunctionOnCustomRange(), LinearFVKernel::requestVariableCellGradient(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

5852 {
5853  for (auto & sys : _solver_systems)
5854  if (sys->hasVariable(var_name))
5855  return sys->getFieldVariable<Real>(tid, var_name);
5856  if (_aux->hasVariable(var_name))
5857  return _aux->getFieldVariable<Real>(tid, var_name);
5858 
5859  mooseError("Unknown variable " + var_name);
5860 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
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

◆ getSteadyStateConvergenceName()

const ConvergenceName & FEProblemBase::getSteadyStateConvergenceName ( ) const
inherited

Gets the steady-state detection convergence object name.

Definition at line 9340 of file FEProblemBase.C.

Referenced by FEProblemBase::addDefaultSteadyStateConvergence(), TransientBase::convergedToSteadyState(), and TransientBase::init().

9341 {
9343  return _steady_state_convergence_name.value();
9344  else
9345  mooseError("The steady convergence name has not been set.");
9346 }
std::optional< ConvergenceName > _steady_state_convergence_name
Steady-state detection convergence name.
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

◆ getSystem()

System & FEProblemBase::getSystem ( const std::string &  var_name)
overridevirtualinherited

Returns the equation system containing the variable provided.

Implements SubProblem.

Definition at line 5923 of file FEProblemBase.C.

Referenced by FEProblemBase::addObjectParamsHelper(), MultiApp::appTransferVector(), ElementSubdomainModifierBase::gatherPatchElements(), FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

5924 {
5925  const auto [var_in_sys, sys_num] = determineSolverSystem(var_name);
5926  if (var_in_sys)
5927  return _solver_systems[sys_num]->system();
5928  else if (_aux->hasVariable(var_name) || _aux->hasScalarVariable(var_name))
5929  return _aux->system();
5930  else
5931  mooseError("Unable to find a system containing the variable " + var_name);
5932 }
virtual std::pair< bool, unsigned int > determineSolverSystem(const std::string &var_name, bool error_if_not_found=false) const override
Determine what solver system the provided variable name lies in.
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
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

◆ getSystemBase() [1/3]

const SystemBase & FEProblemBase::getSystemBase ( const unsigned int  sys_num) const
virtualinherited

Get constant reference to a system in this problem.

Parameters
sys_numThe number of the system

Definition at line 9053 of file FEProblemBase.C.

Referenced by FEProblemBase::addObjectParamsHelper(), PhysicsBase::copyVariablesFromMesh(), FEProblemBase::getSystemBase(), FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

9054 {
9055  if (sys_num < _solver_systems.size())
9056  return *_solver_systems[sys_num];
9057 
9058  return *_aux;
9059 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ getSystemBase() [2/3]

SystemBase & FEProblemBase::getSystemBase ( const unsigned int  sys_num)
virtualinherited

Get non-constant reference to a system in this problem.

Parameters
sys_numThe number of the system

Definition at line 9074 of file FEProblemBase.C.

9075 {
9076  if (sys_num < _solver_systems.size())
9077  return *_solver_systems[sys_num];
9078 
9079  return *_aux;
9080 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ getSystemBase() [3/3]

SystemBase & FEProblemBase::getSystemBase ( const std::string &  sys_name)
inherited

Get non-constant reference to a system in this problem.

Parameters
sys_nameThe name of the system

Definition at line 9062 of file FEProblemBase.C.

9063 {
9064  if (std::find(_solver_sys_names.begin(), _solver_sys_names.end(), sys_name) !=
9065  _solver_sys_names.end())
9066  return getSystemBase(solverSysNum(sys_name));
9067  else if (sys_name == "aux0")
9068  return *_aux;
9069  else
9070  mooseError("System '" + sys_name + "' was requested from problem but does not exist.");
9071 }
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:30
std::vector< SolverSystemName > _solver_sys_names
The union of nonlinear and linear system names.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
virtual const SystemBase & getSystemBase(const unsigned int sys_num) const
Get constant reference to a system in this problem.
unsigned int solverSysNum(const SolverSystemName &solver_sys_name) const override
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

◆ getTimeFromStateArg()

Real FEProblemBase::getTimeFromStateArg ( const Moose::StateArg state) const
inherited

Returns the time associated with the requested state.

Definition at line 6897 of file FEProblemBase.C.

Referenced by Function::evaluate(), Function::evaluateDotHelper(), Function::evaluateGradientHelper(), Function::evaluateHelper(), and ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl().

6898 {
6900  // If we are any iteration type other than time (e.g. nonlinear), then temporally we are still
6901  // in the present time
6902  return time();
6903 
6904  switch (state.state)
6905  {
6906  case 0:
6907  return time();
6908 
6909  case 1:
6910  return timeOld();
6911 
6912  default:
6913  mooseError("Unhandled state ", state.state, " in FEProblemBase::getTimeFromStateArg");
6914  }
6915 }
virtual Real & time() const
SolutionIterationType iteration_type
The solution iteration type, e.g. time or nonlinear.
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
virtual Real & timeOld() const
unsigned int state
The state.

◆ getTransfers() [1/2]

std::vector< std::shared_ptr< Transfer > > FEProblemBase::getTransfers ( ExecFlagType  type,
Transfer::DIRECTION  direction 
) const
inherited

Get Transfers by ExecFlagType and direction.

Definition at line 5530 of file FEProblemBase.C.

5531 {
5532  if (direction == MultiAppTransfer::TO_MULTIAPP)
5534  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
5536  else
5538 }
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
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...
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.

◆ getTransfers() [2/2]

std::vector< std::shared_ptr< Transfer > > FEProblemBase::getTransfers ( Transfer::DIRECTION  direction) const
inherited

Definition at line 5541 of file FEProblemBase.C.

5542 {
5543  if (direction == MultiAppTransfer::TO_MULTIAPP)
5545  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
5547  else
5549 }
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
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...
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.

◆ getUserObject()

template<class T >
T& FEProblemBase::getUserObject ( const std::string &  name,
unsigned int  tid = 0 
) const
inlineinherited

Get the user object by its name.

Parameters
nameThe name of the user object being retrieved
Returns
Const reference to the user object

Definition at line 1229 of file FEProblemBase.h.

Referenced by ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ReporterTransferInterface::hideVariableHelper(), EigenExecutionerBase::init(), Eigenvalue::init(), IntegralPreservingFunctionIC::initialSetup(), ElementSubdomainModifierBase::initialSetup(), and EigenExecutionerBase::inversePowerIteration().

1230  {
1231  std::vector<T *> objs;
1232  theWarehouse()
1233  .query()
1234  .condition<AttribSystem>("UserObject")
1235  .condition<AttribThread>(tid)
1236  .condition<AttribName>(name)
1237  .queryInto(objs);
1238  if (objs.empty())
1239  mooseError("Unable to find user object with name '" + name + "'");
1240  return *(objs[0]);
1241  }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
TheWarehouse & theWarehouse() const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
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
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ getUserObjectBase()

const UserObject & FEProblemBase::getUserObjectBase ( const std::string &  name,
const THREAD_ID  tid = 0 
) const
inherited

Get the user object by its name.

Parameters
nameThe name of the user object being retrieved
tidThe thread of the user object (defaults to 0)
Returns
Const reference to the user object

Definition at line 4508 of file FEProblemBase.C.

Referenced by addBoundaryCondition(), addKernel(), FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiApp::appUserObjectBase(), EigenProblem::checkProblemIntegrity(), FunctorAux::computeValue(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectFromFEProblem(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), Terminator::initialSetup(), and FunctorIC::value().

4509 {
4510  std::vector<UserObject *> objs;
4511  theWarehouse()
4512  .query()
4513  .condition<AttribSystem>("UserObject")
4514  .condition<AttribThread>(tid)
4515  .condition<AttribName>(name)
4516  .queryInto(objs);
4517  if (objs.empty())
4518  mooseError("Unable to find user object with name '" + name + "'");
4519  mooseAssert(objs.size() == 1, "Should only find one UO");
4520  return *(objs[0]);
4521 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
TheWarehouse & theWarehouse() const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
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
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ getUserObjectJacobianVariables()

const std::vector<const MooseVariableFEBase *>& FEProblemBase::getUserObjectJacobianVariables ( const THREAD_ID  tid) const
inlineinherited

Definition at line 321 of file FEProblemBase.h.

Referenced by ComputeUserObjectsThread::onBoundary(), and ComputeUserObjectsThread::onElement().

322  {
323  return _uo_jacobian_moose_vars[tid];
324  }
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars

◆ getUserObjects()

const ExecuteMooseObjectWarehouse<UserObject>& FEProblemBase::getUserObjects ( ) const
inlineinherited

Definition at line 1216 of file FEProblemBase.h.

1217  {
1219  "This function is deprecated, use theWarehouse().query() to construct a query instead");
1220  return _all_user_objects;
1221  }
ExecuteMooseObjectWarehouse< UserObject > _all_user_objects
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314

◆ getVariable() [1/4]

virtual const MooseVariableFieldBase& SubProblem::getVariable
inherited

Returns the variable reference for requested variable which must be of the expected_var_type (Nonlinear vs.

Auxiliary) and expected_var_field_type (standard, scalar, vector). The default values of VAR_ANY and VAR_FIELD_ANY should be used when "any" type of variable is acceptable. Throws an error if the variable in question is not in the expected System or of the expected type.

◆ getVariable() [2/4]

virtual MooseVariableFieldBase& SubProblem::getVariable
inlineinherited

Definition at line 279 of file SubProblem.h.

283  {
284  return const_cast<MooseVariableFieldBase &>(const_cast<const SubProblem *>(this)->getVariable(
285  tid, var_name, expected_var_type, expected_var_field_type));
286  }
This class provides an interface for common operations on field variables of both FE and FV types wit...
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...
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78

◆ getVariable() [3/4]

const MooseVariableFieldBase & FEProblemBase::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
overridevirtualinherited

Returns the variable reference for requested variable which must be of the expected_var_type (Nonlinear vs.

Auxiliary) and expected_var_field_type (standard, scalar, vector). The default values of VAR_ANY and VAR_FIELD_ANY should be used when "any" type of variable is acceptable. Throws an error if the variable in question is not in the expected System or of the expected type.

Implements SubProblem.

Definition at line 5841 of file FEProblemBase.C.

Referenced by FEProblemBase::addFVInitialCondition(), FEProblemBase::addInitialCondition(), EigenProblem::adjustEigenVector(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), CoupleableMooseVariableDependencyIntermediateInterface::coupledArrayValueByName(), CoupleableMooseVariableDependencyIntermediateInterface::coupledValueByName(), NodalNormalsCorner::execute(), NodalNormalsEvaluator::execute(), MultiAppProjectionTransfer::execute(), NodalNormalsPreprocessor::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), LazyCoupleable::init(), AdvancedOutput::initAvailableLists(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), AdvancedOutput::initShowHideLists(), SolutionUserObjectBase::pointValueWrapper(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), MultiAppProjectionTransfer::projectSolution(), MultiAppDofCopyTransfer::transfer(), and MultiAppShapeEvaluationTransfer::transferVariable().

5845 {
5846  return getVariableHelper(
5847  tid, var_name, expected_var_type, expected_var_field_type, _solver_systems, *_aux);
5848 }
MooseVariableFieldBase & getVariableHelper(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &nls, const SystemBase &aux) const
Helper function called by getVariable that handles the logic for checking whether Variables of the re...
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ getVariable() [4/4]

virtual MooseVariableFieldBase& SubProblem::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 
)
inlinevirtualinherited

Definition at line 279 of file SubProblem.h.

283  {
284  return const_cast<MooseVariableFieldBase &>(const_cast<const SubProblem *>(this)->getVariable(
285  tid, var_name, expected_var_type, expected_var_field_type));
286  }
This class provides an interface for common operations on field variables of both FE and FV types wit...
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...
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78

◆ getVariableHelper() [1/2]

template<typename T >
MooseVariableFEBase& SubProblem::getVariableHelper ( const THREAD_ID  tid,
const std::string &  var_name,
Moose::VarKindType  expected_var_type,
Moose::VarFieldType  expected_var_field_type,
const std::vector< T > &  systems,
const SystemBase aux 
) const
inherited

Definition at line 818 of file SubProblem.C.

824 {
825  // Eventual return value
826  MooseVariableFEBase * var = nullptr;
827 
828  const auto [var_in_sys, sys_num] = determineSolverSystem(var_name);
829 
830  // First check that the variable is found on the expected system.
831  if (expected_var_type == Moose::VarKindType::VAR_ANY)
832  {
833  if (var_in_sys)
834  var = &(systems[sys_num]->getVariable(tid, var_name));
835  else if (aux.hasVariable(var_name))
836  var = &(aux.getVariable(tid, var_name));
837  else
838  mooseError("Unknown variable " + var_name);
839  }
840  else if (expected_var_type == Moose::VarKindType::VAR_SOLVER && var_in_sys &&
841  systems[sys_num]->hasVariable(var_name))
842  var = &(systems[sys_num]->getVariable(tid, var_name));
843  else if (expected_var_type == Moose::VarKindType::VAR_AUXILIARY && aux.hasVariable(var_name))
844  var = &(aux.getVariable(tid, var_name));
845  else
846  {
847  std::string expected_var_type_string =
848  (expected_var_type == Moose::VarKindType::VAR_SOLVER ? "nonlinear" : "auxiliary");
849  mooseError("No ",
850  expected_var_type_string,
851  " variable named ",
852  var_name,
853  " found. "
854  "Did you specify an auxiliary variable when you meant to specify a nonlinear "
855  "variable (or vice-versa)?");
856  }
857 
858  // Now make sure the var found has the expected field type.
859  if ((expected_var_field_type == Moose::VarFieldType::VAR_FIELD_ANY) ||
860  (expected_var_field_type == var->fieldType()))
861  return *var;
862  else
863  {
864  std::string expected_var_field_type_string =
865  MooseUtils::toLower(Moose::stringify(expected_var_field_type));
866  std::string var_field_type_string = MooseUtils::toLower(Moose::stringify(var->fieldType()));
867 
868  mooseError("No ",
869  expected_var_field_type_string,
870  " variable named ",
871  var_name,
872  " found. "
873  "Did you specify a ",
874  var_field_type_string,
875  " variable when you meant to specify a ",
876  expected_var_field_type_string,
877  " variable?");
878  }
879 }
This class provides an interface for common operations on field variables of both FE and FV types wit...
std::string toLower(std::string name)
Convert supplied string to lower case.
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
virtual bool hasVariable(const std::string &var_name) const =0
Whether or not this problem has the variable.
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
Definition: SystemBase.C:851
virtual std::pair< bool, unsigned int > determineSolverSystem(const std::string &var_name, bool error_if_not_found=false) const =0
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
virtual Moose::VarFieldType fieldType() const =0
Field type of this variable.
MooseVariableFieldBase & getVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a variable of with specified name.
Definition: SystemBase.C:90

◆ getVariableHelper() [2/2]

template<typename T >
MooseVariableFieldBase& SubProblem::getVariableHelper ( const THREAD_ID  tid,
const std::string &  var_name,
Moose::VarKindType  expected_var_type,
Moose::VarFieldType  expected_var_field_type,
const std::vector< T > &  nls,
const SystemBase aux 
) const
protectedinherited

Helper function called by getVariable that handles the logic for checking whether Variables of the requested type are available.

Referenced by DisplacedProblem::getVariable(), and FEProblemBase::getVariable().

◆ getVariableNames()

std::vector< VariableName > FEProblemBase::getVariableNames ( )
virtualinherited

Returns a list of all the variables in the problem (both from the NL and Aux systems.

Definition at line 8813 of file FEProblemBase.C.

Referenced by EigenProblem::adjustEigenVector(), AdvancedOutput::initAvailableLists(), and ElementSubdomainModifierBase::initialSetup().

8814 {
8815  std::vector<VariableName> names;
8816 
8817  for (auto & sys : _solver_systems)
8818  {
8819  const std::vector<VariableName> & var_names = sys->getVariableNames();
8820  names.insert(names.end(), var_names.begin(), var_names.end());
8821  }
8822 
8823  const std::vector<VariableName> & aux_var_names = _aux->getVariableNames();
8824  names.insert(names.end(), aux_var_names.begin(), aux_var_names.end());
8825 
8826  return names;
8827 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ getVectorPostprocessorObjectByName()

const VectorPostprocessor & FEProblemBase::getVectorPostprocessorObjectByName ( const std::string &  object_name,
const THREAD_ID  tid = 0 
) const
inherited

Return the VPP object given the name.

Parameters
object_nameThe name of the VPP object
Returns
Desired VPP object

This is used by various output objects as well as the scatter value handling.

See also
CSV.C, XMLOutput.C, VectorPostprocessorInterface.C

Definition at line 4602 of file FEProblemBase.C.

Referenced by VectorPostprocessorInterface::isVectorPostprocessorDistributedByName(), CSV::output(), and XMLOutput::outputVectorPostprocessors().

4604 {
4605  return getUserObject<VectorPostprocessor>(object_name, tid);
4606 }

◆ getVectorPostprocessorValueByName()

const VectorPostprocessorValue & FEProblemBase::getVectorPostprocessorValueByName ( const std::string &  object_name,
const std::string &  vector_name,
std::size_t  t_index = 0 
) const
inherited

Get a read-only reference to the vector value associated with the VectorPostprocessor.

Parameters
object_nameThe name of the VPP object.
vector_nameThe namve of the decalred vector within the object.
Returns
Referent to the vector of data.

Note: This method is only for retrieving values that already exist, the VectorPostprocessor and VectorPostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

Definition at line 4583 of file FEProblemBase.C.

Referenced by HistogramVectorPostprocessor::execute().

4586 {
4588  VectorPostprocessorReporterName(object_name, vector_name), t_index);
4589 }
A ReporterName that represents a VectorPostprocessor.
Definition: ReporterName.h:152
ReporterData _reporter_data
const T & getReporterValue(const ReporterName &reporter_name, const MooseObject &consumer, const ReporterMode &mode, const std::size_t time_index=0) const
Method for returning read only references to Reporter values.
Definition: ReporterData.h:388
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:203

◆ getVectorTag()

const VectorTag & SubProblem::getVectorTag ( const TagID  tag_id) const
virtualinherited

Get a VectorTag from a TagID.

Reimplemented in DisplacedProblem.

Definition at line 161 of file SubProblem.C.

Referenced by FEProblemBase::addCachedResidualDirectly(), Assembly::cacheResidual(), Assembly::cacheResidualNodes(), DisplacedProblem::getVectorTag(), SubProblem::getVectorTags(), TaggingInterface::prepareVectorTagInternal(), TaggingInterface::prepareVectorTagLower(), TaggingInterface::prepareVectorTagNeighbor(), FEProblemBase::setResidual(), and FEProblemBase::setResidualNeighbor().

162 {
163  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
164 
165  if (!vectorTagExists(tag_id))
166  mooseError("Vector tag with ID ", tag_id, " does not exist");
167 
168  return _vector_tags[tag_id];
169 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1167
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
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

◆ getVectorTagID()

TagID SubProblem::getVectorTagID ( const TagName &  tag_name) const
virtualinherited

Get a TagID from a TagName.

Reimplemented in DisplacedProblem.

Definition at line 203 of file SubProblem.C.

Referenced by Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), Coupleable::coupledVectorTagValues(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), DisplacedProblem::getVectorTagID(), MooseVariableDataBase< OutputType >::MooseVariableDataBase(), ReferenceResidualConvergence::ReferenceResidualConvergence(), SolverSystem::setSolution(), TaggingInterface::TaggingInterface(), TagVectorAux::TagVectorAux(), MultiAppDofCopyTransfer::transfer(), TaggingInterface::useVectorTag(), Coupleable::vectorTagDofValueHelper(), and Coupleable::vectorTagValueHelper().

204 {
205  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
206 
207  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
208  const auto search = _vector_tags_name_map.find(tag_name_upper);
209  if (search != _vector_tags_name_map.end())
210  return search->second;
211 
212  std::string message =
213  tag_name_upper == "TIME"
214  ? ".\n\nThis may occur if "
215  "you have a TimeKernel in your problem but did not specify a transient executioner."
216  : "";
217  mooseError("Vector tag '", tag_name_upper, "' does not exist", message);
218 }
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
std::string toUpper(std::string name)
Convert supplied string to upper case.
std::map< TagName, TagID > _vector_tags_name_map
Map of vector tag TagName to TagID.
Definition: SubProblem.h:1177
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

◆ getVectorTags() [1/2]

std::vector< VectorTag > SubProblem::getVectorTags ( const std::set< TagID > &  tag_ids) const
inherited

Definition at line 172 of file SubProblem.C.

Referenced by FEProblemBase::computeLinearSystemSys(), EigenProblem::computeResidualAB(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualInternal(), EigenProblem::computeResidualTag(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), DisplacedProblem::getVectorTags(), SubProblem::numVectorTags(), ComputeMortarFunctor::operator()(), and FEProblemBase::setCurrentResidualVectorTags().

173 {
174  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
175 
176  std::vector<VectorTag> tags;
177  tags.reserve(tag_ids.size());
178  for (const auto & tag_id : tag_ids)
179  tags.push_back(getVectorTag(tag_id));
180  return tags;
181 }
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
Definition: SubProblem.C:161

◆ getVectorTags() [2/2]

const std::vector< VectorTag > & SubProblem::getVectorTags ( const Moose::VectorTagType  type = Moose::VECTOR_TAG_ANY) const
virtualinherited

Return all vector tags, where a tag is represented by a map from name to ID.

Can optionally be limited to a vector tag type.

Reimplemented in DisplacedProblem.

Definition at line 184 of file SubProblem.C.

185 {
186  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
187 
189  return _vector_tags;
190  else
191  return _typed_vector_tags[type];
192 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1167
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
std::vector< std::vector< VectorTag > > _typed_vector_tags
The vector tags associated with each VectorTagType This is kept separate from _vector_tags for quick ...
Definition: SubProblem.h:1174

◆ getVectorVariable()

VectorMooseVariable & FEProblemBase::getVectorVariable ( const THREAD_ID  tid,
const std::string &  var_name 
)
overridevirtualinherited

Returns the variable reference for requested VectorMooseVariable which may be in any system.

Implements SubProblem.

Definition at line 5875 of file FEProblemBase.C.

5876 {
5877  for (auto & sys : _solver_systems)
5878  if (sys->hasVariable(var_name))
5879  return sys->getFieldVariable<RealVectorValue>(tid, var_name);
5880  if (_aux->hasVariable(var_name))
5881  return _aux->getFieldVariable<RealVectorValue>(tid, var_name);
5882 
5883  mooseError("Unknown variable " + var_name);
5884 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
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

◆ getXFEM()

std::shared_ptr<XFEMInterface> FEProblemBase::getXFEM ( )
inlineinherited

Get a pointer to the XFEM controller object.

Definition at line 1877 of file FEProblemBase.h.

1877 { return _xfem; }
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.

◆ ghostedElems()

virtual std::set<dof_id_type>& SubProblem::ghostedElems ( )
inlinevirtualinherited

Return the list of elements that should have their DoFs ghosted to this processor.

Returns
The list

Reimplemented in DisplacedProblem.

Definition at line 672 of file SubProblem.h.

Referenced by SystemBase::augmentSendList(), NearestNodeLocator::findNodes(), DisplacedProblem::ghostedElems(), and NearestNodeLocator::updatePatch().

672 { return _ghosted_elems; }
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
Definition: SubProblem.h:1093

◆ ghostGhostedBoundaries()

void FEProblemBase::ghostGhostedBoundaries ( )
overridevirtualinherited

Causes the boundaries added using addGhostedBoundary to actually be ghosted.

Implements SubProblem.

Definition at line 2133 of file FEProblemBase.C.

Referenced by DisplacedProblem::ghostGhostedBoundaries(), FEProblemBase::init(), and FEProblemBase::meshChanged().

2134 {
2135  TIME_SECTION("ghostGhostedBoundaries", 3, "Ghosting Ghosted Boundaries");
2136 
2138 
2139  if (_displaced_problem)
2141 }
MooseMesh & _mesh
std::shared_ptr< DisplacedProblem > _displaced_problem
void ghostGhostedBoundaries()
Actually do the ghosting of boundaries that need to be ghosted to this processor. ...
Definition: MooseMesh.C:3354
MooseMesh * _displaced_mesh

◆ hasActiveElementalMooseVariables()

bool SubProblem::hasActiveElementalMooseVariables ( const THREAD_ID  tid) const
virtualinherited

Whether or not a list of active elemental moose variables has been set.

Returns
True if there has been a list of active elemental moose variables set, False otherwise

Definition at line 460 of file SubProblem.C.

Referenced by SystemBase::prepare(), SystemBase::prepareFace(), and SystemBase::reinitElem().

461 {
463 }
std::vector< unsigned int > _has_active_elemental_moose_variables
Whether or not there is currently a list of active elemental moose variables.
Definition: SubProblem.h:1079

◆ hasActiveMaterialProperties()

bool FEProblemBase::hasActiveMaterialProperties ( const THREAD_ID  tid) const
inherited

Method to check whether or not a list of active material roperties has been set.

This method is called by reinitMaterials to determine whether Material computeProperties methods need to be called. If the return is False, this check prevents unnecessary material property computation

Parameters
tidThe thread id
Returns
True if there has been a list of active material properties set, False otherwise

Definition at line 6043 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::onElement(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsInterface(), and FEProblemBase::reinitMaterialsNeighbor().

6044 {
6045  return _has_active_material_properties[tid];
6046 }
std::vector< unsigned char > _has_active_material_properties
Whether there are active material properties on each thread.

◆ hasAuxiliaryVariable()

bool SubProblem::hasAuxiliaryVariable ( const std::string &  var_name) const
virtualinherited

Whether or not this problem has this auxiliary variable.

Definition at line 811 of file SubProblem.C.

Referenced by SubProblem::getFunctor(), and NearestNodeValueAux::NearestNodeValueAux().

812 {
813  return systemBaseAuxiliary().hasVariable(var_name);
814 }
virtual const SystemBase & systemBaseAuxiliary() const =0
Return the auxiliary system object as a base class reference.
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
Definition: SystemBase.C:851

◆ hasBase()

bool MooseBase::hasBase ( ) const
inlineinherited
Returns
Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142 { return _pars.hasBase(); }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
bool hasBase() const

◆ hasBlockMaterialProperty()

bool SubProblem::hasBlockMaterialProperty ( SubdomainID  block_id,
const std::string &  prop_name 
)
virtualinherited

Check if a material property is defined on a block.

Definition at line 511 of file SubProblem.C.

512 {
513  auto it = _map_block_material_props.find(bid);
514  if (it == _map_block_material_props.end())
515  return false;
516 
517  if (it->second.count(prop_name) > 0)
518  return true;
519  else
520  return false;
521 }
std::map< SubdomainID, std::set< std::string > > _map_block_material_props
Map of material properties (block_id -> list of properties)
Definition: SubProblem.h:1052

◆ hasBoundaryMaterialProperty()

bool SubProblem::hasBoundaryMaterialProperty ( BoundaryID  boundary_id,
const std::string &  prop_name 
)
virtualinherited

Check if a material property is defined on a block.

Definition at line 570 of file SubProblem.C.

571 {
572  auto it = _map_boundary_material_props.find(bid);
573  if (it == _map_boundary_material_props.end())
574  return false;
575 
576  if (it->second.count(prop_name) > 0)
577  return true;
578  else
579  return false;
580 }
std::map< BoundaryID, std::set< std::string > > _map_boundary_material_props
Map for boundary material properties (boundary_id -> list of properties)
Definition: SubProblem.h:1055

◆ hasConvergence()

bool FEProblemBase::hasConvergence ( const std::string &  name,
const THREAD_ID  tid = 0 
) const
virtualinherited

Returns true if the problem has a Convergence object of the given name.

Definition at line 2653 of file FEProblemBase.C.

Referenced by ParsedConvergence::initializeSymbols().

2654 {
2655  return _convergences.hasActiveObject(name, tid);
2656 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseObjectWarehouse< Convergence > _convergences
convergence warehouse
bool hasActiveObject(const std::string &name, THREAD_ID tid=0) const
Convenience functions for checking/getting specific objects.

◆ hasDampers()

bool FEProblemBase::hasDampers ( )
inlineinherited

Whether or not this system has dampers.

Definition at line 1366 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::preInit(), and NonlinearSystem::solve().

1366 { return _has_dampers; }
bool _has_dampers
Whether or not this system has any Dampers associated with it.

◆ hasException()

virtual bool FEProblemBase::hasException ( )
inlinevirtualinherited

Whether or not an exception has occurred.

Definition at line 499 of file FEProblemBase.h.

Referenced by NonlinearSystem::converged(), ThreadedElementLoop< ConstElemPointerRange >::keepGoing(), and ThreadedNodeLoop< ConstBndNodeRange, ConstBndNodeRange::const_iterator >::keepGoing().

499 { return _has_exception; }
bool _has_exception
Whether or not an exception has occurred.

◆ hasFunction()

bool FEProblemBase::hasFunction ( const std::string &  name,
const THREAD_ID  tid = 0 
)
virtualinherited

Definition at line 2602 of file FEProblemBase.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), FunctorIC::FunctorIC(), FEProblemBase::getFunction(), FunctionInterface::hasFunctionByName(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), ParsedConvergence::initializeSymbols(), and MooseParsedFunction::initialSetup().

2603 {
2604  return _functions.hasActiveObject(name, tid);
2605 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool hasActiveObject(const std::string &name, THREAD_ID tid=0) const
Convenience functions for checking/getting specific objects.
MooseObjectWarehouse< Function > _functions
functions

◆ hasFunctor()

bool SubProblem::hasFunctor ( const std::string &  name,
const THREAD_ID  tid 
) const
inherited

checks whether we have a functor corresponding to name on the thread id tid

Definition at line 1270 of file SubProblem.C.

Referenced by FunctorInterface::isFunctor().

1271 {
1272  mooseAssert(tid < _functors.size(), "Too large a thread ID");
1273  auto & functors = _functors[tid];
1274  return (functors.find("wraps_" + name) != functors.end());
1275 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > > _functors
A container holding pointers to all the functors in our problem.
Definition: SubProblem.h:1144

◆ hasFunctorWithType()

template<typename T >
bool SubProblem::hasFunctorWithType ( const std::string &  name,
const THREAD_ID  tid 
) const
inherited

checks whether we have a functor of type T corresponding to name on the thread id tid

Definition at line 1320 of file SubProblem.h.

1321 {
1322  mooseAssert(tid < _functors.size(), "Too large a thread ID");
1323  auto & functors = _functors[tid];
1324 
1325  const auto & it = functors.find("wraps_" + name);
1326  constexpr bool requested_functor_is_ad =
1327  !std::is_same<T, typename MetaPhysicL::RawType<T>::value_type>::value;
1328 
1329  if (it == functors.end())
1330  return false;
1331  else
1332  return dynamic_cast<Moose::Functor<T> *>(
1333  requested_functor_is_ad ? std::get<2>(it->second).get() : std::get<1>(it->second).get());
1334 }
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
Definition: MooseUtils.h:1133
This is a wrapper that forwards calls to the implementation, which can be switched out at any time wi...
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > > _functors
A container holding pointers to all the functors in our problem.
Definition: SubProblem.h:1144

◆ hasInitialAdaptivity() [1/2]

bool FEProblemBase::hasInitialAdaptivity ( ) const
inlineinherited

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 1865 of file FEProblemBase.h.

1865 { return _adaptivity.getInitialSteps() > 0; }
Adaptivity _adaptivity
unsigned int getInitialSteps() const
Pull out the number of initial steps previously set by calling init()
Definition: Adaptivity.h:98

◆ hasInitialAdaptivity() [2/2]

bool FEProblemBase::hasInitialAdaptivity ( ) const
inlineinherited

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 1870 of file FEProblemBase.h.

1870 { return false; }

◆ hasJacobian()

bool FEProblemBase::hasJacobian ( ) const
inherited

Returns _has_jacobian.

Definition at line 8968 of file FEProblemBase.C.

8969 {
8970  return _has_jacobian;
8971 }
bool _has_jacobian
Indicates if the Jacobian was computed.

◆ hasKokkosObjects()

bool FEProblemBase::hasKokkosObjects ( ) const
inlineinherited
Returns
whether any Kokkos object was added in the problem

Definition at line 2661 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::preInit(), and MooseMesh::update().

2661 { return _has_kokkos_objects; }
bool _has_kokkos_objects
Whether we have any Kokkos objects.

◆ hasLinearConvergenceObjects()

bool FEProblemBase::hasLinearConvergenceObjects ( ) const
inherited

Whether we have linear convergence objects.

Definition at line 9307 of file FEProblemBase.C.

Referenced by Moose::PetscSupport::petscSetDefaults().

9308 {
9309  // If false,this means we have not set one, not that we are querying this too early
9310  // TODO: once there is a default linear CV object, error on the 'not set' case
9311  return _linear_convergence_names.has_value();
9312 }
std::optional< std::vector< ConvergenceName > > _linear_convergence_names
Linear system(s) convergence name(s) (if any)

◆ hasLinearVariable()

bool SubProblem::hasLinearVariable ( const std::string &  var_name) const
virtualinherited

Whether or not this problem has this linear variable.

Definition at line 802 of file SubProblem.C.

Referenced by SubProblem::getFunctor().

803 {
804  for (const auto i : make_range(numLinearSystems()))
805  if (systemBaseLinear(i).hasVariable(var_name))
806  return true;
807  return false;
808 }
virtual bool hasVariable(const std::string &var_name) const =0
Whether or not this problem has the variable.
IntRange< T > make_range(T beg, T end)
virtual const SystemBase & systemBaseLinear(const unsigned int sys_num) const =0
Return the linear system object as a base class reference given the system number.
virtual std::size_t numLinearSystems() const =0

◆ hasMortarCoupling()

virtual bool FEProblemBase::hasMortarCoupling ( ) const
inlinevirtualinherited

Whether the simulation has mortar coupling.

Definition at line 2362 of file FEProblemBase.h.

2362 { return _has_mortar; }
bool _has_mortar
Whether the simulation requires mortar coupling.

◆ hasMultiApp()

bool FEProblemBase::hasMultiApp ( const std::string &  name) const
inherited

Definition at line 5451 of file FEProblemBase.C.

5452 {
5453  return _multi_apps.hasActiveObject(multi_app_name);
5454 }
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
bool hasActiveObject(const std::string &name, THREAD_ID tid=0) const
Convenience functions for checking/getting specific objects.

◆ hasMultiApps() [1/2]

bool FEProblemBase::hasMultiApps ( ) const
inlineinherited

Returns whether or not the current simulation has any multiapps.

Definition at line 1352 of file FEProblemBase.h.

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), FEProblemBase::checkProblemIntegrity(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), and DefaultMultiAppFixedPointConvergence::preExecute().

1352 { return _multi_apps.hasActiveObjects(); }
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
bool hasActiveObjects(THREAD_ID tid=0) const

◆ hasMultiApps() [2/2]

bool FEProblemBase::hasMultiApps ( ExecFlagType  type) const
inherited

Definition at line 5445 of file FEProblemBase.C.

5446 {
5447  return _multi_apps[type].hasActiveObjects();
5448 }
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
bool hasActiveObjects(THREAD_ID tid=0) const

◆ hasNeighborCoupling()

virtual bool FEProblemBase::hasNeighborCoupling ( ) const
inlinevirtualinherited

Whether the simulation has neighbor coupling.

Definition at line 2357 of file FEProblemBase.h.

bool _has_internal_edge_residual_objects
Whether the problem has dgkernels or interface kernels.

◆ hasNonlocalCoupling()

virtual bool FEProblemBase::hasNonlocalCoupling ( ) const
inlineoverridevirtualinherited

Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian.

For this to return true, there must be at least one active nonlocal kernel or boundary condition

Implements SubProblem.

Definition at line 2619 of file FEProblemBase.h.

Referenced by DisplacedProblem::hasNonlocalCoupling().

2619 { return _has_nonlocal_coupling; }
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.

◆ hasPostprocessor()

bool FEProblemBase::hasPostprocessor ( const std::string &  name) const
inherited

Deprecated.

Use hasPostprocessorValueByName

Definition at line 4575 of file FEProblemBase.C.

Referenced by GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl().

4576 {
4577  mooseDeprecated("FEProblemBase::hasPostprocssor is being removed; use "
4578  "hasPostprocessorValueByName instead.");
4580 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
void mooseDeprecated(Args &&... args) const
Definition: MooseBase.h:314
bool hasPostprocessorValueByName(const PostprocessorName &name) const
Whether or not a Postprocessor value exists by a given name.

◆ hasPostprocessorValueByName()

bool FEProblemBase::hasPostprocessorValueByName ( const PostprocessorName &  name) const
inherited

Whether or not a Postprocessor value exists by a given name.

Parameters
nameThe name of the Postprocessor
Returns
True if a Postprocessor value exists

Note: You should prioritize the use of PostprocessorInterface::hasPostprocessor and PostprocessorInterface::hasPostprocessorByName over this method when possible.

Definition at line 4552 of file FEProblemBase.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), FunctorAux::computeValue(), FunctorExtremaPositions::FunctorExtremaPositions(), FEProblemBase::hasPostprocessor(), MooseParsedFunction::initialSetup(), and FunctorIC::value().

4553 {
4555 }
ReporterData _reporter_data
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
Real PostprocessorValue
various MOOSE typedefs
Definition: MooseTypes.h:202
A ReporterName that represents a Postprocessor.
Definition: ReporterName.h:143
bool hasReporterValue(const ReporterName &reporter_name) const
Return True if a Reporter value with the given type and name have been created.
Definition: ReporterData.h:445

◆ hasScalarVariable()

bool FEProblemBase::hasScalarVariable ( const std::string &  var_name) const
overridevirtualinherited

Returns a Boolean indicating whether any system contains a variable with the name provided.

Implements SubProblem.

Definition at line 5899 of file FEProblemBase.C.

Referenced by FEProblemBase::addInitialCondition(), FEProblemBase::addObjectParamsHelper(), EigenProblem::adjustEigenVector(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), AdvancedOutput::initAvailableLists(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), AdvancedOutput::initShowHideLists(), and Split::setup().

5900 {
5901  for (auto & sys : _solver_systems)
5902  if (sys->hasScalarVariable(var_name))
5903  return true;
5904  if (_aux->hasScalarVariable(var_name))
5905  return true;
5906 
5907  return false;
5908 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ hasScalingVector()

void SubProblem::hasScalingVector ( const unsigned int  nl_sys_num)
inherited

Tells this problem that the assembly associated with the given nonlinear system number involves a scaling vector.

Definition at line 1170 of file SubProblem.C.

Referenced by SystemBase::addScalingVector().

1171 {
1172  for (const THREAD_ID tid : make_range(libMesh::n_threads()))
1173  assembly(tid, nl_sys_num).hasScalingVector();
1174 }
unsigned int n_threads()
void hasScalingVector()
signals this object that a vector containing variable scaling factors should be used when doing resid...
Definition: Assembly.C:4574
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num)=0
IntRange< T > make_range(T beg, T end)
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ hasSetMultiAppFixedPointConvergenceName()

bool FEProblemBase::hasSetMultiAppFixedPointConvergenceName ( ) const
inlineinherited

Returns true if the problem has set the fixed point convergence name.

Definition at line 691 of file FEProblemBase.h.

692  {
693  return _multiapp_fixed_point_convergence_name.has_value();
694  }
std::optional< ConvergenceName > _multiapp_fixed_point_convergence_name
MultiApp fixed point convergence name.

◆ hasSetSteadyStateConvergenceName()

bool FEProblemBase::hasSetSteadyStateConvergenceName ( ) const
inlineinherited

Returns true if the problem has set the steady-state detection convergence name.

Definition at line 696 of file FEProblemBase.h.

697  {
698  return _steady_state_convergence_name.has_value();
699  }
std::optional< ConvergenceName > _steady_state_convergence_name
Steady-state detection convergence name.

◆ hasSolverVariable()

bool FEProblemBase::hasSolverVariable ( const std::string &  var_name) const
inherited

Definition at line 5831 of file FEProblemBase.C.

5832 {
5833  for (auto & sys : _solver_systems)
5834  if (sys->hasVariable(var_name))
5835  return true;
5836 
5837  return false;
5838 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.

◆ hasTimeIntegrator()

bool FEProblemBase::hasTimeIntegrator ( ) const
inlineinherited

Returns whether or not this Problem has a TimeIntegrator.

Definition at line 2148 of file FEProblemBase.h.

Referenced by TransientBase::setupTimeIntegrator().

2148 { return _has_time_integrator; }
bool _has_time_integrator
Indicates whether or not this executioner has a time integrator (during setup)

◆ hasUOAuxStateCheck()

bool FEProblemBase::hasUOAuxStateCheck ( ) const
inlineinherited

Whether or not MOOSE will perform a user object/auxiliary kernel state check.

Definition at line 201 of file FEProblemBase.h.

201 { return _uo_aux_state_check; }
const bool _uo_aux_state_check
Whether or not checking the state of uo/aux evaluation.

◆ hasUserObject()

bool FEProblemBase::hasUserObject ( const std::string &  name) const
inherited

Check if there if a user object of given name.

Parameters
nameThe name of the user object being checked for
Returns
true if the user object exists, false otherwise

Definition at line 4539 of file FEProblemBase.C.

Referenced by addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), FunctorAux::computeValue(), DistributedPositions::DistributedPositions(), UserObjectInterface::hasUserObjectByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), ReporterTransferInterface::hideVariableHelper(), ParsedDownSelectionPositions::initialize(), and TransformedPositions::TransformedPositions().

4540 {
4541  std::vector<UserObject *> objs;
4542  theWarehouse()
4543  .query()
4544  .condition<AttribSystem>("UserObject")
4545  .condition<AttribThread>(0)
4546  .condition<AttribName>(name)
4547  .queryInto(objs);
4548  return !objs.empty();
4549 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
TheWarehouse & theWarehouse() const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ hasVariable()

bool FEProblemBase::hasVariable ( const std::string &  var_name) const
overridevirtualinherited

Whether or not this problem has the variable.

Implements SubProblem.

Definition at line 5819 of file FEProblemBase.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), FEProblemBase::addFVInitialCondition(), DiffusionFV::addFVKernels(), FEProblemBase::addInitialCondition(), FEProblemBase::addObjectParamsHelper(), MultiAppTransfer::checkVariable(), FunctorIC::FunctorIC(), LazyCoupleable::init(), AdvancedOutput::initAvailableLists(), MooseParsedFunction::initialSetup(), AdvancedOutput::initShowHideLists(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), and Split::setup().

5820 {
5821  for (auto & sys : _solver_systems)
5822  if (sys->hasVariable(var_name))
5823  return true;
5824  if (_aux->hasVariable(var_name))
5825  return true;
5826 
5827  return false;
5828 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ haveADObjects() [1/4]

bool SubProblem::haveADObjects ( ) const
inlineinherited

Method for reading wehther we have any ad objects.

Definition at line 771 of file SubProblem.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::init().

771 { return _have_ad_objects; }
bool _have_ad_objects
AD flag indicating whether any AD objects have been added.
Definition: SubProblem.h:1114

◆ haveADObjects() [2/4]

virtual void SubProblem::haveADObjects
inlineinherited

Method for setting whether we have any ad objects.

Definition at line 767 of file SubProblem.h.

767 { _have_ad_objects = have_ad_objects; }
bool _have_ad_objects
AD flag indicating whether any AD objects have been added.
Definition: SubProblem.h:1114

◆ haveADObjects() [3/4]

bool SubProblem::haveADObjects
inlineinherited

Method for reading wehther we have any ad objects.

Definition at line 771 of file SubProblem.h.

771 { return _have_ad_objects; }
bool _have_ad_objects
AD flag indicating whether any AD objects have been added.
Definition: SubProblem.h:1114

◆ haveADObjects() [4/4]

void FEProblemBase::haveADObjects ( bool  have_ad_objects)
overridevirtualinherited

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 9045 of file FEProblemBase.C.

9046 {
9047  _have_ad_objects = have_ad_objects;
9048  if (_displaced_problem)
9049  _displaced_problem->SubProblem::haveADObjects(have_ad_objects);
9050 }
bool _have_ad_objects
AD flag indicating whether any AD objects have been added.
Definition: SubProblem.h:1114
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ haveDisplaced()

bool FEProblemBase::haveDisplaced ( ) const
inlinefinaloverridevirtualinherited

Whether we have a displaced problem in our simulation.

Implements SubProblem.

Definition at line 2453 of file FEProblemBase.h.

2453 { return _displaced_problem.get(); }
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ haveFV()

virtual bool FEProblemBase::haveFV ( ) const
inlineoverridevirtualinherited

◆ havePRefinement()

bool SubProblem::havePRefinement ( ) const
inlineinherited

Query whether p-refinement has been requested at any point during the simulation.

Definition at line 1009 of file SubProblem.h.

Referenced by AdvancedOutput::initAvailableLists(), and FEProblemBase::meshChanged().

1009 { return _have_p_refinement; }
bool _have_p_refinement
Whether p-refinement has been requested at any point during the simulation.
Definition: SubProblem.h:1202

◆ haveXFEM()

bool FEProblemBase::haveXFEM ( )
inlineinherited

Find out whether the current analysis is using XFEM.

Definition at line 1880 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup(), FixedPointSolve::solveStep(), TransientBase::takeStep(), and FEProblemBase::updateMeshXFEM().

1880 { return _xfem != nullptr; }
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.

◆ identifyVariableGroupsInNL()

bool FEProblemBase::identifyVariableGroupsInNL ( ) const
inlineinherited

Whether to identify variable groups in nonlinear systems.

This affects dof ordering

Definition at line 2624 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::NonlinearSystemBase().

const bool _identify_variable_groups_in_nl
Whether to identify variable groups in nonlinear systems. This affects dof ordering.

◆ ignoreZerosInJacobian()

bool FEProblemBase::ignoreZerosInJacobian ( ) const
inlineinherited

Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern.

Note that this can make preserving the matrix sparsity pattern impossible.

Definition at line 2120 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::constraintJacobians().

2120 { return _ignore_zeros_in_jacobian; }
bool _ignore_zeros_in_jacobian
Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.

◆ immediatelyPrintInvalidSolution()

bool FEProblemBase::immediatelyPrintInvalidSolution ( ) const
inlineinherited

Whether or not the solution invalid warnings are printed out immediately.

Definition at line 2145 of file FEProblemBase.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

const bool & _immediately_print_invalid_solution

◆ incrementMultiAppTStep()

void FEProblemBase::incrementMultiAppTStep ( ExecFlagType  type)
inherited

Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType.

Definition at line 5636 of file FEProblemBase.C.

Referenced by TransientBase::incrementStepOrReject().

5637 {
5638  const auto & multi_apps = _multi_apps[type].getActiveObjects();
5639 
5640  if (multi_apps.size())
5641  for (const auto & multi_app : multi_apps)
5642  multi_app->incrementTStep(_time);
5643 }
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...
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.

◆ init()

void FEProblemBase::init ( )
overridevirtualinherited

Implements Problem.

Reimplemented in FEProblem, and EigenProblem.

Definition at line 6317 of file FEProblemBase.C.

Referenced by EigenProblem::init(), and FEProblem::init().

6318 {
6319  if (_initialized)
6320  return;
6321 
6322  TIME_SECTION("init", 2, "Initializing");
6323 
6324  // call executioner's preProblemInit so that it can do some setups before problem init
6326 
6327  // If we have AD and we are doing global AD indexing, then we should by default set the matrix
6328  // coupling to full. If the user has told us to trust their coupling matrix, then this call will
6329  // not do anything
6332 
6333  for (const auto i : index_range(_nl))
6334  {
6335  auto & nl = _nl[i];
6336  auto & cm = _cm[i];
6337 
6338  unsigned int n_vars = nl->nVariables();
6339  {
6340  TIME_SECTION("fillCouplingMatrix", 3, "Filling Coupling Matrix");
6341 
6342  switch (_coupling)
6343  {
6344  case Moose::COUPLING_DIAG:
6345  cm = std::make_unique<CouplingMatrix>(n_vars);
6346  for (unsigned int i = 0; i < n_vars; i++)
6347  (*cm)(i, i) = 1;
6348  break;
6349 
6350  // for full jacobian
6351  case Moose::COUPLING_FULL:
6352  cm = std::make_unique<CouplingMatrix>(n_vars);
6353  for (unsigned int i = 0; i < n_vars; i++)
6354  for (unsigned int j = 0; j < n_vars; j++)
6355  (*cm)(i, j) = 1;
6356  break;
6357 
6359  // do nothing, _cm was already set through couplingMatrix() call
6360  break;
6361  }
6362  }
6363 
6364  nl->dofMap()._dof_coupling = cm.get();
6365 
6366  // If there are no variables, make sure to pass a nullptr coupling
6367  // matrix, to avoid warnings about non-nullptr yet empty
6368  // CouplingMatrices.
6369  if (n_vars == 0)
6370  nl->dofMap()._dof_coupling = nullptr;
6371 
6372  nl->dofMap().attach_extra_sparsity_function(&extraSparsity, nl.get());
6373  nl->dofMap().attach_extra_send_list_function(&extraSendList, nl.get());
6374  _aux->dofMap().attach_extra_send_list_function(&extraSendList, _aux.get());
6375 
6376  if (!_skip_nl_system_check && _solve && n_vars == 0)
6377  mooseError("No variables specified in nonlinear system '", nl->name(), "'.");
6378  }
6379 
6380  ghostGhostedBoundaries(); // We do this again right here in case new boundaries have been added
6381 
6382  // We may have added element/nodes to the mesh in ghostGhostedBoundaries so we need to update
6383  // all of our mesh information. We need to make sure that mesh information is up-to-date before
6384  // EquationSystems::init because that will call through to updateGeomSearch (for sparsity
6385  // augmentation) and if we haven't added back boundary node information before that latter call,
6386  // then we're screwed. We'll get things like "Unable to find closest node!"
6387  _mesh.meshChanged();
6388  if (_displaced_problem)
6390 
6391  if (_mesh.doingPRefinement())
6392  {
6394  if (_displaced_problem)
6395  _displaced_problem->preparePRefinement();
6396  }
6397 
6398  // do not assemble system matrix for JFNK solve
6399  for (auto & nl : _nl)
6400  if (solverParams(nl->number())._type == Moose::ST_JFNK)
6401  nl->turnOffJacobian();
6402 
6403  for (auto & sys : _solver_systems)
6404  sys->preInit();
6405  _aux->preInit();
6406 
6407  // Build the mortar segment meshes, if they haven't been already, for a couple reasons:
6408  // 1) Get the ghosting correct for both static and dynamic meshes
6409  // 2) Make sure the mortar mesh is built for mortar constraints that live on the static mesh
6410  //
6411  // It is worth-while to note that mortar meshes that live on a dynamic mesh will be built
6412  // during residual and Jacobian evaluation because when displacements are solution variables
6413  // the mortar mesh will move and change during the course of a non-linear solve. We DO NOT
6414  // redo ghosting during non-linear solve, so for purpose 1) the below call has to be made
6415  if (!_mortar_data.initialized())
6416  updateMortarMesh();
6417 
6418  {
6419  TIME_SECTION("EquationSystems::Init", 2, "Initializing Equation Systems");
6420  es().init();
6421  }
6422 
6423  for (auto & sys : _solver_systems)
6424  sys->postInit();
6425  _aux->postInit();
6426 
6427  // Now that the equation system and the dof distribution is done, we can generate the
6428  // finite volume-related parts if needed.
6429  if (haveFV())
6431 
6432  for (auto & sys : _solver_systems)
6433  sys->update();
6434  _aux->update();
6435 
6436  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
6437  for (const auto i : index_range(_nl))
6438  {
6439  mooseAssert(
6440  _cm[i],
6441  "Coupling matrix not set for system "
6442  << i
6443  << ". This should only happen if a preconditioner was not setup for this system");
6444  _assembly[tid][i]->init(_cm[i].get());
6445  }
6446 
6447  if (_displaced_problem)
6448  _displaced_problem->init();
6449 
6450 #ifdef MOOSE_KOKKOS_ENABLED
6451  if (_has_kokkos_objects)
6452  initKokkos();
6453 #endif
6454 
6455  _initialized = true;
6456 }
void extraSparsity(libMesh::SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *context)
Free function used for a libMesh callback.
Definition: SystemBase.C:48
unsigned int n_threads()
virtual bool haveFV() const override
returns true if this problem includes/needs finite volume functionality.
void setCoupling(Moose::CouplingType type)
Set the coupling between variables TODO: allow user-defined coupling.
bool _has_kokkos_objects
Whether we have any Kokkos objects.
bool globalADIndexing()
Whether we are using global AD indexing.
Definition: ADUtils.h:28
bool initialized() const
Definition: MortarData.h:127
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
void preparePRefinement()
Prepare DofMap and Assembly classes with our p-refinement information.
Definition: SubProblem.C:1332
const bool _skip_nl_system_check
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const bool & _solve
Whether or not to actually solve the nonlinear system.
unsigned int n_vars
Moose::CouplingType _coupling
Type of variable coupling.
void extraSendList(std::vector< dof_id_type > &send_list, void *context)
///< Type of coordinate system
Definition: SystemBase.C:40
Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:846
virtual libMesh::EquationSystems & es() override
MortarData _mortar_data
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
bool haveADObjects() const
Method for reading wehther we have any ad objects.
Definition: SubProblem.h:771
Executioner * getExecutioner() const
Retrieve the Executioner for this App.
Definition: MooseApp.C:2161
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
virtual void updateMortarMesh()
virtual void preProblemInit()
Perform initializations during executing actions right before init_problem task.
Definition: Executioner.h:57
void initKokkos()
Construct Kokkos assembly and systems and allocate Kokkos material property storages.
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
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.
std::shared_ptr< DisplacedProblem > _displaced_problem
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
Coupling matrix for variables.
void doingPRefinement(bool doing_p_refinement)
Indicate whether the kind of adaptivity we&#39;re doing is p-refinement.
Definition: MooseMesh.h:1373
auto index_range(const T &sizable)
const std::string & _type
The type of this class.
Definition: MooseBase.h:360
MooseMesh * _displaced_mesh
void meshChanged()
Declares that the MooseMesh has changed, invalidates cached data and rebuilds caches.
Definition: MooseMesh.C:897
unsigned int THREAD_ID
Definition: MooseTypes.h:209
virtual void ghostGhostedBoundaries() override
Causes the boundaries added using addGhostedBoundary to actually be ghosted.
void setupFiniteVolumeMeshData() const
Sets up the additional data needed for finite volume computations.
Definition: MooseMesh.C:4112

◆ initElementStatefulProps()

void FEProblemBase::initElementStatefulProps ( const libMesh::ConstElemRange elem_range,
const bool  threaded 
)
inherited

Initialize stateful properties for elements in a specific elem_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

Definition at line 8407 of file FEProblemBase.C.

Referenced by ActivateElementsUserObjectBase::finalize(), ElementSubdomainModifierBase::initElementStatefulProps(), and FEProblemBase::initialSetup().

8408 {
8411  if (threaded)
8412  Threads::parallel_reduce(elem_range, cmt);
8413  else
8414  cmt(elem_range, true);
8415 
8416 #ifdef MOOSE_KOKKOS_ENABLED
8417  if (_has_kokkos_objects)
8419 #endif
8420 }
MaterialPropertyStorage & _bnd_material_props
bool _has_kokkos_objects
Whether we have any Kokkos objects.
void parallel_reduce(const Range &range, Body &body, const Partitioner &)
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
MaterialPropertyStorage & _neighbor_material_props
MaterialPropertyStorage & _material_props
void initKokkosStatefulProps()

◆ initialAdaptMesh()

void FEProblemBase::initialAdaptMesh ( )
virtualinherited

Definition at line 8080 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

8081 {
8082  unsigned int n = adaptivity().getInitialSteps();
8083  _cycles_completed = 0;
8084  if (n)
8085  {
8086  if (!_mesh.interiorLowerDBlocks().empty() || !_mesh.boundaryLowerDBlocks().empty())
8087  mooseError("HFEM does not support mesh adaptivity currently.");
8088 
8089  TIME_SECTION("initialAdaptMesh", 2, "Performing Initial Adaptivity");
8090 
8091  for (unsigned int i = 0; i < n; i++)
8092  {
8094  computeMarkers();
8095 
8097  {
8098  meshChanged(
8099  /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
8100 
8101  // reproject the initial condition
8102  projectSolution();
8103 
8105  }
8106  else
8107  {
8108  _console << "Mesh unchanged, skipping remaining steps..." << std::endl;
8109  return;
8110  }
8111  }
8112  }
8113 }
bool initialAdaptMesh()
Used during initial adaptivity.
Definition: Adaptivity.C:268
virtual void meshChanged()
Deprecated.
const std::set< SubdomainID > & interiorLowerDBlocks() const
Definition: MooseMesh.h:1429
unsigned int _cycles_completed
virtual void computeMarkers()
void projectSolution()
virtual void computeIndicators()
MooseMesh & _mesh
Adaptivity _adaptivity
const std::set< SubdomainID > & boundaryLowerDBlocks() const
Definition: MooseMesh.h:1433
unsigned int getInitialSteps() const
Pull out the number of initial steps previously set by calling init()
Definition: Adaptivity.h:98
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
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Adaptivity & adaptivity()

◆ initialSetup()

void MFEMProblem::initialSetup ( )
overridevirtual

Reimplemented from SubProblem.

Definition at line 41 of file MFEMProblem.C.

Referenced by MFEMSteady::init().

42 {
45 }
void addMFEMNonlinearSolver()
Add the nonlinear solver to the system.
Definition: MFEMProblem.C:77
void initialSetup() override

◆ initKokkos()

void FEProblemBase::initKokkos ( )
inherited

Construct Kokkos assembly and systems and allocate Kokkos material property storages.

Referenced by FEProblemBase::init().

◆ initKokkosStatefulProps()

void FEProblemBase::initKokkosStatefulProps ( )
inherited

◆ initNullSpaceVectors()

void FEProblemBase::initNullSpaceVectors ( const InputParameters parameters,
std::vector< std::shared_ptr< NonlinearSystemBase >> &  nl 
)
virtualinherited

Definition at line 758 of file FEProblemBase.C.

Referenced by EigenProblem::EigenProblem(), and FEProblem::FEProblem().

760 {
761  TIME_SECTION("initNullSpaceVectors", 5, "Initializing Null Space Vectors");
762 
763  unsigned int dimNullSpace = parameters.get<unsigned int>("null_space_dimension");
764  unsigned int dimTransposeNullSpace =
765  parameters.get<unsigned int>("transpose_null_space_dimension");
766  unsigned int dimNearNullSpace = parameters.get<unsigned int>("near_null_space_dimension");
767  for (unsigned int i = 0; i < dimNullSpace; ++i)
768  {
769  std::ostringstream oss;
770  oss << "_" << i;
771  // do not project, since this will be recomputed, but make it ghosted, since the near nullspace
772  // builder might march over all nodes
773  for (auto & nl : nls)
774  nl->addVector("NullSpace" + oss.str(), false, libMesh::GHOSTED);
775  }
776  _subspace_dim["NullSpace"] = dimNullSpace;
777  for (unsigned int i = 0; i < dimTransposeNullSpace; ++i)
778  {
779  std::ostringstream oss;
780  oss << "_" << i;
781  // do not project, since this will be recomputed, but make it ghosted, since the near nullspace
782  // builder might march over all nodes
783  for (auto & nl : nls)
784  nl->addVector("TransposeNullSpace" + oss.str(), false, libMesh::GHOSTED);
785  }
786  _subspace_dim["TransposeNullSpace"] = dimTransposeNullSpace;
787  for (unsigned int i = 0; i < dimNearNullSpace; ++i)
788  {
789  std::ostringstream oss;
790  oss << "_" << i;
791  // do not project, since this will be recomputed, but make it ghosted, since the near-nullspace
792  // builder might march over all semilocal nodes
793  for (auto & nl : nls)
794  nl->addVector("NearNullSpace" + oss.str(), false, libMesh::GHOSTED);
795  }
796  _subspace_dim["NearNullSpace"] = dimNearNullSpace;
797 }
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
std::map< std::string, unsigned int > _subspace_dim
Dimension of the subspace spanned by the vectors with a given prefix.

◆ initPetscOutputAndSomeSolverSettings()

void FEProblemBase::initPetscOutputAndSomeSolverSettings ( )
virtualinherited

Reinitialize PETSc output for proper linear/nonlinear iteration display.

This also may be used for some PETSc-related solver settings

Reimplemented in EigenProblem.

Definition at line 6876 of file FEProblemBase.C.

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), and FEProblemBase::solve().

6877 {
6880 }
void petscSetDefaults(FEProblemBase &problem)
Sets the default options for PETSc.
Definition: PetscSupport.C:450
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
void solveSetup()
Calls the timestepSetup function for each of the output objects.
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480

◆ initXFEM()

void FEProblemBase::initXFEM ( std::shared_ptr< XFEMInterface xfem)
inherited

Create XFEM controller object.

Definition at line 8178 of file FEProblemBase.C.

8179 {
8180  _xfem = xfem;
8181  _xfem->setMesh(&_mesh);
8182  if (_displaced_mesh)
8183  _xfem->setDisplacedMesh(_displaced_mesh);
8184 
8185  auto fill_data = [](auto & storage)
8186  {
8187  std::vector<MaterialData *> data(libMesh::n_threads());
8188  for (const auto tid : make_range(libMesh::n_threads()))
8189  data[tid] = &storage.getMaterialData(tid);
8190  return data;
8191  };
8192  _xfem->setMaterialData(fill_data(_material_props));
8193  _xfem->setBoundaryMaterialData(fill_data(_bnd_material_props));
8194 
8195  unsigned int n_threads = libMesh::n_threads();
8196  for (unsigned int i = 0; i < n_threads; ++i)
8197  for (const auto nl_sys_num : index_range(_nl))
8198  {
8199  _assembly[i][nl_sys_num]->setXFEM(_xfem);
8200  if (_displaced_problem)
8201  _displaced_problem->assembly(i, nl_sys_num).setXFEM(_xfem);
8202  }
8203 }
void fill_data(std::map< processor_id_type, std::vector< std::set< unsigned int >>> &data, int M)
MaterialPropertyStorage & _bnd_material_props
unsigned int n_threads()
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
MooseMesh & _mesh
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
IntRange< T > make_range(T beg, T end)
std::shared_ptr< DisplacedProblem > _displaced_problem
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.
MaterialPropertyStorage & _material_props
auto index_range(const T &sizable)
MooseMesh * _displaced_mesh

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( IsKokkosObjectKey &&  ) const
inlineinherited

Get whether this object is a Kokkos functor The parameter is set by the Kokkos base classes:

Definition at line 72 of file MooseObject.h.

Referenced by BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

73  {
75  }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
static const std::string kokkos_object_param
The name of the parameter that indicates an object is a Kokkos functor.
Definition: MooseBase.h:64
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ isMatPropRequested()

bool SubProblem::isMatPropRequested ( const std::string &  prop_name) const
virtualinherited

Find out if a material property has been requested by any object.

Definition at line 730 of file SubProblem.C.

731 {
732  return _material_property_requested.find(prop_name) != _material_property_requested.end();
733 }
std::set< std::string > _material_property_requested
set containing all material property names that have been requested by getMaterialProperty* ...
Definition: SubProblem.h:1062

◆ isParamSetByUser()

bool MooseBase::isParamSetByUser ( const std::string &  name) const
inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters
nameThe name of the parameter to test

Definition at line 205 of file MooseBase.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::runInputFile(), MooseApp::runInputs(), MFEMSolverBase::setPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

206  {
207  return _pars.isParamSetByUser(name);
208  }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.

◆ isParamValid()

bool MooseBase::isParamValid ( const std::string &  name) const
inlineinherited

Test if the supplied parameter is valid.

Parameters
nameThe name of the parameter to test

Definition at line 199 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), CopyNodalVarsAction::act(), SetupMeshAction::act(), SetupDebugAction::act(), ComposeTimeStepperAction::act(), SetAdaptivityOptionsAction::act(), AddVariableAction::act(), CreateDisplacedProblemAction::act(), CommonOutputAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), DiffusionPhysicsBase::addPostprocessors(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinerGenerator::CombinerGenerator(), FunctorAux::computeValue(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), FEProblemSolve::convergenceSetup(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), Eigenvalue::Eigenvalue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), FileMeshGenerator::generate(), AddMetaDataGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), BlockDeletionGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), MeshExtruderGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYZDelaunayGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), PiecewiseTabularBase::initialSetup(), ParsedConvergence::initialSetup(), SolutionScalarAux::initialSetup(), SolutionAux::initialSetup(), Console::initialSetup(), MooseParsedVectorFunction::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MatDiffusionBase< Real >::MatDiffusionBase(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< Real >::MooseVariableFV(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ParsedCurveGenerator::ParsedCurveGenerator(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), MooseMesh::prepare(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusII(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), Split::setup(), SideSetsGeneratorBase::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), WebServerControl::startServer(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

199 { return _pars.isParamValid(name); }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ isSNESMFReuseBaseSetbyUser()

bool FEProblemBase::isSNESMFReuseBaseSetbyUser ( )
inlineinherited

Return a flag to indicate if _snesmf_reuse_base is set by users.

Definition at line 2283 of file FEProblemBase.h.

bool _snesmf_reuse_base_set_by_user
If or not _snesmf_reuse_base is set by user.

◆ isSolverSystemNonlinear()

bool FEProblemBase::isSolverSystemNonlinear ( const unsigned int  sys_num)
inlineinherited

◆ isSolveTerminationRequested()

virtual bool Problem::isSolveTerminationRequested ( ) const
inlinevirtualinherited

Check of termination has been requested.

This should be called by transient Executioners in the keepGoing() member.

Definition at line 43 of file Problem.h.

Referenced by WebServerControl::execute(), and TransientBase::keepGoing().

43 { return _termination_requested; };
bool _termination_requested
True if termination of the solve has been requested.
Definition: Problem.h:58

◆ isTransient()

virtual bool FEProblemBase::isTransient ( ) const
inlineoverridevirtualinherited

◆ jacobianSetup()

void FEProblemBase::jacobianSetup ( )
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 9363 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::jacobianSetup().

9364 {
9366  // We need to setup all the nonlinear systems other than our current one which actually called
9367  // this method (so we have to make sure we don't go in a circle)
9368  for (const auto i : make_range(numNonlinearSystems()))
9369  if (i != currentNlSysNum())
9370  _nl[i]->jacobianSetup();
9371  // We don't setup the aux sys because that's been done elsewhere
9372  if (_displaced_problem)
9373  _displaced_problem->jacobianSetup();
9374 }
virtual std::size_t numNonlinearSystems() const override
virtual void jacobianSetup()
Definition: SubProblem.C:1209
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
virtual unsigned int currentNlSysNum() const override
IntRange< T > make_range(T beg, T end)
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ kokkosAssembly() [1/2]

Moose::Kokkos::Assembly& FEProblemBase::kokkosAssembly ( )
inlineinherited

Definition at line 330 of file FEProblemBase.h.

330 { return _kokkos_assembly; }
Moose::Kokkos::Assembly _kokkos_assembly

◆ kokkosAssembly() [2/2]

const Moose::Kokkos::Assembly& FEProblemBase::kokkosAssembly ( ) const
inlineinherited

Definition at line 331 of file FEProblemBase.h.

331 { return _kokkos_assembly; }
Moose::Kokkos::Assembly _kokkos_assembly

◆ linearSysNum()

unsigned int FEProblemBase::linearSysNum ( const LinearSystemName &  linear_sys_name) const
overridevirtualinherited
Returns
the linear system number corresponding to the provided linear_sys_name

Implements SubProblem.

Definition at line 6470 of file FEProblemBase.C.

Referenced by Moose::compute_linear_system(), LinearSystem::computeGradients(), FEProblemBase::computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and DisplacedProblem::linearSysNum().

6471 {
6472  std::istringstream ss(linear_sys_name);
6473  unsigned int linear_sys_num;
6474  if (!(ss >> linear_sys_num) || !ss.eof())
6475  linear_sys_num = libmesh_map_find(_linear_sys_name_to_num, linear_sys_name);
6476 
6477  return linear_sys_num;
6478 }
std::map< LinearSystemName, unsigned int > _linear_sys_name_to_num
Map from linear system name to number.

◆ lineSearch()

void FEProblemBase::lineSearch ( )
virtualinherited

execute MOOSE line search

Definition at line 2699 of file FEProblemBase.C.

Referenced by ComputeLineSearchObjectWrapper::linesearch().

2700 {
2701  _line_search->lineSearch();
2702 }
std::shared_ptr< LineSearch > _line_search

◆ logAdd()

void FEProblemBase::logAdd ( const std::string &  system,
const std::string &  name,
const std::string &  type,
const InputParameters params 
) const
inherited

Output information about the object just added to the problem.

Definition at line 4322 of file FEProblemBase.C.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addOutput(), FEProblemBase::addPredictor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVariable(), and FEProblemBase::setResidualObjectParamsAndLog().

4326 {
4327  if (_verbose_setup != "false")
4328  _console << "[DBG] Adding " << system << " '" << name << "' of type " << type << std::endl;
4329  if (_verbose_setup == "extra")
4330  _console << params << std::endl;
4331 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
MooseEnum _verbose_setup
Whether or not to be verbose during setup.

◆ markFamilyPRefinement()

void SubProblem::markFamilyPRefinement ( const InputParameters params)
protectedinherited

Mark a variable family for either disabling or enabling p-refinement with valid parameters of a variable.

Definition at line 1367 of file SubProblem.C.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxVariable(), and FEProblemBase::addVariable().

1368 {
1369  auto family = Utility::string_to_enum<FEFamily>(params.get<MooseEnum>("family"));
1370  bool flag = _default_families_without_p_refinement.count(family);
1371  if (params.isParamValid("disable_p_refinement"))
1372  flag = params.get<bool>("disable_p_refinement");
1373 
1374  auto [it, inserted] = _family_for_p_refinement.emplace(family, flag);
1375  if (!inserted && flag != it->second)
1376  mooseError("'disable_p_refinement' not set consistently for variables in ", family);
1377 }
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
std::unordered_map< FEFamily, bool > _family_for_p_refinement
Indicate whether a family is disabled for p-refinement.
Definition: SubProblem.h:1205
static const std::unordered_set< FEFamily > _default_families_without_p_refinement
The set of variable families by default disable p-refinement.
Definition: SubProblem.h:1207
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
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
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ markMatPropRequested()

void SubProblem::markMatPropRequested ( const std::string &  prop_name)
virtualinherited

Helper method for adding a material property name to the _material_property_requested set.

Definition at line 724 of file SubProblem.C.

Referenced by MaterialBase::markMatPropRequested(), and MaterialPropertyInterface::markMatPropRequested().

725 {
726  _material_property_requested.insert(prop_name);
727 }
std::set< std::string > _material_property_requested
set containing all material property names that have been requested by getMaterialProperty* ...
Definition: SubProblem.h:1062

◆ matrixTagExists() [1/2]

bool SubProblem::matrixTagExists ( const TagName &  tag_name) const
virtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 328 of file SubProblem.C.

Referenced by SystemBase::addMatrix(), SystemBase::associateMatrixToTag(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), SystemBase::disassociateDefaultMatrixTags(), SystemBase::disassociateMatrixFromTag(), SystemBase::getMatrix(), SubProblem::getMatrixTagID(), SystemBase::matrixTagActive(), DisplacedProblem::matrixTagExists(), SystemBase::removeMatrix(), and TaggingInterface::useMatrixTag().

329 {
330  auto tag_name_upper = MooseUtils::toUpper(tag_name);
331 
332  return _matrix_tag_name_to_tag_id.find(tag_name_upper) != _matrix_tag_name_to_tag_id.end();
333 }
std::map< TagName, TagID > _matrix_tag_name_to_tag_id
The currently declared tags.
Definition: SubProblem.h:1041
std::string toUpper(std::string name)
Convert supplied string to upper case.

◆ matrixTagExists() [2/2]

bool SubProblem::matrixTagExists ( TagID  tag_id) const
virtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 336 of file SubProblem.C.

337 {
338  return _matrix_tag_id_to_tag_name.find(tag_id) != _matrix_tag_id_to_tag_name.end();
339 }
std::map< TagID, TagName > _matrix_tag_id_to_tag_name
Reverse map.
Definition: SubProblem.h:1044

◆ matrixTagName()

TagName SubProblem::matrixTagName ( TagID  tag)
virtualinherited

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 357 of file SubProblem.C.

Referenced by SystemBase::addMatrix(), DisplacedProblem::matrixTagName(), and SystemBase::removeMatrix().

358 {
359  return _matrix_tag_id_to_tag_name[tag];
360 }
std::map< TagID, TagName > _matrix_tag_id_to_tag_name
Reverse map.
Definition: SubProblem.h:1044

◆ mesh() [1/3]

MFEMMesh & MFEMProblem::mesh ( )
overridevirtual

Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMesh.

Reimplemented from FEProblemBase.

Definition at line 465 of file MFEMProblem.C.

Referenced by addMFEMFESpaceFromMOOSEVariable(), MFEMGMRESSolver::constructSolver(), MFEMHypreFGMRES::constructSolver(), MFEMCGSolver::constructSolver(), MFEMHyprePCG::constructSolver(), MFEMHypreGMRES::constructSolver(), MFEMSuperLU::constructSolver(), displaceMesh(), getMeshDisplacementGridFunction(), MFEMSimplifiedFESpace::getProblemDim(), MFEMCutTransitionSubMesh::labelMesh(), mesh(), setMesh(), MFEMHyprePCG::updateSolver(), MFEMHypreFGMRES::updateSolver(), and MFEMHypreGMRES::updateSolver().

466 {
467  mooseAssert(ExternalProblem::mesh().type() == "MFEMMesh",
468  "Please choose the MFEMMesh mesh type for an MFEMProblem\n");
469  return static_cast<MFEMMesh &>(_mesh);
470 }
MooseMesh & _mesh
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MFEMMesh inherits a MOOSE mesh class which allows us to work with other MOOSE objects.
Definition: MFEMMesh.h:22
virtual MooseMesh & mesh() override

◆ mesh() [2/3]

const MFEMMesh & MFEMProblem::mesh ( ) const
overridevirtual

Reimplemented from FEProblemBase.

Definition at line 473 of file MFEMProblem.C.

474 {
475  return const_cast<MFEMProblem *>(this)->mesh();
476 }
virtual MFEMMesh & mesh() override
Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMes...
Definition: MFEMProblem.C:465

◆ mesh() [3/3]

const MooseMesh & FEProblemBase::mesh ( bool  use_displaced) const
overridevirtualinherited

Implements SubProblem.

Definition at line 663 of file FEProblemBase.C.

664 {
665  if (use_displaced && !_displaced_problem)
666  mooseWarning("Displaced mesh was requested but the displaced problem does not exist. "
667  "Regular mesh will be returned");
668  return ((use_displaced && _displaced_problem) ? _displaced_problem->mesh() : mesh());
669 }
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:299
virtual MooseMesh & mesh() override
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ meshChanged() [1/2]

void FEProblemBase::meshChanged ( bool  intermediate_change,
bool  contract_mesh,
bool  clean_refinement_flags 
)
virtualinherited

Update data after a mesh change.

Iff intermediate_change is true, only perform updates as necessary to prepare for another mesh change immediately-subsequent. An example of data that is not updated during an intermediate change is libMesh System matrix data. An example of data that is updated during an intermediate change is libMesh System vectors. These vectors are projected or restricted based off of adaptive mesh refinement or the changing of element subdomain IDs. The flags contract_mesh and clean_refinement_flags should generally only be set to true when the mesh has changed due to mesh refinement. contract_mesh deletes children of coarsened elements and renumbers nodes and elements. clean_refinement_flags resets refinement flags such that any subsequent calls to System::restrict_vectors or System::prolong_vectors before another AMR step do not mistakenly attempt to re-do the restriction/prolongation which occurred in this method

Definition at line 8233 of file FEProblemBase.C.

Referenced by SidesetAroundSubdomainUpdater::finalize(), ActivateElementsUserObjectBase::finalize(), Exodus::handleExodusIOMeshRenumbering(), ElementSubdomainModifierBase::modify(), and Adaptivity::uniformRefineWithProjection().

8236 {
8237  TIME_SECTION("meshChanged", 3, "Handling Mesh Changes");
8238 
8241  _mesh.cacheChangedLists(); // Currently only used with adaptivity and stateful material
8242  // properties
8243 
8244  // Clear these out because they corresponded to the old mesh
8245  _ghosted_elems.clear();
8247 
8248  // The mesh changed. We notify the MooseMesh first, because
8249  // callbacks (e.g. for sparsity calculations) triggered by the
8250  // EquationSystems reinit may require up-to-date MooseMesh caches.
8251  _mesh.meshChanged();
8252 
8253  // If we're just going to alter the mesh again, all we need to
8254  // handle here is AMR and projections, not full system reinit
8255  if (intermediate_change)
8256  es().reinit_solutions();
8257  else
8258  es().reinit();
8259 
8260  if (contract_mesh)
8261  // Once vectors are restricted, we can delete children of coarsened elements
8262  _mesh.getMesh().contract();
8263  if (clean_refinement_flags)
8264  {
8265  // Finally clear refinement flags so that if someone tries to project vectors again without
8266  // an intervening mesh refinement to clear flags they won't run into trouble
8267  MeshRefinement refinement(_mesh.getMesh());
8268  refinement.clean_refinement_flags();
8269  }
8270 
8271  if (!intermediate_change)
8272  {
8273  // Since the mesh has changed, we need to make sure that we update any of our
8274  // MOOSE-system specific data.
8275  for (auto & sys : _solver_systems)
8276  sys->reinit();
8277  _aux->reinit();
8278  }
8279 
8280  // Updating MooseMesh first breaks other adaptivity code, unless we
8281  // then *again* update the MooseMesh caches. E.g. the definition of
8282  // "active" and "local" may have been *changed* by refinement and
8283  // repartitioning done in EquationSystems::reinit().
8284  _mesh.meshChanged();
8285 
8286  // If we have finite volume variables, we will need to recompute additional elemental/face
8287  // quantities
8290 
8291  // Let the meshChangedInterface notify the mesh changed event before we update the active
8292  // semilocal nodes, because the set of ghosted elements may potentially be updated during a mesh
8293  // changed event.
8294  for (const auto & mci : _notify_when_mesh_changes)
8295  mci->meshChanged();
8296 
8297  // Since the Mesh changed, update the PointLocator object used by DiracKernels.
8299 
8300  // Need to redo ghosting
8302 
8303  if (_displaced_problem)
8304  {
8305  _displaced_problem->meshChanged(contract_mesh, clean_refinement_flags);
8307  }
8308 
8310 
8313 
8314  // Just like we reinitialized our geometric search objects, we also need to reinitialize our
8315  // mortar meshes. Note that this needs to happen after DisplacedProblem::meshChanged because the
8316  // mortar mesh discretization will depend necessarily on the displaced mesh being re-displaced
8317  updateMortarMesh();
8318 
8319  // Nonlinear systems hold the mortar mesh functors. The domains of definition of the mortar
8320  // functors might have changed when the mesh changed.
8321  for (auto & nl_sys : _nl)
8322  nl_sys->reinitMortarFunctors();
8323 
8324  reinitBecauseOfGhostingOrNewGeomObjects(/*mortar_changed=*/true);
8325 
8326  // We need to create new storage for newly active elements, and copy
8327  // stateful properties from the old elements.
8330  {
8331  if (havePRefinement())
8333 
8334  // Prolong properties onto newly refined elements' children
8335  {
8337  /* refine = */ true, *this, _material_props, _bnd_material_props, _assembly);
8338  const auto & range = *_mesh.refinedElementRange();
8339  Threads::parallel_reduce(range, pmp);
8340 
8341  // Concurrent erasure from the shared hash map is not safe while we are reading from it in
8342  // ProjectMaterialProperties, so we handle erasure here. Moreover, erasure based on key is
8343  // not thread safe in and of itself because it is a read-write operation. Note that we do not
8344  // do the erasure for p-refinement because the coarse level element is the same as our active
8345  // refined level element
8346  if (!doingPRefinement())
8347  for (const auto & elem : range)
8348  {
8352  }
8353  }
8354 
8355  // Restrict properties onto newly coarsened elements
8356  {
8358  /* refine = */ false, *this, _material_props, _bnd_material_props, _assembly);
8359  const auto & range = *_mesh.coarsenedElementRange();
8360  Threads::parallel_reduce(range, pmp);
8361  // Note that we do not do the erasure for p-refinement because the coarse level element is the
8362  // same as our active refined level element
8363  if (!doingPRefinement())
8364  for (const auto & elem : range)
8365  {
8366  auto && coarsened_children = _mesh.coarsenedElementChildren(elem);
8367  for (auto && child : coarsened_children)
8368  {
8372  }
8373  }
8374  }
8375  }
8376 
8379 
8380  _has_jacobian = false; // we have to recompute jacobian when mesh changed
8381 
8382  // Now for backwards compatibility with user code that overrode the old no-arg meshChanged we must
8383  // call it here
8384  meshChanged();
8385 }
void setVariableAllDoFMap(const std::vector< const MooseVariableFEBase *> &moose_vars)
bool isFiniteVolumeInfoDirty() const
Definition: MooseMesh.h:1330
virtual void meshChanged()
Deprecated.
void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed=false)
Call when it is possible that the needs for ghosted elements has changed.
MaterialPropertyStorage & _bnd_material_props
bool _has_jacobian
Indicates if the Jacobian was computed.
virtual bool haveFV() const override
returns true if this problem includes/needs finite volume functionality.
void eraseProperty(const Elem *elem)
Remove the property storage and element pointer from internal data structures Use this when elements ...
void parallel_reduce(const Range &range, Body &body, const Partitioner &)
void cacheChangedLists()
Cache information about what elements were refined and coarsened in the previous step.
Definition: MooseMesh.C:928
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
ConstElemPointerRange * refinedElementRange() const
Return a range that is suitable for threaded execution over elements that were just refined...
Definition: MooseMesh.C:946
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
Definition: SubProblem.h:1093
std::unique_ptr< libMesh::ConstElemRange > _nl_evaluable_local_elem_range
bool _calculate_jacobian_in_uo
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
bool havePRefinement() const
Query whether p-refinement has been requested at any point during the simulation. ...
Definition: SubProblem.h:1009
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition: MooseMesh.C:3488
std::vector< MeshChangedInterface * > _notify_when_mesh_changes
Objects to be notified when the mesh changes.
virtual libMesh::EquationSystems & es() override
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
void reinit()
Completely redo all geometric search objects.
bool doingPRefinement() const
Definition: SubProblem.C:1361
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
virtual void updateMortarMesh()
const std::vector< const Elem * > & coarsenedElementChildren(const Elem *elem) const
Get the newly removed children element ids for an element that was just coarsened.
Definition: MooseMesh.C:958
virtual bool contract()=0
void updateActiveSemiLocalNodeRange(std::set< dof_id_type > &ghosted_elems)
Clears the "semi-local" node list and rebuilds it.
Definition: MooseMesh.C:966
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars
std::shared_ptr< DisplacedProblem > _displaced_problem
GeometricSearchData _geometric_search_data
bool _has_initialized_stateful
Whether nor not stateful materials have been initialized.
MaterialPropertyStorage & _neighbor_material_props
ConstElemPointerRange * coarsenedElementRange() const
Return a range that is suitable for threaded execution over elements that were just coarsened...
Definition: MooseMesh.C:952
std::unique_ptr< libMesh::ConstElemRange > _evaluable_local_elem_range
DiracKernelInfo _dirac_kernel_info
Definition: SubProblem.h:1049
MaterialPropertyStorage & _material_props
void updatePointLocator(const MooseMesh &mesh)
Called during FEProblemBase::meshChanged() to update the PointLocator object used by the DiracKernels...
MooseMesh * _displaced_mesh
void meshChanged()
Declares that the MooseMesh has changed, invalidates cached data and rebuilds caches.
Definition: MooseMesh.C:897
void buildPRefinementAndCoarseningMaps(Assembly *assembly)
Definition: MooseMesh.C:2406
virtual void ghostGhostedBoundaries() override
Causes the boundaries added using addGhostedBoundary to actually be ghosted.
void setupFiniteVolumeMeshData() const
Sets up the additional data needed for finite volume computations.
Definition: MooseMesh.C:4112

◆ meshChanged() [2/2]

virtual void FEProblemBase::meshChanged ( )
inlineprotectedvirtualinherited

Deprecated.

Users should switch to overriding the meshChanged which takes arguments

Definition at line 2667 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::initialAdaptMesh(), FEProblemBase::meshChanged(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateMeshXFEM().

2667 {}

◆ meshDisplaced()

void FEProblemBase::meshDisplaced ( )
protectedvirtualinherited

Update data after a mesh displaced.

Definition at line 8400 of file FEProblemBase.C.

Referenced by DisplacedProblem::updateMesh().

8401 {
8402  for (const auto & mdi : _notify_when_mesh_displaces)
8403  mdi->meshDisplaced();
8404 }
std::vector< MeshDisplacedInterface * > _notify_when_mesh_displaces
Objects to be notified when the mesh displaces.

◆ messagePrefix()

std::string MooseBase::messagePrefix ( const bool  hit_prefix = true) const
inlineinherited
Returns
A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

257  {
258  return messagePrefix(_pars, hit_prefix);
259  }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

◆ mooseDeprecated()

template<typename... Args>
void MooseBase::mooseDeprecated ( Args &&...  args) const
inlineinherited

Definition at line 314 of file MooseBase.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), MooseApp::getRecoverFileBase(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MooseApp::hasRecoverFileBase(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), MooseApp::setupOptions(), TagVectorAux::TagVectorAux(), UserForcingFunction::UserForcingFunction(), and VariableResidual::VariableResidual().

315  {
317  _console, false, true, messagePrefix(true), std::forward<Args>(args)...);
318  }
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, Args &&... args)
Definition: MooseError.h:265
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

◆ mooseDocumentedError()

template<typename... Args>
void MooseBase::mooseDocumentedError ( const std::string &  repo_name,
const unsigned int  issue_num,
Args &&...  args 
) const
inlineinherited

Definition at line 277 of file MooseBase.h.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

280  {
282  repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
283  /* with_prefix = */ true);
284  }
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105
std::string formatMooseDocumentedError(const std::string &repo_name, const unsigned int issue_num, const std::string &msg)
Formats a documented error.
Definition: MooseError.C:128

◆ mooseError()

template<typename... Args>
void MooseBase::mooseError ( Args &&...  args) const
inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 271 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), CheckFVBCAction::act(), CheckIntegrityAction::act(), InitProblemAction::act(), AddBoundsVectorsAction::act(), SetupMeshCompleteAction::act(), AddVectorPostprocessorAction::act(), AutoCheckpointAction::act(), CreateExecutionerAction::act(), AddFVICAction::act(), AddICAction::act(), AddMeshGeneratorAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), ChainControlSetupAction::act(), AddTimeStepperAction::act(), DeprecatedBlockAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), SetAdaptivityOptionsAction::act(), MaterialOutputAction::act(), AddMFEMSubMeshAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::adaptMesh(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), MooseVariableFV< Real >::adCurlSln(), MooseVariableFV< Real >::adCurlSlnNeighbor(), AddActionComponentAction::AddActionComponentAction(), addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DiffusionCG::addBoundaryConditionsFromComponents(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), FEProblemBase::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFVInitialCondition(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInitialCondition(), PhysicsComponentInterface::addInitialConditionsFromComponents(), FEProblemBase::addInterfaceKernel(), addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), addMaterial(), MeshGenerator::addMeshSubgenerator(), addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DiracKernelBase::addPoint(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addScalarKernel(), AddVariableAction::addVariable(), FEProblemBase::addVectorPostprocessor(), SubProblem::addVectorTag(), MooseLinearVariableFV< Real >::adError(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), AdvectiveFluxAux::AdvectiveFluxAux(), MooseVariableBase::allDofIndices(), NEML2ModelExecutor::applyPredictor(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), MooseApp::attachRelationshipManagers(), AddPeriodicBCAction::autoTranslationBoundaries(), AuxKernelTempl< Real >::AuxKernelTempl(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), TimedSubdomainModifier::buildFromParameters(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), MooseMesh::buildLowerDMesh(), TiledMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildSideList(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), FEProblemBase::checkExceptionAndStopSolve(), NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), DefaultSteadyStateConvergence::checkIterationType(), DefaultMultiAppFixedPointConvergence::checkIterationType(), DefaultNonlinearConvergence::checkIterationType(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), Sampler::checkReinitStatus(), MooseApp::checkReservedCapability(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::checkSiblingsTransferSupported(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), FEProblemBase::checkUserObjects(), Moose::PetscSupport::checkUserProvidedPetscOption(), DomainUserObject::checkVariable(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), LibmeshPartitioner::clone(), MooseMesh::clone(), CombinerGenerator::CombinerGenerator(), ComparisonPostprocessor::comparisonIsTrue(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), FEProblemBase::computeBounds(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), InternalSideIntegralPostprocessor::computeFaceInfoIntegral(), SideIntegralPostprocessor::computeFaceInfoIntegral(), MooseVariableFieldBase::computeFaceValues(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), FVFluxKernel::computeJacobian(), NodalConstraint::computeJacobian(), FEProblemBase::computeJacobianTags(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), EigenProblem::computeMatricesTags(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), FVElementalKernel::computeOffDiagJacobian(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MaterialBase::computeProperties(), SideFVFluxBCIntegral::computeQpIntegral(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), NodalEqualValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), NodeElemConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), MassMatrix::computeQpResidual(), HDGKernel::computeQpResidual(), DiffusionLHDGDirichletBC::computeQpResidual(), NodalEqualValueConstraint::computeQpResidual(), DiffusionLHDGPrescribedGradientBC::computeQpResidual(), IPHDGBC::computeQpResidual(), KernelValue::computeQpResidual(), TorchScriptMaterial::computeQpValues(), InterfaceQpValueUserObject::computeRealValue(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FVFluxBC::computeResidual(), FVFluxKernel::computeResidual(), NodalConstraint::computeResidual(), FVFluxKernel::computeResidualAndJacobian(), ResidualObject::computeResidualAndJacobian(), FEProblemBase::computeResidualAndJacobian(), HDGKernel::computeResidualAndJacobianOnSide(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), KernelScalarBase::computeScalarOffDiagJacobian(), ADKernelScalarBase::computeScalarQpResidual(), ADMortarScalarBase::computeScalarQpResidual(), MortarScalarBase::computeScalarQpResidual(), KernelScalarBase::computeScalarQpResidual(), TimeStepper::computeStep(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CentralDifference::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), MultiAppGeometricInterpolationTransfer::computeTransformation(), BuildArrayVariableAux::computeValue(), TagVectorArrayVariableAux::computeValue(), NearestNodeValueAux::computeValue(), ProjectionAux::computeValue(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), CoupledForceNodalKernel::CoupledForceNodalKernel(), MultiApp::createApp(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), MooseVariableFV< Real >::curlPhi(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), SidesetInfoVectorPostprocessor::dataHelper(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyByName(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), DefaultSteadyStateConvergence::DefaultSteadyStateConvergence(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), BicubicSplineFunction::derivative(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), MooseApp::determineLibtorchDeviceType(), FEProblemBase::determineSolverSystem(), DGKernel::DGKernel(), MeshDiagnosticsGenerator::diagnosticsLog(), DistributedPositions::DistributedPositions(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), MooseVariableFV< Real >::divPhi(), FunctorRelationshipManager::dofmap_reinit(), EigenProblem::doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementIntegerAux::ElementIntegerAux(), ElementMaterialSampler::ElementMaterialSampler(), ElementQualityAux::ElementQualityAux(), ElementUOAux::ElementUOAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), DistributedRectilinearMeshGenerator::elemId(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), EigenKernel::enabled(), MooseApp::errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), SideIntegralPostprocessor::errorNoFaceInfo(), SideIntegralFunctorPostprocessorTempl< false >::errorNoFaceInfo(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), FixedPointSolve::examineFixedPointConvergence(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), RealToBoolChainControl::execute(), DiscreteElementUserObject::execute(), RestartableDataReporter::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), PositionsFunctorValueSampler::execute(), NodalValueSampler::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorTransfer::execute(), ElementQualityChecker::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppUserObjectTransfer::execute(), InterfaceQpUserObjectBase::execute(), MultiAppGeometricInterpolationTransfer::execute(), WebServerControl::execute(), TransientBase::execute(), LeastSquaresFit::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFitHistory::execute(), Eigenvalue::execute(), TimeExtremeValue::execute(), DomainUserObject::execute(), FEProblemBase::execute(), FEProblemBase::executeControls(), MooseApp::executeExecutioner(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), NEML2ModelExecutor::extractOutputs(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), NEML2ModelExecutor::fillInputs(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), VerifyNodalUniqueID::finalize(), VerifyElementUniqueID::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), DiscreteVariableResidualNorm::finalize(), NearestPointAverage::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), MooseApp::finalizeRestore(), Transfer::find_sys(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVMassMatrix::FVMassMatrix(), FVMatAdvection::FVMatAdvection(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), GapValueAux::GapValueAux(), WorkBalance::gather(), ElementSubdomainModifierBase::gatherPatchElements(), Boundary2DDelaunayGenerator::General2DDelaunay(), ElementOrderConversionGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SmoothMeshGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), MoveNodeGenerator::generate(), SideSetsFromPointsGenerator::generate(), StitchMeshGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), MeshDiagnosticsGenerator::generate(), MeshRepairGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), AdvancedExtruderGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedGenerateNodeset::generate(), SpiralAnnularMeshGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), CutMeshByLevelSetGeneratorBase::generate(), SubdomainBoundingBoxGenerator::generate(), PatternedMeshGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), RandomICBase::generateRandom(), GenericConstantMaterialTempl< is_ad >::GenericConstantMaterialTempl(), GenericConstantVectorMaterialTempl< is_ad >::GenericConstantVectorMaterialTempl(), GenericFunctionMaterialTempl< is_ad >::GenericFunctionMaterialTempl(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), DisplacedProblem::getActualFieldVariable(), FEProblemBase::getActualFieldVariable(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), MooseMesh::getAxisymmetricRadialCoord(), MFEMFESpace::getBasis(), NEML2BatchIndexGenerator::getBatchIndex(), MooseMesh::getBlockConnectedBlocks(), VariableOldValueBounds::getBound(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), MooseMesh::getCoarseningMap(), NodalPatchRecoveryBase::getCoefficients(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), FEProblemBase::getConvergence(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PropertyReadFile::getData(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), FEProblemBase::getDistribution(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), GhostingUserObject::getElementalValue(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), PropertyReadFile::getElementData(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), MultiAppFieldTransfer::getEquationSystem(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MFEMVectorFESpace::getFECName(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVMatsAndDependencies(), MooseMesh::getGeneralAxisymmetricCoordAxis(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), FEProblemBase::getLinearConvergenceNames(), SolutionUserObjectBase::getLocalVarIndex(), Material::getMaterialByName(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), SubProblem::getMatrixTagID(), GeneratedMesh::getMaxInDimension(), AnnularMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), GeneratedMesh::getMinInDimension(), AnnularMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), FEProblemBase::getMultiAppFixedPointConvergenceName(), DistributedRectilinearMeshGenerator::getNeighbors(), Times::getNextTime(), MooseMesh::getNodeBlockIds(), PropertyReadFile::getNodeData(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearConvergenceNames(), EigenProblem::getNonlinearEigenSystem(), FEProblemBase::getNonlinearSystem(), NEML2ModelExecutor::getOutput(), NEML2ModelExecutor::getOutputDerivative(), NEML2ModelExecutor::getOutputParameterDerivative(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), PlaneIDMeshGenerator::getPlaneID(), Positions::getPosition(), Positions::getPositions(), FEProblemBase::getPositionsObject(), Positions::getPositionsVector2D(), Positions::getPositionsVector3D(), Positions::getPositionsVector4D(), PostprocessorInterface::getPostprocessorValueByNameInternal(), Times::getPreviousTime(), ComponentMaterialPropertyInterface::getPropertyValue(), InterfaceQpUserObjectBase::getQpValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), FEProblemBase::getSampler(), WebServerControl::getScalarJSONValue(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), MooseObject::getSharedPtr(), InterfaceQpUserObjectBase::getSideAverageValue(), PhysicsBase::getSolverSystem(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSteadyStateConvergenceName(), MooseMesh::getSubdomainBoundaryIds(), TimedSubdomainModifier::getSubdomainIDAndCheck(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), Times::getTimeAtIndex(), FEProblemBase::getTimeFromStateArg(), TransientBase::getTimeIntegratorNames(), Times::getTimes(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), NumRelationshipManagers::getValue(), VectorPostprocessorComponent::getValue(), Residual::getValue(), SideAverageValue::getValue(), JSONFileReader::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), JSONFileReader::getVector(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingFromUOAux::GhostingFromUOAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), Function::gradient(), FEProblemBase::handleException(), Terminator::handleMessage(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), HDGKernel::HDGKernel(), TransientBase::incrementStepOrReject(), FixedPointIterationAdaptiveDT::init(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), EigenExecutionerBase::init(), ExplicitTimeIntegrator::init(), TransientBase::init(), FEProblem::init(), AddAuxVariableAction::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), MultiApp::init(), FEProblemBase::initialAdaptMesh(), NestedDivision::initialize(), DistributedPositions::initialize(), ReporterPositions::initialize(), TransformedPositions::initialize(), ElementGroupCentroidPositions::initialize(), ReporterTimes::initialize(), FunctorPositions::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SteffensenSolve::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), PiecewiseLinearBase::initialSetup(), ChainControlDataPostprocessor::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), SolutionScalarAux::initialSetup(), LinearFVAdvection::initialSetup(), LinearFVDiffusion::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), SolutionAux::initialSetup(), ExplicitTimeIntegrator::initialSetup(), ReferenceResidualConvergence::initialSetup(), NodalVariableValue::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), ElementSubdomainModifierBase::initialSetup(), Exodus::initialSetup(), CSV::initialSetup(), MooseParsedFunction::initialSetup(), SolutionUserObjectBase::initialSetup(), FEProblemBase::initialSetup(), SubProblem::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Function::integral(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), InternalSideIndicatorBase::InternalSideIndicatorBase(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), MooseApp::libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MooseApp::loadLibraryAndDependencies(), MultiAppGeneralFieldTransfer::locatePointReceivers(), LowerBoundNodalKernel::LowerBoundNodalKernel(), MooseLinearVariableFV< Real >::lowerDError(), PNGOutput::makePNG(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), MassMatrix::MassMatrix(), Material::Material(), MaterialRealTensorValueAuxTempl< is_ad >::MaterialRealTensorValueAuxTempl(), MaterialRealVectorValueAuxTempl< T, is_ad, is_functor >::MaterialRealVectorValueAuxTempl(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableConstMonomial::MooseVariableConstMonomial(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), FEProblemBase::needsPreviousNewtonIteration(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), MooseVariableFV< Real >::nodalDofIndex(), MooseVariableFV< Real >::nodalDofIndexNeighbor(), MooseLinearVariableFV< Real >::nodalError(), MooseVariableFV< Real >::nodalMatrixTagValue(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalScalarKernel::NodalScalarKernel(), MooseVariableFV< Real >::nodalValueArray(), MooseVariableFV< Real >::nodalValueOldArray(), MooseVariableFV< Real >::nodalValueOlderArray(), NodalVariableValue::NodalVariableValue(), MooseVariableFV< Real >::nodalVectorTagValue(), DistributedRectilinearMeshGenerator::nodeId(), MooseVariableFV< Real >::numberOfDofsNeighbor(), NumDOFs::NumDOFs(), NumFailedTimeSteps::NumFailedTimeSteps(), DistributedRectilinearMeshGenerator::numNeighbors(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), XDA::output(), SolutionHistory::output(), Exodus::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), MooseApp::outputMachineReadableData(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), Exodus::outputSetup(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), DistributedRectilinearMeshGenerator::paritionSquarely(), PiecewiseBilinear::parse(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), MultiAppConservativeTransfer::performAdjustment(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), MooseVariableFV< Real >::phiLowerSize(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), PiecewiseTabularBase::PiecewiseTabularBase(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), SolutionUserObjectBase::pointValueGradientWrapper(), SolutionUserObjectBase::pointValueWrapper(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), AStableDirk4::postResidual(), LStableDirk4::postResidual(), ExplicitRK2::postResidual(), EigenProblem::postScaleEigenVector(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), ADKernelValueTempl< T >::precomputeQpJacobian(), FunctorKernel::precomputeQpResidual(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), ElementSubdomainModifierBase::prepareVariableForReinitialization(), FixedPointSolve::printFixedPointConvergenceReason(), PseudoTimestep::PseudoTimestep(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusII(), SolutionUserObjectBase::readXda(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), MFEMTransient::relativeSolutionDifferenceNorm(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), PiecewiseMultiInterpolation::sample(), ScalarComponentIC::ScalarComponentIC(), MortarScalarBase::scalarVariable(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), BicubicSplineFunction::secondDerivative(), MooseVariableFV< Real >::secondPhi(), MooseVariableFV< Real >::secondPhiFace(), MooseVariableFV< Real >::secondPhiFaceNeighbor(), MooseVariableFV< Real >::secondPhiNeighbor(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), FEProblemBase::setCoupling(), PiecewiseBase::setData(), FileOutput::setFileBaseInternal(), MooseMesh::setGeneralAxisymmetricCoordAxes(), FEProblemSolve::setInnerSolve(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), FVPointValueConstraint::setMyElem(), FEProblemBase::setNonlocalCouplingMatrix(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), AddPeriodicBCAction::setPeriodicVars(), MFEMSolverBase::setPreconditioner(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), Split::setup(), TransientMultiApp::setupApp(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), TimePeriodBase::setupTimes(), IntegratedBCBase::shouldApply(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SideAdvectiveFluxIntegralTempl< is_ad >::SideAdvectiveFluxIntegralTempl(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObjectBase::SolutionUserObjectBase(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TimeIntegrator::solve(), FEProblemBase::solverSysNum(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialPoints(), NearestPointIntegralVariablePostprocessor::spatialValue(), NearestPointAverage::spatialValue(), MeshDivisionFunctorReductionVectorPostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), WebServerControl::stringifyJSONType(), MultiAppGeometricInterpolationTransfer::subdomainIDsNode(), Constraint::subdomainSetup(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), MaterialBase::subdomainSetup(), FEProblemBase::swapBackMaterialsNeighbor(), DisplacedProblem::systemBaseLinear(), Console::systemInfoFlags(), FEProblemBase::systemNumForVariable(), TerminateChainControl::terminate(), Terminator::Terminator(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), Function::timeDerivative(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeExtremeValue::TimeExtremeValue(), Function::timeIntegral(), MooseLinearVariableFV< Real >::timeIntegratorError(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriodBase::TimePeriodBase(), VectorPostprocessorVisualizationAux::timestepSetup(), WebServerControl::toMiniJson(), MultiAppDofCopyTransfer::transfer(), MultiAppMFEMCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransformedPositions::TransformedPositions(), FEProblemBase::trustUserCouplingMatrix(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), MooseBase::uniqueName(), Positions::unrollMultiDPositions(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), Checkpoint::updateCheckpointFiles(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObjectBase::updateExodusBracketingTimeIndices(), FEProblemBase::updateMaxQps(), MFEMHypreADS::updateSolver(), MFEMHypreAMS::updateSolver(), MFEMHyprePCG::updateSolver(), MFEMCGSolver::updateSolver(), MFEMHypreBoomerAMG::updateSolver(), MFEMHypreFGMRES::updateSolver(), MFEMOperatorJacobiSmoother::updateSolver(), MFEMGMRESSolver::updateSolver(), MFEMHypreGMRES::updateSolver(), MFEMSuperLU::updateSolver(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointIntegralVariablePostprocessor::userObjectValue(), NearestPointAverage::userObjectValue(), BoundingBoxIC::value(), PiecewiseConstantFromCSV::value(), IntegralPreservingFunctionIC::value(), Axisymmetric2D3DSolutionFunction::value(), Function::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), AddVariableAction::variableType(), VariableValueVolumeHistogram::VariableValueVolumeHistogram(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), VectorNodalBC::VectorNodalBC(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), VTKOutput::VTKOutput(), WebServerControl::WebServerControl(), MooseApp::writeRestartableMetaData(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

272  {
273  callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
274  }
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105

◆ mooseErrorNonPrefixed()

template<typename... Args>
void MooseBase::mooseErrorNonPrefixed ( Args &&...  args) const
inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 290 of file MooseBase.h.

291  {
292  callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
293  }
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105

◆ mooseInfo()

template<typename... Args>
void MooseBase::mooseInfo ( Args &&...  args) const
inlineinherited

Definition at line 321 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MFEMScalarFESpace::getFECName(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

322  {
323  moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
324  }
void mooseInfoStream(S &oss, Args &&... args)
Definition: MooseError.h:258
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

◆ mooseWarning()

template<typename... Args>
void MooseBase::mooseWarning ( Args &&...  args) const
inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), addFunction(), MooseMesh::addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), DataFileInterface::getDataFilePath(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseApp::loadLibraryAndDependencies(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramWarning(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

300  {
301  moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
302  }
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:210
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:256

◆ mooseWarningNonPrefixed()

template<typename... Args>
void MooseBase::mooseWarningNonPrefixed ( Args &&...  args) const
inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 308 of file MooseBase.h.

309  {
310  moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
311  }
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:210
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.

◆ mortarData() [1/2]

const MortarData& FEProblemBase::mortarData ( ) const
inlineinherited

Returns the mortar data object.

Definition at line 2351 of file FEProblemBase.h.

2351 { return _mortar_data; }
MortarData _mortar_data

◆ mortarData() [2/2]

MortarData& FEProblemBase::mortarData ( )
inlineinherited

Definition at line 2352 of file FEProblemBase.h.

2352 { return _mortar_data; }
MortarData _mortar_data

◆ name()

const std::string& MooseBase::name ( ) const
inlineinherited

Get the name of the class.

Returns
The name of the class

Definition at line 103 of file MooseBase.h.

Referenced by AddElementalFieldAction::act(), CopyNodalVarsAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), DeprecatedBlockAction::act(), SetupTimeIntegratorAction::act(), AddActionComponentAction::act(), SetupResidualDebugAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), Registry::addDataFilePath(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), addFESpace(), addFunction(), FEProblemBase::addFunction(), SubProblem::addFunctor(), addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), addInitialCondition(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), DiffusionLHDGKernel::additionalROVariables(), IPHDGAssemblyHelper::additionalROVariables(), addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), addMFEMPreconditioner(), addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), InitialConditionWarehouse::addObject(), FEProblemBase::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), addPostprocessor(), FEProblemBase::addPostprocessor(), InitialConditionBase::addPostprocessorDependencyHelper(), UserObject::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), InitialConditionBase::addUserObjectDependencyHelper(), UserObject::addUserObjectDependencyHelper(), AuxKernelTempl< Real >::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), UserObject::addVectorPostprocessorDependencyHelper(), MooseLinearVariableFV< Real >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), Registry::appNameFromAppPath(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), AuxKernelTempl< Real >::AuxKernelTempl(), Function::average(), MultiApp::backup(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), MFEMFESpace::buildFEC(), PiecewiseTabularBase::buildFromFile(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), ParsedConvergence::checkConvergence(), DefaultNonlinearConvergence::checkConvergence(), FEProblemBase::checkDependMaterialsHelper(), SamplerBase::checkForStandardFieldVariableType(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Moose::Kokkos::Material< KokkosGenericConstantMaterial >::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), DomainUserObject::checkVariable(), BlockRestrictable::checkVariable(), Coupleable::checkWritableVar(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MooseBase::connectControllableParams(), ConstantPostprocessor::ConstantPostprocessor(), Coupleable::coupledName(), CommonOutputAction::create(), MultiApp::createApp(), MooseApp::createExecutors(), MeshGeneratorSystem::createMeshGeneratorOrder(), MooseApp::createRecoverablePerfGraph(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), DebugResidualAux::DebugResidualAux(), MaterialBase::declareADProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), Registry::determineDataFilePath(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), SideValueSampler::execute(), RestartableDataReporter::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), WebServerControl::execute(), MultiAppGeneralFieldTransfer::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FunctionIC::functionName(), FVFunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), MooseServer::gatherDocumentSymbols(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MeshGenerator::generateInternal(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), Registry::getDataFilePath(), UserObject::getDependObjects(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), MooseApp::getExecutor(), FEProblemBase::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), AuxKernelTempl< Real >::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), getGridFunction(), Moose::Kokkos::Material< KokkosGenericConstantMaterial >::getKokkosMaterialProperty(), Moose::Kokkos::Material< KokkosGenericConstantMaterial >::getKokkosMaterialPropertyOld(), Moose::Kokkos::Material< KokkosGenericConstantMaterial >::getKokkosMaterialPropertyOlder(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), Material::getMaterialProperty(), AuxKernelTempl< Real >::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), AuxKernelTempl< Real >::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), AuxKernelTempl< Real >::getMaterialPropertyOlder(), MFEMGeneralUserObject::getMatrixCoefficient(), MFEMGeneralUserObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), ActionWarehouse::getMooseAppName(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), MooseServer::getObjectParameters(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), OutputWarehouse::getOutput(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMGeneralUserObject::getScalarCoefficient(), MFEMGeneralUserObject::getScalarCoefficientByName(), TimedSubdomainModifier::getSubdomainIDAndCheck(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMGeneralUserObject::getVectorCoefficient(), MFEMGeneralUserObject::getVectorCoefficientByName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), MooseApp::hasMeshGenerator(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), IterationAdaptiveDT::init(), AddVariableAction::init(), AdvancedOutput::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), JSONOutput::initialSetup(), SideFVFluxBCIntegral::initialSetup(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), NodalVariableValue::initialSetup(), Console::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< MortarScalarBase >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< Real >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), MatDiffusionBase< Real >::MatDiffusionBase(), Material::Material(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), OutputWarehouse::mooseConsole(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MooseLinearVariableFV< Real >::nodalError(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), Registry::objData(), MeshGenerator::Comparator::operator()(), ProgressOutput::output(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), MooseApp::possiblyLoadRestartableMetaData(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), AppFactory::reg(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), MooseMesh::setSubdomainName(), NodeSetsGeneratorBase::setup(), Split::setup(), SideSetsGeneratorBase::setup(), TransientMultiApp::setupApp(), FullSolveMultiApp::showStatusMessage(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), SubProblem::storeSubdomainZeroMatProp(), ConstraintWarehouse::subdomainsCovered(), MaterialBase::subdomainSetup(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< Real >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransientMultiApp::TransientMultiApp(), MooseServer::traverseParseTreeAndFillSymbols(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVFluxBC::uOnGhost(), FVFluxBC::uOnUSub(), UserObject::UserObject(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

104  {
105  mooseAssert(_name.size(), "Empty name");
106  return _name;
107  }
const std::string & _name
The name of this class.
Definition: MooseBase.h:363

◆ needBoundaryMaterialOnSide()

bool FEProblemBase::needBoundaryMaterialOnSide ( BoundaryID  bnd_id,
const THREAD_ID  tid 
)
inherited

These methods are used to determine whether stateful material properties need to be stored on internal sides.

There are five situations where this may be the case: 1) DGKernels 2) IntegratedBCs 3)InternalSideUserObjects 4)ElementalAuxBCs 5)InterfaceUserObjects

Method 1:

Parameters
bnd_idthe boundary id for which to see if stateful material properties need to be stored
tidthe THREAD_ID of the caller
Returns
Boolean indicating whether material properties need to be stored

Method 2:

Parameters
subdomain_idthe subdomain id for which to see if stateful material properties need to be stored
tidthe THREAD_ID of the caller
Returns
Boolean indicating whether material properties need to be stored

Definition at line 8855 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onBoundary(), and ProjectMaterialProperties::onBoundary().

8856 {
8857  if (_bnd_mat_side_cache[tid].find(bnd_id) == _bnd_mat_side_cache[tid].end())
8858  {
8859  auto & bnd_mat_side_cache = _bnd_mat_side_cache[tid][bnd_id];
8860  bnd_mat_side_cache = false;
8861 
8862  if (_aux->needMaterialOnSide(bnd_id))
8863  {
8864  bnd_mat_side_cache = true;
8865  return true;
8866  }
8867  else
8868  for (auto & nl : _nl)
8869  if (nl->needBoundaryMaterialOnSide(bnd_id, tid))
8870  {
8871  bnd_mat_side_cache = true;
8872  return true;
8873  }
8874 
8875  if (theWarehouse()
8876  .query()
8877  .condition<AttribThread>(tid)
8878  .condition<AttribInterfaces>(Interfaces::SideUserObject)
8879  .condition<AttribBoundaries>(bnd_id)
8880  .count() > 0)
8881  {
8882  bnd_mat_side_cache = true;
8883  return true;
8884  }
8885  }
8886 
8887  return _bnd_mat_side_cache[tid][bnd_id];
8888 }
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:30
std::vector< std::unordered_map< BoundaryID, bool > > _bnd_mat_side_cache
Cache for calculating materials on side.
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
TheWarehouse & theWarehouse() const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
AttribBoundaries tracks all boundary IDs associated with an object.
Definition: Attributes.h:188
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ needFV()

virtual void FEProblemBase::needFV ( )
inlineoverridevirtualinherited

marks this problem as including/needing finite volume functionality.

Implements SubProblem.

Definition at line 2616 of file FEProblemBase.h.

Referenced by DiffusionFV::initializePhysicsAdditional(), and DisplacedProblem::needFV().

2616 { _have_fv = true; }
bool _have_fv
Whether we are performing some calculations with finite volume discretizations.

◆ needInterfaceMaterialOnSide()

bool FEProblemBase::needInterfaceMaterialOnSide ( BoundaryID  bnd_id,
const THREAD_ID  tid 
)
inherited

Definition at line 8891 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInterface().

8892 {
8893  if (_interface_mat_side_cache[tid].find(bnd_id) == _interface_mat_side_cache[tid].end())
8894  {
8895  auto & interface_mat_side_cache = _interface_mat_side_cache[tid][bnd_id];
8896  interface_mat_side_cache = false;
8897 
8898  for (auto & nl : _nl)
8899  if (nl->needInterfaceMaterialOnSide(bnd_id, tid))
8900  {
8901  interface_mat_side_cache = true;
8902  return true;
8903  }
8904 
8905  if (theWarehouse()
8906  .query()
8907  .condition<AttribThread>(tid)
8908  .condition<AttribInterfaces>(Interfaces::InterfaceUserObject)
8909  .condition<AttribBoundaries>(bnd_id)
8910  .count() > 0)
8911  {
8912  interface_mat_side_cache = true;
8913  return true;
8914  }
8915  else if (_interface_materials.hasActiveBoundaryObjects(bnd_id, tid))
8916  {
8917  interface_mat_side_cache = true;
8918  return true;
8919  }
8920  }
8921  return _interface_mat_side_cache[tid][bnd_id];
8922 }
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:30
MaterialWarehouse _interface_materials
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
TheWarehouse & theWarehouse() const
AttribBoundaries tracks all boundary IDs associated with an object.
Definition: Attributes.h:188
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284
std::vector< std::unordered_map< BoundaryID, bool > > _interface_mat_side_cache
Cache for calculating materials on interface.

◆ needSolutionState()

void FEProblemBase::needSolutionState ( unsigned int  oldest_needed,
Moose::SolutionIterationType  iteration_type 
)
inherited

Declare that we need up to old (1) or older (2) solution states for a given type of iteration.

Parameters
oldest_neededoldest solution state needed
iteration_typethe type of iteration for which old/older states are needed

Definition at line 736 of file FEProblemBase.C.

Referenced by FEProblemBase::createTagSolutions().

737 {
738  for (auto & sys : _solver_systems)
739  sys->needSolutionState(state, iteration_type);
740  _aux->needSolutionState(state, iteration_type);
741 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ needsPreviousNewtonIteration() [1/2]

void FEProblemBase::needsPreviousNewtonIteration ( bool  state)
inherited

Set a flag that indicated that user required values for the previous Newton iterate.

Definition at line 8960 of file FEProblemBase.C.

Referenced by Coupleable::coupledGradientPreviousNL(), Coupleable::coupledNodalValuePreviousNL(), Coupleable::coupledSecondPreviousNL(), Coupleable::coupledValuePreviousNL(), and NonlinearSystem::solve().

8961 {
8963  mooseError("Previous nonlinear solution is required but not added through "
8964  "Problem/previous_nl_solution_required=true");
8965 }
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
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
const TagName PREVIOUS_NL_SOLUTION_TAG
Definition: MooseTypes.C:28

◆ needsPreviousNewtonIteration() [2/2]

bool FEProblemBase::needsPreviousNewtonIteration ( ) const
inherited

Check to see whether we need to compute the variable values of the previous Newton iterate.

Returns
true if the user required values of the previous Newton iterate

Definition at line 8954 of file FEProblemBase.C.

8955 {
8957 }
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
const TagName PREVIOUS_NL_SOLUTION_TAG
Definition: MooseTypes.C:28

◆ needSubdomainMaterialOnSide()

bool FEProblemBase::needSubdomainMaterialOnSide ( SubdomainID  subdomain_id,
const THREAD_ID  tid 
)
inherited

Definition at line 8925 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::subdomainChanged(), and ProjectMaterialProperties::subdomainChanged().

8926 {
8927  if (_block_mat_side_cache[tid].find(subdomain_id) == _block_mat_side_cache[tid].end())
8928  {
8929  _block_mat_side_cache[tid][subdomain_id] = false;
8930 
8931  for (auto & nl : _nl)
8932  if (nl->needSubdomainMaterialOnSide(subdomain_id, tid))
8933  {
8934  _block_mat_side_cache[tid][subdomain_id] = true;
8935  return true;
8936  }
8937 
8938  if (theWarehouse()
8939  .query()
8940  .condition<AttribThread>(tid)
8941  .condition<AttribInterfaces>(Interfaces::InternalSideUserObject)
8942  .condition<AttribSubdomains>(subdomain_id)
8943  .count() > 0)
8944  {
8945  _block_mat_side_cache[tid][subdomain_id] = true;
8946  return true;
8947  }
8948  }
8949 
8950  return _block_mat_side_cache[tid][subdomain_id];
8951 }
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:30
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
TheWarehouse & theWarehouse() const
std::vector< std::unordered_map< SubdomainID, bool > > _block_mat_side_cache
Cache for calculating materials on side.
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284

◆ needToAddDefaultMultiAppFixedPointConvergence()

bool FEProblemBase::needToAddDefaultMultiAppFixedPointConvergence ( ) const
inlineinherited

Returns true if the problem needs to add the default fixed point convergence.

Definition at line 666 of file FEProblemBase.h.

667  {
669  }
bool _need_to_add_default_multiapp_fixed_point_convergence
Flag that the problem needs to add the default fixed point convergence.

◆ needToAddDefaultNonlinearConvergence()

bool FEProblemBase::needToAddDefaultNonlinearConvergence ( ) const
inlineinherited

Returns true if the problem needs to add the default nonlinear convergence.

Definition at line 661 of file FEProblemBase.h.

662  {
664  }
bool _need_to_add_default_nonlinear_convergence
Flag that the problem needs to add the default nonlinear convergence.

◆ needToAddDefaultSteadyStateConvergence()

bool FEProblemBase::needToAddDefaultSteadyStateConvergence ( ) const
inlineinherited

Returns true if the problem needs to add the default steady-state detection convergence.

Definition at line 671 of file FEProblemBase.h.

672  {
674  }
bool _need_to_add_default_steady_state_convergence
Flag that the problem needs to add the default steady convergence.

◆ neighborSubdomainSetup()

void FEProblemBase::neighborSubdomainSetup ( SubdomainID  subdomain,
const THREAD_ID  tid 
)
virtualinherited

Definition at line 2522 of file FEProblemBase.C.

Referenced by ThreadedFaceLoop< RangeType >::neighborSubdomainChanged().

2523 {
2524  _all_materials.neighborSubdomainSetup(subdomain, tid);
2525 }
virtual void neighborSubdomainSetup(THREAD_ID tid=0) const
MaterialWarehouse _all_materials

◆ newAssemblyArray()

void FEProblemBase::newAssemblyArray ( std::vector< std::shared_ptr< SolverSystem >> &  solver_systems)
virtualinherited

Definition at line 744 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), and FEProblem::FEProblem().

745 {
746  unsigned int n_threads = libMesh::n_threads();
747 
748  _assembly.resize(n_threads);
749  for (const auto i : make_range(n_threads))
750  {
751  _assembly[i].resize(solver_systems.size());
752  for (const auto j : index_range(solver_systems))
753  _assembly[i][j] = std::make_unique<Assembly>(*solver_systems[j], i);
754  }
755 }
unsigned int n_threads()
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
IntRange< T > make_range(T beg, T end)
auto index_range(const T &sizable)

◆ nlConverged()

bool SubProblem::nlConverged ( const unsigned int  nl_sys_num)
virtualinherited
Returns
whether the given nonlinear system nl_sys_num is converged.

Definition at line 716 of file SubProblem.C.

717 {
718  mooseAssert(nl_sys_num < numNonlinearSystems(),
719  "The nonlinear system number is higher than the number of systems we have!");
720  return solverSystemConverged(nl_sys_num);
721 }
virtual std::size_t numNonlinearSystems() const =0
virtual bool solverSystemConverged(const unsigned int sys_num)
Definition: SubProblem.h:100

◆ nLinearIterations()

unsigned int FEProblemBase::nLinearIterations ( const unsigned int  nl_sys_num) const
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6729 of file FEProblemBase.C.

Referenced by PiecewiseLinearFromVectorPostprocessor::valueInternal().

6730 {
6731  return _nl[nl_sys_num]->nLinearIterations();
6732 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ nlSysNum()

unsigned int FEProblemBase::nlSysNum ( const NonlinearSystemName &  nl_sys_name) const
overridevirtualinherited
Returns
the nonlinear system number corresponding to the provided nl_sys_name

Implements SubProblem.

Definition at line 6459 of file FEProblemBase.C.

Referenced by DisplacedProblem::nlSysNum().

6460 {
6461  std::istringstream ss(nl_sys_name);
6462  unsigned int nl_sys_num;
6463  if (!(ss >> nl_sys_num) || !ss.eof())
6464  nl_sys_num = libmesh_map_find(_nl_sys_name_to_num, nl_sys_name);
6465 
6466  return nl_sys_num;
6467 }
std::map< NonlinearSystemName, unsigned int > _nl_sys_name_to_num
Map from nonlinear system name to number.

◆ nNonlinearIterations()

unsigned int FEProblemBase::nNonlinearIterations ( const unsigned int  nl_sys_num) const
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6723 of file FEProblemBase.C.

Referenced by PiecewiseLinearFromVectorPostprocessor::valueInternal().

6724 {
6725  return _nl[nl_sys_num]->nNonlinearIterations();
6726 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ nonlocalCouplingEntries()

std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & FEProblemBase::nonlocalCouplingEntries ( const THREAD_ID  tid,
const unsigned int  nl_sys_num 
)
inherited

Definition at line 6311 of file FEProblemBase.C.

Referenced by ComputeFullJacobianThread::computeOnBoundary(), and ComputeFullJacobianThread::computeOnElement().

6312 {
6313  return _assembly[tid][nl_sys]->nonlocalCouplingEntries();
6314 }
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.

◆ nonlocalCouplingMatrix()

const libMesh::CouplingMatrix & FEProblemBase::nonlocalCouplingMatrix ( const unsigned  i) const
overridevirtualinherited
Returns
the nonlocal coupling matrix for the i'th nonlinear system

Implements SubProblem.

Definition at line 9599 of file FEProblemBase.C.

Referenced by DisplacedProblem::nonlocalCouplingMatrix().

9600 {
9601  return _nonlocal_cm[i];
9602 }
std::vector< libMesh::CouplingMatrix > _nonlocal_cm
nonlocal coupling matrix

◆ notifyWhenMeshChanges()

void FEProblemBase::notifyWhenMeshChanges ( MeshChangedInterface mci)
inherited

Register an object that derives from MeshChangedInterface to be notified when the mesh changes.

Definition at line 8388 of file FEProblemBase.C.

Referenced by MeshChangedInterface::MeshChangedInterface().

8389 {
8390  _notify_when_mesh_changes.push_back(mci);
8391 }
std::vector< MeshChangedInterface * > _notify_when_mesh_changes
Objects to be notified when the mesh changes.

◆ notifyWhenMeshDisplaces()

void FEProblemBase::notifyWhenMeshDisplaces ( MeshDisplacedInterface mdi)
inherited

Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh gets updated.

Definition at line 8394 of file FEProblemBase.C.

Referenced by MeshDisplacedInterface::MeshDisplacedInterface().

8395 {
8396  _notify_when_mesh_displaces.push_back(mdi);
8397 }
std::vector< MeshDisplacedInterface * > _notify_when_mesh_displaces
Objects to be notified when the mesh displaces.

◆ numGridSteps()

void FEProblemBase::numGridSteps ( unsigned int  num_grid_steps)
inlineinherited

Set the number of steps in a grid sequences.

Definition at line 2373 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

2373 { _num_grid_steps = num_grid_steps; }
unsigned int _num_grid_steps
Number of steps in a grid sequence.

◆ numLinearSystems()

virtual std::size_t FEProblemBase::numLinearSystems ( ) const
inlineoverridevirtualinherited

◆ numMatrixTags()

virtual unsigned int SubProblem::numMatrixTags ( ) const
inlinevirtualinherited

◆ numNonlinearSystems()

virtual std::size_t FEProblemBase::numNonlinearSystems ( ) const
inlineoverridevirtualinherited

◆ numSolverSystems()

virtual std::size_t FEProblemBase::numSolverSystems ( ) const
inlineoverridevirtualinherited

◆ numVectorTags()

unsigned int SubProblem::numVectorTags ( const Moose::VectorTagType  type = Moose::VECTOR_TAG_ANY) const
virtualinherited

The total number of tags, which can be limited to the tag type.

Reimplemented in DisplacedProblem.

Definition at line 195 of file SubProblem.C.

Referenced by NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeResidualInternal(), ComputeResidualThread::determineObjectWarehouses(), MooseVariableDataBase< OutputType >::MooseVariableDataBase(), MooseVariableScalar::MooseVariableScalar(), DisplacedProblem::numVectorTags(), ComputeNodalKernelBcsThread::pre(), and ComputeNodalKernelsThread::pre().

196 {
197  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
198 
199  return getVectorTags(type).size();
200 }
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Definition: SubProblem.C:172

◆ objectExecuteHelper()

template<typename T >
void FEProblemBase::objectExecuteHelper ( const std::vector< T *> &  objects)
staticinherited

Definition at line 3321 of file FEProblemBase.h.

3322 {
3323  for (T * obj_ptr : objects)
3324  obj_ptr->execute();
3325 }

◆ objectSetupHelper()

template<typename T >
void FEProblemBase::objectSetupHelper ( const std::vector< T *> &  objects,
const ExecFlagType exec_flag 
)
staticinherited

Helpers for calling the necessary setup/execute functions for the supplied objects.

Definition at line 3287 of file FEProblemBase.h.

3288 {
3289  if (exec_flag == EXEC_INITIAL)
3290  {
3291  for (T * obj_ptr : objects)
3292  obj_ptr->initialSetup();
3293  }
3294 
3295  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
3296  {
3297  for (const auto obj_ptr : objects)
3298  obj_ptr->timestepSetup();
3299  }
3300  else if (exec_flag == EXEC_SUBDOMAIN)
3301  {
3302  for (const auto obj_ptr : objects)
3303  obj_ptr->subdomainSetup();
3304  }
3305 
3306  else if (exec_flag == EXEC_NONLINEAR)
3307  {
3308  for (const auto obj_ptr : objects)
3309  obj_ptr->jacobianSetup();
3310  }
3311 
3312  else if (exec_flag == EXEC_LINEAR)
3313  {
3314  for (const auto obj_ptr : objects)
3315  obj_ptr->residualSetup();
3316  }
3317 }
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
const ExecFlagType EXEC_SUBDOMAIN
Definition: Moose.C:50
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:30

◆ onlyAllowDefaultNonlinearConvergence()

virtual bool FEProblemBase::onlyAllowDefaultNonlinearConvergence ( ) const
inlinevirtualinherited

Returns true if an error will result if the user supplies 'nonlinear_convergence'.

Some problems are strongly tied to their convergence, and it does not make sense to use any convergence other than their default and additionally would be error-prone.

Reimplemented in ReferenceResidualProblem.

Definition at line 715 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

715 { return false; }

◆ onTimestepBegin()

void FEProblemBase::onTimestepBegin ( )
overridevirtualinherited

Implements SubProblem.

Definition at line 6883 of file FEProblemBase.C.

Referenced by MFEMTransient::takeStep(), and TransientBase::takeStep().

6884 {
6885  TIME_SECTION("onTimestepBegin", 2);
6886 
6887  for (auto & nl : _nl)
6888  nl->onTimestepBegin();
6889 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ onTimestepEnd()

void FEProblemBase::onTimestepEnd ( )
overridevirtualinherited

◆ outputStep()

void FEProblemBase::outputStep ( ExecFlagType  type)
virtualinherited

Output the current step.

Will ensure that everything is in the proper state to be outputted. Then tell the OutputWarehouse to do its thing

Parameters
typeThe type execution flag (see Moose.h)

Reimplemented in DumpObjectsProblem.

Definition at line 6846 of file FEProblemBase.C.

Referenced by TransientBase::endStep(), MFEMSteady::execute(), SteadyBase::execute(), TransientBase::execute(), Eigenvalue::execute(), InversePowerMethod::init(), NonlinearEigen::init(), EigenExecutionerBase::postExecute(), TransientBase::preExecute(), MFEMProblemSolve::solve(), FixedPointSolve::solve(), TransientMultiApp::solveStep(), and FixedPointSolve::solveStep().

6847 {
6848  TIME_SECTION("outputStep", 1, "Outputting");
6849 
6851 
6852  for (auto & sys : _solver_systems)
6853  sys->update();
6854  _aux->update();
6855 
6856  if (_displaced_problem)
6857  _displaced_problem->syncSolutions();
6859 
6861 }
void outputStep(ExecFlagType type)
Calls the outputStep method for each output object.
const ExecFlagType EXEC_NONE
Definition: Moose.C:29
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
void setCurrentExecuteOnFlag(const ExecFlagType &)
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
std::shared_ptr< DisplacedProblem > _displaced_problem
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480

◆ paramError()

template<typename... Args>
void MooseBase::paramError ( const std::string &  param,
Args...  args 
) const
inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 439 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), SetupDebugAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADNodalKernel::ADNodalKernel(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelTempl< Real >::AuxKernelTempl(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), PiecewiseTabularBase::buildFromFile(), MFEMMesh::buildMesh(), CartesianGridDivision::CartesianGridDivision(), checkComponent(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), FunctorAux::computeValue(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), DebugResidualAux::DebugResidualAux(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), ReporterPointSource::fillPoint(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), ForcingFunctionAux::ForcingFunctionAux(), FullSolveMultiApp::FullSolveMultiApp(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorCoordinatesFunctionAux::FunctorCoordinatesFunctionAux(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), AddMetaDataGenerator::generate(), BlockToMeshConverterGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementsToTetrahedronsConverter::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BlockDeletionGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), AdvancedExtruderGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), ComponentBoundaryConditionInterface::getBoundaryCondition(), MultiApp::getCommandLineArgs(), PropertyReadFile::getData(), PropertyReadFile::getFileNames(), Sampler::getGlobalSamples(), ComponentInitialConditionInterface::getInitialCondition(), NEML2Action::getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), Sampler::getNextLocalRow(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), JSONOutput::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), ElementSubdomainModifierBase::initialSetup(), SampledOutput::initSample(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), KokkosBoundNodalKernel< KokkosUpperBoundNodalKernel >::KokkosBoundNodalKernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestNodeValueAux::NearestNodeValueAux(), NEML2Action::NEML2Action(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshGenerator::PolyLineMeshGenerator(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupParameterDerivativeMappings(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), TimeSequenceStepperBase::updateSequence(), UserObject::UserObject(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), ParsedMaterialBase::validateVectorNames(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

440 {
441  _pars.paramError(param, std::forward<Args>(args)...);
442 }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
void paramError(const std::string &param, Args... args) const
Emits a parameter error prefixed with the parameter location and object information if available...

◆ parameters()

const InputParameters& MooseBase::parameters ( ) const
inlineinherited

Get the parameters of the object.

Returns
The parameters of the object

Definition at line 131 of file MooseBase.h.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), SetupDebugAction::act(), AddActionComponentAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), addAuxVariable(), DisplacedProblem::addAuxVariable(), addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), addFESpace(), addFunction(), FEProblemBase::addFunction(), addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), addGridFunction(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), addInitialCondition(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), addMFEMFESpaceFromMOOSEVariable(), addMFEMPreconditioner(), addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), addPostprocessor(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), addSubMesh(), FEProblemBase::addTimeIntegrator(), addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), addVariable(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelTempl< Real >::AuxKernelTempl(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementMaterialSampler::ElementMaterialSampler(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), ElementSubdomainModifierBase::extrapolatePolynomial(), FEProblem::FEProblem(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainGeneratorBase::generate(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), MeshGeneratorSystem::hasDataDrivenAllowed(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MooseObject::isKokkosObject(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MFEMCGSolver::MFEMCGSolver(), MFEMGMRESSolver::MFEMGMRESSolver(), MFEMHypreADS::MFEMHypreADS(), MFEMHypreAMS::MFEMHypreAMS(), MFEMHypreBoomerAMG::MFEMHypreBoomerAMG(), MFEMHypreFGMRES::MFEMHypreFGMRES(), MFEMHypreGMRES::MFEMHypreGMRES(), MFEMHyprePCG::MFEMHyprePCG(), MFEMOperatorJacobiSmoother::MFEMOperatorJacobiSmoother(), MFEMSuperLU::MFEMSuperLU(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MooseServer::parseDocumentForDiagnostics(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), FEProblemBase::setResidualObjectParamsAndLog(), SideSetsGeneratorBase::setup(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), Moose::PetscSupport::storePetscOptions(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), and MooseApp::~MooseApp().

131 { return _pars; }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366

◆ paramInfo()

template<typename... Args>
void MooseBase::paramInfo ( const std::string &  param,
Args...  args 
) const
inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 453 of file MooseBase.h.

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

454 {
455  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
456 }
std::string paramMessage(const std::string &param, Args... args) const
void mooseInfo(Args &&... args) const
Definition: MooseBase.h:321
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366

◆ paramWarning()

template<typename... Args>
void MooseBase::paramWarning ( const std::string &  param,
Args...  args 
) const
inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 446 of file MooseBase.h.

Referenced by GridPartitioner::_do_partition(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), CombinerGenerator::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

447 {
448  mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
449 }
std::string paramMessage(const std::string &param, Args... args) const
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:299

◆ parentOutputPositionChanged()

void FEProblemBase::parentOutputPositionChanged ( )
inherited

Calls parentOutputPositionChanged() on all sub apps.

Definition at line 4609 of file FEProblemBase.C.

Referenced by TransientBase::parentOutputPositionChanged().

4610 {
4611  for (const auto & it : _multi_apps)
4612  {
4613  const auto & objects = it.second.getActiveObjects();
4614  for (const auto & obj : objects)
4615  obj->parentOutputPositionChanged();
4616  }
4617 }
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )
inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), and PerfGraphOutput::output().

79 {
80  return _pg_moose_app.perfGraph();
81 }
MooseApp & _pg_moose_app
The MooseApp that owns the PerfGraph.
PerfGraph & perfGraph()
Get the PerfGraph for this app.
Definition: MooseApp.h:173

◆ petscOptionsDatabase()

PetscOptions& FEProblemBase::petscOptionsDatabase ( )
inlineinherited

Definition at line 2291 of file FEProblemBase.h.

Referenced by Eigenvalue::prepareSolverOptions().

2291 { return _petsc_option_data_base; }
PetscOptions _petsc_option_data_base

◆ petscOptionsInserted()

bool& FEProblemBase::petscOptionsInserted ( )
inlineinherited

If PETSc options are already inserted.

Definition at line 2288 of file FEProblemBase.h.

Referenced by Eigenvalue::prepareSolverOptions().

2288 { return _is_petsc_options_inserted; }
bool _is_petsc_options_inserted
If or not PETSc options have been added to database.

◆ possiblyRebuildGeomSearchPatches()

void FEProblemBase::possiblyRebuildGeomSearchPatches ( )
virtualinherited

Definition at line 8018 of file FEProblemBase.C.

Referenced by FEProblemBase::solve().

8019 {
8020  if (_displaced_problem) // Only need to do this if things are moving...
8021  {
8022  TIME_SECTION("possiblyRebuildGeomSearchPatches", 5, "Rebuilding Geometric Search Patches");
8023 
8024  switch (_mesh.getPatchUpdateStrategy())
8025  {
8026  case Moose::Never:
8027  break;
8028  case Moose::Iteration:
8029  // Update the list of ghosted elements at the start of the time step
8032 
8033  _displaced_problem->geomSearchData().updateGhostedElems();
8035 
8036  // The commands below ensure that the sparsity of the Jacobian matrix is
8037  // augmented at the start of the time step using neighbor nodes from the end
8038  // of the previous time step.
8039 
8041 
8042  // This is needed to reinitialize PETSc output
8044 
8045  break;
8046 
8047  case Moose::Auto:
8048  {
8049  Real max = _displaced_problem->geomSearchData().maxPatchPercentage();
8051 
8052  // If we haven't moved very far through the patch
8053  if (max < 0.4)
8054  break;
8055  }
8056  libmesh_fallthrough();
8057 
8058  // Let this fall through if things do need to be updated...
8059  case Moose::Always:
8060  // Flush output here to see the message before the reinitialization, which could take a
8061  // while
8062  _console << "\n\nUpdating geometric search patches\n" << std::endl;
8063 
8066 
8067  _displaced_problem->geomSearchData().clearNearestNodeLocators();
8069 
8071 
8072  // This is needed to reinitialize PETSc output
8074  }
8075  }
8076 }
virtual void initPetscOutputAndSomeSolverSettings()
Reinitialize PETSc output for proper linear/nonlinear iteration display.
void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed=false)
Call when it is possible that the needs for ghosted elements has changed.
const Parallel::Communicator & _communicator
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
Definition: SubProblem.h:1093
auto max(const L &left, const R &right)
void updateGhostedElems()
Updates the list of ghosted elements at the start of each time step for the nonlinear iteration patch...
MooseMesh & _mesh
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void updateActiveSemiLocalNodeRange(std::set< dof_id_type > &ghosted_elems)
Clears the "semi-local" node list and rebuilds it.
Definition: MooseMesh.C:966
void max(const T &r, T &o, Request &req) const
std::shared_ptr< DisplacedProblem > _displaced_problem
GeometricSearchData _geometric_search_data
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
const Moose::PatchUpdateType & getPatchUpdateStrategy() const
Get the current patch update strategy.
Definition: MooseMesh.C:3453
void clearNearestNodeLocators()
Clear out the Penetration Locators so they will redo the search.
MooseMesh * _displaced_mesh

◆ postExecute()

void FEProblemBase::postExecute ( )
virtualinherited

Method called at the end of the simulation.

Definition at line 5627 of file FEProblemBase.C.

Referenced by MFEMSteady::execute(), SteadyBase::execute(), TransientBase::execute(), and Eigenvalue::execute().

5628 {
5629  const auto & multi_apps = _multi_apps.getActiveObjects();
5630 
5631  for (const auto & multi_app : multi_apps)
5632  multi_app->postExecute();
5633 }
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...
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.

◆ predictorCleanup()

void FEProblemBase::predictorCleanup ( NumericVector< libMesh::Number > &  ghosted_solution)
virtualinherited

Perform cleanup tasks after application of predictor to solution vector.

Parameters
ghosted_solutionGhosted solution vector

Definition at line 7925 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::setInitialSolution().

7926 {
7927 }

◆ prepare() [1/2]

virtual void FEProblemBase::prepare ( const Elem *  elem,
const THREAD_ID  tid 
)
overridevirtualinherited

◆ prepare() [2/2]

virtual void FEProblemBase::prepare ( const Elem *  elem,
unsigned int  ivar,
unsigned int  jvar,
const std::vector< dof_id_type > &  dof_indices,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

◆ prepareAssembly()

void FEProblemBase::prepareAssembly ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 1847 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::reinitNodeFace(), and NonlinearSystemBase::setConstraintSecondaryValues().

1848 {
1849  _assembly[tid][_current_nl_sys->number()]->prepare();
1851  _assembly[tid][_current_nl_sys->number()]->prepareNonlocal();
1852 
1854  {
1855  _displaced_problem->prepareAssembly(tid);
1857  _displaced_problem->prepareNonlocal(tid);
1858  }
1859 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ prepareFace()

void FEProblemBase::prepareFace ( const Elem elem,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 1761 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onInterface(), and ComputeUserObjectsThread::onInternalSide().

1762 {
1763  for (auto & nl : _nl)
1764  nl->prepareFace(tid, true);
1765  _aux->prepareFace(tid, false);
1766 
1768  _displaced_problem->prepareFace(_displaced_mesh->elemPtr(elem->id()), tid);
1769 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
dof_id_type id() const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseMesh * _displaced_mesh

◆ prepareFaceShapes()

void FEProblemBase::prepareFaceShapes ( unsigned int  var,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2106 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onBoundary().

2107 {
2108  _assembly[tid][_current_nl_sys->number()]->copyFaceShapes(var);
2109 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.

◆ prepareKokkosMaterials()

void FEProblemBase::prepareKokkosMaterials ( const std::unordered_set< unsigned int > &  consumer_needed_mat_props)
inherited

◆ prepareMaterials()

void FEProblemBase::prepareMaterials ( const std::unordered_set< unsigned int > &  consumer_needed_mat_props,
const SubdomainID  blk_id,
const THREAD_ID  tid 
)
inherited

Add the MooseVariables and the material properties that the current materials depend on to the dependency list.

Parameters
consumer_needed_mat_propsThe material properties needed by consumer objects (other than the materials themselves)
blk_idThe subdomain ID for which we are preparing our list of needed vars and props
tidThe thread ID we are preparing the requirements for

This MUST be done after the moose variable dependency list has been set for all the other objects using the setActiveElementalMooseVariables API!

Definition at line 4104 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

4107 {
4108  std::set<MooseVariableFEBase *> needed_moose_vars;
4109  std::unordered_set<unsigned int> needed_mat_props;
4110 
4111  if (_all_materials.hasActiveBlockObjects(blk_id, tid))
4112  {
4113  _all_materials.updateVariableDependency(needed_moose_vars, tid);
4114  _all_materials.updateBlockMatPropDependency(blk_id, needed_mat_props, tid);
4115  }
4116 
4117  const auto & ids = _mesh.getSubdomainBoundaryIds(blk_id);
4118  for (const auto id : ids)
4119  {
4120  _materials.updateBoundaryVariableDependency(id, needed_moose_vars, tid);
4121  _materials.updateBoundaryMatPropDependency(id, needed_mat_props, tid);
4122  }
4123 
4124  const auto & current_active_elemental_moose_variables = getActiveElementalMooseVariables(tid);
4125  needed_moose_vars.insert(current_active_elemental_moose_variables.begin(),
4126  current_active_elemental_moose_variables.end());
4127 
4128  needed_mat_props.insert(consumer_needed_mat_props.begin(), consumer_needed_mat_props.end());
4129 
4130  setActiveElementalMooseVariables(needed_moose_vars, tid);
4131  setActiveMaterialProperties(needed_mat_props, tid);
4132 }
void updateVariableDependency(std::set< MooseVariableFieldBase *> &needed_moose_vars, THREAD_ID tid=0) const
Update variable dependency vector.
void setActiveMaterialProperties(const std::unordered_set< unsigned int > &mat_prop_ids, const THREAD_ID tid)
Record and set the material properties required by the current computing thread.
bool hasActiveBlockObjects(THREAD_ID tid=0) const
const std::set< BoundaryID > & getSubdomainBoundaryIds(const SubdomainID subdomain_id) const
Get the list of boundary ids associated with the given subdomain id.
Definition: MooseMesh.C:3537
virtual const std::set< MooseVariableFieldBase * > & getActiveElementalMooseVariables(const THREAD_ID tid) const
Get the MOOSE variables to be reinited on each element.
Definition: SubProblem.C:454
virtual void setActiveElementalMooseVariables(const std::set< MooseVariableFEBase *> &moose_vars, const THREAD_ID tid) override
Set the MOOSE variables to be reinited on each element.
MooseMesh & _mesh
void updateBoundaryMatPropDependency(std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
void updateBlockMatPropDependency(SubdomainID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
void updateBoundaryVariableDependency(std::set< MooseVariableFieldBase *> &needed_moose_vars, THREAD_ID tid=0) const
MaterialWarehouse _all_materials
MaterialWarehouse _materials

◆ prepareNeighborShapes()

void FEProblemBase::prepareNeighborShapes ( unsigned int  var,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2112 of file FEProblemBase.C.

2113 {
2114  _assembly[tid][_current_nl_sys->number()]->copyNeighborShapes(var);
2115 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.

◆ preparePRefinement()

void SubProblem::preparePRefinement ( )
inherited

Prepare DofMap and Assembly classes with our p-refinement information.

Definition at line 1332 of file SubProblem.C.

Referenced by FEProblemBase::init().

1333 {
1334  std::unordered_set<FEFamily> disable_families;
1335  for (const auto & [family, flag] : _family_for_p_refinement)
1336  if (flag)
1337  disable_families.insert(family);
1338 
1339  for (const auto tid : make_range(libMesh::n_threads()))
1340  for (const auto s : make_range(numNonlinearSystems()))
1341  assembly(tid, s).havePRefinement(disable_families);
1342 
1343  auto & eq = es();
1344  for (const auto family : disable_families)
1345  for (const auto i : make_range(eq.n_systems()))
1346  {
1347  auto & system = eq.get_system(i);
1348  auto & dof_map = system.get_dof_map();
1349  for (const auto vg : make_range(system.n_variable_groups()))
1350  {
1351  const auto & var_group = system.variable_group(vg);
1352  if (var_group.type().family == family)
1353  dof_map.should_p_refine(vg, false);
1354  }
1355  }
1356 
1357  _have_p_refinement = true;
1358 }
unsigned int n_threads()
virtual libMesh::EquationSystems & es()=0
std::unordered_map< FEFamily, bool > _family_for_p_refinement
Indicate whether a family is disabled for p-refinement.
Definition: SubProblem.h:1205
void havePRefinement(const std::unordered_set< FEFamily > &disable_p_refinement_for_families)
Indicate that we have p-refinement.
Definition: Assembly.C:4859
bool _have_p_refinement
Whether p-refinement has been requested at any point during the simulation.
Definition: SubProblem.h:1202
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num)=0
IntRange< T > make_range(T beg, T end)
virtual std::size_t numNonlinearSystems() const =0

◆ prepareShapes()

void FEProblemBase::prepareShapes ( unsigned int  var,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2100 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onElement().

2101 {
2102  _assembly[tid][_current_nl_sys->number()]->copyShapes(var);
2103 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.

◆ preserveMatrixSparsityPattern()

bool FEProblemBase::preserveMatrixSparsityPattern ( ) const
inlineinherited

Will return True if the executioner in use requires preserving the sparsity pattern of the matrices being formed during the solve.

This is usually the Jacobian.

Definition at line 2109 of file FEProblemBase.h.

bool _preserve_matrix_sparsity_pattern
Whether to preserve the system matrix / Jacobian sparsity pattern, using 0-valued entries usually...

◆ projectFunctionOnCustomRange()

void FEProblemBase::projectFunctionOnCustomRange ( ConstElemRange elem_range,
Number(*)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &)  func,
Gradient(*)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &)  func_grad,
const libMesh::Parameters params,
const VariableName &  target_var 
)
inherited

Project a function onto a range of elements for a given variable.

Warning
The current implementation is not ideal. The projection takes place on all local active elements, ignoring the specified elem_range. After the projection, dof values on the specified elem_range are copied over to the current solution vector. This should be fixed once the project_vector or project_solution API is modified to take a custom element range.
Parameters
elem_rangeElement range to project on
funcFunction to project
func_gradGradient of the function
paramsParameters to pass to the function
target_varvariable name to project

Definition at line 3804 of file FEProblemBase.C.

Referenced by ElementSubdomainModifierBase::extrapolatePolynomial().

3815 {
3816  mooseAssert(!Threads::in_threads,
3817  "We're performing a projection based on data from just the thread 0 variable, so any "
3818  "modifications to the variable solution must have been thread joined already");
3819 
3820  const auto & var = getStandardVariable(0, target_var);
3821  const auto var_num = var.number();
3822  const auto sn = systemNumForVariable(target_var);
3823  auto & sys = getSystemBase(sn);
3824 
3825  // Let libmesh handle the projection
3826  System & libmesh_sys = getSystem(target_var);
3827  auto temp_vec = libmesh_sys.current_local_solution->zero_clone();
3828  libmesh_sys.project_vector(func, func_grad, params, *temp_vec);
3829  temp_vec->close();
3830 
3831  // Get the dof indices to copy
3832  DofMap & dof_map = sys.dofMap();
3833  std::set<dof_id_type> dof_indices;
3834  std::vector<dof_id_type> elem_dof_indices;
3835 
3836  for (const auto & elem : elem_range)
3837  {
3838  dof_map.dof_indices(elem, elem_dof_indices, var_num);
3839  dof_indices.insert(elem_dof_indices.begin(), elem_dof_indices.end());
3840  }
3841  std::vector<dof_id_type> dof_indices_v(dof_indices.begin(), dof_indices.end());
3842 
3843  // Copy the projected values into the solution vector
3844  std::vector<Real> dof_vals;
3845  temp_vec->get(dof_indices_v, dof_vals);
3846  mooseAssert(sys.solution().closed(),
3847  "The solution should be closed before mapping our projection");
3848  sys.solution().insert(dof_vals, dof_indices_v);
3849  sys.solution().close();
3850  sys.solution().localize(*libmesh_sys.current_local_solution, sys.dofMap().get_send_list());
3851 }
virtual libMesh::System & getSystem(const std::string &var_name) override
Returns the equation system containing the variable provided.
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
unsigned int systemNumForVariable(const VariableName &variable_name) const
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.
virtual const SystemBase & getSystemBase(const unsigned int sys_num) const
Get constant reference to a system in this problem.
std::unique_ptr< NumericVector< Number > > current_local_solution
void project_vector(NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=nullptr, int is_adjoint=-1) const

◆ projectInitialConditionOnCustomRange()

void FEProblemBase::projectInitialConditionOnCustomRange ( libMesh::ConstElemRange elem_range,
ConstBndNodeRange bnd_node_range,
const std::optional< std::set< VariableName >> &  target_vars = std::nullopt 
)
inherited

Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

Parameters
elem_rangeElement range to project on
bnd_node_rangeBoundary node range to project on
target_varsSet of variable names to project ICs

Definition at line 3729 of file FEProblemBase.C.

Referenced by ElementSubdomainModifierBase::applyIC(), and ActivateElementsUserObjectBase::initSolutions().

3733 {
3734  if (target_vars)
3735  {
3736  ComputeInitialConditionThread cic(*this, &(*target_vars));
3737  Threads::parallel_reduce(elem_range, cic);
3738  }
3739  else
3740  {
3741  ComputeInitialConditionThread cic(*this);
3742  Threads::parallel_reduce(elem_range, cic);
3743  }
3744 
3745  // Need to close the solution vector here so that boundary ICs take precendence
3746  for (auto & nl : _nl)
3747  nl->solution().close();
3748  _aux->solution().close();
3749 
3750  if (target_vars)
3751  {
3752  ComputeBoundaryInitialConditionThread cbic(*this, &(*target_vars));
3753  Threads::parallel_reduce(bnd_nodes, cbic);
3754  }
3755  else
3756  {
3758  Threads::parallel_reduce(bnd_nodes, cbic);
3759  }
3760 
3761  for (auto & nl : _nl)
3762  nl->solution().close();
3763  _aux->solution().close();
3764 
3765  // Also, load values into the SCALAR dofs
3766  // Note: We assume that all SCALAR dofs are on the
3767  // processor with highest ID
3768  if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects())
3769  {
3770  const auto & ics = _scalar_ics.getActiveObjects();
3771  for (const auto & ic : ics)
3772  {
3773  MooseVariableScalar & var = ic->variable();
3774 
3775  if (target_vars && !target_vars->count(var.name()))
3776  continue;
3777 
3778  var.reinit();
3779 
3780  DenseVector<Number> vals(var.order());
3781  ic->compute(vals);
3782 
3783  const unsigned int n_scalar_dofs = var.dofIndices().size();
3784  for (unsigned int i = 0; i < n_scalar_dofs; i++)
3785  {
3786  const auto global_index = var.dofIndices()[i];
3787  var.sys().solution().set(global_index, vals(i));
3788  var.setValue(i, vals(i));
3789  }
3790  }
3791  }
3792 
3793  for (auto & nl : _nl)
3794  {
3795  nl->solution().close();
3796  nl->solution().localize(*nl->system().current_local_solution, nl->dofMap().get_send_list());
3797  }
3798 
3799  _aux->solution().close();
3800  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
3801 }
NumericVector< Number > & solution()
Definition: SystemBase.h:196
void reinit(bool reinit_for_derivative_reordering=false)
Fill out the VariableValue arrays from the system solution vector.
void parallel_reduce(const Range &range, Body &body, const Partitioner &)
ScalarInitialConditionWarehouse _scalar_ics
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
processor_id_type n_processors() const
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
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...
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
void setValue(unsigned int i, Number value)
Set the nodal value for this variable (to keep everything up to date.
virtual const std::vector< dof_id_type > & dofIndices() const
Get local DoF indices.
libMesh::Order order() const
Get the order of this variable Note: Order enum can be implicitly converted to unsigned int...
bool hasActiveObjects(THREAD_ID tid=0) const
Class for scalar variables (they are different).
virtual void set(const numeric_index_type i, const T value)=0
processor_id_type processor_id() const
SystemBase & sys()
Get the system this variable is part of.

◆ projectSolution()

void FEProblemBase::projectSolution ( )
inherited

Definition at line 3661 of file FEProblemBase.C.

Referenced by FEProblemBase::initialAdaptMesh(), and FEProblemBase::initialSetup().

3662 {
3663  TIME_SECTION("projectSolution", 2, "Projecting Initial Solutions")
3664 
3665  FloatingPointExceptionGuard fpe_guard(_app);
3666 
3667  ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
3668  ComputeInitialConditionThread cic(*this);
3669  Threads::parallel_reduce(elem_range, cic);
3670 
3671  if (haveFV())
3672  {
3674  ElemInfoRange elem_info_range(_mesh.ownedElemInfoBegin(), _mesh.ownedElemInfoEnd());
3675 
3676  ComputeFVInitialConditionThread cfvic(*this);
3677  Threads::parallel_reduce(elem_info_range, cfvic);
3678  }
3679 
3680  // Need to close the solution vector here so that boundary ICs take precendence
3681  for (auto & nl : _nl)
3682  nl->solution().close();
3683  _aux->solution().close();
3684 
3685  // now run boundary-restricted initial conditions
3686  ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
3688  Threads::parallel_reduce(bnd_nodes, cbic);
3689 
3690  for (auto & nl : _nl)
3691  nl->solution().close();
3692  _aux->solution().close();
3693 
3694  // Also, load values into the SCALAR dofs
3695  // Note: We assume that all SCALAR dofs are on the
3696  // processor with highest ID
3697  if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects())
3698  {
3699  const auto & ics = _scalar_ics.getActiveObjects();
3700  for (const auto & ic : ics)
3701  {
3702  MooseVariableScalar & var = ic->variable();
3703  var.reinit();
3704 
3705  DenseVector<Number> vals(var.order());
3706  ic->compute(vals);
3707 
3708  const unsigned int n_scalar_dofs = var.dofIndices().size();
3709  for (unsigned int i = 0; i < n_scalar_dofs; i++)
3710  {
3711  const auto global_index = var.dofIndices()[i];
3712  var.sys().solution().set(global_index, vals(i));
3713  var.setValue(i, vals(i));
3714  }
3715  }
3716  }
3717 
3718  for (auto & sys : _solver_systems)
3719  {
3720  sys->solution().close();
3721  sys->solution().localize(*sys->system().current_local_solution, sys->dofMap().get_send_list());
3722  }
3723 
3724  _aux->solution().close();
3725  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
3726 }
NumericVector< Number > & solution()
Definition: SystemBase.h:196
virtual bool haveFV() const override
returns true if this problem includes/needs finite volume functionality.
void reinit(bool reinit_for_derivative_reordering=false)
Fill out the VariableValue arrays from the system solution vector.
void parallel_reduce(const Range &range, Body &body, const Partitioner &)
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
Scope guard for starting and stopping Floating Point Exception Trapping.
elem_info_iterator ownedElemInfoBegin()
Iterators to owned faceInfo objects.
Definition: MooseMesh.C:1566
ScalarInitialConditionWarehouse _scalar_ics
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
processor_id_type n_processors() const
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...
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
void setValue(unsigned int i, Number value)
Set the nodal value for this variable (to keep everything up to date.
MooseMesh & _mesh
virtual const std::vector< dof_id_type > & dofIndices() const
Get local DoF indices.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
libMesh::Order order() const
Get the order of this variable Note: Order enum can be implicitly converted to unsigned int...
bool hasActiveObjects(THREAD_ID tid=0) const
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
Class for scalar variables (they are different).
elem_info_iterator ownedElemInfoEnd()
Definition: MooseMesh.C:1574
virtual void set(const numeric_index_type i, const T value)=0
processor_id_type processor_id() const
SystemBase & sys()
Get the system this variable is part of.
libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > * getBoundaryNodeRange()
Definition: MooseMesh.C:1327

◆ queryParam()

template<typename T >
const T * MooseBase::queryParam ( const std::string &  name) const
inherited

Query a parameter for the object.

If the parameter is not valid, nullptr will be returned

Parameters
nameThe name of the parameter
Returns
A pointer to the parameter value, if it exists

Definition at line 395 of file MooseBase.h.

396 {
397  return isParamValid(name) ? &getParam<T>(name) : nullptr;
398 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:199

◆ registerRandomInterface()

void FEProblemBase::registerRandomInterface ( RandomInterface random_interface,
const std::string &  name 
)
inherited

Definition at line 8845 of file FEProblemBase.C.

Referenced by RandomInterface::setRandomResetFrequency().

8846 {
8847  auto insert_pair = moose_try_emplace(
8848  _random_data_objects, name, std::make_unique<RandomData>(*this, random_interface));
8849 
8850  auto random_data_ptr = insert_pair.first->second.get();
8851  random_interface.setRandomDataPointer(random_data_ptr);
8852 }
std::pair< typename M::iterator, bool > moose_try_emplace(M &m, const typename M::key_type &k, Args &&... args)
Function to mirror the behavior of the C++17 std::map::try_emplace() method (no hint).
Definition: Moose.h:98
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
void setRandomDataPointer(RandomData *random_data)

◆ registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name,
const unsigned int  level 
) const
protectedinherited

Call to register a named section for timing.

Parameters
section_nameThe name of the code section to be timed
levelThe importance of the timer - lower is more important (0 will always come out)
Returns
The ID of the section - use when starting timing

Definition at line 53 of file PerfGraphInterface.C.

55 {
56  const auto timed_section_name = timedSectionName(section_name);
57  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
58  return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
59  else
60  return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
61 }
PerfID registerSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
std::string timedSectionName(const std::string &section_name) const
PerfID sectionID(const std::string &section_name) const
Given a name return the PerfID The name of the section.
PerfGraphRegistry & getPerfGraphRegistry()
Get the global PerfGraphRegistry singleton.

◆ registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name,
const unsigned int  level,
const std::string &  live_message,
const bool  print_dots = true 
) const
protectedinherited

Call to register a named section for timing.

Parameters
section_nameThe name of the code section to be timed
levelThe importance of the timer - lower is more important (0 will always come out)
live_messageThe message to be printed to the screen during execution
print_dotsWhether or not progress dots should be printed for this section
Returns
The ID of the section - use when starting timing

Definition at line 64 of file PerfGraphInterface.C.

68 {
69  const auto timed_section_name = timedSectionName(section_name);
70  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
72  timedSectionName(section_name), level, live_message, print_dots);
73  else
74  return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
75 }
PerfID registerSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
std::string timedSectionName(const std::string &section_name) const
PerfID sectionID(const std::string &section_name) const
Given a name return the PerfID The name of the section.
PerfGraphRegistry & getPerfGraphRegistry()
Get the global PerfGraphRegistry singleton.

◆ registerUnfilledFunctorRequest()

template<typename T >
void SubProblem::registerUnfilledFunctorRequest ( T *  functor_interface,
const std::string &  functor_name,
const THREAD_ID  tid 
)
inherited

Register an unfulfilled functor request.

◆ reinitBecauseOfGhostingOrNewGeomObjects()

void FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects ( bool  mortar_changed = false)
protectedinherited

Call when it is possible that the needs for ghosted elements has changed.

Parameters
mortar_changedWhether an update of mortar data has been requested since the last EquationSystems (re)initialization

Definition at line 5263 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), FEProblemBase::meshChanged(), and FEProblemBase::possiblyRebuildGeomSearchPatches().

5264 {
5265  TIME_SECTION("reinitBecauseOfGhostingOrNewGeomObjects",
5266  3,
5267  "Reinitializing Because of Geometric Search Objects");
5268 
5269  // Need to see if _any_ processor has ghosted elems or geometry objects.
5270  bool needs_reinit = !_ghosted_elems.empty();
5271  needs_reinit = needs_reinit || !_geometric_search_data._nearest_node_locators.empty() ||
5272  (_mortar_data.hasObjects() && mortar_changed);
5273  needs_reinit =
5274  needs_reinit || (_displaced_problem &&
5275  (!_displaced_problem->geomSearchData()._nearest_node_locators.empty() ||
5276  (_mortar_data.hasDisplacedObjects() && mortar_changed)));
5277  _communicator.max(needs_reinit);
5278 
5279  if (needs_reinit)
5280  {
5281  // Call reinit to get the ghosted vectors correct now that some geometric search has been done
5282  es().reinit();
5283 
5284  if (_displaced_mesh)
5285  _displaced_problem->es().reinit();
5286  }
5287 }
const Parallel::Communicator & _communicator
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
Definition: SubProblem.h:1093
bool hasObjects() const
Returns whether we have any active AutomaticMortarGeneration objects.
Definition: MortarData.h:104
std::map< std::pair< BoundaryID, BoundaryID >, NearestNodeLocator * > _nearest_node_locators
virtual libMesh::EquationSystems & es() override
MortarData _mortar_data
void max(const T &r, T &o, Request &req) const
bool hasDisplacedObjects() const
Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh...
Definition: MortarData.h:99
std::shared_ptr< DisplacedProblem > _displaced_problem
GeometricSearchData _geometric_search_data
MooseMesh * _displaced_mesh

◆ reinitDirac()

bool FEProblemBase::reinitDirac ( const Elem elem,
const THREAD_ID  tid 
)
overridevirtualinherited

Returns true if the Problem has Dirac kernels it needs to compute on elem.

The maximum number of qps can rise if several Dirac points are added to a single element. In that case we need to resize the zeros to compensate.

Implements SubProblem.

Definition at line 2151 of file FEProblemBase.C.

Referenced by ComputeDiracThread::onElement().

2152 {
2153  std::vector<Point> & points = _dirac_kernel_info.getPoints()[elem].first;
2154 
2155  unsigned int n_points = points.size();
2156 
2157  if (n_points)
2158  {
2159  if (n_points > _max_qps)
2160  {
2161  _max_qps = n_points;
2162 
2167  unsigned int max_qpts = getMaxQps();
2168  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
2169  {
2170  // the highest available order in libMesh is 43
2171  _scalar_zero[tid].resize(FORTYTHIRD, 0);
2172  _zero[tid].resize(max_qpts, 0);
2173  _grad_zero[tid].resize(max_qpts, RealGradient(0.));
2174  _second_zero[tid].resize(max_qpts, RealTensor(0.));
2175  _vector_zero[tid].resize(max_qpts, RealGradient(0.));
2176  _vector_curl_zero[tid].resize(max_qpts, RealGradient(0.));
2177  }
2178  }
2179 
2180  for (const auto i : index_range(_nl))
2181  {
2182  _assembly[tid][i]->reinitAtPhysical(elem, points);
2183  _nl[i]->prepare(tid);
2184  }
2185  _aux->prepare(tid);
2186 
2187  reinitElem(elem, tid);
2188  }
2189 
2190  _assembly[tid][_current_nl_sys->number()]->prepare();
2192  _assembly[tid][_current_nl_sys->number()]->prepareNonlocal();
2193 
2194  bool have_points = n_points > 0;
2196  {
2197  have_points |= _displaced_problem->reinitDirac(_displaced_mesh->elemPtr(elem->id()), tid);
2199  _displaced_problem->prepareNonlocal(tid);
2200  }
2201 
2202  return have_points;
2203 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
unsigned int n_threads()
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
std::vector< VariableSecond > _second_zero
std::vector< VectorVariableCurl > _vector_curl_zero
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
MultiPointMap & getPoints()
Returns a writeable reference to the _points container.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
dof_id_type id() const
virtual void reinitElem(const Elem *elem, const THREAD_ID tid) override
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::vector< VariableGradient > _grad_zero
std::vector< VariableValue > _scalar_zero
std::vector< VariableValue > _zero
std::shared_ptr< DisplacedProblem > _displaced_problem
std::vector< VectorVariableValue > _vector_zero
unsigned int _max_qps
Maximum number of quadrature points used in the problem.
DiracKernelInfo _dirac_kernel_info
Definition: SubProblem.h:1049
auto index_range(const T &sizable)
MooseMesh * _displaced_mesh
unsigned int getMaxQps() const

◆ reinitElem()

void FEProblemBase::reinitElem ( const Elem elem,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2206 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), ComputeMarkerThread::onElement(), ComputeElemDampingThread::onElement(), ComputeIndicatorThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeUserObjectsThread::onElement(), ComputeInitialConditionThread::operator()(), FEProblemBase::reinitDirac(), and FEProblemBase::reinitElemPhys().

2207 {
2208  for (auto & sys : _solver_systems)
2209  sys->reinitElem(elem, tid);
2210  _aux->reinitElem(elem, tid);
2211 
2213  _displaced_problem->reinitElem(_displaced_mesh->elemPtr(elem->id()), tid);
2214 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
dof_id_type id() const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseMesh * _displaced_mesh

◆ reinitElemFace() [1/2]

void FEProblemBase::reinitElemFace ( const Elem *  elem,
unsigned int  side,
BoundaryID  ,
const THREAD_ID  tid 
)
inherited

◆ reinitElemFace() [2/2]

virtual void FEProblemBase::reinitElemFace ( const Elem *  elem,
unsigned int  side,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

◆ reinitElemFaceRef()

void FEProblemBase::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 
)
overridevirtualinherited

reinitialize FE objects on a given element on a given side at a given set of reference points and then compute variable data.

Note that this method makes no assumptions about what's been called beforehand, e.g. you don't have to call some prepare method before this one. This is an all-in-one reinit

Reimplemented from SubProblem.

Definition at line 9184 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments().

9190 {
9191  SubProblem::reinitElemFaceRef(elem, side, tolerance, pts, weights, tid);
9192 
9193  if (_displaced_problem)
9194  _displaced_problem->reinitElemFaceRef(
9195  _displaced_mesh->elemPtr(elem->id()), side, tolerance, pts, weights, tid);
9196 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
dof_id_type id() const
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)
reinitialize FE objects on a given element on a given side at a given set of reference points and the...
Definition: SubProblem.C:882
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseMesh * _displaced_mesh

◆ reinitElemNeighborAndLowerD()

void FEProblemBase::reinitElemNeighborAndLowerD ( const Elem elem,
unsigned int  side,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2392 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInternalSide(), and NonlinearThread::onInternalSide().

2395 {
2396  reinitNeighbor(elem, side, tid);
2397 
2398  const Elem * lower_d_elem = _mesh.getLowerDElem(elem, side);
2399  if (lower_d_elem && _mesh.interiorLowerDBlocks().count(lower_d_elem->subdomain_id()) > 0)
2400  reinitLowerDElem(lower_d_elem, tid);
2401  else
2402  {
2403  // with mesh refinement, lower-dimensional element might be defined on neighbor side
2404  auto & neighbor = _assembly[tid][0]->neighbor();
2405  auto & neighbor_side = _assembly[tid][0]->neighborSide();
2406  const Elem * lower_d_elem_neighbor = _mesh.getLowerDElem(neighbor, neighbor_side);
2407  if (lower_d_elem_neighbor &&
2408  _mesh.interiorLowerDBlocks().count(lower_d_elem_neighbor->subdomain_id()) > 0)
2409  {
2410  auto qps = _assembly[tid][0]->qPointsFaceNeighbor().stdVector();
2411  std::vector<Point> reference_points;
2412  FEMap::inverse_map(
2413  lower_d_elem_neighbor->dim(), lower_d_elem_neighbor, qps, reference_points);
2414  reinitLowerDElem(lower_d_elem_neighbor, tid, &reference_points);
2415  }
2416  }
2417 
2419  _displaced_problem->reinitElemNeighborAndLowerD(
2420  _displaced_mesh->elemPtr(elem->id()), side, tid);
2421 }
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
const std::set< SubdomainID > & interiorLowerDBlocks() const
Definition: MooseMesh.h:1429
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
const Elem * getLowerDElem(const Elem *, unsigned short int) const
Returns a const pointer to a lower dimensional element that corresponds to a side of a higher dimensi...
Definition: MooseMesh.C:1739
dof_id_type id() const
MooseMesh & _mesh
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
virtual void reinitLowerDElem(const Elem *lower_d_elem, const THREAD_ID tid, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr) override
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
subdomain_id_type subdomain_id() const
virtual unsigned short dim() const=0
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual void reinitNeighbor(const Elem *elem, unsigned int side, const THREAD_ID tid) override
MooseMesh * _displaced_mesh

◆ reinitElemPhys()

void FEProblemBase::reinitElemPhys ( const Elem elem,
const std::vector< Point > &  phys_points_in_elem,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2217 of file FEProblemBase.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

2220 {
2221  mooseAssert(_mesh.queryElemPtr(elem->id()) == elem,
2222  "Are you calling this method with a displaced mesh element?");
2223 
2224  for (const auto i : index_range(_solver_systems))
2225  {
2226  _assembly[tid][i]->reinitAtPhysical(elem, phys_points_in_elem);
2227  _solver_systems[i]->prepare(tid);
2228  _assembly[tid][i]->prepare();
2230  _assembly[tid][i]->prepareNonlocal();
2231  }
2232  _aux->prepare(tid);
2233 
2234  reinitElem(elem, tid);
2235 }
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
virtual Elem * queryElemPtr(const dof_id_type i)
Definition: MooseMesh.C:3165
dof_id_type id() const
virtual void reinitElem(const Elem *elem, const THREAD_ID tid) override
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
auto index_range(const T &sizable)

◆ reinitFVFace()

void SubProblem::reinitFVFace ( const THREAD_ID  tid,
const FaceInfo fi 
)
inherited

reinitialize the finite volume assembly data for the provided face and thread

Definition at line 1284 of file SubProblem.C.

1285 {
1286  for (const auto nl : make_range(numNonlinearSystems()))
1287  assembly(tid, nl).reinitFVFace(fi);
1288 }
void reinitFVFace(const FaceInfo &fi)
Definition: Assembly.C:1855
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num)=0
IntRange< T > make_range(T beg, T end)
virtual std::size_t numNonlinearSystems() const =0

◆ reinitKokkosMaterials()

void FEProblemBase::reinitKokkosMaterials ( )
inherited

◆ reinitLowerDElem()

void FEProblemBase::reinitLowerDElem ( const Elem lower_d_elem,
const THREAD_ID  tid,
const std::vector< Point > *const  pts = nullptr,
const std::vector< Real > *const  weights = nullptr 
)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2265 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onBoundary(), NonlinearThread::prepareFace(), and FEProblemBase::reinitElemNeighborAndLowerD().

2269 {
2270  SubProblem::reinitLowerDElem(lower_d_elem, tid, pts, weights);
2271 
2273  _displaced_problem->reinitLowerDElem(
2274  _displaced_mesh->elemPtr(lower_d_elem->id()), tid, pts, weights);
2275 }
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)
Definition: SubProblem.C:957
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
dof_id_type id() const
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseMesh * _displaced_mesh

◆ reinitMaterials()

void FEProblemBase::reinitMaterials ( SubdomainID  blk_id,
const THREAD_ID  tid,
bool  swap_stateful = true 
)
inherited

Definition at line 4135 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), ComputeMarkerThread::onElement(), ComputeIndicatorThread::onElement(), ComputeDiracThread::onElement(), and ComputeUserObjectsThread::onElement().

4136 {
4137  if (hasActiveMaterialProperties(tid))
4138  {
4139  auto && elem = _assembly[tid][0]->elem();
4140  unsigned int n_points = _assembly[tid][0]->qRule()->n_points();
4141 
4142  auto & material_data = _material_props.getMaterialData(tid);
4143  material_data.resize(n_points);
4144 
4145  // Only swap if requested
4146  if (swap_stateful)
4147  material_data.swap(*elem);
4148 
4149  if (_discrete_materials.hasActiveBlockObjects(blk_id, tid))
4150  material_data.reset(_discrete_materials.getActiveBlockObjects(blk_id, tid));
4151 
4152  if (_materials.hasActiveBlockObjects(blk_id, tid))
4153  material_data.reinit(_materials.getActiveBlockObjects(blk_id, tid));
4154  }
4155 }
bool hasActiveBlockObjects(THREAD_ID tid=0) const
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
MaterialWarehouse _discrete_materials
const MaterialData & getMaterialData(const THREAD_ID tid) const
MaterialPropertyStorage & _material_props
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.
void resize(unsigned int n_qpoints)
Resize the data to hold properties for n_qpoints quadrature points.
Definition: MaterialData.C:21
MaterialWarehouse _materials

◆ reinitMaterialsBoundary()

void FEProblemBase::reinitMaterialsBoundary ( BoundaryID  boundary_id,
const THREAD_ID  tid,
bool  swap_stateful = true,
const std::deque< MaterialBase *> *  reinit_mats = nullptr 
)
inherited

reinit materials on a boundary

Parameters
boundary_idThe boundary on which to reinit corresponding materials
tidThe thread id
swap_statefulWhether to swap stateful material properties between MaterialData and MaterialPropertyStorage
execute_statefulWhether to execute material objects that have stateful properties. This should be false when for example executing material objects for mortar contexts in which stateful properties don't make sense

Definition at line 4228 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), and NonlinearThread::prepareFace().

4232 {
4233  if (hasActiveMaterialProperties(tid))
4234  {
4235  auto && elem = _assembly[tid][0]->elem();
4236  unsigned int side = _assembly[tid][0]->side();
4237  unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
4238 
4239  auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
4240  bnd_material_data.resize(n_points);
4241 
4242  if (swap_stateful && !bnd_material_data.isSwapped())
4243  bnd_material_data.swap(*elem, side);
4244 
4245  if (_discrete_materials.hasActiveBoundaryObjects(boundary_id, tid))
4246  bnd_material_data.reset(_discrete_materials.getActiveBoundaryObjects(boundary_id, tid));
4247 
4248  if (reinit_mats)
4249  bnd_material_data.reinit(*reinit_mats);
4250  else if (_materials.hasActiveBoundaryObjects(boundary_id, tid))
4251  bnd_material_data.reinit(_materials.getActiveBoundaryObjects(boundary_id, tid));
4252  }
4253 }
MaterialPropertyStorage & _bnd_material_props
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
MaterialWarehouse _discrete_materials
const MaterialData & getMaterialData(const THREAD_ID tid) const
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.
void resize(unsigned int n_qpoints)
Resize the data to hold properties for n_qpoints quadrature points.
Definition: MaterialData.C:21
MaterialWarehouse _materials

◆ reinitMaterialsFace()

void FEProblemBase::reinitMaterialsFace ( SubdomainID  blk_id,
const THREAD_ID  tid,
bool  swap_stateful = true,
const std::deque< MaterialBase *> *  reinit_mats = nullptr 
)
inherited

reinit materials on element faces

Parameters
blk_idThe subdomain on which the element owning the face lives
tidThe thread id
swap_statefulWhether to swap stateful material properties between MaterialData and MaterialPropertyStorage
execute_statefulWhether to execute material objects that have stateful properties. This should be false when for example executing material objects for mortar contexts in which stateful properties don't make sense

Definition at line 4158 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and NonlinearThread::prepareFace().

4162 {
4163  if (hasActiveMaterialProperties(tid))
4164  {
4165  auto && elem = _assembly[tid][0]->elem();
4166  unsigned int side = _assembly[tid][0]->side();
4167  unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
4168 
4169  auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
4170  bnd_material_data.resize(n_points);
4171 
4172  if (swap_stateful && !bnd_material_data.isSwapped())
4173  bnd_material_data.swap(*elem, side);
4174 
4175  if (_discrete_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4176  bnd_material_data.reset(
4177  _discrete_materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4178 
4179  if (reinit_mats)
4180  bnd_material_data.reinit(*reinit_mats);
4181  else if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4182  bnd_material_data.reinit(
4183  _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4184  }
4185 }
MaterialPropertyStorage & _bnd_material_props
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
MaterialWarehouse _discrete_materials
const MaterialData & getMaterialData(const THREAD_ID tid) const
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.
void resize(unsigned int n_qpoints)
Resize the data to hold properties for n_qpoints quadrature points.
Definition: MaterialData.C:21
MaterialWarehouse _materials

◆ reinitMaterialsInterface()

void FEProblemBase::reinitMaterialsInterface ( BoundaryID  boundary_id,
const THREAD_ID  tid,
bool  swap_stateful = true 
)
inherited

Definition at line 4256 of file FEProblemBase.C.

Referenced by NonlinearThread::onInterface(), and ComputeUserObjectsThread::onInterface().

4259 {
4260  if (hasActiveMaterialProperties(tid))
4261  {
4262  const Elem * const & elem = _assembly[tid][0]->elem();
4263  unsigned int side = _assembly[tid][0]->side();
4264  unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
4265 
4266  auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
4267  bnd_material_data.resize(n_points);
4268 
4269  if (swap_stateful && !bnd_material_data.isSwapped())
4270  bnd_material_data.swap(*elem, side);
4271 
4272  if (_interface_materials.hasActiveBoundaryObjects(boundary_id, tid))
4273  bnd_material_data.reinit(_interface_materials.getActiveBoundaryObjects(boundary_id, tid));
4274  }
4275 }
MaterialPropertyStorage & _bnd_material_props
MaterialWarehouse _interface_materials
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
const MaterialData & getMaterialData(const THREAD_ID tid) const
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.
void resize(unsigned int n_qpoints)
Resize the data to hold properties for n_qpoints quadrature points.
Definition: MaterialData.C:21

◆ reinitMaterialsNeighbor()

void FEProblemBase::reinitMaterialsNeighbor ( SubdomainID  blk_id,
const THREAD_ID  tid,
bool  swap_stateful = true,
const std::deque< MaterialBase *> *  reinit_mats = nullptr 
)
inherited

reinit materials on the neighboring element face

Parameters
blk_idThe subdomain on which the neighbor element lives
tidThe thread id
swap_statefulWhether to swap stateful material properties between MaterialData and MaterialPropertyStorage
execute_statefulWhether to execute material objects that have stateful properties. This should be false when for example executing material objects for mortar contexts in which stateful properties don't make sense

Definition at line 4188 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and NonlinearSystemBase::reinitNodeFace().

4192 {
4193  if (hasActiveMaterialProperties(tid))
4194  {
4195  // NOTE: this will not work with h-adaptivity
4196  // lindsayad: why not?
4197 
4198  const Elem * neighbor = _assembly[tid][0]->neighbor();
4199  unsigned int neighbor_side = neighbor->which_neighbor_am_i(_assembly[tid][0]->elem());
4200 
4201  mooseAssert(neighbor, "neighbor should be non-null");
4202  mooseAssert(blk_id == neighbor->subdomain_id(),
4203  "The provided blk_id " << blk_id << " and neighbor subdomain ID "
4204  << neighbor->subdomain_id() << " do not match.");
4205 
4206  unsigned int n_points = _assembly[tid][0]->qRuleNeighbor()->n_points();
4207 
4208  auto & neighbor_material_data = _neighbor_material_props.getMaterialData(tid);
4209  neighbor_material_data.resize(n_points);
4210 
4211  // Only swap if requested
4212  if (swap_stateful)
4213  neighbor_material_data.swap(*neighbor, neighbor_side);
4214 
4215  if (_discrete_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4216  neighbor_material_data.reset(
4217  _discrete_materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4218 
4219  if (reinit_mats)
4220  neighbor_material_data.reinit(*reinit_mats);
4221  else if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4222  neighbor_material_data.reinit(
4223  _materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4224  }
4225 }
unsigned int which_neighbor_am_i(const Elem *e) const
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
MaterialWarehouse _discrete_materials
subdomain_id_type subdomain_id() const
MaterialPropertyStorage & _neighbor_material_props
const MaterialData & getMaterialData(const THREAD_ID tid) const
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.
void resize(unsigned int n_qpoints)
Resize the data to hold properties for n_qpoints quadrature points.
Definition: MaterialData.C:21
MaterialWarehouse _materials

◆ reinitMortarElem()

void SubProblem::reinitMortarElem ( const Elem elem,
const THREAD_ID  tid = 0 
)
inherited

Reinit a mortar element to obtain a valid JxW.

Definition at line 994 of file SubProblem.C.

Referenced by Moose::Mortar::loopOverMortarSegments().

995 {
996  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
997  assembly(tid, nl_sys_num).reinitMortarElem(elem);
998 }
void reinitMortarElem(const Elem *elem)
reinitialize a mortar segment mesh element in order to get a proper JxW
Definition: Assembly.C:2402
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num)=0
IntRange< T > make_range(T beg, T end)
virtual std::size_t numNonlinearSystems() const =0

◆ reinitMortarUserObjects()

void FEProblemBase::reinitMortarUserObjects ( BoundaryID  primary_boundary_id,
BoundaryID  secondary_boundary_id,
bool  displaced 
)
inherited

Call reinit on mortar user objects with matching primary boundary ID, secondary boundary ID, and displacement characteristics.

Definition at line 9449 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments().

9452 {
9453  const auto mortar_uos =
9454  getMortarUserObjects(primary_boundary_id, secondary_boundary_id, displaced);
9455  for (auto * const mortar_uo : mortar_uos)
9456  {
9457  mortar_uo->setNormals();
9458  mortar_uo->reinit();
9459  }
9460 }
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...

◆ reinitNeighbor()

void FEProblemBase::reinitNeighbor ( const Elem elem,
unsigned int  side,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2353 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInterface(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and FEProblemBase::reinitElemNeighborAndLowerD().

2354 {
2355  setNeighborSubdomainID(elem, side, tid);
2356 
2357  const Elem * neighbor = elem->neighbor_ptr(side);
2358  unsigned int neighbor_side = neighbor->which_neighbor_am_i(elem);
2359 
2360  for (const auto i : index_range(_nl))
2361  {
2362  _assembly[tid][i]->reinitElemAndNeighbor(elem, side, neighbor, neighbor_side);
2363  _nl[i]->prepareNeighbor(tid);
2364  // Called during stateful material property evaluation outside of solve
2365  _assembly[tid][i]->prepareNeighbor();
2366  }
2367  _aux->prepareNeighbor(tid);
2368 
2369  for (auto & nl : _nl)
2370  {
2371  nl->reinitElemFace(elem, side, tid);
2372  nl->reinitNeighborFace(neighbor, neighbor_side, tid);
2373  }
2374  _aux->reinitElemFace(elem, side, tid);
2375  _aux->reinitNeighborFace(neighbor, neighbor_side, tid);
2376 
2378  {
2379  // There are cases like for cohesive zone modeling without significant sliding where we cannot
2380  // use FEInterface::inverse_map in Assembly::reinitElemAndNeighbor in the displaced problem
2381  // because the physical points coming from the element don't actually lie on the neighbor.
2382  // Moreover, what's the point of doing another physical point inversion in other cases? We only
2383  // care about the reference points which we can just take from the undisplaced computation
2384  const auto & displaced_ref_pts = _assembly[tid][0]->qRuleNeighbor()->get_points();
2385 
2386  _displaced_problem->reinitNeighbor(
2387  _displaced_mesh->elemPtr(elem->id()), side, tid, &displaced_ref_pts);
2388  }
2389 }
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
dof_id_type id() const
unsigned int which_neighbor_am_i(const Elem *e) const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
const Elem * neighbor_ptr(unsigned int i) const
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual void setNeighborSubdomainID(const Elem *elem, unsigned int side, const THREAD_ID tid) override
auto index_range(const T &sizable)
MooseMesh * _displaced_mesh

◆ reinitNeighborFaceRef()

void FEProblemBase::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 
)
overridevirtualinherited

reinitialize FE objects on a given neighbor element on a given side at a given set of reference points and then compute variable data.

Note that this method makes no assumptions about what's been called beforehand, e.g. you don't have to call some prepare method before this one. This is an all-in-one reinit

Reimplemented from SubProblem.

Definition at line 9199 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments().

9205 {
9206  SubProblem::reinitNeighborFaceRef(neighbor_elem, neighbor_side, tolerance, pts, weights, tid);
9207 
9208  if (_displaced_problem)
9209  _displaced_problem->reinitNeighborFaceRef(
9210  _displaced_mesh->elemPtr(neighbor_elem->id()), neighbor_side, tolerance, pts, weights, tid);
9211 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
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)
reinitialize FE objects on a given neighbor element on a given side at a given set of reference point...
Definition: SubProblem.C:921
dof_id_type id() const
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseMesh * _displaced_mesh

◆ reinitNeighborLowerDElem()

void SubProblem::reinitNeighborLowerDElem ( const Elem elem,
const THREAD_ID  tid = 0 
)
inherited

reinitialize a neighboring lower dimensional element

Definition at line 987 of file SubProblem.C.

Referenced by Moose::Mortar::loopOverMortarSegments().

988 {
989  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
990  assembly(tid, nl_sys_num).reinitNeighborLowerDElem(elem);
991 }
void reinitNeighborLowerDElem(const Elem *elem)
reinitialize a neighboring lower dimensional element
Definition: Assembly.C:2381
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num)=0
IntRange< T > make_range(T beg, T end)
virtual std::size_t numNonlinearSystems() const =0

◆ reinitNeighborPhys() [1/2]

virtual void FEProblemBase::reinitNeighborPhys ( const Elem *  neighbor,
unsigned int  neighbor_side,
const std::vector< Point > &  physical_points,
const THREAD_ID  tid 
)
overridevirtualinherited

◆ reinitNeighborPhys() [2/2]

virtual void FEProblemBase::reinitNeighborPhys ( const Elem *  neighbor,
const std::vector< Point > &  physical_points,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

◆ reinitNode()

void FEProblemBase::reinitNode ( const Node node,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2278 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), NonlinearSystemBase::computeResidualInternal(), ComputeNodalUserObjectsThread::onNode(), ComputeNodalDampingThread::onNode(), ComputeNodalKernelsThread::onNode(), and ComputeNodalKernelJacobiansThread::onNode().

2279 {
2281  _displaced_problem->reinitNode(&_displaced_mesh->nodeRef(node->id()), tid);
2282 
2283  for (const auto i : index_range(_nl))
2284  {
2285  _assembly[tid][i]->reinit(node);
2286  _nl[i]->reinitNode(node, tid);
2287  }
2288  _aux->reinitNode(node, tid);
2289 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
virtual const Node & nodeRef(const dof_id_type i) const
Definition: MooseMesh.C:849
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
dof_id_type id() const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
auto index_range(const T &sizable)
MooseMesh * _displaced_mesh

◆ reinitNodeFace()

void FEProblemBase::reinitNodeFace ( const Node node,
BoundaryID  bnd_id,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2292 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), NonlinearSystemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSecondaryValues(), and NonlinearSystemBase::setInitialSolution().

2293 {
2295  _displaced_problem->reinitNodeFace(&_displaced_mesh->nodeRef(node->id()), bnd_id, tid);
2296 
2297  for (const auto i : index_range(_nl))
2298  {
2299  _assembly[tid][i]->reinit(node);
2300  _nl[i]->reinitNodeFace(node, bnd_id, tid);
2301  }
2302  _aux->reinitNodeFace(node, bnd_id, tid);
2303 }
virtual const Node & nodeRef(const dof_id_type i) const
Definition: MooseMesh.C:849
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
dof_id_type id() const
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
std::shared_ptr< DisplacedProblem > _displaced_problem
auto index_range(const T &sizable)
MooseMesh * _displaced_mesh

◆ reinitNodes()

void FEProblemBase::reinitNodes ( const std::vector< dof_id_type > &  nodes,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2306 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::enforceNodalConstraintsJacobian(), and NonlinearSystemBase::enforceNodalConstraintsResidual().

2307 {
2309  _displaced_problem->reinitNodes(nodes, tid);
2310 
2311  for (auto & nl : _nl)
2312  nl->reinitNodes(nodes, tid);
2313  _aux->reinitNodes(nodes, tid);
2314 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ reinitNodesNeighbor()

void FEProblemBase::reinitNodesNeighbor ( const std::vector< dof_id_type > &  nodes,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 2317 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::enforceNodalConstraintsJacobian(), and NonlinearSystemBase::enforceNodalConstraintsResidual().

2318 {
2320  _displaced_problem->reinitNodesNeighbor(nodes, tid);
2321 
2322  for (auto & nl : _nl)
2323  nl->reinitNodesNeighbor(nodes, tid);
2324  _aux->reinitNodesNeighbor(nodes, tid);
2325 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ reinitOffDiagScalars()

void FEProblemBase::reinitOffDiagScalars ( const THREAD_ID  tid)
overridevirtualinherited

Implements SubProblem.

Definition at line 2345 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians(), NonlinearSystemBase::constraintJacobians(), and NonlinearThread::onElement().

2346 {
2347  _assembly[tid][_current_nl_sys->number()]->prepareOffDiagScalar();
2348  if (_displaced_problem)
2349  _displaced_problem->reinitOffDiagScalars(tid);
2350 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ reinitScalars()

void FEProblemBase::reinitScalars ( const THREAD_ID  tid,
bool  reinit_for_derivative_reordering = false 
)
overridevirtualinherited

fills the VariableValue arrays for scalar variables from the solution vector

Parameters
tidThe thread id
reinit_for_derivative_reorderingA flag indicating whether we are reinitializing for the purpose of re-ordering derivative information for ADNodalBCs

Implements SubProblem.

Definition at line 2328 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeResidualTags(), NonlinearSystemBase::computeScalarKernelsJacobians(), AuxiliarySystem::computeScalarVars(), and FEProblemBase::initialSetup().

2329 {
2330  TIME_SECTION("reinitScalars", 3, "Reinitializing Scalar Variables");
2331 
2333  _displaced_problem->reinitScalars(tid, reinit_for_derivative_reordering);
2334 
2335  for (auto & nl : _nl)
2336  nl->reinitScalars(tid, reinit_for_derivative_reordering);
2337  _aux->reinitScalars(tid, reinit_for_derivative_reordering);
2338 
2339  // This is called outside of residual/Jacobian call-backs
2340  for (auto & assembly : _assembly[tid])
2342 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
void prepareScalar()
Definition: Assembly.C:2945
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ removeAlgebraicGhostingFunctor()

void SubProblem::removeAlgebraicGhostingFunctor ( libMesh::GhostingFunctor algebraic_gf)
inherited

Remove an algebraic ghosting functor from this problem's DofMaps.

Definition at line 1067 of file SubProblem.C.

1068 {
1069  EquationSystems & eq = es();
1070  const auto n_sys = eq.n_systems();
1071  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
1072 
1073  const bool found_in_root_sys =
1075  nl_dof_map.algebraic_ghosting_functors_end(),
1076  &algebraic_gf) != nl_dof_map.algebraic_ghosting_functors_end();
1077 
1078 #ifndef NDEBUG
1079  const bool found_in_our_map =
1080  _root_alg_gf_to_sys_clones.find(&algebraic_gf) != _root_alg_gf_to_sys_clones.end();
1081  mooseAssert(found_in_root_sys == found_in_our_map,
1082  "If the ghosting functor exists in the root DofMap, then we need to have a key for "
1083  "it in our gf to clones map");
1084 #endif
1085 
1086  if (found_in_root_sys) // libMesh yells if we try to remove
1087  // something that's not there
1088  nl_dof_map.remove_algebraic_ghosting_functor(algebraic_gf);
1089 
1090  auto it = _root_alg_gf_to_sys_clones.find(&algebraic_gf);
1091  if (it == _root_alg_gf_to_sys_clones.end())
1092  return;
1093 
1094  auto & clones_vec = it->second;
1095  mooseAssert((n_sys - 1) == clones_vec.size(),
1096  "The size of the gf clones vector doesn't match the number of systems minus one");
1097  if (clones_vec.empty())
1098  {
1099  mooseAssert(n_sys == 1, "The clones vector should only be empty if there is only one system");
1100  return;
1101  }
1102 
1103  for (const auto i : make_range(n_sys))
1104  eq.get_system(i + 1).get_dof_map().remove_algebraic_ghosting_functor(*clones_vec[i]);
1105 
1106  _root_alg_gf_to_sys_clones.erase(it->first);
1107 }
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:30
unsigned int n_systems() const
GhostingFunctorIterator algebraic_ghosting_functors_begin() const
GhostingFunctorIterator algebraic_ghosting_functors_end() const
const T_sys & get_system(std::string_view name) const
virtual libMesh::EquationSystems & es()=0
std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > > _root_alg_gf_to_sys_clones
A map from a root algebraic ghosting functor, e.g.
Definition: SubProblem.h:1192
IntRange< T > make_range(T beg, T end)
void remove_algebraic_ghosting_functor(GhostingFunctor &evaluable_functor)

◆ removeCouplingGhostingFunctor()

void SubProblem::removeCouplingGhostingFunctor ( libMesh::GhostingFunctor coupling_gf)
inherited

Remove a coupling ghosting functor from this problem's DofMaps.

Definition at line 1110 of file SubProblem.C.

1111 {
1112  EquationSystems & eq = es();
1113  const auto num_nl_sys = numNonlinearSystems();
1114  if (!num_nl_sys)
1115  return;
1116 
1117  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
1118  const bool found_in_root_sys = std::find(nl_dof_map.coupling_functors_begin(),
1119  nl_dof_map.coupling_functors_end(),
1120  &coupling_gf) != nl_dof_map.coupling_functors_end();
1121 
1122 #ifndef NDEBUG
1123  const bool found_in_our_map =
1125  mooseAssert(found_in_root_sys == found_in_our_map,
1126  "If the ghosting functor exists in the root DofMap, then we need to have a key for "
1127  "it in our gf to clones map");
1128 #endif
1129 
1130  if (found_in_root_sys) // libMesh yells if we try to remove
1131  // something that's not there
1132  nl_dof_map.remove_coupling_functor(coupling_gf);
1133 
1134  auto it = _root_coupling_gf_to_sys_clones.find(&coupling_gf);
1135  if (it == _root_coupling_gf_to_sys_clones.end())
1136  return;
1137 
1138  auto & clones_vec = it->second;
1139  mooseAssert((num_nl_sys - 1) == clones_vec.size(),
1140  "The size of the gf clones vector doesn't match the number of systems minus one");
1141  if (clones_vec.empty())
1142  {
1143  mooseAssert(num_nl_sys == 1,
1144  "The clones vector should only be empty if there is only one nonlinear system");
1145  return;
1146  }
1147 
1148  for (const auto i : make_range(num_nl_sys))
1149  eq.get_system(i + 1).get_dof_map().remove_coupling_functor(*clones_vec[i]);
1150 
1151  _root_coupling_gf_to_sys_clones.erase(it->first);
1152 }
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition: KokkosUtils.h:30
std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > > _root_coupling_gf_to_sys_clones
A map from a root coupling ghosting functor, e.g.
Definition: SubProblem.h:1199
const T_sys & get_system(std::string_view name) const
virtual libMesh::EquationSystems & es()=0
GhostingFunctorIterator coupling_functors_end() const
void remove_coupling_functor(GhostingFunctor &coupling_functor)
IntRange< T > make_range(T beg, T end)
virtual std::size_t numNonlinearSystems() const =0
GhostingFunctorIterator coupling_functors_begin() const

◆ reportMooseObjectDependency()

void FEProblemBase::reportMooseObjectDependency ( MooseObject a,
MooseObject b 
)
inherited

Register a MOOSE object dependency so we can either order operations properly or report when we cannot.

a -> b (a depends on b)

Definition at line 5257 of file FEProblemBase.C.

5258 {
5259  //<< "Object " << a->name() << " -> " << b->name() << std::endl;
5260 }

◆ resetFailNextNonlinearConvergenceCheck()

void FEProblemBase::resetFailNextNonlinearConvergenceCheck ( )
inlineinherited

Tell the problem that the nonlinear convergence check(s) may proceed as normal.

Definition at line 2565 of file FEProblemBase.h.

Referenced by Moose::PetscSupport::petscNonlinearConverged().

void resetFailNextSystemConvergenceCheck()
Tell the problem that the system convergence check(s) may proceed as normal.

◆ resetFailNextSystemConvergenceCheck()

void FEProblemBase::resetFailNextSystemConvergenceCheck ( )
inlineinherited

Tell the problem that the system convergence check(s) may proceed as normal.

Definition at line 2567 of file FEProblemBase.h.

Referenced by Moose::PetscSupport::petscLinearConverged(), and FEProblemBase::resetFailNextNonlinearConvergenceCheck().

bool _fail_next_system_convergence_check

◆ residualSetup()

void FEProblemBase::residualSetup ( )
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 9349 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::residualSetup().

9350 {
9352  // We need to setup all the nonlinear systems other than our current one which actually called
9353  // this method (so we have to make sure we don't go in a circle)
9354  for (const auto i : make_range(numNonlinearSystems()))
9355  if (i != currentNlSysNum())
9356  _nl[i]->residualSetup();
9357  // We don't setup the aux sys because that's been done elsewhere
9358  if (_displaced_problem)
9359  _displaced_problem->residualSetup();
9360 }
virtual std::size_t numNonlinearSystems() const override
virtual void residualSetup()
Definition: SubProblem.C:1201
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
virtual unsigned int currentNlSysNum() const override
IntRange< T > make_range(T beg, T end)
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ resizeMaterialData()

void FEProblemBase::resizeMaterialData ( Moose::MaterialDataType  data_type,
unsigned int  nqp,
const THREAD_ID  tid 
)
inherited

Resize material data.

Parameters
data_typeThe type of material data to resize
nqpThe number of quadrature points to resize for
tidThe thread ID

Definition at line 9270 of file FEProblemBase.C.

9273 {
9274  getMaterialData(data_type, tid).resize(nqp);
9275 }
MPI_Datatype data_type
MaterialData & getMaterialData(Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const
void resize(unsigned int n_qpoints)
Resize the data to hold properties for n_qpoints quadrature points.
Definition: MaterialData.C:21

◆ restartableName()

std::string Restartable::restartableName ( const std::string &  data_name) const
protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataHelper().

79 {
80  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
81 }
std::string _restartable_name
The name of the object.
Definition: Restartable.h:250
const std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:237

◆ restoreMultiApps()

void FEProblemBase::restoreMultiApps ( ExecFlagType  type,
bool  force = false 
)
inherited

Restore the MultiApps associated with the ExecFlagType.

Parameters
forceForce restoration because something went wrong with the solve

Definition at line 5692 of file FEProblemBase.C.

Referenced by TransientBase::incrementStepOrReject(), and FixedPointSolve::solve().

5693 {
5694  const auto & multi_apps = _multi_apps[type].getActiveObjects();
5695 
5696  if (multi_apps.size())
5697  {
5698  if (_verbose_multiapps)
5699  {
5700  if (force)
5701  _console << COLOR_CYAN << "\nRestoring Multiapps on " << type.name()
5702  << " because of solve failure!" << COLOR_DEFAULT << std::endl;
5703  else
5704  _console << COLOR_CYAN << "\nRestoring MultiApps on " << type.name() << COLOR_DEFAULT
5705  << std::endl;
5706  }
5707 
5708  for (const auto & multi_app : multi_apps)
5709  multi_app->restore(force);
5710 
5712 
5713  if (_verbose_multiapps)
5714  _console << COLOR_CYAN << "Finished Restoring MultiApps on " << type.name() << "\n"
5715  << COLOR_DEFAULT << std::endl;
5716  }
5717 }
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.
const Parallel::Communicator & _communicator
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...
void parallelBarrierNotify(const libMesh::Parallel::Communicator &comm, bool messaging=true)
This function implements a parallel barrier function but writes progress to stdout.
Definition: MooseUtils.C:323
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool _verbose_multiapps
Whether or not to be verbose with multiapps.

◆ restoreOldSolutions()

void FEProblemBase::restoreOldSolutions ( )
virtualinherited

Restore old solutions from the backup vectors and deallocate them.

Definition at line 6836 of file FEProblemBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

6837 {
6838  TIME_SECTION("restoreOldSolutions", 5, "Restoring Old Solutions");
6839 
6840  for (auto & sys : _solver_systems)
6841  sys->restoreOldSolutions();
6842  _aux->restoreOldSolutions();
6843 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ restoreOriginalNonzeroPattern()

bool FEProblemBase::restoreOriginalNonzeroPattern ( ) const
inlineinherited
Returns
Whether the original matrix nonzero pattern is restored before each Jacobian assembly

Definition at line 2089 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeJacobianInternal().

const bool _restore_original_nonzero_pattern
Whether we should restore the original nonzero pattern for every Jacobian evaluation.

◆ restoreSolutions()

void FEProblemBase::restoreSolutions ( )
virtualinherited

Definition at line 6798 of file FEProblemBase.C.

Referenced by ActivateElementsUserObjectBase::initSolutions(), TimeStepper::rejectStep(), and FEProblemBase::updateMeshXFEM().

6799 {
6800  TIME_SECTION("restoreSolutions", 5, "Restoring Solutions");
6801 
6802  if (!_not_zeroed_tagged_vectors.empty())
6803  paramError("not_zeroed_tag_vectors",
6804  "There is currently no way to restore not-zeroed vectors.");
6805 
6806  for (auto & sys : _solver_systems)
6807  {
6808  if (_verbose_restore)
6809  _console << "Restoring solutions on system " << sys->name() << "..." << std::endl;
6810  sys->restoreSolutions();
6811  }
6812 
6813  if (_verbose_restore)
6814  _console << "Restoring solutions on Auxiliary system..." << std::endl;
6815  _aux->restoreSolutions();
6816 
6817  if (_verbose_restore)
6818  _console << "Restoring postprocessor, vector-postprocessor, and reporter data..." << std::endl;
6820 
6821  if (_displaced_problem)
6822  _displaced_problem->updateMesh();
6823 }
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition: MooseBase.h:439
std::unordered_set< TagID > _not_zeroed_tagged_vectors
the list of vector tags that will not be zeroed when all other tags are
Definition: SubProblem.h:1117
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
bool _verbose_restore
Whether or not to be verbose on solution restoration post a failed time step.
ReporterData _reporter_data
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
std::shared_ptr< DisplacedProblem > _displaced_problem
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
void restoreState(bool verbose=false)
When a time step fails, this method is called to revert the current reporter values to their old stat...
Definition: ReporterData.C:24

◆ safeAccessTaggedMatrices()

virtual bool SubProblem::safeAccessTaggedMatrices ( ) const
inlinevirtualinherited

Is it safe to access the tagged matrices.

Reimplemented in DisplacedProblem.

Definition at line 731 of file SubProblem.h.

Referenced by MooseVariableScalar::reinit(), and DisplacedProblem::safeAccessTaggedMatrices().

bool _safe_access_tagged_matrices
Is it safe to retrieve data from tagged matrices.
Definition: SubProblem.h:1108

◆ safeAccessTaggedVectors()

virtual bool SubProblem::safeAccessTaggedVectors ( ) const
inlinevirtualinherited

Is it safe to access the tagged vectors.

Reimplemented in DisplacedProblem.

Definition at line 734 of file SubProblem.h.

Referenced by MooseVariableScalar::reinit(), and DisplacedProblem::safeAccessTaggedVectors().

734 { return _safe_access_tagged_vectors; }
bool _safe_access_tagged_vectors
Is it safe to retrieve data from tagged vectors.
Definition: SubProblem.h:1111

◆ saveOldSolutions()

void FEProblemBase::saveOldSolutions ( )
virtualinherited

Allocate vectors and save old solutions into them.

Definition at line 6826 of file FEProblemBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

6827 {
6828  TIME_SECTION("saveOldSolutions", 5, "Saving Old Solutions");
6829 
6830  for (auto & sys : _solver_systems)
6831  sys->saveOldSolutions();
6832  _aux->saveOldSolutions();
6833 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ selectMatrixTagsFromSystem()

void SubProblem::selectMatrixTagsFromSystem ( const SystemBase system,
const std::map< TagName, TagID > &  input_matrix_tags,
std::set< TagID > &  selected_tags 
)
staticinherited

Select the matrix tags which belong to a specific system.

Parameters
systemReference to the system
input_matrix_tagsA map of matrix tags
selected_tagsA set which gets populated by the tag-ids that belong to the system

Definition at line 300 of file SubProblem.C.

Referenced by FEProblemBase::computeLinearSystemSys().

303 {
304  selected_tags.clear();
305  for (const auto & matrix_tag_pair : input_matrix_tags)
306  if (system.hasMatrix(matrix_tag_pair.second))
307  selected_tags.insert(matrix_tag_pair.second);
308 }
virtual bool hasMatrix(TagID tag) const
Check if the tagged matrix exists in the system.
Definition: SystemBase.h:360

◆ selectVectorTagsFromSystem()

void SubProblem::selectVectorTagsFromSystem ( const SystemBase system,
const std::vector< VectorTag > &  input_vector_tags,
std::set< TagID > &  selected_tags 
)
staticinherited

Select the vector tags which belong to a specific system.

Parameters
systemReference to the system
input_vector_tagsA vector of vector tags
selected_tagsA set which gets populated by the tag-ids that belong to the system

Definition at line 289 of file SubProblem.C.

Referenced by FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeResidualAndJacobian(), and ComputeResidualAndJacobianThread::determineObjectWarehouses().

292 {
293  selected_tags.clear();
294  for (const auto & vector_tag : input_vector_tags)
295  if (system.hasVector(vector_tag._id))
296  selected_tags.insert(vector_tag._id);
297 }
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
Definition: SystemBase.C:924

◆ setActiveElementalMooseVariables()

void FEProblemBase::setActiveElementalMooseVariables ( const std::set< MooseVariableFEBase *> &  moose_vars,
const THREAD_ID  tid 
)
overridevirtualinherited

Set the MOOSE variables to be reinited on each element.

Parameters
moose_varsA set of variables that need to be reinited each time reinit() is called.
tidThe thread id

Reimplemented from SubProblem.

Definition at line 5973 of file FEProblemBase.C.

Referenced by FEProblemBase::prepareMaterials(), ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeDiracThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

5975 {
5977 
5978  if (_displaced_problem)
5979  _displaced_problem->setActiveElementalMooseVariables(moose_vars, tid);
5980 }
virtual void setActiveElementalMooseVariables(const std::set< MooseVariableFieldBase *> &moose_vars, const THREAD_ID tid)
Set the MOOSE variables to be reinited on each element.
Definition: SubProblem.C:443
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ setActiveFEVariableCoupleableMatrixTags()

void FEProblemBase::setActiveFEVariableCoupleableMatrixTags ( std::set< TagID > &  mtags,
const THREAD_ID  tid 
)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 5935 of file FEProblemBase.C.

5936 {
5938 
5939  if (_displaced_problem)
5940  _displaced_problem->setActiveFEVariableCoupleableMatrixTags(mtags, tid);
5941 }
virtual void setActiveFEVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid)
Definition: SubProblem.C:363
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ setActiveFEVariableCoupleableVectorTags()

void FEProblemBase::setActiveFEVariableCoupleableVectorTags ( std::set< TagID > &  vtags,
const THREAD_ID  tid 
)
overridevirtualinherited

◆ setActiveMaterialProperties()

void FEProblemBase::setActiveMaterialProperties ( const std::unordered_set< unsigned int > &  mat_prop_ids,
const THREAD_ID  tid 
)
inherited

Record and set the material properties required by the current computing thread.

Parameters
mat_prop_idsThe set of material properties required by the current computing thread.
tidThe thread id

Definition at line 6028 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), FEProblemBase::prepareMaterials(), NodalPatchRecovery::reinitPatch(), NonlinearSystemBase::setConstraintSecondaryValues(), and ComputeDiracThread::subdomainChanged().

6030 {
6031  // mark active properties in every material
6032  for (auto & mat : _all_materials.getObjects(tid))
6033  mat->setActiveProperties(mat_prop_ids);
6034  for (auto & mat : _all_materials[Moose::FACE_MATERIAL_DATA].getObjects(tid))
6035  mat->setActiveProperties(mat_prop_ids);
6036  for (auto & mat : _all_materials[Moose::NEIGHBOR_MATERIAL_DATA].getObjects(tid))
6037  mat->setActiveProperties(mat_prop_ids);
6038 
6039  _has_active_material_properties[tid] = !mat_prop_ids.empty();
6040 }
const std::vector< std::shared_ptr< T > > & getObjects(THREAD_ID tid=0) const
Retrieve complete vector to the all/block/boundary restricted objects for a given thread...
std::vector< unsigned char > _has_active_material_properties
Whether there are active material properties on each thread.
MaterialWarehouse _all_materials

◆ setActiveScalarVariableCoupleableMatrixTags()

void FEProblemBase::setActiveScalarVariableCoupleableMatrixTags ( std::set< TagID > &  mtags,
const THREAD_ID  tid 
)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 5953 of file FEProblemBase.C.

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

5955 {
5957 
5958  if (_displaced_problem)
5959  _displaced_problem->setActiveScalarVariableCoupleableMatrixTags(mtags, tid);
5960 }
virtual void setActiveScalarVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid)
Definition: SubProblem.C:402
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ setActiveScalarVariableCoupleableVectorTags()

void FEProblemBase::setActiveScalarVariableCoupleableVectorTags ( std::set< TagID > &  vtags,
const THREAD_ID  tid 
)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 5963 of file FEProblemBase.C.

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

5965 {
5967 
5968  if (_displaced_problem)
5969  _displaced_problem->setActiveScalarVariableCoupleableVectorTags(vtags, tid);
5970 }
virtual void setActiveScalarVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid)
Definition: SubProblem.C:409
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ setAxisymmetricCoordAxis()

void FEProblemBase::setAxisymmetricCoordAxis ( const MooseEnum rz_coord_axis)
inherited

Definition at line 843 of file FEProblemBase.C.

844 {
845  _mesh.setAxisymmetricCoordAxis(rz_coord_axis);
846 }
MooseMesh & _mesh
void setAxisymmetricCoordAxis(const MooseEnum &rz_coord_axis)
For axisymmetric simulations, set the symmetry coordinate axis.
Definition: MooseMesh.C:4253

◆ setConstJacobian()

void FEProblemBase::setConstJacobian ( bool  state)
inlineinherited

Set flag that Jacobian is constant (for optimization purposes)

Parameters
stateTrue if the Jacobian is constant, false otherwise

Definition at line 1937 of file FEProblemBase.h.

Referenced by ExplicitEuler::preSolve(), ExplicitTVDRK2::preSolve(), and ExplicitRK2::preSolve().

1937 { _const_jacobian = state; }
bool _const_jacobian
true if the Jacobian is constant

◆ setCoordSystem()

void FEProblemBase::setCoordSystem ( const std::vector< SubdomainName > &  blocks,
const MultiMooseEnum coord_sys 
)
inherited

Definition at line 835 of file FEProblemBase.C.

837 {
838  TIME_SECTION("setCoordSystem", 5, "Setting Coordinate System");
839  _mesh.setCoordSystem(blocks, coord_sys);
840 }
char ** blocks
MooseMesh & _mesh
void setCoordSystem(const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
Set the coordinate system for the provided blocks to coord_sys.
Definition: MooseMesh.C:4121

◆ setCoupling()

void FEProblemBase::setCoupling ( Moose::CouplingType  type)
inherited

Set the coupling between variables TODO: allow user-defined coupling.

Parameters
typeType of coupling

Definition at line 6204 of file FEProblemBase.C.

Referenced by FEProblemBase::init(), FEProblemBase::setCouplingMatrix(), and Moose::SlepcSupport::setEigenProblemSolverParams().

6205 {
6207  {
6209  mooseError("Someone told us (the FEProblemBase) to trust the user coupling matrix, but we "
6210  "haven't been provided a coupling matrix!");
6211 
6212  // We've been told to trust the user coupling matrix, so we're going to leave things alone
6213  return;
6214  }
6215 
6216  _coupling = type;
6217 }
bool _trust_user_coupling_matrix
Whether to trust the user coupling matrix no matter what.
Moose::CouplingType _coupling
Type of variable coupling.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
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

◆ setCouplingMatrix() [1/2]

void FEProblemBase::setCouplingMatrix ( std::unique_ptr< libMesh::CouplingMatrix cm,
const unsigned int  nl_sys_num 
)
inherited

Set custom coupling matrix.

Parameters
cmcoupling matrix to be set
nl_sys_numwhich nonlinear system we are setting the coupling matrix for

Definition at line 6228 of file FEProblemBase.C.

Referenced by MoosePreconditioner::setCouplingMatrix().

6229 {
6231  _cm[i] = std::move(cm);
6232 }
void setCoupling(Moose::CouplingType type)
Set the coupling between variables TODO: allow user-defined coupling.
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
Coupling matrix for variables.

◆ setCouplingMatrix() [2/2]

void FEProblemBase::setCouplingMatrix ( libMesh::CouplingMatrix cm,
const unsigned int  nl_sys_num 
)
inherited

Definition at line 6220 of file FEProblemBase.C.

6221 {
6222  // TODO: Deprecate method
6224  _cm[i].reset(cm);
6225 }
void setCoupling(Moose::CouplingType type)
Set the coupling between variables TODO: allow user-defined coupling.
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
Coupling matrix for variables.

◆ setCurrentAlgebraicBndNodeRange()

void FEProblemBase::setCurrentAlgebraicBndNodeRange ( ConstBndNodeRange range)
inherited

Definition at line 9566 of file FEProblemBase.C.

9567 {
9568  if (!range)
9569  {
9571  return;
9572  }
9573 
9574  _current_algebraic_bnd_node_range = std::make_unique<ConstBndNodeRange>(*range);
9575 }
std::unique_ptr< ConstBndNodeRange > _current_algebraic_bnd_node_range

◆ setCurrentAlgebraicElementRange()

void FEProblemBase::setCurrentAlgebraicElementRange ( libMesh::ConstElemRange range)
inherited

These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes that contribute to the jacobian and residual for this local processor.

setCurrentAlgebraicElementRange() sets the element range that contributes to the system. A nullptr will reset the range to use the mesh's range.

setCurrentAlgebraicNodeRange() sets the node range that contributes to the system. A nullptr will reset the range to use the mesh's range.

setCurrentAlgebraicBndNodeRange() sets the boundary node range that contributes to the system. A nullptr will reset the range to use the mesh's range.

Parameters
rangeA pointer to the const range object representing the algebraic elements, nodes, or boundary nodes.

Definition at line 9544 of file FEProblemBase.C.

9545 {
9546  if (!range)
9547  {
9549  return;
9550  }
9551 
9552  _current_algebraic_elem_range = std::make_unique<ConstElemRange>(*range);
9553 }
std::unique_ptr< libMesh::ConstElemRange > _current_algebraic_elem_range

◆ setCurrentAlgebraicNodeRange()

void FEProblemBase::setCurrentAlgebraicNodeRange ( libMesh::ConstNodeRange range)
inherited

Definition at line 9555 of file FEProblemBase.C.

9556 {
9557  if (!range)
9558  {
9560  return;
9561  }
9562 
9563  _current_algebraic_node_range = std::make_unique<ConstNodeRange>(*range);
9564 }
std::unique_ptr< libMesh::ConstNodeRange > _current_algebraic_node_range

◆ setCurrentBoundaryID()

void FEProblemBase::setCurrentBoundaryID ( BoundaryID  bid,
const THREAD_ID  tid 
)
overridevirtualinherited

sets the current boundary ID in assembly

Reimplemented from SubProblem.

Definition at line 9480 of file FEProblemBase.C.

9481 {
9483  if (_displaced_problem)
9484  _displaced_problem->setCurrentBoundaryID(bid, tid);
9485 }
virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid)
sets the current boundary ID in assembly
Definition: SubProblem.C:789
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ setCurrentExecuteOnFlag()

void FEProblemBase::setCurrentExecuteOnFlag ( const ExecFlagType flag)
inherited

Definition at line 4708 of file FEProblemBase.C.

Referenced by FEProblemBase::execute(), FEProblemBase::initialSetup(), and FEProblemBase::outputStep().

4709 {
4710  _current_execute_on_flag = flag;
4711 }
ExecFlagType _current_execute_on_flag
Current execute_on flag.

◆ setCurrentLinearSystem()

void FEProblemBase::setCurrentLinearSystem ( unsigned int  sys_num)
inherited

Set the current linear system pointer.

Parameters
sys_numThe number of linear system

Definition at line 9497 of file FEProblemBase.C.

Referenced by FEProblemBase::computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and FEProblemBase::solveLinearSystem().

9498 {
9499  mooseAssert(sys_num < _linear_systems.size(),
9500  "System number greater than the number of linear systems");
9501  _current_linear_sys = _linear_systems[sys_num].get();
9503 }
LinearSystem * _current_linear_sys
The current linear system that we are solving.
SolverSystem * _current_solver_sys
The current solver system.
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.

◆ setCurrentLowerDElem()

void FEProblemBase::setCurrentLowerDElem ( const Elem *const  lower_d_elem,
const THREAD_ID  tid 
)
overridevirtualinherited

Set the current lower dimensional element.

This can be null

Reimplemented from SubProblem.

Definition at line 9471 of file FEProblemBase.C.

9472 {
9473  SubProblem::setCurrentLowerDElem(lower_d_elem, tid);
9474  if (_displaced_problem)
9475  _displaced_problem->setCurrentLowerDElem(
9476  lower_d_elem ? _displaced_mesh->elemPtr(lower_d_elem->id()) : nullptr, tid);
9477 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3153
virtual void setCurrentLowerDElem(const Elem *const lower_d_elem, const THREAD_ID tid)
Set the current lower dimensional element.
Definition: SubProblem.C:1380
dof_id_type id() const
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseMesh * _displaced_mesh

◆ setCurrentlyComputingJacobian()

void SubProblem::setCurrentlyComputingJacobian ( const bool  currently_computing_jacobian)
inlineinherited

Set whether or not the problem is in the process of computing the Jacobian.

Definition at line 689 of file SubProblem.h.

Referenced by FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

690  {
691  _currently_computing_jacobian = currently_computing_jacobian;
692  }
bool _currently_computing_jacobian
Flag to determine whether the problem is currently computing Jacobian.
Definition: SubProblem.h:1096

◆ setCurrentlyComputingResidual()

void FEProblemBase::setCurrentlyComputingResidual ( bool  currently_computing_residual)
finalvirtualinherited

Set whether or not the problem is in the process of computing the residual.

Reimplemented from SubProblem.

Definition at line 9151 of file FEProblemBase.C.

Referenced by FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualTags(), and FEProblemBase::resetState().

9152 {
9153  if (_displaced_problem)
9154  _displaced_problem->setCurrentlyComputingResidual(currently_computing_residual);
9155  _currently_computing_residual = currently_computing_residual;
9156 }
std::shared_ptr< DisplacedProblem > _displaced_problem
bool _currently_computing_residual
Whether the residual is being evaluated.
Definition: SubProblem.h:1105

◆ setCurrentlyComputingResidualAndJacobian()

void SubProblem::setCurrentlyComputingResidualAndJacobian ( bool  currently_computing_residual_and_jacobian)
inlineinherited

Set whether or not the problem is in the process of computing the Jacobian.

Definition at line 1493 of file SubProblem.h.

Referenced by FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

1495 {
1496  _currently_computing_residual_and_jacobian = currently_computing_residual_and_jacobian;
1497 }
bool _currently_computing_residual_and_jacobian
Flag to determine whether the problem is currently computing the residual and Jacobian.
Definition: SubProblem.h:1099

◆ setCurrentNonlinearSystem()

void FEProblemBase::setCurrentNonlinearSystem ( const unsigned int  nl_sys_num)
inherited

Definition at line 9488 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobian(), EigenProblem::computeJacobianAB(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), EigenProblem::computeJacobianTag(), EigenProblem::computeMatricesTags(), EigenProblem::computeResidualTag(), NonlinearSystemBase::computeResidualTags(), FEProblem::FEProblem(), EigenProblem::solve(), and FEProblemBase::solve().

9489 {
9490  mooseAssert(nl_sys_num < _nl.size(),
9491  "System number greater than the number of nonlinear systems");
9492  _current_nl_sys = _nl[nl_sys_num].get();
9494 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
SolverSystem * _current_solver_sys
The current solver system.

◆ setCurrentResidualVectorTags()

void FEProblemBase::setCurrentResidualVectorTags ( const std::set< TagID > &  vector_tags)
inlineinherited

Set the current residual vector tag data structure based on the passed in tag IDs.

Definition at line 3468 of file FEProblemBase.h.

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and CrankNicolson::init().

3469 {
3471 }
std::vector< VectorTag > _current_residual_vector_tags
A data member to store the residual vector tag(s) passed into computeResidualTag(s).
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Definition: SubProblem.C:172

◆ setCurrentSubdomainID()

void FEProblemBase::setCurrentSubdomainID ( const Elem elem,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 1808 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementalVariableValue::execute(), and ComputeInitialConditionThread::operator()().

1809 {
1810  SubdomainID did = elem->subdomain_id();
1811  for (const auto i : index_range(_solver_systems))
1812  {
1813  _assembly[tid][i]->setCurrentSubdomainID(did);
1814  if (_displaced_problem &&
1816  _displaced_problem->assembly(tid, i).setCurrentSubdomainID(did);
1817  }
1818 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
subdomain_id_type subdomain_id() const
std::shared_ptr< DisplacedProblem > _displaced_problem
auto index_range(const T &sizable)

◆ setDevice()

void MFEMProblem::setDevice ( )

Set the device to use to solve the FE problem.

◆ setErrorOnJacobianNonzeroReallocation()

void FEProblemBase::setErrorOnJacobianNonzeroReallocation ( bool  state)
inlineinherited

Definition at line 2100 of file FEProblemBase.h.

2101  {
2103  }
bool _error_on_jacobian_nonzero_reallocation
Whether to error when the Jacobian is re-allocated, usually because the sparsity pattern changed...

◆ setException()

void FEProblemBase::setException ( const std::string &  message)
virtualinherited

Set an exception, which is stored at this point by toggling a member variable in this class, and which must be followed up with by a call to checkExceptionAndStopSolve().

Parameters
messageThe error message describing the exception, which will get printed when checkExceptionAndStopSolve() is called

Definition at line 6578 of file FEProblemBase.C.

Referenced by ComputeThreadedGeneralUserObjectsThread::caughtMooseException(), ThreadedNodeLoop< ConstBndNodeRange, ConstBndNodeRange::const_iterator >::caughtMooseException(), ThreadedFaceLoop< RangeType >::caughtMooseException(), NonlinearSystemBase::computeDamping(), AuxiliarySystem::computeElementalVarsHelper(), AuxiliarySystem::computeMortarNodalVars(), FEProblemBase::handleException(), ComputeMortarFunctor::operator()(), and DisplacedProblem::updateMesh().

6579 {
6580  _has_exception = true;
6581  _exception_message = message;
6582 }
bool _has_exception
Whether or not an exception has occurred.
std::string _exception_message
The error message to go with an exception.

◆ setExecutionPrinting()

void FEProblemBase::setExecutionPrinting ( const ExecFlagEnum print_exec)
inlineinherited

Definition at line 2573 of file FEProblemBase.h.

2573 { _print_execution_on = print_exec; }
ExecFlagEnum _print_execution_on
When to print the execution of loops.

◆ setFailNextNonlinearConvergenceCheck()

void FEProblemBase::setFailNextNonlinearConvergenceCheck ( )
inlineinherited

Skip further residual evaluations and fail the next nonlinear convergence check(s)

Definition at line 2560 of file FEProblemBase.h.

Referenced by Terminator::execute().

void setFailNextSystemConvergenceCheck()
Tell the problem that the system(s) cannot be considered converged next time convergence is checked...

◆ setFailNextSystemConvergenceCheck()

void FEProblemBase::setFailNextSystemConvergenceCheck ( )
inlineinherited

Tell the problem that the system(s) cannot be considered converged next time convergence is checked.

Definition at line 2562 of file FEProblemBase.h.

Referenced by FEProblemBase::setFailNextNonlinearConvergenceCheck().

bool _fail_next_system_convergence_check

◆ setFunctorOutput()

void SubProblem::setFunctorOutput ( bool  set_output)
inlineinherited

Setter for debug functor output.

Definition at line 924 of file SubProblem.h.

924 { _output_functors = set_output; }
bool _output_functors
Whether to output a list of the functors used and requested (currently only at initialSetup) ...
Definition: SubProblem.h:1164

◆ setIgnoreZerosInJacobian()

void FEProblemBase::setIgnoreZerosInJacobian ( bool  state)
inlineinherited

Set whether the zeros in the Jacobian should be dropped from the sparsity pattern.

Definition at line 2123 of file FEProblemBase.h.

2123 { _ignore_zeros_in_jacobian = state; }
bool _ignore_zeros_in_jacobian
Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.

◆ setInputParametersFEProblem()

virtual void FEProblemBase::setInputParametersFEProblem ( InputParameters parameters)
inlinevirtualinherited

Reimplemented in FEProblem.

Definition at line 902 of file FEProblemBase.h.

Referenced by FEProblem::setInputParametersFEProblem().

903  {
904  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
905  }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.

◆ setKernelCoverageCheck() [1/2]

void FEProblemBase::setKernelCoverageCheck ( CoverageCheckMode  mode)
inlineinherited

Set flag to indicate whether kernel coverage checks should be performed.

This check makes sure that at least one kernel is active on all subdomains in the domain (default: true).

Definition at line 1943 of file FEProblemBase.h.

1943 { _kernel_coverage_check = mode; }
CoverageCheckMode _kernel_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active kernel...

◆ setKernelCoverageCheck() [2/2]

void FEProblemBase::setKernelCoverageCheck ( bool  flag)
inlineinherited

Set flag to indicate whether kernel coverage checks should be performed.

This check makes sure that at least one kernel is active on all subdomains in the domain (default: true).

Definition at line 1949 of file FEProblemBase.h.

1950  {
1952  }
CoverageCheckMode _kernel_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active kernel...

◆ setLinearConvergenceNames()

void FEProblemBase::setLinearConvergenceNames ( const std::vector< ConvergenceName > &  convergence_names)
inherited

Sets the linear convergence object name(s) if there is one.

Definition at line 9315 of file FEProblemBase.C.

Referenced by FEProblemSolve::FEProblemSolve().

9316 {
9317  if (convergence_names.size() != numLinearSystems())
9318  paramError("linear_convergence", "There must be one convergence object per linear system");
9319  _linear_convergence_names = convergence_names;
9320 }
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition: MooseBase.h:439
std::optional< std::vector< ConvergenceName > > _linear_convergence_names
Linear system(s) convergence name(s) (if any)
virtual std::size_t numLinearSystems() const override

◆ setMaterialCoverageCheck() [1/2]

void FEProblemBase::setMaterialCoverageCheck ( CoverageCheckMode  mode)
inlineinherited

Set flag to indicate whether material coverage checks should be performed.

This check makes sure that at least one material is active on all subdomains in the domain if any material is supplied. If no materials are supplied anywhere, a simulation is still considered OK as long as no properties are being requested anywhere.

Definition at line 1960 of file FEProblemBase.h.

1960 { _material_coverage_check = mode; }
CoverageCheckMode _material_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active material...

◆ setMaterialCoverageCheck() [2/2]

void FEProblemBase::setMaterialCoverageCheck ( bool  flag)
inlineinherited

Set flag to indicate whether material coverage checks should be performed.

This check makes sure that at least one material is active on all subdomains in the domain if any material is supplied. If no materials are supplied anywhere, a simulation is still considered OK as long as no properties are being requested anywhere.

Definition at line 1968 of file FEProblemBase.h.

1969  {
1971  }
CoverageCheckMode _material_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active material...

◆ setMesh()

void MFEMProblem::setMesh ( )

Set the mesh used by MFEM.

Definition at line 48 of file MFEMProblem.C.

Referenced by MFEMProblem().

49 {
50  auto pmesh = mesh().getMFEMParMeshPtr();
51  getProblemData().pmesh = pmesh;
52  getProblemData().comm = pmesh->GetComm();
53  MPI_Comm_size(pmesh->GetComm(), &(getProblemData().num_procs));
54  MPI_Comm_rank(pmesh->GetComm(), &(getProblemData().myid));
55 }
std::shared_ptr< mfem::ParMesh > pmesh
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
virtual MFEMMesh & mesh() override
Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMes...
Definition: MFEMProblem.C:465
std::shared_ptr< mfem::ParMesh > getMFEMParMeshPtr()
Copy a shared_ptr to the mfem::ParMesh object.
Definition: MFEMMesh.h:42

◆ setMultiAppFixedPointConvergenceName()

void FEProblemBase::setMultiAppFixedPointConvergenceName ( const ConvergenceName &  convergence_name)
inherited

Sets the MultiApp fixed point convergence object name if there is one.

Definition at line 9287 of file FEProblemBase.C.

Referenced by FixedPointSolve::FixedPointSolve().

9288 {
9289  _multiapp_fixed_point_convergence_name = convergence_name;
9290 }
std::optional< ConvergenceName > _multiapp_fixed_point_convergence_name
MultiApp fixed point convergence name.

◆ setNeedToAddDefaultMultiAppFixedPointConvergence()

void FEProblemBase::setNeedToAddDefaultMultiAppFixedPointConvergence ( )
inlineinherited

Sets _need_to_add_default_multiapp_fixed_point_convergence to true.

Definition at line 681 of file FEProblemBase.h.

Referenced by FixedPointSolve::FixedPointSolve().

682  {
684  }
bool _need_to_add_default_multiapp_fixed_point_convergence
Flag that the problem needs to add the default fixed point convergence.

◆ setNeedToAddDefaultNonlinearConvergence()

void FEProblemBase::setNeedToAddDefaultNonlinearConvergence ( )
inlineinherited

Sets _need_to_add_default_nonlinear_convergence to true.

Definition at line 676 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

677  {
679  }
bool _need_to_add_default_nonlinear_convergence
Flag that the problem needs to add the default nonlinear convergence.

◆ setNeedToAddDefaultSteadyStateConvergence()

void FEProblemBase::setNeedToAddDefaultSteadyStateConvergence ( )
inlineinherited

Sets _need_to_add_default_steady_state_convergence to true.

Definition at line 686 of file FEProblemBase.h.

Referenced by TransientBase::TransientBase().

687  {
689  }
bool _need_to_add_default_steady_state_convergence
Flag that the problem needs to add the default steady convergence.

◆ setNeighborSubdomainID() [1/2]

virtual void FEProblemBase::setNeighborSubdomainID ( const Elem *  elem,
unsigned int  side,
const THREAD_ID  tid 
)
overridevirtualinherited

◆ setNeighborSubdomainID() [2/2]

virtual void FEProblemBase::setNeighborSubdomainID ( const Elem *  elem,
const THREAD_ID  tid 
)
virtualinherited

◆ setNonlinearConvergenceNames()

void FEProblemBase::setNonlinearConvergenceNames ( const std::vector< ConvergenceName > &  convergence_names)
inherited

Sets the nonlinear convergence object name(s) if there is one.

Definition at line 9278 of file FEProblemBase.C.

Referenced by FEProblemSolve::FEProblemSolve().

9279 {
9280  if (convergence_names.size() != numNonlinearSystems())
9281  paramError("nonlinear_convergence",
9282  "There must be one convergence object per nonlinear system");
9283  _nonlinear_convergence_names = convergence_names;
9284 }
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition: MooseBase.h:439
virtual std::size_t numNonlinearSystems() const override
std::optional< std::vector< ConvergenceName > > _nonlinear_convergence_names
Nonlinear system(s) convergence name(s)

◆ setNonlocalCouplingMatrix()

void FEProblemBase::setNonlocalCouplingMatrix ( )
inherited

Set custom coupling matrix for variables requiring nonlocal contribution.

Definition at line 6245 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

6246 {
6247  TIME_SECTION("setNonlocalCouplingMatrix", 5, "Setting Nonlocal Coupling Matrix");
6248 
6249  if (_nl.size() > 1)
6250  mooseError("Nonlocal kernels are weirdly stored on the FEProblem so we don't currently support "
6251  "multiple nonlinear systems with nonlocal kernels.");
6252 
6253  for (const auto nl_sys_num : index_range(_nl))
6254  {
6255  auto & nl = _nl[nl_sys_num];
6256  auto & nonlocal_cm = _nonlocal_cm[nl_sys_num];
6257  unsigned int n_vars = nl->nVariables();
6258  nonlocal_cm.resize(n_vars);
6259  const auto & vars = nl->getVariables(0);
6260  const auto & nonlocal_kernel = _nonlocal_kernels.getObjects();
6261  const auto & nonlocal_integrated_bc = _nonlocal_integrated_bcs.getObjects();
6262  for (const auto & ivar : vars)
6263  {
6264  for (const auto & kernel : nonlocal_kernel)
6265  {
6266  for (unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
6267  if (i == kernel->variable().number())
6268  for (const auto & jvar : vars)
6269  {
6270  const auto it = _var_dof_map.find(jvar->name());
6271  if (it != _var_dof_map.end())
6272  {
6273  unsigned int j = jvar->number();
6274  nonlocal_cm(i, j) = 1;
6275  }
6276  }
6277  }
6278  for (const auto & integrated_bc : nonlocal_integrated_bc)
6279  {
6280  for (unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
6281  if (i == integrated_bc->variable().number())
6282  for (const auto & jvar : vars)
6283  {
6284  const auto it = _var_dof_map.find(jvar->name());
6285  if (it != _var_dof_map.end())
6286  {
6287  unsigned int j = jvar->number();
6288  nonlocal_cm(i, j) = 1;
6289  }
6290  }
6291  }
6292  }
6293  }
6294 }
char ** vars
std::map< std::string, std::vector< dof_id_type > > _var_dof_map
Definition: SubProblem.h:674
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
const std::vector< std::shared_ptr< T > > & getObjects(THREAD_ID tid=0) const
Retrieve complete vector to the all/block/boundary restricted objects for a given thread...
unsigned int n_vars
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
std::vector< libMesh::CouplingMatrix > _nonlocal_cm
nonlocal coupling matrix
auto index_range(const T &sizable)
MooseObjectWarehouse< IntegratedBCBase > _nonlocal_integrated_bcs
nonlocal integrated_bcs
MooseObjectWarehouse< KernelBase > _nonlocal_kernels
nonlocal kernels

◆ setParallelBarrierMessaging()

void FEProblemBase::setParallelBarrierMessaging ( bool  flag)
inlineinherited

Toggle parallel barrier messaging (defaults to on).

Definition at line 1976 of file FEProblemBase.h.

1976 { _parallel_barrier_messaging = flag; }
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.

◆ setPostprocessorValueByName()

void FEProblemBase::setPostprocessorValueByName ( const PostprocessorName &  name,
const PostprocessorValue value,
std::size_t  t_index = 0 
)
inherited

Set the value of a PostprocessorValue.

Parameters
nameThe name of the post-processor
t_indexFlag for getting current (0), old (1), or older (2) values
Returns
The reference to the value at the given time index

Note: This method is only for setting values that already exist, the Postprocessor and PostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

WARNING! This method should be used with caution. It exists to allow Transfers and other similar objects to modify Postprocessor values. It is not intended for general use.

Definition at line 4566 of file FEProblemBase.C.

Referenced by MultiAppPostprocessorTransfer::execute(), PIDTransientControl::execute(), FEProblemBase::joinAndFinalize(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), and PicardSolve::transformPostprocessors().

4569 {
4571  PostprocessorReporterName(name), value, t_index);
4572 }
ReporterData _reporter_data
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
Real PostprocessorValue
various MOOSE typedefs
Definition: MooseTypes.h:202
void setReporterValue(const ReporterName &reporter_name, const T &value, const std::size_t time_index=0)
Method for setting Reporter values that already exist.
Definition: ReporterData.h:481
A ReporterName that represents a Postprocessor.
Definition: ReporterName.h:143

◆ setPreserveMatrixSparsityPattern()

void FEProblemBase::setPreserveMatrixSparsityPattern ( bool  preserve)
inherited

Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian) should be preserved.

This global setting can be retrieved by kernels, notably those using AD, to decide whether to take additional care to preserve the sparsity pattern

Definition at line 3928 of file FEProblemBase.C.

3929 {
3930  if (_ignore_zeros_in_jacobian && preserve)
3931  paramWarning(
3932  "ignore_zeros_in_jacobian",
3933  "We likely cannot preserve the sparsity pattern if ignoring zeros in the Jacobian, which "
3934  "leads to removing those entries from the Jacobian sparsity pattern");
3936 }
bool _ignore_zeros_in_jacobian
Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.
bool _preserve_matrix_sparsity_pattern
Whether to preserve the system matrix / Jacobian sparsity pattern, using 0-valued entries usually...
void paramWarning(const std::string &param, Args... args) const
Emits a warning prefixed with the file and line number of the given param (from the input file) along...
Definition: MooseBase.h:446

◆ setResidual() [1/2]

virtual void SubProblem::setResidual ( libMesh::NumericVector< libMesh::Number > &  residual,
const THREAD_ID  tid 
)
pure virtualinherited

◆ setResidual() [2/2]

void FEProblemBase::setResidual ( NumericVector< libMesh::Number > &  residual,
const THREAD_ID  tid 
)
overridevirtualinherited

Definition at line 1942 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals().

1943 {
1944  _assembly[tid][_current_nl_sys->number()]->setResidual(
1945  residual,
1947  getVectorTag(_nl[_current_nl_sys->number()]->residualVectorTag()));
1948  if (_displaced_problem)
1949  _displaced_problem->setResidual(residual, tid);
1950 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
Definition: SubProblem.C:161
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ setResidualNeighbor() [1/2]

virtual void SubProblem::setResidualNeighbor ( libMesh::NumericVector< libMesh::Number > &  residual,
const THREAD_ID  tid 
)
pure virtualinherited

◆ setResidualNeighbor() [2/2]

void FEProblemBase::setResidualNeighbor ( NumericVector< libMesh::Number > &  residual,
const THREAD_ID  tid 
)
overridevirtualinherited

Definition at line 1953 of file FEProblemBase.C.

1954 {
1955  _assembly[tid][_current_nl_sys->number()]->setResidualNeighbor(
1957  if (_displaced_problem)
1958  _displaced_problem->setResidualNeighbor(residual, tid);
1959 }
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
unsigned int number() const
Gets the number of this system.
Definition: SystemBase.C:1157
TagID residualVectorTag() const override
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
Definition: SubProblem.C:161
Key structure for APIs manipulating global vectors/matrices.
Definition: Assembly.h:844

◆ setRestartFile()

void FEProblemBase::setRestartFile ( const std::string &  file_name)
inherited

Communicate to the Resurector the name of the restart filer.

Parameters
file_nameThe file name for restarting from

Definition at line 8798 of file FEProblemBase.C.

Referenced by Executioner::Executioner(), and FEProblemBase::FEProblemBase().

8799 {
8800  if (_app.isRecovering())
8801  {
8802  mooseInfo("Restart file ", file_name, " is NOT being used since we are performing recovery.");
8803  }
8804  else
8805  {
8806  _app.setRestart(true);
8807  _app.setRestartRecoverFileBase(file_name);
8808  mooseInfo("Using ", file_name, " for restart.");
8809  }
8810 }
void mooseInfo(Args &&... args) const
Definition: MooseBase.h:321
void setRestartRecoverFileBase(const std::string &file_base)
mutator for recover_base (set by RecoverBaseAction)
Definition: MooseApp.h:506
void setRestart(bool value)
Sets the restart/recover flags.
Definition: MooseApp.C:2950
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
bool isRecovering() const
Whether or not this is a "recover" calculation.
Definition: MooseApp.C:1839

◆ setSNESMFReuseBase()

void FEProblemBase::setSNESMFReuseBase ( bool  reuse,
bool  set_by_user 
)
inlineinherited

If or not to reuse the base vector for matrix-free calculation.

Definition at line 2262 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

2263  {
2264  _snesmf_reuse_base = reuse, _snesmf_reuse_base_set_by_user = set_by_user;
2265  }
bool _snesmf_reuse_base_set_by_user
If or not _snesmf_reuse_base is set by user.
bool _snesmf_reuse_base
If or not to resuse the base vector for matrix-free calculation.

◆ setSteadyStateConvergenceName()

void FEProblemBase::setSteadyStateConvergenceName ( const ConvergenceName &  convergence_name)
inherited

Sets the steady-state detection convergence object name if there is one.

Definition at line 9293 of file FEProblemBase.C.

Referenced by TransientBase::TransientBase().

9294 {
9295  _steady_state_convergence_name = convergence_name;
9296 }
std::optional< ConvergenceName > _steady_state_convergence_name
Steady-state detection convergence name.

◆ setUDotDotOldRequested()

virtual void FEProblemBase::setUDotDotOldRequested ( const bool  u_dotdot_old_requested)
inlinevirtualinherited

Set boolean flag to true to store old solution second time derivative.

Definition at line 2310 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

2311  {
2312  _u_dotdot_old_requested = u_dotdot_old_requested;
2313  }
bool _u_dotdot_old_requested
Whether old solution second time derivative needs to be stored.

◆ setUDotDotRequested()

virtual void FEProblemBase::setUDotDotRequested ( const bool  u_dotdot_requested)
inlinevirtualinherited

Set boolean flag to true to store solution second time derivative.

Definition at line 2298 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

2299  {
2300  _u_dotdot_requested = u_dotdot_requested;
2301  }
bool _u_dotdot_requested
Whether solution second time derivative needs to be stored.

◆ setUDotOldRequested()

virtual void FEProblemBase::setUDotOldRequested ( const bool  u_dot_old_requested)
inlinevirtualinherited

Set boolean flag to true to store old solution time derivative.

Definition at line 2304 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

2305  {
2306  _u_dot_old_requested = u_dot_old_requested;
2307  }
bool _u_dot_old_requested
Whether old solution time derivative needs to be stored.

◆ setUDotRequested()

virtual void FEProblemBase::setUDotRequested ( const bool  u_dot_requested)
inlinevirtualinherited

Set boolean flag to true to store solution time derivative.

Definition at line 2295 of file FEProblemBase.h.

Referenced by TimeIntegrator::TimeIntegrator().

2295 { _u_dot_requested = u_dot_requested; }
bool _u_dot_requested
Whether solution time derivative needs to be stored.

◆ setupDampers()

void FEProblemBase::setupDampers ( )
inherited

Definition at line 5314 of file FEProblemBase.C.

5315 {
5316  for (auto & nl : _nl)
5317  nl->setupDampers();
5318 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ setVariableAllDoFMap()

void FEProblemBase::setVariableAllDoFMap ( const std::vector< const MooseVariableFEBase *> &  moose_vars)
inherited

Definition at line 1716 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), and FEProblemBase::meshChanged().

1717 {
1718  for (unsigned int i = 0; i < moose_vars.size(); ++i)
1719  {
1720  VariableName var_name = moose_vars[i]->name();
1721  auto & sys = _solver_systems[moose_vars[i]->sys().number()];
1722  sys->setVariableGlobalDoFs(var_name);
1723  _var_dof_map[var_name] = sys->getVariableGlobalDoFs();
1724  }
1725 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::map< std::string, std::vector< dof_id_type > > _var_dof_map
Definition: SubProblem.h:674

◆ setVectorPostprocessorValueByName()

void FEProblemBase::setVectorPostprocessorValueByName ( const std::string &  object_name,
const std::string &  vector_name,
const VectorPostprocessorValue value,
std::size_t  t_index = 0 
)
inherited

Set the value of a VectorPostprocessor vector.

Parameters
object_nameThe name of the VPP object
vector_nameThe name of the declared vector
valueThe data to apply to the vector
t_indexFlag for getting current (0), old (1), or older (2) values

Definition at line 4592 of file FEProblemBase.C.

4596 {
4598  VectorPostprocessorReporterName(object_name, vector_name), value, t_index);
4599 }
A ReporterName that represents a VectorPostprocessor.
Definition: ReporterName.h:152
ReporterData _reporter_data
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
void setReporterValue(const ReporterName &reporter_name, const T &value, const std::size_t time_index=0)
Method for setting Reporter values that already exist.
Definition: ReporterData.h:481
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:203

◆ setVerboseProblem()

void FEProblemBase::setVerboseProblem ( bool  verbose)
inherited

Make the problem be verbose.

Definition at line 9463 of file FEProblemBase.C.

Referenced by Executioner::Executioner(), and PhysicsBase::initializePhysics().

9464 {
9465  _verbose_setup = verbose ? "true" : "false";
9466  _verbose_multiapps = verbose;
9467  _verbose_restore = verbose;
9468 }
bool _verbose_restore
Whether or not to be verbose on solution restoration post a failed time step.
MooseEnum _verbose_setup
Whether or not to be verbose during setup.
bool _verbose_multiapps
Whether or not to be verbose with multiapps.

◆ shouldPrintExecution()

bool FEProblemBase::shouldPrintExecution ( const THREAD_ID  tid) const
inherited

Check whether the problem should output execution orders at this time.

Definition at line 9405 of file FEProblemBase.C.

Referenced by FEProblemBase::joinAndFinalize(), ComputeMarkerThread::printBlockExecutionInformation(), ComputeDiracThread::printBlockExecutionInformation(), ComputeIndicatorThread::printBlockExecutionInformation(), ComputeUserObjectsThread::printBlockExecutionInformation(), ComputeLinearFVElementalThread::printBlockExecutionInformation(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), NonlinearThread::printBlockExecutionInformation(), NonlinearThread::printBoundaryExecutionInformation(), ComputeFVInitialConditionThread::printGeneralExecutionInformation(), ComputeInitialConditionThread::printGeneralExecutionInformation(), ComputeNodalUserObjectsThread::printGeneralExecutionInformation(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), ComputeElemDampingThread::printGeneralExecutionInformation(), ComputeNodalKernelsThread::printGeneralExecutionInformation(), ComputeNodalDampingThread::printGeneralExecutionInformation(), ComputeMarkerThread::printGeneralExecutionInformation(), ComputeDiracThread::printGeneralExecutionInformation(), ComputeIndicatorThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), ComputeThreadedGeneralUserObjectsThread::printGeneralExecutionInformation(), ComputeUserObjectsThread::printGeneralExecutionInformation(), ComputeLinearFVElementalThread::printGeneralExecutionInformation(), ComputeLinearFVFaceThread::printGeneralExecutionInformation(), and NonlinearThread::printGeneralExecutionInformation().

9406 {
9407  // For now, only support printing from thread 0
9408  if (tid != 0)
9409  return false;
9410 
9413  return true;
9414  else
9415  return false;
9416 }
ExecFlagType _current_execute_on_flag
Current execute_on flag.
const ExecFlagType EXEC_ALWAYS
Definition: Moose.C:51
ExecFlagEnum _print_execution_on
When to print the execution of loops.
bool isValueSet(const std::string &value) const
Methods for seeing if a value is set in the MultiMooseEnum.

◆ shouldSolve()

bool FEProblemBase::shouldSolve ( ) const
inlineinherited

Definition at line 2346 of file FEProblemBase.h.

Referenced by FEProblemSolve::solve(), MFEMProblemSolve::solve(), and TransientBase::TransientBase().

2346 { return _solve; }
const bool & _solve
Whether or not to actually solve the nonlinear system.

◆ shouldUpdateSolution()

bool FEProblemBase::shouldUpdateSolution ( )
virtualinherited

Check to see whether the problem should update the solution.

Returns
true if the problem should update the solution, false otherwise

Definition at line 7912 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck(), and NonlinearSystem::solve().

7913 {
7914  return false;
7915 }

◆ showInvalidSolutionConsole()

bool FEProblemBase::showInvalidSolutionConsole ( ) const
inlineinherited

Whether or not to print out the invalid solutions summary table in console.

Definition at line 2140 of file FEProblemBase.h.

Referenced by SolverSystem::checkInvalidSolution().

const bool _show_invalid_solution_console

◆ sizeZeroes()

void FEProblemBase::sizeZeroes ( unsigned int  size,
const THREAD_ID  tid 
)
virtualinherited

Definition at line 2144 of file FEProblemBase.C.

2145 {
2146  mooseDoOnce(mooseWarning(
2147  "This function is deprecated and no longer performs any function. Please do not call it."));
2148 }
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:299

◆ skipExceptionCheck()

void FEProblemBase::skipExceptionCheck ( bool  skip_exception_check)
inlineinherited

Set a flag that indicates if we want to skip exception and stop solve.

Definition at line 2275 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

2276  {
2277  _skip_exception_check = skip_exception_check;
2278  }
bool _skip_exception_check
If or not skip &#39;exception and stop solve&#39;.

◆ solve()

void ExternalProblem::solve ( unsigned int  nl_sys_num = 0)
finaloverridevirtualinherited

Solve is implemented to providing syncing to/from the "transfer" mesh.

Reimplemented from FEProblemBase.

Definition at line 61 of file ExternalProblem.C.

62 {
63  TIME_SECTION("solve", 1, "Solving", false)
64 
65  syncSolutions(Direction::TO_EXTERNAL_APP);
66  externalSolve();
67  syncSolutions(Direction::FROM_EXTERNAL_APP);
68 }
virtual void syncSolutions(Direction direction)=0
Method to transfer data to/from the external application to the associated transfer mesh...
virtual void externalSolve()=0
New interface for solving an External problem.

◆ solveLinearSystem()

void FEProblemBase::solveLinearSystem ( const unsigned int  linear_sys_num,
const Moose::PetscSupport::PetscOptions po = nullptr 
)
virtualinherited

Build and solve a linear system.

Parameters
linear_sys_numThe number of the linear system (1,..,num. of lin. systems)
poThe petsc options for the solve, if not supplied, the defaults are used

Reimplemented in DumpObjectsProblem.

Definition at line 6674 of file FEProblemBase.C.

Referenced by FEProblemSolve::solve().

6676 {
6677  TIME_SECTION("solve", 1, "Solving", false);
6678 
6679  setCurrentLinearSystem(linear_sys_num);
6680 
6681  const Moose::PetscSupport::PetscOptions & options = po ? *po : _petsc_options;
6682  auto & solver_params = _solver_params[numNonlinearSystems() + linear_sys_num];
6683 
6684  // Set custom convergence criteria
6686 
6687 #if PETSC_RELEASE_LESS_THAN(3, 12, 0)
6688  LibmeshPetscCall(Moose::PetscSupport::petscSetOptions(
6689  options, solver_params)); // Make sure the PETSc options are setup for this app
6690 #else
6691  // Now this database will be the default
6692  // Each app should have only one database
6693  if (!_app.isUltimateMaster())
6694  LibmeshPetscCall(PetscOptionsPush(_petsc_option_data_base));
6695 
6696  // We did not add PETSc options to database yet
6698  {
6699  Moose::PetscSupport::petscSetOptions(options, solver_params, this);
6701  }
6702 #endif
6703 
6704  if (_solve)
6706 
6707 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
6708  if (!_app.isUltimateMaster())
6709  LibmeshPetscCall(PetscOptionsPop());
6710 #endif
6711 }
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:820
virtual std::size_t numNonlinearSystems() const override
void petscSetDefaults(FEProblemBase &problem)
Sets the default options for PETSc.
Definition: PetscSupport.C:450
std::vector< SolverParams > _solver_params
bool _is_petsc_options_inserted
If or not PETSc options have been added to database.
A struct for storing the various types of petsc options and values.
Definition: PetscSupport.h:44
PetscOptions _petsc_option_data_base
const bool & _solve
Whether or not to actually solve the nonlinear system.
LinearSystem * _current_linear_sys
The current linear system that we are solving.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
virtual void solve() override
Solve the system (using libMesh magic)
Definition: LinearSystem.C:299
void petscSetOptions(const PetscOptions &po, const SolverParams &solver_params, FEProblemBase *const problem=nullptr)
A function for setting the PETSc options in PETSc from the options supplied to MOOSE.
Definition: PetscSupport.C:230
void setCurrentLinearSystem(unsigned int sys_num)
Set the current linear system pointer.
Moose::PetscSupport::PetscOptions _petsc_options
PETSc option storage.

◆ solverParams() [1/2]

SolverParams & FEProblemBase::solverParams ( unsigned int  solver_sys_num = 0)
inherited

Get the solver parameters.

Definition at line 8830 of file FEProblemBase.C.

Referenced by NonlinearEigenSystem::attachPreconditioner(), SolverSystem::compute(), SlepcEigenSolverConfiguration::configure_solver(), Eigenvalue::Eigenvalue(), ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), ExplicitTimeIntegrator::init(), EigenProblem::init(), FEProblemBase::init(), EigenProblem::isNonlinearEigenvalueSolver(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionA(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionB(), Moose::SlepcSupport::mooseSlepcEigenFormJacobianA(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), ConsoleUtils::outputExecutionInformation(), Moose::PetscSupport::petscSetDefaults(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), Eigenvalue::prepareSolverOptions(), NonlinearSystem::residualAndJacobianTogether(), Moose::SlepcSupport::setEigenProblemSolverParams(), Moose::PetscSupport::setLineSearchFromParams(), Moose::PetscSupport::setMFFDTypeFromParams(), Moose::PetscSupport::setSinglePetscOption(), Moose::PetscSupport::setSolveTypeFromParams(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), EigenProblem::solve(), FEProblemBase::solverParams(), EigenProblem::solverTypeString(), FEProblemBase::solverTypeString(), and Moose::SlepcSupport::storeSolveType().

8831 {
8832  mooseAssert(solver_sys_num < numSolverSystems(),
8833  "Solver system number '" << solver_sys_num << "' is out of bounds. We have '"
8834  << numSolverSystems() << "' solver systems");
8835  return _solver_params[solver_sys_num];
8836 }
std::vector< SolverParams > _solver_params
virtual std::size_t numSolverSystems() const override

◆ solverParams() [2/2]

const SolverParams & FEProblemBase::solverParams ( unsigned int  solver_sys_num = 0) const
inherited

const version

Definition at line 8839 of file FEProblemBase.C.

8840 {
8841  return const_cast<FEProblemBase *>(this)->solverParams(solver_sys_num);
8842 }
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.

◆ solverSysNum()

unsigned int FEProblemBase::solverSysNum ( const SolverSystemName &  solver_sys_name) const
overridevirtualinherited
Returns
the solver system number corresponding to the provided solver_sys_name

Implements SubProblem.

Definition at line 6481 of file FEProblemBase.C.

Referenced by FEProblemBase::addVariable(), FEProblemBase::getSystemBase(), MultiSystemSolveObject::MultiSystemSolveObject(), and DisplacedProblem::solverSysNum().

6482 {
6483  std::istringstream ss(solver_sys_name);
6484  unsigned int solver_sys_num;
6485  if (!(ss >> solver_sys_num) || !ss.eof())
6486  {
6487  const auto & search = _solver_sys_name_to_num.find(solver_sys_name);
6488  if (search == _solver_sys_name_to_num.end())
6489  mooseError("The solver system number was requested for system '" + solver_sys_name,
6490  "' but this system does not exist in the Problem. Systems can be added to the "
6491  "problem using the 'nl_sys_names'/'linear_sys_names' parameter.\nSystems in the "
6492  "Problem: " +
6494  solver_sys_num = search->second;
6495  }
6496 
6497  return solver_sys_num;
6498 }
std::map< SolverSystemName, unsigned int > _solver_sys_name_to_num
Map connecting solver system names with their respective systems.
std::vector< SolverSystemName > _solver_sys_names
The union of nonlinear and linear system names.
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
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

◆ solverSystemConverged()

bool FEProblemBase::solverSystemConverged ( const unsigned int  sys_num)
overridevirtualinherited
Returns
whether the given solver system sys_num is converged

Reimplemented from SubProblem.

Reimplemented in EigenProblem.

Definition at line 6714 of file FEProblemBase.C.

6715 {
6716  if (_solve)
6717  return _solver_systems[sys_num]->converged();
6718  else
6719  return true;
6720 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
const bool & _solve
Whether or not to actually solve the nonlinear system.

◆ solverTypeString()

std::string MFEMProblem::solverTypeString ( unsigned int  solver_sys_num)
overridevirtual

Return solver type as a human readable string.

Reimplemented from FEProblemBase.

Definition at line 517 of file MFEMProblem.C.

518 {
519  mooseAssert(solver_sys_num == 0, "No support for multi-system with MFEM right now");
520  return MooseUtils::prettyCppType(getProblemData().jacobian_solver.get());
521 }
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem...
Definition: MFEMProblem.h:186
std::string prettyCppType(const std::string &cpp_type)
Definition: MooseUtils.C:1147

◆ startedInitialSetup()

virtual bool FEProblemBase::startedInitialSetup ( )
inlinevirtualinherited

Returns true if we are in or beyond the initialSetup stage.

Definition at line 533 of file FEProblemBase.h.

Referenced by NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), and MaterialPropertyInterface::checkExecutionStage().

533 { return _started_initial_setup; }
bool _started_initial_setup
At or beyond initialSteup stage.

◆ storeBoundaryDelayedCheckMatProp()

void SubProblem::storeBoundaryDelayedCheckMatProp ( const std::string &  requestor,
BoundaryID  boundary_id,
const std::string &  name 
)
virtualinherited

Adds to a map based on boundary ids of material properties to validate.

Parameters
requestorThe MOOSE object name requesting the material property
boundary_idThe block id for the MaterialProperty
nameThe name of the property

Definition at line 615 of file SubProblem.C.

Referenced by MaterialPropertyInterface::checkMaterialProperty().

618 {
619  _map_boundary_material_props_check[boundary_id].insert(std::make_pair(requestor, name));
620 }
std::map< BoundaryID, std::multimap< std::string, std::string > > _map_boundary_material_props_check
Definition: SubProblem.h:1071
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ storeBoundaryMatPropName()

void SubProblem::storeBoundaryMatPropName ( BoundaryID  boundary_id,
const std::string &  name 
)
virtualinherited

Adds the given material property to a storage map based on boundary ids.

This is method is called from within the Material class when the property is first registered.

Parameters
boundary_idThe block id for the MaterialProperty
nameThe name of the property

Definition at line 589 of file SubProblem.C.

Referenced by MaterialBase::registerPropName().

590 {
591  _map_boundary_material_props[boundary_id].insert(name);
592 }
std::map< BoundaryID, std::set< std::string > > _map_boundary_material_props
Map for boundary material properties (boundary_id -> list of properties)
Definition: SubProblem.h:1055
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ storeBoundaryZeroMatProp()

void SubProblem::storeBoundaryZeroMatProp ( BoundaryID  boundary_id,
const MaterialPropertyName &  name 
)
virtualinherited

Adds to a map based on boundary ids of material properties for which a zero value can be returned.

Thes properties are optional and will not trigger a missing material property error.

Parameters
boundary_idThe block id for the MaterialProperty
nameThe name of the property

Definition at line 601 of file SubProblem.C.

Referenced by MaterialBase::storeBoundaryZeroMatProp().

602 {
603  _zero_boundary_material_props[boundary_id].insert(name);
604 }
std::map< BoundaryID, std::set< MaterialPropertyName > > _zero_boundary_material_props
Definition: SubProblem.h:1059
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ storeSubdomainDelayedCheckMatProp()

void SubProblem::storeSubdomainDelayedCheckMatProp ( const std::string &  requestor,
SubdomainID  block_id,
const std::string &  name 
)
virtualinherited

Adds to a map based on block ids of material properties to validate.

Parameters
block_idThe block id for the MaterialProperty
nameThe name of the property

Definition at line 607 of file SubProblem.C.

Referenced by MaterialPropertyInterface::checkMaterialProperty().

610 {
611  _map_block_material_props_check[block_id].insert(std::make_pair(requestor, name));
612 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::map< SubdomainID, std::multimap< std::string, std::string > > _map_block_material_props_check
Data structures of the requested material properties.
Definition: SubProblem.h:1070

◆ storeSubdomainMatPropName()

void SubProblem::storeSubdomainMatPropName ( SubdomainID  block_id,
const std::string &  name 
)
virtualinherited

Adds the given material property to a storage map based on block ids.

This is method is called from within the Material class when the property is first registered.

Parameters
block_idThe block id for the MaterialProperty
nameThe name of the property

Definition at line 583 of file SubProblem.C.

Referenced by MaterialBase::registerPropName().

584 {
585  _map_block_material_props[block_id].insert(name);
586 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::map< SubdomainID, std::set< std::string > > _map_block_material_props
Map of material properties (block_id -> list of properties)
Definition: SubProblem.h:1052

◆ storeSubdomainZeroMatProp()

void SubProblem::storeSubdomainZeroMatProp ( SubdomainID  block_id,
const MaterialPropertyName &  name 
)
virtualinherited

Adds to a map based on block ids of material properties for which a zero value can be returned.

Thes properties are optional and will not trigger a missing material property error.

Parameters
block_idThe block id for the MaterialProperty
nameThe name of the property

Definition at line 595 of file SubProblem.C.

Referenced by MaterialBase::storeSubdomainZeroMatProp().

596 {
597  _zero_block_material_props[block_id].insert(name);
598 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::map< SubdomainID, std::set< MaterialPropertyName > > _zero_block_material_props
Set of properties returned as zero properties.
Definition: SubProblem.h:1058

◆ subdomainSetup()

void FEProblemBase::subdomainSetup ( SubdomainID  subdomain,
const THREAD_ID  tid 
)
virtualinherited

Definition at line 2507 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeDiracThread::subdomainChanged(), NonlinearThread::subdomainChanged(), ComputeUserObjectsThread::subdomainChanged(), and ThreadedFaceLoop< RangeType >::subdomainChanged().

2508 {
2509  _all_materials.subdomainSetup(subdomain, tid);
2510  // Call the subdomain methods of the output system, these are not threaded so only call it once
2511  if (tid == 0)
2513 
2514  for (auto & nl : _nl)
2515  nl->subdomainSetup(subdomain, tid);
2516 
2517  // FIXME: call displaced_problem->subdomainSetup() ?
2518  // When adding possibility with materials being evaluated on displaced mesh
2519 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
void subdomainSetup()
Calls the subdomainSetup function for each of the output objects.
virtual void subdomainSetup(THREAD_ID tid=0) const
MaterialWarehouse _all_materials
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480

◆ subspaceDim()

unsigned int FEProblemBase::subspaceDim ( const std::string &  prefix) const
inlineinherited

Dimension of the subspace spanned by vectors with a given prefix.

Parameters
prefixPrefix of the vectors spanning the subspace.

Definition at line 2018 of file FEProblemBase.h.

Referenced by FEProblemBase::computeNearNullSpace(), FEProblemBase::computeNullSpace(), and FEProblemBase::computeTransposeNullSpace().

2019  {
2020  if (_subspace_dim.count(prefix))
2021  return _subspace_dim.find(prefix)->second;
2022  else
2023  return 0;
2024  }
std::map< std::string, unsigned int > _subspace_dim
Dimension of the subspace spanned by the vectors with a given prefix.

◆ swapBackMaterials()

void FEProblemBase::swapBackMaterials ( const THREAD_ID  tid)
virtualinherited

Definition at line 4278 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), LineMaterialSamplerBase< Real >::execute(), ComputeMarkerThread::onElement(), ComputeElemAuxVarsThread< AuxKernelType >::onElement(), ComputeIndicatorThread::onElement(), NonlinearThread::onElement(), and ComputeUserObjectsThread::onElement().

4279 {
4280  auto && elem = _assembly[tid][0]->elem();
4282 }
void swapBack(const Elem &elem, unsigned int side=0)
material properties for given element (and possible side)
Definition: MaterialData.C:58
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
const MaterialData & getMaterialData(const THREAD_ID tid) const
MaterialPropertyStorage & _material_props

◆ swapBackMaterialsFace()

void FEProblemBase::swapBackMaterialsFace ( const THREAD_ID  tid)
virtualinherited

Definition at line 4285 of file FEProblemBase.C.

Referenced by NonlinearThread::onBoundary(), ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

4286 {
4287  auto && elem = _assembly[tid][0]->elem();
4288  unsigned int side = _assembly[tid][0]->side();
4289  _bnd_material_props.getMaterialData(tid).swapBack(*elem, side);
4290 }
MaterialPropertyStorage & _bnd_material_props
void swapBack(const Elem &elem, unsigned int side=0)
material properties for given element (and possible side)
Definition: MaterialData.C:58
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
const MaterialData & getMaterialData(const THREAD_ID tid) const

◆ swapBackMaterialsNeighbor()

void FEProblemBase::swapBackMaterialsNeighbor ( const THREAD_ID  tid)
virtualinherited

Definition at line 4293 of file FEProblemBase.C.

Referenced by NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

4294 {
4295  // NOTE: this will not work with h-adaptivity
4296  const Elem * neighbor = _assembly[tid][0]->neighbor();
4297  unsigned int neighbor_side =
4298  neighbor ? neighbor->which_neighbor_am_i(_assembly[tid][0]->elem()) : libMesh::invalid_uint;
4299 
4300  if (!neighbor)
4301  {
4302  if (haveFV())
4303  {
4304  // If neighbor is null, then we're on the neighbor side of a mesh boundary, e.g. we're off
4305  // the mesh in ghost-land. If we're using the finite volume method, then variable values and
4306  // consequently material properties have well-defined values in this ghost region outside of
4307  // the mesh and we really do want to reinit our neighbor materials in this case. Since we're
4308  // off in ghost land it's safe to do swaps with `MaterialPropertyStorage` using the elem and
4309  // elem_side keys
4310  neighbor = _assembly[tid][0]->elem();
4311  neighbor_side = _assembly[tid][0]->side();
4312  mooseAssert(neighbor, "We should have an appropriate value for elem coming from Assembly");
4313  }
4314  else
4315  mooseError("neighbor is null in Assembly!");
4316  }
4317 
4318  _neighbor_material_props.getMaterialData(tid).swapBack(*neighbor, neighbor_side);
4319 }
const unsigned int invalid_uint
virtual bool haveFV() const override
returns true if this problem includes/needs finite volume functionality.
void swapBack(const Elem &elem, unsigned int side=0)
material properties for given element (and possible side)
Definition: MaterialData.C:58
unsigned int which_neighbor_am_i(const Elem *e) const
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
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
MaterialPropertyStorage & _neighbor_material_props
const MaterialData & getMaterialData(const THREAD_ID tid) const

◆ syncSolutions()

virtual void MFEMProblem::syncSolutions ( Direction  direction)
inlineoverridevirtual

Method to transfer data to/from the external application to the associated transfer mesh.

Implements ExternalProblem.

Definition at line 27 of file MFEMProblem.h.

27 {}

◆ systemBaseAuxiliary() [1/2]

const SystemBase & FEProblemBase::systemBaseAuxiliary ( ) const
overridevirtualinherited

Return the auxiliary system object as a base class reference.

Implements SubProblem.

Definition at line 9129 of file FEProblemBase.C.

Referenced by PhysicsBase::copyVariablesFromMesh(), and getAuxVariableNames().

9130 {
9131  return *_aux;
9132 }
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ systemBaseAuxiliary() [2/2]

SystemBase & FEProblemBase::systemBaseAuxiliary ( )
overridevirtualinherited

Implements SubProblem.

Definition at line 9135 of file FEProblemBase.C.

9136 {
9137  return *_aux;
9138 }
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ systemBaseLinear() [1/2]

const SystemBase & FEProblemBase::systemBaseLinear ( unsigned int  sys_num) const
overridevirtualinherited

Get a constant base class reference to a linear system.

Parameters
sys_numThe number of the linear system

Implements SubProblem.

Definition at line 9097 of file FEProblemBase.C.

9098 {
9099  mooseAssert(sys_num < _linear_systems.size(),
9100  "System number greater than the number of linear systems");
9101  return *_linear_systems[sys_num];
9102 }
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.

◆ systemBaseLinear() [2/2]

SystemBase & FEProblemBase::systemBaseLinear ( unsigned int  sys_num)
overridevirtualinherited

Get a non-constant base class reference to a linear system.

Parameters
sys_numThe number of the linear system

Implements SubProblem.

Definition at line 9105 of file FEProblemBase.C.

9106 {
9107  mooseAssert(sys_num < _linear_systems.size(),
9108  "System number greater than the number of linear systems");
9109  return *_linear_systems[sys_num];
9110 }
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.

◆ systemBaseNonlinear() [1/2]

const SystemBase & FEProblemBase::systemBaseNonlinear ( const unsigned int  sys_num) const
overridevirtualinherited

Return the nonlinear system object as a base class reference given the system number.

Implements SubProblem.

Definition at line 9083 of file FEProblemBase.C.

9084 {
9085  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
9086  return *_nl[sys_num];
9087 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ systemBaseNonlinear() [2/2]

SystemBase & FEProblemBase::systemBaseNonlinear ( const unsigned int  sys_num)
overridevirtualinherited

Implements SubProblem.

Definition at line 9090 of file FEProblemBase.C.

9091 {
9092  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
9093  return *_nl[sys_num];
9094 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ systemBaseSolver() [1/2]

const SystemBase & FEProblemBase::systemBaseSolver ( const unsigned int  sys_num) const
overridevirtualinherited

Return the solver system object as a base class reference given the system number.

Implements SubProblem.

Definition at line 9113 of file FEProblemBase.C.

9114 {
9115  mooseAssert(sys_num < _solver_systems.size(),
9116  "System number greater than the number of solver systems");
9117  return *_solver_systems[sys_num];
9118 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.

◆ systemBaseSolver() [2/2]

SystemBase & FEProblemBase::systemBaseSolver ( const unsigned int  sys_num)
overridevirtualinherited

Implements SubProblem.

Definition at line 9121 of file FEProblemBase.C.

9122 {
9123  mooseAssert(sys_num < _solver_systems.size(),
9124  "System number greater than the number of solver systems");
9125  return *_solver_systems[sys_num];
9126 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.

◆ systemNumForVariable()

unsigned int FEProblemBase::systemNumForVariable ( const VariableName &  variable_name) const
inherited
Returns
the system number for the provided variable_name Can be nonlinear or auxiliary

Definition at line 6501 of file FEProblemBase.C.

Referenced by FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

6502 {
6503  for (const auto & solver_sys : _solver_systems)
6504  if (solver_sys->hasVariable(variable_name))
6505  return solver_sys->number();
6506  mooseAssert(_aux, "Should have an auxiliary system");
6507  if (_aux->hasVariable(variable_name))
6508  return _aux->number();
6509 
6510  mooseError("Variable '",
6511  variable_name,
6512  "' was not found in any solver (nonlinear/linear) or auxiliary system");
6513 }
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
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

◆ terminateSolve()

virtual void Problem::terminateSolve ( )
inlinevirtualinherited

Allow objects to request clean termination of the solve.

Definition at line 37 of file Problem.h.

Referenced by WebServerControl::execute(), Terminator::execute(), and TerminateChainControl::terminate().

37 { _termination_requested = true; };
bool _termination_requested
True if termination of the solve has been requested.
Definition: Problem.h:58

◆ theWarehouse()

TheWarehouse& FEProblemBase::theWarehouse ( ) const
inlineinherited

Definition at line 2257 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), NonlinearSystemBase::addHDGKernel(), NonlinearSystemBase::addInterfaceKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), FEProblemBase::addObject(), NonlinearSystemBase::addScalarKernel(), NonlinearSystemBase::addSplit(), FEProblemBase::addUserObject(), NonlinearSystemBase::checkKernelCoverage(), FEProblemBase::checkUserObjectJacobianRequirement(), FEProblemBase::checkUserObjects(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), LinearSystem::containsTimeKernel(), NonlinearSystemBase::customSetup(), FEProblemBase::customSetup(), ComputeResidualThread::determineObjectWarehouses(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), FEProblemBase::executeSamplers(), ComputeLinearFVElementalThread::fetchBlockSystemContributionObjects(), ComputeLinearFVFaceThread::fetchBlockSystemContributionObjects(), FEProblemBase::getDistribution(), FEProblemBase::getMortarUserObjects(), FEProblemBase::getPositionsObject(), FEProblemBase::getSampler(), CompositionDT::getTimeSteppers(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), FEProblemBase::hasUserObject(), SideFVFluxBCIntegral::initialSetup(), ExplicitTimeIntegrator::initialSetup(), LinearSystem::initialSetup(), NonlinearSystemBase::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needInterfaceMaterialOnSide(), FEProblemBase::needSubdomainMaterialOnSide(), JSONOutput::outputReporters(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), ComputeLinearFVElementalThread::setupSystemContributionObjects(), ComputeLinearFVFaceThread::setupSystemContributionObjects(), NonlinearThread::subdomainChanged(), NonlinearSystemBase::timestepSetup(), and FEProblemBase::timestepSetup().

2257 { return _app.theWarehouse(); }
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
TheWarehouse & theWarehouse()
Definition: MooseApp.h:137

◆ time()

virtual Real& FEProblemBase::time ( ) const
inlinevirtualinherited

◆ timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name) const
protectedinherited
Returns
The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

48 {
49  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
50 }
const std::string _prefix
A prefix to use for all sections.

◆ timeOld()

virtual Real& FEProblemBase::timeOld ( ) const
inlinevirtualinherited

◆ timeStep()

virtual int& FEProblemBase::timeStep ( ) const
inlinevirtualinherited

◆ timestepSetup()

void FEProblemBase::timestepSetup ( )
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1523 of file FEProblemBase.C.

Referenced by MFEMSteady::execute(), SteadyBase::execute(), Eigenvalue::execute(), NonlinearEigen::takeStep(), MFEMTransient::takeStep(), and TransientBase::takeStep().

1524 {
1526 
1527  if (_t_step > 1 && _num_grid_steps)
1528  {
1529  libMesh::MeshRefinement mesh_refinement(_mesh);
1530  std::unique_ptr<libMesh::MeshRefinement> displaced_mesh_refinement(nullptr);
1531  if (_displaced_mesh)
1532  displaced_mesh_refinement = std::make_unique<libMesh::MeshRefinement>(*_displaced_mesh);
1533 
1534  for (MooseIndex(_num_grid_steps) i = 0; i < _num_grid_steps; ++i)
1535  {
1536  if (_displaced_problem)
1537  // If the DisplacedProblem is active, undisplace the DisplacedMesh in preparation for
1538  // refinement. We can't safely refine the DisplacedMesh directly, since the Hilbert keys
1539  // computed on the inconsistenly-displaced Mesh are different on different processors,
1540  // leading to inconsistent Hilbert keys. We must do this before the undisplaced Mesh is
1541  // coarsensed, so that the element and node numbering is still consistent. We also have to
1542  // make sure this is done during every step of coarsening otherwise different partitions
1543  // will be generated for the reference and displaced meshes (even for replicated)
1544  _displaced_problem->undisplaceMesh();
1545 
1546  mesh_refinement.uniformly_coarsen();
1547  if (_displaced_mesh)
1548  displaced_mesh_refinement->uniformly_coarsen();
1549 
1550  // Mark this as an intermediate change because we do not yet want to reinit_systems. E.g. we
1551  // need things to happen in the following order for the undisplaced problem:
1552  // u1) EquationSystems::reinit_solutions. This will restrict the solution vectors and then
1553  // contract the mesh
1554  // u2) MooseMesh::meshChanged. This will update the node/side lists and other
1555  // things which needs to happen after the contraction
1556  // u3) GeometricSearchData::reinit. Once the node/side lists are updated we can perform our
1557  // geometric searches which will aid in determining sparsity patterns
1558  //
1559  // We do these things for the displaced problem (if it exists)
1560  // d1) EquationSystems::reinit. Restrict the displaced problem vector copies and then contract
1561  // the mesh. It's safe to do a full reinit with the displaced because there are no
1562  // matrices that sparsity pattern calculations will be conducted for
1563  // d2) MooseMesh::meshChanged. This will update the node/side lists and other
1564  // things which needs to happen after the contraction
1565  // d3) UpdateDisplacedMeshThread::operator(). Re-displace the mesh using the *displaced*
1566  // solution vector copy because we don't know the state of the reference solution vector.
1567  // It's safe to use the displaced copy because we are outside of a non-linear solve,
1568  // and there is no concern about differences between solution and current_local_solution
1569  // d4) GeometricSearchData::reinit. With the node/side lists updated and the mesh
1570  // re-displaced, we can perform our geometric searches, which will aid in determining the
1571  // sparsity pattern of the matrix held by the libMesh::ImplicitSystem held by the
1572  // NonlinearSystem held by this
1573  meshChanged(
1574  /*intermediate_change=*/true, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
1575  }
1576 
1577  // u4) Now that all the geometric searches have been done (both undisplaced and displaced),
1578  // we're ready to update the sparsity pattern
1579  es().reinit_systems();
1580  }
1581 
1582  if (_line_search)
1583  _line_search->timestepSetup();
1584 
1585  // Random interface objects
1586  for (const auto & it : _random_data_objects)
1587  it.second->updateSeeds(EXEC_TIMESTEP_BEGIN);
1588 
1589  unsigned int n_threads = libMesh::n_threads();
1590  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1591  {
1594  }
1595 
1596  _aux->timestepSetup();
1597  for (auto & sys : _solver_systems)
1598  sys->timestepSetup();
1599 
1600  if (_displaced_problem)
1601  // timestepSetup for displaced systems
1602  _displaced_problem->timestepSetup();
1603 
1604  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1605  {
1608  _markers.timestepSetup(tid);
1609  }
1610 
1611  std::vector<UserObject *> userobjs;
1612  theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(userobjs);
1613  for (auto obj : userobjs)
1614  obj->timestepSetup();
1615 
1616  // Timestep setup of output objects
1618 
1621  _has_nonlocal_coupling = true;
1622 }
virtual void meshChanged()
Deprecated.
unsigned int n_threads()
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
virtual void timestepSetup(THREAD_ID tid=0) const
bool _requires_nonlocal_coupling
nonlocal coupling requirement flag
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
unsigned int _num_grid_steps
Number of steps in a grid sequence.
virtual void reinit_systems()
TheWarehouse & theWarehouse() const
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
virtual void timestepSetup(THREAD_ID tid=0) const
virtual libMesh::EquationSystems & es() override
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
MooseObjectWarehouse< Indicator > _indicators
virtual void timestepSetup()
Definition: SubProblem.C:1185
bool hasActiveObjects(THREAD_ID tid=0) const
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseObjectWarehouse< Function > _functions
functions
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284
MooseObjectWarehouse< Marker > _markers
MaterialWarehouse _all_materials
void timestepSetup()
Calls the timestepSetup function for each of the output objects.
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2480
MooseMesh * _displaced_mesh
unsigned int THREAD_ID
Definition: MooseTypes.h:209
MooseObjectWarehouse< IntegratedBCBase > _nonlocal_integrated_bcs
nonlocal integrated_bcs
std::shared_ptr< LineSearch > _line_search
MooseObjectWarehouse< KernelBase > _nonlocal_kernels
nonlocal kernels

◆ transient()

virtual void FEProblemBase::transient ( bool  trans)
inlinevirtualinherited

Definition at line 548 of file FEProblemBase.h.

Referenced by EigenExecutionerBase::EigenExecutionerBase(), and TransientBase::TransientBase().

548 { _transient = trans; }

◆ trustUserCouplingMatrix()

void FEProblemBase::trustUserCouplingMatrix ( )
inherited

Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a full coupling matrix.

See https://github.com/idaholab/moose/issues/16395 for detailed background

Definition at line 6235 of file FEProblemBase.C.

Referenced by SingleMatrixPreconditioner::SingleMatrixPreconditioner().

6236 {
6238  mooseError("Someone told us (the FEProblemBase) to trust the user coupling matrix, but we "
6239  "haven't been provided a coupling matrix!");
6240 
6242 }
bool _trust_user_coupling_matrix
Whether to trust the user coupling matrix no matter what.
Moose::CouplingType _coupling
Type of variable coupling.
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

◆ type()

const std::string& MooseBase::type ( ) const
inlineinherited

Get the type of this class.

Returns
the name of the type of this class

Definition at line 93 of file MooseBase.h.

Referenced by CreateProblemDefaultAction::act(), SetupDebugAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addConvergence(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), addFunction(), FEProblemBase::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addObject(), addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addTimeIntegrator(), MooseServer::addValuesToList(), DisplacedProblem::addVectorTag(), SubProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelTempl< Real >::AuxKernelTempl(), FEProblemBase::backupMultiApps(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildLowerDMesh(), MooseMesh::buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), ADDGKernel::computeElemNeighJacobian(), DGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), ADDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), LowerDIntegratedBC::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDJacobian(), DGLowerDKernel::computeLowerDJacobian(), ArrayDGLowerDKernel::computeLowerDJacobian(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpJacobian(), ArrayHFEMDiffusion::computeLowerDQpJacobian(), HFEMDirichletBC::computeLowerDQpJacobian(), HFEMDiffusion::computeLowerDQpJacobian(), ArrayHFEMDirichletBC::computeLowerDQpOffDiagJacobian(), HFEMDirichletBC::computeLowerDQpOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDQpOffDiagJacobian(), ArrayDGLowerDKernel::computeLowerDQpOffDiagJacobian(), FEProblemBase::computeMultiAppsDT(), ADDGKernel::computeOffDiagElemNeighJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), DGConvection::computeQpJacobian(), ScalarKernel::computeQpJacobian(), InterfaceDiffusion::computeQpJacobian(), InterfaceReaction::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), DGDiffusion::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), HFEMTestJump::computeQpOffDiagJacobian(), HFEMTrialJump::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), ArrayHFEMDiffusion::computeQpResidual(), DGConvection::computeQpResidual(), HFEMDiffusion::computeQpResidual(), ScalarKernel::computeQpResidual(), InterfaceDiffusion::computeQpResidual(), ADMatInterfaceReaction::computeQpResidual(), InterfaceReaction::computeQpResidual(), ADDGAdvection::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), DGDiffusion::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), ADDGDiffusion::computeQpResidual(), HFEMTrialJump::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), HFEMTestJump::computeQpResidual(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), DisplacedProblem::createQRules(), FEProblemBase::createQRules(), MooseApp::createRecoverablePerfGraph(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), WebServerControl::execute(), SteadyBase::execute(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), MooseServer::gatherDocumentReferencesLocations(), Boundary2DDelaunayGenerator::General2DDelaunay(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), Boundary2DDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateInternal(), MultiAppTransfer::getAppInfo(), TransfiniteMeshGenerator::getEdge(), ElementGenerator::getElemType(), MooseServer::getInputLookupDefinitionNodes(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), MaterialOutputAction::getParams(), ReporterData::getReporterInfo(), FEProblemBase::getTransfers(), DisplacedProblem::getVectorTags(), SubProblem::getVectorTags(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), AdvancedOutput::initAvailableLists(), FunctorPositions::initialize(), FunctorTimes::initialize(), MultiAppConservativeTransfer::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVDiffusion::initialSetup(), LinearFVAdvection::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), mesh(), MooseObject::MooseObject(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), DisplacedProblem::numVectorTags(), SubProblem::numVectorTags(), Console::output(), AdvancedOutput::output(), ConsoleUtils::outputExecutionInformation(), SampledOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), MooseMesh::prepare(), ProjectedStatefulMaterialStorageAction::processProperty(), MooseApp::recursivelyCreateExecutors(), SolutionInvalidInterface::registerInvalidSolutionInternal(), FEProblemBase::restoreMultiApps(), MeshRepairGenerator::separateSubdomainsByElementType(), FEProblemBase::setCoupling(), MooseApp::setupOptions(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), WebServerControl::startServer(), Reporter::store(), MooseBase::typeAndName(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), UserObjectInterface::userObjectType(), and AdvancedOutput::wantOutput().

94  {
95  mooseAssert(_type.size(), "Empty type");
96  return _type;
97  }
const std::string & _type
The type of this class.
Definition: MooseBase.h:360

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const
inherited

Get the class's combined type and name; useful in error handling.

Returns
The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

Referenced by FEProblemBase::addPostprocessor(), MaterialPropertyStorage::addProperty(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

58 {
59  return type() + std::string(" \"") + name() + std::string("\"");
60 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

◆ uDotDotOldRequested()

virtual bool FEProblemBase::uDotDotOldRequested ( )
inlinevirtualinherited

Get boolean flag to check whether old solution second time derivative needs to be stored.

Definition at line 2333 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

2334  {
2336  mooseError("FEProblemBase: When requesting old second time derivative of solution, current "
2337  "second time derivation of solution should also be stored. Please set "
2338  "`u_dotdot_requested` to true using setUDotDotRequested.");
2339  return _u_dotdot_old_requested;
2340  }
bool _u_dotdot_old_requested
Whether old solution second time derivative needs to be stored.
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
bool _u_dotdot_requested
Whether solution second time derivative needs to be stored.

◆ uDotDotRequested()

virtual bool FEProblemBase::uDotDotRequested ( )
inlinevirtualinherited

Get boolean flag to check whether solution second time derivative needs to be stored.

Definition at line 2319 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors(), and FEProblemBase::addTimeIntegrator().

2319 { return _u_dotdot_requested; }
bool _u_dotdot_requested
Whether solution second time derivative needs to be stored.

◆ uDotOldRequested()

virtual bool FEProblemBase::uDotOldRequested ( )
inlinevirtualinherited

Get boolean flag to check whether old solution time derivative needs to be stored.

Definition at line 2322 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

2323  {
2325  mooseError("FEProblemBase: When requesting old time derivative of solution, current time "
2326  "derivative of solution should also be stored. Please set `u_dot_requested` to "
2327  "true using setUDotRequested.");
2328 
2329  return _u_dot_old_requested;
2330  }
bool _u_dot_requested
Whether solution time derivative needs to be stored.
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
bool _u_dot_old_requested
Whether old solution time derivative needs to be stored.

◆ uDotRequested()

virtual bool FEProblemBase::uDotRequested ( )
inlinevirtualinherited

Get boolean flag to check whether solution time derivative needs to be stored.

Definition at line 2316 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

2316 { return _u_dot_requested; }
bool _u_dot_requested
Whether solution time derivative needs to be stored.

◆ uniformRefine()

void FEProblemBase::uniformRefine ( )
inherited

uniformly refine the problem mesh(es).

This will also prolong the the solution, and in order for that to be safe, we can only perform one refinement at a time

Definition at line 9159 of file FEProblemBase.C.

Referenced by FEProblemSolve::solve().

9160 {
9161  // ResetDisplacedMeshThread::onNode looks up the reference mesh by ID, so we need to make sure
9162  // we undisplace before adapting the reference mesh
9163  if (_displaced_problem)
9164  _displaced_problem->undisplaceMesh();
9165 
9167  if (_displaced_problem)
9169 
9170  meshChanged(
9171  /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
9172 }
virtual void meshChanged()
Deprecated.
static void uniformRefine(MooseMesh *mesh, unsigned int level=libMesh::invalid_uint)
Performs uniform refinement of the passed Mesh object.
Definition: Adaptivity.C:274
MooseMesh & _mesh
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const
inherited
Returns
The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

70 {
71  if (!_pars.have_parameter<std::string>(unique_name_param))
72  mooseError("uniqueName(): Object does not have a unique name");
73  return MooseObjectName(_pars.get<std::string>(unique_name_param));
74 }
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:366
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
static const std::string unique_name_param
The name of the parameter that contains the unique object name.
Definition: MooseBase.h:57
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
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
A class for storing the names of MooseObject by tag and object name.

◆ uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string &  parameter_name) const
inherited
Returns
The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

64 {
65  return MooseObjectParameterName(getBase(), name(), parameter_name);
66 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
A class for storing an input parameter name.
const std::string & getBase() const
Definition: MooseBase.h:147

◆ updateActiveObjects()

void FEProblemBase::updateActiveObjects ( )
virtualinherited

Update the active objects in the warehouses.

Reimplemented in DumpObjectsProblem.

Definition at line 5226 of file FEProblemBase.C.

Referenced by MooseEigenSystem::eigenKernelOnCurrent(), MooseEigenSystem::eigenKernelOnOld(), MFEMProblemSolve::solve(), and FixedPointSolve::solveStep().

5227 {
5228  TIME_SECTION("updateActiveObjects", 5, "Updating Active Objects");
5229 
5230  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
5231  {
5232  for (auto & nl : _nl)
5233  nl->updateActive(tid);
5234  _aux->updateActive(tid);
5237  _markers.updateActive(tid);
5239  _materials.updateActive(tid);
5241  }
5242 
5250 
5251 #ifdef MOOSE_KOKKOS_ENABLED
5253 #endif
5254 }
unsigned int n_threads()
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.
void updateActive(THREAD_ID tid=0) override
Updates the active objects storage.
MaterialWarehouse _kokkos_materials
ExecuteMooseObjectWarehouse< TransientMultiApp > _transient_multi_apps
Storage for TransientMultiApps (only needed for calling &#39;computeDT&#39;)
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
ExecuteMooseObjectWarehouse< Transfer > _transfers
Normal Transfers.
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
virtual void updateActive(THREAD_ID tid=0)
Update the active status of Kernels.
MooseObjectWarehouse< Indicator > _indicators
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
MaterialWarehouse _discrete_materials
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.
MooseObjectWarehouse< Marker > _markers
MaterialWarehouse _all_materials
unsigned int THREAD_ID
Definition: MooseTypes.h:209
MaterialWarehouse _materials

◆ updateGeomSearch()

void FEProblemBase::updateGeomSearch ( GeometricSearchData::GeometricSearchType  type = GeometricSearchData::ALL)
overridevirtualinherited

Implements SubProblem.

Definition at line 7939 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::augmentSparsity(), and FEProblemBase::initialSetup().

7940 {
7941  TIME_SECTION("updateGeometricSearch", 3, "Updating Geometric Search");
7942 
7944 
7945  if (_displaced_problem)
7946  _displaced_problem->updateGeomSearch(type);
7947 }
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
void update(GeometricSearchType type=ALL)
Update all of the search objects.
std::shared_ptr< DisplacedProblem > _displaced_problem
GeometricSearchData _geometric_search_data

◆ updateMeshXFEM()

bool FEProblemBase::updateMeshXFEM ( )
virtualinherited

Update the mesh due to changing XFEM cuts.

Definition at line 8206 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), and FixedPointSolve::solveStep().

8207 {
8208  TIME_SECTION("updateMeshXFEM", 5, "Updating XFEM");
8209 
8210  bool updated = false;
8211  if (haveXFEM())
8212  {
8213  if (_xfem->updateHeal())
8214  // XFEM exodiff tests rely on a given numbering because they cannot use map = true due to
8215  // having coincident elements. While conceptually speaking we do not need to contract the
8216  // mesh, we need its call to renumber_nodes_and_elements in order to preserve these tests
8217  meshChanged(
8218  /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/false);
8219 
8220  updated = _xfem->update(_time, _nl, *_aux);
8221  if (updated)
8222  {
8223  meshChanged(
8224  /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/false);
8225  _xfem->initSolution(_nl, *_aux);
8226  restoreSolutions();
8227  }
8228  }
8229  return updated;
8230 }
virtual void meshChanged()
Deprecated.
bool haveXFEM()
Find out whether the current analysis is using XFEM.
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
virtual void restoreSolutions()
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.

◆ updateMortarMesh()

void FEProblemBase::updateMortarMesh ( )
virtualinherited

Definition at line 7950 of file FEProblemBase.C.

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::init(), FEProblemBase::initialSetup(), and FEProblemBase::meshChanged().

7951 {
7952  TIME_SECTION("updateMortarMesh", 5, "Updating Mortar Mesh");
7953 
7954  FloatingPointExceptionGuard fpe_guard(_app);
7955 
7956  _mortar_data.update();
7957 }
Scope guard for starting and stopping Floating Point Exception Trapping.
MortarData _mortar_data
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
void update()
Builds mortar segment meshes for each mortar interface.
Definition: MortarData.C:149

◆ updateSolution()

bool FEProblemBase::updateSolution ( NumericVector< libMesh::Number > &  vec_solution,
NumericVector< libMesh::Number > &  ghosted_solution 
)
virtualinherited

Update the solution.

Parameters
vec_solutionLocal solution vector that gets modified by this method
ghosted_solutionGhosted solution vector
Returns
true if the solution was modified, false otherwise

Definition at line 7918 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck().

7920 {
7921  return false;
7922 }

◆ useSNESMFReuseBase()

bool FEProblemBase::useSNESMFReuseBase ( )
inlineinherited

Return a flag that indicates if we are reusing the vector base.

Definition at line 2270 of file FEProblemBase.h.

Referenced by NonlinearSystem::potentiallySetupFiniteDifferencing().

2270 { return _snesmf_reuse_base; }
bool _snesmf_reuse_base
If or not to resuse the base vector for matrix-free calculation.

◆ validParams()

InputParameters MFEMProblem::validParams ( )
static

Definition at line 25 of file MFEMProblem.C.

26 {
28  params.addClassDescription("Problem type for building and solving finite element problem using"
29  " the MFEM finite element library.");
30  return params;
31 }
static InputParameters validParams()
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...

◆ vectorTagExists() [1/2]

virtual bool SubProblem::vectorTagExists ( const TagID  tag_id) const
inlinevirtualinherited

◆ vectorTagExists() [2/2]

bool SubProblem::vectorTagExists ( const TagName &  tag_name) const
virtualinherited

Check to see if a particular Tag exists by using Tag name.

Reimplemented in DisplacedProblem.

Definition at line 136 of file SubProblem.C.

137 {
138  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
139 
140  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
141  for (const auto & vector_tag : _vector_tags)
142  if (vector_tag._name == tag_name_upper)
143  return true;
144 
145  return false;
146 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1167
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
std::string toUpper(std::string name)
Convert supplied string to upper case.

◆ vectorTagName()

TagName SubProblem::vectorTagName ( const TagID  tag) const
virtualinherited

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 221 of file SubProblem.C.

Referenced by SystemBase::closeTaggedVector(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), SystemBase::removeVector(), NonlinearSystemBase::residualGhosted(), DisplacedProblem::vectorTagName(), and SystemBase::zeroTaggedVector().

222 {
223  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
224  if (!vectorTagExists(tag_id))
225  mooseError("Vector tag with ID ", tag_id, " does not exist");
226 
227  return _vector_tags[tag_id]._name;
228 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1167
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
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

◆ vectorTagNotZeroed()

bool SubProblem::vectorTagNotZeroed ( const TagID  tag) const
inherited

Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors are.

Parameters
tagthe TagID of the vector that is currently being checked
Returns
false if the tag is not within the set of vectors that are intended to not be zero or if the set is empty. returns true otherwise

Definition at line 155 of file SubProblem.C.

Referenced by SystemBase::zeroTaggedVector().

156 {
157  return _not_zeroed_tagged_vectors.count(tag);
158 }
std::unordered_set< TagID > _not_zeroed_tagged_vectors
the list of vector tags that will not be zeroed when all other tags are
Definition: SubProblem.h:1117

◆ vectorTagType()

Moose::VectorTagType SubProblem::vectorTagType ( const TagID  tag_id) const
virtualinherited

Reimplemented in DisplacedProblem.

Definition at line 231 of file SubProblem.C.

Referenced by MooseVariableScalar::reinit(), TaggingInterface::TaggingInterface(), TagVectorAux::TagVectorAux(), and DisplacedProblem::vectorTagType().

232 {
233  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
234  if (!vectorTagExists(tag_id))
235  mooseError("Vector tag with ID ", tag_id, " does not exist");
236 
237  return _vector_tags[tag_id]._type;
238 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1167
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:241
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
Definition: SubProblem.h:201
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

◆ verboseMultiApps()

bool FEProblemBase::verboseMultiApps ( ) const
inlineinherited

Whether or not to use verbose printing for MultiApps.

Definition at line 1984 of file FEProblemBase.h.

Referenced by MultiApp::backup(), MultiApp::createApp(), MultiApp::restore(), FullSolveMultiApp::showStatusMessage(), and TransientMultiApp::solveStep().

1984 { return _verbose_multiapps; }
bool _verbose_multiapps
Whether or not to be verbose with multiapps.

◆ verifyVectorTags()

bool SubProblem::verifyVectorTags ( ) const
protectedinherited

Verify the integrity of _vector_tags and _typed_vector_tags.

Definition at line 241 of file SubProblem.C.

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), SubProblem::getVectorTags(), SubProblem::numVectorTags(), SubProblem::vectorTagExists(), SubProblem::vectorTagName(), and SubProblem::vectorTagType().

242 {
243  for (TagID tag_id = 0; tag_id < _vector_tags.size(); ++tag_id)
244  {
245  const auto & vector_tag = _vector_tags[tag_id];
246 
247  if (vector_tag._id != tag_id)
248  mooseError("Vector tag ", vector_tag._id, " id mismatch in _vector_tags");
249  if (vector_tag._type == Moose::VECTOR_TAG_ANY)
250  mooseError("Vector tag '", vector_tag._name, "' has type VECTOR_TAG_ANY");
251 
252  const auto search = _vector_tags_name_map.find(vector_tag._name);
253  if (search == _vector_tags_name_map.end())
254  mooseError("Vector tag ", vector_tag._id, " is not in _vector_tags_name_map");
255  else if (search->second != tag_id)
256  mooseError("Vector tag ", vector_tag._id, " has incorrect id in _vector_tags_name_map");
257 
258  unsigned int found_in_type = 0;
259  for (TagTypeID tag_type_id = 0; tag_type_id < _typed_vector_tags[vector_tag._type].size();
260  ++tag_type_id)
261  {
262  const auto & vector_tag_type = _typed_vector_tags[vector_tag._type][tag_type_id];
263  if (vector_tag_type == vector_tag)
264  {
265  ++found_in_type;
266  if (vector_tag_type._type_id != tag_type_id)
267  mooseError("Type ID for Vector tag ", tag_id, " is incorrect");
268  }
269  }
270 
271  if (found_in_type == 0)
272  mooseError("Vector tag ", tag_id, " not found in _typed_vector_tags");
273  if (found_in_type > 1)
274  mooseError("Vector tag ", tag_id, " found multiple times in _typed_vector_tags");
275  }
276 
277  unsigned int num_typed_vector_tags = 0;
278  for (const auto & typed_vector_tags : _typed_vector_tags)
279  num_typed_vector_tags += typed_vector_tags.size();
280  if (num_typed_vector_tags != _vector_tags.size())
281  mooseError("Size mismatch between _vector_tags and _typed_vector_tags");
282  if (_vector_tags_name_map.size() != _vector_tags.size())
283  mooseError("Size mismatch between _vector_tags and _vector_tags_name_map");
284 
285  return true;
286 }
unsigned int TagTypeID
Definition: MooseTypes.h:211
unsigned int TagID
Definition: MooseTypes.h:210
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1167
std::map< TagName, TagID > _vector_tags_name_map
Map of vector tag TagName to TagID.
Definition: SubProblem.h:1177
std::vector< std::vector< VectorTag > > _typed_vector_tags
The vector tags associated with each VectorTagType This is kept separate from _vector_tags for quick ...
Definition: SubProblem.h:1174
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

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory
protectedinherited

◆ _active_elemental_moose_variables

std::vector<std::set<MooseVariableFieldBase *> > SubProblem::_active_elemental_moose_variables
protectedinherited

This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem)

Definition at line 1075 of file SubProblem.h.

Referenced by SubProblem::clearActiveElementalMooseVariables(), SubProblem::getActiveElementalMooseVariables(), SubProblem::setActiveElementalMooseVariables(), and SubProblem::SubProblem().

◆ _active_fe_var_coupleable_matrix_tags

std::vector<std::set<TagID> > SubProblem::_active_fe_var_coupleable_matrix_tags
protectedinherited

◆ _active_fe_var_coupleable_vector_tags

std::vector<std::set<TagID> > SubProblem::_active_fe_var_coupleable_vector_tags
protectedinherited

◆ _active_sc_var_coupleable_matrix_tags

std::vector<std::set<TagID> > SubProblem::_active_sc_var_coupleable_matrix_tags
protectedinherited

◆ _active_sc_var_coupleable_vector_tags

std::vector<std::set<TagID> > SubProblem::_active_sc_var_coupleable_vector_tags
protectedinherited

◆ _ad_grad_zero

std::vector<MooseArray<ADRealVectorValue> > FEProblemBase::_ad_grad_zero
inherited

◆ _ad_second_zero

std::vector<MooseArray<ADRealTensorValue> > FEProblemBase::_ad_second_zero
inherited

◆ _ad_zero

std::vector<MooseArray<ADReal> > FEProblemBase::_ad_zero
inherited

◆ _adaptivity

Adaptivity FEProblemBase::_adaptivity
protectedinherited

◆ _all_materials

MaterialWarehouse FEProblemBase::_all_materials
protectedinherited

◆ _all_user_objects

ExecuteMooseObjectWarehouse<UserObject> FEProblemBase::_all_user_objects
protectedinherited

◆ _app

MooseApp& MooseBase::_app
protectedinherited

The MOOSE application this is associated with.

Definition at line 357 of file MooseBase.h.

◆ _assembly

std::vector<std::vector<std::unique_ptr<Assembly> > > FEProblemBase::_assembly
protectedinherited

The Assembly objects.

The first index corresponds to the thread ID and the second index corresponds to the nonlinear system number

Definition at line 2816 of file FEProblemBase.h.

Referenced by FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addJacobianOffDiagScalar(), FEProblemBase::addJacobianScalar(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), FEProblemBase::assembly(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::couplingEntries(), FEProblemBase::createQRules(), FEProblemBase::init(), FEProblemBase::initElementStatefulProps(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::newAssemblyArray(), FEProblemBase::nonlocalCouplingEntries(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFaceShapes(), FEProblemBase::prepareNeighborShapes(), FEProblemBase::prepareShapes(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitElemPhys(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsInterface(), FEProblemBase::reinitMaterialsNeighbor(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::reinitScalars(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), FEProblemBase::swapBackMaterials(), FEProblemBase::swapBackMaterialsFace(), and FEProblemBase::swapBackMaterialsNeighbor().

◆ _aux

std::shared_ptr<AuxiliarySystem> FEProblemBase::_aux
protectedinherited

The auxiliary system.

Definition at line 2802 of file FEProblemBase.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addIndicator(), FEProblemBase::addMarker(), FEProblemBase::addMultiApp(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::advanceState(), FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeBounds(), FEProblemBase::computeIndicators(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeMarkers(), FEProblemBase::computePostCheck(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::copySolutionsBackwards(), FEProblemBase::createQRules(), FEProblemBase::createTagMatrices(), FEProblemBase::createTagSolutions(), FEProblemBase::customSetup(), FEProblemBase::determineSolverSystem(), DumpObjectsProblem::DumpObjectsProblem(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), FEProblemBase::execute(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::getActualFieldVariable(), FEProblemBase::getArrayVariable(), FEProblemBase::getAuxiliarySystem(), FEProblemBase::getScalarVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), FEProblemBase::getVariable(), FEProblemBase::getVariableNames(), FEProblemBase::getVectorVariable(), FEProblemBase::hasScalarVariable(), FEProblemBase::hasVariable(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::meshChanged(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needSolutionState(), FEProblemBase::outputStep(), FEProblemBase::prepareFace(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemPhys(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitNodes(), FEProblemBase::reinitNodesNeighbor(), FEProblemBase::reinitScalars(), FEProblemBase::restoreOldSolutions(), FEProblemBase::restoreSolutions(), FEProblemBase::saveOldSolutions(), FEProblemBase::systemBaseAuxiliary(), FEProblemBase::systemNumForVariable(), FEProblemBase::timestepSetup(), FEProblemBase::updateActiveObjects(), and FEProblemBase::updateMeshXFEM().

◆ _aux_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_aux_evaluable_local_elem_range
protectedinherited

Definition at line 3099 of file FEProblemBase.h.

◆ _between_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_between_multi_app_transfers
protectedinherited

◆ _block_mat_side_cache

std::vector<std::unordered_map<SubdomainID, bool> > FEProblemBase::_block_mat_side_cache
protectedinherited

Cache for calculating materials on side.

Definition at line 2906 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), and FEProblemBase::needSubdomainMaterialOnSide().

◆ _bnd_mat_side_cache

std::vector<std::unordered_map<BoundaryID, bool> > FEProblemBase::_bnd_mat_side_cache
protectedinherited

Cache for calculating materials on side.

Definition at line 2909 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), and FEProblemBase::needBoundaryMaterialOnSide().

◆ _bnd_material_props

MaterialPropertyStorage& FEProblemBase::_bnd_material_props
protectedinherited

◆ _boundary_restricted_elem_integrity_check

const bool FEProblemBase::_boundary_restricted_elem_integrity_check
protectedinherited

whether to perform checking of boundary restricted elemental object variable dependencies, e.g.

whether the variable dependencies are defined on the selected boundaries

Definition at line 3038 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup().

◆ _boundary_restricted_node_integrity_check

const bool FEProblemBase::_boundary_restricted_node_integrity_check
protectedinherited

whether to perform checking of boundary restricted nodal object variable dependencies, e.g.

whether the variable dependencies are defined on the selected boundaries

Definition at line 3034 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup().

◆ _calculate_jacobian_in_uo

bool FEProblemBase::_calculate_jacobian_in_uo
protectedinherited

◆ _cli_option_found

bool Problem::_cli_option_found
protectedinherited

True if the CLI option is found.

Definition at line 52 of file Problem.h.

Referenced by Problem::_setCLIOption().

◆ _cm

std::vector<std::unique_ptr<libMesh::CouplingMatrix> > FEProblemBase::_cm
protectedinherited

◆ _color_output

bool Problem::_color_output
protectedinherited

True if we're going to attempt to write color output.

Definition at line 55 of file Problem.h.

◆ _computing_nonlinear_residual

bool SubProblem::_computing_nonlinear_residual
protectedinherited

Whether the non-linear residual is being evaluated.

Definition at line 1102 of file SubProblem.h.

Referenced by SubProblem::computingNonlinearResid(), and FEProblemBase::computingNonlinearResid().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console
inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MeshOnlyAction::act(), SetupDebugAction::act(), MaterialOutputAction::act(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkRelativeConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), LinearSystem::computeLinearSystemTags(), FEProblemBase::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MFEMSteady::execute(), MessageFromInput::execute(), SteadyBase::execute(), Eigenvalue::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), ElementQualityChecker::finalize(), SidesetAroundSubdomainUpdater::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), CoarsenBlockGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseBase::mooseDeprecated(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ReporterDebugOutput::output(), PerfGraphOutput::output(), SolutionInvalidityOutput::output(), MaterialPropertyDebugOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), PicardSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), EigenProblem::solve(), FEProblemSolve::solve(), NonlinearSystem::solve(), FixedPointSolve::solve(), LinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), LStableDirk4::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), FixedPointSolve::solveStep(), PerfGraphLivePrint::start(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), MFEMTransient::takeStep(), TransientBase::takeStep(), TerminateChainControl::terminate(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

◆ _const_jacobian

bool FEProblemBase::_const_jacobian
protectedinherited

true if the Jacobian is constant

Definition at line 3006 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::constJacobian(), and FEProblemBase::setConstJacobian().

◆ _control_warehouse

ExecuteMooseObjectWarehouse<Control> FEProblemBase::_control_warehouse
protectedinherited

The control logic warehouse.

Definition at line 3084 of file FEProblemBase.h.

Referenced by FEProblemBase::executeControls(), FEProblemBase::getControlWarehouse(), and FEProblemBase::updateActiveObjects().

◆ _convergences

MooseObjectWarehouse<Convergence> FEProblemBase::_convergences
protectedinherited

◆ _coupling

Moose::CouplingType FEProblemBase::_coupling
protectedinherited

◆ _current_algebraic_bnd_node_range

std::unique_ptr<ConstBndNodeRange> FEProblemBase::_current_algebraic_bnd_node_range
protectedinherited

◆ _current_algebraic_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_current_algebraic_elem_range
protectedinherited

◆ _current_algebraic_node_range

std::unique_ptr<libMesh::ConstNodeRange> FEProblemBase::_current_algebraic_node_range
protectedinherited

◆ _current_execute_on_flag

ExecFlagType FEProblemBase::_current_execute_on_flag
protectedinherited

◆ _current_ic_state

unsigned short FEProblemBase::_current_ic_state
protectedinherited

◆ _current_linear_sys

LinearSystem* FEProblemBase::_current_linear_sys
protectedinherited

◆ _current_nl_sys

NonlinearSystemBase* FEProblemBase::_current_nl_sys
protectedinherited

The current nonlinear system that we are solving.

Definition at line 2784 of file FEProblemBase.h.

Referenced by FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addJacobianOffDiagScalar(), FEProblemBase::addJacobianScalar(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeBounds(), FEProblemBase::computeDamping(), FEProblemBase::computeJacobianBlock(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), FEProblemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTag(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeNearNullSpace(), FEProblemBase::computeNullSpace(), FEProblemBase::computePostCheck(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), FEProblemBase::computeTransposeNullSpace(), FEProblemBase::currentNonlinearSystem(), EigenProblem::doFreeNonlinearPowerIterations(), EigenProblem::EigenProblem(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFaceShapes(), FEProblemBase::prepareNeighborShapes(), FEProblemBase::prepareShapes(), FEProblemBase::reinitDirac(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::setCurrentNonlinearSystem(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), EigenProblem::solve(), and FEProblemBase::solve().

◆ _current_solver_sys

SolverSystem* FEProblemBase::_current_solver_sys
protectedinherited

The current solver system.

Definition at line 2787 of file FEProblemBase.h.

Referenced by FEProblemBase::setCurrentLinearSystem(), and FEProblemBase::setCurrentNonlinearSystem().

◆ _currently_computing_jacobian

bool SubProblem::_currently_computing_jacobian
protectedinherited

◆ _currently_computing_residual

bool SubProblem::_currently_computing_residual
protectedinherited

◆ _currently_computing_residual_and_jacobian

bool SubProblem::_currently_computing_residual_and_jacobian
protectedinherited

Flag to determine whether the problem is currently computing the residual and Jacobian.

Definition at line 1099 of file SubProblem.h.

Referenced by SubProblem::currentlyComputingResidualAndJacobian(), and SubProblem::setCurrentlyComputingResidualAndJacobian().

◆ _cycles_completed

unsigned int FEProblemBase::_cycles_completed
protectedinherited

◆ _default_ghosting

bool SubProblem::_default_ghosting
protectedinherited

Whether or not to use default libMesh coupling.

Definition at line 1090 of file SubProblem.h.

Referenced by SubProblem::defaultGhosting().

◆ _dirac_kernel_info

DiracKernelInfo SubProblem::_dirac_kernel_info
protectedinherited

◆ _discrete_materials

MaterialWarehouse FEProblemBase::_discrete_materials
protectedinherited

◆ _displaced_mesh

MooseMesh* FEProblemBase::_displaced_mesh
protectedinherited

◆ _displaced_problem

std::shared_ptr<DisplacedProblem> FEProblemBase::_displaced_problem
protectedinherited

Definition at line 2973 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addCachedJacobian(), FEProblemBase::addCachedResidual(), FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addConstraint(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDisplacedProblem(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVKernel(), FEProblemBase::addGhostedBoundary(), FEProblemBase::addIndicator(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVariable(), FEProblemBase::advanceState(), FEProblemBase::automaticScaling(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::cacheJacobian(), FEProblemBase::cacheJacobianNeighbor(), FEProblemBase::cacheResidual(), FEProblemBase::cacheResidualNeighbor(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::clearActiveElementalMooseVariables(), FEProblemBase::clearActiveFEVariableCoupleableMatrixTags(), FEProblemBase::clearActiveFEVariableCoupleableVectorTags(), FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags(), FEProblemBase::clearActiveScalarVariableCoupleableVectorTags(), FEProblemBase::clearDiracInfo(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::computingNonlinearResid(), FEProblemBase::createMortarInterface(), FEProblemBase::createQRules(), FEProblemBase::customSetup(), FEProblemBase::execute(), FEProblemBase::getDiracElements(), FEProblemBase::getDisplacedProblem(), FEProblemBase::getMortarUserObjects(), FEProblemBase::ghostGhostedBoundaries(), FEProblemBase::haveADObjects(), FEProblemBase::haveDisplaced(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::jacobianSetup(), FEProblemBase::mesh(), FEProblemBase::meshChanged(), FEProblemBase::outputStep(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFace(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFaceRef(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitLowerDElem(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborFaceRef(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitNodes(), FEProblemBase::reinitNodesNeighbor(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::reinitScalars(), FEProblemBase::resetState(), FEProblemBase::residualSetup(), FEProblemBase::restoreSolutions(), FEProblemBase::setActiveElementalMooseVariables(), FEProblemBase::setActiveFEVariableCoupleableMatrixTags(), FEProblemBase::setActiveFEVariableCoupleableVectorTags(), FEProblemBase::setActiveScalarVariableCoupleableMatrixTags(), FEProblemBase::setActiveScalarVariableCoupleableVectorTags(), FEProblemBase::setCurrentBoundaryID(), FEProblemBase::setCurrentLowerDElem(), FEProblemBase::setCurrentlyComputingResidual(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), FEProblemBase::setResidualObjectParamsAndLog(), EigenProblem::solve(), FEProblemBase::solve(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateGeomSearch().

◆ _dt

Real& FEProblemBase::_dt
protectedinherited

◆ _dt_old

Real& FEProblemBase::_dt_old
protectedinherited

Definition at line 2744 of file FEProblemBase.h.

Referenced by FEProblemBase::dtOld(), and FEProblemBase::FEProblemBase().

◆ _enabled

const bool& MooseObject::_enabled
protectedinherited

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition at line 80 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_evaluable_local_elem_range
protectedinherited

◆ _exception_message

std::string FEProblemBase::_exception_message
protectedinherited

The error message to go with an exception.

Definition at line 3078 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), and FEProblemBase::setException().

◆ _factory

Factory& SubProblem::_factory
protectedinherited

◆ _fe_matrix_tags

std::set<TagID> FEProblemBase::_fe_matrix_tags
protectedinherited

◆ _fe_vector_tags

std::set<TagID> FEProblemBase::_fe_vector_tags
protectedinherited

◆ _from_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_from_multi_app_transfers
protectedinherited

◆ _functions

MooseObjectWarehouse<Function> FEProblemBase::_functions
protectedinherited

◆ _fv_bcs_integrity_check

bool FEProblemBase::_fv_bcs_integrity_check
protectedinherited

Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset.

Definition at line 3045 of file FEProblemBase.h.

Referenced by FEProblemBase::fvBCsIntegrityCheck().

◆ _fv_ics

FVInitialConditionWarehouse FEProblemBase::_fv_ics
protectedinherited

◆ _geometric_search_data

GeometricSearchData FEProblemBase::_geometric_search_data
protectedinherited

◆ _ghosted_elems

std::set<dof_id_type> SubProblem::_ghosted_elems
protectedinherited

◆ _grad_phi_zero

std::vector<VariablePhiGradient> FEProblemBase::_grad_phi_zero
inherited

◆ _grad_zero

std::vector<VariableGradient> FEProblemBase::_grad_zero
inherited

◆ _has_active_elemental_moose_variables

std::vector<unsigned int> SubProblem::_has_active_elemental_moose_variables
protectedinherited

Whether or not there is currently a list of active elemental moose variables.

Definition at line 1079 of file SubProblem.h.

Referenced by SubProblem::clearActiveElementalMooseVariables(), SubProblem::hasActiveElementalMooseVariables(), SubProblem::setActiveElementalMooseVariables(), and SubProblem::SubProblem().

◆ _has_active_material_properties

std::vector<unsigned char> FEProblemBase::_has_active_material_properties
protectedinherited

◆ _has_constraints

bool FEProblemBase::_has_constraints
protectedinherited

Whether or not this system has any Constraints.

Definition at line 2991 of file FEProblemBase.h.

Referenced by FEProblemBase::addConstraint(), NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

◆ _has_dampers

bool FEProblemBase::_has_dampers
protectedinherited

Whether or not this system has any Dampers associated with it.

Definition at line 2988 of file FEProblemBase.h.

Referenced by FEProblemBase::addDamper(), FEProblemBase::computeDamping(), FEProblemBase::computePostCheck(), and FEProblemBase::hasDampers().

◆ _has_exception

bool FEProblemBase::_has_exception
protectedinherited

Whether or not an exception has occurred.

Definition at line 3063 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::hasException(), and FEProblemBase::setException().

◆ _has_initialized_stateful

bool FEProblemBase::_has_initialized_stateful
protectedinherited

Whether nor not stateful materials have been initialized.

Definition at line 3003 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup(), and FEProblemBase::meshChanged().

◆ _has_jacobian

bool FEProblemBase::_has_jacobian
protectedinherited

Indicates if the Jacobian was computed.

Definition at line 3009 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::hasJacobian(), and FEProblemBase::meshChanged().

◆ _has_nonlocal_coupling

bool FEProblemBase::_has_nonlocal_coupling
protectedinherited

◆ _has_time_integrator

bool FEProblemBase::_has_time_integrator
protectedinherited

Indicates whether or not this executioner has a time integrator (during setup)

Definition at line 3060 of file FEProblemBase.h.

Referenced by FEProblemBase::addTimeIntegrator(), and FEProblemBase::hasTimeIntegrator().

◆ _have_ad_objects

bool SubProblem::_have_ad_objects
protectedinherited

AD flag indicating whether any AD objects have been added.

Definition at line 1114 of file SubProblem.h.

Referenced by DisplacedProblem::haveADObjects(), SubProblem::haveADObjects(), and FEProblemBase::haveADObjects().

◆ _ics

InitialConditionWarehouse FEProblemBase::_ics
protectedinherited

◆ _indicators

MooseObjectWarehouse<Indicator> FEProblemBase::_indicators
protectedinherited

◆ _initialized

bool FEProblemBase::_initialized
protectedinherited

Definition at line 2715 of file FEProblemBase.h.

Referenced by FEProblemBase::init().

◆ _input_file_saved

bool FEProblemBase::_input_file_saved
protectedinherited

whether input file has been written

Definition at line 2985 of file FEProblemBase.h.

◆ _interface_mat_side_cache

std::vector<std::unordered_map<BoundaryID, bool> > FEProblemBase::_interface_mat_side_cache
protectedinherited

Cache for calculating materials on interface.

Definition at line 2912 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), and FEProblemBase::needInterfaceMaterialOnSide().

◆ _interface_materials

MaterialWarehouse FEProblemBase::_interface_materials
protectedinherited

◆ _internal_side_indicators

MooseObjectWarehouse<InternalSideIndicatorBase> FEProblemBase::_internal_side_indicators
protectedinherited

◆ _is_petsc_options_inserted

bool FEProblemBase::_is_petsc_options_inserted
protectedinherited

If or not PETSc options have been added to database.

Definition at line 3093 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::petscOptionsInserted(), FEProblemBase::solve(), and FEProblemBase::solveLinearSystem().

◆ _kernel_coverage_blocks

std::vector<SubdomainName> FEProblemBase::_kernel_coverage_blocks
protectedinherited

◆ _kernel_coverage_check

CoverageCheckMode FEProblemBase::_kernel_coverage_check
protectedinherited

Determines whether and which subdomains are to be checked to ensure that they have an active kernel.

Definition at line 3029 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::FEProblemBase(), and FEProblemBase::setKernelCoverageCheck().

◆ _kokkos_assembly

Moose::Kokkos::Assembly FEProblemBase::_kokkos_assembly
protectedinherited

Definition at line 2819 of file FEProblemBase.h.

Referenced by FEProblemBase::kokkosAssembly().

◆ _kokkos_bnd_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_bnd_material_props
protectedinherited

◆ _kokkos_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_material_props
protectedinherited

◆ _kokkos_materials

MaterialWarehouse FEProblemBase::_kokkos_materials
protectedinherited

◆ _kokkos_neighbor_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_neighbor_material_props
protectedinherited

◆ _kokkos_systems

Moose::Kokkos::Array<Moose::Kokkos::System> FEProblemBase::_kokkos_systems
protectedinherited

Definition at line 2808 of file FEProblemBase.h.

Referenced by FEProblemBase::getKokkosSystems().

◆ _line_search

std::shared_ptr<LineSearch> FEProblemBase::_line_search
protectedinherited

◆ _linear_convergence_names

std::optional<std::vector<ConvergenceName> > FEProblemBase::_linear_convergence_names
protectedinherited

Linear system(s) convergence name(s) (if any)

Definition at line 2720 of file FEProblemBase.h.

Referenced by FEProblemBase::getLinearConvergenceNames(), FEProblemBase::hasLinearConvergenceObjects(), and FEProblemBase::setLinearConvergenceNames().

◆ _linear_matrix_tags

std::set<TagID> FEProblemBase::_linear_matrix_tags
protectedinherited

Temporary storage for filtered matrix tags for linear systems.

Definition at line 2734 of file FEProblemBase.h.

Referenced by FEProblemBase::computeLinearSystemSys().

◆ _linear_sys_name_to_num

std::map<LinearSystemName, unsigned int> FEProblemBase::_linear_sys_name_to_num
protectedinherited

Map from linear system name to number.

Definition at line 2763 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), and FEProblemBase::linearSysNum().

◆ _linear_sys_names

const std::vector<LinearSystemName> FEProblemBase::_linear_sys_names
protectedinherited

◆ _linear_systems

std::vector<std::shared_ptr<LinearSystem> > FEProblemBase::_linear_systems
protectedinherited

◆ _linear_vector_tags

std::set<TagID> FEProblemBase::_linear_vector_tags
protectedinherited

Temporary storage for filtered vector tags for linear systems.

Definition at line 2731 of file FEProblemBase.h.

Referenced by FEProblemBase::computeLinearSystemSys().

◆ _map_block_material_props

std::map<SubdomainID, std::set<std::string> > SubProblem::_map_block_material_props
protectedinherited

Map of material properties (block_id -> list of properties)

Definition at line 1052 of file SubProblem.h.

Referenced by SubProblem::checkBlockMatProps(), SubProblem::getMaterialPropertyBlocks(), SubProblem::hasBlockMaterialProperty(), and SubProblem::storeSubdomainMatPropName().

◆ _map_block_material_props_check

std::map<SubdomainID, std::multimap<std::string, std::string> > SubProblem::_map_block_material_props_check
protectedinherited

Data structures of the requested material properties.

We store them in a map from boundary/block id to multimap. Each of the multimaps is a list of requestor object names to material property names.

Definition at line 1070 of file SubProblem.h.

Referenced by SubProblem::checkBlockMatProps(), and SubProblem::storeSubdomainDelayedCheckMatProp().

◆ _map_boundary_material_props

std::map<BoundaryID, std::set<std::string> > SubProblem::_map_boundary_material_props
protectedinherited

Map for boundary material properties (boundary_id -> list of properties)

Definition at line 1055 of file SubProblem.h.

Referenced by SubProblem::checkBoundaryMatProps(), SubProblem::getMaterialPropertyBoundaryIDs(), SubProblem::hasBoundaryMaterialProperty(), and SubProblem::storeBoundaryMatPropName().

◆ _map_boundary_material_props_check

std::map<BoundaryID, std::multimap<std::string, std::string> > SubProblem::_map_boundary_material_props_check
protectedinherited

◆ _markers

MooseObjectWarehouse<Marker> FEProblemBase::_markers
protectedinherited

◆ _material_coverage_blocks

std::vector<SubdomainName> FEProblemBase::_material_coverage_blocks
protectedinherited

◆ _material_coverage_check

CoverageCheckMode FEProblemBase::_material_coverage_check
protectedinherited

Determines whether and which subdomains are to be checked to ensure that they have an active material.

Definition at line 3041 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::FEProblemBase(), and FEProblemBase::setMaterialCoverageCheck().

◆ _material_dependency_check

const bool FEProblemBase::_material_dependency_check
protectedinherited

Determines whether a check to verify material dependencies on every subdomain.

Definition at line 3048 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity().

◆ _material_prop_registry

MaterialPropertyRegistry FEProblemBase::_material_prop_registry
protectedinherited

◆ _material_property_requested

std::set<std::string> SubProblem::_material_property_requested
protectedinherited

set containing all material property names that have been requested by getMaterialProperty*

Definition at line 1062 of file SubProblem.h.

Referenced by SubProblem::isMatPropRequested(), and SubProblem::markMatPropRequested().

◆ _material_props

MaterialPropertyStorage& FEProblemBase::_material_props
protectedinherited

◆ _materials

MaterialWarehouse FEProblemBase::_materials
protectedinherited

◆ _matrix_tag_id_to_tag_name

std::map<TagID, TagName> SubProblem::_matrix_tag_id_to_tag_name
protectedinherited

Reverse map.

Definition at line 1044 of file SubProblem.h.

Referenced by SubProblem::addMatrixTag(), SubProblem::matrixTagExists(), and SubProblem::matrixTagName().

◆ _matrix_tag_name_to_tag_id

std::map<TagName, TagID> SubProblem::_matrix_tag_name_to_tag_id
protectedinherited

◆ _max_qps

unsigned int FEProblemBase::_max_qps
protectedinherited

Maximum number of quadrature points used in the problem.

Definition at line 3054 of file FEProblemBase.h.

Referenced by FEProblemBase::getMaxQps(), FEProblemBase::reinitDirac(), and FEProblemBase::updateMaxQps().

◆ _max_scalar_order

libMesh::Order FEProblemBase::_max_scalar_order
protectedinherited

Maximum scalar variable order.

Definition at line 3057 of file FEProblemBase.h.

Referenced by FEProblemBase::addAuxScalarVariable(), and FEProblemBase::getMaxScalarOrder().

◆ _mesh

MooseMesh& FEProblemBase::_mesh
protectedinherited

◆ _mesh_divisions

MooseObjectWarehouse<MeshDivision> FEProblemBase::_mesh_divisions
protectedinherited

Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the Problem Time (and people's uses) will tell where this fits best.

Definition at line 2825 of file FEProblemBase.h.

Referenced by FEProblemBase::addMeshDivision(), and FEProblemBase::getMeshDivision().

◆ _mortar_data

MortarData FEProblemBase::_mortar_data
protectedinherited

◆ _multi_apps

ExecuteMooseObjectWarehouse<MultiApp> FEProblemBase::_multi_apps
protectedinherited

◆ _multiapp_fixed_point_convergence_name

std::optional<ConvergenceName> FEProblemBase::_multiapp_fixed_point_convergence_name
protectedinherited

◆ _name

const std::string& MooseBase::_name
protectedinherited

The name of this class.

Definition at line 363 of file MooseBase.h.

Referenced by AddBCAction::act(), AddConstraintAction::act(), AddDamperAction::act(), AddFVInitialConditionAction::act(), AddNodalKernelAction::act(), AddFVInterfaceKernelAction::act(), AddDGKernelAction::act(), AddPostprocessorAction::act(), AddScalarKernelAction::act(), AddDiracKernelAction::act(), AddIndicatorAction::act(), AddInitialConditionAction::act(), AddTransferAction::act(), AddUserObjectAction::act(), AddInterfaceKernelAction::act(), AddVectorPostprocessorAction::act(), AddKernelAction::act(), PartitionerAction::act(), ReadExecutorParamsAction::act(), AddFunctorMaterialAction::act(), AddMarkerAction::act(), AddMaterialAction::act(), AddMeshGeneratorAction::act(), AddMultiAppAction::act(), AddPositionsAction::act(), AddReporterAction::act(), AddTimesAction::act(), AddFieldSplitAction::act(), AddFVKernelAction::act(), AddFVBCAction::act(), AddHDGKernelAction::act(), AddTimeStepperAction::act(), AddDistributionAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddFunctionAction::act(), AddConvergenceAction::act(), AddMeshDivisionAction::act(), AddOutputAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddCorrectorAction::act(), AddMeshModifiersAction::act(), AddSamplerAction::act(), AddControlAction::act(), AddMFEMFESpaceAction::act(), AddMFEMPreconditionerAction::act(), AddMFEMSolverAction::act(), AddMFEMSubMeshAction::act(), AddPeriodicBCAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenSidesetsGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), MooseBase::MooseBase(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::name(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseBase::setData(), and AddVariableAction::varName().

◆ _need_to_add_default_multiapp_fixed_point_convergence

bool FEProblemBase::_need_to_add_default_multiapp_fixed_point_convergence
protectedinherited

Flag that the problem needs to add the default fixed point convergence.

Definition at line 2749 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultMultiAppFixedPointConvergence(), and FEProblemBase::setNeedToAddDefaultMultiAppFixedPointConvergence().

◆ _need_to_add_default_nonlinear_convergence

bool FEProblemBase::_need_to_add_default_nonlinear_convergence
protectedinherited

Flag that the problem needs to add the default nonlinear convergence.

Definition at line 2747 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultNonlinearConvergence(), and FEProblemBase::setNeedToAddDefaultNonlinearConvergence().

◆ _need_to_add_default_steady_state_convergence

bool FEProblemBase::_need_to_add_default_steady_state_convergence
protectedinherited

Flag that the problem needs to add the default steady convergence.

Definition at line 2751 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultSteadyStateConvergence(), and FEProblemBase::setNeedToAddDefaultSteadyStateConvergence().

◆ _needs_old_newton_iter

bool FEProblemBase::_needs_old_newton_iter
protectedinherited

Indicates that we need to compute variable values for previous Newton iteration.

Definition at line 3012 of file FEProblemBase.h.

◆ _neighbor_material_props

MaterialPropertyStorage& FEProblemBase::_neighbor_material_props
protectedinherited

◆ _nl

std::vector<std::shared_ptr<NonlinearSystemBase> > FEProblemBase::_nl
protectedinherited

The nonlinear systems.

Definition at line 2778 of file FEProblemBase.h.

Referenced by FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addPredictor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::checkNonlocalCoupling(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::computingPreSMOResidual(), FEProblemBase::currentNlSysNum(), FEProblemBase::customSetup(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::finalNonlinearResidual(), FEProblemBase::getNonlinearEvaluableElementRange(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getNonlinearSystemBase(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::jacobianSetup(), FEProblemBase::meshChanged(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needInterfaceMaterialOnSide(), FEProblemBase::needSubdomainMaterialOnSide(), FEProblemBase::nLinearIterations(), FEProblemBase::nNonlinearIterations(), FEProblemBase::onTimestepBegin(), FEProblemBase::prepareFace(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::reinitDirac(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitNodes(), FEProblemBase::reinitNodesNeighbor(), FEProblemBase::reinitScalars(), FEProblemBase::residualSetup(), FEProblemBase::setCurrentNonlinearSystem(), FEProblemBase::setNonlocalCouplingMatrix(), FEProblemBase::setResidual(), FEProblemBase::setResidualObjectParamsAndLog(), FEProblemBase::setupDampers(), FEProblemBase::subdomainSetup(), FEProblemBase::systemBaseNonlinear(), FEProblemBase::updateActiveObjects(), and FEProblemBase::updateMeshXFEM().

◆ _nl_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_nl_evaluable_local_elem_range
protectedinherited

◆ _nl_sys_name_to_num

std::map<NonlinearSystemName, unsigned int> FEProblemBase::_nl_sys_name_to_num
protectedinherited

Map from nonlinear system name to number.

Definition at line 2781 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), and FEProblemBase::nlSysNum().

◆ _nl_sys_names

const std::vector<NonlinearSystemName> FEProblemBase::_nl_sys_names
protectedinherited

◆ _nonlinear_convergence_names

std::optional<std::vector<ConvergenceName> > FEProblemBase::_nonlinear_convergence_names
protectedinherited

Nonlinear system(s) convergence name(s)

Definition at line 2718 of file FEProblemBase.h.

Referenced by FEProblemBase::getNonlinearConvergenceNames(), and FEProblemBase::setNonlinearConvergenceNames().

◆ _nonlocal_integrated_bcs

MooseObjectWarehouse<IntegratedBCBase> FEProblemBase::_nonlocal_integrated_bcs
protectedinherited

◆ _nonlocal_kernels

MooseObjectWarehouse<KernelBase> FEProblemBase::_nonlocal_kernels
protectedinherited

◆ _not_zeroed_tagged_vectors

std::unordered_set<TagID> SubProblem::_not_zeroed_tagged_vectors
protectedinherited

the list of vector tags that will not be zeroed when all other tags are

Definition at line 1117 of file SubProblem.h.

Referenced by SubProblem::addNotZeroedVectorTag(), FEProblemBase::restoreSolutions(), and SubProblem::vectorTagNotZeroed().

◆ _notify_when_mesh_changes

std::vector<MeshChangedInterface *> FEProblemBase::_notify_when_mesh_changes
protectedinherited

Objects to be notified when the mesh changes.

Definition at line 2915 of file FEProblemBase.h.

Referenced by FEProblemBase::meshChanged(), and FEProblemBase::notifyWhenMeshChanges().

◆ _notify_when_mesh_displaces

std::vector<MeshDisplacedInterface *> FEProblemBase::_notify_when_mesh_displaces
protectedinherited

Objects to be notified when the mesh displaces.

Definition at line 2918 of file FEProblemBase.h.

Referenced by FEProblemBase::meshDisplaced(), and FEProblemBase::notifyWhenMeshDisplaces().

◆ _num_linear_sys

const std::size_t FEProblemBase::_num_linear_sys
protectedinherited

◆ _num_nl_sys

const std::size_t FEProblemBase::_num_nl_sys
protectedinherited

◆ _parallel_barrier_messaging

bool FEProblemBase::_parallel_barrier_messaging
protectedinherited

◆ _pars

const InputParameters& MooseBase::_pars
protectedinherited

The object's parameters.

Definition at line 366 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _petsc_option_data_base

PetscOptions FEProblemBase::_petsc_option_data_base
protectedinherited

◆ _petsc_options

Moose::PetscSupport::PetscOptions FEProblemBase::_petsc_options
protectedinherited

PETSc option storage.

Definition at line 3087 of file FEProblemBase.h.

Referenced by FEProblemBase::getPetscOptions(), FEProblemBase::solve(), and FEProblemBase::solveLinearSystem().

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app
protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _phi_zero

std::vector<VariablePhiValue> FEProblemBase::_phi_zero
inherited

◆ _point_zero

std::vector<Point> FEProblemBase::_point_zero
inherited

Definition at line 2207 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase().

◆ _prefix

const std::string PerfGraphInterface::_prefix
protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _previous_nl_solution_required

bool FEProblemBase::_previous_nl_solution_required
protectedinherited

Indicates we need to save the previous NL iteration variable values.

Definition at line 3015 of file FEProblemBase.h.

Referenced by FEProblemBase::createTagSolutions().

◆ _problem_data

MFEMProblemData MFEMProblem::_problem_data
protected

Definition at line 209 of file MFEMProblem.h.

Referenced by getCoefficients(), getMeshDisplacementGridFunction(), and getProblemData().

◆ _random_data_objects

std::map<std::string, std::unique_ptr<RandomData> > FEProblemBase::_random_data_objects
protectedinherited

◆ _real_zero

std::vector<Real> FEProblemBase::_real_zero
inherited

Convenience zeros.

Definition at line 2196 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase().

◆ _reinit_displaced_elem

bool FEProblemBase::_reinit_displaced_elem
protectedinherited

◆ _reinit_displaced_face

bool FEProblemBase::_reinit_displaced_face
protectedinherited

◆ _reinit_displaced_neighbor

bool FEProblemBase::_reinit_displaced_neighbor
protectedinherited

◆ _reporter_data

ReporterData FEProblemBase::_reporter_data
protectedinherited

◆ _restartable_app

MooseApp& Restartable::_restartable_app
protectedinherited

Reference to the application.

Definition at line 234 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

◆ _restartable_read_only

const bool Restartable::_restartable_read_only
protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _restartable_system_name

const std::string Restartable::_restartable_system_name
protectedinherited

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by Restartable::restartableName().

◆ _restartable_tid

const THREAD_ID Restartable::_restartable_tid
protectedinherited

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

◆ _safe_access_tagged_matrices

bool SubProblem::_safe_access_tagged_matrices
protectedinherited

◆ _safe_access_tagged_vectors

bool SubProblem::_safe_access_tagged_vectors
protectedinherited

◆ _scalar_ics

ScalarInitialConditionWarehouse FEProblemBase::_scalar_ics
protectedinherited

◆ _scalar_zero

std::vector<VariableValue> FEProblemBase::_scalar_zero
inherited

◆ _second_phi_zero

std::vector<VariablePhiSecond> FEProblemBase::_second_phi_zero
inherited

◆ _second_zero

std::vector<VariableSecond> FEProblemBase::_second_zero
inherited

◆ _skip_exception_check

bool FEProblemBase::_skip_exception_check
protectedinherited

If or not skip 'exception and stop solve'.

Definition at line 2997 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::initialSetup(), and FEProblemBase::skipExceptionCheck().

◆ _snesmf_reuse_base

bool FEProblemBase::_snesmf_reuse_base
protectedinherited

If or not to resuse the base vector for matrix-free calculation.

Definition at line 2994 of file FEProblemBase.h.

Referenced by FEProblemBase::setSNESMFReuseBase(), and FEProblemBase::useSNESMFReuseBase().

◆ _snesmf_reuse_base_set_by_user

bool FEProblemBase::_snesmf_reuse_base_set_by_user
protectedinherited

If or not _snesmf_reuse_base is set by user.

Definition at line 3000 of file FEProblemBase.h.

Referenced by FEProblemBase::isSNESMFReuseBaseSetbyUser(), and FEProblemBase::setSNESMFReuseBase().

◆ _solve

const bool& FEProblemBase::_solve
protectedinherited

◆ _solver_params

std::vector<SolverParams> FEProblemBase::_solver_params
protectedinherited

◆ _solver_sys_name_to_num

std::map<SolverSystemName, unsigned int> FEProblemBase::_solver_sys_name_to_num
protectedinherited

Map connecting solver system names with their respective systems.

Definition at line 2796 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), and FEProblemBase::solverSysNum().

◆ _solver_sys_names

std::vector<SolverSystemName> FEProblemBase::_solver_sys_names
protectedinherited

◆ _solver_systems

std::vector<std::shared_ptr<SolverSystem> > FEProblemBase::_solver_systems
protectedinherited

Combined container to base pointer of every solver system.

Definition at line 2790 of file FEProblemBase.h.

Referenced by FEProblemBase::addAuxKernel(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addVariable(), FEProblemBase::advanceState(), FEProblemBase::computeSystems(), FEProblemBase::copySolutionsBackwards(), FEProblemBase::createQRules(), FEProblemBase::createTagMatrices(), FEProblemBase::createTagSolutions(), FEProblemBase::createTagVectors(), FEProblemBase::determineSolverSystem(), DumpObjectsProblem::DumpObjectsProblem(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::getActualFieldVariable(), FEProblemBase::getArrayVariable(), FEProblemBase::getScalarVariable(), FEProblemBase::getSolverSystem(), FEProblemBase::getStandardVariable(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), FEProblemBase::getVariable(), FEProblemBase::getVariableNames(), FEProblemBase::getVectorVariable(), FEProblemBase::hasScalarVariable(), FEProblemBase::hasSolverVariable(), FEProblemBase::hasVariable(), FEProblem::init(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::meshChanged(), FEProblemBase::needSolutionState(), FEProblemBase::outputStep(), FEProblemBase::projectSolution(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemPhys(), FEProblemBase::restoreOldSolutions(), FEProblemBase::restoreSolutions(), FEProblemBase::saveOldSolutions(), FEProblemBase::setCurrentSubdomainID(), Moose::PetscSupport::setSinglePetscOption(), FEProblemBase::setVariableAllDoFMap(), FEProblemBase::solverSystemConverged(), FEProblemBase::systemBaseSolver(), FEProblemBase::systemNumForVariable(), and FEProblemBase::timestepSetup().

◆ _solver_var_to_sys_num

std::map<SolverVariableName, unsigned int> FEProblemBase::_solver_var_to_sys_num
protectedinherited

Map connecting variable names with their respective solver systems.

Definition at line 2793 of file FEProblemBase.h.

Referenced by FEProblemBase::addVariable(), and FEProblemBase::determineSolverSystem().

◆ _steady_state_convergence_name

std::optional<ConvergenceName> FEProblemBase::_steady_state_convergence_name
protectedinherited

◆ _subspace_dim

std::map<std::string, unsigned int> FEProblemBase::_subspace_dim
protectedinherited

Dimension of the subspace spanned by the vectors with a given prefix.

Definition at line 2812 of file FEProblemBase.h.

Referenced by FEProblemBase::initNullSpaceVectors(), and FEProblemBase::subspaceDim().

◆ _t_step

int& FEProblemBase::_t_step
protectedinherited

◆ _termination_requested

bool Problem::_termination_requested
protectedinherited

True if termination of the solve has been requested.

Definition at line 58 of file Problem.h.

Referenced by Problem::isSolveTerminationRequested(), and Problem::terminateSolve().

◆ _time

Real& FEProblemBase::_time
protectedinherited

◆ _time_old

Real& FEProblemBase::_time_old
protectedinherited

◆ _to_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_to_multi_app_transfers
protectedinherited

◆ _transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_transfers
protectedinherited

◆ _transient

bool FEProblemBase::_transient
protectedinherited

Definition at line 2739 of file FEProblemBase.h.

Referenced by FEProblemBase::isTransient(), and FEProblemBase::transient().

◆ _transient_multi_apps

ExecuteMooseObjectWarehouse<TransientMultiApp> FEProblemBase::_transient_multi_apps
protectedinherited

Storage for TransientMultiApps (only needed for calling 'computeDT')

Definition at line 2888 of file FEProblemBase.h.

Referenced by FEProblemBase::addMultiApp(), FEProblemBase::computeMultiAppsDT(), and FEProblemBase::updateActiveObjects().

◆ _type

const std::string& MooseBase::_type
protectedinherited

◆ _uo_aux_state_check

const bool FEProblemBase::_uo_aux_state_check
protectedinherited

Whether or not checking the state of uo/aux evaluation.

Definition at line 3051 of file FEProblemBase.h.

Referenced by FEProblemBase::execute(), and FEProblemBase::hasUOAuxStateCheck().

◆ _uo_jacobian_moose_vars

std::vector<std::vector<const MooseVariableFEBase *> > FEProblemBase::_uo_jacobian_moose_vars
protectedinherited

◆ _use_hash_table_matrix_assembly

const bool FEProblemBase::_use_hash_table_matrix_assembly
protectedinherited

Whether to assemble matrices using hash tables instead of preallocating matrix memory.

This can be a good option if the sparsity pattern changes throughout the course of the simulation

Definition at line 3114 of file FEProblemBase.h.

Referenced by EigenProblem::EigenProblem(), and FEProblem::FEProblem().

◆ _using_ad_mat_props

bool FEProblemBase::_using_ad_mat_props
protectedinherited

Automatic differentiaion (AD) flag which indicates whether any consumer has requested an AD material property or whether any suppier has declared an AD material property.

Definition at line 3107 of file FEProblemBase.h.

◆ _using_default_nl

const bool FEProblemBase::_using_default_nl
protectedinherited

Boolean to check if we have the default nonlinear system.

Definition at line 2769 of file FEProblemBase.h.

◆ _var_dof_map

std::map<std::string, std::vector<dof_id_type> > SubProblem::_var_dof_map
inherited

◆ _vector_curl_zero

std::vector<VectorVariableCurl> FEProblemBase::_vector_curl_zero
inherited

◆ _vector_zero

std::vector<VectorVariableValue> FEProblemBase::_vector_zero
inherited

◆ _verbose_multiapps

bool FEProblemBase::_verbose_multiapps
protectedinherited

◆ _verbose_restore

bool FEProblemBase::_verbose_restore
protectedinherited

Whether or not to be verbose on solution restoration post a failed time step.

Definition at line 3075 of file FEProblemBase.h.

Referenced by FEProblemBase::restoreSolutions(), and FEProblemBase::setVerboseProblem().

◆ _verbose_setup

MooseEnum FEProblemBase::_verbose_setup
protectedinherited

Whether or not to be verbose during setup.

Definition at line 3069 of file FEProblemBase.h.

Referenced by FEProblemBase::logAdd(), and FEProblemBase::setVerboseProblem().

◆ _xfem

std::shared_ptr<XFEMInterface> FEProblemBase::_xfem
protectedinherited

Pointer to XFEM controller.

Definition at line 2969 of file FEProblemBase.h.

Referenced by FEProblemBase::getXFEM(), FEProblemBase::haveXFEM(), FEProblemBase::initXFEM(), and FEProblemBase::updateMeshXFEM().

◆ _zero

std::vector<VariableValue> FEProblemBase::_zero
inherited

◆ _zero_block_material_props

std::map<SubdomainID, std::set<MaterialPropertyName> > SubProblem::_zero_block_material_props
protectedinherited

Set of properties returned as zero properties.

Definition at line 1058 of file SubProblem.h.

Referenced by SubProblem::checkBlockMatProps(), FEProblemBase::checkDependMaterialsHelper(), and SubProblem::storeSubdomainZeroMatProp().

◆ _zero_boundary_material_props

std::map<BoundaryID, std::set<MaterialPropertyName> > SubProblem::_zero_boundary_material_props
protectedinherited

◆ app_param

const std::string MooseBase::app_param = "_moose_app"
staticinherited

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"
staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by MooseObject::isKokkosObject().

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"
staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ name_param

const std::string MooseBase::name_param = "_object_name"
staticinherited

◆ type_param

const std::string MooseBase::type_param = "_type"
staticinherited

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"
staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().


The documentation for this class was generated from the following files: