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

#include <ComplexEquationSystemProblemOperator.h>

Inheritance diagram for Moose::MFEM::ComplexEquationSystemProblemOperator:

Public Member Functions
	ComplexEquationSystemProblemOperator (MFEMProblem &problem)

virtual void	SetGridFunctions () override

virtual void	Solve () override

virtual Moose::MFEM::ComplexEquationSystem *	GetEquationSystem () const override
	Returns a pointer to the operator's equation system.

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	FormEquationSystemOperator ()
	Form equation-system state used by Solve().

void	SolveWithOperator (mfem::Operator &system_operator, mfem::Operator &linear_operator, const mfem::Vector &rhs, mfem::Vector &x)
	Solve the current system operator using the configured nonlinear and linear solvers.

void	SolveWithOperator (mfem::Operator &system_operator, const mfem::Vector &rhs, mfem::Vector &x)
	Solve the current system operator using system_operator.GetGradient(x) as the linear operator.

Protected Attributes
MFEMProblem &	_problem
	Reference to the current problem.

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.

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< Moose::MFEM::ComplexEquationSystem >	_equation_system {nullptr}

std::vector< mfem::ParComplexGridFunction * >	_cmplx_trial_variables

std::vector< mfem::ParComplexGridFunction * >	_cmplx_test_variables

Detailed Description

Steady-state problem operator with an equation system.

Definition at line 19 of file ComplexEquationSystemProblemOperator.h.

Constructor & Destructor Documentation

◆ ComplexEquationSystemProblemOperator()

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

inline

Definition at line 23 of file ComplexEquationSystemProblemOperator.h.

    : EquationSystemProblemOperator(problem),
      _equation_system{
          std::dynamic_pointer_cast<Moose::MFEM::ComplexEquationSystem>(_problem_data.eqn_system)}
  {
  }

Member Function Documentation

◆ FormEquationSystemOperator()

void Moose::MFEM::EquationSystemProblemOperator::FormEquationSystemOperator ( )

protectedinherited

Form equation-system state used by Solve().

Definition at line 36 of file EquationSystemProblemOperator.C.

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

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

◆ GetEquationSystem()

virtual Moose::MFEM::ComplexEquationSystem * Moose::MFEM::ComplexEquationSystemProblemOperator::GetEquationSystem ( ) const

inlineoverridevirtual

Returns a pointer to the operator's equation system.

Reimplemented from Moose::MFEM::EquationSystemProblemOperator.

Definition at line 33 of file ComplexEquationSystemProblemOperator.h.

  {
    mooseAssert(_equation_system,
                "No ComplexEquationSystem in ComplexEquationSystemProblemOperator.");
    return _equation_system.get();
  }

Referenced by SetGridFunctions(), and Solve().

◆ Init()

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

virtualinherited

Reimplemented in Moose::MFEM::TimeDependentEquationSystemProblemOperator.

Definition at line 49 of file ProblemOperatorBase.C.

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

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

◆ 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::ComplexEquationSystemProblemOperator::SetGridFunctions ( )

overridevirtual

Reimplemented from Moose::MFEM::EquationSystemProblemOperator.

Definition at line 17 of file ComplexEquationSystemProblemOperator.C.

{
  _trial_var_names = GetEquationSystem()->GetTrialVarNames();
  _test_var_names = GetEquationSystem()->GetTestVarNames();
 
  _cmplx_trial_variables = _problem_data.cmplx_gridfunctions.Get(_trial_var_names);
  _cmplx_test_variables = _problem_data.cmplx_gridfunctions.Get(_test_var_names);
 
  // Set operator size and block structure for trial spaces
  _block_true_offsets_trial.SetSize(_cmplx_trial_variables.size() + 1);
  _block_true_offsets_trial[0] = 0;
  for (const auto ind : index_range(_cmplx_trial_variables))
  {
    _block_true_offsets_trial[ind + 1] =
        2 * _cmplx_trial_variables.at(ind)->ParFESpace()->TrueVSize();
  }
  _block_true_offsets_trial.PartialSum();
 
  // Set operator size and block structure for test spaces
  _block_true_offsets_test.SetSize(_cmplx_test_variables.size() + 1);
  _block_true_offsets_test[0] = 0;
  for (const auto ind : index_range(_cmplx_test_variables))
  {
    _block_true_offsets_test[ind + 1] =
        2 * _cmplx_test_variables.at(ind)->ParFESpace()->TrueVSize();
  }
  _block_true_offsets_test.PartialSum();
 
  _true_x.Update(_block_true_offsets_trial);
  _true_rhs.Update(_block_true_offsets_test);
 
  width = _block_true_offsets_trial[_cmplx_trial_variables.size()];
  height = _block_true_offsets_test[_cmplx_test_variables.size()];
}

◆ SetTrialVariablesFromTrueVectors()

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

virtualinherited

Definition at line 66 of file ProblemOperatorBase.C.

{
  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();
  }
}

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

◆ Solve()

void Moose::MFEM::ComplexEquationSystemProblemOperator::Solve ( )

overridevirtual

Reimplemented from Moose::MFEM::EquationSystemProblemOperator.

Definition at line 53 of file ComplexEquationSystemProblemOperator.C.

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

◆ SolveWithOperator() [1/2]

void Moose::MFEM::ProblemOperatorBase::SolveWithOperator	(	mfem::Operator &	system_operator,
		const mfem::Vector &	rhs,
		mfem::Vector &	x
	)

inlineprotectedinherited

Solve the current system operator using system_operator.GetGradient(x) as the linear operator.

Definition at line 77 of file ProblemOperatorBase.h.

  {
    return SolveWithOperator(system_operator, system_operator.GetGradient(x), rhs, x);
  }

◆ SolveWithOperator() [2/2]

void Moose::MFEM::ProblemOperatorBase::SolveWithOperator	(	mfem::Operator &	system_operator,
		mfem::Operator &	linear_operator,
		const mfem::Vector &	rhs,
		mfem::Vector &	x
	)

protectedinherited

Solve the current system operator using the configured nonlinear and linear solvers.

Definition at line 78 of file ProblemOperatorBase.C.

{
  // Nonlinear solver path for both linear and nonlinear problems. (as a linear problem may still
  // intentionally be solved through the nonlinear solver machinery when one is provided)
  if (_problem_data.nonlinear_solver)
  {
    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;
      linear_solver.SetOperator(linear_operator);
      nonlinear_solver.SetLinearSolver(linear_solver.GetSolver());
    }
 
    nonlinear_solver.SetOperator(system_operator);
    nonlinear_solver.Mult(rhs, x);
  }
  // Linear solver path for linear problems.
  else
  {
    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;
    linear_solver.SetOperator(linear_operator);
    linear_solver.Mult(rhs, x);
  }
}