This is an interface to call a pure PETSc solver. More...

#include <ExternalPETScProblem.h>

Inheritance diagram for ExternalPETScProblem:

Public Types
enum	Direction { Direction::TO_EXTERNAL_APP, Direction::FROM_EXTERNAL_APP }

enum	CoverageCheckMode { CoverageCheckMode::FALSE, CoverageCheckMode::TRUE, CoverageCheckMode::OFF, CoverageCheckMode::ON, CoverageCheckMode::SKIP_LIST, CoverageCheckMode::ONLY_LIST }

typedef DataFileName	DataFileParameterType

Public Member Functions
	ExternalPETScProblem (const InputParameters &params)

	~ExternalPETScProblem ()

virtual void	externalSolve () override

virtual void	syncSolutions (Direction) override

virtual bool	converged (unsigned int) override

virtual void	advanceState () override

virtual Real	computeResidualL2Norm () override

Vec &	solutionOld ()

Vec &	currentSolution ()

Vec &	udot ()

TS &	getPetscTS ()

virtual void	solve (unsigned int nl_sys_num=0) override final

virtual void	addExternalVariables ()

virtual libMesh::EquationSystems &	es () override

virtual MooseMesh &	mesh () override

virtual const MooseMesh &	mesh () const override

const MooseMesh &	mesh (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)

Moose::CouplingType	coupling () const

void	setCouplingMatrix (std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)

void	setCouplingMatrix (libMesh::CouplingMatrix *cm, const unsigned int nl_sys_num)

const libMesh::CouplingMatrix *	couplingMatrix (const unsigned int nl_sys_num) const override

void	setNonlocalCouplingMatrix ()

bool	areCoupled (const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const

bool	hasUOAuxStateCheck () const

bool	checkingUOAuxState () const

void	trustUserCouplingMatrix ()

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

bool	hasSolverVariable (const std::string &var_name) const

virtual const MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const override

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

virtual 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)

virtual 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)

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

virtual MooseVariable &	getStandardVariable (const THREAD_ID tid, const std::string &var_name) override

virtual VectorMooseVariable &	getVectorVariable (const THREAD_ID tid, const std::string &var_name) override

virtual ArrayMooseVariable &	getArrayVariable (const THREAD_ID tid, const std::string &var_name) override

virtual bool	hasScalarVariable (const std::string &var_name) const override

virtual MooseVariableScalar &	getScalarVariable (const THREAD_ID tid, const std::string &var_name) override

virtual libMesh::System &	getSystem (const std::string &var_name) override

virtual void	setActiveElementalMooseVariables (const std::set< MooseVariableFEBase * > &moose_vars, const THREAD_ID tid) override

virtual void	clearActiveElementalMooseVariables (const THREAD_ID tid) override

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)

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 Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) override

virtual const Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) const override

virtual std::vector< VariableName >	getVariableNames ()

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

virtual void	addGhostedBoundary (BoundaryID boundary_id) override

virtual void	ghostGhostedBoundaries () override

virtual void	sizeZeroes (unsigned int size, const THREAD_ID tid)

virtual bool	reinitDirac (const Elem *elem, const THREAD_ID tid) override

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

virtual void	reinitOffDiagScalars (const THREAD_ID tid) override

virtual void	getDiracElements (std::set< const Elem * > &elems) override

virtual void	clearDiracInfo () override

virtual void	subdomainSetup (SubdomainID subdomain, const THREAD_ID tid)

virtual void	neighborSubdomainSetup (SubdomainID subdomain, const THREAD_ID tid)

virtual void	newAssemblyArray (std::vector< std::shared_ptr< SolverSystem >> &solver_systems)

virtual void	initNullSpaceVectors (const InputParameters &parameters, std::vector< std::shared_ptr< NonlinearSystemBase >> &nl)

virtual void	init () override

virtual void	solveLinearSystem (const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)

virtual void	setException (const std::string &message)

virtual bool	hasException ()

virtual void	checkExceptionAndStopSolve (bool print_message=true)

virtual bool	solverSystemConverged (const unsigned int solver_sys_num) override

virtual unsigned int	nNonlinearIterations (const unsigned int nl_sys_num) const override

virtual unsigned int	nLinearIterations (const unsigned int nl_sys_num) const override

virtual Real	finalNonlinearResidual (const unsigned int nl_sys_num) const override

virtual bool	computingPreSMOResidual (const unsigned int nl_sys_num) const override

virtual std::string	solverTypeString (unsigned int solver_sys_num=0)

virtual bool	startedInitialSetup ()

virtual void	onTimestepBegin () override

virtual void	onTimestepEnd () override

virtual Real &	time () const

virtual Real &	timeOld () const

virtual int &	timeStep () const

virtual Real &	dt () const

virtual Real &	dtOld () const

Real	getTimeFromStateArg (const Moose::StateArg &state) const

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	restoreSolutions ()

virtual void	saveOldSolutions ()

virtual void	restoreOldSolutions ()

void	needSolutionState (unsigned int oldest_needed, Moose::SolutionIterationType iteration_type)

virtual void	outputStep (ExecFlagType type)

virtual void	postExecute ()

void	forceOutput ()

virtual void	initPetscOutputAndSomeSolverSettings ()

Moose::PetscSupport::PetscOptions &	getPetscOptions ()

void	logAdd (const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const

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 Function &	getFunction (const std::string &name, const THREAD_ID tid=0)

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

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

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

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

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

virtual bool	hasConvergence (const std::string &name, const THREAD_ID tid=0) const

bool	needToAddDefaultNonlinearConvergence () const

bool	needToAddDefaultMultiAppFixedPointConvergence () const

void	setNeedToAddDefaultNonlinearConvergence ()

void	setNeedToAddDefaultMultiAppFixedPointConvergence ()

bool	hasSetMultiAppFixedPointConvergenceName () const

virtual void	addDefaultNonlinearConvergence (const InputParameters &params)

virtual bool	onlyAllowDefaultNonlinearConvergence () const

void	addDefaultMultiAppFixedPointConvergence (const InputParameters &params)

virtual void	addLineSearch (const InputParameters &)

virtual void	lineSearch ()

LineSearch *	getLineSearch () override

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

virtual Distribution &	getDistribution (const std::string &name)

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

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

NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num)

const NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num) const

void	setCurrentNonlinearSystem (const unsigned int nl_sys_num)

NonlinearSystemBase &	currentNonlinearSystem ()

const NonlinearSystemBase &	currentNonlinearSystem () const

virtual const SystemBase &	systemBaseNonlinear (const unsigned int sys_num) const override

virtual SystemBase &	systemBaseNonlinear (const unsigned int sys_num) override

virtual const SystemBase &	systemBaseSolver (const unsigned int sys_num) const override

virtual SystemBase &	systemBaseSolver (const unsigned int sys_num) override

virtual const SystemBase &	systemBaseAuxiliary () const override

virtual SystemBase &	systemBaseAuxiliary () override

virtual NonlinearSystem &	getNonlinearSystem (const unsigned int sys_num)

virtual const SystemBase &	getSystemBase (const unsigned int sys_num) const

virtual SystemBase &	getSystemBase (const unsigned int sys_num)

LinearSystem &	getLinearSystem (unsigned int sys_num)

const LinearSystem &	getLinearSystem (unsigned int sys_num) const

SolverSystem &	getSolverSystem (unsigned int sys_num)

const SolverSystem &	getSolverSystem (unsigned int sys_num) const

void	setCurrentLinearSystem (unsigned int sys_num)

LinearSystem &	currentLinearSystem ()

const LinearSystem &	currentLinearSystem () const

virtual const SystemBase &	systemBaseLinear (unsigned int sys_num) const override

virtual SystemBase &	systemBaseLinear (unsigned int sys_num) override

virtual void	addVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)

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	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)

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)

AuxiliarySystem &	getAuxiliarySystem ()

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)

void	projectSolution ()

unsigned short	getCurrentICState ()

void	projectInitialConditionOnCustomRange (libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range)

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)

void	prepareMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)

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)

void	reinitMaterialsNeighbor (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)

void	reinitMaterialsBoundary (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)

void	reinitMaterialsInterface (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)

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)

bool	hasActiveMaterialProperties (const THREAD_ID tid) const

void	clearActiveMaterialProperties (const THREAD_ID tid)

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")

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)

const ReporterData &	getReporterData () const

ReporterData &	getReporterData (ReporterData::WriteKey)

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

T &	getUserObject (const std::string &name, unsigned int tid=0) const

const UserObject &	getUserObjectBase (const std::string &name, const THREAD_ID tid=0) const

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

bool	hasUserObject (const std::string &name) const

bool	hasPostprocessorValueByName (const PostprocessorName &name) const

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

void	setPostprocessorValueByName (const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)

bool	hasPostprocessor (const std::string &name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, std::size_t t_index=0) const

void	setVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, const VectorPostprocessorValue &value, std::size_t t_index=0)

const VectorPostprocessor &	getVectorPostprocessorObjectByName (const std::string &object_name, const THREAD_ID tid=0) const

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

void	setupDampers ()

bool	hasDampers ()

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)

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

std::vector< std::shared_ptr< Transfer > >	getTransfers (ExecFlagType type, Transfer::DIRECTION direction) const

std::vector< std::shared_ptr< Transfer > >	getTransfers (Transfer::DIRECTION direction) const

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

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

bool	execMultiApps (ExecFlagType type, bool auto_advance=true)

void	finalizeMultiApps ()

void	incrementMultiAppTStep (ExecFlagType type)

void	advanceMultiApps (ExecFlagType type)

void	finishMultiAppStep (ExecFlagType type, bool recurse_through_multiapp_levels=false)

void	backupMultiApps (ExecFlagType type)

void	restoreMultiApps (ExecFlagType type, bool force=false)

Real	computeMultiAppsDT (ExecFlagType type)

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

void	execTransfers (ExecFlagType type)

Real	computeResidualL2Norm (NonlinearSystemBase &sys)

Real	computeResidualL2Norm (LinearSystem &sys)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual bool	shouldUpdateSolution ()

virtual bool	updateSolution (NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)

virtual void	predictorCleanup (NumericVector< libMesh::Number > &ghosted_solution)

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)

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 DisplacedProblem >	getDisplacedProblem () const

virtual std::shared_ptr< DisplacedProblem >	getDisplacedProblem ()

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 GeometricSearchData &	geomSearchData () override

void	setRestartFile (const std::string &file_name)

const MaterialPropertyRegistry &	getMaterialPropertyRegistry () const

const InitialConditionWarehouse &	getInitialConditionWarehouse () const

const FVInitialConditionWarehouse &	getFVInitialConditionWarehouse () const

SolverParams &	solverParams (unsigned int solver_sys_num=0)

const SolverParams &	solverParams (unsigned int solver_sys_num=0) const

Adaptivity &	adaptivity ()

virtual void	initialAdaptMesh ()

virtual bool	adaptMesh ()

unsigned int	getNumCyclesCompleted ()

bool	hasInitialAdaptivity () const

bool	hasInitialAdaptivity () const

void	initXFEM (std::shared_ptr< XFEMInterface > xfem)

std::shared_ptr< XFEMInterface >	getXFEM ()

bool	haveXFEM ()

virtual bool	updateMeshXFEM ()

virtual void	meshChanged (bool intermediate_change, bool contract_mesh, bool clean_refinement_flags)

void	notifyWhenMeshChanges (MeshChangedInterface *mci)

void	notifyWhenMeshDisplaces (MeshDisplacedInterface *mdi)

void	initElementStatefulProps (const libMesh::ConstElemRange &elem_range, const bool threaded)

virtual void	checkProblemIntegrity ()

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

void	setConstJacobian (bool state)

void	setKernelCoverageCheck (CoverageCheckMode mode)

void	setKernelCoverageCheck (bool flag)

void	setKernelCoverageCheck (CoverageCheckMode mode)

void	setMaterialCoverageCheck (CoverageCheckMode mode)

void	setMaterialCoverageCheck (bool flag)

void	setMaterialCoverageCheck (CoverageCheckMode mode)

void	setParallelBarrierMessaging (bool flag)

void	setVerboseProblem (bool verbose)

bool	verboseMultiApps () const

void	parentOutputPositionChanged ()

unsigned int	subspaceDim (const std::string &prefix) const

const MaterialWarehouse &	getMaterialWarehouse () const

const MaterialWarehouse &	getRegularMaterialsWarehouse () const

const MaterialWarehouse &	getDiscreteMaterialWarehouse () const

const MaterialWarehouse &	getInterfaceMaterialsWarehouse () const

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

MaterialData &	getMaterialData (Moose::MaterialDataType type, const THREAD_ID tid=0) const

bool	restoreOriginalNonzeroPattern () const

bool	errorOnJacobianNonzeroReallocation () const

void	setErrorOnJacobianNonzeroReallocation (bool state)

bool	preserveMatrixSparsityPattern () const

void	setPreserveMatrixSparsityPattern (bool preserve)

bool	ignoreZerosInJacobian () const

void	setIgnoreZerosInJacobian (bool state)

bool	acceptInvalidSolution () const

bool	allowInvalidSolution () const

bool	showInvalidSolutionConsole () const

bool	immediatelyPrintInvalidSolution () const

bool	hasTimeIntegrator () const

virtual void	execute (const ExecFlagType &exec_type)

virtual void	executeAllObjects (const ExecFlagType &exec_type)

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

virtual void	computeUserObjects (const ExecFlagType &type, const Moose::AuxGroup &group)

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

void	needsPreviousNewtonIteration (bool state)

bool	needsPreviousNewtonIteration () const

ExecuteMooseObjectWarehouse< Control > &	getControlWarehouse ()

void	executeControls (const ExecFlagType &exec_type)

void	executeSamplers (const ExecFlagType &exec_type)

virtual void	updateActiveObjects ()

void	reportMooseObjectDependency (MooseObject a, MooseObject b)

ExecuteMooseObjectWarehouse< MultiApp > &	getMultiAppWarehouse ()

bool	hasJacobian () const

bool	constJacobian () const

void	addOutput (const std::string &, const std::string &, InputParameters &)

TheWarehouse &	theWarehouse () const

void	setSNESMFReuseBase (bool reuse, bool set_by_user)

bool	useSNESMFReuseBase ()

void	skipExceptionCheck (bool skip_exception_check)

bool	isSNESMFReuseBaseSetbyUser ()

bool &	petscOptionsInserted ()

PetscOptions &	petscOptionsDatabase ()

virtual void	setUDotRequested (const bool u_dot_requested)

virtual void	setUDotDotRequested (const bool u_dotdot_requested)

virtual void	setUDotOldRequested (const bool u_dot_old_requested)

virtual void	setUDotDotOldRequested (const bool u_dotdot_old_requested)

virtual bool	uDotRequested ()

virtual bool	uDotDotRequested ()

virtual bool	uDotOldRequested ()

virtual bool	uDotDotOldRequested ()

void	haveADObjects (bool have_ad_objects) override

virtual void	haveADObjects (bool have_ad_objects)

bool	haveADObjects () const

bool	haveADObjects () const

bool	shouldSolve () const

const MortarData &	mortarData () const

MortarData &	mortarData ()

virtual bool	hasNeighborCoupling () const

virtual bool	hasMortarCoupling () const

void	computingNonlinearResid (bool computing_nonlinear_residual) final

bool	computingNonlinearResid () const

virtual void	computingNonlinearResid (const bool computing_nonlinear_residual)

bool	computingNonlinearResid () const

void	setCurrentlyComputingResidual (bool currently_computing_residual) final

void	numGridSteps (unsigned int num_grid_steps)

void	uniformRefine ()

void	automaticScaling (bool automatic_scaling) override

virtual void	automaticScaling (bool automatic_scaling)

bool	automaticScaling () const

bool	automaticScaling () 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) override

virtual void	reinitNeighborFaceRef (const Elem neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override

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)

void	resizeMaterialData (Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)

bool	haveDisplaced () const override final

bool	hasLinearConvergenceObjects () const

void	setNonlinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)

void	setLinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)

void	setMultiAppFixedPointConvergenceName (const ConvergenceName &convergence_name)

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

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

const ConvergenceName &	getMultiAppFixedPointConvergenceName () const

void	computingScalingJacobian (bool computing_scaling_jacobian)

bool	computingScalingJacobian () const override final

void	computingScalingResidual (bool computing_scaling_residual)

bool	computingScalingResidual () const override final

MooseAppCoordTransform &	coordTransform ()

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)

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

bool	getFailNextSystemConvergenceCheck () const

void	setFailNextNonlinearConvergenceCheck ()

void	setFailNextSystemConvergenceCheck ()

void	resetFailNextNonlinearConvergenceCheck ()

void	resetFailNextSystemConvergenceCheck ()

void	setExecutionPrinting (const ExecFlagEnum &print_exec)

bool	shouldPrintExecution (const THREAD_ID tid) const

void	reinitMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)

virtual const std::vector< VectorTag > &	currentResidualVectorTags () const override

void	setCurrentResidualVectorTags (const std::set< TagID > &vector_tags)

void	clearCurrentResidualVectorTags ()

void	clearCurrentJacobianMatrixTags ()

virtual void	needFV () override

virtual bool	haveFV () const override

virtual bool	hasNonlocalCoupling () const override

bool	identifyVariableGroupsInNL () const

virtual void	setCurrentLowerDElem (const Elem *const lower_d_elem, const THREAD_ID tid) override

