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

Problem for solving eigenvalue problems. More...

#include <EigenProblem.h>

Inheritance diagram for EigenProblem:
[legend]

Public Types

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

 EigenProblem (const InputParameters &parameters)
 
virtual std::string solverTypeString (unsigned int solver_sys_num=0) override
 Return solver type as a human readable string. More...
 
virtual void solve (const unsigned int nl_sys_num) override
 
virtual void init () override
 
virtual bool solverSystemConverged (const unsigned int solver_sys_num) override
 
unsigned int getNEigenPairsRequired () const
 
void setNEigenPairsRequired (unsigned int n_eigen_pairs)
 
bool isGeneralizedEigenvalueProblem () const
 
bool isNonlinearEigenvalueSolver (unsigned int eigen_sys_num) const
 
NonlinearEigenSystemgetNonlinearEigenSystem (const unsigned int nl_sys_num)
 
NonlinearEigenSystemgetCurrentNonlinearEigenSystem ()
 
virtual void checkProblemIntegrity () override
 Method called to perform a series of sanity checks before a simulation is run. More...
 
bool negativeSignEigenKernel () const
 A flag indicates if a negative sign is used in eigen kernels. More...
 
void setNormalization (const PostprocessorName &pp, const Real value=std::numeric_limits< Real >::max())
 Set postprocessor and normalization factor 'Postprocessor' is often used to compute an integral of physics variables. More...
 
void setInitialEigenvalue (const Real initial_eigenvalue)
 Set an initial eigenvalue for initial normalization. More...
 
bool doFreePowerIteration () const
 Whether or not we are doing free power iteration. More...
 
void doFreePowerIteration (bool do_power)
 Set a flag to indicate whether or not we are doing free power iterations. More...
 
void preScaleEigenVector (const std::pair< Real, Real > &eig)
 Eigenvector need to be scaled back if it was scaled in an earlier stage Scaling eigen vector does not affect solution (eigenvalue, eigenvector), but it does affect the convergence rate. More...
 
void postScaleEigenVector ()
 Normalize eigen vector. More...
 
void scaleEigenvector (const Real scaling_factor)
 Scale eigenvector. More...
 
void setEigenproblemType (Moose::EigenProblemType eigen_problem_type)
 Set eigen problem type. More...
 
virtual Real computeResidualL2Norm () override
 Compute the residual of Ax - Bx. More...
 
virtual void computeJacobianTag (const NumericVector< Number > &soln, SparseMatrix< Number > &jacobian, TagID tag) override
 Form a Jacobian matrix for all kernels and BCs with a given tag. More...
 
void computeMatricesTags (const NumericVector< Number > &soln, const std::vector< SparseMatrix< Number > *> &jacobians, const std::set< TagID > &tags)
 Form several matrices simultaneously. More...
 
void computeJacobianAB (const NumericVector< Number > &soln, SparseMatrix< Number > &jacobianA, SparseMatrix< Number > &jacobianB, TagID tagA, TagID tagB)
 Form two Jacobian matrices, where each is associated with one tag, through one element-loop. More...
 
virtual void computeJacobianBlocks (std::vector< JacobianBlock *> &blocks, const unsigned int nl_sys_num) override
 Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices. More...
 
virtual void computeResidualTag (const NumericVector< Number > &soln, NumericVector< Number > &residual, TagID tag) override
 Form a vector for all kernels and BCs with a given tag. More...
 
void computeResidualAB (const NumericVector< Number > &soln, NumericVector< Number > &residualA, NumericVector< Number > &residualB, TagID tagA, TagID tagB)
 Form two vetors, where each is associated with one tag, through one element-loop. More...
 
virtual void execute (const ExecFlagType &exec_type) override
 Convenience function for performing execution of MOOSE systems. More...
 
void initEigenvector (const Real initial_value)
 For nonlinear eigen solver, a good initial value can help convergence. More...
 
unsigned int activeEigenvalueIndex () const
 Which eigenvalue is active. More...
 
virtual void initPetscOutputAndSomeSolverSettings () override
 Hook up monitors for SNES and KSP. More...
 
bool outputInverseEigenvalue () const
 Whether or not to output eigenvalue inverse. More...
 
void outputInverseEigenvalue (bool inverse)
 Set a flag to indicate whether or not to output eigenvalue inverse. More...
 
bool onLinearSolver () const
 Whether or not we are in a linear solver iteration. More...
 
void onLinearSolver (bool ols)
 Set a flag to indicate whether or not we are in a linear solver iteration. More...
 
bool constantMatrices () const
 Whether or not matrices are constant. More...
 
void constantMatrices (bool cm)
 Set a flag to indicate whether or not we use constant matrices. More...
 
bool wereMatricesFormed () const
 Whether or not constant matrices were already formed. More...
 
void wereMatricesFormed (bool mf)
 Set a flag to indicate whether or not constant matrices were already formed. More...
 
Real formNorm ()
 Form the Bx norm. More...
 
bool bxNormProvided () const
 Whether a Bx norm postprocessor has been provided. More...
 
void setBxNorm (const PostprocessorName &bx_norm)
 Set the Bx norm postprocessor programatically. 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 libMesh::EquationSystemses () override
 
virtual MooseMeshmesh () override
 
virtual const MooseMeshmesh () const 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...
 
const RestartableEquationSystemsgetRestartableEquationSystems () const
 Get the RestartableEquationSystems object. 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 initialSetup () override
 
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)
 
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 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...
 
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 void addFunction (const std::string &type, const std::string &name, InputParameters &parameters)
 
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
 
Moose::Kokkos::SystemgetKokkosSystem (const unsigned int sys_num)
 Get the Kokkos system of a specified number that is associated with MOOSE nonlinear and auxiliary systems. More...
 
const Moose::Kokkos::SystemgetKokkosSystem (const unsigned int sys_num) 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 addVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)
 Canonical method for adding a non-linear variable. More...
 
virtual void addKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
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 addBoundaryCondition (const std::string &bc_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_type, const std::string &var_name, InputParameters &params)
 Canonical method for adding an auxiliary variable. More...
 
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 addAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addAuxScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
 
virtual void addKokkosAuxKernel (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 addInitialCondition (const std::string &ic_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 addMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
 
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 addFunctorMaterial (const std::string &functor_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 reinitMaterialsFaceOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
 reinit materials on element faces on a boundary (internal or external) This specific routine helps us not reinit when don't need to More...
 
void reinitMaterialsNeighborOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
 reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specific routine helps us not reinit when don't need to 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 addPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)
 
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...
 
virtual void addTransfer (const std::string &transfer_name, const std::string &name, InputParameters &parameters)
 Add a Transfer to the problem. 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 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 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 ()
 
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 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
 
virtual Moose::FEBackend feBackend () const
 
void createTagMatrices (CreateTaggedMatrixKey)
 
bool hasKokkosObjects () const
 
bool hasKokkosResidualObjects () 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...
 
void setChainControlDataOutput (bool set_output)
 Setter for debug chain control data 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 paramWarning (const std::string &param, Args... args) const
 
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 mooseWarning (Args &&... args) const
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 Emits a warning without the prefixing included in mooseWarning(). More...
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 
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 needInternalNeighborSideMaterial (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
 
 usingCombinedWarningSolutionWarnings
 
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...
 
template<bool warning>
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 Set solution invalid mark for the given solution ID. More...
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 
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

unsigned int _n_eigen_pairs_required
 
bool _generalized_eigenvalue_problem
 
std::shared_ptr< NonlinearEigenSystem_nl_eigen
 
bool _negative_sign_eigen_kernel
 Whether or not use negative sign for Bx. More...
 
unsigned int _active_eigen_index
 Which eigenvalue is used to compute residual. More...
 
bool _do_free_power_iteration
 Whether or not we are doing free power iteration. More...
 
bool _output_inverse_eigenvalue
 Whether or not output eigenvalue as its inverse. By default, we output regular eigenvalue. More...
 
bool _on_linear_solver
 Whether or not we are in linear solver. More...
 
bool _matrices_formed
 Whether or not matrices had been formed. More...
 
bool _constant_matrices
 Whether or not require constant matrices. More...
 
bool _has_normalization
 Whether or not we normalize eigenvector. More...
 
PostprocessorName _normalization
 Postprocessor used to compute a factor from eigenvector. More...
 
Real _normal_factor
 Postprocessor target value. More...
 
bool & _first_solve
 A flag to indicate if it is the first time calling the solve. More...
 
Real _initial_eigenvalue
 A value used for initial normalization. More...
 
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::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
 

Private Member Functions

void doFreeNonlinearPowerIterations (unsigned int free_power_iterations)
 Do some free/extra power iterations. More...
 
void adjustEigenVector (const Real value, bool scaling)
 Adjust eigen vector by either scaling the existing values or setting new values The operations are applied for only eigen variables. More...
 

Private Attributes

std::optional< PostprocessorName > _bx_norm_name
 The name of the Postprocessor providing the Bx norm. More...
 
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
 The nonlinear systems. More...
 

Detailed Description

Problem for solving eigenvalue problems.

Definition at line 21 of file EigenProblem.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  };

Constructor & Destructor Documentation

◆ EigenProblem()

EigenProblem::EigenProblem ( const InputParameters parameters)

Definition at line 57 of file EigenProblem.C.

59 #ifdef LIBMESH_HAVE_SLEPC
60  ,
61  // By default, we want to compute an eigenvalue only (smallest or largest)
64  _negative_sign_eigen_kernel(getParam<bool>("negative_sign_eigen_kernel")),
65  _active_eigen_index(getParam<unsigned int>("active_eigen_index")),
68  _on_linear_solver(false),
69  _matrices_formed(false),
70  _constant_matrices(false),
71  _has_normalization(false),
72  _normal_factor(1.0),
73  _first_solve(declareRestartableData<bool>("first_solve", true)),
74  _bx_norm_name(isParamValid("bx_norm")
75  ? std::make_optional(getParam<PostprocessorName>("bx_norm"))
76  : std::nullopt)
77 #endif
78 {
79 #ifdef LIBMESH_HAVE_SLEPC
80  if (_nl_sys_names.size() > 1)
81  paramError("nl_sys_names",
82  "eigen problems do not currently support multiple nonlinear eigen systems");
83  if (_linear_sys_names.size())
84  paramError("linear_sys_names", "EigenProblem only works with a single nonlinear eigen system");
85 
86  for (const auto i : index_range(_nl_sys_names))
87  {
88  const auto & sys_name = _nl_sys_names[i];
89  auto & nl = _nl[i];
90  nl = std::make_shared<NonlinearEigenSystem>(*this, sys_name);
92  _current_nl_sys = nl.get();
95  }
96 
97  _aux = std::make_shared<AuxiliarySystem>(*this, "aux0");
98 
100 
102 
103  es().parameters.set<EigenProblem *>("_eigen_problem") = this;
104 #else
105  mooseError("Need to install SLEPc to solve eigenvalue problems, please reconfigure\n");
106 #endif /* LIBMESH_HAVE_SLEPC */
107 
108  // SLEPc older than 3.13.0 can not take initial guess from moose
109 #if PETSC_RELEASE_LESS_THAN(3, 13, 0)
111  "Please use SLEPc-3.13.0 or higher. Old versions of SLEPc likely produce bad convergence");
112 #endif
113  // Create extra vectors if any
115 
116  // Create extra solution vectors if any
118 }
119 
120 #ifdef LIBMESH_HAVE_SLEPC
121 void
123 {
124  switch (eigen_problem_type)
125  {
127  _nl_eigen->sys().set_eigenproblem_type(libMesh::HEP);
129  break;
130 
132  _nl_eigen->sys().set_eigenproblem_type(libMesh::NHEP);
134  break;
135 
137  _nl_eigen->sys().set_eigenproblem_type(libMesh::GHEP);
139  break;
140 
142  _nl_eigen->sys().set_eigenproblem_type(libMesh::GHIEP);
144  break;
145 
147  _nl_eigen->sys().set_eigenproblem_type(libMesh::GNHEP);
149  break;
150 
152  mooseError("libMesh does not support EPT_POS_GEN_NON_HERMITIAN currently \n");
153  break;
154 
157  break;
158 
159  default:
160  mooseError("Unknown eigen solver type \n");
161  }
162 }
Nonlinear eigenvalue system to be solved.
Generalized Non-Hermitian.
Definition: MooseTypes.h:877
bool _matrices_formed
Whether or not matrices had been formed.
Definition: EigenProblem.h:260
Generalized Hermitian indefinite.
Definition: MooseTypes.h:876
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
bool _on_linear_solver
Whether or not we are in linear solver.
Definition: EigenProblem.h:258
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
virtual void newAssemblyArray(std::vector< std::shared_ptr< SolverSystem >> &solver_systems)
bool _has_normalization
Whether or not we normalize eigenvector.
Definition: EigenProblem.h:264
virtual libMesh::System & system()=0
Get the reference to the libMesh system.
unsigned int _n_eigen_pairs_required
Definition: EigenProblem.h:240
bool _output_inverse_eigenvalue
Whether or not output eigenvalue as its inverse. By default, we output regular eigenvalue.
Definition: EigenProblem.h:256
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
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.
use whatever SLPEC has by default
Definition: MooseTypes.h:879
bool _negative_sign_eigen_kernel
Whether or not use negative sign for Bx.
Definition: EigenProblem.h:246
bool _constant_matrices
Whether or not require constant matrices.
Definition: EigenProblem.h:262
Generalized Non-Hermitian with positive (semi-)definite B.
Definition: MooseTypes.h:878
FEProblemBase(const InputParameters &parameters)
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
bool _generalized_eigenvalue_problem
Definition: EigenProblem.h:241
bool _do_free_power_iteration
Whether or not we are doing free power iteration.
Definition: EigenProblem.h:254
bool & _first_solve
A flag to indicate if it is the first time calling the solve.
Definition: EigenProblem.h:271
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
void createTagSolutions()
Create extra tagged solution vectors.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
void createTagVectors()
Create extra tagged vectors and matrices.
virtual libMesh::EquationSystems & es() override
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
void mooseDeprecated(Args &&... args) const
unsigned int _active_eigen_index
Which eigenvalue is used to compute residual.
Definition: EigenProblem.h:249
virtual void initNullSpaceVectors(const InputParameters &parameters, std::vector< std::shared_ptr< NonlinearSystemBase >> &nl)
const std::vector< NonlinearSystemName > _nl_sys_names
The nonlinear system names.
void prefer_hash_table_matrix_assembly(bool preference)
T & set(const std::string &)
const std::vector< LinearSystemName > _linear_sys_names
The linear system names.
Non-Hermitian.
Definition: MooseTypes.h:874
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
Real _normal_factor
Postprocessor target value.
Definition: EigenProblem.h:269
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:199
const bool _use_hash_table_matrix_assembly
Whether to assemble matrices using hash tables instead of preallocating matrix memory.
std::optional< PostprocessorName > _bx_norm_name
The name of the Postprocessor providing the Bx norm.
Definition: EigenProblem.h:289
Problem for solving eigenvalue problems.
Definition: EigenProblem.h:21
EigenProblemType
Type of the eigen problem.
Definition: MooseTypes.h:871
void setEigenproblemType(Moose::EigenProblemType eigen_problem_type)
Set eigen problem type.
auto index_range(const T &sizable)
Generalized Hermitian.
Definition: MooseTypes.h:875

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 3961 of file FEProblemBase.C.

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

3962 {
3963  return allowInvalidSolution() || // invalid solutions are always allowed
3964  !_app.solutionInvalidity().hasInvalidSolutionError(); // if not allowed, check for errors
3965 }
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

◆ activeEigenvalueIndex()

unsigned int EigenProblem::activeEigenvalueIndex ( ) const
inline

Which eigenvalue is active.

Definition at line 176 of file EigenProblem.h.

Referenced by NonlinearEigenSystem::solve().

176 { return _active_eigen_index; }
unsigned int _active_eigen_index
Which eigenvalue is used to compute residual.
Definition: EigenProblem.h:249

◆ adaptivity()

Adaptivity& FEProblemBase::adaptivity ( )
inlineinherited

◆ adaptMesh()

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

Reimplemented in DumpObjectsProblem.

Definition at line 8196 of file FEProblemBase.C.

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

8197 {
8198  // reset cycle counter
8199  _cycles_completed = 0;
8200 
8202  return false;
8203 
8204  TIME_SECTION("adaptMesh", 3, "Adapting Mesh");
8205 
8206  unsigned int cycles_per_step = _adaptivity.getCyclesPerStep();
8207 
8208  bool mesh_changed = false;
8209 
8210  for (unsigned int i = 0; i < cycles_per_step; ++i)
8211  {
8212  if (!_mesh.interiorLowerDBlocks().empty() || !_mesh.boundaryLowerDBlocks().empty())
8213  mooseError("HFEM does not support mesh adaptivity currently.");
8214 
8215  // Markers were already computed once by Executioner
8216  if (_adaptivity.getRecomputeMarkersFlag() && i > 0)
8217  computeMarkers();
8218 
8219  bool mesh_changed_this_step;
8220  mesh_changed_this_step = _adaptivity.adaptMesh();
8221 
8222  if (mesh_changed_this_step)
8223  {
8224  mesh_changed = true;
8225 
8226  meshChanged(
8227  /*intermediate_change=*/true, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
8229  }
8230  else
8231  {
8232  // If the mesh didn't change, we still need to update the displaced mesh
8233  // to undo the undisplacement performed in Adaptivity::adaptMesh
8234  if (_displaced_problem)
8235  _displaced_problem->updateMesh();
8236 
8237  _console << "Mesh unchanged, skipping remaining steps..." << std::endl;
8238  break;
8239  }
8240 
8241  // Show adaptivity progress
8242  _console << std::flush;
8243  }
8244 
8245  // We're done with all intermediate changes; now get systems ready
8246  // for real if necessary.
8247  if (mesh_changed)
8248  es().reinit_systems();
8249 
8250  // Execute multi-apps that need to run after adaptivity, but before the next timestep.
8252 
8253  return mesh_changed;
8254 }
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:1421
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:1425
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 1024 of file SubProblem.C.

1025 {
1026  EquationSystems & eq = es();
1027  const auto n_sys = eq.n_systems();
1028  if (!n_sys)
1029  return;
1030 
1031  eq.get_system(0).get_dof_map().add_algebraic_ghosting_functor(algebraic_gf, to_mesh);
1032  cloneAlgebraicGhostingFunctor(algebraic_gf, to_mesh);
1033 }
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:1002
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 3269 of file FEProblemBase.C.

3273 {
3274  parallel_object_only();
3275 
3276  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");
3277 
3278  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
3279  return;
3280 
3281  InputParameters params = _factory.getValidParams("ArrayMooseVariable");
3282  params.set<FEProblemBase *>("_fe_problem_base") = this;
3284  params.set<MooseEnum>("order") = type.order.get_order();
3285  params.set<MooseEnum>("family") = Moose::stringify(type.family);
3286  params.set<unsigned int>("components") = components;
3287 
3288  if (active_subdomains)
3289  for (const SubdomainID & id : *active_subdomains)
3290  params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
3291 
3292  logAdd("Variable", var_name, "ArrayMooseVariable", params);
3293  _aux->addVariable("ArrayMooseVariable", var_name, params);
3294  if (_displaced_problem)
3295  _displaced_problem->addAuxVariable("ArrayMooseVariable", var_name, params);
3296 
3297  markFamilyPRefinement(params);
3298 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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.
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:1372
void mooseDeprecated(Args &&... args) const
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 FEProblemBase::addAuxKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Reimplemented in MFEMProblem.

Definition at line 3335 of file FEProblemBase.C.

3338 {
3339  parallel_object_only();
3340 
3341  setAuxKernelParamsAndLog(kernel_name, name, parameters, "AuxKernel");
3342 
3343  _aux->addKernel(kernel_name, name, parameters);
3344 }
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
void setAuxKernelParamsAndLog(const std::string &ak_name, const std::string &name, InputParameters &parameters, const std::string &base_name)
Set the subproblem and system parameters for auxiliary kernels and log their addition.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ addAuxScalarKernel()

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

Definition at line 3347 of file FEProblemBase.C.

3350 {
3351  parallel_object_only();
3352 
3353  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3354  {
3355  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3356  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
3357  }
3358  else
3359  {
3360  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3361  {
3362  // We allow AuxScalarKernels to request that they use_displaced_mesh,
3363  // but then be overridden when no displacements variables are
3364  // provided in the Mesh block. If that happened, update the value
3365  // of use_displaced_mesh appropriately for this AuxScalarKernel.
3366  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3367  parameters.set<bool>("use_displaced_mesh") = false;
3368  }
3369 
3370  parameters.set<SubProblem *>("_subproblem") = this;
3371  parameters.set<SystemBase *>("_sys") = _aux.get();
3372  }
3373 
3374  logAdd("AuxScalarKernel", name, kernel_name, parameters);
3375  _aux->addScalarKernel(kernel_name, name, parameters);
3376 }
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 3301 of file FEProblemBase.C.

3305 {
3306  parallel_object_only();
3307 
3308  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");
3309 
3310  if (order > _max_scalar_order)
3311  _max_scalar_order = order;
3312 
3313  FEType type(order, SCALAR);
3314  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
3315  return;
3316 
3317  InputParameters params = _factory.getValidParams("MooseVariableScalar");
3318  params.set<FEProblemBase *>("_fe_problem_base") = this;
3320 
3321  params.set<MooseEnum>("order") = type.order.get_order();
3322  params.set<MooseEnum>("family") = "SCALAR";
3323  params.set<std::vector<Real>>("scaling") = {1};
3324  if (active_subdomains)
3325  for (const SubdomainID & id : *active_subdomains)
3326  params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
3327 
3328  logAdd("ScalarVariable", var_name, "MooseVariableScalar", params);
3329  _aux->addVariable("MooseVariableScalar", var_name, params);
3330  if (_displaced_problem)
3331  _displaced_problem->addAuxVariable("MooseVariableScalar", var_name, params);
3332 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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.
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
void mooseDeprecated(Args &&... args) const
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 FEProblemBase::addAuxVariable ( const std::string &  var_type,
const std::string &  var_name,
InputParameters params 
)
virtualinherited

Canonical method for adding an auxiliary variable.

Parameters
var_typethe type of the variable, e.g. MooseVariableScalar
var_namethe variable name, e.g. 'u'
paramsthe InputParameters from which to construct the variable

Reimplemented in MFEMProblem.

Definition at line 3198 of file FEProblemBase.C.

Referenced by AddElementalFieldAction::init(), and AddAuxVariableAction::init().

3201 {
3202  parallel_object_only();
3203 
3204  const auto order = Utility::string_to_enum<Order>(params.get<MooseEnum>("order"));
3205  const auto family = Utility::string_to_enum<FEFamily>(params.get<MooseEnum>("family"));
3206  const auto fe_type = FEType(order, family);
3207 
3208  const auto active_subdomains_vector =
3209  _mesh.getSubdomainIDs(params.get<std::vector<SubdomainName>>("block"));
3210  const std::set<SubdomainID> active_subdomains(active_subdomains_vector.begin(),
3211  active_subdomains_vector.end());
3212 
3213  if (duplicateVariableCheck(var_name, fe_type, /* is_aux = */ true, &active_subdomains))
3214  return;
3215 
3216  params.set<FEProblemBase *>("_fe_problem_base") = this;
3218 
3219  logAdd("AuxVariable", var_name, var_type, params);
3220  _aux->addVariable(var_type, var_name, params);
3221  if (_displaced_problem)
3222  // MooseObjects need to be unique so change the name here
3223  _displaced_problem->addAuxVariable(var_type, var_name, params);
3224 
3225  markFamilyPRefinement(params);
3226 }
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.
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.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
std::vector< SubdomainID > getSubdomainIDs(const std::vector< SubdomainName > &subdomain_names) const
Get the associated subdomainIDs for the subdomain names that are passed in.
Definition: MooseMesh.C:1775
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
MooseMesh & _mesh
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:1372
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
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

◆ 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 3229 of file FEProblemBase.C.

3232 {
3233  parallel_object_only();
3234 
3235  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");
3236 
3237  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
3238  return;
3239 
3240  std::string var_type;
3241  if (type == FEType(0, MONOMIAL))
3242  var_type = "MooseVariableConstMonomial";
3243  else if (type.family == SCALAR)
3244  var_type = "MooseVariableScalar";
3245  else if (FEInterface::field_type(type) == TYPE_VECTOR)
3246  var_type = "VectorMooseVariable";
3247  else
3248  var_type = "MooseVariable";
3249 
3250  InputParameters params = _factory.getValidParams(var_type);
3251  params.set<FEProblemBase *>("_fe_problem_base") = this;
3253  params.set<MooseEnum>("order") = type.order.get_order();
3254  params.set<MooseEnum>("family") = Moose::stringify(type.family);
3255 
3256  if (active_subdomains)
3257  for (const SubdomainID & id : *active_subdomains)
3258  params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
3259 
3260  logAdd("AuxVariable", var_name, var_type, params);
3261  _aux->addVariable(var_type, var_name, params);
3262  if (_displaced_problem)
3263  _displaced_problem->addAuxVariable("MooseVariable", var_name, params);
3264 
3265  markFamilyPRefinement(params);
3266 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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.
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:1372
void mooseDeprecated(Args &&... args) const
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 FEProblemBase::addBoundaryCondition ( const std::string &  bc_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Reimplemented in MFEMProblem.

Definition at line 3127 of file FEProblemBase.C.

Referenced by DiffusionCG::addBoundaryConditionsFromComponents(), and DiffusionCG::addFEBCs().

3130 {
3131  parallel_object_only();
3132 
3133  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3134  if (!isSolverSystemNonlinear(nl_sys_num))
3135  mooseError(
3136  "You are trying to add a BoundaryCondition to a linear variable/system, which is not "
3137  "supported at the moment!");
3138 
3140  bc_name, name, parameters, nl_sys_num, "BoundaryCondition", _reinit_displaced_face);
3141  _nl[nl_sys_num]->addBoundaryCondition(bc_name, name, parameters);
3142 }
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
void setResidualObjectParamsAndLog(const std::string &ro_name, const std::string &name, InputParameters &parameters, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
Set the subproblem and system parameters for residual objects and log their addition.
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.
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

◆ 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 1935 of file FEProblemBase.C.

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

1936 {
1938  _assembly[tid][_current_nl_sys->number()]->addCachedResidualDirectly(
1940 
1942  _assembly[tid][_current_nl_sys->number()]->addCachedResidualDirectly(
1944 
1945  // We do this because by adding the cached residual directly, we cannot ensure that all of the
1946  // cached residuals are emptied after only the two add calls above
1947  _assembly[tid][_current_nl_sys->number()]->clearCachedResiduals(Assembly::GlobalDataKey{});
1948 
1949  if (_displaced_problem)
1950  _displaced_problem->addCachedResidualDirectly(residual, tid);
1951 }
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:162
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 3145 of file FEProblemBase.C.

3148 {
3149  parallel_object_only();
3150 
3151  _has_constraints = true;
3152 
3153  auto determine_var_param_name = [&parameters, this]()
3154  {
3155  if (parameters.isParamValid("variable"))
3156  return "variable";
3157  else
3158  {
3159  // must be a mortar constraint
3160  const bool has_secondary_var = parameters.isParamValid("secondary_variable");
3161  const bool has_primary_var = parameters.isParamValid("primary_variable");
3162  if (!has_secondary_var && !has_primary_var)
3163  mooseError(
3164  "Either a 'secondary_variable' or 'primary_variable' parameter must be supplied for '",
3166  "'");
3167  return has_secondary_var ? "secondary_variable" : "primary_variable";
3168  }
3169  };
3170 
3171  const auto nl_sys_num =
3172  determineSolverSystem(parameters.varName(determine_var_param_name(), name), true).second;
3173  if (!isSolverSystemNonlinear(nl_sys_num))
3174  mooseError("You are trying to add a Constraint to a linear variable/system, which is not "
3175  "supported at the moment!");
3176 
3177  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3178  {
3179  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3180  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3181  _reinit_displaced_face = true;
3182  }
3183  else
3184  {
3185  // It might _want_ to use a displaced mesh... but we're not so set it to false
3186  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3187  parameters.set<bool>("use_displaced_mesh") = false;
3188 
3189  parameters.set<SubProblem *>("_subproblem") = this;
3190  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3191  }
3192 
3193  logAdd("Constraint", name, c_name, parameters);
3194  _nl[nl_sys_num]->addConstraint(c_name, name, parameters);
3195 }
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 737 of file SubProblem.C.

Referenced by MaterialPropertyInterface::addConsumedPropertyName().

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

◆ addConvergence()

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

Adds a Convergence object.

Definition at line 2566 of file FEProblemBase.C.

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

2569 {
2570  parallel_object_only();
2571 
2572  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
2573  {
2574  std::shared_ptr<Convergence> conv = _factory.create<Convergence>(type, name, parameters, tid);
2575  _convergences.addObject(conv, tid);
2576  }
2577 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 1057 of file SubProblem.C.

1058 {
1059  const auto num_nl_sys = numNonlinearSystems();
1060  if (!num_nl_sys)
1061  return;
1062 
1063  systemBaseNonlinear(0).system().get_dof_map().add_coupling_functor(coupling_gf, to_mesh);
1064  cloneCouplingGhostingFunctor(coupling_gf, to_mesh);
1065 }
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:1036
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 5364 of file FEProblemBase.C.

5367 {
5368  parallel_object_only();
5369 
5370  const auto nl_sys_num =
5371  parameters.isParamValid("variable")
5372  ? determineSolverSystem(parameters.varName("variable", name), true).second
5373  : (unsigned int)0;
5374 
5375  if (!isSolverSystemNonlinear(nl_sys_num))
5376  mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
5377  "supported at the moment!");
5378 
5379  parameters.set<SubProblem *>("_subproblem") = this;
5380  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
5381 
5382  _has_dampers = true;
5383  logAdd("Damper", name, damper_name, parameters);
5384  _nl[nl_sys_num]->addDamper(damper_name, name, parameters);
5385 }
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 2592 of file FEProblemBase.C.

2593 {
2594  const std::string class_name = "DefaultMultiAppFixedPointConvergence";
2595  InputParameters params = _factory.getValidParams(class_name);
2596  params.applyParameters(params_to_apply);
2597  params.applyParameters(parameters());
2598  params.set<bool>("added_as_default") = true;
2600 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 2580 of file FEProblemBase.C.

2581 {
2582  const std::string class_name = "DefaultNonlinearConvergence";
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;
2587  for (const auto & conv_name : getNonlinearConvergenceNames())
2588  addConvergence(class_name, conv_name, params);
2589 }
const std::vector< ConvergenceName > & getNonlinearConvergenceNames() const
Gets the nonlinear system convergence object name(s).
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 2603 of file FEProblemBase.C.

2604 {
2605  const std::string class_name = "DefaultSteadyStateConvergence";
2606  InputParameters params = _factory.getValidParams(class_name);
2607  params.applyParameters(params_to_apply);
2608  params.applyParameters(parameters());
2609  params.set<bool>("added_as_default") = true;
2610  addConvergence(class_name, getSteadyStateConvergenceName(), params);
2611 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 3419 of file FEProblemBase.C.

3422 {
3423  parallel_object_only();
3424 
3425  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3426  if (!isSolverSystemNonlinear(nl_sys_num))
3427  mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
3428  "supported at the moment!");
3429 
3430  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3431  {
3432  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3433  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3435  }
3436  else
3437  {
3438  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3439  {
3440  // We allow DGKernels to request that they use_displaced_mesh,
3441  // but then be overridden when no displacements variables are
3442  // provided in the Mesh block. If that happened, update the value
3443  // of use_displaced_mesh appropriately for this DGKernel.
3444  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3445  parameters.set<bool>("use_displaced_mesh") = false;
3446  }
3447 
3448  parameters.set<SubProblem *>("_subproblem") = this;
3449  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3450  }
3451 
3452  logAdd("DGKernel", name, dg_kernel_name, parameters);
3453  _nl[nl_sys_num]->addDGKernel(dg_kernel_name, name, parameters);
3454 
3456 }
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 3379 of file FEProblemBase.C.

3382 {
3383  parallel_object_only();
3384 
3385  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3386  if (!isSolverSystemNonlinear(nl_sys_num))
3387  mooseError("You are trying to add a DiracKernel to a linear variable/system, which is not "
3388  "supported at the moment!");
3389 
3390  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3391  {
3392  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3393  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3394  _reinit_displaced_elem = true;
3395  }
3396  else
3397  {
3398  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3399  {
3400  // We allow DiracKernels to request that they use_displaced_mesh,
3401  // but then be overridden when no displacements variables are
3402  // provided in the Mesh block. If that happened, update the value
3403  // of use_displaced_mesh appropriately for this DiracKernel.
3404  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3405  parameters.set<bool>("use_displaced_mesh") = false;
3406  }
3407 
3408  parameters.set<SubProblem *>("_subproblem") = this;
3409  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3410  }
3411 
3412  logAdd("DiracKernel", name, kernel_name, parameters);
3413  _nl[nl_sys_num]->addDiracKernel(kernel_name, name, parameters);
3414 }
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 8010 of file FEProblemBase.C.

8011 {
8012  parallel_object_only();
8013 
8016 }
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 2732 of file FEProblemBase.C.

2735 {
2736  parameters.set<std::string>("type") = type;
2737  addObject<Distribution>(type, name, parameters, /* threaded = */ false);
2738 }
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

◆ addFunction()

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

Reimplemented in MFEMProblem.

Definition at line 2540 of file FEProblemBase.C.

Referenced by MFEMProblem::addFunction(), and FEProblemBase::getFunction().

2543 {
2544  parallel_object_only();
2545 
2546  parameters.set<SubProblem *>("_subproblem") = this;
2547 
2548  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
2549  {
2550  std::shared_ptr<Function> func = _factory.create<Function>(type, name, parameters, tid);
2551  logAdd("Function", name, type, parameters);
2552  _functions.addObject(func, tid);
2553 
2554  if (auto * const functor = dynamic_cast<Moose::FunctorBase<Real> *>(func.get()))
2555  {
2556  this->addFunctor(name, *functor, tid);
2557  if (_displaced_problem)
2558  _displaced_problem->addFunctor(name, *functor, tid);
2559  }
2560  else
2561  mooseError("Unrecognized function functor type");
2562  }
2563 }
Base class for function objects.
Definition: Function.h:36
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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.
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:1380
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
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
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseObjectWarehouse< Function > _functions
functions
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

◆ 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 1380 of file SubProblem.h.

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

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

◆ addFunctorMaterial()

void FEProblemBase::addFunctorMaterial ( const std::string &  functor_material_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Reimplemented in MFEMProblem.

Definition at line 3968 of file FEProblemBase.C.

3971 {
3972  parallel_object_only();
3973 
3974  auto add_functor_materials = [&](const auto & parameters, const auto & name)
3975  {
3976  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
3977  {
3978  // Create the general Block/Boundary MaterialBase object
3979  std::shared_ptr<MaterialBase> material =
3980  _factory.create<MaterialBase>(functor_material_name, name, parameters, tid);
3981  logAdd("FunctorMaterial", name, functor_material_name, parameters);
3982  _all_materials.addObject(material, tid);
3983  _materials.addObject(material, tid);
3984  }
3985  };
3986 
3987  parameters.set<SubProblem *>("_subproblem") = this;
3988  add_functor_materials(parameters, name);
3989  if (_displaced_problem)
3990  {
3991  auto disp_params = parameters;
3992  disp_params.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3993  add_functor_materials(disp_params, name + "_displaced");
3994  }
3995 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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.
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
virtual std::unique_ptr< Base > create()=0
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.
MaterialBases compute MaterialProperties.
Definition: MaterialBase.h:62
MaterialWarehouse _all_materials
unsigned int THREAD_ID
Definition: MooseTypes.h:209
MaterialWarehouse _materials

◆ addFVBC()

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

Definition at line 3473 of file FEProblemBase.C.

Referenced by DiffusionFV::addFVBCs().

3476 {
3477  addObject<FVBoundaryCondition>(fv_bc_name, name, parameters);
3478 }
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 3642 of file FEProblemBase.C.

3645 {
3646  parallel_object_only();
3647 
3648  // before we start to mess with the initial condition, we need to check parameters for errors.
3650  const std::string & var_name = parameters.get<VariableName>("variable");
3651 
3652  // Forbid initial conditions on a restarted problem, as they would override the restart
3653  checkICRestartError(ic_name, name, var_name);
3654 
3655  parameters.set<SubProblem *>("_subproblem") = this;
3656 
3657  // field IC
3658  if (hasVariable(var_name))
3659  {
3660  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
3661  {
3662  auto & var = getVariable(
3664  parameters.set<SystemBase *>("_sys") = &var.sys();
3665  std::shared_ptr<FVInitialConditionBase> ic;
3666  if (var.isFV())
3667  ic = _factory.create<FVInitialCondition>(ic_name, name, parameters, tid);
3668  else
3669  mooseError(
3670  "Your variable for an FVInitialCondition needs to be an a finite volume variable!");
3671  _fv_ics.addObject(ic, tid);
3672  }
3673  }
3674  else
3675  mooseError("Variable '",
3676  var_name,
3677  "' requested in finite volume initial condition '",
3678  name,
3679  "' does not exist.");
3680 }
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:1049
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 3481 of file FEProblemBase.C.

3484 {
3487  addObject<FVInterfaceKernel>(
3488  fv_ik_name, name, parameters, /*threaded=*/true, /*variable_param_name=*/"variable1");
3489 }
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 3459 of file FEProblemBase.C.

Referenced by DiffusionFV::addFVKernels().

3462 {
3463  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3464  // FVElementalKernels are computed in the historically finite element threaded loops. They rely
3465  // on Assembly data like _current_elem. When we call reinit on the FEProblemBase we will only
3466  // reinit the DisplacedProblem and its associated Assembly objects if we mark this boolean as
3467  // true
3468  _reinit_displaced_elem = true;
3469  addObject<FVKernel>(fv_kernel_name, name, parameters);
3470 }
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 2137 of file FEProblemBase.C.

Referenced by DisplacedProblem::addGhostedBoundary().

2138 {
2139  _mesh.addGhostedBoundary(boundary_id);
2140  if (_displaced_problem)
2141  _displaced_mesh->addGhostedBoundary(boundary_id);
2142 }
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:3250
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 2130 of file FEProblemBase.C.

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

2131 {
2132  if (_mesh.elemPtr(elem_id)->processor_id() != processor_id())
2133  _ghosted_elems.insert(elem_id);
2134 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3134
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
Definition: SubProblem.h:1095
MooseMesh & _mesh
processor_id_type processor_id() const
processor_id_type processor_id() const

◆ addHDGKernel()

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

Definition at line 3041 of file FEProblemBase.C.

3044 {
3045  parallel_object_only();
3046  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3047  if (!isSolverSystemNonlinear(nl_sys_num))
3048  mooseError("You are trying to add a HDGKernel to a linear variable/system, which is not "
3049  "supported at the moment!");
3051  kernel_name, name, parameters, nl_sys_num, "HDGKernel", _reinit_displaced_elem);
3052 
3053  _nl[nl_sys_num]->addHDGKernel(kernel_name, name, parameters);
3054 }
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.
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
void setResidualObjectParamsAndLog(const std::string &ro_name, const std::string &name, InputParameters &parameters, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
Set the subproblem and system parameters for residual objects and log their addition.
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 5395 of file FEProblemBase.C.

5398 {
5399  parallel_object_only();
5400 
5401  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
5402  {
5403  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
5404  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
5405  _reinit_displaced_elem = true;
5406  }
5407  else
5408  {
5409  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
5410  {
5411  // We allow Indicators to request that they use_displaced_mesh,
5412  // but then be overridden when no displacements variables are
5413  // provided in the Mesh block. If that happened, update the value
5414  // of use_displaced_mesh appropriately for this Indicator.
5415  if (parameters.have_parameter<bool>("use_displaced_mesh"))
5416  parameters.set<bool>("use_displaced_mesh") = false;
5417  }
5418 
5419  parameters.set<SubProblem *>("_subproblem") = this;
5420  parameters.set<SystemBase *>("_sys") = _aux.get();
5421  }
5422 
5423  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
5424  {
5425  std::shared_ptr<Indicator> indicator =
5426  _factory.create<Indicator>(indicator_name, name, parameters, tid);
5427  logAdd("Indicator", name, indicator_name, parameters);
5428  std::shared_ptr<InternalSideIndicatorBase> isi =
5430  if (isi)
5432  else
5433  _indicators.addObject(indicator, tid);
5434  }
5435 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 FEProblemBase::addInitialCondition ( const std::string &  ic_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Reimplemented in MFEMProblem.

Definition at line 3582 of file FEProblemBase.C.

Referenced by DiffusionPhysicsBase::addInitialConditions(), and DiffusionPhysicsBase::addInitialConditionsFromComponents().

3585 {
3586  parallel_object_only();
3587 
3588  // before we start to mess with the initial condition, we need to check parameters for errors.
3590  const std::string & var_name = parameters.get<VariableName>("variable");
3591 
3592  // Forbid initial conditions on a restarted problem, as they would override the restart
3593  checkICRestartError(ic_name, name, var_name);
3594 
3595  parameters.set<SubProblem *>("_subproblem") = this;
3596 
3597  // field IC
3598  if (hasVariable(var_name))
3599  {
3600  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
3601  {
3604  parameters.set<SystemBase *>("_sys") = &var.sys();
3605  std::shared_ptr<InitialConditionBase> ic;
3606  if (dynamic_cast<MooseVariable *>(&var))
3607  ic = _factory.create<InitialCondition>(ic_name, name, parameters, tid);
3608  else if (dynamic_cast<VectorMooseVariable *>(&var))
3609  ic = _factory.create<VectorInitialCondition>(ic_name, name, parameters, tid);
3610  else if (dynamic_cast<ArrayMooseVariable *>(&var))
3611  ic = _factory.create<ArrayInitialCondition>(ic_name, name, parameters, tid);
3612  else if (dynamic_cast<MooseVariableFVReal *>(&var))
3613  ic = _factory.create<InitialCondition>(ic_name, name, parameters, tid);
3614  else if (dynamic_cast<MooseLinearVariableFVReal *>(&var))
3615  ic = _factory.create<InitialCondition>(ic_name, name, parameters, tid);
3616  else
3617  mooseError("Your FE variable in initial condition ",
3618  name,
3619  " must be either of scalar or vector type");
3620  logAdd("IC", name, ic_name, parameters);
3621  _ics.addObject(ic, tid);
3622  }
3623  }
3624 
3625  // scalar IC
3626  else if (hasScalarVariable(var_name))
3627  {
3628  MooseVariableScalar & var = getScalarVariable(0, var_name);
3629  parameters.set<SystemBase *>("_sys") = &var.sys();
3630  std::shared_ptr<ScalarInitialCondition> ic =
3632  logAdd("ScalarIC", name, ic_name, parameters);
3633  _scalar_ics.addObject(ic);
3634  }
3635 
3636  else
3637  mooseError(
3638  "Variable '", var_name, "' requested in initial condition '", name, "' does not exist.");
3639 }
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:1049
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
This is a template class that implements the workhorse compute and computeNodal methods.
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.
virtual bool hasScalarVariable(const std::string &var_name) const override
Returns a Boolean indicating whether any system contains a variable with the name provided...
This class provides an interface for common operations on field variables of both FE and FV types wit...
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...
ScalarInitialConditionWarehouse _scalar_ics
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
virtual std::unique_ptr< Base > create()=0
virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the scalar variable reference from whichever system contains it.
void addObject(std::shared_ptr< InitialConditionBase > object, THREAD_ID tid, bool recurse=true)
Add object to the warehouse.
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...
InitialConditions are objects that set the initial value of variables.
InitialConditionWarehouse _ics
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
Class for scalar variables (they are different).
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 void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true)
Adds an object to the storage structure.
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...
SystemBase & sys()
Get the system this variable is part of.
unsigned int THREAD_ID
Definition: MooseTypes.h:209

◆ addInterfaceKernel()

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

Definition at line 3510 of file FEProblemBase.C.

3513 {
3514  parallel_object_only();
3515 
3516  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3517  if (!isSolverSystemNonlinear(nl_sys_num))
3518  mooseError("You are trying to add a InterfaceKernel to a linear variable/system, which is not "
3519  "supported at the moment!");
3520 
3521  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3522  {
3523  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3524  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3526  }
3527  else
3528  {
3529  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3530  {
3531  // We allow InterfaceKernels to request that they use_displaced_mesh,
3532  // but then be overridden when no displacements variables are
3533  // provided in the Mesh block. If that happened, update the value
3534  // of use_displaced_mesh appropriately for this InterfaceKernel.
3535  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3536  parameters.set<bool>("use_displaced_mesh") = false;
3537  }
3538 
3539  parameters.set<SubProblem *>("_subproblem") = this;
3540  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3541  }
3542 
3543  logAdd("InterfaceKernel", name, interface_kernel_name, parameters);
3544  _nl[nl_sys_num]->addInterfaceKernel(interface_kernel_name, name, parameters);
3545 
3547 }
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 4006 of file FEProblemBase.C.

4009 {
4011 }
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 1974 of file FEProblemBase.C.

Referenced by ComputeDiracThread::postElement().

1975 {
1976  _assembly[tid][_current_nl_sys->number()]->addJacobian(Assembly::GlobalDataKey{});
1978  _assembly[tid][_current_nl_sys->number()]->addJacobianNonlocal(Assembly::GlobalDataKey{});
1979  if (_displaced_problem)
1980  {
1981  _displaced_problem->addJacobian(tid);
1983  _displaced_problem->addJacobianNonlocal(tid);
1984  }
1985 }
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 2049 of file FEProblemBase.C.

Referenced by ComputeJacobianBlocksThread::postElement().

2056 {
2057  _assembly[tid][_current_nl_sys->number()]->addJacobianBlockTags(
2058  jacobian, ivar, jvar, dof_map, dof_indices, Assembly::GlobalDataKey{}, tags);
2059 
2061  if (_nonlocal_cm[_current_nl_sys->number()](ivar, jvar) != 0)
2062  {
2063  MooseVariableFEBase & jv = _current_nl_sys->getVariable(tid, jvar);
2064  _assembly[tid][_current_nl_sys->number()]->addJacobianBlockNonlocalTags(
2065  jacobian,
2066  ivar,
2067  jvar,
2068  dof_map,
2069  dof_indices,
2070  jv.allDofIndices(),
2072  tags);
2073  }
2074 
2075  if (_displaced_problem)
2076  {
2077  _displaced_problem->addJacobianBlockTags(jacobian, ivar, jvar, dof_map, dof_indices, tags, tid);
2079  if (_nonlocal_cm[_current_nl_sys->number()](ivar, jvar) != 0)
2080  {
2081  MooseVariableFEBase & jv = _current_nl_sys->getVariable(tid, jvar);
2082  _displaced_problem->addJacobianBlockNonlocal(
2083  jacobian, ivar, jvar, dof_map, dof_indices, jv.allDofIndices(), tags, tid);
2084  }
2085  }
2086 }
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 2004 of file FEProblemBase.C.

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

2005 {
2006  _assembly[tid][_current_nl_sys->number()]->addJacobianLowerD(Assembly::GlobalDataKey{});
2007  if (_displaced_problem)
2008  _displaced_problem->addJacobianLowerD(tid);
2009 }
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 1988 of file FEProblemBase.C.

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

1989 {
1990  _assembly[tid][_current_nl_sys->number()]->addJacobianNeighbor(Assembly::GlobalDataKey{});
1991  if (_displaced_problem)
1992  _displaced_problem->addJacobianNeighbor(tid);
1993 }
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 1996 of file FEProblemBase.C.

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

1997 {
1998  _assembly[tid][_current_nl_sys->number()]->addJacobianNeighborLowerD(Assembly::GlobalDataKey{});
1999  if (_displaced_problem)
2000  _displaced_problem->addJacobianNeighborLowerD(tid);
2001 }
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 2018 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

2019 {
2020  _assembly[tid][_current_nl_sys->number()]->addJacobianOffDiagScalar(ivar,
2022 }
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 2012 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

2013 {
2014  _assembly[tid][_current_nl_sys->number()]->addJacobianScalar(Assembly::GlobalDataKey{});
2015 }
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 FEProblemBase::addKernel ( const std::string &  kernel_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Reimplemented in MFEMProblem.

Definition at line 3025 of file FEProblemBase.C.

Referenced by DiffusionCG::addFEKernels().

3028 {
3029  parallel_object_only();
3030  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3031  if (!isSolverSystemNonlinear(nl_sys_num))
3032  mooseError("You are trying to add a Kernel to a linear variable/system, which is not "
3033  "supported at the moment!");
3035  kernel_name, name, parameters, nl_sys_num, "Kernel", _reinit_displaced_elem);
3036 
3037  _nl[nl_sys_num]->addKernel(kernel_name, name, parameters);
3038 }
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.
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
void setResidualObjectParamsAndLog(const std::string &ro_name, const std::string &name, InputParameters &parameters, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
Set the subproblem and system parameters for residual objects and log their addition.
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

◆ addKokkosAuxKernel()

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

◆ 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 3500 of file FEProblemBase.C.

3503 {
3504  addObject<LinearFVBoundaryCondition>(bc_name, name, parameters);
3505 }
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 3492 of file FEProblemBase.C.

3495 {
3496  addObject<LinearFVKernel>(kernel_name, name, parameters);
3497 }
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 739 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

740  {
741  mooseError("Line search not implemented for this problem type yet.");
742  }
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 5438 of file FEProblemBase.C.

5441 {
5442  parallel_object_only();
5443 
5444  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
5445  {
5446  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
5447  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
5448  _reinit_displaced_elem = true;
5449  }
5450  else
5451  {
5452  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
5453  {
5454  // We allow Markers to request that they use_displaced_mesh,
5455  // but then be overridden when no displacements variables are
5456  // provided in the Mesh block. If that happened, update the value
5457  // of use_displaced_mesh appropriately for this Marker.
5458  if (parameters.have_parameter<bool>("use_displaced_mesh"))
5459  parameters.set<bool>("use_displaced_mesh") = false;
5460  }
5461 
5462  parameters.set<SubProblem *>("_subproblem") = this;
5463  parameters.set<SystemBase *>("_sys") = _aux.get();
5464  }
5465 
5466  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
5467  {
5468  std::shared_ptr<Marker> marker = _factory.create<Marker>(marker_name, name, parameters, tid);
5469  logAdd("Marker", name, marker_name, parameters);
5470  _markers.addObject(marker, tid);
5471  }
5472 }
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 FEProblemBase::addMaterial ( const std::string &  material_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Reimplemented in MFEMProblem.

Definition at line 3998 of file FEProblemBase.C.

Referenced by ComponentMaterialPropertyInterface::addMaterials().

4001 {
4002  addMaterialHelper({&_materials}, mat_name, name, parameters);
4003 }
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
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MaterialWarehouse _materials

◆ addMaterialHelper()

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

Definition at line 4014 of file FEProblemBase.C.

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

4018 {
4019  parallel_object_only();
4020 
4021  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
4022  {
4023  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
4025  }
4026  else
4027  {
4028  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
4029  {
4030  // We allow Materials to request that they use_displaced_mesh,
4031  // but then be overridden when no displacements variables are
4032  // provided in the Mesh block. If that happened, update the value
4033  // of use_displaced_mesh appropriately for this Material.
4034  if (parameters.have_parameter<bool>("use_displaced_mesh"))
4035  parameters.set<bool>("use_displaced_mesh") = false;
4036  }
4037 
4038  parameters.set<SubProblem *>("_subproblem") = this;
4039  }
4040 
4041  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
4042  {
4043  // Create the general Block/Boundary MaterialBase object
4044  std::shared_ptr<MaterialBase> material =
4045  _factory.create<MaterialBase>(mat_name, name, parameters, tid);
4046  logAdd("Material", name, mat_name, parameters);
4047  bool discrete = !material->getParam<bool>("compute");
4048 
4049  // If the object is boundary restricted or if it is a functor material we do not create the
4050  // neighbor and face objects
4051  if (material->boundaryRestricted() || dynamic_cast<FunctorMaterial *>(material.get()))
4052  {
4053  _all_materials.addObject(material, tid);
4054  if (discrete)
4055  _discrete_materials.addObject(material, tid);
4056  else
4057  for (auto && warehouse : warehouses)
4058  warehouse->addObject(material, tid);
4059  }
4060 
4061  // Non-boundary restricted require face and neighbor objects
4062  else
4063  {
4064  // TODO: we only need to do this if we have needs for face materials (e.g.
4065  // FV, DG, etc.) - but currently we always do it. Figure out how to fix
4066  // this.
4067 
4068  // The name of the object being created, this is changed multiple times as objects are
4069  // created below
4070  std::string object_name;
4071 
4072  // Create a copy of the supplied parameters to the setting for "_material_data_type" isn't
4073  // used from a previous tid loop
4074  InputParameters current_parameters = parameters;
4075 
4076  // face material
4077  current_parameters.set<Moose::MaterialDataType>("_material_data_type") =
4079  object_name = name + "_face";
4080  std::shared_ptr<MaterialBase> face_material =
4081  _factory.create<MaterialBase>(mat_name, object_name, current_parameters, tid);
4082 
4083  // neighbor material
4084  current_parameters.set<Moose::MaterialDataType>("_material_data_type") =
4086  current_parameters.set<bool>("_neighbor") = true;
4087  object_name = name + "_neighbor";
4088  std::shared_ptr<MaterialBase> neighbor_material =
4089  _factory.create<MaterialBase>(mat_name, object_name, current_parameters, tid);
4090 
4091  // Store the material objects
4092  _all_materials.addObjects(material, neighbor_material, face_material, tid);
4093 
4094  if (discrete)
4095  _discrete_materials.addObjects(material, neighbor_material, face_material, tid);
4096  else
4097  for (auto && warehouse : warehouses)
4098  warehouse->addObjects(material, neighbor_material, face_material, tid);
4099 
4100  // Names of all controllable parameters for this Material object
4101  const std::string & base = parameters.getBase();
4102  MooseObjectParameterName name(MooseObjectName(base, material->name()), "*");
4103  const auto param_names =
4105 
4106  // Connect parameters of the primary Material object to those on the face and neighbor
4107  // objects
4108  for (const auto & p_name : param_names)
4109  {
4110  MooseObjectParameterName primary_name(MooseObjectName(base, material->name()),
4111  p_name.parameter());
4112  MooseObjectParameterName face_name(MooseObjectName(base, face_material->name()),
4113  p_name.parameter());
4114  MooseObjectParameterName neighbor_name(MooseObjectName(base, neighbor_material->name()),
4115  p_name.parameter());
4117  primary_name, face_name, false);
4119  primary_name, neighbor_name, false);
4120  }
4121  }
4122  }
4123 }
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:1049
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:2973
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 312 of file SubProblem.C.

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

313 {
314  auto tag_name_upper = MooseUtils::toUpper(tag_name);
315  auto existing_tag = _matrix_tag_name_to_tag_id.find(tag_name_upper);
316  if (existing_tag == _matrix_tag_name_to_tag_id.end())
317  {
318  auto tag_id = _matrix_tag_name_to_tag_id.size();
319 
320  _matrix_tag_name_to_tag_id[tag_name_upper] = tag_id;
321 
322  _matrix_tag_id_to_tag_name[tag_id] = tag_name_upper;
323  }
324 
325  return _matrix_tag_name_to_tag_id.at(tag_name_upper);
326 }
std::map< TagName, TagID > _matrix_tag_name_to_tag_id
The currently declared tags.
Definition: SubProblem.h:1043
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:1046

◆ addMeshDivision()

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

Add a MeshDivision.

Definition at line 2687 of file FEProblemBase.C.

2690 {
2691  parallel_object_only();
2692  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
2693  parameters.set<SubProblem *>("_subproblem") = this;
2694  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
2695  {
2696  std::shared_ptr<MeshDivision> func = _factory.create<MeshDivision>(type, name, parameters, tid);
2697  _mesh_divisions.addObject(func, tid);
2698  }
2699 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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

◆ 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 5475 of file FEProblemBase.C.

5478 {
5479  parallel_object_only();
5480 
5481  parameters.set<MPI_Comm>("_mpi_comm") = _communicator.get();
5482 
5483  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
5484  {
5485  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
5486  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
5487  _reinit_displaced_elem = true;
5488  }
5489  else
5490  {
5491  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
5492  {
5493  // We allow MultiApps to request that they use_displaced_mesh,
5494  // but then be overridden when no displacements variables are
5495  // provided in the Mesh block. If that happened, update the value
5496  // of use_displaced_mesh appropriately for this MultiApp.
5497  if (parameters.have_parameter<bool>("use_displaced_mesh"))
5498  parameters.set<bool>("use_displaced_mesh") = false;
5499  }
5500 
5501  parameters.set<SubProblem *>("_subproblem") = this;
5502  parameters.set<SystemBase *>("_sys") = _aux.get();
5503  }
5504 
5505  std::shared_ptr<MultiApp> multi_app = _factory.create<MultiApp>(multi_app_name, name, parameters);
5506  logAdd("MultiApp", name, multi_app_name, parameters);
5507  multi_app->setupPositions();
5508 
5509  _multi_apps.addObject(multi_app);
5510 
5511  // Store TransientMultiApp objects in another container, this is needed for calling computeDT
5512  std::shared_ptr<TransientMultiApp> trans_multi_app =
5514  if (trans_multi_app)
5515  _transient_multi_apps.addObject(trans_multi_app);
5516 }
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:1049
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 3057 of file FEProblemBase.C.

3060 {
3061  parallel_object_only();
3062 
3063  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3064  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3065  {
3066  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3067  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3068  _reinit_displaced_elem = true;
3069  }
3070  else
3071  {
3072  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3073  {
3074  // We allow NodalKernels to request that they use_displaced_mesh,
3075  // but then be overridden when no displacements variables are
3076  // provided in the Mesh block. If that happened, update the value
3077  // of use_displaced_mesh appropriately for this NodalKernel.
3078  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3079  parameters.set<bool>("use_displaced_mesh") = false;
3080  }
3081 
3082  parameters.set<SubProblem *>("_subproblem") = this;
3083  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3084  }
3085  logAdd("NodalKernel", name, kernel_name, parameters);
3086  _nl[nl_sys_num]->addNodalKernel(kernel_name, name, parameters);
3087 }
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 150 of file SubProblem.C.

Referenced by FEProblemBase::createTagVectors().

151 {
152  _not_zeroed_tagged_vectors.insert(tag);
153 }
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:1119

◆ 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 3407 of file FEProblemBase.h.

3412 {
3413  parallel_object_only();
3414 
3415  logAdd(MooseUtils::prettyCppType<T>(), name, type, parameters);
3416  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
3417  addObjectParamsHelper(parameters, name, var_param_name);
3418 
3419  const auto n_threads = threaded ? libMesh::n_threads() : 1;
3420  std::vector<std::shared_ptr<T>> objects(n_threads);
3421  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
3422  {
3423  std::shared_ptr<T> obj = _factory.create<T>(type, name, parameters, tid);
3424  theWarehouse().add(obj);
3425  objects[tid] = std::move(obj);
3426  }
3427 
3428  return objects;
3429 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 4408 of file FEProblemBase.C.

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

4411 {
4412  // Due to objects like SolutionUserObject which manipulate libmesh objects
4413  // and variables directly at the back end, we need a default option here
4414  // which is going to be the pointer to the first solver system within this
4415  // problem
4416  unsigned int sys_num = 0;
4417  if (parameters.isParamValid(var_param_name))
4418  {
4419  const auto variable_name = parameters.varName(var_param_name, object_name);
4420  if (this->hasVariable(variable_name) || this->hasScalarVariable(variable_name))
4421  sys_num = getSystem(variable_name).number();
4422  }
4423  if (parameters.isParamValid("solver_sys"))
4424  {
4425  const auto var_sys_num = sys_num;
4426  sys_num = getSystemBase(parameters.get<SolverSystemName>("solver_sys")).number();
4427  if (sys_num != var_sys_num && parameters.isParamValid(var_param_name))
4428  mooseError("We dont support setting 'variable' to a variable that is not set to the same "
4429  "system as the 'solver_sys' parameter");
4430  }
4431 
4432  if (_displaced_problem && parameters.have_parameter<bool>("use_displaced_mesh") &&
4433  parameters.get<bool>("use_displaced_mesh"))
4434  {
4435  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
4436  if (sys_num == _aux->number())
4437  parameters.set<SystemBase *>("_sys") = &_displaced_problem->systemBaseAuxiliary();
4438  else
4439  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(sys_num);
4440  }
4441  else
4442  {
4443  // The object requested use_displaced_mesh, but it was overridden
4444  // due to there being no displacements variables in the [Mesh] block.
4445  // If that happened, update the value of use_displaced_mesh appropriately.
4446  if (!_displaced_problem && parameters.have_parameter<bool>("use_displaced_mesh") &&
4447  parameters.get<bool>("use_displaced_mesh"))
4448  parameters.set<bool>("use_displaced_mesh") = false;
4449 
4450  parameters.set<SubProblem *>("_subproblem") = this;
4451 
4452  if (sys_num == _aux->number())
4453  parameters.set<SystemBase *>("_sys") = _aux.get();
4454  else
4455  parameters.set<SystemBase *>("_sys") = _solver_systems[sys_num].get();
4456  }
4457 }
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 9071 of file FEProblemBase.C.

9074 {
9075  parallel_object_only();
9076 
9077  // Get a reference to the OutputWarehouse
9078  OutputWarehouse & output_warehouse = _app.getOutputWarehouse();
9079 
9080  // Reject the reserved names for objects not built by MOOSE
9081  if (!parameters.get<bool>("_built_by_moose") && output_warehouse.isReservedName(object_name))
9082  mooseError("The name '", object_name, "' is a reserved name for output objects");
9083 
9084  // Check that an object by the same name does not already exist; this must be done before the
9085  // object is created to avoid getting misleading errors from the Parser
9086  if (output_warehouse.hasOutput(object_name))
9087  mooseError("An output object named '", object_name, "' already exists");
9088 
9089  // Add a pointer to the FEProblemBase class
9090  parameters.addPrivateParam<FEProblemBase *>("_fe_problem_base", this);
9091 
9092  // Create common parameter exclude list
9093  std::vector<std::string> exclude;
9094  if (object_type == "Console")
9095  {
9096  exclude.push_back("execute_on");
9097 
9098  // --show-input should enable the display of the input file on the screen
9099  if (_app.getParam<bool>("show_input") && parameters.get<bool>("output_screen"))
9100  parameters.set<ExecFlagEnum>("execute_input_on") = EXEC_INITIAL;
9101  }
9102  // Need this because Checkpoint::validParams changes the default value of
9103  // execute_on
9104  else if (object_type == "Checkpoint")
9105  exclude.push_back("execute_on");
9106 
9107  // Apply the common parameters loaded with Outputs input syntax
9108  const InputParameters * common = output_warehouse.getCommonParameters();
9109  if (common)
9110  parameters.applyParameters(*common, exclude);
9111  if (common && std::find(exclude.begin(), exclude.end(), "execute_on") != exclude.end() &&
9112  common->isParamSetByUser("execute_on") && object_type != "Console")
9114  "'execute_on' parameter specified in [Outputs] block is ignored for object '" +
9115  object_name +
9116  "'.\nDefine this object in its own sub-block of [Outputs] to modify its "
9117  "execution schedule.");
9118 
9119  // Set the correct value for the binary flag for XDA/XDR output
9120  if (object_type == "XDR")
9121  parameters.set<bool>("_binary") = true;
9122  else if (object_type == "XDA")
9123  parameters.set<bool>("_binary") = false;
9124 
9125  // Adjust the checkpoint suffix if auto recovery was enabled
9126  if (object_name == "auto_recovery_checkpoint")
9127  parameters.set<std::string>("suffix") = "auto_recovery";
9128 
9129  // Create the object and add it to the warehouse
9130  std::shared_ptr<Output> output = _factory.create<Output>(object_type, object_name, parameters);
9131  logAdd("Output", object_name, object_type, parameters);
9132  output_warehouse.addOutput(output);
9133 }
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:1049
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:2515
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 1343 of file SubProblem.h.

Referenced by FunctorMaterial::addFunctorPropertyByBlocks().

1349 {
1350  auto & pbblf_functors = _pbblf_functors[tid];
1351 
1352  auto [it, first_time_added] =
1353  pbblf_functors.emplace(name,
1354  std::make_unique<PiecewiseByBlockLambdaFunctor<T>>(
1355  name, my_lammy, clearance_schedule, mesh, block_ids));
1356 
1357  auto * functor = dynamic_cast<PiecewiseByBlockLambdaFunctor<T> *>(it->second.get());
1358  if (!functor)
1359  {
1360  if (first_time_added)
1361  mooseError("This should be impossible. If this was the first time we added the functor, then "
1362  "the dynamic cast absolutely should have succeeded");
1363  else
1364  mooseError("Attempted to add a lambda functor with the name '",
1365  name,
1366  "' but another lambda functor of that name returns a different type");
1367  }
1368 
1369  if (first_time_added)
1370  addFunctor(name, *functor, tid);
1371  else
1372  // The functor already exists
1373  functor->setFunctor(mesh, block_ids, my_lammy);
1374 
1375  return *functor;
1376 }
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:1380
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:1149
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 FEProblemBase::addPostprocessor ( const std::string &  pp_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Reimplemented in MFEMProblem.

Definition at line 4460 of file FEProblemBase.C.

Referenced by MFEMProblem::addPostprocessor(), and DiffusionPhysicsBase::addPostprocessors().

4463 {
4464  // Check for name collision
4465  if (hasUserObject(name))
4466  mooseError("A ",
4468  " already exists. You may not add a Postprocessor by the same name.");
4469 
4470  addUserObject(pp_name, name, parameters);
4471 }
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.

◆ addPredictor()

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

Definition at line 7033 of file FEProblemBase.C.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector().

7036 {
7037  parallel_object_only();
7038 
7040  mooseError("Vector bounds cannot be used with LinearSystems!");
7041 
7042  parameters.set<SubProblem *>("_subproblem") = this;
7043  std::shared_ptr<Predictor> predictor = _factory.create<Predictor>(type, name, parameters);
7044  logAdd("Predictor", name, type, parameters);
7045 
7046  for (auto & nl : _nl)
7047  nl->setPredictor(predictor);
7048 }
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 4488 of file FEProblemBase.C.

Referenced by MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer().

4491 {
4492  // Check for name collision
4493  if (hasUserObject(name))
4494  mooseError("A ",
4496  " already exists. You may not add a Reporter by the same name.");
4497 
4499 }
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 1874 of file FEProblemBase.C.

Referenced by ComputeDiracThread::postElement().

1875 {
1876  _assembly[tid][_current_nl_sys->number()]->addResidual(Assembly::GlobalDataKey{},
1878 
1879  if (_displaced_problem)
1880  _displaced_problem->addResidual(tid);
1881 }
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 1894 of file FEProblemBase.C.

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

1895 {
1896  _assembly[tid][_current_nl_sys->number()]->addResidualLower(Assembly::GlobalDataKey{},
1898 
1899  if (_displaced_problem)
1900  _displaced_problem->addResidualLower(tid);
1901 }
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 1884 of file FEProblemBase.C.

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

1885 {
1886  _assembly[tid][_current_nl_sys->number()]->addResidualNeighbor(Assembly::GlobalDataKey{},
1888 
1889  if (_displaced_problem)
1890  _displaced_problem->addResidualNeighbor(tid);
1891 }
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 1904 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeResidualInternal().

1905 {
1906  _assembly[tid][_current_nl_sys->number()]->addResidualScalar(Assembly::GlobalDataKey{},
1908 }
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 2755 of file FEProblemBase.C.

2758 {
2759  const auto samplers = addObject<Sampler>(type, name, parameters);
2760  for (auto & sampler : samplers)
2761  sampler->init();
2762 }
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 3090 of file FEProblemBase.C.

3093 {
3094  parallel_object_only();
3095 
3096  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
3097  if (!isSolverSystemNonlinear(nl_sys_num))
3098  mooseError("You are trying to add a ScalarKernel to a linear variable/system, which is not "
3099  "supported at the moment!");
3100 
3101  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
3102  {
3103  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
3104  parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
3105  }
3106  else
3107  {
3108  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
3109  {
3110  // We allow ScalarKernels to request that they use_displaced_mesh,
3111  // but then be overridden when no displacements variables are
3112  // provided in the Mesh block. If that happened, update the value
3113  // of use_displaced_mesh appropriately for this ScalarKernel.
3114  if (parameters.have_parameter<bool>("use_displaced_mesh"))
3115  parameters.set<bool>("use_displaced_mesh") = false;
3116  }
3117 
3118  parameters.set<SubProblem *>("_subproblem") = this;
3119  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
3120  }
3121 
3122  logAdd("ScalarKernel", name, kernel_name, parameters);
3123  _nl[nl_sys_num]->addScalarKernel(kernel_name, name, parameters);
3124 }
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

◆ addTimeIntegrator()

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

Definition at line 6998 of file FEProblemBase.C.

Referenced by TransientBase::setupTimeIntegrator().

7001 {
7002  parallel_object_only();
7003 
7004  parameters.set<SubProblem *>("_subproblem") = this;
7005  logAdd("TimeIntegrator", name, type, parameters);
7006  _aux->addTimeIntegrator(type, name + ":aux", parameters);
7007  for (auto & sys : _solver_systems)
7008  sys->addTimeIntegrator(type, name + ":" + sys->name(), parameters);
7009  _has_time_integrator = true;
7010 
7011  // add vectors to store u_dot, u_dotdot, udot_old, u_dotdot_old and
7012  // solution vectors older than 2 time steps, if requested by the time
7013  // integrator
7014  _aux->addDotVectors();
7015  for (auto & nl : _nl)
7016  {
7017  nl->addDotVectors();
7018 
7019  auto tag_udot = nl->getTimeIntegrators()[0]->uDotFactorTag();
7020  if (!nl->hasVector(tag_udot))
7021  nl->associateVectorToTag(*nl->solutionUDot(), tag_udot);
7022  auto tag_udotdot = nl->getTimeIntegrators()[0]->uDotDotFactorTag();
7023  if (!nl->hasVector(tag_udotdot) && uDotDotRequested())
7024  nl->associateVectorToTag(*nl->solutionUDotDot(), tag_udotdot);
7025  }
7026 
7027  if (_displaced_problem)
7028  // Time integrator does not exist when displaced problem is created.
7029  _displaced_problem->addTimeIntegrator();
7030 }
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 FEProblemBase::addTransfer ( const std::string &  transfer_name,
const std::string &  name,
InputParameters parameters 
)
virtualinherited

Add a Transfer to the problem.

Reimplemented in MFEMProblem.

Definition at line 5821 of file FEProblemBase.C.

Referenced by MFEMProblem::addTransfer().

5824 {
5825  parallel_object_only();
5826 
5827  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
5828  {
5829  parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
5830  parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
5831  _reinit_displaced_elem = true;
5832  }
5833  else
5834  {
5835  if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
5836  {
5837  // We allow Transfers to request that they use_displaced_mesh,
5838  // but then be overridden when no displacements variables are
5839  // provided in the Mesh block. If that happened, update the value
5840  // of use_displaced_mesh appropriately for this Transfer.
5841  if (parameters.have_parameter<bool>("use_displaced_mesh"))
5842  parameters.set<bool>("use_displaced_mesh") = false;
5843  }
5844 
5845  parameters.set<SubProblem *>("_subproblem") = this;
5846  parameters.set<SystemBase *>("_sys") = _aux.get();
5847  }
5848 
5849  // Handle the "SAME_AS_MULTIAPP" execute option. The get method is used to test for the
5850  // flag so the set by user flag is not reset, calling set with the true flag causes the set
5851  // by user status to be reset, which should only be done if the EXEC_SAME_AS_MULTIAPP is
5852  // being applied to the object.
5854  {
5855  ExecFlagEnum & exec_enum = parameters.set<ExecFlagEnum>("execute_on", true);
5856  std::shared_ptr<MultiApp> multiapp;
5857  if (parameters.isParamValid("multi_app"))
5858  multiapp = getMultiApp(parameters.get<MultiAppName>("multi_app"));
5859  // This catches the sibling transfer case, where we want to be executing only as often as the
5860  // receiving application. A transfer 'to' a multiapp is executed before that multiapp
5861  else if (parameters.isParamValid("to_multi_app"))
5862  multiapp = getMultiApp(parameters.get<MultiAppName>("to_multi_app"));
5863  else if (parameters.isParamValid("from_multi_app"))
5864  multiapp = getMultiApp(parameters.get<MultiAppName>("from_multi_app"));
5865  // else do nothing because the user has provided invalid input. They should get a nice error
5866  // about this during transfer construction. This necessitates checking for null in this next
5867  // line, however
5868  if (multiapp)
5869  exec_enum = multiapp->getParam<ExecFlagEnum>("execute_on");
5870  }
5871 
5872  // Create the Transfer objects
5873  std::shared_ptr<Transfer> transfer = _factory.create<Transfer>(transfer_name, name, parameters);
5874  logAdd("Transfer", name, transfer_name, parameters);
5875 
5876  // Add MultiAppTransfer object
5877  std::shared_ptr<MultiAppTransfer> multi_app_transfer =
5879  if (multi_app_transfer)
5880  {
5881  if (multi_app_transfer->directions().isValueSet(MultiAppTransfer::TO_MULTIAPP))
5882  _to_multi_app_transfers.addObject(multi_app_transfer);
5883  if (multi_app_transfer->directions().isValueSet(MultiAppTransfer::FROM_MULTIAPP))
5884  _from_multi_app_transfers.addObject(multi_app_transfer);
5885  if (multi_app_transfer->directions().isValueSet(MultiAppTransfer::BETWEEN_MULTIAPP))
5886  _between_multi_app_transfers.addObject(multi_app_transfer);
5887  }
5888  else
5889  _transfers.addObject(transfer);
5890 }
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.
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:21
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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.
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
Base class for a system (of equations)
Definition: SystemBase.h:84
std::shared_ptr< MultiApp > getMultiApp(const std::string &multi_app_name) const
Get a MultiApp object by name.
ExecuteMooseObjectWarehouse< Transfer > _transfers
Normal Transfers.
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
virtual std::unique_ptr< Base > create()=0
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
bool isValueSet(const std::string &value) const
Methods for seeing if a value is set in the MultiMooseEnum.
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
Base class for all MultiAppTransfer objects.
const ExecFlagType EXEC_SAME_AS_MULTIAPP
Definition: Moose.C:53
std::shared_ptr< DisplacedProblem > _displaced_problem
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.
Base class for all Transfer objects.
Definition: Transfer.h:36
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ 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 4502 of file FEProblemBase.C.

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

4505 {
4506  parallel_object_only();
4507 
4508  std::vector<std::shared_ptr<UserObject>> uos;
4509 
4510  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
4512 
4513  for (const auto tid : make_range(libMesh::n_threads()))
4514  {
4515  // Create the UserObject
4516  std::shared_ptr<UserObject> user_object =
4517  _factory.create<UserObject>(user_object_name, name, parameters, tid);
4518  logAdd("UserObject", name, user_object_name, parameters);
4519  uos.push_back(user_object);
4520 
4521  if (tid != 0)
4522  user_object->setPrimaryThreadCopy(uos[0].get());
4523 
4524  // TODO: delete this line after apps have been updated to not call getUserObjects
4525  _all_user_objects.addObject(user_object, tid);
4526 
4527  theWarehouse().add(user_object);
4528 
4529  // Attempt to create all the possible UserObject types
4530  auto euo = std::dynamic_pointer_cast<ElementUserObject>(user_object);
4531  auto suo = std::dynamic_pointer_cast<SideUserObject>(user_object);
4532  auto isuo = std::dynamic_pointer_cast<InternalSideUserObject>(user_object);
4533  auto iuo = std::dynamic_pointer_cast<InterfaceUserObjectBase>(user_object);
4534  auto nuo = std::dynamic_pointer_cast<NodalUserObject>(user_object);
4535  auto duo = std::dynamic_pointer_cast<DomainUserObject>(user_object);
4536  auto guo = std::dynamic_pointer_cast<GeneralUserObject>(user_object);
4537  auto tguo = std::dynamic_pointer_cast<ThreadedGeneralUserObject>(user_object);
4538  auto muo = std::dynamic_pointer_cast<MortarUserObject>(user_object);
4539 
4540  // Account for displaced mesh use
4541  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
4542  {
4543  // Whether to re-init or not depends on the attributes of the base classes.
4544  // For example, InterfaceUOBase has "_current_side_elem" and "_neighbor_elem"
4545  // so it needs to reinit on displaced neighbors and faces
4546  // _reinit_displaced_elem -> _current_elem will be reinited
4547  // _reinit_displaced_face -> _current_elem, lowerD if any and _current_side_elem to be
4548  // reinited _reinit_displaced_neighbor -> _current_elem, lowerD if any and _current_neighbor
4549  // to be reinited Note that as soon as you use materials on the displaced mesh, all three get
4550  // turned on.
4551  if (euo || nuo || duo)
4552  _reinit_displaced_elem = true;
4553  if (suo || duo || isuo || iuo)
4554  _reinit_displaced_face = true;
4555  if (iuo || duo || isuo)
4557  }
4558 
4559  // These objects only require one thread
4560  if ((guo && !tguo) || muo)
4561  break;
4562  }
4563 
4564  // Add as a Functor if it is one. We usually need to add the user object from thread 0 as the
4565  // registered functor for all threads because when user objects are thread joined, generally only
4566  // the primary thread copy ends up with all the data
4567  for (const auto tid : make_range(libMesh::n_threads()))
4568  {
4569  const decltype(uos)::size_type uo_index = uos.front()->needThreadedCopy() ? tid : 0;
4570  if (const auto functor = dynamic_cast<Moose::FunctorBase<Real> *>(uos[uo_index].get()))
4571  {
4572  this->addFunctor(name, *functor, tid);
4573  if (_displaced_problem)
4574  _displaced_problem->addFunctor(name, *functor, tid);
4575  }
4576  }
4577 
4578  return uos;
4579 }
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:1049
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:1380
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 FEProblemBase::addVariable ( const std::string &  var_type,
const std::string &  var_name,
InputParameters params 
)
virtualinherited

Canonical method for adding a non-linear variable.

Parameters
var_typethe type of the variable, e.g. MooseVariableScalar
var_namethe variable name, e.g. 'u'
paramsthe InputParameters from which to construct the variable

Reimplemented in MFEMProblem.

Definition at line 2894 of file FEProblemBase.C.

Referenced by MFEMProblem::addGridFunction(), DiffusionFV::addSolverVariables(), DiffusionCG::addSolverVariables(), and AddVariableAction::init().

2897 {
2898  parallel_object_only();
2899 
2900  const auto order = Utility::string_to_enum<Order>(params.get<MooseEnum>("order"));
2901  const auto family = Utility::string_to_enum<FEFamily>(params.get<MooseEnum>("family"));
2902  const auto fe_type = FEType(order, family);
2903 
2904  const auto active_subdomains_vector =
2905  _mesh.getSubdomainIDs(params.get<std::vector<SubdomainName>>("block"));
2906  const std::set<SubdomainID> active_subdomains(active_subdomains_vector.begin(),
2907  active_subdomains_vector.end());
2908 
2909  if (duplicateVariableCheck(var_name, fe_type, /* is_aux = */ false, &active_subdomains))
2910  return;
2911 
2912  params.set<FEProblemBase *>("_fe_problem_base") = this;
2913  params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_SOLVER;
2914  SolverSystemName sys_name = params.get<SolverSystemName>("solver_sys");
2915 
2916  const auto solver_system_number = solverSysNum(sys_name);
2917  logAdd("Variable", var_name, var_type, params);
2918  _solver_systems[solver_system_number]->addVariable(var_type, var_name, params);
2919  if (_displaced_problem)
2920  // MooseObjects need to be unique so change the name here
2921  _displaced_problem->addVariable(var_type, var_name, params, solver_system_number);
2922 
2923  _solver_var_to_sys_num[var_name] = solver_system_number;
2924 
2925  markFamilyPRefinement(params);
2926 }
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.
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::map< SolverVariableName, unsigned int > _solver_var_to_sys_num
Map connecting variable names with their respective solver systems.
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
std::vector< SubdomainID > getSubdomainIDs(const std::vector< SubdomainName > &subdomain_names) const
Get the associated subdomainIDs for the subdomain names that are passed in.
Definition: MooseMesh.C:1775
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
MooseMesh & _mesh
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:1372
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
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.
unsigned int solverSysNum(const SolverSystemName &solver_sys_name) const override
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ addVectorPostprocessor()

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

Definition at line 4474 of file FEProblemBase.C.

Referenced by ExtraIDIntegralReporter::ExtraIDIntegralReporter().

4477 {
4478  // Check for name collision
4479  if (hasUserObject(name))
4480  mooseError("A ",
4482  " already exists. You may not add a VectorPostprocessor by the same name.");
4483 
4484  addUserObject(pp_name, name, parameters);
4485 }
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 93 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().

95 {
97  mooseError("Vector tag type cannot be VECTOR_TAG_ANY");
98 
99  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
100 
101  // First, see if the tag exists already
102  for (const auto & vector_tag : _vector_tags)
103  {
104  mooseAssert(_vector_tags[vector_tag._id] == vector_tag, "Vector tags index mismatch");
105  if (vector_tag._name == tag_name_upper)
106  {
107  if (vector_tag._type != type)
108  mooseError("While attempting to add vector tag with name '",
109  tag_name_upper,
110  "' and type ",
111  type,
112  ",\na tag with the same name but type ",
113  vector_tag._type,
114  " was found.\n\nA tag can only exist with one type.");
115 
116  return vector_tag._id;
117  }
118  }
119 
120  // Doesn't exist - create it
121  const TagID new_tag_id = _vector_tags.size();
122  const TagTypeID new_tag_type_id = _typed_vector_tags[type].size();
123  // Primary storage for all tags where the index in the vector == the tag ID
124  _vector_tags.emplace_back(new_tag_id, new_tag_type_id, tag_name_upper, type);
125  // Secondary storage for each type so that we can have quick access to all tags of a type
126  _typed_vector_tags[type].emplace_back(new_tag_id, new_tag_type_id, tag_name_upper, type);
127  // Name map storage for quick name access
128  _vector_tags_name_map.emplace(tag_name_upper, new_tag_id);
129 
130  // Make sure that _vector_tags, _typed_vector_tags, and _vector_tags_name_map are sane
132 
133  return new_tag_id;
134 }
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:1172
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
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:1182
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:1179
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

◆ adjustEigenVector()

void EigenProblem::adjustEigenVector ( const Real  value,
bool  scaling 
)
private

Adjust eigen vector by either scaling the existing values or setting new values The operations are applied for only eigen variables.

Definition at line 389 of file EigenProblem.C.

Referenced by initEigenvector(), and scaleEigenvector().

390 {
391  std::vector<VariableName> var_names = getVariableNames();
392  for (auto & vn : var_names)
393  {
394  MooseVariableBase * var = nullptr;
395  if (hasScalarVariable(vn))
396  var = &getScalarVariable(0, vn);
397  else
398  var = &getVariable(0, vn);
399  // Do operations for only eigen variable
400  if (var->eigen())
401  for (unsigned int vc = 0; vc < var->count(); ++vc)
402  {
403  std::set<dof_id_type> var_indices;
404  _nl_eigen->system().local_dof_indices(var->number() + vc, var_indices);
405  for (const auto & dof : var_indices)
406  _nl_eigen->solution().set(dof, scaling ? (_nl_eigen->solution()(dof) * value) : value);
407  }
408  }
409 
410  _nl_eigen->solution().close();
411  _nl_eigen->update();
412 }
unsigned int number() const
Get variable number coming from libMesh.
unsigned int count() const
Get the number of components Note: For standard and vector variables, the number is one...
virtual bool hasScalarVariable(const std::string &var_name) const override
Returns a Boolean indicating whether any system contains a variable with the name provided...
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...
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
bool eigen() const
Whether or not this variable operates on an eigen kernel.
virtual std::vector< VariableName > getVariableNames()
Returns a list of all the variables in the problem (both from the NL and Aux systems.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the scalar variable reference from whichever system contains it.
Base variable class.

◆ advanceMultiApps()

void FEProblemBase::advanceMultiApps ( ExecFlagType  type)
inlineinherited

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

Definition at line 1481 of file FEProblemBase.h.

1482  {
1483  mooseDeprecated("Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep "
1484  "depending on your purpose");
1486  }
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
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 6837 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().

6838 {
6839  TIME_SECTION("advanceState", 5, "Advancing State");
6840 
6841  for (auto & sys : _solver_systems)
6842  sys->copyOldSolutions();
6843  _aux->copyOldSolutions();
6844 
6845  if (_displaced_problem)
6846  {
6847  for (const auto i : index_range(_solver_systems))
6848  _displaced_problem->solverSys(i).copyOldSolutions();
6849  _displaced_problem->auxSys().copyOldSolutions();
6850  }
6851 
6853 
6855 
6858 
6861 
6864 
6865 #ifdef MOOSE_KOKKOS_ENABLED
6868 
6871 
6874 #endif
6875 }
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 2190 of file FEProblemBase.h.

Referenced by FEProblemBase::acceptInvalidSolution().

2190 { 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 6944 of file FEProblemBase.C.

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

6945 {
6947 }
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:2515

◆ allowOutput() [2/2]

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

Definition at line 3358 of file FEProblemBase.h.

3359 {
3360  _app.getOutputWarehouse().allowOutput<T>(state);
3361 }
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:2515

◆ areCoupled()

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

Definition at line 6377 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians().

6380 {
6381  return (*_cm[nl_sys])(ivar, jvar);
6382 }
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 3506 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().

3507 {
3508  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3509  mooseAssert(sys_num < _assembly[tid].size(),
3510  "System number larger than the assembly container size");
3511  return *_assembly[tid][sys_num];
3512 }
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 3515 of file FEProblemBase.h.

3516 {
3517  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
3518  mooseAssert(sys_num < _assembly[tid].size(),
3519  "System number larger than the assembly container size");
3520  return *_assembly[tid][sys_num];
3521 }
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 1163 of file SubProblem.C.

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

1164 {
1165  // Currently going to assume that we are applying or not applying automatic scaling consistently
1166  // across nonlinear systems
1168 }
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 1156 of file SubProblem.C.

1157 {
1158  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
1159  systemBaseNonlinear(nl_sys_num).automaticScaling(automatic_scaling);
1160 }
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 1163 of file SubProblem.C.

1164 {
1165  // Currently going to assume that we are applying or not applying automatic scaling consistently
1166  // across nonlinear systems
1168 }
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 9266 of file FEProblemBase.C.

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

9267 {
9268  if (_displaced_problem)
9269  _displaced_problem->automaticScaling(automatic_scaling);
9270 
9271  SubProblem::automaticScaling(automatic_scaling);
9272 }
bool automaticScaling() const
Automatic scaling getter.
Definition: SubProblem.C:1163
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ backupMultiApps()

void FEProblemBase::backupMultiApps ( ExecFlagType  type)
inherited

Backup the MultiApps associated with the ExecFlagType.

Definition at line 5742 of file FEProblemBase.C.

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

5743 {
5744  const auto & multi_apps = _multi_apps[type].getActiveObjects();
5745 
5746  if (multi_apps.size())
5747  {
5748  TIME_SECTION("backupMultiApps", 5, "Backing Up MultiApp");
5749 
5750  if (_verbose_multiapps)
5751  _console << COLOR_CYAN << "\nBacking Up MultiApps on " << type.name() << COLOR_DEFAULT
5752  << std::endl;
5753 
5754  for (const auto & multi_app : multi_apps)
5755  multi_app->backup();
5756 
5758 
5759  if (_verbose_multiapps)
5760  _console << COLOR_CYAN << "Finished Backing Up MultiApps on " << type.name() << "\n"
5761  << COLOR_DEFAULT << std::endl;
5762  }
5763 }
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:327
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 6234 of file FEProblemBase.C.

6235 {
6236  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
6237  for (const auto i : index_range(_nl))
6238  _assembly[tid][i]->bumpAllQRuleOrder(order, block);
6239 
6240  if (_displaced_problem)
6241  _displaced_problem->bumpAllQRuleOrder(order, block);
6242 
6243  updateMaxQps();
6244 }
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 6221 of file FEProblemBase.C.

6222 {
6223  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
6224  for (const auto i : index_range(_nl))
6225  _assembly[tid][i]->bumpVolumeQRuleOrder(order, block);
6226 
6227  if (_displaced_problem)
6228  _displaced_problem->bumpVolumeQRuleOrder(order, block);
6229 
6230  updateMaxQps();
6231 }
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)

◆ bxNormProvided()

bool EigenProblem::bxNormProvided ( ) const
inline

Whether a Bx norm postprocessor has been provided.

Definition at line 232 of file EigenProblem.h.

Referenced by Moose::SlepcSupport::attachCallbacksToMat(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionB(), preScaleEigenVector(), and Moose::SlepcSupport::slepcSetOptions().

232 { return _bx_norm_name.has_value(); }
std::optional< PostprocessorName > _bx_norm_name
The name of the Postprocessor providing the Bx norm.
Definition: EigenProblem.h:289

◆ cacheJacobian()

void FEProblemBase::cacheJacobian ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2025 of file FEProblemBase.C.

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

2026 {
2028  if (_displaced_problem)
2029  _displaced_problem->cacheJacobian(tid);
2030 }
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual void cacheJacobian(const THREAD_ID tid)
Definition: SubProblem.C:1317

◆ cacheJacobianNeighbor()

void FEProblemBase::cacheJacobianNeighbor ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2033 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians().

2034 {
2036  if (_displaced_problem)
2037  _displaced_problem->cacheJacobianNeighbor(tid);
2038 }
virtual void cacheJacobianNeighbor(const THREAD_ID tid)
Definition: SubProblem.C:1325
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ cacheResidual()

void FEProblemBase::cacheResidual ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1911 of file FEProblemBase.C.

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

1912 {
1914  if (_displaced_problem)
1915  _displaced_problem->cacheResidual(tid);
1916 }
virtual void cacheResidual(const THREAD_ID tid)
Definition: SubProblem.C:1296
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ cacheResidualNeighbor()

void FEProblemBase::cacheResidualNeighbor ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1919 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals().

1920 {
1922  if (_displaced_problem)
1923  _displaced_problem->cacheResidualNeighbor(tid);
1924 }
std::shared_ptr< DisplacedProblem > _displaced_problem
virtual void cacheResidualNeighbor(const THREAD_ID tid)
Definition: SubProblem.C:1303

◆ 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:2515
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 624 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

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

◆ checkBoundaryMatProps()

void SubProblem::checkBoundaryMatProps ( )
virtualinherited

Checks boundary material properties integrity.

See also
FEProblemBase::checkProblemIntegrity

Definition at line 666 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

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

Referenced by FEProblemBase::checkProblemIntegrity().

8876 {
8878 }
MooseMesh & _mesh
void checkCoordinateSystems()
Performs a sanity check for every element in the mesh.
Definition: MooseMesh.C:4328

◆ 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 8754 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

8756 {
8757  for (const auto & it : materials_map)
8758  {
8760  std::set<std::string> block_depend_props, block_supplied_props;
8761 
8762  for (const auto & mat1 : it.second)
8763  {
8764  auto & alldeps = mat1->getMatPropDependencies(); // includes requested stateful props
8765  for (auto & dep : alldeps)
8766  block_depend_props.insert(_material_prop_registry.getName(dep));
8767 
8768  // See if any of the active materials supply this property
8769  for (const auto & mat2 : it.second)
8770  {
8771  const std::set<std::string> & supplied_props = mat2->MaterialBase::getSuppliedItems();
8772  block_supplied_props.insert(supplied_props.begin(), supplied_props.end());
8773  }
8774  }
8775 
8776  // Add zero material properties specific to this block and unrestricted
8777  block_supplied_props.insert(_zero_block_material_props[it.first].begin(),
8778  _zero_block_material_props[it.first].end());
8779 
8780  // Error check to make sure all properties consumed by materials are supplied on this block
8781  std::set<std::string> difference;
8782  std::set_difference(block_depend_props.begin(),
8783  block_depend_props.end(),
8784  block_supplied_props.begin(),
8785  block_supplied_props.end(),
8786  std::inserter(difference, difference.end()));
8787 
8788  if (!difference.empty())
8789  {
8790  std::ostringstream oss;
8791  oss << "One or more Material Properties were not supplied on block ";
8792  const std::string & subdomain_name = _mesh.getSubdomainName(it.first);
8793  if (subdomain_name.length() > 0)
8794  oss << subdomain_name << " (" << it.first << ")";
8795  else
8796  oss << it.first;
8797  oss << ":\n";
8798  for (const auto & name : difference)
8799  oss << name << "\n";
8800  mooseError(oss.str());
8801  }
8802  }
8803 
8804  // This loop checks that materials are not supplied by multiple Material objects
8805  for (const auto & it : materials_map)
8806  {
8807  const auto & materials = it.second;
8808  std::set<std::string> inner_supplied, outer_supplied;
8809 
8810  for (const auto & outer_mat : materials)
8811  {
8812  // Storage for properties for this material (outer) and all other materials (inner)
8813  outer_supplied = outer_mat->getSuppliedItems();
8814  inner_supplied.clear();
8815 
8816  // Property to material map for error reporting
8817  std::map<std::string, std::set<std::string>> prop_to_mat;
8818  for (const auto & name : outer_supplied)
8819  prop_to_mat[name].insert(outer_mat->name());
8820 
8821  for (const auto & inner_mat : materials)
8822  {
8823  if (outer_mat == inner_mat)
8824  continue;
8825 
8826  // Check whether these materials are an AD pair
8827  auto outer_mat_type = outer_mat->type();
8828  auto inner_mat_type = inner_mat->type();
8829  removeSubstring(outer_mat_type, "<RESIDUAL>");
8830  removeSubstring(outer_mat_type, "<JACOBIAN>");
8831  removeSubstring(inner_mat_type, "<RESIDUAL>");
8832  removeSubstring(inner_mat_type, "<JACOBIAN>");
8833  if (outer_mat_type == inner_mat_type && outer_mat_type != outer_mat->type() &&
8834  inner_mat_type != inner_mat->type())
8835  continue;
8836 
8837  inner_supplied.insert(inner_mat->getSuppliedItems().begin(),
8838  inner_mat->getSuppliedItems().end());
8839 
8840  for (const auto & inner_supplied_name : inner_supplied)
8841  prop_to_mat[inner_supplied_name].insert(inner_mat->name());
8842  }
8843 
8844  // Test that a property isn't supplied on multiple blocks
8845  std::set<std::string> intersection;
8846  std::set_intersection(outer_supplied.begin(),
8847  outer_supplied.end(),
8848  inner_supplied.begin(),
8849  inner_supplied.end(),
8850  std::inserter(intersection, intersection.end()));
8851 
8852  if (!intersection.empty())
8853  {
8854  std::ostringstream oss;
8855  oss << "The following material properties are declared on block " << it.first
8856  << " by multiple materials:\n";
8857  oss << ConsoleUtils::indent(2) << std::setw(30) << std::left << "Material Property"
8858  << "Material Objects\n";
8859  for (const auto & outer_name : intersection)
8860  {
8861  oss << ConsoleUtils::indent(2) << std::setw(30) << std::left << outer_name;
8862  for (const auto & inner_name : prop_to_mat[outer_name])
8863  oss << inner_name << " ";
8864  oss << '\n';
8865  }
8866 
8867  mooseError(oss.str());
8868  break;
8869  }
8870  }
8871  }
8872 }
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:1201
std::map< SubdomainID, std::set< MaterialPropertyName > > _zero_block_material_props
Set of properties returned as zero properties.
Definition: SubProblem.h:1060
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 8678 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

8679 {
8680  if (_displaced_problem)
8681  {
8682  bool mesh_has_second_order_elements = false;
8683  for (const auto & elem : as_range(_displaced_mesh->activeLocalElementsBegin(),
8685  {
8686  if (elem->default_order() == SECOND)
8687  {
8688  mesh_has_second_order_elements = true;
8689  break;
8690  }
8691  }
8692 
8693  // We checked our local elements, so take the max over all processors.
8694  _displaced_mesh->comm().max(mesh_has_second_order_elements);
8695 
8696  // If the Mesh has second order elements, make sure the
8697  // displacement variables are second-order.
8698  if (mesh_has_second_order_elements)
8699  {
8700  const std::vector<std::string> & displacement_variables =
8701  _displaced_problem->getDisplacementVarNames();
8702 
8703  for (const auto & var_name : displacement_variables)
8704  {
8705  MooseVariableFEBase & mv =
8706  _displaced_problem->getVariable(/*tid=*/0,
8707  var_name,
8710  if (mv.order() != SECOND)
8711  mooseError("Error: mesh has SECOND order elements, so all displacement variables must be "
8712  "SECOND order.");
8713  }
8714  }
8715  }
8716 }
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:3072
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:3078
MooseMesh * _displaced_mesh

◆ checkDuplicatePostprocessorVariableNames()

void FEProblemBase::checkDuplicatePostprocessorVariableNames ( )
inherited

Definition at line 1526 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

1527 {
1528  for (const auto & pp : _reporter_data.getPostprocessorNames())
1529  if (hasScalarVariable(pp))
1530  mooseError("Postprocessor \"" + pp +
1531  "\" has the same name as a scalar variable in the system.");
1532 }
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 6665 of file FEProblemBase.C.

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

6666 {
6668  return;
6669 
6670  TIME_SECTION("checkExceptionAndStopSolve", 5);
6671 
6672  // See if any processor had an exception. If it did, get back the
6673  // processor that the exception occurred on.
6674  unsigned int processor_id;
6675 
6677 
6678  if (_has_exception)
6679  {
6681 
6684  {
6685  // Print the message
6686  if (_communicator.rank() == 0 && print_message)
6687  {
6688  _console << "\n" << _exception_message << "\n";
6689  if (isTransient())
6690  _console
6691  << "To recover, the solution will fail and then be re-attempted with a reduced time "
6692  "step.\n"
6693  << std::endl;
6694  }
6695 
6696  // Stop the solve -- this entails setting
6697  // SNESSetFunctionDomainError() or directly inserting NaNs in the
6698  // residual vector to let PETSc >= 3.6 return DIVERGED_NANORINF.
6699  if (_current_nl_sys)
6701 
6702  if (_current_linear_sys)
6704 
6705  // and close Aux system (we MUST do this here; see #11525)
6706  _aux->solution().close();
6707 
6708  // We've handled this exception, so we no longer have one.
6709  _has_exception = false;
6710 
6711  // Force the next non-linear convergence check to fail (and all further residual evaluation
6712  // to be skipped).
6714 
6715  // Repropagate the exception, so it can be caught at a higher level, typically
6716  // this is NonlinearSystem::computeResidual().
6718  }
6719  else
6720  mooseError("The following parallel-communicated exception was detected during " +
6721  Moose::stringify(_current_execute_on_flag) + " evaluation:\n" +
6723  "\nBecause this did not occur during residual evaluation, there"
6724  " is no way to handle this, so the solution is aborting.\n");
6725  }
6726 }
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:339
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 1651 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

1652 {
1653  TIME_SECTION("checkNonlocalCoupling", 5, "Checking Nonlocal Coupling");
1654 
1655  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
1656  for (auto & nl : _nl)
1657  {
1658  const auto & all_kernels = nl->getKernelWarehouse();
1659  const auto & kernels = all_kernels.getObjects(tid);
1660  for (const auto & kernel : kernels)
1661  {
1662  std::shared_ptr<NonlocalKernel> nonlocal_kernel =
1664  if (nonlocal_kernel)
1665  {
1668  _nonlocal_kernels.addObject(kernel, tid);
1669  }
1670  }
1671  const MooseObjectWarehouse<IntegratedBCBase> & all_integrated_bcs =
1672  nl->getIntegratedBCWarehouse();
1673  const auto & integrated_bcs = all_integrated_bcs.getObjects(tid);
1674  for (const auto & integrated_bc : integrated_bcs)
1675  {
1676  std::shared_ptr<NonlocalIntegratedBC> nonlocal_integrated_bc =
1678  if (nonlocal_integrated_bc)
1679  {
1682  _nonlocal_integrated_bcs.addObject(integrated_bc, tid);
1683  }
1684  }
1685  }
1686 }
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 9696 of file FEProblemBase.C.

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

9697 {
9699 }
bool _requires_nonlocal_coupling
nonlocal coupling requirement flag

◆ checkProblemIntegrity()

void EigenProblem::checkProblemIntegrity ( )
overridevirtual

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 from FEProblemBase.

Definition at line 501 of file EigenProblem.C.

502 {
504  _nl_eigen->checkIntegrity();
505  if (_bx_norm_name)
506  {
508  paramWarning("bx_norm", "This parameter is only used for nonlinear solve types");
509  else if (auto & pp = getUserObjectBase(_bx_norm_name.value());
511  pp.paramError("execute_on",
512  "If providing the Bx norm, this postprocessor must execute on linear e.g. "
513  "during residual evaluations");
514  }
515 }
bool isNonlinearEigenvalueSolver(unsigned int eigen_sys_num) const
Definition: EigenProblem.C:676
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
bool contains(const std::string &value) const
Methods for seeing if a value is set in the MultiMooseEnum.
const ExecFlagEnum & getExecuteOnEnum() const
Return the execute on MultiMooseEnum for this object.
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
virtual void checkProblemIntegrity()
Method called to perform a series of sanity checks before a simulation is run.
std::optional< PostprocessorName > _bx_norm_name
The name of the Postprocessor providing the Bx norm.
Definition: EigenProblem.h:289
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.
void paramWarning(const std::string &param, Args... args) const

◆ checkUserObjectJacobianRequirement()

void FEProblemBase::checkUserObjectJacobianRequirement ( THREAD_ID  tid)
inherited

Definition at line 1689 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

1690 {
1691  std::set<const MooseVariableFEBase *> uo_jacobian_moose_vars;
1692  {
1693  std::vector<ShapeElementUserObject *> objs;
1694  theWarehouse()
1695  .query()
1697  .condition<AttribThread>(tid)
1698  .queryInto(objs);
1699 
1700  for (const auto & uo : objs)
1701  {
1702  _calculate_jacobian_in_uo = uo->computeJacobianFlag();
1703  const auto & mv_deps = uo->jacobianMooseVariables();
1704  uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
1705  }
1706  }
1707  {
1708  std::vector<ShapeSideUserObject *> objs;
1709  theWarehouse()
1710  .query()
1712  .condition<AttribThread>(tid)
1713  .queryInto(objs);
1714  for (const auto & uo : objs)
1715  {
1716  _calculate_jacobian_in_uo = uo->computeJacobianFlag();
1717  const auto & mv_deps = uo->jacobianMooseVariables();
1718  uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
1719  }
1720  }
1721 
1722  _uo_jacobian_moose_vars[tid].assign(uo_jacobian_moose_vars.begin(), uo_jacobian_moose_vars.end());
1723  std::sort(
1724  _uo_jacobian_moose_vars[tid].begin(), _uo_jacobian_moose_vars[tid].end(), sortMooseVariables);
1725 }
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 8719 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

8720 {
8721  // Check user_objects block coverage
8722  std::set<SubdomainID> mesh_subdomains = _mesh.meshSubdomains();
8723  std::set<SubdomainID> user_objects_blocks;
8724 
8725  // gather names of all user_objects that were defined in the input file
8726  // and the blocks that they are defined on
8727  std::set<std::string> names;
8728 
8729  std::vector<UserObject *> objects;
8731 
8732  for (const auto & obj : objects)
8733  names.insert(obj->name());
8734 
8735  // See if all referenced blocks are covered
8736  std::set<SubdomainID> difference;
8737  std::set_difference(user_objects_blocks.begin(),
8738  user_objects_blocks.end(),
8739  mesh_subdomains.begin(),
8740  mesh_subdomains.end(),
8741  std::inserter(difference, difference.end()));
8742 
8743  if (!difference.empty())
8744  {
8745  std::ostringstream oss;
8746  oss << "One or more UserObjects is referencing a nonexistent block:\n";
8747  for (const auto & id : difference)
8748  oss << id << "\n";
8749  mooseError(oss.str());
8750  }
8751 }
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:3192

◆ 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 6063 of file FEProblemBase.C.

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

6064 {
6066 
6067  if (_displaced_problem)
6068  _displaced_problem->clearActiveElementalMooseVariables(tid);
6069 }
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid)
Clear the active elemental MooseVariableFieldBase.
Definition: SubProblem.C:467
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearActiveFEVariableCoupleableMatrixTags()

void FEProblemBase::clearActiveFEVariableCoupleableMatrixTags ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6072 of file FEProblemBase.C.

6073 {
6075 
6076  if (_displaced_problem)
6077  _displaced_problem->clearActiveFEVariableCoupleableMatrixTags(tid);
6078 }
virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid)
Definition: SubProblem.C:385
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearActiveFEVariableCoupleableVectorTags()

void FEProblemBase::clearActiveFEVariableCoupleableVectorTags ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6081 of file FEProblemBase.C.

6082 {
6084 
6085  if (_displaced_problem)
6086  _displaced_problem->clearActiveFEVariableCoupleableVectorTags(tid);
6087 }
virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid)
Definition: SubProblem.C:379
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 6129 of file FEProblemBase.C.

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

6130 {
6132 }
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 6090 of file FEProblemBase.C.

Referenced by AuxiliarySystem::clearScalarVariableCoupleableTags().

6091 {
6093 
6094  if (_displaced_problem)
6095  _displaced_problem->clearActiveScalarVariableCoupleableMatrixTags(tid);
6096 }
virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid)
Definition: SubProblem.C:426
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearActiveScalarVariableCoupleableVectorTags()

void FEProblemBase::clearActiveScalarVariableCoupleableVectorTags ( const THREAD_ID  tid)
overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6099 of file FEProblemBase.C.

Referenced by AuxiliarySystem::clearScalarVariableCoupleableTags().

6100 {
6102 
6103  if (_displaced_problem)
6104  _displaced_problem->clearActiveScalarVariableCoupleableVectorTags(tid);
6105 }
virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid)
Definition: SubProblem.C:420
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ clearAllDofIndices()

void SubProblem::clearAllDofIndices ( )
inherited

Clear dof indices from variables in nl and aux systems.

Definition at line 1178 of file SubProblem.C.

Referenced by FEProblemBase::solve().

1179 {
1180  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
1183 }
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 2669 of file FEProblemBase.h.

Referenced by FEProblemBase::resetState().

2669 {}

◆ clearCurrentResidualVectorTags()

void FEProblemBase::clearCurrentResidualVectorTags ( )
inlineinherited

Clear the current residual vector tag data structure.

Definition at line 3552 of file FEProblemBase.h.

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

3553 {
3555 }
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 2510 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDiracContributions().

2511 {
2513 
2514  if (_displaced_problem)
2515  _displaced_problem->clearDiracInfo();
2516 }
void clearPoints()
Remove all of the current points and elements.
std::shared_ptr< DisplacedProblem > _displaced_problem
DiracKernelInfo _dirac_kernel_info
Definition: SubProblem.h:1051

◆ computeBounds()

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

Definition at line 7684 of file FEProblemBase.C.

Referenced by Moose::compute_bounds().

7687 {
7688  try
7689  {
7690  try
7691  {
7692  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7693  "I expect these system numbers to be the same");
7694 
7695  if (!_current_nl_sys->hasVector("lower_bound") || !_current_nl_sys->hasVector("upper_bound"))
7696  return;
7697 
7698  TIME_SECTION("computeBounds", 1, "Computing Bounds");
7699 
7700  NumericVector<Number> & _lower = _current_nl_sys->getVector("lower_bound");
7701  NumericVector<Number> & _upper = _current_nl_sys->getVector("upper_bound");
7702  _lower.swap(lower);
7703  _upper.swap(upper);
7704  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
7706 
7707  _aux->residualSetup();
7709  _lower.swap(lower);
7710  _upper.swap(upper);
7711  }
7712  catch (...)
7713  {
7714  handleException("computeBounds");
7715  }
7716  }
7717  catch (MooseException & e)
7718  {
7719  mooseError("Irrecoverable exception: " + std::string(e.what()));
7720  }
7721  catch (...)
7722  {
7723  mooseError("Unexpected exception type");
7724  }
7725 }
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 7963 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck().

7965 {
7966  // Default to no damping
7967  Real damping = 1.0;
7968 
7969  if (_has_dampers)
7970  {
7971  TIME_SECTION("computeDamping", 1, "Computing Damping");
7972 
7973  // Save pointer to the current solution
7974  const NumericVector<Number> * _saved_current_solution = _current_nl_sys->currentSolution();
7975 
7977  // For now, do not re-compute auxiliary variables. Doing so allows a wild solution increment
7978  // to get to the material models, which may not be able to cope with drastically different
7979  // values. Once more complete dependency checking is in place, auxiliary variables (and
7980  // material properties) will be computed as needed by dampers.
7981  // _aux.compute();
7982  damping = _current_nl_sys->computeDamping(soln, update);
7983 
7984  // restore saved solution
7985  _current_nl_sys->setSolution(*_saved_current_solution);
7986  }
7987 
7988  return damping;
7989 }
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 4701 of file FEProblemBase.C.

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

4702 {
4703  // Initialize indicator aux variable fields
4705  {
4706  TIME_SECTION("computeIndicators", 1, "Computing Indicators");
4707 
4708  // Internal side indicators may lead to creating a much larger sparsity pattern than dictated by
4709  // the actual finite element scheme (e.g. CFEM)
4710  const auto old_do_derivatives = ADReal::do_derivatives;
4711  ADReal::do_derivatives = false;
4712 
4713  std::vector<std::string> fields;
4714 
4715  // Indicator Fields
4716  const auto & indicators = _indicators.getActiveObjects();
4717  for (const auto & indicator : indicators)
4718  fields.push_back(indicator->name());
4719 
4720  // InternalSideIndicator Fields
4721  const auto & internal_indicators = _internal_side_indicators.getActiveObjects();
4722  for (const auto & internal_indicator : internal_indicators)
4723  fields.push_back(internal_indicator->name());
4724 
4725  _aux->zeroVariables(fields);
4726 
4727  // compute Indicators
4728  ComputeIndicatorThread cit(*this);
4730  _aux->solution().close();
4731  _aux->update();
4732 
4733  ComputeIndicatorThread finalize_cit(*this, true);
4735  _aux->solution().close();
4736  _aux->update();
4737 
4738  ADReal::do_derivatives = old_do_derivatives;
4739  }
4740 }
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 4694 of file FEProblemBase.C.

4695 {
4697  computeMarkers();
4698 }
virtual void computeMarkers()
virtual void computeIndicators()

◆ computeJacobian() [1/2]

void FEProblemBase::computeJacobian

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

Definition at line 7519 of file FEProblemBase.C.

7522 {
7523  setCurrentNonlinearSystem(nl_sys_num);
7524 
7525  _fe_matrix_tags.clear();
7526 
7527  auto & tags = getMatrixTags();
7528  for (auto & tag : tags)
7529  _fe_matrix_tags.insert(tag.second);
7530 
7531  computeJacobianInternal(soln, jacobian, _fe_matrix_tags);
7532 }
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

◆ computeJacobian() [2/2]

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 7519 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianSys().

7522 {
7523  setCurrentNonlinearSystem(nl_sys_num);
7524 
7525  _fe_matrix_tags.clear();
7526 
7527  auto & tags = getMatrixTags();
7528  for (auto & tag : tags)
7529  _fe_matrix_tags.insert(tag.second);
7530 
7531  computeJacobianInternal(soln, jacobian, _fe_matrix_tags);
7532 }
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

◆ computeJacobianAB()

void EigenProblem::computeJacobianAB ( const NumericVector< Number > &  soln,
SparseMatrix< Number > &  jacobianA,
SparseMatrix< Number > &  jacobianB,
TagID  tagA,
TagID  tagB 
)

Form two Jacobian matrices, where each is associated with one tag, through one element-loop.

Definition at line 259 of file EigenProblem.C.

Referenced by Moose::assemble_matrix().

264 {
265  TIME_SECTION("computeJacobianAB", 3);
266 
267  // Disassociate the default tags because we will associate vectors with only the
268  // specific system tags that we need for this instance
269  _nl_eigen->disassociateDefaultMatrixTags();
270 
271  // Clear FE tags and first add the specific tags associated with the Jacobian
272  _fe_matrix_tags.clear();
273  _fe_matrix_tags.insert(tagA);
274  _fe_matrix_tags.insert(tagB);
275 
276  // Add any other user-added matrix tags if they have associated matrices
277  const auto & matrix_tags = getMatrixTags();
278  for (const auto & matrix_tag : matrix_tags)
279  if (_nl_eigen->hasMatrix(matrix_tag.second))
280  _fe_matrix_tags.insert(matrix_tag.second);
281 
282  _nl_eigen->setSolution(soln);
283 
284  _nl_eigen->associateMatrixToTag(jacobianA, tagA);
285  _nl_eigen->associateMatrixToTag(jacobianB, tagB);
286 
289 
290  _nl_eigen->disassociateMatrixFromTag(jacobianA, tagA);
291  _nl_eigen->disassociateMatrixFromTag(jacobianB, tagB);
292 }
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
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
virtual void computeJacobianTags(const std::set< TagID > &tags)
Form multiple matrices, and each is associated with a tag.

◆ 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 7672 of file FEProblemBase.C.

7676 {
7677  JacobianBlock jac_block(precond_system, jacobian, ivar, jvar);
7678  std::vector<JacobianBlock *> blocks = {&jac_block};
7679  mooseAssert(_current_nl_sys, "This should be non-null");
7681 }
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 EigenProblem::computeJacobianBlocks ( std::vector< JacobianBlock *> &  blocks,
const unsigned int  nl_sys_num 
)
overridevirtual

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 from FEProblemBase.

Definition at line 240 of file EigenProblem.C.

242 {
243  TIME_SECTION("computeJacobianBlocks", 3);
244  setCurrentNonlinearSystem(nl_sys_num);
245 
246  if (_displaced_problem)
248 
250 
252 
253  _current_nl_sys->computeJacobianBlocks(blocks, {_nl_eigen->precondMatrixTag()});
254 
256 }
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:1098
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
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 7535 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobian().

7538 {
7539  TIME_SECTION("computeJacobianInternal", 1);
7540 
7542 
7544 
7545  computeJacobianTags(tags);
7546 
7548 }
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 7497 of file FEProblemBase.C.

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

7500 {
7501  computeJacobian(soln, jacobian, sys.number());
7502 }
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() [1/2]

void EigenProblem::computeJacobianTag ( const NumericVector< Number > &  soln,
SparseMatrix< Number > &  jacobian,
TagID  tag 
)
overridevirtual

Form a Jacobian matrix for all kernels and BCs with a given tag.

Definition at line 176 of file EigenProblem.C.

Referenced by Moose::assemble_matrix(), NonlinearEigenSystem::computeScalingJacobian(), and Moose::SlepcSupport::moosePetscSNESFormMatrixTag().

179 {
180  TIME_SECTION("computeJacobianTag", 3);
181 
182  // Disassociate the default tags because we will associate vectors with only the
183  // specific system tags that we need for this instance
184  _nl_eigen->disassociateDefaultMatrixTags();
185 
186  // Clear FE tags and first add the specific tag associated with the Jacobian
187  _fe_matrix_tags.clear();
188  _fe_matrix_tags.insert(tag);
189 
190  // Add any other user-added matrix tags if they have associated matrices
191  const auto & matrix_tags = getMatrixTags();
192  for (const auto & matrix_tag : matrix_tags)
193  if (_nl_eigen->hasMatrix(matrix_tag.second))
194  _fe_matrix_tags.insert(matrix_tag.second);
195 
196  _nl_eigen->setSolution(soln);
197 
198  _nl_eigen->associateMatrixToTag(jacobian, tag);
199 
202 
203  _nl_eigen->disassociateMatrixFromTag(jacobian, tag);
204 }
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
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
virtual void computeJacobianTags(const std::set< TagID > &tags)
Form multiple matrices, and each is associated with a tag.

◆ computeJacobianTag() [2/2]

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 7505 of file FEProblemBase.C.

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

7508 {
7510 
7511  _current_nl_sys->associateMatrixToTag(jacobian, tag);
7512 
7513  computeJacobianTags({tag});
7514 
7516 }
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 7551 of file FEProblemBase.C.

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

7552 {
7553  try
7554  {
7555  try
7556  {
7557  if (!_has_jacobian || !_const_jacobian)
7558  {
7559  TIME_SECTION("computeJacobianTags", 5, "Computing Jacobian");
7560 
7561  for (auto tag : tags)
7562  if (_current_nl_sys->hasMatrix(tag))
7563  {
7564  auto & matrix = _current_nl_sys->getMatrix(tag);
7567  else
7568  matrix.zero();
7570  // PETSc algorithms require diagonal allocations regardless of whether there is
7571  // non-zero diagonal dependence. With global AD indexing we only add non-zero
7572  // dependence, so PETSc will scream at us unless we artificially add the diagonals.
7573  for (auto index : make_range(matrix.row_start(), matrix.row_stop()))
7574  matrix.add(index, index, 0);
7575  }
7576 
7577  _aux->zeroVariablesForJacobian();
7578 
7579  unsigned int n_threads = libMesh::n_threads();
7580 
7581  // Random interface objects
7582  for (const auto & it : _random_data_objects)
7583  it.second->updateSeeds(EXEC_NONLINEAR);
7584 
7587  if (_displaced_problem)
7588  _displaced_problem->setCurrentlyComputingJacobian(true);
7589 
7592 
7593  for (unsigned int tid = 0; tid < n_threads; tid++)
7594  reinitScalars(tid);
7595 
7597 
7598  _aux->jacobianSetup();
7599 
7600  if (_displaced_problem)
7601  {
7603  _displaced_problem->updateMesh();
7604  }
7605 
7606  for (unsigned int tid = 0; tid < n_threads; tid++)
7607  {
7610  }
7611 
7613 
7615 
7617 
7619 
7621 
7623 
7624  // For explicit Euler calculations for example we often compute the Jacobian one time and
7625  // then re-use it over and over. If we're performing automatic scaling, we don't want to
7626  // use that kernel, diagonal-block only Jacobian for our actual matrix when performing
7627  // solves!
7629  _has_jacobian = true;
7630  }
7631  }
7632  catch (...)
7633  {
7634  handleException("computeJacobianTags");
7635  }
7636  }
7637  catch (const MooseException &)
7638  {
7639  // The buck stops here, we have already handled the exception by
7640  // calling the system's stopSolve() method, it is now up to PETSc to return a
7641  // "diverged" reason during the next solve.
7642  }
7643  catch (...)
7644  {
7645  mooseError("Unexpected exception type");
7646  }
7647 
7648  resetState();
7649 }
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:1098
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:1110
MaterialWarehouse _all_materials
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2515
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 7728 of file FEProblemBase.C.

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

7732 {
7733  TIME_SECTION("computeLinearSystemSys", 5);
7734 
7736 
7739 
7740  // We are using the residual tag system for right hand sides so we fetch everything
7741  const auto & vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
7742 
7743  // We filter out tags which do not have associated vectors in the current
7744  // system. This is essential to be able to use system-dependent vector tags.
7747 
7751  compute_gradients);
7752 
7757  // We reset the tags to the default containers for further operations
7762 }
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:290
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:173
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:301
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 7765 of file FEProblemBase.C.

Referenced by FEProblemBase::computeLinearSystemSys().

7769 {
7770  TIME_SECTION("computeLinearSystemTags", 5, "Computing Linear System");
7771 
7773 
7774  for (auto tag : matrix_tags)
7775  {
7776  auto & matrix = _current_linear_sys->getMatrix(tag);
7777  matrix.zero();
7778  }
7779 
7780  unsigned int n_threads = libMesh::n_threads();
7781 
7783 
7784  // Random interface objects
7785  for (const auto & it : _random_data_objects)
7786  it.second->updateSeeds(EXEC_NONLINEAR);
7787 
7790 
7792 
7793  _aux->jacobianSetup();
7794 
7795  for (THREAD_ID tid = 0; tid < n_threads; tid++)
7796  {
7798  }
7799 
7800  try
7801  {
7803  }
7804  catch (MooseException & e)
7805  {
7806  _console << "\nA MooseException was raised during Auxiliary variable computation.\n"
7807  << "The next solve will fail, the timestep will be reduced, and we will try again.\n"
7808  << std::endl;
7809 
7810  // We know the next solve is going to fail, so there's no point in
7811  // computing anything else after this. Plus, using incompletely
7812  // computed AuxVariables in subsequent calculations could lead to
7813  // other errors or unhandled exceptions being thrown.
7814  return;
7815  }
7816 
7819 
7821 
7822  _current_linear_sys->computeLinearSystemTags(vector_tags, matrix_tags, compute_gradients);
7823 
7824  // Reset execution flag as after this point we are no longer on LINEAR
7826 
7827  // These are the relevant parts of resetState()
7830 }
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:1113
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:1110
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2515
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:154
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 4743 of file FEProblemBase.C.

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

4744 {
4745  if (_markers.hasActiveObjects())
4746  {
4747  TIME_SECTION("computeMarkers", 1, "Computing Markers");
4748 
4749  std::vector<std::string> fields;
4750 
4751  // Marker Fields
4752  const auto & markers = _markers.getActiveObjects();
4753  for (const auto & marker : markers)
4754  fields.push_back(marker->name());
4755 
4756  _aux->zeroVariables(fields);
4757 
4759 
4760  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
4761  {
4762  const auto & markers = _markers.getActiveObjects(tid);
4763  for (const auto & marker : markers)
4764  marker->markerSetup();
4765  }
4766 
4767  ComputeMarkerThread cmt(*this);
4769 
4770  _aux->solution().close();
4771  _aux->update();
4772  }
4773 }
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

◆ computeMatricesTags()

void EigenProblem::computeMatricesTags ( const NumericVector< Number > &  soln,
const std::vector< SparseMatrix< Number > *> &  jacobians,
const std::set< TagID > &  tags 
)

Form several matrices simultaneously.

Definition at line 207 of file EigenProblem.C.

Referenced by Moose::SlepcSupport::moosePetscSNESFormMatricesTags().

210 {
211  TIME_SECTION("computeMatricesTags", 3);
212 
213  if (jacobians.size() != tags.size())
214  mooseError("The number of matrices ",
215  jacobians.size(),
216  " does not equal the number of tags ",
217  tags.size());
218 
219  // Disassociate the default tags because we will associate vectors with only the
220  // specific system tags that we need for this instance
221  _nl_eigen->disassociateDefaultMatrixTags();
222 
223  _fe_matrix_tags.clear();
224 
225  _nl_eigen->setSolution(soln);
226 
227  unsigned int i = 0;
228  for (auto tag : tags)
229  _nl_eigen->associateMatrixToTag(*(jacobians[i++]), tag);
230 
232  computeJacobianTags(tags);
233 
234  i = 0;
235  for (auto tag : tags)
236  _nl_eigen->disassociateMatrixFromTag(*(jacobians[i++]), tag);
237 }
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
std::set< TagID > _fe_matrix_tags
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 void computeJacobianTags(const std::set< TagID > &tags)
Form multiple matrices, and each is associated with a tag.

◆ computeMultiAppsDT()

Real FEProblemBase::computeMultiAppsDT ( ExecFlagType  type)
inherited

Find the smallest timestep over all MultiApps.

Definition at line 5794 of file FEProblemBase.C.

Referenced by TransientBase::constrainDTFromMultiApp().

5795 {
5796  const auto & multi_apps = _transient_multi_apps[type].getActiveObjects();
5797 
5798  Real smallest_dt = std::numeric_limits<Real>::max();
5799 
5800  for (const auto & multi_app : multi_apps)
5801  smallest_dt = std::min(smallest_dt, multi_app->computeDT());
5802 
5803  return smallest_dt;
5804 }
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 7833 of file FEProblemBase.C.

Referenced by Moose::compute_nearnullspace().

7835 {
7836  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7837  "I expect these system numbers to be the same");
7838 
7839  sp.clear();
7840  for (unsigned int i = 0; i < subspaceDim("NearNullSpace"); ++i)
7841  {
7842  std::stringstream postfix;
7843  postfix << "_" << i;
7844  std::string modename = "NearNullSpace" + postfix.str();
7845  sp.push_back(&_current_nl_sys->getVector(modename));
7846  }
7847 }
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 7850 of file FEProblemBase.C.

Referenced by Moose::compute_nullspace().

7852 {
7853  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7854  "I expect these system numbers to be the same");
7855  sp.clear();
7856  for (unsigned int i = 0; i < subspaceDim("NullSpace"); ++i)
7857  {
7858  std::stringstream postfix;
7859  postfix << "_" << i;
7860  sp.push_back(&_current_nl_sys->getVector("NullSpace" + postfix.str()));
7861  }
7862 }
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 7880 of file FEProblemBase.C.

Referenced by Moose::compute_postcheck().

7886 {
7887  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7888  "I expect these system numbers to be the same");
7889 
7890  // This function replaces the old PetscSupport::dampedCheck() function.
7891  //
7892  // 1.) Recreate code in PetscSupport::dampedCheck() for constructing
7893  // ghosted "soln" and "update" vectors.
7894  // 2.) Call FEProblemBase::computeDamping() with these ghost vectors.
7895  // 3.) Recreate the code in PetscSupport::dampedCheck() to actually update
7896  // the solution vector based on the damping, and set the "changed" flags
7897  // appropriately.
7898 
7899  TIME_SECTION("computePostCheck", 2, "Computing Post Check");
7900 
7902 
7903  // MOOSE's FEProblemBase doesn't update the solution during the
7904  // postcheck, but FEProblemBase-derived classes might.
7906  {
7907  // We need ghosted versions of new_soln and search_direction (the
7908  // ones we get from libmesh/PETSc are PARALLEL vectors. To make
7909  // our lives simpler, we use the same ghosting pattern as the
7910  // system's current_local_solution to create new ghosted vectors.
7911 
7912  // Construct zeroed-out clones with the same ghosted dofs as the
7913  // System's current_local_solution.
7914  std::unique_ptr<NumericVector<Number>> ghosted_solution =
7915  sys.current_local_solution->zero_clone(),
7916  ghosted_search_direction =
7917  sys.current_local_solution->zero_clone();
7918 
7919  // Copy values from input vectors into clones with ghosted values.
7920  *ghosted_solution = new_soln;
7921  *ghosted_search_direction = search_direction;
7922 
7923  if (_has_dampers)
7924  {
7925  // Compute the damping coefficient using the ghosted vectors
7926  Real damping = computeDamping(*ghosted_solution, *ghosted_search_direction);
7927 
7928  // If some non-trivial damping was computed, update the new_soln
7929  // vector accordingly.
7930  if (damping < 1.0)
7931  {
7932  new_soln = old_soln;
7933  new_soln.add(-damping, search_direction);
7934  changed_new_soln = true;
7935  }
7936  }
7937 
7938  if (shouldUpdateSolution())
7939  {
7940  // Update the ghosted copy of the new solution, if necessary.
7941  if (changed_new_soln)
7942  *ghosted_solution = new_soln;
7943 
7944  bool updated_solution = updateSolution(new_soln, *ghosted_solution);
7945  if (updated_solution)
7946  changed_new_soln = true;
7947  }
7948  }
7949 
7951  {
7953  _aux->copyCurrentIntoPreviousNL();
7954  }
7955 
7956  // MOOSE doesn't change the search_direction
7957  changed_search_direction = false;
7958 
7960 }
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).

◆ computeResidualAB()

void EigenProblem::computeResidualAB ( const NumericVector< Number > &  soln,
NumericVector< Number > &  residualA,
NumericVector< Number > &  residualB,
TagID  tagA,
TagID  tagB 
)

Form two vetors, where each is associated with one tag, through one element-loop.

Definition at line 327 of file EigenProblem.C.

Referenced by computeResidualL2Norm(), and Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB().

332 {
333  TIME_SECTION("computeResidualAB", 3);
334 
335  // Disassociate the default tags because we will associate vectors with only the
336  // specific system tags that we need for this instance
337  _nl_eigen->disassociateDefaultVectorTags();
338 
339  // add the specific tags associated with the residual
340  mooseAssert(_fe_vector_tags.empty(), "This should be empty indicating a clean starting state");
341  _fe_vector_tags.insert(tagA);
342  _fe_vector_tags.insert(tagB);
343 
344  // Add any other user-added vector residual tags if they have associated vectors
345  const auto & residual_vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
346  for (const auto & vector_tag : residual_vector_tags)
347  if (_nl_eigen->hasVector(vector_tag._id))
348  _fe_vector_tags.insert(vector_tag._id);
349 
350  _nl_eigen->associateVectorToTag(residualA, tagA);
351  _nl_eigen->associateVectorToTag(residualB, tagB);
352 
353  _nl_eigen->setSolution(soln);
354 
356  _fe_vector_tags.clear();
357 
358  _nl_eigen->disassociateVectorFromTag(residualA, tagA);
359  _nl_eigen->disassociateVectorFromTag(residualB, tagB);
360 }
virtual void computeResidualTags(const std::set< TagID > &tags)
Form multiple residual vectors and each is associated with one tag.
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Definition: SubProblem.C:173
std::set< TagID > _fe_vector_tags

◆ 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 7142 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobian::residual_and_jacobian().

7145 {
7146  try
7147  {
7148  try
7149  {
7150  // vector tags
7152  const auto & residual_vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
7153 
7154  mooseAssert(_fe_vector_tags.empty(),
7155  "This should be empty indicating a clean starting state");
7156  // We filter out tags which do not have associated vectors in the current nonlinear
7157  // system. This is essential to be able to use system-dependent residual tags.
7159 
7161 
7162  // matrix tags
7163  {
7164  _fe_matrix_tags.clear();
7165 
7166  auto & tags = getMatrixTags();
7167  for (auto & tag : tags)
7168  _fe_matrix_tags.insert(tag.second);
7169  }
7170 
7172 
7175 
7176  for (const auto tag : _fe_matrix_tags)
7177  if (_current_nl_sys->hasMatrix(tag))
7178  {
7179  auto & matrix = _current_nl_sys->getMatrix(tag);
7180  matrix.zero();
7182  // PETSc algorithms require diagonal allocations regardless of whether there is non-zero
7183  // diagonal dependence. With global AD indexing we only add non-zero
7184  // dependence, so PETSc will scream at us unless we artificially add the diagonals.
7185  for (auto index : make_range(matrix.row_start(), matrix.row_stop()))
7186  matrix.add(index, index, 0);
7187  }
7188 
7189  _aux->zeroVariablesForResidual();
7190 
7191  unsigned int n_threads = libMesh::n_threads();
7192 
7194 
7195  // Random interface objects
7196  for (const auto & it : _random_data_objects)
7197  it.second->updateSeeds(EXEC_LINEAR);
7198 
7202  if (_displaced_problem)
7203  {
7204  _displaced_problem->setCurrentlyComputingResidual(true);
7205  _displaced_problem->setCurrentlyComputingJacobian(true);
7206  _displaced_problem->setCurrentlyComputingResidualAndJacobian(true);
7207  }
7208 
7210 
7212 
7213  for (unsigned int tid = 0; tid < n_threads; tid++)
7214  reinitScalars(tid);
7215 
7217 
7218  _aux->residualSetup();
7219 
7220  if (_displaced_problem)
7221  {
7223  _displaced_problem->updateMesh();
7225  updateMortarMesh();
7226  }
7227 
7228  for (THREAD_ID tid = 0; tid < n_threads; tid++)
7229  {
7232  }
7233 
7235 
7237 
7239 
7241 
7244 
7246 
7249  }
7250  catch (...)
7251  {
7252  handleException("computeResidualAndJacobian");
7253  }
7254  }
7255  catch (const MooseException &)
7256  {
7257  // The buck stops here, we have already handled the exception by
7258  // calling the system's stopSolve() method, it is now up to PETSc to return a
7259  // "diverged" reason during the next solve.
7260  }
7261  catch (...)
7262  {
7263  mooseError("Unexpected exception type");
7264  }
7265 
7266  resetState();
7267  _fe_vector_tags.clear();
7268  _fe_matrix_tags.clear();
7269 }
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:290
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:1498
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:1113
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:173
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:1110
MaterialWarehouse _all_materials
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2515
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 7301 of file FEProblemBase.C.

7304 {
7305  parallel_object_only();
7306 
7307  TIME_SECTION("computeResidualInternal", 1);
7308 
7309  try
7310  {
7312 
7314 
7315  computeResidualTags(tags);
7316 
7318  }
7319  catch (MooseException & e)
7320  {
7321  // If a MooseException propagates all the way to here, it means
7322  // that it was thrown from a MOOSE system where we do not
7323  // (currently) properly support the throwing of exceptions, and
7324  // therefore we have no choice but to error out. It may be
7325  // *possible* to handle exceptions from other systems, but in the
7326  // meantime, we don't want to silently swallow any unhandled
7327  // exceptions here.
7328  mooseError("An unhandled MooseException was raised during residual computation. Please "
7329  "contact the MOOSE team for assistance.");
7330  }
7331 }
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 EigenProblem::computeResidualL2Norm ( )
overridevirtual

Compute the residual of Ax - Bx.

If there is no yet, "1" will be used.

Reimplemented from FEProblemBase.

Definition at line 363 of file EigenProblem.C.

364 {
365  computeResidualAB(*_nl_eigen->currentSolution(),
366  _nl_eigen->residualVectorAX(),
367  _nl_eigen->residualVectorBX(),
368  _nl_eigen->nonEigenVectorTag(),
369  _nl_eigen->eigenVectorTag());
370 
371  Real eigenvalue = 1.0;
372 
373  if (_active_eigen_index < _nl_eigen->getNumConvergedEigenvalues())
374  eigenvalue = _nl_eigen->getConvergedEigenvalue(_active_eigen_index).first;
375 
376  // Scale BX with eigenvalue
377  _nl_eigen->residualVectorBX() *= eigenvalue;
378 
379  // Compute entire residual
381  _nl_eigen->residualVectorAX() += _nl_eigen->residualVectorBX();
382  else
383  _nl_eigen->residualVectorAX() -= _nl_eigen->residualVectorBX();
384 
385  return _nl_eigen->residualVectorAX().l2_norm();
386 }
bool _negative_sign_eigen_kernel
Whether or not use negative sign for Bx.
Definition: EigenProblem.h:246
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
void computeResidualAB(const NumericVector< Number > &soln, NumericVector< Number > &residualA, NumericVector< Number > &residualB, TagID tagA, TagID tagB)
Form two vetors, where each is associated with one tag, through one element-loop. ...
Definition: EigenProblem.C:327
unsigned int _active_eigen_index
Which eigenvalue is used to compute residual.
Definition: EigenProblem.h:249
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ computeResidualL2Norm() [2/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 7051 of file FEProblemBase.C.

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

7052 {
7053  _current_nl_sys = &sys;
7054  computeResidual(*sys.currentSolution(), sys.RHS(), sys.number());
7055  return sys.RHS().l2_norm();
7056 }
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() [3/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 7059 of file FEProblemBase.C.

7060 {
7061  _current_linear_sys = &sys;
7062 
7063  // We assemble the current system to check the current residual
7066  *sys.linearImplicitSystem().rhs,
7067  /*compute fresh gradients*/ true);
7068 
7069  // Unfortunate, but we have to allocate a new vector for the residual
7070  auto residual = sys.linearImplicitSystem().rhs->clone();
7071  residual->scale(-1.0);
7072  residual->add_vector(*sys.currentSolution(), *sys.linearImplicitSystem().matrix);
7073  return residual->l2_norm();
7074 }
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

◆ 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 7099 of file FEProblemBase.C.

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

7102 {
7103  parallel_object_only();
7104 
7105  TIME_SECTION("computeResidualSys", 5);
7106 
7107  computeResidual(soln, residual, sys.number());
7108 }
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() [1/2]

void EigenProblem::computeResidualTag ( const NumericVector< Number > &  soln,
NumericVector< Number > &  residual,
TagID  tag 
)
overridevirtual

Form a vector for all kernels and BCs with a given tag.

Definition at line 295 of file EigenProblem.C.

Referenced by NonlinearEigenSystem::computeScalingResidual(), and preScaleEigenVector().

298 {
299  TIME_SECTION("computeResidualTag", 3);
300 
301  // Disassociate the default tags because we will associate vectors with only the
302  // specific system tags that we need for this instance
303  _nl_eigen->disassociateDefaultVectorTags();
304 
305  // add the specific tag associated with the residual
306  mooseAssert(_fe_vector_tags.empty(), "This should be empty indicating a clean starting state");
307  _fe_vector_tags.insert(tag);
308 
309  // Add any other user-added vector residual tags if they have associated vectors
310  const auto & residual_vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
311  for (const auto & vector_tag : residual_vector_tags)
312  if (_nl_eigen->hasVector(vector_tag._id))
313  _fe_vector_tags.insert(vector_tag._id);
314 
315  _nl_eigen->associateVectorToTag(residual, tag);
316 
317  _nl_eigen->setSolution(soln);
318 
321  _fe_vector_tags.clear();
322 
323  _nl_eigen->disassociateVectorFromTag(residual, tag);
324 }
virtual void computeResidualTags(const std::set< TagID > &tags)
Form multiple residual vectors and each is associated with one tag.
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Definition: SubProblem.C:173
std::set< TagID > _fe_vector_tags

◆ computeResidualTag() [2/2]

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 7272 of file FEProblemBase.C.

7275 {
7276  try
7277  {
7279 
7280  _current_nl_sys->associateVectorToTag(residual, tag);
7281 
7282  computeResidualTags({tag});
7283 
7285  }
7286  catch (MooseException & e)
7287  {
7288  // If a MooseException propagates all the way to here, it means
7289  // that it was thrown from a MOOSE system where we do not
7290  // (currently) properly support the throwing of exceptions, and
7291  // therefore we have no choice but to error out. It may be
7292  // *possible* to handle exceptions from other systems, but in the
7293  // meantime, we don't want to silently swallow any unhandled
7294  // exceptions here.
7295  mooseError("An unhandled MooseException was raised during residual computation. Please "
7296  "contact the MOOSE team for assistance.");
7297  }
7298 }
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 7417 of file FEProblemBase.C.

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

7418 {
7419  parallel_object_only();
7420 
7421  try
7422  {
7423  try
7424  {
7425  TIME_SECTION("computeResidualTags", 5, "Computing Residual");
7426 
7427  ADReal::do_derivatives = false;
7428 
7430 
7431  _aux->zeroVariablesForResidual();
7432 
7433  unsigned int n_threads = libMesh::n_threads();
7434 
7436 
7437  // Random interface objects
7438  for (const auto & it : _random_data_objects)
7439  it.second->updateSeeds(EXEC_LINEAR);
7440 
7442 
7444 
7445  for (unsigned int tid = 0; tid < n_threads; tid++)
7446  reinitScalars(tid);
7447 
7449 
7450  _aux->residualSetup();
7451 
7452  if (_displaced_problem)
7453  {
7455  _displaced_problem->updateMesh();
7457  updateMortarMesh();
7458  }
7459 
7460  for (THREAD_ID tid = 0; tid < n_threads; tid++)
7461  {
7464  }
7465 
7467 
7469 
7471 
7473 
7476  }
7477  catch (...)
7478  {
7479  handleException("computeResidualTags");
7480  }
7481  }
7482  catch (const MooseException &)
7483  {
7484  // The buck stops here, we have already handled the exception by
7485  // calling the system's stopSolve() method, it is now up to PETSc to return a
7486  // "diverged" reason during the next solve.
7487  }
7488  catch (...)
7489  {
7490  mooseError("Unexpected exception type");
7491  }
7492 
7493  resetState();
7494 }
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:1113
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:2515
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 7334 of file FEProblemBase.C.

7337 {
7338  TIME_SECTION("computeResidualType", 5);
7339 
7340  try
7341  {
7343 
7345 
7347 
7349  }
7350  catch (MooseException & e)
7351  {
7352  // If a MooseException propagates all the way to here, it means
7353  // that it was thrown from a MOOSE system where we do not
7354  // (currently) properly support the throwing of exceptions, and
7355  // therefore we have no choice but to error out. It may be
7356  // *possible* to handle exceptions from other systems, but in the
7357  // meantime, we don't want to silently swallow any unhandled
7358  // exceptions here.
7359  mooseError("An unhandled MooseException was raised during residual computation. Please "
7360  "contact the MOOSE team for assistance.");
7361  }
7362 }
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 9597 of file FEProblemBase.C.

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

9598 {
9599  // When performing an adjoint solve in the optimization module, the current solver system is the
9600  // adjoint. However, the adjoint solve requires having accurate time derivative calculations for
9601  // the forward system. The cleanest way to handle such uses is just to compute the time
9602  // derivatives for all solver systems instead of trying to guess which ones we need and don't need
9603  for (auto & solver_sys : _solver_systems)
9604  solver_sys->compute(type);
9605 
9606  _aux->compute(type);
9607 }
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 7865 of file FEProblemBase.C.

Referenced by Moose::compute_transpose_nullspace().

7867 {
7868  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
7869  "I expect these system numbers to be the same");
7870  sp.clear();
7871  for (unsigned int i = 0; i < subspaceDim("TransposeNullSpace"); ++i)
7872  {
7873  std::stringstream postfix;
7874  postfix << "_" << i;
7875  sp.push_back(&_current_nl_sys->getVector("TransposeNullSpace" + postfix.str()));
7876  }
7877 }
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 4993 of file FEProblemBase.C.

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

4996 {
4997  const auto old_exec_flag = _current_execute_on_flag;
5000  .query()
5001  .condition<AttribSystem>("UserObject")
5002  .condition<AttribExecOns>(type)
5003  .condition<AttribName>(name);
5004  computeUserObjectsInternal(type, group, query);
5005  _current_execute_on_flag = old_exec_flag;
5006 }
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 5009 of file FEProblemBase.C.

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

5010 {
5012  theWarehouse().query().condition<AttribSystem>("UserObject").condition<AttribExecOns>(type);
5013  computeUserObjectsInternal(type, group, query);
5014 }
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 5017 of file FEProblemBase.C.

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

5020 {
5021  try
5022  {
5023  TIME_SECTION("computeUserObjects", 1, "Computing User Objects");
5024 
5025  // Add group to query
5026  if (group == Moose::PRE_IC)
5027  primary_query.condition<AttribPreIC>(true);
5028  else if (group == Moose::PRE_AUX)
5029  primary_query.condition<AttribPreAux>(type);
5030  else if (group == Moose::POST_AUX)
5031  primary_query.condition<AttribPostAux>(type);
5032 
5033  // query everything first to obtain a list of execution groups
5034  std::vector<UserObject *> uos;
5035  primary_query.clone().queryIntoUnsorted(uos);
5036  std::set<int> execution_groups;
5037  for (const auto & uo : uos)
5038  execution_groups.insert(uo->getParam<int>("execution_order_group"));
5039 
5040  // iterate over execution order groups
5041  for (const auto execution_group : execution_groups)
5042  {
5043  auto query = primary_query.clone().condition<AttribExecutionOrderGroup>(execution_group);
5044 
5045  std::vector<GeneralUserObject *> genobjs;
5046  query.clone().condition<AttribInterfaces>(Interfaces::GeneralUserObject).queryInto(genobjs);
5047 
5048  std::vector<UserObject *> userobjs;
5049  query.clone()
5054  .queryInto(userobjs);
5055 
5056  std::vector<UserObject *> tgobjs;
5057  query.clone()
5059  .queryInto(tgobjs);
5060 
5061  std::vector<UserObject *> nodal;
5062  query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject).queryInto(nodal);
5063 
5064  std::vector<MortarUserObject *> mortar;
5065  query.clone().condition<AttribInterfaces>(Interfaces::MortarUserObject).queryInto(mortar);
5066 
5067  if (userobjs.empty() && genobjs.empty() && tgobjs.empty() && nodal.empty() && mortar.empty())
5068  continue;
5069 
5070  // Start the timer here since we have at least one active user object
5071  std::string compute_uo_tag = "computeUserObjects(" + Moose::stringify(type) + ")";
5072 
5073  // Perform Residual/Jacobian setups
5074  if (type == EXEC_LINEAR)
5075  {
5076  for (auto obj : userobjs)
5077  obj->residualSetup();
5078  for (auto obj : nodal)
5079  obj->residualSetup();
5080  for (auto obj : mortar)
5081  obj->residualSetup();
5082  for (auto obj : tgobjs)
5083  obj->residualSetup();
5084  for (auto obj : genobjs)
5085  obj->residualSetup();
5086  }
5087  else if (type == EXEC_NONLINEAR)
5088  {
5089  for (auto obj : userobjs)
5090  obj->jacobianSetup();
5091  for (auto obj : nodal)
5092  obj->jacobianSetup();
5093  for (auto obj : mortar)
5094  obj->jacobianSetup();
5095  for (auto obj : tgobjs)
5096  obj->jacobianSetup();
5097  for (auto obj : genobjs)
5098  obj->jacobianSetup();
5099  }
5100 
5101  for (auto obj : userobjs)
5102  obj->initialize();
5103 
5104  // Execute Side/InternalSide/Interface/Elemental/DomainUserObjects
5105  if (!userobjs.empty())
5106  {
5107  // non-nodal user objects have to be run separately before the nodal user objects run
5108  // because some nodal user objects (NodalNormal related) depend on elemental user objects
5109  // :-(
5110  ComputeUserObjectsThread cppt(*this, query);
5112 
5113  // There is one instance in rattlesnake where an elemental user object's finalize depends
5114  // on a side user object having been finalized first :-(
5121  }
5122 
5123  // if any userobject may have written to variables we need to close the aux solution
5124  for (const auto & uo : userobjs)
5125  if (auto euo = dynamic_cast<const ElementUserObject *>(uo);
5126  euo && euo->hasWritableCoupledVariables())
5127  {
5128  _aux->solution().close();
5129  _aux->system().update();
5130  break;
5131  }
5132 
5133  // Execute NodalUserObjects
5134  // BISON has an axial reloc elemental user object that has a finalize func that depends on a
5135  // nodal user object's prev value. So we can't initialize this until after elemental objects
5136  // have been finalized :-(
5137  for (auto obj : nodal)
5138  obj->initialize();
5139  if (query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject).count() > 0)
5140  {
5141  ComputeNodalUserObjectsThread cnppt(*this, query);
5144  }
5145 
5146  // if any userobject may have written to variables we need to close the aux solution
5147  for (const auto & uo : nodal)
5148  if (auto nuo = dynamic_cast<const NodalUserObject *>(uo);
5149  nuo && nuo->hasWritableCoupledVariables())
5150  {
5151  _aux->solution().close();
5152  _aux->system().update();
5153  break;
5154  }
5155 
5156  // Execute MortarUserObjects
5157  {
5158  for (auto obj : mortar)
5159  obj->initialize();
5160  if (!mortar.empty())
5161  {
5162  auto create_and_run_mortar_functors = [this, type, &mortar](const bool displaced)
5163  {
5164  // go over mortar interfaces and construct functors
5165  const auto & mortar_interfaces = getMortarInterfaces(displaced);
5166  for (const auto & mortar_interface : mortar_interfaces)
5167  {
5168  const auto primary_secondary_boundary_pair = mortar_interface.first;
5169  auto mortar_uos_to_execute =
5170  getMortarUserObjects(primary_secondary_boundary_pair.first,
5171  primary_secondary_boundary_pair.second,
5172  displaced,
5173  mortar);
5174  const auto & mortar_generation_object = mortar_interface.second;
5175 
5176  auto * const subproblem = displaced
5177  ? static_cast<SubProblem *>(_displaced_problem.get())
5178  : static_cast<SubProblem *>(this);
5179  MortarUserObjectThread muot(mortar_uos_to_execute,
5180  mortar_generation_object,
5181  *subproblem,
5182  *this,
5183  displaced,
5184  subproblem->assembly(0, 0));
5185 
5186  muot();
5187  }
5188  };
5189 
5190  create_and_run_mortar_functors(false);
5191  if (_displaced_problem)
5192  create_and_run_mortar_functors(true);
5193  }
5194  for (auto obj : mortar)
5195  obj->finalize();
5196  }
5197 
5198  // Execute threaded general user objects
5199  for (auto obj : tgobjs)
5200  obj->initialize();
5201  std::vector<GeneralUserObject *> tguos_zero;
5202  query.clone()
5203  .condition<AttribThread>(0)
5204  .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject)
5205  .queryInto(tguos_zero);
5206  for (auto obj : tguos_zero)
5207  {
5208  std::vector<GeneralUserObject *> tguos;
5209  auto q = query.clone()
5210  .condition<AttribName>(obj->name())
5211  .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject);
5212  q.queryInto(tguos);
5213 
5215  Threads::parallel_reduce(GeneralUserObjectRange(tguos.begin(), tguos.end()), ctguot);
5216  joinAndFinalize(q);
5217  }
5218 
5219  // Execute general user objects
5221  true);
5222  }
5223  }
5224  catch (...)
5225  {
5226  handleException("computeUserObjectsInternal");
5227  }
5228 }
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:1104

◆ 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:1104

◆ 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:1104

◆ 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 9232 of file FEProblemBase.C.

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

9233 {
9234  parallel_object_only();
9235 
9236  if (_displaced_problem)
9237  _displaced_problem->computingNonlinearResid(computing_nonlinear_residual);
9238  _computing_nonlinear_residual = computing_nonlinear_residual;
9239 }
bool _computing_nonlinear_residual
Whether the non-linear residual is being evaluated.
Definition: SubProblem.h:1104
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 6821 of file FEProblemBase.C.

Referenced by DisplacedProblem::computingPreSMOResidual().

6822 {
6823  return _nl[nl_sys_num]->computingPreSMOResidual();
6824 }
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 2549 of file FEProblemBase.h.

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

2550  {
2551  _computing_scaling_jacobian = computing_scaling_jacobian;
2552  }
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 2554 of file FEProblemBase.h.

2554 { 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 2559 of file FEProblemBase.h.

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

2560  {
2561  _computing_scaling_residual = computing_scaling_residual;
2562  }
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 2567 of file FEProblemBase.h.

2567 { 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:2973
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.

◆ constantMatrices() [1/2]

bool EigenProblem::constantMatrices ( ) const
inline

◆ constantMatrices() [2/2]

void EigenProblem::constantMatrices ( bool  cm)
inline

Set a flag to indicate whether or not we use constant matrices.

Definition at line 212 of file EigenProblem.h.

212 { _constant_matrices = cm; }
bool _constant_matrices
Whether or not require constant matrices.
Definition: EigenProblem.h:262

◆ 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 9065 of file FEProblemBase.C.

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

9066 {
9067  return _const_jacobian;
9068 }
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 9468 of file FEProblemBase.C.

9469 {
9470  return mesh().coordTransform();
9471 }
MooseAppCoordTransform & coordTransform()
Definition: MooseMesh.h:1923
virtual MooseMesh & mesh() override

◆ copySolutionsBackwards()

void FEProblemBase::copySolutionsBackwards ( )
virtualinherited

Definition at line 6827 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

6828 {
6829  TIME_SECTION("copySolutionsBackwards", 3, "Copying Solutions Backward");
6830 
6831  for (auto & sys : _solver_systems)
6832  sys->copySolutionsBackwards();
6833  _aux->copySolutionsBackwards();
6834 }
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 3524 of file FEProblemBase.h.

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

3525 {
3526  return _cm[i].get();
3527 }
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 8040 of file FEProblemBase.C.

8048 {
8049  _has_mortar = true;
8050 
8051  if (on_displaced)
8052  return _mortar_data.createMortarInterface(primary_secondary_boundary_pair,
8053  primary_secondary_subdomain_pair,
8055  on_displaced,
8056  periodic,
8057  debug,
8058  correct_edge_dropping,
8059  minimum_projection_angle);
8060  else
8061  return _mortar_data.createMortarInterface(primary_secondary_boundary_pair,
8062  primary_secondary_subdomain_pair,
8063  *this,
8064  on_displaced,
8065  periodic,
8066  debug,
8067  correct_edge_dropping,
8068  minimum_projection_angle);
8069 }
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 6247 of file FEProblemBase.C.

6253 {
6254  if (order == INVALID_ORDER)
6255  {
6256  // automatically determine the integration order
6257  order = _solver_systems[0]->getMinQuadratureOrder();
6258  for (const auto i : make_range(std::size_t(1), _solver_systems.size()))
6259  if (order < _solver_systems[i]->getMinQuadratureOrder())
6260  order = _solver_systems[i]->getMinQuadratureOrder();
6261  if (order < _aux->getMinQuadratureOrder())
6262  order = _aux->getMinQuadratureOrder();
6263  }
6264 
6265  if (volume_order == INVALID_ORDER)
6266  volume_order = order;
6267 
6268  if (face_order == INVALID_ORDER)
6269  face_order = order;
6270 
6271  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
6272  for (const auto i : index_range(_solver_systems))
6273  _assembly[tid][i]->createQRules(
6274  type, order, volume_order, face_order, block, allow_negative_qweights);
6275 
6276  if (_displaced_problem)
6277  _displaced_problem->createQRules(
6278  type, order, volume_order, face_order, block, allow_negative_qweights);
6279 
6280  updateMaxQps();
6281 }
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:312
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(), 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:93
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(), 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:93
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:150

◆ currentLinearSysNum()

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

Implements SubProblem.

Definition at line 9485 of file FEProblemBase.C.

Referenced by DisplacedProblem::currentLinearSysNum().

9486 {
9487  // If we don't have linear systems this should be an invalid number
9488  unsigned int current_linear_sys_num = libMesh::invalid_uint;
9489  if (_linear_systems.size())
9490  current_linear_sys_num = currentLinearSystem().number();
9491 
9492  return current_linear_sys_num;
9493 }
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 3492 of file FEProblemBase.h.

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

3493 {
3494  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3495  return *_current_linear_sys;
3496 }
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 3499 of file FEProblemBase.h.

3500 {
3501  mooseAssert(_current_linear_sys, "The linear system is not currently set");
3502  return *_current_linear_sys;
3503 }
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:1098

◆ 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:1107

◆ 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:1107

◆ 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 1492 of file SubProblem.h.

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

1493 {
1495 }
bool _currently_computing_residual_and_jacobian
Flag to determine whether the problem is currently computing the residual and Jacobian.
Definition: SubProblem.h:1101

◆ currentNlSysNum()

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

Implements SubProblem.

Definition at line 9474 of file FEProblemBase.C.

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

9475 {
9476  // If we don't have nonlinear systems this should be an invalid number
9477  unsigned int current_nl_sys_num = libMesh::invalid_uint;
9478  if (_nl.size())
9479  current_nl_sys_num = currentNonlinearSystem().number();
9480 
9481  return current_nl_sys_num;
9482 }
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 3469 of file FEProblemBase.h.

3470 {
3471  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
3472  return *_current_nl_sys;
3473 }
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 3540 of file FEProblemBase.h.

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

3541 {
3543 }
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 4793 of file FEProblemBase.C.

Referenced by FEProblemBase::execute().

4794 {
4795  SubProblem::customSetup(exec_type);
4796 
4797  if (_line_search)
4798  _line_search->customSetup(exec_type);
4799 
4800  unsigned int n_threads = libMesh::n_threads();
4801  for (THREAD_ID tid = 0; tid < n_threads; tid++)
4802  {
4803  _all_materials.customSetup(exec_type, tid);
4804  _functions.customSetup(exec_type, tid);
4805  }
4806 
4807  _aux->customSetup(exec_type);
4808  for (auto & nl : _nl)
4809  nl->customSetup(exec_type);
4810 
4811  if (_displaced_problem)
4812  _displaced_problem->customSetup(exec_type);
4813 
4814  for (THREAD_ID tid = 0; tid < n_threads; tid++)
4815  {
4816  _internal_side_indicators.customSetup(exec_type, tid);
4817  _indicators.customSetup(exec_type, tid);
4818  _markers.customSetup(exec_type, tid);
4819  }
4820 
4821  std::vector<UserObject *> userobjs;
4822  theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(userobjs);
4823  for (auto obj : userobjs)
4824  obj->customSetup(exec_type);
4825 
4826  _app.getOutputWarehouse().customSetup(exec_type);
4827 }
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:1196
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:2515
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 DisplacedSystem::DisplacedSystem(), and NonlinearSystemBase::NonlinearSystemBase().

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

◆ diracKernelInfo()

DiracKernelInfo & SubProblem::diracKernelInfo ( )
virtualinherited

Definition at line 749 of file SubProblem.C.

750 {
751  return _dirac_kernel_info;
752 }
DiracKernelInfo _dirac_kernel_info
Definition: SubProblem.h:1051

◆ doFreeNonlinearPowerIterations()

void EigenProblem::doFreeNonlinearPowerIterations ( unsigned int  free_power_iterations)
private

Do some free/extra power iterations.

Definition at line 518 of file EigenProblem.C.

Referenced by solve().

519 {
520  mooseAssert(_current_nl_sys, "This needs to be non-null");
521 
522  doFreePowerIteration(true);
523  // Set free power iterations
525 
526  // Call solver
529 
530  // Clear free power iterations
531  auto executioner = getMooseApp().getExecutioner();
532  if (executioner)
534  else
535  mooseError("There is no executioner for this moose app");
536 
537  doFreePowerIteration(false);
538 }
void clearFreeNonlinearPowerIterations(const InputParameters &params)
Definition: SlepcSupport.C:419
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:87
void update()
Update the system (doing libMesh magic)
Definition: SystemBase.C:1243
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
Executioner * getExecutioner() const
Retrieve the Executioner for this App.
Definition: MooseApp.C:2196
virtual void solve() override=0
Solve the system (using libMesh magic)
void setFreeNonlinearPowerIterations(unsigned int free_power_iterations)
Set SLEPc/PETSc options to trigger free power iteration.
Definition: SlepcSupport.C:404
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 doFreePowerIteration() const
Whether or not we are doing free power iteration.
Definition: EigenProblem.h:79

◆ doFreePowerIteration() [1/2]

bool EigenProblem::doFreePowerIteration ( ) const
inline

Whether or not we are doing free power iteration.

It is used in convergence check. We need to mark the solver as "converged" when doing free power to retrieve the final solution from SLPEc

Definition at line 79 of file EigenProblem.h.

Referenced by doFreeNonlinearPowerIterations(), and Moose::SlepcSupport::mooseSlepcStoppingTest().

79 { return _do_free_power_iteration; }
bool _do_free_power_iteration
Whether or not we are doing free power iteration.
Definition: EigenProblem.h:254

◆ doFreePowerIteration() [2/2]

void EigenProblem::doFreePowerIteration ( bool  do_power)
inline

Set a flag to indicate whether or not we are doing free power iterations.

Definition at line 84 of file EigenProblem.h.

84 { _do_free_power_iteration = do_power; }
bool _do_free_power_iteration
Whether or not we are doing free power iteration.
Definition: EigenProblem.h:254

◆ doingPRefinement()

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

Definition at line 1366 of file SubProblem.C.

Referenced by FEProblemBase::meshChanged().

1367 {
1368  return mesh().doingPRefinement();
1369 }
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:1365

◆ dt()

virtual Real& FEProblemBase::dt ( ) const
inlinevirtualinherited

◆ dtOld()

virtual Real& FEProblemBase::dtOld ( ) const
inlinevirtualinherited

Definition at line 545 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep().

545 { 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 2783 of file FEProblemBase.C.

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

2787 {
2788  std::set<SubdomainID> subdomainIDs;
2789  if (active_subdomains->size() == 0)
2790  {
2791  const auto subdomains = _mesh.meshSubdomains();
2792  subdomainIDs.insert(subdomains.begin(), subdomains.end());
2793  }
2794  else
2795  subdomainIDs.insert(active_subdomains->begin(), active_subdomains->end());
2796 
2797  for (auto & sys : _solver_systems)
2798  {
2799  SystemBase * curr_sys_ptr = sys.get();
2800  SystemBase * other_sys_ptr = _aux.get();
2801  std::string error_prefix = "";
2802  if (is_aux)
2803  {
2804  curr_sys_ptr = _aux.get();
2805  other_sys_ptr = sys.get();
2806  error_prefix = "aux";
2807  }
2808 
2809  if (other_sys_ptr->hasVariable(var_name))
2810  mooseError("Cannot have an auxiliary variable and a solver variable with the same name: ",
2811  var_name);
2812 
2813  if (curr_sys_ptr->hasVariable(var_name))
2814  {
2815  const Variable & var =
2816  curr_sys_ptr->system().variable(curr_sys_ptr->system().variable_number(var_name));
2817 
2818  // variable type
2819  if (var.type() != type)
2820  {
2821  const auto stringifyType = [](FEType t)
2822  { return Moose::stringify(t.family) + " of order " + Moose::stringify(t.order); };
2823 
2824  mooseError("Mismatching types are specified for ",
2825  error_prefix,
2826  "variable with name '",
2827  var_name,
2828  "': '",
2829  stringifyType(var.type()),
2830  "' and '",
2831  stringifyType(type),
2832  "'");
2833  }
2834 
2835  // block-restriction
2836  if (!(active_subdomains->size() == 0 && var.active_subdomains().size() == 0))
2837  {
2838  const auto varActiveSubdomains = var.active_subdomains();
2839  std::set<SubdomainID> varSubdomainIDs;
2840  if (varActiveSubdomains.size() == 0)
2841  {
2842  const auto subdomains = _mesh.meshSubdomains();
2843  varSubdomainIDs.insert(subdomains.begin(), subdomains.end());
2844  }
2845  else
2846  varSubdomainIDs.insert(varActiveSubdomains.begin(), varActiveSubdomains.end());
2847 
2848  // Is subdomainIDs a subset of varSubdomainIDs? With this we allow the case that the newly
2849  // requested block restriction is only a subset of the existing one.
2850  const auto isSubset = std::includes(varSubdomainIDs.begin(),
2851  varSubdomainIDs.end(),
2852  subdomainIDs.begin(),
2853  subdomainIDs.end());
2854 
2855  if (!isSubset)
2856  {
2857  // helper function: make a string from a set of subdomain ids
2858  const auto stringifySubdomains = [this](std::set<SubdomainID> subdomainIDs)
2859  {
2860  std::stringstream s;
2861  for (auto const i : subdomainIDs)
2862  {
2863  // do we need to insert a comma?
2864  if (s.tellp() != 0)
2865  s << ", ";
2866 
2867  // insert subdomain name and id -or- only the id (if no name is given)
2868  const auto subdomainName = _mesh.getSubdomainName(i);
2869  if (subdomainName.empty())
2870  s << i;
2871  else
2872  s << subdomainName << " (" << i << ")";
2873  }
2874  return s.str();
2875  };
2876 
2877  const std::string msg = "Mismatching block-restrictions are specified for " +
2878  error_prefix + "variable with name '" + var_name + "': {" +
2879  stringifySubdomains(varSubdomainIDs) + "} and {" +
2880  stringifySubdomains(subdomainIDs) + "}";
2881 
2882  mooseError(msg);
2883  }
2884  }
2885 
2886  return true;
2887  }
2888  }
2889 
2890  return false;
2891 }
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:3192
const FEType & type() const

◆ enabled()

virtual bool MooseObject::enabled ( ) const
inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

Referenced by EigenKernel::enabled().

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

◆ 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 2150 of file FEProblemBase.h.

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

2151  {
2153  }
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 5637 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().

5638 {
5639  // Active MultiApps
5640  const std::vector<MooseSharedPointer<MultiApp>> & multi_apps =
5642 
5643  // Do anything that needs to be done to Apps before transfers
5644  for (const auto & multi_app : multi_apps)
5645  multi_app->preTransfer(_dt, _time);
5646 
5647  // Execute Transfers _to_ MultiApps
5649 
5650  // Execute Transfers _between_ Multiapps
5652 
5653  // Execute MultiApps
5654  if (multi_apps.size())
5655  {
5656  TIME_SECTION("execMultiApps", 1, "Executing MultiApps", false);
5657 
5658  if (_verbose_multiapps)
5659  _console << COLOR_CYAN << "\nExecuting MultiApps on " << Moose::stringify(type)
5660  << COLOR_DEFAULT << std::endl;
5661 
5662  bool success = true;
5663 
5664  for (const auto & multi_app : multi_apps)
5665  {
5666  success = multi_app->solveStep(_dt, _time, auto_advance);
5667  // no need to finish executing the subapps if one fails
5668  if (!success)
5669  break;
5670  }
5671 
5673 
5674  _communicator.min(success);
5675 
5676  if (!success)
5677  return false;
5678 
5679  if (_verbose_multiapps)
5680  _console << COLOR_CYAN << "Finished Executing MultiApps on " << Moose::stringify(type) << "\n"
5681  << COLOR_DEFAULT << std::endl;
5682  }
5683 
5684  // Execute Transfers _from_ MultiApps
5686 
5687  // If we made it here then everything passed
5688  return true;
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 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:327
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 5537 of file FEProblemBase.C.

Referenced by FEProblemBase::execMultiApps().

5538 {
5539  bool to_multiapp = direction == MultiAppTransfer::TO_MULTIAPP;
5540  bool from_multiapp = direction == MultiAppTransfer::FROM_MULTIAPP;
5541  std::string string_direction;
5542  if (to_multiapp)
5543  string_direction = " To ";
5544  else if (from_multiapp)
5545  string_direction = " From ";
5546  else
5547  string_direction = " Between ";
5548 
5549  const MooseObjectWarehouse<Transfer> & wh = to_multiapp ? _to_multi_app_transfers[type]
5550  : from_multiapp ? _from_multi_app_transfers[type]
5552 
5553  if (wh.hasActiveObjects())
5554  {
5555  TIME_SECTION("execMultiAppTransfers", 1, "Executing Transfers");
5556 
5557  const auto & transfers = wh.getActiveObjects();
5558 
5559  if (_verbose_multiapps)
5560  {
5561  _console << COLOR_CYAN << "\nTransfers on " << Moose::stringify(type) << string_direction
5562  << "MultiApps" << COLOR_DEFAULT << ":" << std::endl;
5563 
5565  {"Name", "Type", "From", "To"});
5566 
5567  // Build Table of Transfer Info
5568  for (const auto & transfer : transfers)
5569  {
5570  auto multiapp_transfer = dynamic_cast<MultiAppTransfer *>(transfer.get());
5571 
5572  table.addRow(multiapp_transfer->name(),
5573  multiapp_transfer->type(),
5574  multiapp_transfer->getFromName(),
5575  multiapp_transfer->getToName());
5576  }
5577 
5578  // Print it
5579  table.print(_console);
5580  }
5581 
5582  for (const auto & transfer : transfers)
5583  {
5584  transfer->setCurrentDirection(direction);
5585  transfer->execute();
5586  }
5587 
5589 
5590  if (_verbose_multiapps)
5591  _console << COLOR_CYAN << "Transfers on " << Moose::stringify(type) << " Are Finished\n"
5592  << COLOR_DEFAULT << std::endl;
5593  }
5594  else if (_multi_apps[type].getActiveObjects().size())
5595  {
5596  if (_verbose_multiapps)
5597  _console << COLOR_CYAN << "\nNo Transfers on " << Moose::stringify(type) << string_direction
5598  << "MultiApps\n"
5599  << COLOR_DEFAULT << std::endl;
5600  }
5601 }
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:327
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 5807 of file FEProblemBase.C.

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

5808 {
5809  if (_transfers[type].hasActiveObjects())
5810  {
5811  TIME_SECTION("execTransfers", 3, "Executing Transfers");
5812 
5813  const auto & transfers = _transfers[type].getActiveObjects();
5814 
5815  for (const auto & transfer : transfers)
5816  transfer->execute();
5817  }
5818 }
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 EigenProblem::execute ( const ExecFlagType exec_type)
overridevirtual

Convenience function for performing execution of MOOSE systems.

We override this function to perform an initial scaling.

Reimplemented from FEProblemBase.

Definition at line 165 of file EigenProblem.C.

Referenced by Eigenvalue::execute(), Eigenvalue::init(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionB(), postScaleEigenVector(), and solve().

166 {
167  if (exec_type == EXEC_INITIAL && !_app.isRestarting())
168  // we need to scale the solution properly and we can do this only all initial setup of
169  // depending objects by the residual evaluations has been done to this point.
170  preScaleEigenVector(std::pair<Real, Real>(_initial_eigenvalue, 0));
171 
172  FEProblemBase::execute(exec_type);
173 }
bool isRestarting() const
Whether or not this is a "restart" calculation.
Definition: MooseApp.C:1880
void preScaleEigenVector(const std::pair< Real, Real > &eig)
Eigenvector need to be scaled back if it was scaled in an earlier stage Scaling eigen vector does not...
Definition: EigenProblem.C:433
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
Real _initial_eigenvalue
A value used for initial normalization.
Definition: EigenProblem.h:273
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:30

◆ executeAllObjects()

void FEProblemBase::executeAllObjects ( const ExecFlagType exec_type)
virtualinherited

Definition at line 4788 of file FEProblemBase.C.

Referenced by Executor::exec().

4789 {
4790 }

◆ executeControls()

void FEProblemBase::executeControls ( const ExecFlagType exec_type)
inherited

Performs setup and execute calls for Control objects.

Definition at line 5231 of file FEProblemBase.C.

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

5232 {
5233  if (_control_warehouse[exec_type].hasActiveObjects())
5234  {
5235  TIME_SECTION("executeControls", 1, "Executing Controls");
5236 
5238 
5239  auto controls_wh = _control_warehouse[exec_type];
5240  // Add all of the dependencies into the resolver and sort them
5241  for (const auto & it : controls_wh.getActiveObjects())
5242  {
5243  // Make sure an item with no dependencies comes out too!
5244  resolver.addItem(it);
5245 
5246  std::vector<std::string> & dependent_controls = it->getDependencies();
5247  for (const auto & depend_name : dependent_controls)
5248  {
5249  if (controls_wh.hasActiveObject(depend_name))
5250  {
5251  auto dep_control = controls_wh.getActiveObject(depend_name);
5252  resolver.addEdge(dep_control, it);
5253  }
5254  else
5255  mooseError("The Control \"",
5256  depend_name,
5257  "\" was not created, did you make a "
5258  "spelling mistake or forget to include it "
5259  "in your input file?");
5260  }
5261  }
5262 
5263  const auto & ordered_controls = resolver.getSortedValues();
5264 
5265  if (!ordered_controls.empty())
5266  {
5267  _control_warehouse.setup(exec_type);
5268  // Run the controls in the proper order
5269  for (const auto & control : ordered_controls)
5270  control->execute();
5271  }
5272  }
5273 }
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 5276 of file FEProblemBase.C.

Referenced by FEProblemBase::execute().

5277 {
5278  // TODO: This should be done in a threaded loop, but this should be super quick so for now
5279  // do a serial loop.
5280  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
5281  {
5282  std::vector<Sampler *> objects;
5283  theWarehouse()
5284  .query()
5285  .condition<AttribSystem>("Sampler")
5286  .condition<AttribThread>(tid)
5287  .condition<AttribExecOns>(exec_type)
5288  .queryInto(objects);
5289 
5290  if (!objects.empty())
5291  {
5292  TIME_SECTION("executeSamplers", 1, "Executing Samplers");
5293  FEProblemBase::objectSetupHelper<Sampler>(objects, exec_type);
5294  FEProblemBase::objectExecuteHelper<Sampler>(objects);
5295  }
5296  }
5297 }
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

◆ feBackend()

virtual Moose::FEBackend FEProblemBase::feBackend ( ) const
inlinevirtualinherited

◆ finalizeMultiApps()

void FEProblemBase::finalizeMultiApps ( )
inherited

Definition at line 5692 of file FEProblemBase.C.

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

5693 {
5694  const auto & multi_apps = _multi_apps.getActiveObjects();
5695 
5696  for (const auto & multi_app : multi_apps)
5697  multi_app->finalize();
5698 }
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 6815 of file FEProblemBase.C.

6816 {
6817  return _nl[nl_sys_num]->finalNonlinearResidual();
6818 }
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 5720 of file FEProblemBase.C.

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

5721 {
5722  const auto & multi_apps = _multi_apps[type].getActiveObjects();
5723 
5724  if (multi_apps.size())
5725  {
5726  if (_verbose_multiapps)
5727  _console << COLOR_CYAN << "\nAdvancing MultiApps on " << type.name() << COLOR_DEFAULT
5728  << std::endl;
5729 
5730  for (const auto & multi_app : multi_apps)
5731  multi_app->finishStep(recurse_through_multiapp_levels);
5732 
5734 
5735  if (_verbose_multiapps)
5736  _console << COLOR_CYAN << "Finished Advancing MultiApps on " << type.name() << "\n"
5737  << COLOR_DEFAULT << std::endl;
5738  }
5739 }
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:327
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.

◆ flagInvalidSolutionInternal()

template<bool warning>
template void SolutionInvalidInterface::flagInvalidSolutionInternal< false > ( const InvalidSolutionID  invalid_solution_id) const
protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

43 {
44  mooseAssert(
45  warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
46  "Inconsistent warning flag");
47  auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
48  if constexpr (!warning)
50  solution_invalidity.printDebug(invalid_solution_id);
51  return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
52 }
const FEProblemBase * _si_problem
A pointer to FEProblem base.
void printDebug(InvalidSolutionID _invalid_solution_id) const
Immediately print the section and message for debug purpose.
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:87
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
Definition: MooseApp.h:179
SolutionInvalidityRegistry & getSolutionInvalidityRegistry()
Get the global SolutionInvalidityRegistry singleton.
bool immediatelyPrintInvalidSolution() const
Whether or not the solution invalid warnings are printed out immediately.
const MooseBase & _si_moose_base
The MooseBase that owns this interface.

◆ 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 6950 of file FEProblemBase.C.

Referenced by TransientMultiApp::solveStep().

6951 {
6953 }
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:2515

◆ formNorm()

Real EigenProblem::formNorm ( )

Form the Bx norm.

Definition at line 693 of file EigenProblem.C.

Referenced by Moose::SlepcSupport::mooseSlepcEigenFormNorm(), and preScaleEigenVector().

694 {
695  mooseAssert(_bx_norm_name,
696  "We should not get here unless a bx_norm postprocessor has been provided");
698 }
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.
std::optional< PostprocessorName > _bx_norm_name
The name of the Postprocessor providing the Bx norm.
Definition: EigenProblem.h:289

◆ fvBCsIntegrityCheck() [1/2]

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

Definition at line 2478 of file FEProblemBase.h.

2478 { 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 3530 of file FEProblemBase.h.

3531 {
3533  // the user has requested that we don't check integrity so we will honor that
3534  return;
3535 
3536  _fv_bcs_integrity_check = fv_bcs_integrity_check;
3537 }
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 455 of file SubProblem.C.

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

456 {
458 }
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:1077

◆ getActiveFEVariableCoupleableMatrixTags()

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

Definition at line 391 of file SubProblem.C.

392 {
394 }
std::vector< std::set< TagID > > _active_fe_var_coupleable_matrix_tags
Definition: SubProblem.h:1083

◆ getActiveFEVariableCoupleableVectorTags()

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

Definition at line 397 of file SubProblem.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

398 {
400 }
std::vector< std::set< TagID > > _active_fe_var_coupleable_vector_tags
Definition: SubProblem.h:1085

◆ getActiveScalarVariableCoupleableMatrixTags()

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

Definition at line 432 of file SubProblem.C.

Referenced by MooseVariableScalar::reinit().

433 {
435 }
std::vector< std::set< TagID > > _active_sc_var_coupleable_matrix_tags
Definition: SubProblem.h:1087

◆ getActiveScalarVariableCoupleableVectorTags()

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

Definition at line 438 of file SubProblem.C.

439 {
441 }
std::vector< std::set< TagID > > _active_sc_var_coupleable_vector_tags
Definition: SubProblem.h:1089

◆ 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 5937 of file FEProblemBase.C.

Referenced by MultiAppVariableValueSampleTransfer::execute().

5938 {
5939  for (auto & sys : _solver_systems)
5940  if (sys->hasVariable(var_name))
5941  return sys->getActualFieldVariable<Real>(tid, var_name);
5942  if (_aux->hasVariable(var_name))
5943  return _aux->getActualFieldVariable<Real>(tid, var_name);
5944 
5945  mooseError("Unknown variable " + var_name);
5946 }
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 5961 of file FEProblemBase.C.

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

5962 {
5963  for (auto & sys : _solver_systems)
5964  if (sys->hasVariable(var_name))
5965  return sys->getFieldVariable<RealEigenVector>(tid, var_name);
5966  if (_aux->hasVariable(var_name))
5967  return _aux->getFieldVariable<RealEigenVector>(tid, var_name);
5968 
5969  mooseError("Unknown variable " + var_name);
5970 }
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

◆ 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 797 of file SubProblem.C.

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

◆ 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 1848 of file FEProblemBase.h.

1848 { 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

◆ 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 743 of file SubProblem.C.

Referenced by MaterialPropertyDebugOutput::output().

744 {
746 }
std::map< MooseObjectName, std::set< std::string > > _consumed_material_properties
Definition: SubProblem.h:1190

◆ getControlWarehouse()

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

Reference to the control logic warehouse.

Definition at line 2270 of file FEProblemBase.h.

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

2270 { 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 2671 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().

2672 {
2673  auto * const ret = dynamic_cast<Convergence *>(_convergences.getActiveObject(name, tid).get());
2674  if (!ret)
2675  mooseError("The Convergence object '", name, "' does not exist.");
2676 
2677  return *ret;
2678 }
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 2681 of file FEProblemBase.C.

2682 {
2683  return _convergences.getActiveObjects(tid);
2684 }
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 1283 of file SubProblem.C.

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

1284 {
1285  return mesh().getCoordSystem(sid);
1286 }
virtual MooseMesh & mesh()=0
Moose::CoordinateSystemType getCoordSystem(SubdomainID sid) const
Get the coordinate system type, e.g.
Definition: MooseMesh.C:4196

◆ getCurrentAlgebraicBndNodeRange()

const ConstBndNodeRange & FEProblemBase::getCurrentAlgebraicBndNodeRange ( )
inherited

Definition at line 9626 of file FEProblemBase.C.

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

9627 {
9629  return *_mesh.getBoundaryNodeRange();
9630 
9632 }
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 9610 of file FEProblemBase.C.

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

9611 {
9614 
9616 }
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 9618 of file FEProblemBase.C.

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

9619 {
9621  return *_mesh.getLocalNodeRange();
9622 
9624 }
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 4776 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().

4777 {
4778  return _current_execute_on_flag;
4779 }
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 9669 of file FEProblemBase.C.

Referenced by ComputeInitialConditionThread::operator()().

9670 {
9671  return _current_ic_state;
9672 }
unsigned short _current_ic_state

◆ getCurrentNonlinearEigenSystem()

NonlinearEigenSystem & EigenProblem::getCurrentNonlinearEigenSystem ( )
inline

◆ 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:297
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 2491 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDiracContributions().

2492 {
2493  // First add in the undisplaced elements
2494  elems = _dirac_kernel_info.getElements();
2495 
2496  if (_displaced_problem)
2497  {
2498  std::set<const Elem *> displaced_elements;
2499  _displaced_problem->getDiracElements(displaced_elements);
2500 
2501  { // Use the ids from the displaced elements to get the undisplaced elements
2502  // and add them to the list
2503  for (const auto & elem : displaced_elements)
2504  elems.insert(_mesh.elemPtr(elem->id()));
2505  }
2506  }
2507 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3134
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:1051

◆ getDiscreteMaterialWarehouse()

const MaterialWarehouse& FEProblemBase::getDiscreteMaterialWarehouse ( ) const
inlineinherited

Definition at line 2090 of file FEProblemBase.h.

2090 { 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 1790 of file FEProblemBase.h.

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

◆ getDistribution()

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

Definition at line 2741 of file FEProblemBase.C.

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

2742 {
2743  std::vector<Distribution *> objs;
2744  theWarehouse()
2745  .query()
2746  .condition<AttribSystem>("Distribution")
2747  .condition<AttribName>(name)
2748  .queryInto(objs);
2749  if (objs.empty())
2750  mooseError("Unable to find Distribution with name '" + name + "'");
2751  return *(objs[0]);
2752 }
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:3469
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 2222 of file FEProblemBase.h.

2222 { 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 2610 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 2612 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 2620 of file FEProblemBase.C.

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

2621 {
2622  // This thread lock is necessary since this method will create functions
2623  // for all threads if one is missing.
2624  Threads::spin_mutex::scoped_lock lock(get_function_mutex);
2625 
2626  if (!hasFunction(name, tid))
2627  {
2628  // If we didn't find a function, it might be a default function, attempt to construct one now
2629  std::istringstream ss(name);
2630  Real real_value;
2631 
2632  // First see if it's just a constant. If it is, build a ConstantFunction
2633  if (ss >> real_value && ss.eof())
2634  {
2635  InputParameters params = _factory.getValidParams("ConstantFunction");
2636  params.set<Real>("value") = real_value;
2637  addFunction("ConstantFunction", ss.str(), params);
2638  }
2639  else
2640  {
2642  std::string vars = "x,y,z,t,NaN,pi,e";
2643  if (fp.Parse(name, vars) == -1) // -1 for success
2644  {
2645  // It parsed ok, so build a MooseParsedFunction
2646  InputParameters params = _factory.getValidParams("ParsedFunction");
2647  params.set<std::string>("expression") = name;
2648  addFunction("ParsedFunction", name, params);
2649  }
2650  }
2651 
2652  // Try once more
2653  if (!hasFunction(name, tid))
2654  mooseError("Unable to find function " + name);
2655  }
2656 
2657  auto * const ret = dynamic_cast<Function *>(_functions.getActiveObject(name, tid).get());
2658  if (!ret)
2659  mooseError("No function named ", name, " of appropriate type");
2660 
2661  return *ret;
2662 }
Base class for function objects.
Definition: Function.h:36
Factory & _factory
The Factory for building objects.
Definition: SubProblem.h:1049
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 1219 of file SubProblem.h.

Referenced by FunctorInterface::getFunctorByName().

1223 {
1224  mooseAssert(tid < _functors.size(), "Too large a thread ID");
1225 
1226  // Log the requestor
1227  _functor_to_requestors["wraps_" + name].insert(requestor_name);
1228 
1229  constexpr bool requested_functor_is_ad =
1230  !std::is_same<T, typename MetaPhysicL::RawType<T>::value_type>::value;
1231 
1232  auto & functor_to_request_info = _functor_to_request_info[tid];
1233 
1234  // Get the requested functor if we already have it
1235  auto & functors = _functors[tid];
1236  if (auto find_ret = functors.find("wraps_" + name); find_ret != functors.end())
1237  {
1238  if (functors.count("wraps_" + name) > 1)
1239  mooseError("Attempted to get a functor with the name '",
1240  name,
1241  "' but multiple (" + std::to_string(functors.count("wraps_" + name)) +
1242  ") functors match. Make sure that you do not have functor material "
1243  "properties, functions, postprocessors or variables with the same names.");
1244 
1245  auto & [true_functor_is, non_ad_functor, ad_functor] = find_ret->second;
1246  auto & functor_wrapper = requested_functor_is_ad ? *ad_functor : *non_ad_functor;
1247 
1248  auto * const functor = dynamic_cast<Moose::Functor<T> *>(&functor_wrapper);
1249  if (!functor)
1250  mooseError("A call to SubProblem::getFunctor requested a functor named '",
1251  name,
1252  "' that returns the type: '",
1253  libMesh::demangle(typeid(T).name()),
1254  "'. However, that functor already exists and returns a different type: '",
1255  functor_wrapper.returnType(),
1256  "'");
1257 
1258  if (functor->template wrapsType<Moose::NullFunctor<T>>())
1259  // Store for future checking when the actual functor gets added
1260  functor_to_request_info.emplace(name,
1261  std::make_pair(requested_functor_is_ad, requestor_is_ad));
1262  else
1263  {
1264  // We already have the actual functor
1265  if (true_functor_is == SubProblem::TrueFunctorIs::UNSET)
1266  mooseError("We already have the functor; it should not be unset");
1267 
1268  // Check for whether this is a valid request
1269  // We allow auxiliary variables and linear variables to be retrieved as non AD
1270  if (!requested_functor_is_ad && requestor_is_ad &&
1271  true_functor_is == SubProblem::TrueFunctorIs::AD &&
1273  mooseError("The AD object '",
1274  requestor_name,
1275  "' is requesting the functor '",
1276  name,
1277  "' as a non-AD functor even though it is truly an AD functor, which is not "
1278  "allowed, since this may unintentionally drop derivatives.");
1279  }
1280 
1281  return *functor;
1282  }
1283 
1284  // We don't have the functor yet but we could have it in the future. We'll create null functors
1285  // for now
1286  functor_to_request_info.emplace(name, std::make_pair(requested_functor_is_ad, requestor_is_ad));
1287  if constexpr (requested_functor_is_ad)
1288  {
1289  typedef typename MetaPhysicL::RawType<T>::value_type NonADType;
1290  typedef T ADType;
1291 
1292  auto emplace_ret =
1293  functors.emplace("wraps_" + name,
1294  std::make_tuple(SubProblem::TrueFunctorIs::UNSET,
1295  std::make_unique<Moose::Functor<NonADType>>(
1296  std::make_unique<Moose::NullFunctor<NonADType>>()),
1297  std::make_unique<Moose::Functor<ADType>>(
1298  std::make_unique<Moose::NullFunctor<ADType>>())));
1299 
1300  return static_cast<Moose::Functor<T> &>(*(requested_functor_is_ad
1301  ? std::get<2>(emplace_ret->second)
1302  : std::get<1>(emplace_ret->second)));
1303  }
1304  else
1305  {
1306  typedef T NonADType;
1307  typedef typename Moose::ADType<T>::type ADType;
1308 
1309  auto emplace_ret =
1310  functors.emplace("wraps_" + name,
1311  std::make_tuple(SubProblem::TrueFunctorIs::UNSET,
1312  std::make_unique<Moose::Functor<NonADType>>(
1313  std::make_unique<Moose::NullFunctor<NonADType>>()),
1314  std::make_unique<Moose::Functor<ADType>>(
1315  std::make_unique<Moose::NullFunctor<ADType>>())));
1316 
1317  return static_cast<Moose::Functor<T> &>(*(requested_functor_is_ad
1318  ? std::get<2>(emplace_ret->second)
1319  : std::get<1>(emplace_ret->second)));
1320  }
1321 }
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:1159
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:1163
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:1146
virtual bool hasLinearVariable(const std::string &var_name) const
Whether or not this problem has this linear variable.
Definition: SubProblem.C:803
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:812

◆ getFVInitialConditionWarehouse()

const FVInitialConditionWarehouse& FEProblemBase::getFVInitialConditionWarehouse ( ) const
inlineinherited

Return FVInitialCondition storage.

Definition at line 1890 of file FEProblemBase.h.

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

1890 { 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 9305 of file FEProblemBase.C.

9311 {
9312  if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
9313  {
9314  auto & this_face_mats =
9316  for (std::shared_ptr<MaterialBase> face_mat : this_face_mats)
9317  if (face_mat->ghostable())
9318  {
9319  face_materials.push_back(face_mat);
9320  auto & var_deps = face_mat->getMooseVariableDependencies();
9321  for (auto * var : var_deps)
9322  {
9323  if (!var->isFV())
9324  mooseError(
9325  "Ghostable materials should only have finite volume variables coupled into them.");
9326  else if (face_mat->hasStatefulProperties())
9327  mooseError("Finite volume materials do not currently support stateful properties.");
9328  variables.insert(var);
9329  }
9330  }
9331  }
9332 
9333  if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
9334  {
9335  auto & this_neighbor_mats =
9337  for (std::shared_ptr<MaterialBase> neighbor_mat : this_neighbor_mats)
9338  if (neighbor_mat->ghostable())
9339  {
9340  neighbor_materials.push_back(neighbor_mat);
9341 #ifndef NDEBUG
9342  auto & var_deps = neighbor_mat->getMooseVariableDependencies();
9343  for (auto * var : var_deps)
9344  {
9345  if (!var->isFV())
9346  mooseError(
9347  "Ghostable materials should only have finite volume variables coupled into them.");
9348  else if (neighbor_mat->hasStatefulProperties())
9349  mooseError("Finite volume materials do not currently support stateful properties.");
9350  auto pr = variables.insert(var);
9351  mooseAssert(!pr.second,
9352  "We should not have inserted any new variables dependencies from our "
9353  "neighbor materials that didn't exist for our face materials");
9354  }
9355 #endif
9356  }
9357  }
9358 }
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

◆ 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 1874 of file FEProblemBase.h.

1874 { return _indicators; }
MooseObjectWarehouse< Indicator > _indicators

◆ getInitialConditionWarehouse()

const InitialConditionWarehouse& FEProblemBase::getInitialConditionWarehouse ( ) const
inlineinherited

Return InitialCondition storage.

Definition at line 1885 of file FEProblemBase.h.

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

1885 { return _ics; }
InitialConditionWarehouse _ics

◆ getInterfaceMaterialsWarehouse()

const MaterialWarehouse& FEProblemBase::getInterfaceMaterialsWarehouse ( ) const
inlineinherited

Definition at line 2091 of file FEProblemBase.h.

2091 { return _interface_materials; }
MaterialWarehouse _interface_materials

◆ getInternalSideIndicatorWarehouse()

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

Definition at line 1875 of file FEProblemBase.h.

1876  {
1878  }
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators

◆ getKokkosBndMaterialPropertyStorage()

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

Definition at line 1859 of file FEProblemBase.h.

1860  {
1862  }
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 1855 of file FEProblemBase.h.

1856  {
1857  return _kokkos_material_props;
1858  }
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 2097 of file FEProblemBase.h.

2097 { return _kokkos_materials; }
MaterialWarehouse _kokkos_materials

◆ getKokkosNeighborMaterialPropertyStorage()

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

Definition at line 1863 of file FEProblemBase.h.

1864  {
1866  }
Moose::Kokkos::MaterialPropertyStorage & _kokkos_neighbor_material_props

◆ getKokkosSystem() [1/2]

Moose::Kokkos::System& FEProblemBase::getKokkosSystem ( const unsigned int  sys_num)
inherited

Get the Kokkos system of a specified number that is associated with MOOSE nonlinear and auxiliary systems.

Parameters
sys_numThe system number
Returns
The Kokkos system{@

◆ getKokkosSystem() [2/2]

const Moose::Kokkos::System& FEProblemBase::getKokkosSystem ( const unsigned int  sys_num) const
inherited

◆ 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 792 of file FEProblemBase.h.

792 { 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 793 of file FEProblemBase.h.

794  {
795  return _kokkos_systems;
796  }
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 9414 of file FEProblemBase.C.

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

9415 {
9417  return *_linear_convergence_names;
9418  mooseError("The linear convergence name(s) have not been set.");
9419 }
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 3476 of file FEProblemBase.h.

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

3477 {
3478  mooseAssert(sys_num < _linear_systems.size(),
3479  "System number greater than the number of linear systems");
3480  return *_linear_systems[sys_num];
3481 }
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 3484 of file FEProblemBase.h.

3485 {
3486  mooseAssert(sys_num < _linear_systems.size(),
3487  "System number greater than the number of linear systems");
3488  return *_linear_systems[sys_num];
3489 }
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 2691 of file FEProblemBase.h.

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

2691 { 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 752 of file FEProblemBase.h.

Referenced by DisplacedProblem::getLineSearch().

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

◆ getMarkerWarehouse()

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

Definition at line 1879 of file FEProblemBase.h.

1879 { 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 3876 of file FEProblemBase.C.

Referenced by MaterialPropertyInterface::getMaterialByName().

3880 {
3881  switch (type)
3882  {
3884  name += "_neighbor";
3885  break;
3887  name += "_face";
3888  break;
3889  default:
3890  break;
3891  }
3892 
3893  std::shared_ptr<MaterialBase> material = _all_materials[type].getActiveObject(name, tid);
3894  if (!no_warn && material->getParam<bool>("compute") && type == Moose::BLOCK_MATERIAL_DATA)
3895  mooseWarning("You are retrieving a Material object (",
3896  material->name(),
3897  "), but its compute flag is set to true. This indicates that MOOSE is "
3898  "computing this property which may not be desired and produce un-expected "
3899  "results.");
3900 
3901  return material;
3902 }
void mooseWarning(Args &&... args) const
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
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 3905 of file FEProblemBase.C.

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

3908 {
3909  switch (type)
3910  {
3912  if (object)
3913  _material_props.addConsumer(type, object);
3914  return _material_props.getMaterialData(tid);
3916  if (object)
3922  if (object)
3925  }
3926 
3927  mooseError("FEProblemBase::getMaterialData(): Invalid MaterialDataType ", type);
3928 }
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 490 of file SubProblem.C.

Referenced by MaterialPropertyInterface::getMaterialPropertyBlockNames().

491 {
492  std::set<SubdomainID> blocks = getMaterialPropertyBlocks(prop_name);
493  std::vector<SubdomainName> block_names;
494  block_names.reserve(blocks.size());
495  for (const auto & block_id : blocks)
496  {
497  SubdomainName name;
498  name = mesh().getMesh().subdomain_name(block_id);
499  if (name.empty())
500  {
501  std::ostringstream oss;
502  oss << block_id;
503  name = oss.str();
504  }
505  block_names.push_back(name);
506  }
507 
508  return block_names;
509 }
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:3469
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:474

◆ 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 474 of file SubProblem.C.

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

475 {
476  std::set<SubdomainID> blocks;
477 
478  for (const auto & it : _map_block_material_props)
479  {
480  const std::set<std::string> & prop_names = it.second;
481  std::set<std::string>::iterator name_it = prop_names.find(prop_name);
482  if (name_it != prop_names.end())
483  blocks.insert(it.first);
484  }
485 
486  return blocks;
487 }
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:1054

◆ 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 526 of file SubProblem.C.

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

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

◆ 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 542 of file SubProblem.C.

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryNames().

543 {
544  std::set<BoundaryID> boundaries = getMaterialPropertyBoundaryIDs(prop_name);
545  std::vector<BoundaryName> boundary_names;
546  boundary_names.reserve(boundaries.size());
547  const BoundaryInfo & boundary_info = mesh().getMesh().get_boundary_info();
548 
549  for (const auto & bnd_id : boundaries)
550  {
551  BoundaryName name;
552  if (bnd_id == Moose::ANY_BOUNDARY_ID)
553  name = "ANY_BOUNDARY_ID";
554  else
555  {
556  name = boundary_info.get_sideset_name(bnd_id);
557  if (name.empty())
558  {
559  std::ostringstream oss;
560  oss << bnd_id;
561  name = oss.str();
562  }
563  }
564  boundary_names.push_back(name);
565  }
566 
567  return boundary_names;
568 }
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:526
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:3469
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 1837 of file FEProblemBase.h.

Referenced by MaterialBase::checkStatefulSanity().

1838  {
1839  return _material_prop_registry;
1840  }
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 1847 of file FEProblemBase.h.

1847 { 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 3931 of file FEProblemBase.C.

3932 {
3933  switch (type)
3934  {
3943  }
3944 
3945  mooseError("FEProblemBase::getMaterialPropertyStorageConsumers(): Invalid MaterialDataType ",
3946  type);
3947 }
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 343 of file SubProblem.C.

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

344 {
345  auto tag_name_upper = MooseUtils::toUpper(tag_name);
346 
347  if (!matrixTagExists(tag_name))
348  mooseError("Matrix tag: ",
349  tag_name,
350  " does not exist. ",
351  "If this is a TimeKernel then this may have happened because you didn't "
352  "specify a Transient Executioner.");
353 
354  return _matrix_tag_name_to_tag_id.at(tag_name_upper);
355 }
std::map< TagName, TagID > _matrix_tag_name_to_tag_id
The currently declared tags.
Definition: SubProblem.h:1043
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:329

◆ 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(), computeJacobianAB(), NonlinearSystemBase::computeJacobianBlocks(), 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:1043

◆ 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 1637 of file FEProblemBase.C.

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

1638 {
1640  mooseError("Max QPS uninitialized");
1641  return _max_qps;
1642 }
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 1645 of file FEProblemBase.C.

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

1646 {
1647  return _max_scalar_order;
1648 }
libMesh::Order _max_scalar_order
Maximum scalar variable order.

◆ getMeshDivision()

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

Get a MeshDivision.

Definition at line 2702 of file FEProblemBase.C.

Referenced by NestedDivision::NestedDivision().

2703 {
2704  auto * const ret = dynamic_cast<MeshDivision *>(_mesh_divisions.getActiveObject(name, tid).get());
2705  if (!ret)
2706  mooseError("No MeshDivision object named ", name, " of appropriate type");
2707  return *ret;
2708 }
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(), 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 8072 of file FEProblemBase.C.

8076 {
8078  primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
8079 }
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 8082 of file FEProblemBase.C.

8086 {
8088  primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
8089 }
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 8092 of file FEProblemBase.C.

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

8093 {
8094  return _mortar_data.getMortarInterfaces(on_displaced);
8095 }
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 5531 of file FEProblemBase.C.

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

5532 {
5533  return _multi_apps.getObject(multi_app_name);
5534 }
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 9422 of file FEProblemBase.C.

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

9423 {
9426  else
9427  mooseError("The fixed point convergence name has not been set.");
9428 }
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 5626 of file FEProblemBase.C.

5627 {
5628  if (direction == MultiAppTransfer::TO_MULTIAPP)
5629  return _to_multi_app_transfers;
5630  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
5632  else
5634 }
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 2294 of file FEProblemBase.h.

Referenced by MooseApp::errorCheck().

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

◆ getNEigenPairsRequired()

unsigned int EigenProblem::getNEigenPairsRequired ( ) const
inline

Definition at line 37 of file EigenProblem.h.

Referenced by NonlinearEigenSystem::solve().

37 { return _n_eigen_pairs_required; }
unsigned int _n_eigen_pairs_required
Definition: EigenProblem.h:240

◆ getNeighborMaterialPropertyStorage()

const MaterialPropertyStorage& FEProblemBase::getNeighborMaterialPropertyStorage ( )
inlineinherited

Definition at line 1849 of file FEProblemBase.h.

1850  {
1851  return _neighbor_material_props;
1852  }
MaterialPropertyStorage & _neighbor_material_props

◆ getNonlinearConvergenceNames()

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

Gets the nonlinear system convergence object name(s).

Definition at line 9390 of file FEProblemBase.C.

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

9391 {
9394  mooseError("The nonlinear system convergence name(s) have not been set.");
9395 }
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

◆ getNonlinearEigenSystem()

NonlinearEigenSystem & EigenProblem::getNonlinearEigenSystem ( const unsigned int  nl_sys_num)
inline

Definition at line 299 of file EigenProblem.h.

Referenced by Moose::assemble_matrix(), and Eigenvalue::Eigenvalue().

300 {
301  if (nl_sys_num > 0)
302  mooseError("eigen problems do not currently support multiple nonlinear eigen systems");
303  return *_nl_eigen;
304 }
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
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:3469
MooseMesh & _mesh
auto index_range(const T &sizable)

◆ getNonlinearSystem()

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

Reimplemented in FEProblem.

Definition at line 2717 of file FEProblemBase.C.

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

2718 {
2719  mooseDeprecated("FEProblemBase::getNonlinearSystem() is deprecated, please use "
2720  "FEProblemBase::getNonlinearSystemBase() \n");
2721 
2722  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
2723  auto nl_sys = std::dynamic_pointer_cast<NonlinearSystem>(_nl[sys_num]);
2724 
2725  if (!nl_sys)
2726  mooseError("This is not a NonlinearSystem");
2727 
2728  return *nl_sys;
2729 }
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
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 3432 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().

3433 {
3434  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3435  return *_nl[sys_num];
3436 }
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 3439 of file FEProblemBase.h.

3440 {
3441  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
3442  return *_nl[sys_num];
3443 }
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 2687 of file FEProblemBase.h.

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

2687 { 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 1915 of file FEProblemBase.h.

1915 { 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(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ParsedSubdomainGeneratorBase::functionInitialize(), FVInterfaceKernel::FVInterfaceKernel(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), CoarsenBlockGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), MeshExtruderGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), 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(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), 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 4598 of file FEProblemBase.C.

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

4599 {
4600  std::vector<Positions *> objs;
4601  theWarehouse()
4602  .query()
4603  .condition<AttribSystem>("UserObject")
4604  .condition<AttribName>(name)
4605  .queryInto(objs);
4606  if (objs.empty())
4607  mooseError("Unable to find Positions object with name '" + name + "'");
4608  mooseAssert(objs.size() == 1, "Should only find one Positions");
4609  return *(objs[0]);
4610 }
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 4632 of file FEProblemBase.C.

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

4634 {
4636  t_index);
4637 }
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

◆ getRegularMaterialsWarehouse()

const MaterialWarehouse& FEProblemBase::getRegularMaterialsWarehouse ( ) const
inlineinherited

Definition at line 2089 of file FEProblemBase.h.

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

2089 { 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 1257 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().

1257 { 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 1264 of file FEProblemBase.h.

1264 { 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 }

◆ getRestartableEquationSystems()

const RestartableEquationSystems & FEProblemBase::getRestartableEquationSystems ( ) const
inherited

Get the RestartableEquationSystems object.

Definition at line 6009 of file FEProblemBase.C.

6010 {
6011  return _req.get();
6012 }
const T & get() const
Get the restartable value.
Definition: Restartable.h:58
Restartable::ManagedValue< RestartableEquationSystems > _req
The EquationSystems object, wrapped for restart.

◆ getSampler()

Sampler & FEProblemBase::getSampler ( const std::string &  name,
const THREAD_ID  tid = 0 
)
virtualinherited

Definition at line 2765 of file FEProblemBase.C.

Referenced by SamplerInterface::getSampler(), and SamplerInterface::getSamplerByName().

2766 {
2767  std::vector<Sampler *> objs;
2768  theWarehouse()
2769  .query()
2770  .condition<AttribSystem>("Sampler")
2771  .condition<AttribThread>(tid)
2772  .condition<AttribName>(name)
2773  .queryInto(objs);
2774  if (objs.empty())
2775  mooseError(
2776  "Unable to find Sampler with name '" + name +
2777  "', if you are attempting to access this object in the constructor of another object then "
2778  "the object being retrieved must occur prior to the caller within the input file.");
2779  return *(objs[0]);
2780 }
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 5985 of file FEProblemBase.C.

Referenced by FEProblemBase::addInitialCondition(), adjustEigenVector(), MultiAppScalarToAuxScalarTransfer::execute(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), TableOutput::outputScalarVariables(), and Exodus::outputScalarVariables().

5986 {
5987  for (auto & sys : _solver_systems)
5988  if (sys->hasScalarVariable(var_name))
5989  return sys->getScalarVariable(tid, var_name);
5990  if (_aux->hasScalarVariable(var_name))
5991  return _aux->getScalarVariable(tid, var_name);
5992 
5993  mooseError("Unknown variable " + var_name);
5994 }
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 72 of file MooseObject.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), and MFEMProblem::addMFEMSolver().

73 {
74  try
75  {
76  return shared_from_this();
77  }
78  catch (std::bad_weak_ptr &)
79  {
80  mooseError(not_shared_error);
81  }
82 }
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 85 of file MooseObject.C.

86 {
87  try
88  {
89  return shared_from_this();
90  }
91  catch (std::bad_weak_ptr &)
92  {
93  mooseError(not_shared_error);
94  }
95 }
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 3446 of file FEProblemBase.h.

Referenced by MooseApp::attachRelationshipManagers(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), MultiSystemSolveObject::MultiSystemSolveObject(), ConsoleUtils::outputSolverSystemInformation(), Moose::PetscSupport::petscSetDefaultKSPNormType(), and Moose::PetscSupport::petscSetDefaultPCSide().

3447 {
3448  mooseAssert(sys_num < _solver_systems.size(),
3449  "System number greater than the number of solver systems");
3450  return *_solver_systems[sys_num];
3451 }
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 3454 of file FEProblemBase.h.

3455 {
3456  mooseAssert(sys_num < _solver_systems.size(),
3457  "System number greater than the number of solver systems");
3458  return *_solver_systems[sys_num];
3459 }
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 2695 of file FEProblemBase.h.

Referenced by ConsoleUtils::outputExecutionInformation().

2695 { 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 5925 of file FEProblemBase.C.

Referenced by CoupleableMooseVariableDependencyIntermediateInterface::coupledValueByName(), FEProblemBase::projectFunctionOnCustomRange(), LinearFVKernel::requestVariableCellGradient(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

5926 {
5927  for (auto & sys : _solver_systems)
5928  if (sys->hasVariable(var_name))
5929  return sys->getFieldVariable<Real>(tid, var_name);
5930  if (_aux->hasVariable(var_name))
5931  return _aux->getFieldVariable<Real>(tid, var_name);
5932 
5933  mooseError("Unknown variable " + var_name);
5934 }
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 9431 of file FEProblemBase.C.

Referenced by FEProblemBase::addDefaultSteadyStateConvergence(), TransientBase::convergedToSteadyState(), and TransientBase::init().

9432 {
9434  return _steady_state_convergence_name.value();
9435  else
9436  mooseError("The steady convergence name has not been set.");
9437 }
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 5997 of file FEProblemBase.C.

Referenced by FEProblemBase::addObjectParamsHelper(), MultiApp::appTransferVector(), ElementSubdomainModifierBase::gatherPatchElements(), FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

5998 {
5999  const auto [var_in_sys, sys_num] = determineSolverSystem(var_name);
6000  if (var_in_sys)
6001  return _solver_systems[sys_num]->system();
6002  else if (_aux->hasVariable(var_name) || _aux->hasScalarVariable(var_name))
6003  return _aux->system();
6004  else
6005  mooseError("Unable to find a system containing the variable " + var_name);
6006 }
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 9144 of file FEProblemBase.C.

Referenced by FEProblemBase::addObjectParamsHelper(), PhysicsBase::copyVariablesFromMesh(), FEProblemBase::getSystemBase(), FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

9145 {
9146  if (sys_num < _solver_systems.size())
9147  return *_solver_systems[sys_num];
9148 
9149  return *_aux;
9150 }
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 9165 of file FEProblemBase.C.

9166 {
9167  if (sys_num < _solver_systems.size())
9168  return *_solver_systems[sys_num];
9169 
9170  return *_aux;
9171 }
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 9153 of file FEProblemBase.C.

9154 {
9155  if (std::find(_solver_sys_names.begin(), _solver_sys_names.end(), sys_name) !=
9156  _solver_sys_names.end())
9157  return getSystemBase(solverSysNum(sys_name));
9158  else if (sys_name == "aux0")
9159  return *_aux;
9160  else
9161  mooseError("System '" + sys_name + "' was requested from problem but does not exist.");
9162 }
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 6977 of file FEProblemBase.C.

Referenced by Function::evaluate(), Function::evaluateDotHelper(), Function::evaluateGradientHelper(), Function::evaluateHelper(), and ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl().

6978 {
6980  // If we are any iteration type other than time (e.g. nonlinear), then temporally we are still
6981  // in the present time
6982  return time();
6983 
6984  switch (state.state)
6985  {
6986  case 0:
6987  return time();
6988 
6989  case 1:
6990  return timeOld();
6991 
6992  default:
6993  mooseError("Unhandled state ", state.state, " in FEProblemBase::getTimeFromStateArg");
6994  }
6995 }
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 5604 of file FEProblemBase.C.

5605 {
5606  if (direction == MultiAppTransfer::TO_MULTIAPP)
5608  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
5610  else
5612 }
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 5615 of file FEProblemBase.C.

5616 {
5617  if (direction == MultiAppTransfer::TO_MULTIAPP)
5619  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
5621  else
5623 }
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 1284 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().

1285  {
1286  std::vector<T *> objs;
1287  theWarehouse()
1288  .query()
1289  .condition<AttribSystem>("UserObject")
1290  .condition<AttribThread>(tid)
1291  .condition<AttribName>(name)
1292  .queryInto(objs);
1293  if (objs.empty())
1294  mooseError("Unable to find user object with name '" + name + "'");
1295  return *(objs[0]);
1296  }
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 4582 of file FEProblemBase.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiApp::appUserObjectBase(), checkProblemIntegrity(), FunctorAux::computeValue(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectFromFEProblem(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), Terminator::initialSetup(), and FunctorIC::value().

4583 {
4584  std::vector<UserObject *> objs;
4585  theWarehouse()
4586  .query()
4587  .condition<AttribSystem>("UserObject")
4588  .condition<AttribThread>(tid)
4589  .condition<AttribName>(name)
4590  .queryInto(objs);
4591  if (objs.empty())
4592  mooseError("Unable to find user object with name '" + name + "'");
4593  mooseAssert(objs.size() == 1, "Should only find one UO");
4594  return *(objs[0]);
4595 }
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 324 of file FEProblemBase.h.

Referenced by ComputeUserObjectsThread::onBoundary(), and ComputeUserObjectsThread::onElement().

325  {
326  return _uo_jacobian_moose_vars[tid];
327  }
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars

◆ getUserObjects()

const ExecuteMooseObjectWarehouse<UserObject>& FEProblemBase::getUserObjects ( ) const
inlineinherited

Definition at line 1271 of file FEProblemBase.h.

1272  {
1274  "This function is deprecated, use theWarehouse().query() to construct a query instead");
1275  return _all_user_objects;
1276  }
ExecuteMooseObjectWarehouse< UserObject > _all_user_objects
void mooseDeprecated(Args &&... args) const

◆ getVariable() [1/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() [2/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() [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 5915 of file FEProblemBase.C.

Referenced by FEProblemBase::addFVInitialCondition(), FEProblemBase::addInitialCondition(), adjustEigenVector(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), CoupleableMooseVariableDependencyIntermediateInterface::coupledArrayValueByName(), CoupleableMooseVariableDependencyIntermediateInterface::coupledValueByName(), NodalNormalsCorner::execute(), NodalNormalsEvaluator::execute(), MultiAppProjectionTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), NodalNormalsPreprocessor::execute(), LazyCoupleable::init(), AdvancedOutput::initAvailableLists(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), AdvancedOutput::initShowHideLists(), SolutionUserObjectBase::pointValueWrapper(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), MultiAppProjectionTransfer::projectSolution(), MultiAppDofCopyTransfer::transfer(), and MultiAppShapeEvaluationTransfer::transferVariable().

5919 {
5920  return getVariableHelper(
5921  tid, var_name, expected_var_type, expected_var_field_type, _solver_systems, *_aux);
5922 }
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 819 of file SubProblem.C.

825 {
826  // Eventual return value
827  MooseVariableFEBase * var = nullptr;
828 
829  const auto [var_in_sys, sys_num] = determineSolverSystem(var_name);
830 
831  // First check that the variable is found on the expected system.
832  if (expected_var_type == Moose::VarKindType::VAR_ANY)
833  {
834  if (var_in_sys)
835  var = &(systems[sys_num]->getVariable(tid, var_name));
836  else if (aux.hasVariable(var_name))
837  var = &(aux.getVariable(tid, var_name));
838  else
839  mooseError("Unknown variable " + var_name);
840  }
841  else if (expected_var_type == Moose::VarKindType::VAR_SOLVER && var_in_sys &&
842  systems[sys_num]->hasVariable(var_name))
843  var = &(systems[sys_num]->getVariable(tid, var_name));
844  else if (expected_var_type == Moose::VarKindType::VAR_AUXILIARY && aux.hasVariable(var_name))
845  var = &(aux.getVariable(tid, var_name));
846  else
847  {
848  std::string expected_var_type_string =
849  (expected_var_type == Moose::VarKindType::VAR_SOLVER ? "nonlinear" : "auxiliary");
850  mooseError("No ",
851  expected_var_type_string,
852  " variable named ",
853  var_name,
854  " found. "
855  "Did you specify an auxiliary variable when you meant to specify a nonlinear "
856  "variable (or vice-versa)?");
857  }
858 
859  // Now make sure the var found has the expected field type.
860  if ((expected_var_field_type == Moose::VarFieldType::VAR_FIELD_ANY) ||
861  (expected_var_field_type == var->fieldType()))
862  return *var;
863  else
864  {
865  std::string expected_var_field_type_string =
866  MooseUtils::toLower(Moose::stringify(expected_var_field_type));
867  std::string var_field_type_string = MooseUtils::toLower(Moose::stringify(var->fieldType()));
868 
869  mooseError("No ",
870  expected_var_field_type_string,
871  " variable named ",
872  var_name,
873  " found. "
874  "Did you specify a ",
875  var_field_type_string,
876  " variable when you meant to specify a ",
877  expected_var_field_type_string,
878  " variable?");
879  }
880 }
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 8896 of file FEProblemBase.C.

Referenced by adjustEigenVector(), AdvancedOutput::initAvailableLists(), and ElementSubdomainModifierBase::initialSetup().

8897 {
8898  std::vector<VariableName> names;
8899 
8900  for (auto & sys : _solver_systems)
8901  {
8902  const std::vector<VariableName> & var_names = sys->getVariableNames();
8903  names.insert(names.end(), var_names.begin(), var_names.end());
8904  }
8905 
8906  const std::vector<VariableName> & aux_var_names = _aux->getVariableNames();
8907  names.insert(names.end(), aux_var_names.begin(), aux_var_names.end());
8908 
8909  return names;
8910 }
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 4676 of file FEProblemBase.C.

Referenced by VectorPostprocessorInterface::isVectorPostprocessorDistributedByName(), CSV::output(), and XMLOutput::outputVectorPostprocessors().

4678 {
4679  return getUserObject<VectorPostprocessor>(object_name, tid);
4680 }

◆ 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 4657 of file FEProblemBase.C.

Referenced by HistogramVectorPostprocessor::execute().

4660 {
4662  VectorPostprocessorReporterName(object_name, vector_name), t_index);
4663 }
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 162 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().

163 {
164  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
165 
166  if (!vectorTagExists(tag_id))
167  mooseError("Vector tag with ID ", tag_id, " does not exist");
168 
169  return _vector_tags[tag_id];
170 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1172
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
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 204 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().

205 {
206  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
207 
208  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
209  const auto search = _vector_tags_name_map.find(tag_name_upper);
210  if (search != _vector_tags_name_map.end())
211  return search->second;
212 
213  std::string message =
214  tag_name_upper == "TIME"
215  ? ".\n\nThis may occur if "
216  "you have a TimeKernel in your problem but did not specify a transient executioner."
217  : "";
218  mooseError("Vector tag '", tag_name_upper, "' does not exist", message);
219 }
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
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:1182
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 173 of file SubProblem.C.

Referenced by FEProblemBase::computeLinearSystemSys(), computeResidualAB(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualInternal(), computeResidualTag(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), DisplacedProblem::getVectorTags(), SubProblem::numVectorTags(), ComputeMortarFunctor::operator()(), and FEProblemBase::setCurrentResidualVectorTags().

174 {
175  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
176 
177  std::vector<VectorTag> tags;
178  tags.reserve(tag_ids.size());
179  for (const auto & tag_id : tag_ids)
180  tags.push_back(getVectorTag(tag_id));
181  return tags;
182 }
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
Definition: SubProblem.C:162

◆ 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 185 of file SubProblem.C.

186 {
187  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
188 
190  return _vector_tags;
191  else
192  return _typed_vector_tags[type];
193 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1172
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
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:1179

◆ 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 5949 of file FEProblemBase.C.

5950 {
5951  for (auto & sys : _solver_systems)
5952  if (sys->hasVariable(var_name))
5953  return sys->getFieldVariable<RealVectorValue>(tid, var_name);
5954  if (_aux->hasVariable(var_name))
5955  return _aux->getFieldVariable<RealVectorValue>(tid, var_name);
5956 
5957  mooseError("Unknown variable " + var_name);
5958 }
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 1932 of file FEProblemBase.h.

1932 { 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:1095

◆ ghostGhostedBoundaries()

void FEProblemBase::ghostGhostedBoundaries ( )
overridevirtualinherited

Causes the boundaries added using addGhostedBoundary to actually be ghosted.

Implements SubProblem.

Definition at line 2145 of file FEProblemBase.C.

Referenced by DisplacedProblem::ghostGhostedBoundaries(), FEProblemBase::init(), and FEProblemBase::meshChanged().

2146 {
2147  TIME_SECTION("ghostGhostedBoundaries", 3, "Ghosting Ghosted Boundaries");
2148 
2150 
2151  if (_displaced_problem)
2153 }
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:3335
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 461 of file SubProblem.C.

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

462 {
464 }
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:1081

◆ 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 6123 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::onElement(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::reinitMaterialsNeighborOnBoundary().

6124 {
6125  return _has_active_material_properties[tid];
6126 }
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 812 of file SubProblem.C.

Referenced by SubProblem::getFunctor(), and NearestNodeValueAux::NearestNodeValueAux().

813 {
814  return systemBaseAuxiliary().hasVariable(var_name);
815 }
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 512 of file SubProblem.C.

513 {
514  auto it = _map_block_material_props.find(bid);
515  if (it == _map_block_material_props.end())
516  return false;
517 
518  if (it->second.count(prop_name) > 0)
519  return true;
520  else
521  return false;
522 }
std::map< SubdomainID, std::set< std::string > > _map_block_material_props
Map of material properties (block_id -> list of properties)
Definition: SubProblem.h:1054

◆ 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 571 of file SubProblem.C.

572 {
573  auto it = _map_boundary_material_props.find(bid);
574  if (it == _map_boundary_material_props.end())
575  return false;
576 
577  if (it->second.count(prop_name) > 0)
578  return true;
579  else
580  return false;
581 }
std::map< BoundaryID, std::set< std::string > > _map_boundary_material_props
Map for boundary material properties (boundary_id -> list of properties)
Definition: SubProblem.h:1057

◆ 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 2665 of file FEProblemBase.C.

Referenced by ParsedConvergence::initializeSymbols().

2666 {
2667  return _convergences.hasActiveObject(name, tid);
2668 }
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 1421 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::preInit(), and NonlinearSystem::solve().

1421 { 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 502 of file FEProblemBase.h.

Referenced by NonlinearSystem::converged(), ThreadedElementLoop< ConstElemPointerRange >::keepGoing(), and ThreadedNodeLoop< ConstBndNodeRange, ConstBndNodeRange::const_iterator >::keepGoing().

502 { 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 2614 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().

2615 {
2616  return _functions.hasActiveObject(name, tid);
2617 }
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 1275 of file SubProblem.C.

Referenced by FunctorInterface::isFunctor().

1276 {
1277  mooseAssert(tid < _functors.size(), "Too large a thread ID");
1278  auto & functors = _functors[tid];
1279  return (functors.find("wraps_" + name) != functors.end());
1280 }
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:1146

◆ 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 1325 of file SubProblem.h.

1326 {
1327  mooseAssert(tid < _functors.size(), "Too large a thread ID");
1328  auto & functors = _functors[tid];
1329 
1330  const auto & it = functors.find("wraps_" + name);
1331  constexpr bool requested_functor_is_ad =
1332  !std::is_same<T, typename MetaPhysicL::RawType<T>::value_type>::value;
1333 
1334  if (it == functors.end())
1335  return false;
1336  else
1337  return dynamic_cast<Moose::Functor<T> *>(
1338  requested_functor_is_ad ? std::get<2>(it->second).get() : std::get<1>(it->second).get());
1339 }
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:1135
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:1146

◆ hasInitialAdaptivity() [1/2]

bool FEProblemBase::hasInitialAdaptivity ( ) const
inlineinherited

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 1920 of file FEProblemBase.h.

1920 { 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 1925 of file FEProblemBase.h.

1925 { return false; }

◆ hasJacobian()

bool FEProblemBase::hasJacobian ( ) const
inherited

Returns _has_jacobian.

Definition at line 9059 of file FEProblemBase.C.

9060 {
9061  return _has_jacobian;
9062 }
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 2717 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::preInit(), and MooseMesh::update().

2717 { return _has_kokkos_objects; }
bool _has_kokkos_objects
Whether we have any Kokkos objects.

◆ hasKokkosResidualObjects()

bool FEProblemBase::hasKokkosResidualObjects ( ) const
inlineinherited
Returns
whether any Kokkos residual object was added in the problem

Definition at line 2721 of file FEProblemBase.h.

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

2721 { return _has_kokkos_residual_objects; }
bool _has_kokkos_residual_objects
Whether we have any Kokkos residual objects.

◆ hasLinearConvergenceObjects()

bool FEProblemBase::hasLinearConvergenceObjects ( ) const
inherited

Whether we have linear convergence objects.

Definition at line 9398 of file FEProblemBase.C.

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

9399 {
9400  // If false,this means we have not set one, not that we are querying this too early
9401  // TODO: once there is a default linear CV object, error on the 'not set' case
9402  return _linear_convergence_names.has_value();
9403 }
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 803 of file SubProblem.C.

Referenced by SubProblem::getFunctor().

804 {
805  for (const auto i : make_range(numLinearSystems()))
806  if (systemBaseLinear(i).hasVariable(var_name))
807  return true;
808  return false;
809 }
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 2417 of file FEProblemBase.h.

2417 { 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 5525 of file FEProblemBase.C.

5526 {
5527  return _multi_apps.hasActiveObject(multi_app_name);
5528 }
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 1407 of file FEProblemBase.h.

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), FEProblemBase::checkProblemIntegrity(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), and DefaultMultiAppFixedPointConvergence::preExecute().

1407 { 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 5519 of file FEProblemBase.C.

5520 {
5521  return _multi_apps[type].hasActiveObjects();
5522 }
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 2412 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 2674 of file FEProblemBase.h.

Referenced by DisplacedProblem::hasNonlocalCoupling().

2674 { 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 4649 of file FEProblemBase.C.

Referenced by GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl().

4650 {
4651  mooseDeprecated("FEProblemBase::hasPostprocssor is being removed; use "
4652  "hasPostprocessorValueByName instead.");
4654 }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
void mooseDeprecated(Args &&... args) const
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 4626 of file FEProblemBase.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), FunctorAux::computeValue(), FunctorExtremaPositions::FunctorExtremaPositions(), FEProblemBase::hasPostprocessor(), MooseParsedFunction::initialSetup(), and FunctorIC::value().

4627 {
4629 }
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 5973 of file FEProblemBase.C.

Referenced by FEProblemBase::addInitialCondition(), FEProblemBase::addObjectParamsHelper(), adjustEigenVector(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), AdvancedOutput::initAvailableLists(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), AdvancedOutput::initShowHideLists(), and Split::setup().

5974 {
5975  for (auto & sys : _solver_systems)
5976  if (sys->hasScalarVariable(var_name))
5977  return true;
5978  if (_aux->hasScalarVariable(var_name))
5979  return true;
5980 
5981  return false;
5982 }
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 1171 of file SubProblem.C.

Referenced by SystemBase::addScalingVector().

1172 {
1173  for (const THREAD_ID tid : make_range(libMesh::n_threads()))
1174  assembly(tid, nl_sys_num).hasScalingVector();
1175 }
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 694 of file FEProblemBase.h.

695  {
696  return _multiapp_fixed_point_convergence_name.has_value();
697  }
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 699 of file FEProblemBase.h.

700  {
701  return _steady_state_convergence_name.has_value();
702  }
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 5905 of file FEProblemBase.C.

5906 {
5907  for (auto & sys : _solver_systems)
5908  if (sys->hasVariable(var_name))
5909  return true;
5910 
5911  return false;
5912 }
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 2203 of file FEProblemBase.h.

Referenced by TransientBase::setupTimeIntegrator().

2203 { 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 4613 of file FEProblemBase.C.

Referenced by MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), FunctorAux::computeValue(), DistributedPositions::DistributedPositions(), UserObjectInterface::hasUserObjectByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), ReporterTransferInterface::hideVariableHelper(), ParsedDownSelectionPositions::initialize(), and TransformedPositions::TransformedPositions().

4614 {
4615  std::vector<UserObject *> objs;
4616  theWarehouse()
4617  .query()
4618  .condition<AttribSystem>("UserObject")
4619  .condition<AttribThread>(0)
4620  .condition<AttribName>(name)
4621  .queryInto(objs);
4622  return !objs.empty();
4623 }
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 5893 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().

5894 {
5895  for (auto & sys : _solver_systems)
5896  if (sys->hasVariable(var_name))
5897  return true;
5898  if (_aux->hasVariable(var_name))
5899  return true;
5900 
5901  return false;
5902 }
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:1116

◆ 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:1116

◆ 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:1116

◆ 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 9136 of file FEProblemBase.C.

9137 {
9138  _have_ad_objects = have_ad_objects;
9139  if (_displaced_problem)
9140  _displaced_problem->SubProblem::haveADObjects(have_ad_objects);
9141 }
bool _have_ad_objects
AD flag indicating whether any AD objects have been added.
Definition: SubProblem.h:1116
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 2508 of file FEProblemBase.h.

2508 { 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 1011 of file SubProblem.h.

Referenced by AdvancedOutput::initAvailableLists(), and FEProblemBase::meshChanged().

1011 { return _have_p_refinement; }
bool _have_p_refinement
Whether p-refinement has been requested at any point during the simulation.
Definition: SubProblem.h:1207

◆ haveXFEM()

bool FEProblemBase::haveXFEM ( )
inlineinherited

Find out whether the current analysis is using XFEM.

Definition at line 1935 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup(), FixedPointSolve::solveStep(), TransientBase::takeStep(), and FEProblemBase::updateMeshXFEM().

1935 { 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 2679 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 2175 of file FEProblemBase.h.

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

2175 { 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 2200 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 5710 of file FEProblemBase.C.

Referenced by TransientBase::incrementStepOrReject().

5711 {
5712  const auto & multi_apps = _multi_apps[type].getActiveObjects();
5713 
5714  if (multi_apps.size())
5715  for (const auto & multi_app : multi_apps)
5716  multi_app->incrementTStep(_time);
5717 }
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 EigenProblem::init ( )
overridevirtual

Reimplemented from FEProblemBase.

Definition at line 638 of file EigenProblem.C.

639 {
640 #if PETSC_RELEASE_LESS_THAN(3, 13, 0)
641  // Prior to Slepc 3.13 we did not have a nonlinear eigenvalue solver so we must always assemble
642  // before the solve
643  _nl_eigen->sys().attach_assemble_function(Moose::assemble_matrix);
644 #else
645  mooseAssert(
646  numNonlinearSystems() == 1,
647  "We should have errored during construction if we had more than one nonlinear system");
648  mooseAssert(numLinearSystems() == 0,
649  "We should have errored during construction if we had any linear systems");
651  // We don't need to assemble before the solve
652  _nl_eigen->sys().assemble_before_solve = false;
653  else
654  _nl_eigen->sys().attach_assemble_function(Moose::assemble_matrix);
655 
656  // If matrix_free=true, this tells Libmesh to use shell matrices
657  _nl_eigen->sys().use_shell_matrices(solverParams(0)._eigen_matrix_free &&
658  !solverParams(0)._eigen_matrix_vector_mult);
659  // We need to tell libMesh if we are using a shell preconditioning matrix
660  _nl_eigen->sys().use_shell_precond_matrix(solverParams(0)._precond_matrix_free);
661 #endif
662 
664 }
virtual std::size_t numNonlinearSystems() const override
virtual void init() override
bool isNonlinearEigenvalueSolver(unsigned int eigen_sys_num) const
Definition: EigenProblem.C:676
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
void assemble_matrix(EquationSystems &es, const std::string &system_name)
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.
virtual std::size_t numLinearSystems() const override

◆ initEigenvector()

void EigenProblem::initEigenvector ( const Real  initial_value)

For nonlinear eigen solver, a good initial value can help convergence.

Should set initial values for only eigen variables.

Definition at line 421 of file EigenProblem.C.

Referenced by Eigenvalue::init().

422 {
423  // Yaqi's note: the following code will set a flat solution for lagrange and
424  // constant monomial variables. For the first or higher order elemental variables,
425  // the solution is not flat. Fortunately, the initial guess does not affect
426  // the final solution as long as it is not perpendicular to the true solution.
427  // We, in general, do not need to worry about that.
428 
429  adjustEigenVector(initial_value, false);
430 }
void adjustEigenVector(const Real value, bool scaling)
Adjust eigen vector by either scaling the existing values or setting new values The operations are ap...
Definition: EigenProblem.C:389

◆ 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 8490 of file FEProblemBase.C.

Referenced by ActivateElementsUserObjectBase::finalize(), ElementSubdomainModifierBase::initElementStatefulProps(), and FEProblemBase::initialSetup().

8491 {
8494  if (threaded)
8495  Threads::parallel_reduce(elem_range, cmt);
8496  else
8497  cmt(elem_range, true);
8498 
8499 #ifdef MOOSE_KOKKOS_ENABLED
8500  if (_has_kokkos_objects)
8502 #endif
8503 }
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 8160 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

8161 {
8162  unsigned int n = adaptivity().getInitialSteps();
8163  _cycles_completed = 0;
8164  if (n)
8165  {
8166  if (!_mesh.interiorLowerDBlocks().empty() || !_mesh.boundaryLowerDBlocks().empty())
8167  mooseError("HFEM does not support mesh adaptivity currently.");
8168 
8169  TIME_SECTION("initialAdaptMesh", 2, "Performing Initial Adaptivity");
8170 
8171  for (unsigned int i = 0; i < n; i++)
8172  {
8174  computeMarkers();
8175 
8177  {
8178  meshChanged(
8179  /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
8180 
8181  // reproject the initial condition
8182  projectSolution();
8183 
8185  }
8186  else
8187  {
8188  _console << "Mesh unchanged, skipping remaining steps..." << std::endl;
8189  return;
8190  }
8191  }
8192  }
8193 }
bool initialAdaptMesh()
Used during initial adaptivity.
Definition: Adaptivity.C:268
virtual void meshChanged()
Deprecated.
const std::set< SubdomainID > & interiorLowerDBlocks() const
Definition: MooseMesh.h:1421
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:1425
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 FEProblemBase::initialSetup ( )
overridevirtualinherited

If this is a restart run, the user may want to override the start time, which we already set in the constructor. "_time" however will have been "restored" from the restart file. We need to honor the original request of the developer now that the restore has been completed.

If we are not recovering but we are doing restart (_app.getExodusFileRestart() == true) with additional uniform refinements. We have to delay the refinement until this point in time so that the equation systems are initialized and projections can be performed.

Reimplemented from SubProblem.

Definition at line 883 of file FEProblemBase.C.

Referenced by Steady::init(), EigenExecutionerBase::init(), TransientBase::init(), Eigenvalue::init(), and MFEMProblem::initialSetup().

884 {
885  TIME_SECTION("initialSetup", 2, "Performing Initial Setup");
886 
888 
890  mooseError("Checkpoint recovery and restart and exodus restart are all mutually exclusive.");
891 
893  mooseWarning("MOOSE may fail to catch an exception when the \"skip_exception_check\" parameter "
894  "is used. If you receive a terse MPI error during execution, remove this "
895  "parameter and rerun your simulation");
896 
897  // set state flag indicating that we are in or beyond initialSetup.
898  // This can be used to throw errors in methods that _must_ be called at construction time.
899  _started_initial_setup = true;
901 
902  // Setup the solution states (current, old, etc) in each system based on
903  // its default and the states requested of each of its variables
904  for (const auto i : index_range(_solver_systems))
905  {
906  _solver_systems[i]->initSolutionState();
907  if (getDisplacedProblem())
908  getDisplacedProblem()->solverSys(i).initSolutionState();
909  }
910  _aux->initSolutionState();
911  if (getDisplacedProblem())
912  getDisplacedProblem()->auxSys().initSolutionState();
913 
914  // always execute to get the max number of DoF per element and node needed to initialize phi_zero
915  // variables
916  dof_id_type global_max_var_n_dofs_per_elem = 0;
917  for (const auto i : index_range(_solver_systems))
918  {
919  auto & sys = *_solver_systems[i];
920  dof_id_type max_var_n_dofs_per_elem;
921  dof_id_type max_var_n_dofs_per_node;
922  {
923  TIME_SECTION("computingMaxDofs", 3, "Computing Max Dofs Per Element");
924 
925  MaxVarNDofsPerElem mvndpe(*this, sys);
927  max_var_n_dofs_per_elem = mvndpe.max();
928  _communicator.max(max_var_n_dofs_per_elem);
929 
930  MaxVarNDofsPerNode mvndpn(*this, sys);
932  max_var_n_dofs_per_node = mvndpn.max();
933  _communicator.max(max_var_n_dofs_per_node);
934  global_max_var_n_dofs_per_elem =
935  std::max(global_max_var_n_dofs_per_elem, max_var_n_dofs_per_elem);
936  }
937 
938  {
939  TIME_SECTION("assignMaxDofs", 5, "Assigning Maximum Dofs Per Elem");
940 
941  sys.assignMaxVarNDofsPerElem(max_var_n_dofs_per_elem);
943  if (displaced_problem)
944  displaced_problem->solverSys(i).assignMaxVarNDofsPerElem(max_var_n_dofs_per_elem);
945 
946  sys.assignMaxVarNDofsPerNode(max_var_n_dofs_per_node);
947  if (displaced_problem)
948  displaced_problem->solverSys(i).assignMaxVarNDofsPerNode(max_var_n_dofs_per_node);
949  }
950  }
951 
952  {
953  TIME_SECTION("resizingVarValues", 5, "Resizing Variable Values");
954 
955  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
956  {
957  _phi_zero[tid].resize(global_max_var_n_dofs_per_elem, std::vector<Real>(getMaxQps(), 0.));
958  _grad_phi_zero[tid].resize(global_max_var_n_dofs_per_elem,
959  std::vector<RealGradient>(getMaxQps(), RealGradient(0.)));
960  _second_phi_zero[tid].resize(global_max_var_n_dofs_per_elem,
961  std::vector<RealTensor>(getMaxQps(), RealTensor(0.)));
962  }
963  }
964 
965  // Set up stateful material property redistribution, if we suspect
966  // it may be necessary later.
968 
970  {
971  // Only load all of the vectors if we're recovering
973 
974  // This forces stateful material property loading to be an exact one-to-one match
975  if (_app.isRecovering())
976  {
978  props->setRecovering();
979 
980 #ifdef MOOSE_KOKKOS_ENABLED
981  for (auto props :
983  props->setRecovering();
984 #endif
985  }
986 
987  TIME_SECTION("restore", 3, "Restoring from backup");
988 
989  // We could have a cached backup when this app is a sub-app and has been given a Backup
990  if (!_app.hasInitialBackup())
992  else
994 
1000  if (_app.isRestarting())
1001  {
1002  if (_app.hasStartTime())
1004  else
1005  _time_old = _time;
1006  }
1007  }
1008  else
1009  {
1011 
1012  if (reader)
1013  {
1014  TIME_SECTION("copyingFromExodus", 3, "Copying Variables From Exodus");
1015 
1016  for (auto & sys : _solver_systems)
1017  sys->copyVars(*reader);
1018  _aux->copyVars(*reader);
1019  }
1020  else
1021  {
1022  if (_solver_systems[0]->hasVarCopy() || _aux->hasVarCopy())
1023  mooseError("Need Exodus reader to restart variables but the reader is not available\n"
1024  "Use either FileMesh with an Exodus mesh file or FileMeshGenerator with an "
1025  "Exodus mesh file and with use_for_exodus_restart equal to true");
1026  }
1027  }
1028 
1029  // Perform output related setups
1031 
1032  // Flush all output to _console that occur during construction and initialization of objects
1034 
1035  // Build Refinement and Coarsening maps for stateful material projections if necessary
1036  if ((_adaptivity.isOn() || _num_grid_steps) &&
1039  {
1041  mooseError("Stateful neighbor material properties do not work with mesh adaptivity");
1042 
1044  }
1045 
1046  if (!_app.isRecovering())
1047  {
1054  {
1055  if (!_app.isUltimateMaster())
1056  mooseError(
1057  "Doing extra refinements when restarting is NOT supported for sub-apps of a MultiApp");
1058 
1060  }
1061  }
1062 
1063  unsigned int n_threads = libMesh::n_threads();
1064 
1065  // Convergence initial setup
1066  {
1067  TIME_SECTION("convergenceInitialSetup", 5, "Initializing Convergence objects");
1068 
1069  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1071  }
1072 
1073  // UserObject initialSetup
1074  std::set<std::string> depend_objects_ic = _ics.getDependObjects();
1075  std::set<std::string> depend_objects_aux = _aux->getDependObjects();
1076 
1077  // This replaces all prior updateDependObjects calls on the old user object warehouses.
1078  TheWarehouse::Query uo_query = theWarehouse().query().condition<AttribSystem>("UserObject");
1079  std::vector<UserObject *> userobjs;
1080  uo_query.queryInto(userobjs);
1082  theWarehouse(), getAuxiliarySystem(), _app.getExecuteOnEnum(), userobjs, depend_objects_ic);
1083 
1084  std::map<int, std::vector<UserObject *>> group_userobjs;
1085  for (auto obj : userobjs)
1086  group_userobjs[obj->getParam<int>("execution_order_group")].push_back(obj);
1087 
1088  for (auto & [group, objs] : group_userobjs)
1089  for (auto obj : objs)
1090  obj->initialSetup();
1091 
1092  // check if jacobian calculation is done in userobject
1093  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
1095 
1096  // Check whether nonlocal couling is required or not
1100 
1101  {
1102  TIME_SECTION("initializingFunctions", 5, "Initializing Functions");
1103 
1104  // Call the initialSetup methods for functions
1105  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1106  {
1107  reinitScalars(tid); // initialize scalars so they are properly sized for use as input into
1108  // ParsedFunctions
1109  _functions.initialSetup(tid);
1110  }
1111  }
1112 
1113  {
1114  TIME_SECTION("initializingRandomObjects", 5, "Initializing Random Objects");
1115 
1116  // Random interface objects
1117  for (const auto & it : _random_data_objects)
1118  it.second->updateSeeds(EXEC_INITIAL);
1119  }
1120 
1121  if (!_app.isRecovering())
1122  {
1124 
1125  {
1126  TIME_SECTION("ICinitialSetup", 5, "Setting Up Initial Conditions");
1127 
1128  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1129  _ics.initialSetup(tid);
1130 
1132  }
1133 
1134  projectSolution();
1135  }
1136 
1137  // Materials
1139  {
1140  TIME_SECTION("materialInitialSetup", 3, "Setting Up Materials");
1141 
1142  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1143  {
1144  // Sort the Material objects, these will be actually computed by MOOSE in reinit methods.
1145  _materials.sort(tid);
1147 
1148  // Call initialSetup on all material objects
1150 
1151  // Discrete materials may insert additional dependencies on materials during the initial
1152  // setup. Therefore we resolve the dependencies once more, now with the additional
1153  // dependencies due to discrete materials.
1155  {
1156  _materials.sort(tid);
1158  }
1159  }
1160 
1161 #ifdef MOOSE_KOKKOS_ENABLED
1162  _kokkos_materials.sort(0, true);
1163 #endif
1164 
1165  {
1166  TIME_SECTION("computingInitialStatefulProps", 3, "Computing Initial Material Values");
1167 
1169 
1173 #ifdef MOOSE_KOKKOS_ENABLED
1178 #endif
1179  }
1180  }
1181 
1182  // setRestartInPlace() is set because the property maps have now been setup and we can
1183  // dataLoad() them directly in place
1184  // setRecovering() is set because from now on we require a one-to-one mapping of
1185  // stateful properties because we shouldn't be declaring any more
1187  {
1188  props->setRestartInPlace();
1189  props->setRecovering();
1190  }
1191 
1192  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1193  {
1196  _markers.sort(tid);
1197  _markers.initialSetup(tid);
1198  }
1199 
1200 #ifdef LIBMESH_ENABLE_AMR
1201 
1202  if (!_app.isRecovering())
1203  {
1204  unsigned int n = adaptivity().getInitialSteps();
1205  if (n && !_app.isUltimateMaster() && _app.isRestarting())
1206  mooseError("Cannot perform initial adaptivity during restart on sub-apps of a MultiApp!");
1207 
1208  initialAdaptMesh();
1209  }
1210 
1211 #endif // LIBMESH_ENABLE_AMR
1212 
1213  if (!_app.isRecovering() && !_app.isRestarting())
1214  {
1215  // During initial setup the solution is copied to the older solution states (old, older, etc)
1217 
1218  // Check if there are old state initial conditions
1219  auto ics = _ics.getActiveObjects();
1220  auto fv_ics = _fv_ics.getActiveObjects();
1221  auto scalar_ics = _scalar_ics.getActiveObjects();
1222  unsigned short ic_state_max = 0;
1223 
1224  auto findMax = [&ic_state_max](const auto & obj_list)
1225  {
1226  for (auto ic : obj_list.getActiveObjects())
1227  ic_state_max = std::max(ic_state_max, ic->getState());
1228  };
1229  findMax(_ics);
1230  findMax(_fv_ics);
1231  findMax(_scalar_ics);
1232 
1233  // if there are old state ICs, compute them and write to old states accordingly
1234  if (ic_state_max > 0)
1235  {
1236  // state 0 copy (we'll overwrite current state when evaluating ICs and need to restore it once
1237  // we're done with the old/older state ICs)
1238  std::vector<std::unique_ptr<NumericVector<Real>>> state0_sys_buffers(_solver_systems.size());
1239  std::unique_ptr<NumericVector<Real>> state0_aux_buffer;
1240 
1241  // save state 0
1242  for (const auto i : index_range(_solver_systems))
1243  state0_sys_buffers[i] = _solver_systems[i]->solutionState(0).clone();
1244 
1245  state0_aux_buffer = _aux->solutionState(0).clone();
1246 
1247  // compute old state ICs
1248  for (_current_ic_state = 1; _current_ic_state <= ic_state_max; _current_ic_state++)
1249  {
1250  projectSolution();
1251 
1252  for (auto & sys : _solver_systems)
1253  sys->solutionState(_current_ic_state) = sys->solutionState(0);
1254 
1255  _aux->solutionState(_current_ic_state) = _aux->solutionState(0);
1256  }
1257  _current_ic_state = 0;
1258 
1259  // recover state 0
1260  for (const auto i : index_range(_solver_systems))
1261  {
1262  _solver_systems[i]->solutionState(0) = *state0_sys_buffers[i];
1263  _solver_systems[i]->solutionState(0).close();
1264  _solver_systems[i]->update();
1265  }
1266  _aux->solutionState(0) = *state0_aux_buffer;
1267  _aux->solutionState(0).close();
1268  _aux->update();
1269  }
1270  }
1271 
1272  if (!_app.isRecovering())
1273  {
1274  if (haveXFEM())
1275  updateMeshXFEM();
1276  }
1277 
1278  // Call initialSetup on the solver systems
1279  for (auto & sys : _solver_systems)
1280  sys->initialSetup();
1281 
1282  // Auxilary variable initialSetup calls
1283  _aux->initialSetup();
1284 
1285  if (_displaced_problem)
1286  // initialSetup for displaced systems
1287  _displaced_problem->initialSetup();
1288 
1289  for (auto & sys : _solver_systems)
1290  sys->setSolution(*(sys->system().current_local_solution.get()));
1291 
1292  // Update the nearest node searches (has to be called after the problem is all set up)
1293  // We do this here because this sets up the Element's DoFs to ghost
1295 
1297  if (_displaced_mesh)
1299 
1300  // We need to move the mesh in order to build a map between mortar secondary and primary
1301  // interfaces. This map will then be used by the AgumentSparsityOnInterface ghosting functor to
1302  // know which dofs we need ghosted when we call EquationSystems::reinit
1304  {
1305  _displaced_problem->updateMesh();
1306  // if displacements were applied to the mesh, the mortar mesh should be updated too
1307  updateMortarMesh();
1308  }
1309 
1310  // Possibly reinit one more time to get ghosting correct
1312 
1313  if (_displaced_mesh)
1314  _displaced_problem->updateMesh();
1315 
1316  updateGeomSearch(); // Call all of the rest of the geometric searches
1317 
1318  for (auto & sys : _solver_systems)
1319  {
1320  const auto & tis = sys->getTimeIntegrators();
1321 
1322  {
1323  TIME_SECTION("timeIntegratorInitialSetup", 5, "Initializing Time Integrator");
1324  for (auto & ti : tis)
1325  ti->initialSetup();
1326  }
1327  }
1328 
1329  // HUGE NOTE: MultiApp initialSetup() MUST... I repeat MUST be _after_ main-app restartable data
1330  // has been restored
1331 
1332  // Call initialSetup on the MultiApps
1333  if (_multi_apps.hasObjects())
1334  {
1335  TIME_SECTION("initialSetupMultiApps", 2, "Initializing MultiApps", false);
1337  }
1338 
1339  // Call initialSetup on the transfers
1340  {
1341  TIME_SECTION("initialSetupTransfers", 2, "Initializing Transfers");
1342 
1344 
1345  // Call initialSetup on the MultiAppTransfers to be executed on TO_MULTIAPP
1346  const auto & to_multi_app_objects = _to_multi_app_transfers.getActiveObjects();
1347  for (const auto & transfer : to_multi_app_objects)
1348  {
1349  transfer->setCurrentDirection(Transfer::DIRECTION::TO_MULTIAPP);
1350  transfer->initialSetup();
1351  }
1352 
1353  // Call initialSetup on the MultiAppTransfers to be executed on FROM_MULTIAPP
1354  const auto & from_multi_app_objects = _from_multi_app_transfers.getActiveObjects();
1355  for (const auto & transfer : from_multi_app_objects)
1356  {
1357  transfer->setCurrentDirection(Transfer::DIRECTION::FROM_MULTIAPP);
1358  transfer->initialSetup();
1359  }
1360 
1361  // Call initialSetup on the MultiAppTransfers to be executed on BETWEEN_MULTIAPP
1362  const auto & between_multi_app_objects = _between_multi_app_transfers.getActiveObjects();
1363  for (const auto & transfer : between_multi_app_objects)
1364  {
1365  transfer->setCurrentDirection(Transfer::DIRECTION::BETWEEN_MULTIAPP);
1366  transfer->initialSetup();
1367  }
1368  }
1369 
1371  {
1372  TIME_SECTION("BoundaryRestrictedNodeIntegrityCheck", 5);
1373 
1374  // check that variables are defined along boundaries of boundary restricted nodal objects
1375  ConstBndNodeRange & bnd_nodes = *mesh().getBoundaryNodeRange();
1376  BoundaryNodeIntegrityCheckThread bnict(*this, uo_query);
1377  Threads::parallel_reduce(bnd_nodes, bnict);
1378 
1379  // Nodal bcs aren't threaded
1380  const auto & node_to_elem_map = _mesh.nodeToActiveSemilocalElemMap();
1381  for (const auto & bnode : bnd_nodes)
1382  {
1383  const auto boundary_id = bnode->_bnd_id;
1384  const Node * const node = bnode->_node;
1385 
1386  if (node->processor_id() != this->processor_id())
1387  continue;
1388 
1389  // Only check vertices. Variables may not be defined on non-vertex nodes (think first order
1390  // Lagrange on a second order mesh) and user-code can often handle that
1391  const Elem * const an_elem =
1392  _mesh.getMesh().elem_ptr(libmesh_map_find(node_to_elem_map, node->id()).front());
1393  if (!an_elem->is_vertex(an_elem->get_node_index(node)))
1394  continue;
1395 
1396  const auto & bnd_name = _mesh.getBoundaryName(boundary_id);
1397 
1398  for (auto & nl : _nl)
1399  {
1400  const auto & nodal_bcs = nl->getNodalBCWarehouse();
1401  if (!nodal_bcs.hasBoundaryObjects(boundary_id, 0))
1402  continue;
1403 
1404  const auto & bnd_objects = nodal_bcs.getBoundaryObjects(boundary_id, 0);
1405  for (const auto & bnd_object : bnd_objects)
1406  // Skip if this object uses geometric search because coupled variables may be defined on
1407  // paired boundaries instead of the boundary this node is on
1408  if (!bnd_object->requiresGeometricSearch() &&
1409  bnd_object->checkVariableBoundaryIntegrity())
1410  {
1411  std::set<MooseVariableFieldBase *> vars_to_omit = {
1412  &static_cast<MooseVariableFieldBase &>(
1413  const_cast<MooseVariableBase &>(bnd_object->variable()))};
1414 
1416  *bnd_object, bnd_object->checkAllVariables(*node, vars_to_omit), bnd_name);
1417  }
1418  }
1419  }
1420  }
1421 
1423  {
1424  TIME_SECTION("BoundaryRestrictedElemIntegrityCheck", 5);
1425 
1426  // check that variables are defined along boundaries of boundary restricted elemental objects
1427  ConstBndElemRange & bnd_elems = *mesh().getBoundaryElementRange();
1428  BoundaryElemIntegrityCheckThread beict(*this, uo_query);
1429  Threads::parallel_reduce(bnd_elems, beict);
1430  }
1431 
1432  if (!_app.isRecovering())
1433  {
1435 
1437  if (!converged)
1438  mooseError("failed to converge initial MultiApp");
1439 
1440  // We'll backup the Multiapp here
1442 
1443  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1444  reinitScalars(tid);
1445 
1447 
1448  // The FEProblemBase::execute method doesn't call all the systems on EXEC_INITIAL, but it does
1449  // set/unset the current flag. Therefore, this resets the current flag to EXEC_INITIAL so that
1450  // subsequent calls (e.g., executeControls) have the proper flag.
1452  }
1453 
1454  // Here we will initialize the stateful properties once more since they may have been updated
1455  // during initialSetup by calls to computeProperties.
1456  //
1457  // It's really bad that we don't allow this during restart. It means that we can't add new
1458  // stateful materials
1459  // during restart. This is only happening because this _has_ to be below initial userobject
1460  // execution.
1461  // Otherwise this could be done up above... _before_ restoring restartable data... which would
1462  // allow you to have
1463  // this happen during restart. I honestly have no idea why this has to happen after initial user
1464  // object computation.
1465  // THAT is something we should fix... so I've opened this ticket: #5804
1466  if (!_app.isRecovering() && !_app.isRestarting())
1467  {
1470  {
1471  TIME_SECTION("computeMaterials", 2, "Computing Initial Material Properties");
1472 
1474  }
1475 #ifdef MOOSE_KOKKOS_ENABLED
1479  {
1480  TIME_SECTION("computeMaterials", 2, "Computing Initial Material Properties");
1481 
1483  }
1484 #endif
1485  }
1486 
1487  // Control Logic
1489 
1490  // Scalar variables need to reinited for the initial conditions to be available for output
1491  for (unsigned int tid = 0; tid < n_threads; tid++)
1492  reinitScalars(tid);
1493 
1494  if (_displaced_mesh)
1495  _displaced_problem->syncSolutions();
1496 
1497  // Writes all calls to _console from initialSetup() methods
1499 
1501  {
1503  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
1504  for (auto & assembly : _assembly[tid])
1506  }
1507 
1508  {
1509  TIME_SECTION("lineSearchInitialSetup", 5, "Initializing Line Search");
1510 
1511  if (_line_search)
1512  _line_search->initialSetup();
1513  }
1514 
1515  // Perform Reporter get/declare check
1517 
1518  // We do this late to allow objects to get late restartable data
1521 
1523 }
void sort(THREAD_ID tid=0)
Sort the objects using the DependencyResolver.
void setVariableAllDoFMap(const std::vector< const MooseVariableFEBase *> &moose_vars)
bool _skip_exception_check
If or not skip &#39;exception and stop solve&#39;.
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
Definition: MooseMesh.C:1276
void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed=false)
Call when it is possible that the needs for ghosted elements has changed.
const std::string & getBoundaryName(BoundaryID boundary_id) const
Return the name of the boundary given the id.
Definition: MooseMesh.C:1830
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:820
MaterialPropertyStorage & _bnd_material_props
void setNonlocalCouplingMatrix()
Set custom coupling matrix for variables requiring nonlocal contribution.
void initialSetup()
Calls the initialSetup function for each of the output objects.
unsigned int n_threads()
QueryCache is a convenient way to construct and pass around (possible partially constructed) warehous...
Definition: TheWarehouse.h:208
std::shared_ptr< DisplacedProblem > displaced_problem
unsigned int get_node_index(const Node *node_ptr) const
bool hasObjects(THREAD_ID tid=0) const
Convenience functions for determining if objects exist.
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
const std::map< dof_id_type, std::vector< dof_id_type > > & nodeToActiveSemilocalElemMap()
If not already created, creates a map from every node to all active semilocal elements to which they ...
Definition: MooseMesh.C:1244
bool hasInitialBackup() const
Definition: MooseApp.h:1001
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
const ExecFlagEnum & getExecuteOnEnum() const
Return the app level ExecFlagEnum, this contains all the available flags for the app.
Definition: MooseApp.h:994
void parallel_reduce(const Range &range, Body &body, const Partitioner &)
unsigned short _current_ic_state
std::vector< T * > & queryInto(std::vector< T *> &results, Args &&... args)
queryInto executes the query and stores the results in the given vector.
Definition: TheWarehouse.h:311
const ExecFlagType EXEC_NONE
Definition: Moose.C:29
std::filesystem::path restartFolderBase(const std::filesystem::path &folder_base) const
The file suffix for restartable data.
Definition: MooseApp.C:3160
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.
MaterialWarehouse _kokkos_materials
unsigned int _num_grid_steps
Number of steps in a grid sequence.
bool haveXFEM()
Find out whether the current analysis is using XFEM.
This class provides an interface for common operations on field variables of both FE and FV types wit...
const Parallel::Communicator & _communicator
MaterialWarehouse _interface_materials
Real getStartTime() const
Definition: MooseApp.h:300
void setCurrentExecuteOnFlag(const ExecFlagType &)
void initElementStatefulProps(const libMesh::ConstElemRange &elem_range, const bool threaded)
Initialize stateful properties for elements in a specific elem_range This is needed when elements/bou...
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
bool isRestarting() const
Whether or not this is a "restart" calculation.
Definition: MooseApp.C:1880
libMesh::ConstNodeRange * getLocalNodeRange()
Definition: MooseMesh.C:1313
bool isOn()
Is adaptivity on?
Definition: Adaptivity.h:179
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
Definition: SubProblem.h:1095
void projectSolution()
auto max(const L &left, const R &right)
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override
ScalarInitialConditionWarehouse _scalar_ics
bool getExodusFileRestart() const
Whether or not we need to use a separate Exodus reader to read the mesh BEFORE we create the mesh...
Definition: MooseApp.h:430
ExecuteMooseObjectWarehouse< Transfer > _transfers
Normal Transfers.
virtual void copySolutionsBackwards()
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
std::vector< VariablePhiGradient > _grad_phi_zero
void mooseWarning(Args &&... args) const
void initialSetup(THREAD_ID tid)
Initial setup.
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
ReporterData _reporter_data
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.
MooseObjectWarehouse< Convergence > _convergences
convergence warehouse
void sort(THREAD_ID tid=0, bool sort_all_objects=false)
By default, this method only sorts block and boundary-wise object storages that are used by the MOOSE...
dof_id_type id() const
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition: MooseMesh.C:3469
TheWarehouse & theWarehouse() const
void boundaryIntegrityCheckError(const MooseObject &object, const std::set< MooseVariableFieldBase *> &variables, const BoundaryName &boundary_name)
Compose boundary restricted error message for the provided object, variables, and boundary_name if th...
void checkNonlocalCoupling()
void groupUserObjects(TheWarehouse &w, AuxiliarySystem &aux, const ExecFlagEnum &execute_flags, const std::vector< T *> &objs, const std::set< std::string > &ic_deps)
MortarData _mortar_data
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
virtual bool converged(const unsigned int sys_num)
Eventually we want to convert this virtual over to taking a solver system number argument.
Definition: SubProblem.h:113
const bool _boundary_restricted_node_integrity_check
whether to perform checking of boundary restricted nodal object variable dependencies, e.g.
MooseMesh & _mesh
virtual bool updateMeshXFEM()
Update the mesh due to changing XFEM cuts.
void addAnyRedistributers()
void restoreFromInitialBackup(const bool for_restart)
Restores from a "initial" backup, that is, one set in _initial_backup.
Definition: MooseApp.C:1982
Adaptivity _adaptivity
void checkUserObjectJacobianRequirement(THREAD_ID tid)
const bool _force_restart
std::vector< VariablePhiSecond > _second_phi_zero
bool _started_initial_setup
At or beyond initialSteup stage.
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
libMesh::ExodusII_IO * getExReaderForRestart() const
Get the Exodus reader to restart variables from an Exodus mesh file.
Definition: MooseApp.h:443
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
unsigned int uniformRefineLevel() const
Returns the level of uniform refinement requested (zero if AMR is disabled).
Definition: MooseMesh.C:3237
AuxiliarySystem & getAuxiliarySystem()
virtual void initialSetup(THREAD_ID tid=0) const
Convenience methods for calling object setup methods.
virtual void updateGeomSearch(GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
void buildRefinementAndCoarseningMaps(Assembly *assembly)
Create the refinement and coarsening maps necessary for projection of stateful material properties wh...
Definition: MooseMesh.C:2500
MooseObjectWarehouse< Indicator > _indicators
void backupMultiApps(ExecFlagType type)
Backup the MultiApps associated with the ExecFlagType.
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
void uniformRefineWithProjection()
Performs uniform refinement on the meshes in the current object.
Definition: Adaptivity.C:301
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
virtual void initialSetup(THREAD_ID tid=0) const
Convenience methods for calling object setup methods that handle the extra neighbor and face objects...
virtual const Elem * elem_ptr(const dof_id_type i) const=0
virtual void updateMortarMesh()
void restore(const std::filesystem::path &folder_base, const bool for_restart)
Restore an application from file.
Definition: MooseApp.C:1947
Moose::Kokkos::MaterialPropertyStorage & _kokkos_material_props
std::vector< VariablePhiValue > _phi_zero
InitialConditionWarehouse _ics
MaterialWarehouse _discrete_materials
virtual void initialSetup()
Definition: SubProblem.C:1220
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
void updateActiveSemiLocalNodeRange(std::set< dof_id_type > &ghosted_elems)
Clears the "semi-local" node list and rebuilds it.
Definition: MooseMesh.C:966
bool hasActiveObjects(THREAD_ID tid=0) const
unsigned int getInitialSteps() const
Pull out the number of initial steps previously set by calling init()
Definition: Adaptivity.h:98
void max(const T &r, T &o, Request &req) const
void setLoadAllVectors(const bool load_all_vectors)
Sets whether or not all vectors are to be loaded.
virtual bool is_vertex(const unsigned int i) const=0
void initNonlocalCoupling()
Create pair of variables requiring nonlocal jacobian contributions.
Definition: Assembly.C:2647
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
Definition: TheWarehouse.h:466
bool hasStartTime() const
Definition: MooseApp.h:295
bool hasDisplacedObjects() const
Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh...
Definition: MortarData.h:99
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars
virtual MooseMesh & mesh() 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
void mooseConsole()
Send current output buffer to Console output objects.
std::set< std::string > getDependObjects() const
Get a list of dependent UserObjects for this exec type.
std::shared_ptr< DisplacedProblem > _displaced_problem
MooseObjectWarehouse< Function > _functions
functions
bool _has_initialized_stateful
Whether nor not stateful materials have been initialized.
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Definition: TheWarehouse.h:284
MaterialPropertyStorage & _neighbor_material_props
std::unique_ptr< Backup > finalizeRestore()
Finalizes (closes) the restoration process done in restore().
Definition: MooseApp.C:1989
libMesh::StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > * getBoundaryElementRange()
Definition: MooseMesh.C:1341
bool _has_internal_edge_residual_objects
Whether the problem has dgkernels or interface kernels.
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
void check() const
Perform integrity check for get/declare calls.
Definition: ReporterData.C:162
const bool _boundary_restricted_elem_integrity_check
whether to perform checking of boundary restricted elemental object variable dependencies, e.g.
Moose::Kokkos::MaterialPropertyStorage & _kokkos_bnd_material_props
processor_id_type processor_id() const
MaterialPropertyStorage & _material_props
Adaptivity & adaptivity()
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.
bool isRecovering() const
Whether or not this is a "recover" calculation.
Definition: MooseApp.C:1874
Restartable::ManagedValue< RestartableEquationSystems > _req
The EquationSystems object, wrapped for restart.
processor_id_type processor_id() const
std::string getRestartRecoverFileBase() const
The file_base for the recovery file.
Definition: MooseApp.h:494
MooseObjectWarehouse< Marker > _markers
FVInitialConditionWarehouse _fv_ics
virtual void initialAdaptMesh()
Moose::Kokkos::MaterialPropertyStorage & _kokkos_neighbor_material_props
MaterialWarehouse _all_materials
libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > * getBoundaryNodeRange()
Definition: MooseMesh.C:1327
auto index_range(const T &sizable)
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2515
MooseMesh * _displaced_mesh
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
Base variable class.
unsigned int THREAD_ID
Definition: MooseTypes.h:209
MaterialWarehouse _materials
uint8_t dof_id_type
std::shared_ptr< LineSearch > _line_search
unsigned int getMaxQps() const
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:30

◆ 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(), 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 EigenProblem::initPetscOutputAndSomeSolverSettings ( )
overridevirtual

Hook up monitors for SNES and KSP.

Reimplemented from FEProblemBase.

Definition at line 687 of file EigenProblem.C.

Referenced by SlepcEigenSolverConfiguration::configure_solver().

688 {
690 }
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:2515

◆ initXFEM()

void FEProblemBase::initXFEM ( std::shared_ptr< XFEMInterface xfem)
inherited

Create XFEM controller object.

Definition at line 8258 of file FEProblemBase.C.

8259 {
8260  _xfem = xfem;
8261  _xfem->setMesh(&_mesh);
8262  if (_displaced_mesh)
8263  _xfem->setDisplacedMesh(_displaced_mesh);
8264 
8265  auto fill_data = [](auto & storage)
8266  {
8267  std::vector<MaterialData *> data(libMesh::n_threads());
8268  for (const auto tid : make_range(libMesh::n_threads()))
8269  data[tid] = &storage.getMaterialData(tid);
8270  return data;
8271  };
8272  _xfem->setMaterialData(fill_data(_material_props));
8273  _xfem->setBoundaryMaterialData(fill_data(_bnd_material_props));
8274 
8275  unsigned int n_threads = libMesh::n_threads();
8276  for (unsigned int i = 0; i < n_threads; ++i)
8277  for (const auto nl_sys_num : index_range(_nl))
8278  {
8279  _assembly[i][nl_sys_num]->setXFEM(_xfem);
8280  if (_displaced_problem)
8281  _displaced_problem->assembly(i, nl_sys_num).setXFEM(_xfem);
8282  }
8283 }
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

◆ isGeneralizedEigenvalueProblem()

bool EigenProblem::isGeneralizedEigenvalueProblem ( ) const
inline

Definition at line 42 of file EigenProblem.h.

bool _generalized_eigenvalue_problem
Definition: EigenProblem.h:241

◆ 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 75 of file MooseObject.h.

Referenced by BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

76  {
78  }
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 731 of file SubProblem.C.

732 {
733  return _material_property_requested.find(prop_name) != _material_property_requested.end();
734 }
std::set< std::string > _material_property_requested
set containing all material property names that have been requested by getMaterialProperty* ...
Definition: SubProblem.h:1064

◆ isNonlinearEigenvalueSolver()

bool EigenProblem::isNonlinearEigenvalueSolver ( unsigned int  eigen_sys_num) const

Definition at line 676 of file EigenProblem.C.

Referenced by Moose::assemble_matrix(), checkProblemIntegrity(), SlepcEigenSolverConfiguration::configure_solver(), NonlinearEigenSystem::getSNES(), init(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), solve(), and NonlinearEigenSystem::solve().

677 {
678  const auto & solver_params = solverParams(eigen_sys_num);
679  return solver_params._eigen_solve_type == Moose::EST_NONLINEAR_POWER ||
680  solver_params._eigen_solve_type == Moose::EST_NEWTON ||
681  solver_params._eigen_solve_type == Moose::EST_PJFNK ||
682  solver_params._eigen_solve_type == Moose::EST_JFNK ||
683  solver_params._eigen_solve_type == Moose::EST_PJFNKMO;
684 }
Newton-based eigensolver with an assembled Jacobian matrix (fully coupled by default) ...
Definition: MooseTypes.h:862
The same as PJFNK except that matrix-vector multiplication is employed to replace residual evaluation...
Definition: MooseTypes.h:864
Preconditioned Jacobian-free Newton Krylov.
Definition: MooseTypes.h:863
Nonlinear inverse power.
Definition: MooseTypes.h:861
Jacobian-free Newton Krylov.
Definition: MooseTypes.h:865
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.

◆ 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(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), MFEMVectorFESpace::getFECName(), 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(), AddVariableAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), CommonOutputAction::act(), 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(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), 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(), AddMetaDataGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), BlockDeletionGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), SideSetsFromNodeSetsGenerator::generate(), MeshExtruderGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYZDelaunayGenerator::generate(), XYMeshLineCutter::generate(), XYDelaunayGenerator::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(), SolutionScalarAux::initialSetup(), ParsedConvergence::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 2338 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 9454 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::jacobianSetup().

9455 {
9457  // We need to setup all the nonlinear systems other than our current one which actually called
9458  // this method (so we have to make sure we don't go in a circle)
9459  for (const auto i : make_range(numNonlinearSystems()))
9460  if (i != currentNlSysNum())
9461  _nl[i]->jacobianSetup();
9462  // We don't setup the aux sys because that's been done elsewhere
9463  if (_displaced_problem)
9464  _displaced_problem->jacobianSetup();
9465 }
virtual std::size_t numNonlinearSystems() const override
virtual void jacobianSetup()
Definition: SubProblem.C:1212
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 333 of file FEProblemBase.h.

333 { return _kokkos_assembly; }
Moose::Kokkos::Assembly _kokkos_assembly

◆ kokkosAssembly() [2/2]

const Moose::Kokkos::Assembly& FEProblemBase::kokkosAssembly ( ) const
inlineinherited

Definition at line 334 of file FEProblemBase.h.

334 { 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 6550 of file FEProblemBase.C.

Referenced by Moose::compute_linear_system(), LinearSystem::computeGradients(), FEProblemBase::computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and DisplacedProblem::linearSysNum().

6551 {
6552  std::istringstream ss(linear_sys_name);
6553  unsigned int linear_sys_num;
6554  if (!(ss >> linear_sys_num) || !ss.eof())
6555  linear_sys_num = libmesh_map_find(_linear_sys_name_to_num, linear_sys_name);
6556 
6557  return linear_sys_num;
6558 }
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 2711 of file FEProblemBase.C.

Referenced by ComputeLineSearchObjectWrapper::linesearch().

2712 {
2713  _line_search->lineSearch();
2714 }
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 4396 of file FEProblemBase.C.

Referenced by FEProblemBase::addAuxArrayVariable(), 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(), FEProblemBase::setAuxKernelParamsAndLog(), and FEProblemBase::setResidualObjectParamsAndLog().

4400 {
4401  if (_verbose_setup != "false")
4402  _console << "[DBG] Adding " << system << " '" << name << "' of type " << type << std::endl;
4403  if (_verbose_setup == "extra")
4404  _console << params << std::endl;
4405 }
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 1372 of file SubProblem.C.

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

1373 {
1374  auto family = Utility::string_to_enum<FEFamily>(params.get<MooseEnum>("family"));
1375  bool flag = _default_families_without_p_refinement.count(family);
1376  if (params.isParamValid("disable_p_refinement"))
1377  flag = params.get<bool>("disable_p_refinement");
1378 
1379  auto [it, inserted] = _family_for_p_refinement.emplace(family, flag);
1380  if (!inserted && flag != it->second)
1381  mooseError("'disable_p_refinement' not set consistently for variables in ", family);
1382 }
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:1210
static const std::unordered_set< FEFamily > _default_families_without_p_refinement
The set of variable families by default disable p-refinement.
Definition: SubProblem.h:1212
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 725 of file SubProblem.C.

Referenced by MaterialBase::markMatPropRequested(), and MaterialPropertyInterface::markMatPropRequested().

726 {
727  _material_property_requested.insert(prop_name);
728 }
std::set< std::string > _material_property_requested
set containing all material property names that have been requested by getMaterialProperty* ...
Definition: SubProblem.h:1064

◆ 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 329 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().

330 {
331  auto tag_name_upper = MooseUtils::toUpper(tag_name);
332 
333  return _matrix_tag_name_to_tag_id.find(tag_name_upper) != _matrix_tag_name_to_tag_id.end();
334 }
std::map< TagName, TagID > _matrix_tag_name_to_tag_id
The currently declared tags.
Definition: SubProblem.h:1043
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 337 of file SubProblem.C.

338 {
339  return _matrix_tag_id_to_tag_name.find(tag_id) != _matrix_tag_id_to_tag_name.end();
340 }
std::map< TagID, TagName > _matrix_tag_id_to_tag_name
Reverse map.
Definition: SubProblem.h:1046

◆ matrixTagName()

TagName SubProblem::matrixTagName ( TagID  tag)
virtualinherited

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 358 of file SubProblem.C.

Referenced by SystemBase::addMatrix(), DisplacedProblem::matrixTagName(), and SystemBase::removeMatrix().

359 {
360  return _matrix_tag_id_to_tag_name[tag];
361 }
std::map< TagID, TagName > _matrix_tag_id_to_tag_name
Reverse map.
Definition: SubProblem.h:1046

◆ mesh() [1/3]

virtual MooseMesh& FEProblemBase::mesh ( )
inlineoverridevirtualinherited

Implements SubProblem.

Reimplemented in MFEMProblem.

Definition at line 163 of file FEProblemBase.h.

Referenced by Adaptivity::adaptMesh(), FEProblemBase::addAnyRedistributers(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), PhysicsBasedPreconditioner::apply(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), SampledOutput::cloneMesh(), LinearSystem::computeGradients(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), ComputeFullJacobianThread::computeOnInternalFace(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::coordTransform(), MultiApp::createApp(), DMMooseGetEmbedding_Private(), ElementsAlongLine::ElementsAlongLine(), ElementsAlongPlane::ElementsAlongPlane(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementsAlongLine::execute(), ElementsAlongPlane::execute(), IntersectionPointsAlongLine::execute(), WorkBalance::execute(), MultiAppUserObjectTransfer::execute(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), FunctionPeriodicBoundary::FunctionPeriodicBoundary(), MultiApp::getBoundingBox(), Exodus::handleExodusIOMeshRenumbering(), FunctorPositions::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), ImageFunction::initialSetup(), FEProblemBase::initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), IntersectionPointsAlongLine::IntersectionPointsAlongLine(), Moose::Mortar::loopOverMortarSegments(), ReporterPointMarker::markerSetup(), MFEMProblem::mesh(), FEProblemBase::mesh(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), ComputeNodalUserObjectsThread::onNode(), BoundaryNodeIntegrityCheckThread::onNode(), ComputeInitialConditionThread::operator()(), BoundaryElemIntegrityCheckThread::operator()(), ComputeLinearFVGreenGaussGradientVolumeThread::operator()(), Output::Output(), Exodus::outputEmptyTimestep(), ConsoleUtils::outputMeshInformation(), Exodus::outputNodalVariables(), Exodus::outputSetup(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), SolutionUserObjectBase::pointValueGradientWrapper(), SolutionUserObjectBase::pointValueWrapper(), MeshInfo::possiblyAddSidesetInfo(), MeshInfo::possiblyAddSubdomainInfo(), ComputeLinearFVElementalThread::printBlockExecutionInformation(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), MaterialPropertyDebugOutput::printMaterialMap(), TopResidualDebugOutput::printTopResiduals(), SolutionUserObjectBase::SolutionUserObjectBase(), FixedPointSolve::solve(), TransientMultiApp::solveStep(), Moose::PetscSupport::storePetscOptions(), MultiAppDofCopyTransfer::transfer(), Checkpoint::updateCheckpointFiles(), and SampledOutput::updateSample().

163 { return _mesh; }
MooseMesh & _mesh

◆ mesh() [2/3]

virtual const MooseMesh& FEProblemBase::mesh ( ) const
inlineoverridevirtualinherited

Implements SubProblem.

Reimplemented in MFEMProblem.

Definition at line 164 of file FEProblemBase.h.

164 { return _mesh; }
MooseMesh & _mesh

◆ 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
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 8316 of file FEProblemBase.C.

Referenced by SidesetAroundSubdomainUpdater::finalize(), ActivateElementsUserObjectBase::finalize(), Exodus::handleExodusIOMeshRenumbering(), ElementSubdomainModifierBase::modify(), and Adaptivity::uniformRefineWithProjection().

8319 {
8320  TIME_SECTION("meshChanged", 3, "Handling Mesh Changes");
8321 
8324  _mesh.cacheChangedLists(); // Currently only used with adaptivity and stateful material
8325  // properties
8326 
8327  // Clear these out because they corresponded to the old mesh
8328  _ghosted_elems.clear();
8330 
8331  // The mesh changed. We notify the MooseMesh first, because
8332  // callbacks (e.g. for sparsity calculations) triggered by the
8333  // EquationSystems reinit may require up-to-date MooseMesh caches.
8334  _mesh.meshChanged();
8335 
8336  // If we're just going to alter the mesh again, all we need to
8337  // handle here is AMR and projections, not full system reinit
8338  if (intermediate_change)
8339  es().reinit_solutions();
8340  else
8341  es().reinit();
8342 
8343  if (contract_mesh)
8344  // Once vectors are restricted, we can delete children of coarsened elements
8345  _mesh.getMesh().contract();
8346  if (clean_refinement_flags)
8347  {
8348  // Finally clear refinement flags so that if someone tries to project vectors again without
8349  // an intervening mesh refinement to clear flags they won't run into trouble
8350  MeshRefinement refinement(_mesh.getMesh());
8351  refinement.clean_refinement_flags();
8352  }
8353 
8354  if (!intermediate_change)
8355  {
8356  // Since the mesh has changed, we need to make sure that we update any of our
8357  // MOOSE-system specific data.
8358  for (auto & sys : _solver_systems)
8359  sys->reinit();
8360  _aux->reinit();
8361  }
8362 
8363  // Updating MooseMesh first breaks other adaptivity code, unless we
8364  // then *again* update the MooseMesh caches. E.g. the definition of
8365  // "active" and "local" may have been *changed* by refinement and
8366  // repartitioning done in EquationSystems::reinit().
8367  _mesh.meshChanged();
8368 
8369  // If we have finite volume variables, we will need to recompute additional elemental/face
8370  // quantities
8373 
8374  // Let the meshChangedInterface notify the mesh changed event before we update the active
8375  // semilocal nodes, because the set of ghosted elements may potentially be updated during a mesh
8376  // changed event.
8377  for (const auto & mci : _notify_when_mesh_changes)
8378  mci->meshChanged();
8379 
8380  // Since the Mesh changed, update the PointLocator object used by DiracKernels.
8382 
8383  // Need to redo ghosting
8385 
8386  if (_displaced_problem)
8387  {
8388  _displaced_problem->meshChanged(contract_mesh, clean_refinement_flags);
8390  }
8391 
8393 
8396 
8397  // Just like we reinitialized our geometric search objects, we also need to reinitialize our
8398  // mortar meshes. Note that this needs to happen after DisplacedProblem::meshChanged because the
8399  // mortar mesh discretization will depend necessarily on the displaced mesh being re-displaced
8400  updateMortarMesh();
8401 
8402  // Nonlinear systems hold the mortar mesh functors. The domains of definition of the mortar
8403  // functors might have changed when the mesh changed.
8404  for (auto & nl_sys : _nl)
8405  nl_sys->reinitMortarFunctors();
8406 
8407  reinitBecauseOfGhostingOrNewGeomObjects(/*mortar_changed=*/true);
8408 
8409  // We need to create new storage for newly active elements, and copy
8410  // stateful properties from the old elements.
8413  {
8414  if (havePRefinement())
8416 
8417  // Prolong properties onto newly refined elements' children
8418  {
8420  /* refine = */ true, *this, _material_props, _bnd_material_props, _assembly);
8421  const auto & range = *_mesh.refinedElementRange();
8422  Threads::parallel_reduce(range, pmp);
8423 
8424  // Concurrent erasure from the shared hash map is not safe while we are reading from it in
8425  // ProjectMaterialProperties, so we handle erasure here. Moreover, erasure based on key is
8426  // not thread safe in and of itself because it is a read-write operation. Note that we do not
8427  // do the erasure for p-refinement because the coarse level element is the same as our active
8428  // refined level element
8429  if (!doingPRefinement())
8430  for (const auto & elem : range)
8431  {
8435  }
8436  }
8437 
8438  // Restrict properties onto newly coarsened elements
8439  {
8441  /* refine = */ false, *this, _material_props, _bnd_material_props, _assembly);
8442  const auto & range = *_mesh.coarsenedElementRange();
8443  Threads::parallel_reduce(range, pmp);
8444  // Note that we do not do the erasure for p-refinement because the coarse level element is the
8445  // same as our active refined level element
8446  if (!doingPRefinement())
8447  for (const auto & elem : range)
8448  {
8449  auto && coarsened_children = _mesh.coarsenedElementChildren(elem);
8450  for (auto && child : coarsened_children)
8451  {
8455  }
8456  }
8457  }
8458  }
8459 
8462 
8463  _has_jacobian = false; // we have to recompute jacobian when mesh changed
8464 
8465  // Now for backwards compatibility with user code that overrode the old no-arg meshChanged we must
8466  // call it here
8467  meshChanged();
8468 }
void setVariableAllDoFMap(const std::vector< const MooseVariableFEBase *> &moose_vars)
bool isFiniteVolumeInfoDirty() const
Definition: MooseMesh.h:1322
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:1095
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:1011
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
Definition: MooseMesh.C:3469
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:1366
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:1051
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:4093

◆ meshChanged() [2/2]

virtual void FEProblemBase::meshChanged ( )
inlineprotectedvirtualinherited

Deprecated.

Users should switch to overriding the meshChanged which takes arguments

Definition at line 2728 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::initialAdaptMesh(), FEProblemBase::meshChanged(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateMeshXFEM().

2728 {}

◆ meshDisplaced()

void FEProblemBase::meshDisplaced ( )
protectedvirtualinherited

Update data after a mesh displaced.

Definition at line 8483 of file FEProblemBase.C.

Referenced by DisplacedProblem::updateMesh().

8484 {
8485  for (const auto & mdi : _notify_when_mesh_displaces)
8486  mdi->meshDisplaced();
8487 }
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() [1/2]

template<typename... Args>
void SolutionInvalidInterface::mooseDeprecated ( Args &&...  args) const
inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), 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(), TagVectorAux::TagVectorAux(), UserForcingFunction::UserForcingFunction(), and VariableResidual::VariableResidual().

88  {
89  _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
90  flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
91  }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const MooseBase & _si_moose_base
The MooseBase that owns this interface.

◆ mooseDeprecated() [2/2]

template<typename... Args>
void MooseBase::mooseDeprecated ( Args &&...  args) const
inlineinherited

Definition at line 314 of file MooseBase.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), MooseApp::getRecoverFileBase(), MooseApp::hasRecoverFileBase(), and MooseApp::setupOptions().

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(), AutoCheckpointAction::act(), AddMeshGeneratorAction::act(), CheckFVBCAction::act(), InitProblemAction::act(), AddBoundsVectorsAction::act(), AddVectorPostprocessorAction::act(), SetupMeshCompleteAction::act(), CreateExecutionerAction::act(), CheckIntegrityAction::act(), AddFVICAction::act(), AddICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), ChainControlSetupAction::act(), AddTimeStepperAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), AddMFEMSubMeshAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::adaptMesh(), MooseVariableFV< Real >::adCurlSln(), MooseVariableFV< Real >::adCurlSlnNeighbor(), AddActionComponentAction::AddActionComponentAction(), MFEMProblem::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(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), MFEMProblem::addMaterial(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::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(), AuxKernelBase::AuxKernelBase(), 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::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(), MFEMSolverBase::checkSpectralEquivalence(), 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(), 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(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), MultiAppGeometricInterpolationTransfer::computeTransformation(), BuildArrayVariableAux::computeValue(), TagVectorArrayVariableAux::computeValue(), NearestNodeValueAux::computeValue(), ProjectionAux::computeValue(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), 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(), doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), 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(), RestartableDataReporter::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), NodalValueSampler::execute(), PositionsFunctorValueSampler::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), ElementQualityChecker::execute(), MultiAppPostprocessorTransfer::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), InterfaceQpUserObjectBase::execute(), WebServerControl::execute(), TransientBase::execute(), LeastSquaresFit::execute(), LeastSquaresFitHistory::execute(), VectorPostprocessorComparison::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(), ParsedVectorReporter::finalize(), ParsedVectorVectorRealReductionReporter::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(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MoveNodeGenerator::generate(), SideSetsFromPointsGenerator::generate(), StitchMeshGenerator::generate(), MeshDiagnosticsGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), MeshRepairGenerator::generate(), ParsedGenerateNodeset::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), CombinerGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), AdvancedExtruderGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), SpiralAnnularMeshGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), CutMeshByLevelSetGeneratorBase::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), 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(), 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(), MeshGenerator::getCSGBaseByName(), 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(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), FEProblemBase::getMultiAppFixedPointConvergenceName(), DistributedRectilinearMeshGenerator::getNeighbors(), Times::getNextTime(), MooseMesh::getNodeBlockIds(), PropertyReadFile::getNodeData(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearConvergenceNames(), 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(), VectorPostprocessorComponent::getValue(), NumRelationshipManagers::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(), ExplicitTimeIntegrator::init(), EigenExecutionerBase::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(), FunctorPositions::initialize(), ReporterTimes::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SteffensenSolve::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), ChainControlDataPostprocessor::initialSetup(), MultiAppConservativeTransfer::initialSetup(), PiecewiseLinearBase::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), SolutionScalarAux::initialSetup(), LinearFVDiffusion::initialSetup(), LinearFVAdvection::initialSetup(), LinearFVAnisotropicDiffusion::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(), LStableDirk4::postResidual(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), 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(), MFEMHypreAMS::updateSolver(), MFEMHypreADS::updateSolver(), MFEMGMRESSolver::updateSolver(), MFEMCGSolver::updateSolver(), MFEMHypreFGMRES::updateSolver(), MFEMHyprePCG::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(), 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() [1/2]

template<typename... Args>
void SolutionInvalidInterface::mooseWarning ( Args &&...  args) const
inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::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(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), MFEMVectorFESpace::getFECName(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), SphericalGridDivision::initialize(), CylindricalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), CartesianGridDivision::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MaterialOutputAction::outputHelper(), MultiAppGeneralFieldTransfer::outputValueConflicts(), 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().

74  {
75  _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
76  flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
77  }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const MooseBase & _si_moose_base
The MooseBase that owns this interface.

◆ mooseWarning() [2/2]

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 DataFileInterface::getDataFilePath(), MooseApp::loadLibraryAndDependencies(), and MooseBase::paramWarning().

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() [1/2]

template<typename... Args>
void SolutionInvalidInterface::mooseWarningNonPrefixed ( Args &&...  args) const
inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

81  {
82  _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
83  flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
84  }
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
const MooseBase & _si_moose_base
The MooseBase that owns this interface.

◆ mooseWarningNonPrefixed() [2/2]

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 2406 of file FEProblemBase.h.

2406 { return _mortar_data; }
MortarData _mortar_data

◆ mortarData() [2/2]

MortarData& FEProblemBase::mortarData ( )
inlineinherited

Definition at line 2407 of file FEProblemBase.h.

2407 { 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(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), SetupTimeIntegratorAction::act(), AddActionComponentAction::act(), SetupResidualDebugAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), Registry::addDataFilePath(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), SubProblem::addFunctor(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), DiffusionLHDGKernel::additionalROVariables(), IPHDGAssemblyHelper::additionalROVariables(), MFEMProblem::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(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), InitialConditionWarehouse::addObject(), FEProblemBase::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), InitialConditionBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), UserObject::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), InitialConditionBase::addUserObjectDependencyHelper(), AuxKernelBase::addUserObjectDependencyHelper(), UserObject::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), AuxKernelBase::addVectorPostprocessorDependencyHelper(), 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(), AuxKernelBase::AuxKernelBase(), 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::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(), SideSetsFromNodeSetsGenerator::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), MeshGenerator::getCSGBase(), MeshGenerator::getCSGBasesByName(), 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(), AuxKernelTempl< Real >::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), AuxKernelTempl< Real >::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), AuxKernelTempl< Real >::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), AuxKernelTempl< Real >::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::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(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< Real >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), 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(), SolutionInvalidInterface::paramWarning(), 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(), FEProblemBase::setAuxKernelParamsAndLog(), 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 8938 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onBoundary(), ProjectMaterialProperties::onBoundary(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFaceOnBoundary(), and FEProblemBase::reinitMaterialsNeighborOnBoundary().

8939 {
8940  if (_bnd_mat_side_cache[tid].find(bnd_id) == _bnd_mat_side_cache[tid].end())
8941  {
8942  auto & bnd_mat_side_cache = _bnd_mat_side_cache[tid][bnd_id];
8943  bnd_mat_side_cache = false;
8944 
8945  // Check systems
8946  if (_aux->needMaterialOnSide(bnd_id))
8947  {
8948  bnd_mat_side_cache = true;
8949  return true;
8950  }
8951  for (auto & nl : _nl)
8952  if (nl->needBoundaryMaterialOnSide(bnd_id, tid))
8953  {
8954  bnd_mat_side_cache = true;
8955  return true;
8956  }
8957 
8958  // TODO: these objects should be checked for whether they actually consume materials
8959  // NOTE: InterfaceUO can use use boundary properties too
8960  if (theWarehouse()
8961  .query()
8962  .condition<AttribThread>(tid)
8963  .condition<AttribInterfaces>(Interfaces::SideUserObject | Interfaces::DomainUserObject |
8965  .condition<AttribBoundaries>(bnd_id)
8966  .count() > 0)
8967  {
8968  bnd_mat_side_cache = true;
8969  return true;
8970  }
8971  }
8972 
8973  return _bnd_mat_side_cache[tid][bnd_id];
8974 }
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 2671 of file FEProblemBase.h.

Referenced by DiffusionFV::initializePhysicsAdditional(), and DisplacedProblem::needFV().

2671 { _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 8977 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInterface(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), and FEProblemBase::reinitMaterialsNeighborOnBoundary().

8978 {
8979  if (_interface_mat_side_cache[tid].find(bnd_id) == _interface_mat_side_cache[tid].end())
8980  {
8981  auto & interface_mat_side_cache = _interface_mat_side_cache[tid][bnd_id];
8982  interface_mat_side_cache = false;
8983 
8984  // Aux-system has not needed interface materials so far
8985  for (auto & nl : _nl)
8986  if (nl->needInterfaceMaterialOnSide(bnd_id, tid))
8987  {
8988  interface_mat_side_cache = true;
8989  return true;
8990  }
8991 
8992  // TODO: these objects should be checked for whether they actually consume materials
8993  if (theWarehouse()
8994  .query()
8995  .condition<AttribThread>(tid)
8996  .condition<AttribInterfaces>(Interfaces::InterfaceUserObject |
8998  .condition<AttribBoundaries>(bnd_id)
8999  .count() > 0)
9000  {
9001  interface_mat_side_cache = true;
9002  return true;
9003  }
9004  else if (_interface_materials.hasActiveBoundaryObjects(bnd_id, tid))
9005  {
9006  interface_mat_side_cache = true;
9007  return true;
9008  }
9009  }
9010  return _interface_mat_side_cache[tid][bnd_id];
9011 }
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.

◆ needInternalNeighborSideMaterial()

bool FEProblemBase::needInternalNeighborSideMaterial ( SubdomainID  subdomain_id,
const THREAD_ID  tid 
)
inherited

Definition at line 9014 of file FEProblemBase.C.

Referenced by FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsNeighborOnBoundary(), ComputeMaterialsObjectThread::subdomainChanged(), and ProjectMaterialProperties::subdomainChanged().

9015 {
9016  if (_block_mat_side_cache[tid].find(subdomain_id) == _block_mat_side_cache[tid].end())
9017  {
9018  _block_mat_side_cache[tid][subdomain_id] = false;
9019 
9020  for (auto & nl : _nl)
9021  if (nl->needInternalNeighborSideMaterial(subdomain_id, tid))
9022  {
9023  _block_mat_side_cache[tid][subdomain_id] = true;
9024  return true;
9025  }
9026 
9027  // TODO: these objects should be checked for whether they actually consume materials
9028  if (theWarehouse()
9029  .query()
9030  .condition<AttribThread>(tid)
9031  .condition<AttribInterfaces>(Interfaces::InternalSideUserObject |
9033  .condition<AttribSubdomains>(subdomain_id)
9034  .count() > 0)
9035  {
9036  _block_mat_side_cache[tid][subdomain_id] = true;
9037  return true;
9038  }
9039  }
9040 
9041  return _block_mat_side_cache[tid][subdomain_id];
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
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

◆ 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 9051 of file FEProblemBase.C.

Referenced by Coupleable::coupledGradientPreviousNL(), Coupleable::coupledNodalValuePreviousNL(), Coupleable::coupledSecondPreviousNL(), Coupleable::coupledValuePreviousNL(), and NonlinearSystem::solve().

9052 {
9054  mooseError("Previous nonlinear solution is required but not added through "
9055  "Problem/previous_nl_solution_required=true");
9056 }
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 9045 of file FEProblemBase.C.

9046 {
9048 }
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

◆ needToAddDefaultMultiAppFixedPointConvergence()

bool FEProblemBase::needToAddDefaultMultiAppFixedPointConvergence ( ) const
inlineinherited

Returns true if the problem needs to add the default fixed point convergence.

Definition at line 669 of file FEProblemBase.h.

670  {
672  }
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 664 of file FEProblemBase.h.

665  {
667  }
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 674 of file FEProblemBase.h.

675  {
677  }
bool _need_to_add_default_steady_state_convergence
Flag that the problem needs to add the default steady convergence.

◆ negativeSignEigenKernel()

bool EigenProblem::negativeSignEigenKernel ( ) const
inline

A flag indicates if a negative sign is used in eigen kernels.

If the negative sign is used, eigen kernels are consistent in nonlinear solver. In nonlinear solver, RHS kernels always have a negative sign.

Definition at line 57 of file EigenProblem.h.

Referenced by Moose::assemble_matrix(), Moose::SlepcSupport::mooseMatMult_Eigen(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionB(), and Moose::SlepcSupport::mooseSlepcEigenFormJacobianB().

bool _negative_sign_eigen_kernel
Whether or not use negative sign for Bx.
Definition: EigenProblem.h:246

◆ neighborSubdomainSetup()

void FEProblemBase::neighborSubdomainSetup ( SubdomainID  subdomain,
const THREAD_ID  tid 
)
virtualinherited

Definition at line 2534 of file FEProblemBase.C.

Referenced by ThreadedFaceLoop< RangeType >::neighborSubdomainChanged().

2535 {
2536  _all_materials.neighborSubdomainSetup(subdomain, tid);
2537 }
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(), 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 717 of file SubProblem.C.

718 {
719  mooseAssert(nl_sys_num < numNonlinearSystems(),
720  "The nonlinear system number is higher than the number of systems we have!");
721  return solverSystemConverged(nl_sys_num);
722 }
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 6809 of file FEProblemBase.C.

Referenced by PiecewiseLinearFromVectorPostprocessor::valueInternal().

6810 {
6811  return _nl[nl_sys_num]->nLinearIterations();
6812 }
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 6539 of file FEProblemBase.C.

Referenced by DisplacedProblem::nlSysNum().

6540 {
6541  std::istringstream ss(nl_sys_name);
6542  unsigned int nl_sys_num;
6543  if (!(ss >> nl_sys_num) || !ss.eof())
6544  nl_sys_num = libmesh_map_find(_nl_sys_name_to_num, nl_sys_name);
6545 
6546  return nl_sys_num;
6547 }
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 6803 of file FEProblemBase.C.

Referenced by PiecewiseLinearFromVectorPostprocessor::valueInternal().

6804 {
6805  return _nl[nl_sys_num]->nNonlinearIterations();
6806 }
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 6391 of file FEProblemBase.C.

Referenced by ComputeFullJacobianThread::computeOnBoundary(), and ComputeFullJacobianThread::computeOnElement().

6392 {
6393  return _assembly[tid][nl_sys]->nonlocalCouplingEntries();
6394 }
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 9690 of file FEProblemBase.C.

Referenced by DisplacedProblem::nonlocalCouplingMatrix().

9691 {
9692  return _nonlocal_cm[i];
9693 }
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 8471 of file FEProblemBase.C.

Referenced by MeshChangedInterface::MeshChangedInterface().

8472 {
8473  _notify_when_mesh_changes.push_back(mci);
8474 }
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 8477 of file FEProblemBase.C.

Referenced by MeshDisplacedInterface::MeshDisplacedInterface().

8478 {
8479  _notify_when_mesh_displaces.push_back(mdi);
8480 }
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 2428 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

2428 { _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 196 of file SubProblem.C.

Referenced by NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeResidualInternal(), ComputeResidualThread::determineObjectWarehouses(), MooseVariableDataBase< OutputType >::MooseVariableDataBase(), MooseVariableScalar::MooseVariableScalar(), DisplacedProblem::numVectorTags(), ComputeNodalKernelBcsThread::pre(), and ComputeNodalKernelsThread::pre().

197 {
198  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
199 
200  return getVectorTags(type).size();
201 }
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
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:173

◆ objectExecuteHelper()

template<typename T >
void FEProblemBase::objectExecuteHelper ( const std::vector< T *> &  objects)
staticinherited

Definition at line 3399 of file FEProblemBase.h.

3400 {
3401  for (T * obj_ptr : objects)
3402  obj_ptr->execute();
3403 }

◆ 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 3365 of file FEProblemBase.h.

3366 {
3367  if (exec_flag == EXEC_INITIAL)
3368  {
3369  for (T * obj_ptr : objects)
3370  obj_ptr->initialSetup();
3371  }
3372 
3373  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
3374  {
3375  for (const auto obj_ptr : objects)
3376  obj_ptr->timestepSetup();
3377  }
3378  else if (exec_flag == EXEC_SUBDOMAIN)
3379  {
3380  for (const auto obj_ptr : objects)
3381  obj_ptr->subdomainSetup();
3382  }
3383 
3384  else if (exec_flag == EXEC_NONLINEAR)
3385  {
3386  for (const auto obj_ptr : objects)
3387  obj_ptr->jacobianSetup();
3388  }
3389 
3390  else if (exec_flag == EXEC_LINEAR)
3391  {
3392  for (const auto obj_ptr : objects)
3393  obj_ptr->residualSetup();
3394  }
3395 }
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

◆ onLinearSolver() [1/2]

bool EigenProblem::onLinearSolver ( ) const
inline

◆ onLinearSolver() [2/2]

void EigenProblem::onLinearSolver ( bool  ols)
inline

Set a flag to indicate whether or not we are in a linear solver iteration.

Definition at line 202 of file EigenProblem.h.

202 { _on_linear_solver = ols; }
bool _on_linear_solver
Whether or not we are in linear solver.
Definition: EigenProblem.h:258

◆ 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 718 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

718 { return false; }

◆ onTimestepBegin()

void FEProblemBase::onTimestepBegin ( )
overridevirtualinherited

Implements SubProblem.

Definition at line 6963 of file FEProblemBase.C.

Referenced by MFEMTransient::takeStep(), and TransientBase::takeStep().

6964 {
6965  TIME_SECTION("onTimestepBegin", 2);
6966 
6967  for (auto & nl : _nl)
6968  nl->onTimestepBegin();
6969 }
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.

◆ onTimestepEnd()

void FEProblemBase::onTimestepEnd ( )
overridevirtualinherited

◆ outputInverseEigenvalue() [1/2]

bool EigenProblem::outputInverseEigenvalue ( ) const
inline

Whether or not to output eigenvalue inverse.

The inverse is useful for neutronics community

Definition at line 187 of file EigenProblem.h.

Referenced by Moose::SlepcSupport::mooseSlepcEPSMonitor().

187 { return _output_inverse_eigenvalue; }
bool _output_inverse_eigenvalue
Whether or not output eigenvalue as its inverse. By default, we output regular eigenvalue.
Definition: EigenProblem.h:256

◆ outputInverseEigenvalue() [2/2]

void EigenProblem::outputInverseEigenvalue ( bool  inverse)
inline

Set a flag to indicate whether or not to output eigenvalue inverse.

Definition at line 192 of file EigenProblem.h.

bool _output_inverse_eigenvalue
Whether or not output eigenvalue as its inverse. By default, we output regular eigenvalue.
Definition: EigenProblem.h:256
void inverse(const std::vector< std::vector< Real >> &m, std::vector< std::vector< Real >> &m_inv)
Inverse the dense square matrix m using LAPACK routines.
Definition: MatrixTools.C:23

◆ 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 6926 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().

6927 {
6928  TIME_SECTION("outputStep", 1, "Outputting");
6929 
6931 
6932  for (auto & sys : _solver_systems)
6933  sys->update();
6934  _aux->update();
6935 
6936  if (_displaced_problem)
6937  _displaced_problem->syncSolutions();
6939 
6941 }
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:2515

◆ 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(), 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(), AuxKernelBase::AuxKernelBase(), 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(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), 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(), 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(), SideSetsFromNodeSetsGenerator::generate(), AdvancedExtruderGenerator::generate(), BreakMeshByElementGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), GenericConstantStdVectorMaterialTempl< is_ad >::GenericConstantStdVectorMaterialTempl(), 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(), MFEMSumAux::MFEMSumAux(), 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(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), 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(), CSGOnlyAction::act(), AddActionComponentAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), MFEMProblem::addAuxVariable(), DisplacedProblem::addAuxVariable(), MFEMProblem::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(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), MFEMProblem::addVariable(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), 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(), 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(), AuxKernelBase::getVariableHelper(), 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(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblemBase::setAuxKernelParamsAndLog(), 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() [1/2]

template<typename... Args>
void SolutionInvalidInterface::paramWarning ( const std::string &  param,
Args...  args 
) const
inlineinherited

◆ paramWarning() [2/2]

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.

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 4683 of file FEProblemBase.C.

Referenced by TransientBase::parentOutputPositionChanged().

4684 {
4685  for (const auto & it : _multi_apps)
4686  {
4687  const auto & objects = it.second.getActiveObjects();
4688  for (const auto & obj : objects)
4689  obj->parentOutputPositionChanged();
4690  }
4691 }
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 2346 of file FEProblemBase.h.

Referenced by Eigenvalue::prepareSolverOptions().

2346 { return _petsc_option_data_base; }
PetscOptions _petsc_option_data_base

◆ petscOptionsInserted()

bool& FEProblemBase::petscOptionsInserted ( )
inlineinherited

If PETSc options are already inserted.

Definition at line 2343 of file FEProblemBase.h.

Referenced by Eigenvalue::prepareSolverOptions().

2343 { 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 8098 of file FEProblemBase.C.

Referenced by FEProblemBase::solve().

8099 {
8100  if (_displaced_problem) // Only need to do this if things are moving...
8101  {
8102  TIME_SECTION("possiblyRebuildGeomSearchPatches", 5, "Rebuilding Geometric Search Patches");
8103 
8104  switch (_mesh.getPatchUpdateStrategy())
8105  {
8106  case Moose::Never:
8107  break;
8108  case Moose::Iteration:
8109  // Update the list of ghosted elements at the start of the time step
8112 
8113  _displaced_problem->geomSearchData().updateGhostedElems();
8115 
8116  // The commands below ensure that the sparsity of the Jacobian matrix is
8117  // augmented at the start of the time step using neighbor nodes from the end
8118  // of the previous time step.
8119 
8121 
8122  // This is needed to reinitialize PETSc output
8124 
8125  break;
8126 
8127  case Moose::Auto:
8128  {
8129  Real max = _displaced_problem->geomSearchData().maxPatchPercentage();
8131 
8132  // If we haven't moved very far through the patch
8133  if (max < 0.4)
8134  break;
8135  }
8136  libmesh_fallthrough();
8137 
8138  // Let this fall through if things do need to be updated...
8139  case Moose::Always:
8140  // Flush output here to see the message before the reinitialization, which could take a
8141  // while
8142  _console << "\n\nUpdating geometric search patches\n" << std::endl;
8143 
8146 
8147  _displaced_problem->geomSearchData().clearNearestNodeLocators();
8149 
8151 
8152  // This is needed to reinitialize PETSc output
8154  }
8155  }
8156 }
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:1095
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:3434
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 5701 of file FEProblemBase.C.

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

5702 {
5703  const auto & multi_apps = _multi_apps.getActiveObjects();
5704 
5705  for (const auto & multi_app : multi_apps)
5706  multi_app->postExecute();
5707 }
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.

◆ postScaleEigenVector()

void EigenProblem::postScaleEigenVector ( )

Normalize eigen vector.

Scale eigen vector such as ||x|| = _normal_factor This might be useful when coupling to other physics

Definition at line 449 of file EigenProblem.C.

Referenced by solve().

450 {
451  if (_has_normalization)
452  {
453  Real v;
455  {
456  if (_active_eigen_index >= _nl_eigen->getNumConvergedEigenvalues())
457  mooseError("Number of converged eigenvalues ",
458  _nl_eigen->getNumConvergedEigenvalues(),
459  " but you required eigenvalue ",
461 
462  // when normal factor is not provided, we use the inverse of the norm of
463  // the active eigenvalue for normalization
464  auto eig = _nl_eigen->getAllConvergedEigenvalues()[_active_eigen_index];
465  v = 1 / std::sqrt(eig.first * eig.first + eig.second * eig.second);
466  }
467  else
468  v = _normal_factor;
469 
471 
472  // We scale SLEPc eigen vector here, so we need to scale it back for optimal
473  // convergence if we call EPS solver again
474  mooseAssert(v != 0., "normal factor can not be zero");
475 
476  unsigned int itr = 0;
477 
478  while (!MooseUtils::relativeFuzzyEqual(v, c))
479  {
480  // If postprocessor is not defined on eigen variables, scaling might not work
481  if (itr > 10)
482  mooseError("Can not scale eigenvector to the required factor ",
483  v,
484  " please check if postprocessor is defined on only eigen variables");
485 
486  mooseAssert(c != 0., "postprocessor value used for scaling can not be zero");
487 
488  scaleEigenvector(v / c);
489 
490  // update all aux variables and user objects on linear
492 
494 
495  itr++;
496  }
497  }
498 }
PostprocessorName _normalization
Postprocessor used to compute a factor from eigenvector.
Definition: EigenProblem.h:266
bool _has_normalization
Whether or not we normalize eigenvector.
Definition: EigenProblem.h:264
virtual void execute(const ExecFlagType &exec_type) override
Convenience function for performing execution of MOOSE systems.
Definition: EigenProblem.C:165
auto max(const L &left, const R &right)
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
unsigned int _active_eigen_index
Which eigenvalue is used to compute residual.
Definition: EigenProblem.h:249
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.
void scaleEigenvector(const Real scaling_factor)
Scale eigenvector.
Definition: EigenProblem.C:415
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
bool relativeFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within a relative tolerance.
Definition: MooseUtils.h:494
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
Real _normal_factor
Postprocessor target value.
Definition: EigenProblem.h:269

◆ 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 8005 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::setInitialSolution().

8006 {
8007 }

◆ 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 1859 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::reinitNodeFace(), and NonlinearSystemBase::setConstraintSecondaryValues().

1860 {
1861  _assembly[tid][_current_nl_sys->number()]->prepare();
1863  _assembly[tid][_current_nl_sys->number()]->prepareNonlocal();
1864 
1866  {
1867  _displaced_problem->prepareAssembly(tid);
1869  _displaced_problem->prepareNonlocal(tid);
1870  }
1871 }
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 1773 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onInterface(), and ComputeUserObjectsThread::onInternalSide().

1774 {
1775  for (auto & nl : _nl)
1776  nl->prepareFace(tid, true);
1777  _aux->prepareFace(tid, false);
1778 
1780  _displaced_problem->prepareFace(_displaced_mesh->elemPtr(elem->id()), tid);
1781 }
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:3134
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 2118 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onBoundary().

2119 {
2120  _assembly[tid][_current_nl_sys->number()]->copyFaceShapes(var);
2121 }
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 4126 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

4129 {
4130  std::set<MooseVariableFEBase *> needed_moose_vars;
4131  std::unordered_set<unsigned int> needed_mat_props;
4132 
4133  if (_all_materials.hasActiveBlockObjects(blk_id, tid))
4134  {
4135  _all_materials.updateVariableDependency(needed_moose_vars, tid);
4136  _all_materials.updateBlockMatPropDependency(blk_id, needed_mat_props, tid);
4137  }
4138 
4139  const auto & ids = _mesh.getSubdomainBoundaryIds(blk_id);
4140  for (const auto id : ids)
4141  {
4142  _materials.updateBoundaryVariableDependency(id, needed_moose_vars, tid);
4143  _materials.updateBoundaryMatPropDependency(id, needed_mat_props, tid);
4144  }
4145 
4146  const auto & current_active_elemental_moose_variables = getActiveElementalMooseVariables(tid);
4147  needed_moose_vars.insert(current_active_elemental_moose_variables.begin(),
4148  current_active_elemental_moose_variables.end());
4149 
4150  needed_mat_props.insert(consumer_needed_mat_props.begin(), consumer_needed_mat_props.end());
4151 
4152  setActiveElementalMooseVariables(needed_moose_vars, tid);
4153  setActiveMaterialProperties(needed_mat_props, tid);
4154 }
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:3518
virtual const std::set< MooseVariableFieldBase * > & getActiveElementalMooseVariables(const THREAD_ID tid) const
Get the MOOSE variables to be reinited on each element.
Definition: SubProblem.C:455
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 2124 of file FEProblemBase.C.

2125 {
2126  _assembly[tid][_current_nl_sys->number()]->copyNeighborShapes(var);
2127 }
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 1337 of file SubProblem.C.

Referenced by FEProblemBase::init().

1338 {
1339  std::unordered_set<FEFamily> disable_families;
1340  for (const auto & [family, flag] : _family_for_p_refinement)
1341  if (flag)
1342  disable_families.insert(family);
1343 
1344  for (const auto tid : make_range(libMesh::n_threads()))
1345  for (const auto s : make_range(numNonlinearSystems()))
1346  assembly(tid, s).havePRefinement(disable_families);
1347 
1348  auto & eq = es();
1349  for (const auto family : disable_families)
1350  for (const auto i : make_range(eq.n_systems()))
1351  {
1352  auto & system = eq.get_system(i);
1353  auto & dof_map = system.get_dof_map();
1354  for (const auto vg : make_range(system.n_variable_groups()))
1355  {
1356  const auto & var_group = system.variable_group(vg);
1357  if (var_group.type().family == family)
1358  dof_map.should_p_refine(vg, false);
1359  }
1360  }
1361 
1362  _have_p_refinement = true;
1363 }
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:1210
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:1207
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 2112 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onElement().

2113 {
2114  _assembly[tid][_current_nl_sys->number()]->copyShapes(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.

◆ preScaleEigenVector()

void EigenProblem::preScaleEigenVector ( const std::pair< Real, Real > &  eig)

Eigenvector need to be scaled back if it was scaled in an earlier stage Scaling eigen vector does not affect solution (eigenvalue, eigenvector), but it does affect the convergence rate.

To have an optimal convergence rate, We pre-scale eigen vector using the same factor as the one computed in "postScaleEigenVector"

Definition at line 433 of file EigenProblem.C.

Referenced by execute(), and solve().

434 {
435  // pre-scale the solution to make sure ||Bx||_2 is equal to inverse of eigenvalue
437  *_nl_eigen->currentSolution(), _nl_eigen->residualVectorBX(), _nl_eigen->eigenVectorTag());
438 
439  // Eigenvalue magnitude
440  Real v = std::sqrt(eig.first * eig.first + eig.second * eig.second);
441  // Scaling factor
442  Real factor = 1 / v / (bxNormProvided() ? formNorm() : _nl_eigen->residualVectorBX().l2_norm());
443  // Scale eigenvector
444  if (!MooseUtils::absoluteFuzzyEqual(factor, 1))
445  scaleEigenvector(factor);
446 }
virtual void computeResidualTag(const NumericVector< Number > &soln, NumericVector< Number > &residual, TagID tag) override
Form a vector for all kernels and BCs with a given tag.
Definition: EigenProblem.C:295
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:382
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
Real formNorm()
Form the Bx norm.
Definition: EigenProblem.C:693
void scaleEigenvector(const Real scaling_factor)
Scale eigenvector.
Definition: EigenProblem.C:415
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
bool bxNormProvided() const
Whether a Bx norm postprocessor has been provided.
Definition: EigenProblem.h:232

◆ 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 2164 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 3826 of file FEProblemBase.C.

Referenced by ElementSubdomainModifierBase::extrapolatePolynomial().

3837 {
3838  mooseAssert(!Threads::in_threads,
3839  "We're performing a projection based on data from just the thread 0 variable, so any "
3840  "modifications to the variable solution must have been thread joined already");
3841 
3842  const auto & var = getStandardVariable(0, target_var);
3843  const auto var_num = var.number();
3844  const auto sn = systemNumForVariable(target_var);
3845  auto & sys = getSystemBase(sn);
3846 
3847  // Let libmesh handle the projection
3848  System & libmesh_sys = getSystem(target_var);
3849  auto temp_vec = libmesh_sys.current_local_solution->zero_clone();
3850  libmesh_sys.project_vector(func, func_grad, params, *temp_vec);
3851  temp_vec->close();
3852 
3853  // Get the dof indices to copy
3854  DofMap & dof_map = sys.dofMap();
3855  std::set<dof_id_type> dof_indices;
3856  std::vector<dof_id_type> elem_dof_indices;
3857 
3858  for (const auto & elem : elem_range)
3859  {
3860  dof_map.dof_indices(elem, elem_dof_indices, var_num);
3861  dof_indices.insert(elem_dof_indices.begin(), elem_dof_indices.end());
3862  }
3863  std::vector<dof_id_type> dof_indices_v(dof_indices.begin(), dof_indices.end());
3864 
3865  // Copy the projected values into the solution vector
3866  std::vector<Real> dof_vals;
3867  temp_vec->get(dof_indices_v, dof_vals);
3868  mooseAssert(sys.solution().closed(),
3869  "The solution should be closed before mapping our projection");
3870  sys.solution().insert(dof_vals, dof_indices_v);
3871  sys.solution().close();
3872  sys.solution().localize(*libmesh_sys.current_local_solution, sys.dofMap().get_send_list());
3873 }
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 3751 of file FEProblemBase.C.

Referenced by ElementSubdomainModifierBase::applyIC(), and ActivateElementsUserObjectBase::initSolutions().

3755 {
3756  if (target_vars)
3757  {
3758  ComputeInitialConditionThread cic(*this, &(*target_vars));
3759  Threads::parallel_reduce(elem_range, cic);
3760  }
3761  else
3762  {
3763  ComputeInitialConditionThread cic(*this);
3764  Threads::parallel_reduce(elem_range, cic);
3765  }
3766 
3767  // Need to close the solution vector here so that boundary ICs take precendence
3768  for (auto & nl : _nl)
3769  nl->solution().close();
3770  _aux->solution().close();
3771 
3772  if (target_vars)
3773  {
3774  ComputeBoundaryInitialConditionThread cbic(*this, &(*target_vars));
3775  Threads::parallel_reduce(bnd_nodes, cbic);
3776  }
3777  else
3778  {
3780  Threads::parallel_reduce(bnd_nodes, cbic);
3781  }
3782 
3783  for (auto & nl : _nl)
3784  nl->solution().close();
3785  _aux->solution().close();
3786 
3787  // Also, load values into the SCALAR dofs
3788  // Note: We assume that all SCALAR dofs are on the
3789  // processor with highest ID
3790  if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects())
3791  {
3792  const auto & ics = _scalar_ics.getActiveObjects();
3793  for (const auto & ic : ics)
3794  {
3795  MooseVariableScalar & var = ic->variable();
3796 
3797  if (target_vars && !target_vars->count(var.name()))
3798  continue;
3799 
3800  var.reinit();
3801 
3802  DenseVector<Number> vals(var.order());
3803  ic->compute(vals);
3804 
3805  const unsigned int n_scalar_dofs = var.dofIndices().size();
3806  for (unsigned int i = 0; i < n_scalar_dofs; i++)
3807  {
3808  const auto global_index = var.dofIndices()[i];
3809  var.sys().solution().set(global_index, vals(i));
3810  var.setValue(i, vals(i));
3811  }
3812  }
3813  }
3814 
3815  for (auto & nl : _nl)
3816  {
3817  nl->solution().close();
3818  nl->solution().localize(*nl->system().current_local_solution, nl->dofMap().get_send_list());
3819  }
3820 
3821  _aux->solution().close();
3822  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
3823 }
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 3683 of file FEProblemBase.C.

Referenced by FEProblemBase::initialAdaptMesh(), and FEProblemBase::initialSetup().

3684 {
3685  TIME_SECTION("projectSolution", 2, "Projecting Initial Solutions")
3686 
3687  FloatingPointExceptionGuard fpe_guard(_app);
3688 
3689  ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
3690  ComputeInitialConditionThread cic(*this);
3691  Threads::parallel_reduce(elem_range, cic);
3692 
3693  if (haveFV())
3694  {
3696  ElemInfoRange elem_info_range(_mesh.ownedElemInfoBegin(), _mesh.ownedElemInfoEnd());
3697 
3698  ComputeFVInitialConditionThread cfvic(*this);
3699  Threads::parallel_reduce(elem_info_range, cfvic);
3700  }
3701 
3702  // Need to close the solution vector here so that boundary ICs take precendence
3703  for (auto & nl : _nl)
3704  nl->solution().close();
3705  _aux->solution().close();
3706 
3707  // now run boundary-restricted initial conditions
3708  ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
3710  Threads::parallel_reduce(bnd_nodes, cbic);
3711 
3712  for (auto & nl : _nl)
3713  nl->solution().close();
3714  _aux->solution().close();
3715 
3716  // Also, load values into the SCALAR dofs
3717  // Note: We assume that all SCALAR dofs are on the
3718  // processor with highest ID
3719  if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects())
3720  {
3721  const auto & ics = _scalar_ics.getActiveObjects();
3722  for (const auto & ic : ics)
3723  {
3724  MooseVariableScalar & var = ic->variable();
3725  var.reinit();
3726 
3727  DenseVector<Number> vals(var.order());
3728  ic->compute(vals);
3729 
3730  const unsigned int n_scalar_dofs = var.dofIndices().size();
3731  for (unsigned int i = 0; i < n_scalar_dofs; i++)
3732  {
3733  const auto global_index = var.dofIndices()[i];
3734  var.sys().solution().set(global_index, vals(i));
3735  var.setValue(i, vals(i));
3736  }
3737  }
3738  }
3739 
3740  for (auto & sys : _solver_systems)
3741  {
3742  sys->solution().close();
3743  sys->solution().localize(*sys->system().current_local_solution, sys->dofMap().get_send_list());
3744  }
3745 
3746  _aux->solution().close();
3747  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
3748 }
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

◆ registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal ( const std::string &  message,
const bool  warning 
) const
protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

57 {
59  _si_moose_base.type(), message, warning);
60 }
InvalidSolutionID registerInvalidity(const std::string &object_type, const std::string &message, const bool warning)
Call to register an invalid calculation.
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
SolutionInvalidityRegistry & getSolutionInvalidityRegistry()
Get the global SolutionInvalidityRegistry singleton.
const MooseBase & _si_moose_base
The MooseBase that owns this interface.

◆ registerRandomInterface()

void FEProblemBase::registerRandomInterface ( RandomInterface random_interface,
const std::string &  name 
)
inherited

Definition at line 8928 of file FEProblemBase.C.

Referenced by RandomInterface::setRandomResetFrequency().

8929 {
8930  auto insert_pair = moose_try_emplace(
8931  _random_data_objects, name, std::make_unique<RandomData>(*this, random_interface));
8932 
8933  auto random_data_ptr = insert_pair.first->second.get();
8934  random_interface.setRandomDataPointer(random_data_ptr);
8935 }
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:101
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 5337 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), FEProblemBase::meshChanged(), and FEProblemBase::possiblyRebuildGeomSearchPatches().

5338 {
5339  TIME_SECTION("reinitBecauseOfGhostingOrNewGeomObjects",
5340  3,
5341  "Reinitializing Because of Geometric Search Objects");
5342 
5343  // Need to see if _any_ processor has ghosted elems or geometry objects.
5344  bool needs_reinit = !_ghosted_elems.empty();
5345  needs_reinit = needs_reinit || !_geometric_search_data._nearest_node_locators.empty() ||
5346  (_mortar_data.hasObjects() && mortar_changed);
5347  needs_reinit =
5348  needs_reinit || (_displaced_problem &&
5349  (!_displaced_problem->geomSearchData()._nearest_node_locators.empty() ||
5350  (_mortar_data.hasDisplacedObjects() && mortar_changed)));
5351  _communicator.max(needs_reinit);
5352 
5353  if (needs_reinit)
5354  {
5355  // Call reinit to get the ghosted vectors correct now that some geometric search has been done
5356  es().reinit();
5357 
5358  if (_displaced_mesh)
5359  _displaced_problem->es().reinit();
5360  }
5361 }
const Parallel::Communicator & _communicator
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
Definition: SubProblem.h:1095
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 2163 of file FEProblemBase.C.

Referenced by ComputeDiracThread::onElement().

2164 {
2165  std::vector<Point> & points = _dirac_kernel_info.getPoints()[elem].first;
2166 
2167  unsigned int n_points = points.size();
2168 
2169  if (n_points)
2170  {
2171  if (n_points > _max_qps)
2172  {
2173  _max_qps = n_points;
2174 
2179  unsigned int max_qpts = getMaxQps();
2180  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
2181  {
2182  // the highest available order in libMesh is 43
2183  _scalar_zero[tid].resize(FORTYTHIRD, 0);
2184  _zero[tid].resize(max_qpts, 0);
2185  _grad_zero[tid].resize(max_qpts, RealGradient(0.));
2186  _second_zero[tid].resize(max_qpts, RealTensor(0.));
2187  _vector_zero[tid].resize(max_qpts, RealGradient(0.));
2188  _vector_curl_zero[tid].resize(max_qpts, RealGradient(0.));
2189  }
2190  }
2191 
2192  for (const auto i : index_range(_nl))
2193  {
2194  _assembly[tid][i]->reinitAtPhysical(elem, points);
2195  _nl[i]->prepare(tid);
2196  }
2197  _aux->prepare(tid);
2198 
2199  reinitElem(elem, tid);
2200  }
2201 
2202  _assembly[tid][_current_nl_sys->number()]->prepare();
2204  _assembly[tid][_current_nl_sys->number()]->prepareNonlocal();
2205 
2206  bool have_points = n_points > 0;
2208  {
2209  have_points |= _displaced_problem->reinitDirac(_displaced_mesh->elemPtr(elem->id()), tid);
2211  _displaced_problem->prepareNonlocal(tid);
2212  }
2213 
2214  return have_points;
2215 }
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:3134
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:1051
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 2218 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().

2219 {
2220  for (auto & sys : _solver_systems)
2221  sys->reinitElem(elem, tid);
2222  _aux->reinitElem(elem, tid);
2223 
2225  _displaced_problem->reinitElem(_displaced_mesh->elemPtr(elem->id()), tid);
2226 }
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:3134
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 9275 of file FEProblemBase.C.

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

9281 {
9282  SubProblem::reinitElemFaceRef(elem, side, tolerance, pts, weights, tid);
9283 
9284  if (_displaced_problem)
9285  _displaced_problem->reinitElemFaceRef(
9286  _displaced_mesh->elemPtr(elem->id()), side, tolerance, pts, weights, tid);
9287 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3134
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:883
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 2404 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInternalSide(), and NonlinearThread::onInternalSide().

2407 {
2408  reinitNeighbor(elem, side, tid);
2409 
2410  const Elem * lower_d_elem = _mesh.getLowerDElem(elem, side);
2411  if (lower_d_elem && _mesh.interiorLowerDBlocks().count(lower_d_elem->subdomain_id()) > 0)
2412  reinitLowerDElem(lower_d_elem, tid);
2413  else
2414  {
2415  // with mesh refinement, lower-dimensional element might be defined on neighbor side
2416  auto & neighbor = _assembly[tid][0]->neighbor();
2417  auto & neighbor_side = _assembly[tid][0]->neighborSide();
2418  const Elem * lower_d_elem_neighbor = _mesh.getLowerDElem(neighbor, neighbor_side);
2419  if (lower_d_elem_neighbor &&
2420  _mesh.interiorLowerDBlocks().count(lower_d_elem_neighbor->subdomain_id()) > 0)
2421  {
2422  auto qps = _assembly[tid][0]->qPointsFaceNeighbor().stdVector();
2423  std::vector<Point> reference_points;
2424  FEMap::inverse_map(
2425  lower_d_elem_neighbor->dim(), lower_d_elem_neighbor, qps, reference_points);
2426  reinitLowerDElem(lower_d_elem_neighbor, tid, &reference_points);
2427  }
2428  }
2429 
2431  _displaced_problem->reinitElemNeighborAndLowerD(
2432  _displaced_mesh->elemPtr(elem->id()), side, tid);
2433 }
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
const std::set< SubdomainID > & interiorLowerDBlocks() const
Definition: MooseMesh.h:1421
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3134
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 2229 of file FEProblemBase.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

2232 {
2233  mooseAssert(_mesh.queryElemPtr(elem->id()) == elem,
2234  "Are you calling this method with a displaced mesh element?");
2235 
2236  for (const auto i : index_range(_solver_systems))
2237  {
2238  _assembly[tid][i]->reinitAtPhysical(elem, phys_points_in_elem);
2239  _solver_systems[i]->prepare(tid);
2240  _assembly[tid][i]->prepare();
2242  _assembly[tid][i]->prepareNonlocal();
2243  }
2244  _aux->prepare(tid);
2245 
2246  reinitElem(elem, tid);
2247 }
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:3146
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 1289 of file SubProblem.C.

1290 {
1291  for (const auto nl : make_range(numNonlinearSystems()))
1292  assembly(tid, nl).reinitFVFace(fi);
1293 }
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 2277 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onBoundary(), NonlinearThread::prepareFace(), and FEProblemBase::reinitElemNeighborAndLowerD().

2281 {
2282  SubProblem::reinitLowerDElem(lower_d_elem, tid, pts, weights);
2283 
2285  _displaced_problem->reinitLowerDElem(
2286  _displaced_mesh->elemPtr(lower_d_elem->id()), tid, pts, weights);
2287 }
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:958
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3134
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 4157 of file FEProblemBase.C.

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

4158 {
4159  if (hasActiveMaterialProperties(tid))
4160  {
4161  auto && elem = _assembly[tid][0]->elem();
4162  unsigned int n_points = _assembly[tid][0]->qRule()->n_points();
4163 
4164  auto & material_data = _material_props.getMaterialData(tid);
4165  material_data.resize(n_points);
4166 
4167  // Only swap if requested
4168  if (swap_stateful)
4169  material_data.swap(*elem);
4170 
4171  if (_discrete_materials.hasActiveBlockObjects(blk_id, tid))
4172  material_data.reset(_discrete_materials.getActiveBlockObjects(blk_id, tid));
4173 
4174  if (_materials.hasActiveBlockObjects(blk_id, tid))
4175  material_data.reinit(_materials.getActiveBlockObjects(blk_id, tid));
4176  }
4177 }
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
reinit_matsspecific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4302 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), and NonlinearThread::prepareFace().

4306 {
4307  if (hasActiveMaterialProperties(tid) && needBoundaryMaterialOnSide(boundary_id, tid))
4308  {
4309  auto && elem = _assembly[tid][0]->elem();
4310  unsigned int side = _assembly[tid][0]->side();
4311  unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
4312 
4313  auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
4314  bnd_material_data.resize(n_points);
4315 
4316  if (swap_stateful && !bnd_material_data.isSwapped())
4317  bnd_material_data.swap(*elem, side);
4318 
4319  if (_discrete_materials.hasActiveBoundaryObjects(boundary_id, tid))
4320  bnd_material_data.reset(_discrete_materials.getActiveBoundaryObjects(boundary_id, tid));
4321 
4322  if (reinit_mats)
4323  bnd_material_data.reinit(*reinit_mats);
4324  else if (_materials.hasActiveBoundaryObjects(boundary_id, tid))
4325  bnd_material_data.reinit(_materials.getActiveBoundaryObjects(boundary_id, tid));
4326  }
4327 }
MaterialPropertyStorage & _bnd_material_props
bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
These methods are used to determine whether stateful material properties need to be stored on interna...
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
reinit_matsspecific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4180 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and NonlinearThread::prepareFace().

4184 {
4185  // we reinit more often than needed here because we dont have a way to check whether
4186  // we need to compute the face materials on a particular (possibly external) face
4187  if (hasActiveMaterialProperties(tid))
4188  {
4189  auto && elem = _assembly[tid][0]->elem();
4190  unsigned int side = _assembly[tid][0]->side();
4191  unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
4192 
4193  auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
4194  bnd_material_data.resize(n_points);
4195 
4196  if (swap_stateful && !bnd_material_data.isSwapped())
4197  bnd_material_data.swap(*elem, side);
4198 
4199  if (_discrete_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4200  bnd_material_data.reset(
4201  _discrete_materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4202 
4203  if (reinit_mats)
4204  bnd_material_data.reinit(*reinit_mats);
4205  else if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4206  bnd_material_data.reinit(
4207  _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4208  }
4209 }
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

◆ reinitMaterialsFaceOnBoundary()

void FEProblemBase::reinitMaterialsFaceOnBoundary ( const BoundaryID  boundary_id,
const SubdomainID  blk_id,
const THREAD_ID  tid,
const bool  swap_stateful = true,
const std::deque< MaterialBase *> *const  reinit_mats = nullptr 
)
inherited

reinit materials on element faces on a boundary (internal or external) This specific routine helps us not reinit when don't need to

Parameters
boundary_idThe boundary on which the face belongs
blk_idThe block id to which the element (who owns the face) belong
tidThe thread id
swap_statefulWhether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_matsspecific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4212 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), and NonlinearThread::prepareFace().

4217 {
4218  if (hasActiveMaterialProperties(tid) && (needBoundaryMaterialOnSide(boundary_id, tid) ||
4219  needInterfaceMaterialOnSide(boundary_id, tid) ||
4220  needInternalNeighborSideMaterial(blk_id, tid)))
4221  {
4222  const auto * const elem = _assembly[tid][0]->elem();
4223  unsigned int side = _assembly[tid][0]->side();
4224  unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
4225 
4226  auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
4227  bnd_material_data.resize(n_points);
4228 
4229  if (swap_stateful && !bnd_material_data.isSwapped())
4230  bnd_material_data.swap(*elem, side);
4231 
4232  if (_discrete_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4233  bnd_material_data.reset(
4234  _discrete_materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4235 
4236  if (reinit_mats)
4237  bnd_material_data.reinit(*reinit_mats);
4238  else if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4239  bnd_material_data.reinit(
4240  _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4241  }
4242 }
MaterialPropertyStorage & _bnd_material_props
bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
These methods are used to determine whether stateful material properties need to be stored on interna...
bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, const THREAD_ID tid)
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
MaterialWarehouse _discrete_materials
bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
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 4330 of file FEProblemBase.C.

Referenced by NonlinearThread::onInterface(), and ComputeUserObjectsThread::onInterface().

4333 {
4334  if (hasActiveMaterialProperties(tid) && needInterfaceMaterialOnSide(boundary_id, tid))
4335  {
4336  const Elem * const & elem = _assembly[tid][0]->elem();
4337  unsigned int side = _assembly[tid][0]->side();
4338  unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
4339 
4340  auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
4341  bnd_material_data.resize(n_points);
4342 
4343  if (swap_stateful && !bnd_material_data.isSwapped())
4344  bnd_material_data.swap(*elem, side);
4345 
4346  if (_interface_materials.hasActiveBoundaryObjects(boundary_id, tid))
4347  bnd_material_data.reinit(_interface_materials.getActiveBoundaryObjects(boundary_id, tid));
4348  }
4349 }
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
bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
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
reinit_matsspecific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4262 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), FEProblemBase::reinitMaterialsNeighborOnBoundary(), and NonlinearSystemBase::reinitNodeFace().

4266 {
4267  if (hasActiveMaterialProperties(tid))
4268  {
4269  // NOTE: this will not work with h-adaptivity
4270  // lindsayad: why not?
4271 
4272  const Elem * neighbor = _assembly[tid][0]->neighbor();
4273  unsigned int neighbor_side = neighbor->which_neighbor_am_i(_assembly[tid][0]->elem());
4274 
4275  mooseAssert(neighbor, "neighbor should be non-null");
4276  mooseAssert(blk_id == neighbor->subdomain_id(),
4277  "The provided blk_id " << blk_id << " and neighbor subdomain ID "
4278  << neighbor->subdomain_id() << " do not match.");
4279 
4280  unsigned int n_points = _assembly[tid][0]->qRuleNeighbor()->n_points();
4281 
4282  auto & neighbor_material_data = _neighbor_material_props.getMaterialData(tid);
4283  neighbor_material_data.resize(n_points);
4284 
4285  // Only swap if requested
4286  if (swap_stateful)
4287  neighbor_material_data.swap(*neighbor, neighbor_side);
4288 
4289  if (_discrete_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4290  neighbor_material_data.reset(
4291  _discrete_materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4292 
4293  if (reinit_mats)
4294  neighbor_material_data.reinit(*reinit_mats);
4295  else if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
4296  neighbor_material_data.reinit(
4297  _materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
4298  }
4299 }
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

◆ reinitMaterialsNeighborOnBoundary()

void FEProblemBase::reinitMaterialsNeighborOnBoundary ( const BoundaryID  boundary_id,
const SubdomainID  blk_id,
const THREAD_ID  tid,
const bool  swap_stateful = true,
const std::deque< MaterialBase *> *const  reinit_mats = nullptr 
)
inherited

reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specific routine helps us not reinit when don't need to

Parameters
boundary_idThe boundary on which the face belongs
blk_idThe block id to which the element (who owns the face) belong
tidThe thread id
swap_statefulWhether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_matsspecific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4245 of file FEProblemBase.C.

Referenced by NonlinearThread::onInterface().

4251 {
4252  // Since objects don't declare whether they need the face or neighbor (side) material properties,
4253  // we use the same criteria for skipping material property computations as for face material
4254  // properties This could be a future optimization.
4255  if (hasActiveMaterialProperties(tid) && (needBoundaryMaterialOnSide(boundary_id, tid) ||
4256  needInterfaceMaterialOnSide(boundary_id, tid) ||
4257  needInternalNeighborSideMaterial(blk_id, tid)))
4258  reinitMaterialsNeighbor(blk_id, tid, swap_stateful, reinit_mats);
4259 }
bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
These methods are used to determine whether stateful material properties need to be stored on interna...
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
bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, const THREAD_ID tid)
bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.

◆ 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 995 of file SubProblem.C.

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

996 {
997  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
998  assembly(tid, nl_sys_num).reinitMortarElem(elem);
999 }
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 9540 of file FEProblemBase.C.

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

9543 {
9544  const auto mortar_uos =
9545  getMortarUserObjects(primary_boundary_id, secondary_boundary_id, displaced);
9546  for (auto * const mortar_uo : mortar_uos)
9547  {
9548  mortar_uo->setNormals();
9549  mortar_uo->reinit();
9550  }
9551 }
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 2365 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInterface(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and FEProblemBase::reinitElemNeighborAndLowerD().

2366 {
2367  setNeighborSubdomainID(elem, side, tid);
2368 
2369  const Elem * neighbor = elem->neighbor_ptr(side);
2370  unsigned int neighbor_side = neighbor->which_neighbor_am_i(elem);
2371 
2372  for (const auto i : index_range(_nl))
2373  {
2374  _assembly[tid][i]->reinitElemAndNeighbor(elem, side, neighbor, neighbor_side);
2375  _nl[i]->prepareNeighbor(tid);
2376  // Called during stateful material property evaluation outside of solve
2377  _assembly[tid][i]->prepareNeighbor();
2378  }
2379  _aux->prepareNeighbor(tid);
2380 
2381  for (auto & nl : _nl)
2382  {
2383  nl->reinitElemFace(elem, side, tid);
2384  nl->reinitNeighborFace(neighbor, neighbor_side, tid);
2385  }
2386  _aux->reinitElemFace(elem, side, tid);
2387  _aux->reinitNeighborFace(neighbor, neighbor_side, tid);
2388 
2390  {
2391  // There are cases like for cohesive zone modeling without significant sliding where we cannot
2392  // use FEInterface::inverse_map in Assembly::reinitElemAndNeighbor in the displaced problem
2393  // because the physical points coming from the element don't actually lie on the neighbor.
2394  // Moreover, what's the point of doing another physical point inversion in other cases? We only
2395  // care about the reference points which we can just take from the undisplaced computation
2396  const auto & displaced_ref_pts = _assembly[tid][0]->qRuleNeighbor()->get_points();
2397 
2398  _displaced_problem->reinitNeighbor(
2399  _displaced_mesh->elemPtr(elem->id()), side, tid, &displaced_ref_pts);
2400  }
2401 }
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:3134
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 9290 of file FEProblemBase.C.

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

9296 {
9297  SubProblem::reinitNeighborFaceRef(neighbor_elem, neighbor_side, tolerance, pts, weights, tid);
9298 
9299  if (_displaced_problem)
9300  _displaced_problem->reinitNeighborFaceRef(
9301  _displaced_mesh->elemPtr(neighbor_elem->id()), neighbor_side, tolerance, pts, weights, tid);
9302 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3134
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:922
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 988 of file SubProblem.C.

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

989 {
990  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
991  assembly(tid, nl_sys_num).reinitNeighborLowerDElem(elem);
992 }
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 2290 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), NonlinearSystemBase::computeResidualInternal(), ComputeNodalUserObjectsThread::onNode(), ComputeNodalDampingThread::onNode(), ComputeNodalKernelsThread::onNode(), and ComputeNodalKernelJacobiansThread::onNode().

2291 {
2293  _displaced_problem->reinitNode(&_displaced_mesh->nodeRef(node->id()), tid);
2294 
2295  for (const auto i : index_range(_nl))
2296  {
2297  _assembly[tid][i]->reinit(node);
2298  _nl[i]->reinitNode(node, tid);
2299  }
2300  _aux->reinitNode(node, tid);
2301 }
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 2304 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().

2305 {
2307  _displaced_problem->reinitNodeFace(&_displaced_mesh->nodeRef(node->id()), bnd_id, tid);
2308 
2309  for (const auto i : index_range(_nl))
2310  {
2311  _assembly[tid][i]->reinit(node);
2312  _nl[i]->reinitNodeFace(node, bnd_id, tid);
2313  }
2314  _aux->reinitNodeFace(node, bnd_id, tid);
2315 }
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 2318 of file FEProblemBase.C.

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

2319 {
2321  _displaced_problem->reinitNodes(nodes, tid);
2322 
2323  for (auto & nl : _nl)
2324  nl->reinitNodes(nodes, tid);
2325  _aux->reinitNodes(nodes, tid);
2326 }
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 2329 of file FEProblemBase.C.

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

2330 {
2332  _displaced_problem->reinitNodesNeighbor(nodes, tid);
2333 
2334  for (auto & nl : _nl)
2335  nl->reinitNodesNeighbor(nodes, tid);
2336  _aux->reinitNodesNeighbor(nodes, tid);
2337 }
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 2357 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians(), NonlinearSystemBase::constraintJacobians(), and NonlinearThread::onElement().

2358 {
2359  _assembly[tid][_current_nl_sys->number()]->prepareOffDiagScalar();
2360  if (_displaced_problem)
2361  _displaced_problem->reinitOffDiagScalars(tid);
2362 }
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 2340 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().

2341 {
2342  TIME_SECTION("reinitScalars", 3, "Reinitializing Scalar Variables");
2343 
2345  _displaced_problem->reinitScalars(tid, reinit_for_derivative_reordering);
2346 
2347  for (auto & nl : _nl)
2348  nl->reinitScalars(tid, reinit_for_derivative_reordering);
2349  _aux->reinitScalars(tid, reinit_for_derivative_reordering);
2350 
2351  // This is called outside of residual/Jacobian call-backs
2352  for (auto & assembly : _assembly[tid])
2354 }
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 1068 of file SubProblem.C.

1069 {
1070  EquationSystems & eq = es();
1071  const auto n_sys = eq.n_systems();
1072  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
1073 
1074  const bool found_in_root_sys =
1076  nl_dof_map.algebraic_ghosting_functors_end(),
1077  &algebraic_gf) != nl_dof_map.algebraic_ghosting_functors_end();
1078 
1079 #ifndef NDEBUG
1080  const bool found_in_our_map =
1081  _root_alg_gf_to_sys_clones.find(&algebraic_gf) != _root_alg_gf_to_sys_clones.end();
1082  mooseAssert(found_in_root_sys == found_in_our_map,
1083  "If the ghosting functor exists in the root DofMap, then we need to have a key for "
1084  "it in our gf to clones map");
1085 #endif
1086 
1087  if (found_in_root_sys) // libMesh yells if we try to remove
1088  // something that's not there
1089  nl_dof_map.remove_algebraic_ghosting_functor(algebraic_gf);
1090 
1091  auto it = _root_alg_gf_to_sys_clones.find(&algebraic_gf);
1092  if (it == _root_alg_gf_to_sys_clones.end())
1093  return;
1094 
1095  auto & clones_vec = it->second;
1096  mooseAssert((n_sys - 1) == clones_vec.size(),
1097  "The size of the gf clones vector doesn't match the number of systems minus one");
1098  if (clones_vec.empty())
1099  {
1100  mooseAssert(n_sys == 1, "The clones vector should only be empty if there is only one system");
1101  return;
1102  }
1103 
1104  for (const auto i : make_range(n_sys))
1105  eq.get_system(i + 1).get_dof_map().remove_algebraic_ghosting_functor(*clones_vec[i]);
1106 
1107  _root_alg_gf_to_sys_clones.erase(it->first);
1108 }
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:1197
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 1111 of file SubProblem.C.

1112 {
1113  EquationSystems & eq = es();
1114  const auto num_nl_sys = numNonlinearSystems();
1115  if (!num_nl_sys)
1116  return;
1117 
1118  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
1119  const bool found_in_root_sys = std::find(nl_dof_map.coupling_functors_begin(),
1120  nl_dof_map.coupling_functors_end(),
1121  &coupling_gf) != nl_dof_map.coupling_functors_end();
1122 
1123 #ifndef NDEBUG
1124  const bool found_in_our_map =
1126  mooseAssert(found_in_root_sys == found_in_our_map,
1127  "If the ghosting functor exists in the root DofMap, then we need to have a key for "
1128  "it in our gf to clones map");
1129 #endif
1130 
1131  if (found_in_root_sys) // libMesh yells if we try to remove
1132  // something that's not there
1133  nl_dof_map.remove_coupling_functor(coupling_gf);
1134 
1135  auto it = _root_coupling_gf_to_sys_clones.find(&coupling_gf);
1136  if (it == _root_coupling_gf_to_sys_clones.end())
1137  return;
1138 
1139  auto & clones_vec = it->second;
1140  mooseAssert((num_nl_sys - 1) == clones_vec.size(),
1141  "The size of the gf clones vector doesn't match the number of systems minus one");
1142  if (clones_vec.empty())
1143  {
1144  mooseAssert(num_nl_sys == 1,
1145  "The clones vector should only be empty if there is only one nonlinear system");
1146  return;
1147  }
1148 
1149  for (const auto i : make_range(num_nl_sys))
1150  eq.get_system(i + 1).get_dof_map().remove_coupling_functor(*clones_vec[i]);
1151 
1152  _root_coupling_gf_to_sys_clones.erase(it->first);
1153 }
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:1204
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 5331 of file FEProblemBase.C.

5332 {
5333  //<< "Object " << a->name() << " -> " << b->name() << std::endl;
5334 }

◆ resetFailNextNonlinearConvergenceCheck()

void FEProblemBase::resetFailNextNonlinearConvergenceCheck ( )
inlineinherited

Tell the problem that the nonlinear convergence check(s) may proceed as normal.

Definition at line 2620 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 2622 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 9440 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::residualSetup().

9441 {
9443  // We need to setup all the nonlinear systems other than our current one which actually called
9444  // this method (so we have to make sure we don't go in a circle)
9445  for (const auto i : make_range(numNonlinearSystems()))
9446  if (i != currentNlSysNum())
9447  _nl[i]->residualSetup();
9448  // We don't setup the aux sys because that's been done elsewhere
9449  if (_displaced_problem)
9450  _displaced_problem->residualSetup();
9451 }
virtual std::size_t numNonlinearSystems() const override
virtual void residualSetup()
Definition: SubProblem.C:1204
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 9361 of file FEProblemBase.C.

9364 {
9365  getMaterialData(data_type, tid).resize(nqp);
9366 }
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 5766 of file FEProblemBase.C.

Referenced by TransientBase::incrementStepOrReject(), and FixedPointSolve::solve().

5767 {
5768  const auto & multi_apps = _multi_apps[type].getActiveObjects();
5769 
5770  if (multi_apps.size())
5771  {
5772  if (_verbose_multiapps)
5773  {
5774  if (force)
5775  _console << COLOR_CYAN << "\nRestoring Multiapps on " << type.name()
5776  << " because of solve failure!" << COLOR_DEFAULT << std::endl;
5777  else
5778  _console << COLOR_CYAN << "\nRestoring MultiApps on " << type.name() << COLOR_DEFAULT
5779  << std::endl;
5780  }
5781 
5782  for (const auto & multi_app : multi_apps)
5783  multi_app->restore(force);
5784 
5786 
5787  if (_verbose_multiapps)
5788  _console << COLOR_CYAN << "Finished Restoring MultiApps on " << type.name() << "\n"
5789  << COLOR_DEFAULT << std::endl;
5790  }
5791 }
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:327
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 6916 of file FEProblemBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

6917 {
6918  TIME_SECTION("restoreOldSolutions", 5, "Restoring Old Solutions");
6919 
6920  for (auto & sys : _solver_systems)
6921  sys->restoreOldSolutions();
6922  _aux->restoreOldSolutions();
6923 }
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 2144 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 6878 of file FEProblemBase.C.

Referenced by ActivateElementsUserObjectBase::initSolutions(), TimeStepper::rejectStep(), and FEProblemBase::updateMeshXFEM().

6879 {
6880  TIME_SECTION("restoreSolutions", 5, "Restoring Solutions");
6881 
6882  if (!_not_zeroed_tagged_vectors.empty())
6883  paramError("not_zeroed_tag_vectors",
6884  "There is currently no way to restore not-zeroed vectors.");
6885 
6886  for (auto & sys : _solver_systems)
6887  {
6888  if (_verbose_restore)
6889  _console << "Restoring solutions on system " << sys->name() << "..." << std::endl;
6890  sys->restoreSolutions();
6891  }
6892 
6893  if (_verbose_restore)
6894  _console << "Restoring solutions on Auxiliary system..." << std::endl;
6895  _aux->restoreSolutions();
6896 
6897  if (_verbose_restore)
6898  _console << "Restoring postprocessor, vector-postprocessor, and reporter data..." << std::endl;
6900 
6901  if (_displaced_problem)
6902  _displaced_problem->updateMesh();
6903 }
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:1119
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:1110

◆ 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:1113

◆ saveOldSolutions()

void FEProblemBase::saveOldSolutions ( )
virtualinherited

Allocate vectors and save old solutions into them.

Definition at line 6906 of file FEProblemBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

6907 {
6908  TIME_SECTION("saveOldSolutions", 5, "Saving Old Solutions");
6909 
6910  for (auto & sys : _solver_systems)
6911  sys->saveOldSolutions();
6912  _aux->saveOldSolutions();
6913 }
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.

◆ scaleEigenvector()

void EigenProblem::scaleEigenvector ( const Real  scaling_factor)

Scale eigenvector.

Scaling_factor is often computed based on physics.

Definition at line 415 of file EigenProblem.C.

Referenced by postScaleEigenVector(), and preScaleEigenVector().

416 {
417  adjustEigenVector(scaling_factor, true);
418 }
void adjustEigenVector(const Real value, bool scaling)
Adjust eigen vector by either scaling the existing values or setting new values The operations are ap...
Definition: EigenProblem.C:389

◆ 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 301 of file SubProblem.C.

Referenced by FEProblemBase::computeLinearSystemSys().

304 {
305  selected_tags.clear();
306  for (const auto & matrix_tag_pair : input_matrix_tags)
307  if (system.hasMatrix(matrix_tag_pair.second))
308  selected_tags.insert(matrix_tag_pair.second);
309 }
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 290 of file SubProblem.C.

Referenced by FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeResidualAndJacobian(), and ComputeResidualAndJacobianThread::determineObjectWarehouses().

293 {
294  selected_tags.clear();
295  for (const auto & vector_tag : input_vector_tags)
296  if (system.hasVector(vector_tag._id))
297  selected_tags.insert(vector_tag._id);
298 }
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 6053 of file FEProblemBase.C.

Referenced by FEProblemBase::prepareMaterials(), ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeDiracThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

6055 {
6057 
6058  if (_displaced_problem)
6059  _displaced_problem->setActiveElementalMooseVariables(moose_vars, tid);
6060 }
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:444
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 6015 of file FEProblemBase.C.

6016 {
6018 
6019  if (_displaced_problem)
6020  _displaced_problem->setActiveFEVariableCoupleableMatrixTags(mtags, tid);
6021 }
virtual void setActiveFEVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid)
Definition: SubProblem.C:364
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 6108 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), FEProblemBase::prepareMaterials(), NodalPatchRecovery::reinitPatch(), NonlinearSystemBase::setConstraintSecondaryValues(), and ComputeDiracThread::subdomainChanged().

6110 {
6111  // mark active properties in every material
6112  for (auto & mat : _all_materials.getObjects(tid))
6113  mat->setActiveProperties(mat_prop_ids);
6114  for (auto & mat : _all_materials[Moose::FACE_MATERIAL_DATA].getObjects(tid))
6115  mat->setActiveProperties(mat_prop_ids);
6116  for (auto & mat : _all_materials[Moose::NEIGHBOR_MATERIAL_DATA].getObjects(tid))
6117  mat->setActiveProperties(mat_prop_ids);
6118 
6119  _has_active_material_properties[tid] = !mat_prop_ids.empty();
6120 }
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 6033 of file FEProblemBase.C.

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

6035 {
6037 
6038  if (_displaced_problem)
6039  _displaced_problem->setActiveScalarVariableCoupleableMatrixTags(mtags, tid);
6040 }
virtual void setActiveScalarVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid)
Definition: SubProblem.C:403
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 6043 of file FEProblemBase.C.

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

6045 {
6047 
6048  if (_displaced_problem)
6049  _displaced_problem->setActiveScalarVariableCoupleableVectorTags(vtags, tid);
6050 }
virtual void setActiveScalarVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid)
Definition: SubProblem.C:410
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:4234

◆ setBxNorm()

void EigenProblem::setBxNorm ( const PostprocessorName &  bx_norm)
inline

Set the Bx norm postprocessor programatically.

Definition at line 237 of file EigenProblem.h.

237 { _bx_norm_name = bx_norm; }
std::optional< PostprocessorName > _bx_norm_name
The name of the Postprocessor providing the Bx norm.
Definition: EigenProblem.h:289

◆ setChainControlDataOutput()

void SubProblem::setChainControlDataOutput ( bool  set_output)
inlineinherited

Setter for debug chain control data output.

Definition at line 926 of file SubProblem.h.

926 { _show_chain_control_data = set_output; }
bool _show_chain_control_data
Whether to output a list of all the chain control data.
Definition: SubProblem.h:1169

◆ 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 1992 of file FEProblemBase.h.

Referenced by ExplicitEuler::preSolve(), ExplicitTVDRK2::preSolve(), and ExplicitRK2::preSolve().

1992 { _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:4102

◆ 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 6284 of file FEProblemBase.C.

Referenced by FEProblemBase::init(), FEProblemBase::setCouplingMatrix(), and Moose::SlepcSupport::setEigenProblemSolverParams().

6285 {
6287  {
6289  mooseError("Someone told us (the FEProblemBase) to trust the user coupling matrix, but we "
6290  "haven't been provided a coupling matrix!");
6291 
6292  // We've been told to trust the user coupling matrix, so we're going to leave things alone
6293  return;
6294  }
6295 
6296  _coupling = type;
6297 }
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 6308 of file FEProblemBase.C.

Referenced by MoosePreconditioner::setCouplingMatrix().

6309 {
6311  _cm[i] = std::move(cm);
6312 }
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 6300 of file FEProblemBase.C.

6301 {
6302  // TODO: Deprecate method
6304  _cm[i].reset(cm);
6305 }
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 9657 of file FEProblemBase.C.

9658 {
9659  if (!range)
9660  {
9662  return;
9663  }
9664 
9665  _current_algebraic_bnd_node_range = std::make_unique<ConstBndNodeRange>(*range);
9666 }
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 9635 of file FEProblemBase.C.

9636 {
9637  if (!range)
9638  {
9640  return;
9641  }
9642 
9643  _current_algebraic_elem_range = std::make_unique<ConstElemRange>(*range);
9644 }
std::unique_ptr< libMesh::ConstElemRange > _current_algebraic_elem_range

◆ setCurrentAlgebraicNodeRange()

void FEProblemBase::setCurrentAlgebraicNodeRange ( libMesh::ConstNodeRange range)
inherited

Definition at line 9646 of file FEProblemBase.C.

9647 {
9648  if (!range)
9649  {
9651  return;
9652  }
9653 
9654  _current_algebraic_node_range = std::make_unique<ConstNodeRange>(*range);
9655 }
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 9571 of file FEProblemBase.C.

9572 {
9574  if (_displaced_problem)
9575  _displaced_problem->setCurrentBoundaryID(bid, tid);
9576 }
virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid)
sets the current boundary ID in assembly
Definition: SubProblem.C:790
std::shared_ptr< DisplacedProblem > _displaced_problem

◆ setCurrentExecuteOnFlag()

void FEProblemBase::setCurrentExecuteOnFlag ( const ExecFlagType flag)
inherited

Definition at line 4782 of file FEProblemBase.C.

Referenced by FEProblemBase::execute(), FEProblemBase::initialSetup(), and FEProblemBase::outputStep().

4783 {
4784  _current_execute_on_flag = flag;
4785 }
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 9588 of file FEProblemBase.C.

Referenced by FEProblemBase::computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and FEProblemBase::solveLinearSystem().

9589 {
9590  mooseAssert(sys_num < _linear_systems.size(),
9591  "System number greater than the number of linear systems");
9592  _current_linear_sys = _linear_systems[sys_num].get();
9594 }
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 9562 of file FEProblemBase.C.

9563 {
9564  SubProblem::setCurrentLowerDElem(lower_d_elem, tid);
9565  if (_displaced_problem)
9566  _displaced_problem->setCurrentLowerDElem(
9567  lower_d_elem ? _displaced_mesh->elemPtr(lower_d_elem->id()) : nullptr, tid);
9568 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:3134
virtual void setCurrentLowerDElem(const Elem *const lower_d_elem, const THREAD_ID tid)
Set the current lower dimensional element.
Definition: SubProblem.C:1385
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:1098

◆ 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 9242 of file FEProblemBase.C.

Referenced by FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualTags(), and FEProblemBase::resetState().

9243 {
9244  if (_displaced_problem)
9245  _displaced_problem->setCurrentlyComputingResidual(currently_computing_residual);
9246  _currently_computing_residual = currently_computing_residual;
9247 }
std::shared_ptr< DisplacedProblem > _displaced_problem
bool _currently_computing_residual
Whether the residual is being evaluated.
Definition: SubProblem.h:1107

◆ 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 1498 of file SubProblem.h.

Referenced by FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

1500 {
1501  _currently_computing_residual_and_jacobian = currently_computing_residual_and_jacobian;
1502 }
bool _currently_computing_residual_and_jacobian
Flag to determine whether the problem is currently computing the residual and Jacobian.
Definition: SubProblem.h:1101

◆ setCurrentNonlinearSystem()

void FEProblemBase::setCurrentNonlinearSystem ( const unsigned int  nl_sys_num)
inherited

Definition at line 9579 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobian(), computeJacobianAB(), computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), computeJacobianTag(), computeMatricesTags(), computeResidualTag(), NonlinearSystemBase::computeResidualTags(), FEProblem::FEProblem(), solve(), and FEProblemBase::solve().

9580 {
9581  mooseAssert(nl_sys_num < _nl.size(),
9582  "System number greater than the number of nonlinear systems");
9583  _current_nl_sys = _nl[nl_sys_num].get();
9585 }
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 3546 of file FEProblemBase.h.

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and CrankNicolson::init().

3547 {
3549 }
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:173

◆ setCurrentSubdomainID()

void FEProblemBase::setCurrentSubdomainID ( const Elem elem,
const THREAD_ID  tid 
)
overridevirtualinherited

Implements SubProblem.

Definition at line 1820 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementalVariableValue::execute(), and ComputeInitialConditionThread::operator()().

1821 {
1822  SubdomainID did = elem->subdomain_id();
1823  for (const auto i : index_range(_solver_systems))
1824  {
1825  _assembly[tid][i]->setCurrentSubdomainID(did);
1826  if (_displaced_problem &&
1828  _displaced_problem->assembly(tid, i).setCurrentSubdomainID(did);
1829  }
1830 }
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)

◆ setEigenproblemType()

void EigenProblem::setEigenproblemType ( Moose::EigenProblemType  eigen_problem_type)

Set eigen problem type.

Don't need to use this if we use Newton eigenvalue solver.

Referenced by Eigenvalue::Eigenvalue().

◆ setErrorOnJacobianNonzeroReallocation()

void FEProblemBase::setErrorOnJacobianNonzeroReallocation ( bool  state)
inlineinherited

Definition at line 2155 of file FEProblemBase.h.

2156  {
2158  }
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 6658 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().

6659 {
6660  _has_exception = true;
6661  _exception_message = message;
6662 }
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 2628 of file FEProblemBase.h.

2628 { _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 2615 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 2617 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 { _show_functors = set_output; }
bool _show_functors
Whether to output a list of the functors used and requested (currently only at initialSetup) ...
Definition: SubProblem.h:1166

◆ setIgnoreZerosInJacobian()

void FEProblemBase::setIgnoreZerosInJacobian ( bool  state)
inlineinherited

Set whether the zeros in the Jacobian should be dropped from the sparsity pattern.

Definition at line 2178 of file FEProblemBase.h.

2178 { _ignore_zeros_in_jacobian = state; }
bool _ignore_zeros_in_jacobian
Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.

◆ setInitialEigenvalue()

void EigenProblem::setInitialEigenvalue ( const Real  initial_eigenvalue)
inline

Set an initial eigenvalue for initial normalization.

Definition at line 69 of file EigenProblem.h.

Referenced by Eigenvalue::Eigenvalue().

70  {
71  _initial_eigenvalue = initial_eigenvalue;
72  }
Real _initial_eigenvalue
A value used for initial normalization.
Definition: EigenProblem.h:273

◆ setInputParametersFEProblem()

virtual void FEProblemBase::setInputParametersFEProblem ( InputParameters parameters)
inlinevirtualinherited

Reimplemented in FEProblem.

Definition at line 915 of file FEProblemBase.h.

Referenced by FEProblem::setInputParametersFEProblem().

916  {
917  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
918  }
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 1998 of file FEProblemBase.h.

1998 { _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 2004 of file FEProblemBase.h.

2005  {
2007  }
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 9406 of file FEProblemBase.C.

Referenced by FEProblemSolve::FEProblemSolve().

9407 {
9408  if (convergence_names.size() != numLinearSystems())
9409  paramError("linear_convergence", "There must be one convergence object per linear system");
9410  _linear_convergence_names = convergence_names;
9411 }
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 2015 of file FEProblemBase.h.

2015 { _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 2023 of file FEProblemBase.h.

2024  {
2026  }
CoverageCheckMode _material_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active material...

◆ setMultiAppFixedPointConvergenceName()

void FEProblemBase::setMultiAppFixedPointConvergenceName ( const ConvergenceName &  convergence_name)
inherited

Sets the MultiApp fixed point convergence object name if there is one.

Definition at line 9378 of file FEProblemBase.C.

Referenced by FixedPointSolve::FixedPointSolve().

9379 {
9380  _multiapp_fixed_point_convergence_name = convergence_name;
9381 }
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 684 of file FEProblemBase.h.

Referenced by FixedPointSolve::FixedPointSolve().

685  {
687  }
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 679 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

680  {
682  }
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 689 of file FEProblemBase.h.

Referenced by TransientBase::TransientBase().

690  {
692  }
bool _need_to_add_default_steady_state_convergence
Flag that the problem needs to add the default steady convergence.

◆ setNEigenPairsRequired()

void EigenProblem::setNEigenPairsRequired ( unsigned int  n_eigen_pairs)
inline

Definition at line 38 of file EigenProblem.h.

Referenced by Moose::SlepcSupport::setEigenProblemSolverParams().

39  {
40  _n_eigen_pairs_required = n_eigen_pairs;
41  }
unsigned int _n_eigen_pairs_required
Definition: EigenProblem.h:240

◆ 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 9369 of file FEProblemBase.C.

Referenced by FEProblemSolve::FEProblemSolve().

9370 {
9371  if (convergence_names.size() != numNonlinearSystems())
9372  paramError("nonlinear_convergence",
9373  "There must be one convergence object per nonlinear system");
9374  _nonlinear_convergence_names = convergence_names;
9375 }
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 6325 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

6326 {
6327  TIME_SECTION("setNonlocalCouplingMatrix", 5, "Setting Nonlocal Coupling Matrix");
6328 
6329  if (_nl.size() > 1)
6330  mooseError("Nonlocal kernels are weirdly stored on the FEProblem so we don't currently support "
6331  "multiple nonlinear systems with nonlocal kernels.");
6332 
6333  for (const auto nl_sys_num : index_range(_nl))
6334  {
6335  auto & nl = _nl[nl_sys_num];
6336  auto & nonlocal_cm = _nonlocal_cm[nl_sys_num];
6337  unsigned int n_vars = nl->nVariables();
6338  nonlocal_cm.resize(n_vars);
6339  const auto & vars = nl->getVariables(0);
6340  const auto & nonlocal_kernel = _nonlocal_kernels.getObjects();
6341  const auto & nonlocal_integrated_bc = _nonlocal_integrated_bcs.getObjects();
6342  for (const auto & ivar : vars)
6343  {
6344  for (const auto & kernel : nonlocal_kernel)
6345  {
6346  for (unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
6347  if (i == kernel->variable().number())
6348  for (const auto & jvar : vars)
6349  {
6350  const auto it = _var_dof_map.find(jvar->name());
6351  if (it != _var_dof_map.end())
6352  {
6353  unsigned int j = jvar->number();
6354  nonlocal_cm(i, j) = 1;
6355  }
6356  }
6357  }
6358  for (const auto & integrated_bc : nonlocal_integrated_bc)
6359  {
6360  for (unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
6361  if (i == integrated_bc->variable().number())
6362  for (const auto & jvar : vars)
6363  {
6364  const auto it = _var_dof_map.find(jvar->name());
6365  if (it != _var_dof_map.end())
6366  {
6367  unsigned int j = jvar->number();
6368  nonlocal_cm(i, j) = 1;
6369  }
6370  }
6371  }
6372  }
6373  }
6374 }
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

◆ setNormalization()

void EigenProblem::setNormalization ( const PostprocessorName &  pp,
const Real  value = std::numeric_limits<Real>::max() 
)

Set postprocessor and normalization factor 'Postprocessor' is often used to compute an integral of physics variables.

Definition at line 630 of file EigenProblem.C.

Referenced by Eigenvalue::Eigenvalue().

631 {
632  _has_normalization = true;
633  _normalization = pp;
635 }
PostprocessorName _normalization
Postprocessor used to compute a factor from eigenvector.
Definition: EigenProblem.h:266
bool _has_normalization
Whether or not we normalize eigenvector.
Definition: EigenProblem.h:264
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
Real _normal_factor
Postprocessor target value.
Definition: EigenProblem.h:269

◆ setParallelBarrierMessaging()

void FEProblemBase::setParallelBarrierMessaging ( bool  flag)
inlineinherited

Toggle parallel barrier messaging (defaults to on).

Definition at line 2031 of file FEProblemBase.h.

2031 { _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 4640 of file FEProblemBase.C.

Referenced by MultiAppPostprocessorTransfer::execute(), PIDTransientControl::execute(), FEProblemBase::joinAndFinalize(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), and PicardSolve::transformPostprocessors().

4643 {
4645  PostprocessorReporterName(name), value, t_index);
4646 }
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 3950 of file FEProblemBase.C.

3951 {
3952  if (_ignore_zeros_in_jacobian && preserve)
3953  paramWarning(
3954  "ignore_zeros_in_jacobian",
3955  "We likely cannot preserve the sparsity pattern if ignoring zeros in the Jacobian, which "
3956  "leads to removing those entries from the Jacobian sparsity pattern");
3958 }
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

◆ 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 1954 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals().

1955 {
1956  _assembly[tid][_current_nl_sys->number()]->setResidual(
1957  residual,
1959  getVectorTag(_nl[_current_nl_sys->number()]->residualVectorTag()));
1960  if (_displaced_problem)
1961  _displaced_problem->setResidual(residual, tid);
1962 }
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:162
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 1965 of file FEProblemBase.C.

1966 {
1967  _assembly[tid][_current_nl_sys->number()]->setResidualNeighbor(
1969  if (_displaced_problem)
1970  _displaced_problem->setResidualNeighbor(residual, tid);
1971 }
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:162
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 8881 of file FEProblemBase.C.

Referenced by Executioner::Executioner(), and FEProblemBase::FEProblemBase().

8882 {
8883  if (_app.isRecovering())
8884  {
8885  mooseInfo("Restart file ", file_name, " is NOT being used since we are performing recovery.");
8886  }
8887  else
8888  {
8889  _app.setRestart(true);
8890  _app.setRestartRecoverFileBase(file_name);
8891  mooseInfo("Using ", file_name, " for restart.");
8892  }
8893 }
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:2985
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:1874

◆ 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 2317 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

2318  {
2319  _snesmf_reuse_base = reuse, _snesmf_reuse_base_set_by_user = set_by_user;
2320  }
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 9384 of file FEProblemBase.C.

Referenced by TransientBase::TransientBase().

9385 {
9386  _steady_state_convergence_name = convergence_name;
9387 }
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 2365 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

2366  {
2367  _u_dotdot_old_requested = u_dotdot_old_requested;
2368  }
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 2353 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

2354  {
2355  _u_dotdot_requested = u_dotdot_requested;
2356  }
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 2359 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

2360  {
2361  _u_dot_old_requested = u_dot_old_requested;
2362  }
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 2350 of file FEProblemBase.h.

Referenced by TimeIntegrator::TimeIntegrator().

2350 { _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 5388 of file FEProblemBase.C.

5389 {
5390  for (auto & nl : _nl)
5391  nl->setupDampers();
5392 }
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 1728 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), and FEProblemBase::meshChanged().

1729 {
1730  for (unsigned int i = 0; i < moose_vars.size(); ++i)
1731  {
1732  VariableName var_name = moose_vars[i]->name();
1733  auto & sys = _solver_systems[moose_vars[i]->sys().number()];
1734  sys->setVariableGlobalDoFs(var_name);
1735  _var_dof_map[var_name] = sys->getVariableGlobalDoFs();
1736  }
1737 }
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 4666 of file FEProblemBase.C.

4670 {
4672  VectorPostprocessorReporterName(object_name, vector_name), value, t_index);
4673 }
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 9554 of file FEProblemBase.C.

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

9555 {
9556  _verbose_setup = verbose ? "true" : "false";
9557  _verbose_multiapps = verbose;
9558  _verbose_restore = verbose;
9559 }
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 9496 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().

9497 {
9498  // For now, only support printing from thread 0
9499  if (tid != 0)
9500  return false;
9501 
9504  return true;
9505  else
9506  return false;
9507 }
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 2401 of file FEProblemBase.h.

Referenced by ExternalProblem::solve(), FEProblemSolve::solve(), MFEMProblemSolve::solve(), and TransientBase::TransientBase().

2401 { 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 7992 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck(), and NonlinearSystem::solve().

7993 {
7994  return false;
7995 }

◆ showInvalidSolutionConsole()

bool FEProblemBase::showInvalidSolutionConsole ( ) const
inlineinherited

Whether or not to print out the invalid solutions summary table in console.

Definition at line 2195 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 2156 of file FEProblemBase.C.

2157 {
2158  mooseDoOnce(mooseWarning(
2159  "This function is deprecated and no longer performs any function. Please do not call it."));
2160 }
void mooseWarning(Args &&... args) const

◆ 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 2330 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

2331  {
2332  _skip_exception_check = skip_exception_check;
2333  }
bool _skip_exception_check
If or not skip &#39;exception and stop solve&#39;.

◆ solve()

void EigenProblem::solve ( const unsigned int  nl_sys_num)
overridevirtual

Reimplemented from FEProblemBase.

Definition at line 541 of file EigenProblem.C.

542 {
543 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
544  // Master has the default database
545  if (!_app.isUltimateMaster())
546  LibmeshPetscCall(PetscOptionsPush(_petsc_option_data_base));
547 #endif
548 
549  setCurrentNonlinearSystem(nl_sys_num);
550 
551  if (_solve)
552  {
553  TIME_SECTION("solve", 1);
554 
555  // Set necessary slepc callbacks
556  // We delay this call as much as possible because libmesh
557  // could rebuild matrices due to mesh changes or something else.
558  _nl_eigen->attachSLEPcCallbacks();
559 
560  // If there is an eigenvalue, we scale 1/|Bx| to eigenvalue
561  if (_active_eigen_index < _nl_eigen->getNumConvergedEigenvalues())
562  {
563  std::pair<Real, Real> eig = _nl_eigen->getConvergedEigenvalue(_active_eigen_index);
564  preScaleEigenVector(eig);
565  }
566 
567  if (isNonlinearEigenvalueSolver(nl_sys_num) &&
568  solverParams(nl_sys_num)._eigen_solve_type != Moose::EST_NONLINEAR_POWER)
569  {
570  // Let do an initial solve if a nonlinear eigen solver but not power is used.
571  // The initial solver is a Inverse Power, and it is used to compute a good initial
572  // guess for Newton
573  if (solverParams(nl_sys_num)._free_power_iterations && _first_solve)
574  {
575  _console << std::endl << " -------------------------------" << std::endl;
576  _console << " Free power iteration starts ..." << std::endl;
577  _console << " -------------------------------" << std::endl << std::endl;
578  doFreeNonlinearPowerIterations(solverParams(nl_sys_num)._free_power_iterations);
579  _first_solve = false;
580  }
581 
582  // Let us do extra power iterations here if necessary
583  if (solverParams(nl_sys_num)._extra_power_iterations)
584  {
585  _console << std::endl << " --------------------------------------" << std::endl;
586  _console << " Extra Free power iteration starts ..." << std::endl;
587  _console << " --------------------------------------" << std::endl << std::endl;
588  doFreeNonlinearPowerIterations(solverParams(nl_sys_num)._extra_power_iterations);
589  }
590  }
591 
592  // We print this for only nonlinear solver
593  if (isNonlinearEigenvalueSolver(nl_sys_num))
594  {
595  _console << std::endl << " -------------------------------------" << std::endl;
596 
597  if (solverParams(nl_sys_num)._eigen_solve_type != Moose::EST_NONLINEAR_POWER)
598  _console << " Nonlinear Newton iteration starts ..." << std::endl;
599  else
600  _console << " Nonlinear power iteration starts ..." << std::endl;
601 
602  _console << " -------------------------------------" << std::endl << std::endl;
603  }
604 
607 
608  // with PJFNKMO solve type, we need to evaluate the linear objects to bring them up-to-date
609  if (solverParams(nl_sys_num)._eigen_solve_type == Moose::EST_PJFNKMO)
611 
612  // Scale eigen vector if users ask
614  }
615 
616 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
617  if (!_app.isUltimateMaster())
618  LibmeshPetscCall(PetscOptionsPop());
619 #endif
620 
621  // sync solutions in displaced problem
622  if (_displaced_problem)
623  _displaced_problem->syncSolutions();
624 
625  // Reset the matrix flag, so that we reform matrix in next picard iteration
626  _matrices_formed = false;
627 }
bool _matrices_formed
Whether or not matrices had been formed.
Definition: EigenProblem.h:260
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:820
The same as PJFNK except that matrix-vector multiplication is employed to replace residual evaluation...
Definition: MooseTypes.h:864
virtual void execute(const ExecFlagType &exec_type) override
Convenience function for performing execution of MOOSE systems.
Definition: EigenProblem.C:165
PetscOptions _petsc_option_data_base
void doFreeNonlinearPowerIterations(unsigned int free_power_iterations)
Do some free/extra power iterations.
Definition: EigenProblem.C:518
void preScaleEigenVector(const std::pair< Real, Real > &eig)
Eigenvector need to be scaled back if it was scaled in an earlier stage Scaling eigen vector does not...
Definition: EigenProblem.C:433
bool isNonlinearEigenvalueSolver(unsigned int eigen_sys_num) const
Definition: EigenProblem.C:676
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
void update()
Update the system (doing libMesh magic)
Definition: SystemBase.C:1243
bool & _first_solve
A flag to indicate if it is the first time calling the solve.
Definition: EigenProblem.h:271
const bool & _solve
Whether or not to actually solve the nonlinear system.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:357
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
Nonlinear inverse power.
Definition: MooseTypes.h:861
unsigned int _active_eigen_index
Which eigenvalue is used to compute residual.
Definition: EigenProblem.h:249
virtual void solve() override=0
Solve the system (using libMesh magic)
void postScaleEigenVector()
Normalize eigen vector.
Definition: EigenProblem.C:449
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.
std::shared_ptr< DisplacedProblem > _displaced_problem
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.

◆ 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 6754 of file FEProblemBase.C.

Referenced by FEProblemSolve::solve().

6756 {
6757  TIME_SECTION("solve", 1, "Solving", false);
6758 
6759  setCurrentLinearSystem(linear_sys_num);
6760 
6761  const Moose::PetscSupport::PetscOptions & options = po ? *po : _petsc_options;
6762  auto & solver_params = _solver_params[numNonlinearSystems() + linear_sys_num];
6763 
6764  // Set custom convergence criteria
6766 
6767 #if PETSC_RELEASE_LESS_THAN(3, 12, 0)
6768  LibmeshPetscCall(Moose::PetscSupport::petscSetOptions(
6769  options, solver_params)); // Make sure the PETSc options are setup for this app
6770 #else
6771  // Now this database will be the default
6772  // Each app should have only one database
6773  if (!_app.isUltimateMaster())
6774  LibmeshPetscCall(PetscOptionsPush(_petsc_option_data_base));
6775 
6776  // We did not add PETSc options to database yet
6778  {
6779  Moose::PetscSupport::petscSetOptions(options, solver_params, this);
6781  }
6782 #endif
6783 
6784  if (_solve)
6786 
6787 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
6788  if (!_app.isUltimateMaster())
6789  LibmeshPetscCall(PetscOptionsPop());
6790 #endif
6791 }
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:312
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 8913 of file FEProblemBase.C.

Referenced by NonlinearEigenSystem::attachPreconditioner(), SolverSystem::compute(), SlepcEigenSolverConfiguration::configure_solver(), Eigenvalue::Eigenvalue(), ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), ExplicitTimeIntegrator::init(), init(), FEProblemBase::init(), 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(), solve(), FEProblemBase::solverParams(), solverTypeString(), FEProblemBase::solverTypeString(), and Moose::SlepcSupport::storeSolveType().

8914 {
8915  mooseAssert(solver_sys_num < numSolverSystems(),
8916  "Solver system number '" << solver_sys_num << "' is out of bounds. We have '"
8917  << numSolverSystems() << "' solver systems");
8918  return _solver_params[solver_sys_num];
8919 }
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 8922 of file FEProblemBase.C.

8923 {
8924  return const_cast<FEProblemBase *>(this)->solverParams(solver_sys_num);
8925 }
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 6561 of file FEProblemBase.C.

Referenced by FEProblemBase::addVariable(), FEProblemBase::getSystemBase(), MultiSystemSolveObject::MultiSystemSolveObject(), and DisplacedProblem::solverSysNum().

6562 {
6563  std::istringstream ss(solver_sys_name);
6564  unsigned int solver_sys_num;
6565  if (!(ss >> solver_sys_num) || !ss.eof())
6566  {
6567  const auto & search = _solver_sys_name_to_num.find(solver_sys_name);
6568  if (search == _solver_sys_name_to_num.end())
6569  mooseError("The solver system number was requested for system '" + solver_sys_name,
6570  "' but this system does not exist in the Problem. Systems can be added to the "
6571  "problem using the 'nl_sys_names'/'linear_sys_names' parameter.\nSystems in the "
6572  "Problem: " +
6574  solver_sys_num = search->second;
6575  }
6576 
6577  return solver_sys_num;
6578 }
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 EigenProblem::solverSystemConverged ( const unsigned int  sys_num)
overridevirtual
Returns
whether the given solver system sys_num is converged

Reimplemented from FEProblemBase.

Definition at line 667 of file EigenProblem.C.

668 {
669  if (_solve)
670  return _nl_eigen->converged();
671  else
672  return true;
673 }
std::shared_ptr< NonlinearEigenSystem > _nl_eigen
Definition: EigenProblem.h:242
const bool & _solve
Whether or not to actually solve the nonlinear system.

◆ solverTypeString()

std::string EigenProblem::solverTypeString ( unsigned int  solver_sys_num = 0)
overridevirtual

Return solver type as a human readable string.

Reimplemented from FEProblemBase.

Definition at line 702 of file EigenProblem.C.

703 {
704  return Moose::stringify(solverParams(solver_sys_num)._eigen_solve_type);
705 }
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.

◆ startedInitialSetup()

virtual bool FEProblemBase::startedInitialSetup ( )
inlinevirtualinherited

Returns true if we are in or beyond the initialSetup stage.

Definition at line 536 of file FEProblemBase.h.

Referenced by NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), and MaterialPropertyInterface::checkExecutionStage().

536 { 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 616 of file SubProblem.C.

Referenced by MaterialPropertyInterface::checkMaterialProperty().

619 {
620  _map_boundary_material_props_check[boundary_id].insert(std::make_pair(requestor, name));
621 }
std::map< BoundaryID, std::multimap< std::string, std::string > > _map_boundary_material_props_check
Definition: SubProblem.h:1073
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 590 of file SubProblem.C.

Referenced by MaterialBase::registerPropName().

591 {
592  _map_boundary_material_props[boundary_id].insert(name);
593 }
std::map< BoundaryID, std::set< std::string > > _map_boundary_material_props
Map for boundary material properties (boundary_id -> list of properties)
Definition: SubProblem.h:1057
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 602 of file SubProblem.C.

Referenced by MaterialBase::storeBoundaryZeroMatProp().

603 {
604  _zero_boundary_material_props[boundary_id].insert(name);
605 }
std::map< BoundaryID, std::set< MaterialPropertyName > > _zero_boundary_material_props
Definition: SubProblem.h:1061
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 608 of file SubProblem.C.

Referenced by MaterialPropertyInterface::checkMaterialProperty().

611 {
612  _map_block_material_props_check[block_id].insert(std::make_pair(requestor, name));
613 }
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:1072

◆ 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 584 of file SubProblem.C.

Referenced by MaterialBase::registerPropName().

585 {
586  _map_block_material_props[block_id].insert(name);
587 }
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:1054

◆ 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 596 of file SubProblem.C.

Referenced by MaterialBase::storeSubdomainZeroMatProp().

597 {
598  _zero_block_material_props[block_id].insert(name);
599 }
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:1060

◆ subdomainSetup()

void FEProblemBase::subdomainSetup ( SubdomainID  subdomain,
const THREAD_ID  tid 
)
virtualinherited

Definition at line 2519 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeDiracThread::subdomainChanged(), NonlinearThread::subdomainChanged(), ComputeUserObjectsThread::subdomainChanged(), and ThreadedFaceLoop< RangeType >::subdomainChanged().

2520 {
2521  _all_materials.subdomainSetup(subdomain, tid);
2522  // Call the subdomain methods of the output system, these are not threaded so only call it once
2523  if (tid == 0)
2525 
2526  for (auto & nl : _nl)
2527  nl->subdomainSetup(subdomain, tid);
2528 
2529  // FIXME: call displaced_problem->subdomainSetup() ?
2530  // When adding possibility with materials being evaluated on displaced mesh
2531 }
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:2515

◆ 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 2073 of file FEProblemBase.h.

Referenced by FEProblemBase::computeNearNullSpace(), FEProblemBase::computeNullSpace(), and FEProblemBase::computeTransposeNullSpace().

2074  {
2075  if (_subspace_dim.count(prefix))
2076  return _subspace_dim.find(prefix)->second;
2077  else
2078  return 0;
2079  }
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 4352 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), LineMaterialSamplerBase< Real >::execute(), ComputeMarkerThread::onElement(), ComputeElemAuxVarsThread< AuxKernelType >::onElement(), ComputeIndicatorThread::onElement(), NonlinearThread::onElement(), and ComputeUserObjectsThread::onElement().

4353 {
4354  auto && elem = _assembly[tid][0]->elem();
4356 }
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 4359 of file FEProblemBase.C.

Referenced by NonlinearThread::onBoundary(), ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

4360 {
4361  auto && elem = _assembly[tid][0]->elem();
4362  unsigned int side = _assembly[tid][0]->side();
4363  _bnd_material_props.getMaterialData(tid).swapBack(*elem, side);
4364 }
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 4367 of file FEProblemBase.C.

Referenced by NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

4368 {
4369  // NOTE: this will not work with h-adaptivity
4370  const Elem * neighbor = _assembly[tid][0]->neighbor();
4371  unsigned int neighbor_side =
4372  neighbor ? neighbor->which_neighbor_am_i(_assembly[tid][0]->elem()) : libMesh::invalid_uint;
4373 
4374  if (!neighbor)
4375  {
4376  if (haveFV())
4377  {
4378  // If neighbor is null, then we're on the neighbor side of a mesh boundary, e.g. we're off
4379  // the mesh in ghost-land. If we're using the finite volume method, then variable values and
4380  // consequently material properties have well-defined values in this ghost region outside of
4381  // the mesh and we really do want to reinit our neighbor materials in this case. Since we're
4382  // off in ghost land it's safe to do swaps with `MaterialPropertyStorage` using the elem and
4383  // elem_side keys
4384  neighbor = _assembly[tid][0]->elem();
4385  neighbor_side = _assembly[tid][0]->side();
4386  mooseAssert(neighbor, "We should have an appropriate value for elem coming from Assembly");
4387  }
4388  else
4389  mooseError("neighbor is null in Assembly!");
4390  }
4391 
4392  _neighbor_material_props.getMaterialData(tid).swapBack(*neighbor, neighbor_side);
4393 }
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

◆ systemBaseAuxiliary() [1/2]

const SystemBase & FEProblemBase::systemBaseAuxiliary ( ) const
overridevirtualinherited

Return the auxiliary system object as a base class reference.

Implements SubProblem.

Definition at line 9220 of file FEProblemBase.C.

Referenced by PhysicsBase::copyVariablesFromMesh(), and MFEMProblem::getAuxVariableNames().

9221 {
9222  return *_aux;
9223 }
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.

◆ systemBaseAuxiliary() [2/2]

SystemBase & FEProblemBase::systemBaseAuxiliary ( )
overridevirtualinherited

Implements SubProblem.

Definition at line 9226 of file FEProblemBase.C.

9227 {
9228  return *_aux;
9229 }
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 9188 of file FEProblemBase.C.

9189 {
9190  mooseAssert(sys_num < _linear_systems.size(),
9191  "System number greater than the number of linear systems");
9192  return *_linear_systems[sys_num];
9193 }
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 9196 of file FEProblemBase.C.

9197 {
9198  mooseAssert(sys_num < _linear_systems.size(),
9199  "System number greater than the number of linear systems");
9200  return *_linear_systems[sys_num];
9201 }
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 9174 of file FEProblemBase.C.

9175 {
9176  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
9177  return *_nl[sys_num];
9178 }
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 9181 of file FEProblemBase.C.

9182 {
9183  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
9184  return *_nl[sys_num];
9185 }
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 9204 of file FEProblemBase.C.

9205 {
9206  mooseAssert(sys_num < _solver_systems.size(),
9207  "System number greater than the number of solver systems");
9208  return *_solver_systems[sys_num];
9209 }
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 9212 of file FEProblemBase.C.

9213 {
9214  mooseAssert(sys_num < _solver_systems.size(),
9215  "System number greater than the number of solver systems");
9216  return *_solver_systems[sys_num];
9217 }
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 6581 of file FEProblemBase.C.

Referenced by FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

6582 {
6583  for (const auto & solver_sys : _solver_systems)
6584  if (solver_sys->hasVariable(variable_name))
6585  return solver_sys->number();
6586  mooseAssert(_aux, "Should have an auxiliary system");
6587  if (_aux->hasVariable(variable_name))
6588  return _aux->number();
6589 
6590  mooseError("Variable '",
6591  variable_name,
6592  "' was not found in any solver (nonlinear/linear) or auxiliary system");
6593 }
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 2312 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::needInternalNeighborSideMaterial(), JSONOutput::outputReporters(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), ComputeLinearFVElementalThread::setupSystemContributionObjects(), ComputeLinearFVFaceThread::setupSystemContributionObjects(), NonlinearThread::subdomainChanged(), NonlinearSystemBase::timestepSetup(), and FEProblemBase::timestepSetup().

2312 { 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 1535 of file FEProblemBase.C.

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

1536 {
1538 
1539  if (_t_step > 1 && _num_grid_steps)
1540  {
1541  libMesh::MeshRefinement mesh_refinement(_mesh);
1542  std::unique_ptr<libMesh::MeshRefinement> displaced_mesh_refinement(nullptr);
1543  if (_displaced_mesh)
1544  displaced_mesh_refinement = std::make_unique<libMesh::MeshRefinement>(*_displaced_mesh);
1545 
1546  for (MooseIndex(_num_grid_steps) i = 0; i < _num_grid_steps; ++i)
1547  {
1548  if (_displaced_problem)
1549  // If the DisplacedProblem is active, undisplace the DisplacedMesh in preparation for
1550  // refinement. We can't safely refine the DisplacedMesh directly, since the Hilbert keys
1551  // computed on the inconsistenly-displaced Mesh are different on different processors,
1552  // leading to inconsistent Hilbert keys. We must do this before the undisplaced Mesh is
1553  // coarsensed, so that the element and node numbering is still consistent. We also have to
1554  // make sure this is done during every step of coarsening otherwise different partitions
1555  // will be generated for the reference and displaced meshes (even for replicated)
1556  _displaced_problem->undisplaceMesh();
1557 
1558  mesh_refinement.uniformly_coarsen();
1559  if (_displaced_mesh)
1560  displaced_mesh_refinement->uniformly_coarsen();
1561 
1562  // Mark this as an intermediate change because we do not yet want to reinit_systems. E.g. we
1563  // need things to happen in the following order for the undisplaced problem:
1564  // u1) EquationSystems::reinit_solutions. This will restrict the solution vectors and then
1565  // contract the mesh
1566  // u2) MooseMesh::meshChanged. This will update the node/side lists and other
1567  // things which needs to happen after the contraction
1568  // u3) GeometricSearchData::reinit. Once the node/side lists are updated we can perform our
1569  // geometric searches which will aid in determining sparsity patterns
1570  //
1571  // We do these things for the displaced problem (if it exists)
1572  // d1) EquationSystems::reinit. Restrict the displaced problem vector copies and then contract
1573  // the mesh. It's safe to do a full reinit with the displaced because there are no
1574  // matrices that sparsity pattern calculations will be conducted for
1575  // d2) MooseMesh::meshChanged. This will update the node/side lists and other
1576  // things which needs to happen after the contraction
1577  // d3) UpdateDisplacedMeshThread::operator(). Re-displace the mesh using the *displaced*
1578  // solution vector copy because we don't know the state of the reference solution vector.
1579  // It's safe to use the displaced copy because we are outside of a non-linear solve,
1580  // and there is no concern about differences between solution and current_local_solution
1581  // d4) GeometricSearchData::reinit. With the node/side lists updated and the mesh
1582  // re-displaced, we can perform our geometric searches, which will aid in determining the
1583  // sparsity pattern of the matrix held by the libMesh::ImplicitSystem held by the
1584  // NonlinearSystem held by this
1585  meshChanged(
1586  /*intermediate_change=*/true, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
1587  }
1588 
1589  // u4) Now that all the geometric searches have been done (both undisplaced and displaced),
1590  // we're ready to update the sparsity pattern
1591  es().reinit_systems();
1592  }
1593 
1594  if (_line_search)
1595  _line_search->timestepSetup();
1596 
1597  // Random interface objects
1598  for (const auto & it : _random_data_objects)
1599  it.second->updateSeeds(EXEC_TIMESTEP_BEGIN);
1600 
1601  unsigned int n_threads = libMesh::n_threads();
1602  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1603  {
1606  }
1607 
1608  _aux->timestepSetup();
1609  for (auto & sys : _solver_systems)
1610  sys->timestepSetup();
1611 
1612  if (_displaced_problem)
1613  // timestepSetup for displaced systems
1614  _displaced_problem->timestepSetup();
1615 
1616  for (THREAD_ID tid = 0; tid < n_threads; tid++)
1617  {
1620  _markers.timestepSetup(tid);
1621  }
1622 
1623  std::vector<UserObject *> userobjs;
1624  theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(userobjs);
1625  for (auto obj : userobjs)
1626  obj->timestepSetup();
1627 
1628  // Timestep setup of output objects
1630 
1633  _has_nonlocal_coupling = true;
1634 }
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:1186
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:2515
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 551 of file FEProblemBase.h.

Referenced by EigenExecutionerBase::EigenExecutionerBase(), and TransientBase::TransientBase().

551 { _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 6315 of file FEProblemBase.C.

Referenced by SingleMatrixPreconditioner::SingleMatrixPreconditioner().

6316 {
6318  mooseError("Someone told us (the FEProblemBase) to trust the user coupling matrix, but we "
6319  "haven't been provided a coupling matrix!");
6320 
6322 }
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(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addObject(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addTimeIntegrator(), MooseServer::addValuesToList(), DisplacedProblem::addVectorTag(), SubProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelBase::AuxKernelBase(), 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(), MeshGenerator::generateInternalCSG(), 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(), LinearFVAdvection::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVDiffusion::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MFEMProblem::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 2388 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

2389  {
2391  mooseError("FEProblemBase: When requesting old second time derivative of solution, current "
2392  "second time derivation of solution should also be stored. Please set "
2393  "`u_dotdot_requested` to true using setUDotDotRequested.");
2394  return _u_dotdot_old_requested;
2395  }
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 2374 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors(), and FEProblemBase::addTimeIntegrator().

2374 { 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 2377 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

2378  {
2380  mooseError("FEProblemBase: When requesting old time derivative of solution, current time "
2381  "derivative of solution should also be stored. Please set `u_dot_requested` to "
2382  "true using setUDotRequested.");
2383 
2384  return _u_dot_old_requested;
2385  }
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 2371 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

2371 { 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 9250 of file FEProblemBase.C.

Referenced by FEProblemSolve::solve().

9251 {
9252  // ResetDisplacedMeshThread::onNode looks up the reference mesh by ID, so we need to make sure
9253  // we undisplace before adapting the reference mesh
9254  if (_displaced_problem)
9255  _displaced_problem->undisplaceMesh();
9256 
9258  if (_displaced_problem)
9260 
9261  meshChanged(
9262  /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
9263 }
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 5300 of file FEProblemBase.C.

Referenced by MooseEigenSystem::eigenKernelOnCurrent(), MooseEigenSystem::eigenKernelOnOld(), MFEMProblemSolve::solve(), and FixedPointSolve::solveStep().

5301 {
5302  TIME_SECTION("updateActiveObjects", 5, "Updating Active Objects");
5303 
5304  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
5305  {
5306  for (auto & nl : _nl)
5307  nl->updateActive(tid);
5308  _aux->updateActive(tid);
5311  _markers.updateActive(tid);
5313  _materials.updateActive(tid);
5315  }
5316 
5324 
5325 #ifdef MOOSE_KOKKOS_ENABLED
5327 #endif
5328 }
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 8019 of file FEProblemBase.C.

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

8020 {
8021  TIME_SECTION("updateGeometricSearch", 3, "Updating Geometric Search");
8022 
8024 
8025  if (_displaced_problem)
8026  _displaced_problem->updateGeomSearch(type);
8027 }
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 8286 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), and FixedPointSolve::solveStep().

8287 {
8288  TIME_SECTION("updateMeshXFEM", 5, "Updating XFEM");
8289 
8290  bool updated = false;
8291  if (haveXFEM())
8292  {
8293  if (_xfem->updateHeal())
8294  // XFEM exodiff tests rely on a given numbering because they cannot use map = true due to
8295  // having coincident elements. While conceptually speaking we do not need to contract the
8296  // mesh, we need its call to renumber_nodes_and_elements in order to preserve these tests
8297  meshChanged(
8298  /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/false);
8299 
8300  updated = _xfem->update(_time, _nl, *_aux);
8301  if (updated)
8302  {
8303  meshChanged(
8304  /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/false);
8305  _xfem->initSolution(_nl, *_aux);
8306  restoreSolutions();
8307  _console << "\nXFEM update complete: Mesh modified" << std::endl;
8308  }
8309  else
8310  _console << "\nXFEM update complete: Mesh not modified" << std::endl;
8311  }
8312  return updated;
8313 }
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()
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.

◆ updateMortarMesh()

void FEProblemBase::updateMortarMesh ( )
virtualinherited

Definition at line 8030 of file FEProblemBase.C.

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::init(), FEProblemBase::initialSetup(), and FEProblemBase::meshChanged().

8031 {
8032  TIME_SECTION("updateMortarMesh", 5, "Updating Mortar Mesh");
8033 
8034  FloatingPointExceptionGuard fpe_guard(_app);
8035 
8036  _mortar_data.update();
8037 }
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 7998 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck().

8000 {
8001  return false;
8002 }

◆ useSNESMFReuseBase()

bool FEProblemBase::useSNESMFReuseBase ( )
inlineinherited

Return a flag that indicates if we are reusing the vector base.

Definition at line 2325 of file FEProblemBase.h.

Referenced by NonlinearSystem::potentiallySetupFiniteDifferencing().

2325 { return _snesmf_reuse_base; }
bool _snesmf_reuse_base
If or not to resuse the base vector for matrix-free calculation.

◆ validParams()

InputParameters EigenProblem::validParams ( )
static

Definition at line 35 of file EigenProblem.C.

36 {
38  params.addClassDescription("Problem object for solving an eigenvalue problem.");
39  params.addParam<bool>("negative_sign_eigen_kernel",
40  true,
41  "Whether or not to use a negative sign for eigenvalue kernels. "
42  "Using a negative sign makes eigenvalue kernels consistent with "
43  "a nonlinear solver");
44 
45  params.addParam<unsigned int>(
46  "active_eigen_index",
47  0,
48  "Which eigenvector is used to compute residual and also associated to nonlinear variable");
49  params.addParam<PostprocessorName>("bx_norm", "A postprocessor describing the norm of Bx");
50 
51  params.addParamNamesToGroup("negative_sign_eigen_kernel active_eigen_index bx_norm",
52  "Eigenvalue solve");
53 
54  return params;
55 }
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...
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
static InputParameters validParams()
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...

◆ 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 137 of file SubProblem.C.

138 {
139  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
140 
141  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
142  for (const auto & vector_tag : _vector_tags)
143  if (vector_tag._name == tag_name_upper)
144  return true;
145 
146  return false;
147 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1172
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
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 222 of file SubProblem.C.

Referenced by SystemBase::closeTaggedVector(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), SystemBase::removeVector(), NonlinearSystemBase::residualGhosted(), DisplacedProblem::vectorTagName(), and SystemBase::zeroTaggedVector().

223 {
224  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
225  if (!vectorTagExists(tag_id))
226  mooseError("Vector tag with ID ", tag_id, " does not exist");
227 
228  return _vector_tags[tag_id]._name;
229 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1172
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
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 156 of file SubProblem.C.

Referenced by SystemBase::zeroTaggedVector().

157 {
158  return _not_zeroed_tagged_vectors.count(tag);
159 }
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:1119

◆ vectorTagType()

Moose::VectorTagType SubProblem::vectorTagType ( const TagID  tag_id) const
virtualinherited

Reimplemented in DisplacedProblem.

Definition at line 232 of file SubProblem.C.

Referenced by MooseVariableScalar::reinit(), TaggingInterface::TaggingInterface(), TagVectorAux::TagVectorAux(), and DisplacedProblem::vectorTagType().

233 {
234  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
235  if (!vectorTagExists(tag_id))
236  mooseError("Vector tag with ID ", tag_id, " does not exist");
237 
238  return _vector_tags[tag_id]._type;
239 }
std::vector< VectorTag > _vector_tags
The declared vector tags.
Definition: SubProblem.h:1172
bool verifyVectorTags() const
Verify the integrity of _vector_tags and _typed_vector_tags.
Definition: SubProblem.C:242
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 2039 of file FEProblemBase.h.

Referenced by MultiApp::backup(), MultiApp::createApp(), MultiApp::restore(), FullSolveMultiApp::showStatusMessage(), and TransientMultiApp::solveStep().

2039 { 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 242 of file SubProblem.C.

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), SubProblem::getVectorTags(), SubProblem::numVectorTags(), SubProblem::vectorTagExists(), SubProblem::vectorTagName(), and SubProblem::vectorTagType().

243 {
244  for (TagID tag_id = 0; tag_id < _vector_tags.size(); ++tag_id)
245  {
246  const auto & vector_tag = _vector_tags[tag_id];
247 
248  if (vector_tag._id != tag_id)
249  mooseError("Vector tag ", vector_tag._id, " id mismatch in _vector_tags");
250  if (vector_tag._type == Moose::VECTOR_TAG_ANY)
251  mooseError("Vector tag '", vector_tag._name, "' has type VECTOR_TAG_ANY");
252 
253  const auto search = _vector_tags_name_map.find(vector_tag._name);
254  if (search == _vector_tags_name_map.end())
255  mooseError("Vector tag ", vector_tag._id, " is not in _vector_tags_name_map");
256  else if (search->second != tag_id)
257  mooseError("Vector tag ", vector_tag._id, " has incorrect id in _vector_tags_name_map");
258 
259  unsigned int found_in_type = 0;
260  for (TagTypeID tag_type_id = 0; tag_type_id < _typed_vector_tags[vector_tag._type].size();
261  ++tag_type_id)
262  {
263  const auto & vector_tag_type = _typed_vector_tags[vector_tag._type][tag_type_id];
264  if (vector_tag_type == vector_tag)
265  {
266  ++found_in_type;
267  if (vector_tag_type._type_id != tag_type_id)
268  mooseError("Type ID for Vector tag ", tag_id, " is incorrect");
269  }
270  }
271 
272  if (found_in_type == 0)
273  mooseError("Vector tag ", tag_id, " not found in _typed_vector_tags");
274  if (found_in_type > 1)
275  mooseError("Vector tag ", tag_id, " found multiple times in _typed_vector_tags");
276  }
277 
278  unsigned int num_typed_vector_tags = 0;
279  for (const auto & typed_vector_tags : _typed_vector_tags)
280  num_typed_vector_tags += typed_vector_tags.size();
281  if (num_typed_vector_tags != _vector_tags.size())
282  mooseError("Size mismatch between _vector_tags and _typed_vector_tags");
283  if (_vector_tags_name_map.size() != _vector_tags.size())
284  mooseError("Size mismatch between _vector_tags and _vector_tags_name_map");
285 
286  return true;
287 }
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:1172
std::map< TagName, TagID > _vector_tags_name_map
Map of vector tag TagName to TagID.
Definition: SubProblem.h:1182
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:1179
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

◆ wereMatricesFormed() [1/2]

bool EigenProblem::wereMatricesFormed ( ) const
inline

Whether or not constant matrices were already formed.

Definition at line 217 of file EigenProblem.h.

Referenced by Moose::SlepcSupport::mooseEPSFormMatrices().

217 { return _matrices_formed; }
bool _matrices_formed
Whether or not matrices had been formed.
Definition: EigenProblem.h:260

◆ wereMatricesFormed() [2/2]

void EigenProblem::wereMatricesFormed ( bool  mf)
inline

Set a flag to indicate whether or not constant matrices were already formed.

Definition at line 222 of file EigenProblem.h.

222 { _matrices_formed = mf; }
bool _matrices_formed
Whether or not matrices had been formed.
Definition: EigenProblem.h:260

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory
protectedinherited

◆ _active_eigen_index

unsigned int EigenProblem::_active_eigen_index
protected

Which eigenvalue is used to compute residual.

By default the zeroth eigenvalue is used.

Definition at line 249 of file EigenProblem.h.

Referenced by activeEigenvalueIndex(), computeResidualL2Norm(), postScaleEigenVector(), and solve().

◆ _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 1077 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 2889 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::reinitMaterialsFaceOnBoundary(), 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 2875 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(), 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::setAuxKernelParamsAndLog(), 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 3172 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 2979 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), and FEProblemBase::needInternalNeighborSideMaterial().

◆ _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 2982 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 3111 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 3107 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup().

◆ _bx_norm_name

std::optional<PostprocessorName> EigenProblem::_bx_norm_name
private

The name of the Postprocessor providing the Bx norm.

This may be empty in which case the default L2 norm of Bx will be used as the Bx norm

Definition at line 289 of file EigenProblem.h.

Referenced by bxNormProvided(), checkProblemIntegrity(), formNorm(), and setBxNorm().

◆ _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 1104 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(), NonlinearEigen::init(), InversePowerMethod::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), 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(), solve(), FEProblemSolve::solve(), NonlinearSystem::solve(), FixedPointSolve::solve(), LinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), FixedPointSolve::solveStep(), PerfGraphLivePrint::start(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), MFEMTransient::takeStep(), TransientBase::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), 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 3079 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::constJacobian(), and FEProblemBase::setConstJacobian().

◆ _constant_matrices

bool EigenProblem::_constant_matrices
protected

Whether or not require constant matrices.

Definition at line 262 of file EigenProblem.h.

Referenced by constantMatrices().

◆ _control_warehouse

ExecuteMooseObjectWarehouse<Control> FEProblemBase::_control_warehouse
protectedinherited

The control logic warehouse.

Definition at line 3157 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 2857 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(), 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(), doFreeNonlinearPowerIterations(), EigenProblem(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFaceShapes(), FEProblemBase::prepareNeighborShapes(), FEProblemBase::prepareShapes(), FEProblemBase::reinitDirac(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::setCurrentNonlinearSystem(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), solve(), and FEProblemBase::solve().

◆ _current_solver_sys

SolverSystem* FEProblemBase::_current_solver_sys
protectedinherited

The current solver system.

Definition at line 2860 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 1101 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 1092 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 3046 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxArrayVariable(), 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(), 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::setAuxKernelParamsAndLog(), FEProblemBase::setCurrentBoundaryID(), FEProblemBase::setCurrentLowerDElem(), FEProblemBase::setCurrentlyComputingResidual(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), FEProblemBase::setResidualObjectParamsAndLog(), solve(), FEProblemBase::solve(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateGeomSearch().

◆ _do_free_power_iteration

bool EigenProblem::_do_free_power_iteration
protected

Whether or not we are doing free power iteration.

Free power iteration is often used to compute initial guess for Newton eigen solver. It is automatically triggered by Eigenvalue Executioner

Definition at line 254 of file EigenProblem.h.

Referenced by doFreePowerIteration().

◆ _dt

Real& FEProblemBase::_dt
protectedinherited

◆ _dt_old

Real& FEProblemBase::_dt_old
protectedinherited

Definition at line 2817 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 86 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 3151 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

◆ _first_solve

bool& EigenProblem::_first_solve
protected

A flag to indicate if it is the first time calling the solve.

Definition at line 271 of file EigenProblem.h.

Referenced by solve().

◆ _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 3118 of file FEProblemBase.h.

Referenced by FEProblemBase::fvBCsIntegrityCheck().

◆ _fv_ics

FVInitialConditionWarehouse FEProblemBase::_fv_ics
protectedinherited

◆ _generalized_eigenvalue_problem

bool EigenProblem::_generalized_eigenvalue_problem
protected

Definition at line 241 of file EigenProblem.h.

Referenced by isGeneralizedEigenvalueProblem().

◆ _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 1081 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 3064 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 3061 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 3136 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 3076 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 3082 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::hasJacobian(), and FEProblemBase::meshChanged().

◆ _has_nonlocal_coupling

bool FEProblemBase::_has_nonlocal_coupling
protectedinherited

◆ _has_normalization

bool EigenProblem::_has_normalization
protected

Whether or not we normalize eigenvector.

Definition at line 264 of file EigenProblem.h.

Referenced by postScaleEigenVector(), and setNormalization().

◆ _has_time_integrator

bool FEProblemBase::_has_time_integrator
protectedinherited

Indicates whether or not this executioner has a time integrator (during setup)

Definition at line 3133 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 1116 of file SubProblem.h.

Referenced by DisplacedProblem::haveADObjects(), SubProblem::haveADObjects(), and FEProblemBase::haveADObjects().

◆ _ics

InitialConditionWarehouse FEProblemBase::_ics
protectedinherited

◆ _indicators

MooseObjectWarehouse<Indicator> FEProblemBase::_indicators
protectedinherited

◆ _initial_eigenvalue

Real EigenProblem::_initial_eigenvalue
protected

A value used for initial normalization.

Definition at line 273 of file EigenProblem.h.

Referenced by execute(), and setInitialEigenvalue().

◆ _initialized

bool FEProblemBase::_initialized
protectedinherited

Definition at line 2788 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 3058 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 2985 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 3166 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 3102 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 2892 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 2881 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 2793 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 2807 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 2836 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 2804 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 1054 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 1072 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 1057 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 3114 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 3121 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 1064 of file SubProblem.h.

Referenced by SubProblem::isMatPropRequested(), and SubProblem::markMatPropRequested().

◆ _material_props

MaterialPropertyStorage& FEProblemBase::_material_props
protectedinherited

◆ _materials

MaterialWarehouse FEProblemBase::_materials
protectedinherited

◆ _matrices_formed

bool EigenProblem::_matrices_formed
protected

Whether or not matrices had been formed.

Definition at line 260 of file EigenProblem.h.

Referenced by solve(), and wereMatricesFormed().

◆ _matrix_tag_id_to_tag_name

std::map<TagID, TagName> SubProblem::_matrix_tag_id_to_tag_name
protectedinherited

Reverse map.

Definition at line 1046 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 3127 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 3130 of file FEProblemBase.h.

Referenced by FEProblemBase::addAuxScalarVariable(), and FEProblemBase::getMaxScalarOrder().

◆ _mesh

MooseMesh& FEProblemBase::_mesh
protectedinherited

Definition at line 2746 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxVariable(), FEProblemBase::addGhostedBoundary(), FEProblemBase::addGhostedElem(), FEProblemBase::addVariable(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::checkUserObjects(), FEProblemBase::computeIndicators(), FEProblemBase::computeMarkers(), FEProblemBase::computeUserObjectsInternal(), DumpObjectsProblem::dumpVariableHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::getCurrentAlgebraicBndNodeRange(), FEProblemBase::getCurrentAlgebraicElementRange(), FEProblemBase::getCurrentAlgebraicNodeRange(), FEProblemBase::getDiracElements(), FEProblemBase::getEvaluableElementRange(), FEProblemBase::getNonlinearEvaluableElementRange(), FEProblemBase::ghostGhostedBoundaries(), FEProblemBase::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), MFEMProblem::mesh(), FEProblemBase::mesh(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::prepareMaterials(), FEProblemBase::projectSolution(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitElemPhys(), FEProblemBase::setAxisymmetricCoordAxis(), FEProblemBase::setCoordSystem(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateMaxQps().

◆ _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 2898 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

◆ _n_eigen_pairs_required

unsigned int EigenProblem::_n_eigen_pairs_required
protected

Definition at line 240 of file EigenProblem.h.

Referenced by getNEigenPairsRequired(), and setNEigenPairsRequired().

◆ _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(), AddFVInitialConditionAction::act(), AddPostprocessorAction::act(), AddVectorPostprocessorAction::act(), AddKernelAction::act(), AddMultiAppAction::act(), PartitionerAction::act(), AddInterfaceKernelAction::act(), AddNodalKernelAction::act(), AddDiracKernelAction::act(), AddDGKernelAction::act(), AddMarkerAction::act(), AddIndicatorAction::act(), AddInitialConditionAction::act(), AddMeshGeneratorAction::act(), AddDamperAction::act(), AddFVInterfaceKernelAction::act(), AddMaterialAction::act(), AddScalarKernelAction::act(), AddTransferAction::act(), AddFunctorMaterialAction::act(), AddUserObjectAction::act(), ReadExecutorParamsAction::act(), AddPositionsAction::act(), AddReporterAction::act(), AddTimesAction::act(), AddFieldSplitAction::act(), AddFVKernelAction::act(), AddFVBCAction::act(), AddFunctionAction::act(), AddConvergenceAction::act(), AddMeshDivisionAction::act(), AddHDGKernelAction::act(), AddTimeStepperAction::act(), AddDistributionAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddOutputAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddMeshModifiersAction::act(), AddCorrectorAction::act(), AddSamplerAction::act(), AddControlAction::act(), AddMFEMFESpaceAction::act(), AddMFEMSolverAction::act(), AddMFEMSubMeshAction::act(), AddMFEMPreconditionerAction::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(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::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 2822 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 2820 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 2824 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 3085 of file FEProblemBase.h.

◆ _negative_sign_eigen_kernel

bool EigenProblem::_negative_sign_eigen_kernel
protected

Whether or not use negative sign for Bx.

Use negative sign by default to make the eigen system consistent with nonlinear system

Definition at line 246 of file EigenProblem.h.

Referenced by computeResidualL2Norm(), and negativeSignEigenKernel().

◆ _neighbor_material_props

MaterialPropertyStorage& FEProblemBase::_neighbor_material_props
protectedinherited

◆ _nl

std::vector<std::shared_ptr<NonlinearSystemBase> > FEProblemBase::_nl
private

The nonlinear systems.

Definition at line 2851 of file FEProblemBase.h.

◆ _nl_eigen

std::shared_ptr<NonlinearEigenSystem> EigenProblem::_nl_eigen
protected

◆ _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 2854 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 2791 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

◆ _normal_factor

Real EigenProblem::_normal_factor
protected

Postprocessor target value.

The value of postprocessor should equal to '_normal_factor' by adjusting eigenvector

Definition at line 269 of file EigenProblem.h.

Referenced by postScaleEigenVector(), and setNormalization().

◆ _normalization

PostprocessorName EigenProblem::_normalization
protected

Postprocessor used to compute a factor from eigenvector.

Definition at line 266 of file EigenProblem.h.

Referenced by postScaleEigenVector(), and setNormalization().

◆ _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 1119 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 2988 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 2991 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

◆ _on_linear_solver

bool EigenProblem::_on_linear_solver
protected

Whether or not we are in linear solver.

Definition at line 258 of file EigenProblem.h.

Referenced by onLinearSolver().

◆ _output_inverse_eigenvalue

bool EigenProblem::_output_inverse_eigenvalue
protected

Whether or not output eigenvalue as its inverse. By default, we output regular eigenvalue.

Definition at line 256 of file EigenProblem.h.

Referenced by outputInverseEigenvalue().

◆ _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(), CreateProblemDefaultAction::act(), CreateProblemAction::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::hasGenerateCSG(), 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 3160 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 2262 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 3088 of file FEProblemBase.h.

Referenced by FEProblemBase::createTagSolutions().

◆ _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 2251 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 3070 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 3067 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 3073 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 2869 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 2863 of file FEProblemBase.h.

Referenced by 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(), 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::setAuxKernelParamsAndLog(), 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 2866 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 2885 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 2812 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 2961 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 3124 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 3187 of file FEProblemBase.h.

Referenced by 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 3180 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 2842 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 3148 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 3142 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 3042 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 1060 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().

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings
inherited

Definition at line 82 of file MooseObject.h.


The documentation for this class was generated from the following files: