Steady-state problem operator with an equation system. More...

#include <EquationSystemProblemOperator.h>

Inheritance diagram for Moose::MFEM::EquationSystemProblemOperator:

Public Member Functions
	EquationSystemProblemOperator (MFEMProblem &problem)

virtual void	SetGridFunctions () override

virtual void	Solve () override

virtual EquationSystem *	GetEquationSystem () const override
	Returns a pointer to the operator's equation system. More...

void	Mult (const mfem::Vector &, mfem::Vector &) const override

virtual void	SetTrialVariablesFromTrueVectors ()

virtual void	Init (mfem::BlockVector &X)

Public Attributes
mfem::Array< int >	_block_true_offsets_test

mfem::Array< int >	_block_true_offsets_trial

mfem::BlockVector	_true_x

mfem::BlockVector	_true_rhs

Protected Member Functions
void	BuildEquationSystemOperator ()
	Add kernels/bcs and assemble the linear part of the equation system. More...

void	SolveWithOperator (EquationSystem &equation_system, const mfem::Vector &rhs, mfem::Vector &x)
	Solve the current equation system/operator using the configured nonlinear solver or linear solver for a purely linear problem. More...

Protected Attributes
MFEMProblem &	_problem
	Reference to the current problem. More...

MFEMProblemData &	_problem_data

std::vector< std::string >	_trial_var_names
	Vector of names of state gridfunctions used in formulation, ordered by appearance in block vector during solve. More...

std::vector< std::string >	_test_var_names

std::vector< mfem::ParGridFunction * >	_trial_variables

std::vector< mfem::ParGridFunction * >	_test_variables

mfem::Vector *	_trial_true_vector = nullptr

Private Attributes
std::shared_ptr< EquationSystem >	_equation_system {nullptr}

Detailed Description

Steady-state problem operator with an equation system.

Definition at line 20 of file EquationSystemProblemOperator.h.

Constructor & Destructor Documentation

◆ EquationSystemProblemOperator()

Moose::MFEM::EquationSystemProblemOperator::EquationSystemProblemOperator ( MFEMProblem & problem )

inline

Definition at line 23 of file EquationSystemProblemOperator.h.

     : ProblemOperator(problem), _equation_system(_problem_data.eqn_system)
   {
   }

Member Function Documentation

◆ BuildEquationSystemOperator()

void Moose::MFEM::EquationSystemProblemOperator::BuildEquationSystemOperator ( )

protected

Add kernels/bcs and assemble the linear part of the equation system.

Definition at line 36 of file EquationSystemProblemOperator.C.

Referenced by Solve(), and Moose::MFEM::ComplexEquationSystemProblemOperator::Solve().

 {
   GetEquationSystem()->BuildEquationSystem();
   GetEquationSystem()->FormSystem(_true_x, _true_rhs);
 }

◆ GetEquationSystem()

virtual EquationSystem* Moose::MFEM::EquationSystemProblemOperator::GetEquationSystem ( ) const

inlineoverridevirtual

Returns a pointer to the operator's equation system.

Implements Moose::MFEM::EquationSystemInterface.

Reimplemented in Moose::MFEM::ComplexEquationSystemProblemOperator, and Moose::MFEM::EigenproblemESProblemOperator.

Definition at line 31 of file EquationSystemProblemOperator.h.

Referenced by BuildEquationSystemOperator(), Moose::MFEM::EigenproblemESProblemOperator::GetEquationSystem(), SetGridFunctions(), and Solve().

   {
     mooseAssert(_equation_system, "No EquationSystem in EquationSystemProblemOperator.");
     return _equation_system.get();
   }

◆ Init()

void Moose::MFEM::ProblemOperatorBase::Init ( mfem::BlockVector & X )

virtualinherited

Reimplemented in Moose::MFEM::TimeDependentEquationSystemProblemOperator.

Definition at line 50 of file ProblemOperatorBase.C.

Referenced by Moose::MFEM::TimeDependentEquationSystemProblemOperator::Init().

 {
   X.Update(_block_true_offsets_trial);
   for (const auto i : index_range(_trial_variables))
     X.GetBlock(i) = _trial_variables[i]->GetTrueVector();
   // Sync the flags from the global vector with the sub-vectors (copies to global vector location)
   X.SyncFromBlocks();
 
   // After initial assignment of X from the grid function, which may contain initial conditions,
   // we alias the grid function to X
   for (const auto i : index_range(_trial_variables))
     _trial_variables[i]->MakeTRef(
         _trial_variables[i]->ParFESpace(), X, _block_true_offsets_trial[i]);
   _trial_true_vector = &X;
 }

◆ Mult()

void Moose::MFEM::ProblemOperator::Mult	(	const mfem::Vector &	,
		mfem::Vector &
	)		const

inlineoverrideinherited

Definition at line 28 of file ProblemOperator.h.

28 {}

◆ SetGridFunctions()

void Moose::MFEM::EquationSystemProblemOperator::SetGridFunctions ( )

overridevirtual

Reimplemented from Moose::MFEM::ProblemOperator.

Reimplemented in Moose::MFEM::ComplexEquationSystemProblemOperator.

Definition at line 17 of file EquationSystemProblemOperator.C.

 {
   _trial_var_names = GetEquationSystem()->GetTrialVarNames();
   _test_var_names = GetEquationSystem()->GetTestVarNames();
   ProblemOperator::SetGridFunctions();
 }

◆ SetTrialVariablesFromTrueVectors()

void Moose::MFEM::ProblemOperatorBase::SetTrialVariablesFromTrueVectors ( )

virtualinherited

Definition at line 67 of file ProblemOperatorBase.C.

Referenced by Moose::MFEM::TimeDependentEquationSystemProblemOperator::Solve().

 {
   mooseAssert(_trial_true_vector, "The true vector should already have been set");
   for (const auto trial_var : _trial_variables)
   {
     // Sync the memory flags from the global true vector to the gridfunction aliases
     trial_var->GetTrueVector().SyncMemory(*_trial_true_vector);
     trial_var->SetFromTrueVector();
   }
 }

◆ Solve()

void Moose::MFEM::EquationSystemProblemOperator::Solve ( )

overridevirtual

Reimplemented from Moose::MFEM::ProblemOperator.

Reimplemented in Moose::MFEM::ComplexEquationSystemProblemOperator, and Moose::MFEM::EigenproblemESProblemOperator.

Definition at line 25 of file EquationSystemProblemOperator.C.

 {
   BuildEquationSystemOperator();
 
   auto * const es = GetEquationSystem();
   SolveWithOperator(*es, _true_rhs, _true_x);
 
   es->SetTrialVariablesFromTrueVectors(_true_x);
 }

◆ SolveWithOperator()

void Moose::MFEM::ProblemOperatorBase::SolveWithOperator	(	EquationSystem &	equation_system,
		const mfem::Vector &	rhs,
		mfem::Vector &	x
	)

protectedinherited

Solve the current equation system/operator using the configured nonlinear solver or linear solver for a purely linear problem.

Definition at line 79 of file ProblemOperatorBase.C.

Referenced by Moose::MFEM::TimeDependentEquationSystemProblemOperator::ImplicitSolve(), Solve(), and Moose::MFEM::ComplexEquationSystemProblemOperator::Solve().

 {
   const bool nonlinear = equation_system.Nonlinear();
 
   // `nonlinear` describes the assembled MFEM operator, not whether the user configured a
   // nonlinear solver object. A linear problem may still intentionally be solved through the
   // nonlinear solver machinery when one is provided.
   if (nonlinear || _problem_data.nonlinear_solver)
   {
     if (nonlinear && !_problem_data.nonlinear_solver)
       mooseError("A nonlinear MFEM solve requires a nonlinear solver, but none was provided.");
 
     auto & nonlinear_solver = *_problem_data.nonlinear_solver;
     if (nonlinear_solver.RequiresExternalLinearSolver())
     {
       if (!_problem_data.jacobian_solver)
         mooseError("The configured MFEM nonlinear solver requires an external linear solver, but "
                    "none was provided.");
       auto & linear_solver = *_problem_data.jacobian_solver;
       equation_system.PrepareLinearSolver(linear_solver);
       nonlinear_solver.SetLinearSolver(linear_solver.GetSolver());
     }
 
     nonlinear_solver.SetOperator(equation_system);
     nonlinear_solver.Mult(rhs, x);
     return;
   }
   else
   {
     //
     // pure linear path
     //
 
     if (!_problem_data.jacobian_solver)
       mooseError("A linear MFEM solve requires a linear solver, but none was provided.");
 
     auto & linear_solver = *_problem_data.jacobian_solver;
     equation_system.PrepareLinearSolver(linear_solver);
     linear_solver.GetSolver().Mult(rhs, x);
   }
 }