virtual void	setCurrentBoundaryID (BoundaryID bid, const THREAD_ID tid) override

const std::vector< NonlinearSystemName > &	getNonlinearSystemNames () const

const std::vector< LinearSystemName > &	getLinearSystemNames () const

const std::vector< SolverSystemName > &	getSolverSystemNames () const

virtual const libMesh::CouplingMatrix &	nonlocalCouplingMatrix (const unsigned i) const override

virtual bool	checkNonlocalCouplingRequirement () const override

virtual Moose::FEBackend	feBackend () const

const bool &	currentlyComputingResidual () const

const bool &	currentlyComputingResidual () const

virtual bool	nlConverged (const unsigned int nl_sys_num)

bool	defaultGhosting ()

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

void	addNotZeroedVectorTag (const TagID tag)

bool	vectorTagNotZeroed (const TagID tag) const

virtual const VectorTag &	getVectorTag (const TagID tag_id) const

std::vector< VectorTag >	getVectorTags (const std::set< TagID > &tag_ids) const

virtual const std::vector< VectorTag > &	getVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const

virtual TagID	getVectorTagID (const TagName &tag_name) const

virtual TagName	vectorTagName (const TagID tag) const

virtual bool	vectorTagExists (const TagID tag_id) const

virtual bool	vectorTagExists (const TagName &tag_name) const

virtual unsigned int	numVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const

virtual Moose::VectorTagType	vectorTagType (const TagID tag_id) const

virtual TagID	addMatrixTag (TagName tag_name)

virtual TagID	getMatrixTagID (const TagName &tag_name) const

virtual TagName	matrixTagName (TagID tag)

virtual bool	matrixTagExists (const TagName &tag_name) const

virtual bool	matrixTagExists (TagID tag_id) const

virtual unsigned int	numMatrixTags () const

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

virtual bool	hasLinearVariable (const std::string &var_name) const

virtual bool	hasAuxiliaryVariable (const std::string &var_name) const

virtual const std::set< MooseVariableFieldBase *> &	getActiveElementalMooseVariables (const THREAD_ID tid) const

virtual bool	hasActiveElementalMooseVariables (const THREAD_ID tid) const

Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const

unsigned int	getAxisymmetricRadialCoord () const

virtual DiracKernelInfo &	diracKernelInfo ()

void	reinitNeighborLowerDElem (const Elem *elem, const THREAD_ID tid=0)

void	reinitMortarElem (const Elem *elem, const THREAD_ID tid=0)

virtual void	storeSubdomainMatPropName (SubdomainID block_id, const std::string &name)

virtual void	storeBoundaryMatPropName (BoundaryID boundary_id, const std::string &name)

virtual void	storeSubdomainZeroMatProp (SubdomainID block_id, const MaterialPropertyName &name)

virtual void	storeBoundaryZeroMatProp (BoundaryID boundary_id, const MaterialPropertyName &name)

virtual void	storeSubdomainDelayedCheckMatProp (const std::string &requestor, SubdomainID block_id, const std::string &name)

virtual void	storeBoundaryDelayedCheckMatProp (const std::string &requestor, BoundaryID boundary_id, const std::string &name)

virtual void	checkBlockMatProps ()

virtual void	checkBoundaryMatProps ()

virtual void	markMatPropRequested (const std::string &)

virtual bool	isMatPropRequested (const std::string &prop_name) const

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

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

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

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

virtual bool	hasBlockMaterialProperty (SubdomainID block_id, const std::string &prop_name)

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

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

virtual bool	hasBoundaryMaterialProperty (BoundaryID boundary_id, const std::string &prop_name)

virtual std::set< dof_id_type > &	ghostedElems ()

const bool &	currentlyComputingJacobian () const

void	setCurrentlyComputingJacobian (const bool currently_computing_jacobian)

const bool &	currentlyComputingResidualAndJacobian () const

void	setCurrentlyComputingResidualAndJacobian (bool currently_computing_residual_and_jacobian)

virtual bool	safeAccessTaggedMatrices () const

virtual bool	safeAccessTaggedVectors () const

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)

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

void	removeAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf)

void	removeCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf)

void	hasScalingVector (const unsigned int nl_sys_num)

void	clearAllDofIndices ()

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

bool	hasFunctorWithType (const std::string &name, const THREAD_ID tid) const

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

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)

void	setFunctorOutput (bool set_output)

void	registerUnfilledFunctorRequest (T *functor_interface, const std::string &functor_name, const THREAD_ID tid)

void	reinitFVFace (const THREAD_ID tid, const FaceInfo &fi)

void	preparePRefinement ()

bool	doingPRefinement () const

bool	havePRefinement () const

MooseVariableFEBase &	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

void	_setCLIOption ()

virtual void	terminateSolve ()

virtual bool	isSolveTerminationRequested () const

const ConsoleStream &	console () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

const T &	getParam (const std::string &name) const

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

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &nm) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

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

void	mooseError (Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

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

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

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

PerfGraph &	perfGraph ()

const libMesh::ConstElemRange &	getEvaluableElementRange ()

const libMesh::ConstElemRange &	getEvaluableElementRange ()

const libMesh::ConstElemRange &	getNonlinearEvaluableElementRange ()

const libMesh::ConstElemRange &	getNonlinearEvaluableElementRange ()

const libMesh::ConstElemRange &	getCurrentAlgebraicElementRange ()

const libMesh::ConstElemRange &	getCurrentAlgebraicElementRange ()

const libMesh::ConstNodeRange &	getCurrentAlgebraicNodeRange ()

const libMesh::ConstNodeRange &	getCurrentAlgebraicNodeRange ()

const ConstBndNodeRange &	getCurrentAlgebraicBndNodeRange ()

const ConstBndNodeRange &	getCurrentAlgebraicBndNodeRange ()

void	setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)

void	setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)

void	setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)

void	setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)

void	setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)

void	setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)

void	allowOutput (bool state)

void	allowOutput (bool state)

void	allowOutput (bool state)

void	allowOutput (bool state)

bool	hasMultiApps () const

bool	hasMultiApps (ExecFlagType type) const

bool	hasMultiApps () const

bool	hasMultiApps (ExecFlagType type) const

bool	hasMultiApp (const std::string &name) const

bool	hasMultiApp (const std::string &name) const

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

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

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

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

const MaterialPropertyStorage &	getMaterialPropertyStorage ()

const MaterialPropertyStorage &	getMaterialPropertyStorage ()

const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()

const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()

const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()

const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()

const MooseObjectWarehouse< Indicator > &	getIndicatorWarehouse ()

const MooseObjectWarehouse< Indicator > &	getIndicatorWarehouse ()

const MooseObjectWarehouse< InternalSideIndicatorBase > &	getInternalSideIndicatorWarehouse ()

const MooseObjectWarehouse< InternalSideIndicatorBase > &	getInternalSideIndicatorWarehouse ()

const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()

const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()

bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needSubdomainMaterialOnSide (SubdomainID subdomain_id, const THREAD_ID tid)

bool	needSubdomainMaterialOnSide (SubdomainID subdomain_id, const THREAD_ID tid)

const ExecFlagType &	getCurrentExecuteOnFlag () const

const ExecFlagType &	getCurrentExecuteOnFlag () const

void	setCurrentExecuteOnFlag (const ExecFlagType &)

void	setCurrentExecuteOnFlag (const ExecFlagType &)

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

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)

static void	selectMatrixTagsFromSystem (const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)

static void	objectSetupHelper (const std::vector< T * > &objects, const ExecFlagType &exec_flag)

static void	objectSetupHelper (const std::vector< T * > &objects, const ExecFlagType &exec_flag)

static void	objectExecuteHelper (const std::vector< T * > &objects)

static void	objectExecuteHelper (const std::vector< T * > &objects)

Public Attributes
std::map< std::string, std::vector< dof_id_type > >	_var_dof_map

const ConsoleStream	_console

std::vector< Real >	_real_zero

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

Protected Member Functions
virtual void	meshChanged ()

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

void	createTagVectors ()

void	createTagSolutions ()

virtual void	meshDisplaced ()

void	computeSystems (const ExecFlagType &type)

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

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

void	checkDisplacementOrders ()

void	checkUserObjects ()

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

void	checkCoordinateSystems ()

void	reinitBecauseOfGhostingOrNewGeomObjects (bool mortar_changed=false)

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

bool	verifyVectorTags () const

void	markFamilyPRefinement (const InputParameters &params)

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

Protected Attributes
MooseMesh &	_mesh

bool	_initialized

std::optional< std::vector< ConvergenceName > >	_nonlinear_convergence_names

std::optional< std::vector< ConvergenceName > >	_linear_convergence_names

std::optional< ConvergenceName >	_multiapp_fixed_point_convergence_name

std::set< TagID >	_fe_vector_tags

std::set< TagID >	_fe_matrix_tags

std::set< TagID >	_linear_vector_tags

std::set< TagID >	_linear_matrix_tags

const bool &	_solve

bool	_transient

Real &	_time

Real &	_time_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_need_to_add_default_nonlinear_convergence

bool	_need_to_add_default_multiapp_fixed_point_convergence

const std::vector< LinearSystemName >	_linear_sys_names

const std::size_t	_num_linear_sys

std::vector< std::shared_ptr< LinearSystem > >	_linear_systems

std::map< LinearSystemName, unsigned int >	_linear_sys_name_to_num

LinearSystem *	_current_linear_sys

const bool	_using_default_nl

const std::vector< NonlinearSystemName >	_nl_sys_names

const std::size_t	_num_nl_sys

std::vector< std::shared_ptr< NonlinearSystemBase > >	_nl

std::map< NonlinearSystemName, unsigned int >	_nl_sys_name_to_num

NonlinearSystemBase *	_current_nl_sys

SolverSystem *	_current_solver_sys

std::vector< std::shared_ptr< SolverSystem > >	_solver_systems

std::map< SolverVariableName, unsigned int >	_solver_var_to_sys_num

std::map< SolverSystemName, unsigned int >	_solver_sys_name_to_num

std::vector< SolverSystemName >	_solver_sys_names

std::shared_ptr< AuxiliarySystem >	_aux

Moose::CouplingType	_coupling

std::vector< std::unique_ptr< libMesh::CouplingMatrix > >	_cm

std::map< std::string, unsigned int >	_subspace_dim

std::vector< std::vector< std::unique_ptr< Assembly > > >	_assembly

MooseObjectWarehouse< MeshDivision >	_mesh_divisions

MooseObjectWarehouse< Function >	_functions

MooseObjectWarehouse< Convergence >	_convergences

MooseObjectWarehouse< KernelBase >	_nonlocal_kernels

MooseObjectWarehouse< IntegratedBCBase >	_nonlocal_integrated_bcs

MaterialPropertyRegistry	_material_prop_registry

MaterialPropertyStorage &	_material_props

MaterialPropertyStorage &	_bnd_material_props

MaterialPropertyStorage &	_neighbor_material_props

MooseObjectWarehouse< Marker >	_markers

ReporterData	_reporter_data

ExecuteMooseObjectWarehouse< UserObject >	_all_user_objects

ExecuteMooseObjectWarehouse< MultiApp >	_multi_apps

ExecuteMooseObjectWarehouse< TransientMultiApp >	_transient_multi_apps

ExecuteMooseObjectWarehouse< Transfer >	_transfers

ExecuteMooseObjectWarehouse< Transfer >	_to_multi_app_transfers

ExecuteMooseObjectWarehouse< Transfer >	_from_multi_app_transfers

ExecuteMooseObjectWarehouse< Transfer >	_between_multi_app_transfers

std::map< std::string, std::unique_ptr< RandomData > >	_random_data_objects

std::vector< std::unordered_map< SubdomainID, bool > >	_block_mat_side_cache

std::vector< std::unordered_map< BoundaryID, bool > >	_bnd_mat_side_cache

std::vector< std::unordered_map< BoundaryID, bool > >	_interface_mat_side_cache

std::vector< MeshChangedInterface *>	_notify_when_mesh_changes

std::vector< MeshDisplacedInterface *>	_notify_when_mesh_displaces

Adaptivity	_adaptivity

unsigned int	_cycles_completed

std::shared_ptr< XFEMInterface >	_xfem

MooseMesh *	_displaced_mesh

std::shared_ptr< DisplacedProblem >	_displaced_problem

GeometricSearchData	_geometric_search_data

MortarData	_mortar_data

bool	_reinit_displaced_elem

bool	_reinit_displaced_face

bool	_reinit_displaced_neighbor

bool	_input_file_saved

bool	_has_dampers

bool	_has_constraints

bool	_snesmf_reuse_base

bool	_skip_exception_check

bool	_snesmf_reuse_base_set_by_user

bool	_has_initialized_stateful

bool	_const_jacobian

bool	_has_jacobian

bool	_needs_old_newton_iter

bool	_previous_nl_solution_required

bool	_has_nonlocal_coupling

bool	_calculate_jacobian_in_uo

std::vector< std::vector< const MooseVariableFEBase *> >	_uo_jacobian_moose_vars

std::vector< unsigned char >	_has_active_material_properties

std::vector< SolverParams >	_solver_params

CoverageCheckMode	_kernel_coverage_check

std::vector< SubdomainName >	_kernel_coverage_blocks

const bool	_boundary_restricted_node_integrity_check

const bool	_boundary_restricted_elem_integrity_check

CoverageCheckMode	_material_coverage_check

std::vector< SubdomainName >	_material_coverage_blocks

bool	_fv_bcs_integrity_check

const bool	_material_dependency_check

const bool	_uo_aux_state_check

unsigned int	_max_qps

libMesh::Order	_max_scalar_order

bool	_has_time_integrator

bool	_has_exception

bool	_parallel_barrier_messaging

MooseEnum	_verbose_setup

bool	_verbose_multiapps

bool	_verbose_restore

std::string	_exception_message

ExecFlagType	_current_execute_on_flag

ExecuteMooseObjectWarehouse< Control >	_control_warehouse

Moose::PetscSupport::PetscOptions	_petsc_options

PetscOptions	_petsc_option_data_base

bool	_is_petsc_options_inserted

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

unsigned short	_current_ic_state

const bool	_use_hash_table_matrix_assembly

std::map< TagName, TagID >	_matrix_tag_name_to_tag_id

std::map< TagID, TagName >	_matrix_tag_id_to_tag_name

Factory &	_factory

DiracKernelInfo	_dirac_kernel_info

std::map< SubdomainID, std::set< std::string > >	_map_block_material_props

std::map< BoundaryID, std::set< std::string > >	_map_boundary_material_props

std::map< SubdomainID, std::set< MaterialPropertyName > >	_zero_block_material_props

std::map< BoundaryID, std::set< MaterialPropertyName > >	_zero_boundary_material_props

std::set< std::string >	_material_property_requested

std::vector< std::set< MooseVariableFieldBase *> >	_active_elemental_moose_variables

std::vector< unsigned int >	_has_active_elemental_moose_variables

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

std::set< dof_id_type >	_ghosted_elems

bool	_currently_computing_jacobian

bool	_currently_computing_residual_and_jacobian

bool	_computing_nonlinear_residual

bool	_currently_computing_residual

bool	_safe_access_tagged_matrices

bool	_safe_access_tagged_vectors

bool	_have_ad_objects

std::unordered_set< TagID >	_not_zeroed_tagged_vectors

bool	_cli_option_found

bool	_color_output

bool	_termination_requested

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

ActionFactory &	_action_factory

MooseApp &	_pg_moose_app

const std::string	_prefix

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

InitialConditionWarehouse	_ics

FVInitialConditionWarehouse	_fv_ics

ScalarInitialConditionWarehouse	_scalar_ics

MaterialWarehouse	_materials

MaterialWarehouse	_interface_materials

MaterialWarehouse	_discrete_materials

MaterialWarehouse	_all_materials

MooseObjectWarehouse< Indicator >	_indicators

MooseObjectWarehouse< InternalSideIndicatorBase >	_internal_side_indicators

std::map< SubdomainID, std::multimap< std::string, std::string > >	_map_block_material_props_check

std::map< BoundaryID, std::multimap< std::string, std::string > >	_map_boundary_material_props_check

const Parallel::Communicator &	_communicator

Private Attributes
const VariableName &	_sync_to_var_name
	The name of the variable to transfer to. More...

PetscBool	_petsc_converged
	If PETSc solver converged. More...

ExternalPetscSolverApp &	_external_petsc_app

TS &	_ts
	PETSc solver. More...

Vec &	_petsc_sol
	PETSc solver solution. More...

Vec &	_petsc_sol_old
	Solution at the previous time step. More...

Vec &	_petsc_udot
	Udot (u_n-u_{n-1})/dt. More...

Vec	_petsc_rhs
	RHS vector. More...

Detailed Description

This is an interface to call a pure PETSc solver.

We also sync the PETSc solution to moose variables, and then these variables can be coupled to other moose applications

Definition at line 22 of file ExternalPETScProblem.h.

Constructor & Destructor Documentation

◆ ExternalPETScProblem()

ExternalPETScProblem::ExternalPETScProblem ( const InputParameters & params )

Definition at line 26 of file ExternalPETScProblem.C.

   : ExternalProblem(params),
     _sync_to_var_name(getParam<VariableName>("sync_variable")),
     // Require ExternalPetscSolverApp
     _external_petsc_app(static_cast<ExternalPetscSolverApp &>(_app)),
     _ts(_external_petsc_app.getPetscTS()),
     // RestartableData is required for recovering when PETSc solver runs as a master app
     _petsc_sol(declareRestartableData<Vec>("petsc_sol")),
     _petsc_sol_old(declareRestartableData<Vec>("petsc_sol_old")),
     _petsc_udot(declareRestartableData<Vec>("petsc_udot"))
 {
   DM da;
   LibmeshPetscCall(TSGetDM(_ts, &da));
   // Create a global solution vector
   LibmeshPetscCall(DMCreateGlobalVector(da, &_petsc_sol));
   // This is required because libMesh incorrectly treats the PETSc parallel vector as a ghost vector
   // We should be able to remove this line of code once libMesh is updated
   LibmeshPetscCall(VecMPISetGhost(_petsc_sol, 0, nullptr));
   // The solution at the previous time step
   LibmeshPetscCall(VecDuplicate(_petsc_sol, &_petsc_sol_old));
   // Udot
   LibmeshPetscCall(VecDuplicate(_petsc_sol, &_petsc_udot));
   // RHS
   LibmeshPetscCall(VecDuplicate(_petsc_sol, &_petsc_rhs));
   // Form an initial condition
   LibmeshPetscCall(FormInitialSolution(_ts, _petsc_sol, NULL));
   LibmeshPetscCall(VecCopy(_petsc_sol, _petsc_sol_old));
   LibmeshPetscCall(VecSet(_petsc_udot, 0));
 }

◆ ~ExternalPETScProblem()

ExternalPETScProblem::~ExternalPETScProblem ( )

Definition at line 56 of file ExternalPETScProblem.C.

 {
   // Destroy all handles of external Petsc solver
   auto ierr = VecDestroy(&_petsc_sol);
   ierr = VecDestroy(&_petsc_sol_old);
   ierr = VecDestroy(&_petsc_udot);
   ierr = VecDestroy(&_petsc_rhs);
   // Don't throw during destruction, just abort
   CHKERRABORT(this->comm().get(), ierr);
 }

Member Function Documentation

◆ advanceState()

void ExternalPETScProblem::advanceState ( )

overridevirtual

Reimplemented from ExternalProblem.

Definition at line 82 of file ExternalPETScProblem.C.

 {
   FEProblemBase::advanceState();
   // Compute udot using a backward Euler method
   // If the external code uses a different method,
   // udot should be retrieved from the external solver
   LibmeshPetscCall(VecCopy(_petsc_sol, _petsc_udot));
   LibmeshPetscCall(VecAXPY(_petsc_udot, -1., _petsc_sol_old));
   LibmeshPetscCall(VecScale(_petsc_udot, 1. / dt()));
   // Save current solution because we are moving to the next time step
   LibmeshPetscCall(VecCopy(_petsc_sol, _petsc_sol_old));
 }

◆ computeResidualL2Norm()

Real ExternalPETScProblem::computeResidualL2Norm ( )

overridevirtual

Reimplemented from ExternalProblem.

Definition at line 96 of file ExternalPETScProblem.C.

 {
   LibmeshPetscCall(
       TSComputeIFunction(_ts, time(), _petsc_sol, _petsc_udot, _petsc_rhs, PETSC_FALSE));
   PetscReal norm;
   LibmeshPetscCall(VecNorm(_petsc_rhs, NORM_2, &norm));
 
   return norm;
 }

◆ converged()

virtual bool ExternalPETScProblem::converged ( unsigned int )

inlineoverridevirtual

Reimplemented from ExternalProblem.

Definition at line 34 of file ExternalPETScProblem.h.

34 { return _petsc_converged; }

ExternalPETScProblem::_petsc_converged

PetscBool _petsc_converged

If PETSc solver converged.

Definition: ExternalPETScProblem.h:52

◆ currentSolution()

Vec& ExternalPETScProblem::currentSolution ( )

inline

Definition at line 42 of file ExternalPETScProblem.h.

42 { return _petsc_sol; }

ExternalPETScProblem::_petsc_sol

Vec & _petsc_sol

PETSc solver solution.

Definition: ExternalPETScProblem.h:57

◆ externalSolve()

void ExternalPETScProblem::externalSolve ( )

overridevirtual

Implements ExternalProblem.

Definition at line 68 of file ExternalPETScProblem.C.

 {
   _console << "PETSc External Solve!" << std::endl;
   // "_petsc_sol_old" is the solution of the current time step, and "_petsc_sol" will be updated
   // to store the solution of the next time step after this call.
   // This call advances a time step so that there is an opportunity to
   // exchange information with MOOSE simulations.
   LibmeshPetscCall(externalPETScDiffusionFDMSolve(
       _ts, _petsc_sol_old, _petsc_sol, dt(), time(), &_petsc_converged));
 }

◆ getPetscTS()

TS& ExternalPETScProblem::getPetscTS ( )

inline

Definition at line 46 of file ExternalPETScProblem.h.

Referenced by ExternalPetscTimeStepper::computeDT(), and ExternalPetscTimeStepper::computeInitialDT().

46 { return _ts; }

ExternalPETScProblem::_ts

TS & _ts

PETSc solver.

Definition: ExternalPETScProblem.h:55

◆ solutionOld()

Vec& ExternalPETScProblem::solutionOld ( )

inline

Definition at line 40 of file ExternalPETScProblem.h.

40 { return _petsc_sol_old; }

ExternalPETScProblem::_petsc_sol_old

Vec & _petsc_sol_old

Solution at the previous time step.

Definition: ExternalPETScProblem.h:59

◆ syncSolutions()

void ExternalPETScProblem::syncSolutions ( Direction direction )

overridevirtual

Implements ExternalProblem.

Definition at line 107 of file ExternalPETScProblem.C.

 {
   if (direction == Direction::FROM_EXTERNAL_APP)
   {
     _console << "syncSolutions from external petsc App" << std::endl;
     DM da;
     // xs: start grid point in x direction on local
     // ys: start grid point in y direciton on local
     // xm: number of grid points in x direciton on local
     // ym: number of grid points in y direction on local
     // Mx: number of grid points in x direction on all processors
     PetscInt i, j, xs, ys, xm, ym, Mx;
     PetscScalar ** _petsc_sol_array;
     LibmeshPetscCall(TSGetDM(_ts, &da));
     LibmeshPetscCall(DMDAGetInfo(da,
                                  PETSC_IGNORE,
                                  &Mx,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE,
                                  PETSC_IGNORE));
     LibmeshPetscCall(DMDAGetCorners(da, &xs, &ys, NULL, &xm, &ym, NULL));
     LibmeshPetscCall(DMDAVecGetArray(da, _petsc_sol, &_petsc_sol_array));
 
     // Take the solution from PETSc, and sync it to one MOOSE variable
     // We currently support one variable only but it is straightforward
     // to have multiple moose variables
     MeshBase & to_mesh = mesh().getMesh();
     auto & sync_to_var = getVariable(
         0, _sync_to_var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD);
 
     for (j = ys; j < ys + ym; j++)
       for (i = xs; i < xs + xm; i++)
       {
         Node * to_node = to_mesh.node_ptr(i + j * Mx);
         // For the current example, we need to update only one variable.
         // This line of code is used to make sure users won't make a mistake in the demo input file.
         // If multiple variables need to be transfered for some use cases, users should
         // loop over variables and copy necessary data.
         if (to_node->n_comp(sync_to_var.sys().number(), sync_to_var.number()) > 1)
           mooseError("Does not support multiple components");
 
         dof_id_type dof = to_node->dof_number(sync_to_var.sys().number(), sync_to_var.number(), 0);
         // Copy the solution to the right location
         sync_to_var.sys().solution().set(dof, _petsc_sol_array[j][i]);
       }
 
     sync_to_var.sys().solution().close();
 
     LibmeshPetscCall(DMDAVecRestoreArray(da, _petsc_sol, &_petsc_sol_array));
 
     // Make the solution and the current local solution consistent
     sync_to_var.sys().update();
   }
   else if (direction == Direction::TO_EXTERNAL_APP)
   {
     _console << "syncSolutions to external petsc App " << std::endl;
     // We could the similar thing to sync the solution back to PETSc.
   }
 }

◆ udot()

Vec& ExternalPETScProblem::udot ( )

inline

Definition at line 44 of file ExternalPETScProblem.h.

44 { return _petsc_udot; }

ExternalPETScProblem::_petsc_udot

Vec & _petsc_udot

Udot (u_n-u_{n-1})/dt.

Definition: ExternalPETScProblem.h:61

◆ validParams()

InputParameters ExternalPETScProblem::validParams ( )

static

Definition at line 18 of file ExternalPETScProblem.C.

 {
   InputParameters params = ExternalProblem::validParams();
   params.addRequiredParam<VariableName>("sync_variable",
                                         "The variable PETSc external solution will be synced to");
   return params;
 }

Member Data Documentation

◆ _external_petsc_app

ExternalPetscSolverApp& ExternalPETScProblem::_external_petsc_app

private

Definition at line 53 of file ExternalPETScProblem.h.

◆ _petsc_converged

PetscBool ExternalPETScProblem::_petsc_converged

private

If PETSc solver converged.

Definition at line 52 of file ExternalPETScProblem.h.

Referenced by converged(), and externalSolve().

◆ _petsc_rhs

Vec ExternalPETScProblem::_petsc_rhs

private

RHS vector.

Definition at line 63 of file ExternalPETScProblem.h.

Referenced by computeResidualL2Norm(), ExternalPETScProblem(), and ~ExternalPETScProblem().

◆ _petsc_sol

Vec& ExternalPETScProblem::_petsc_sol

private

PETSc solver solution.

Definition at line 57 of file ExternalPETScProblem.h.

Referenced by advanceState(), computeResidualL2Norm(), currentSolution(), ExternalPETScProblem(), externalSolve(), syncSolutions(), and ~ExternalPETScProblem().

◆ _petsc_sol_old

Vec& ExternalPETScProblem::_petsc_sol_old

private

Solution at the previous time step.

Definition at line 59 of file ExternalPETScProblem.h.

Referenced by advanceState(), ExternalPETScProblem(), externalSolve(), solutionOld(), and ~ExternalPETScProblem().

◆ _petsc_udot

Vec& ExternalPETScProblem::_petsc_udot

private

Udot (u_n-u_{n-1})/dt.

Definition at line 61 of file ExternalPETScProblem.h.

Referenced by advanceState(), computeResidualL2Norm(), ExternalPETScProblem(), udot(), and ~ExternalPETScProblem().

◆ _sync_to_var_name

const VariableName& ExternalPETScProblem::_sync_to_var_name

private

The name of the variable to transfer to.

Definition at line 50 of file ExternalPETScProblem.h.

Referenced by syncSolutions().

◆ _ts

TS& ExternalPETScProblem::_ts

private

PETSc solver.

Definition at line 55 of file ExternalPETScProblem.h.

Referenced by computeResidualL2Norm(), ExternalPETScProblem(), externalSolve(), getPetscTS(), and syncSolutions().

The documentation for this class was generated from the following files:

external_petsc_solver/include/problems/ExternalPETScProblem.h
external_petsc_solver/src/problems/ExternalPETScProblem.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ExternalPETScProblem()

◆ ~ExternalPETScProblem()

Member Function Documentation

◆ advanceState()

◆ computeResidualL2Norm()

◆ converged()

◆ currentSolution()

◆ externalSolve()

◆ getPetscTS()

◆ solutionOld()

◆ syncSolutions()

◆ udot()

◆ validParams()

Member Data Documentation

◆ _external_petsc_app

◆ _petsc_converged

◆ _petsc_rhs

◆ _petsc_sol

◆ _petsc_sol_old

◆ _petsc_udot

◆ _sync_to_var_name

◆ _ts