Equation system specialization for eigenproblems. More...

#include <EigenproblemEquationSystem.h>

Inheritance diagram for Moose::MFEM::EigenproblemEquationSystem:

Public Member Functions
	EigenproblemEquationSystem ()=default

	~EigenproblemEquationSystem () override=default

void	BuildEigenproblemJacobian (mfem::BlockVector &trueX)
	Build eigenproblem system, with essential boundary conditions accounted for. More...

void	PrepareEigensolver (EigensolverBase &solver)
	Prepare the provided eigensolver. More...

virtual void	AddKernel (std::shared_ptr< MFEMKernel > kernel)
	Add kernels. More...

virtual void	AddIntegratedBC (std::shared_ptr< MFEMIntegratedBC > kernel)

virtual void	AddEssentialBC (std::shared_ptr< MFEMEssentialBC > bc)
	Add BC associated with essentially constrained DoFs on boundaries. More...

virtual void	Init (GridFunctions &gridfunctions, ComplexGridFunctions &cmplx_gridfunctions, mfem::AssemblyLevel assembly_level)
	Initialise. More...

void	FormSystem (mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
	Assemble the linear part of the operator, assemble the right-hand side, apply essential and eliminated-variable constraints, and populate the true-DoF vectors used by the solve. More...

void	Mult (const mfem::Vector &u, mfem::Vector &residual) const override
	Compute residual y = Mu. More...

virtual void	ComputeNonlinearResidual (const mfem::Vector &u, mfem::Vector &residual) const
	Compute the contribution to the residual from nonlinear forms only. More...

mfem::Operator &	GetGradient (const mfem::Vector &u) const override
	Get Jacobian at the provided vector of true DoFs of trial variables. More...

virtual void	SetTrialVariablesFromTrueVectors (const mfem::BlockVector &trueX) const
	Update variable from solution vector after solve. More...

void	SetSolverRequiresGradient (bool requires_gradient)
	Set whether the nonlinear solver driving this equation system requires Jacobian information. More...

const std::vector< std::string > &	GetTrialVarNames () const

const std::vector< std::string > &	GetTestVarNames () const

bool	Nonlinear () const

void	PrepareLinearSolver (LinearSolverBase &solver)
	Prepare the provided linear solver. More...

Protected Member Functions
virtual void	ApplyEssentialBCs () override
	Mark external boundaries as essential for eigenproblem BC elimination. More...

void	FormEigenproblemMatrix ()
	Form HypreParMatrix matrix operator for the eigensolver with Dirichlet BC elimination. More...

void	FormMassMatrix ()
	Form mass matrix for the eigensolver with Dirichlet BC elimination. More...

virtual void	AddCoupledVariableNameIfMissing (const std::string &coupled_var_name)
	Add coupled variable to EquationSystem. More...

virtual void	AddEliminatedVariableNameIfMissing (const std::string &eliminated_var_name)
	Add eliminated variable to EquationSystem. More...

virtual void	AddTestVariableNameIfMissing (const std::string &test_var_name)
	Add test variable to EquationSystem. More...

virtual void	SetTrialVariableNames ()
	Set trial variable names from subset of coupled variables that have an associated test variable. More...

void	DeleteHBlocks ()
	Deletes the HypreParMatrix associated with any pointer stored in _h_blocks, and then proceeds to delete all dynamically allocated memory for _h_blocks itself, resetting all dimensions to zero. More...

void	DeleteJacobianBlocks ()
	Deletes the HypreParMatrix associated with any pointer stored in _jacobian_blocks, and then proceeds to delete all dynamically allocated memory for _jacobian_blocks itself, resetting all dimensions to zero. More...

bool	VectorContainsName (const std::vector< std::string > &the_vector, const std::string &name) const

virtual void	ApplyEssentialBC (const std::string &var_name, mfem::ParGridFunction &trial_gf, mfem::Array< int > &global_ess_markers)
	Apply essential BC(s) associated with var_name to set true DoFs of trial_gf and update markers of all essential boundaries. More...

virtual void	EliminateCoupledVariables ()
	Perform trivial eliminations of coupled variables lacking corresponding test variables. More...

virtual void	BuildLinearForms ()
	Build linear forms and eliminate constrained DoFs. More...

virtual void	BuildNonlinearForms ()
	Build non-linear action forms. More...

virtual void	BuildBilinearForms ()
	Build bilinear forms (diagonal Jacobian contributions) More...

virtual void	BuildMixedBilinearForms ()
	Build mixed bilinear forms (off-diagonal Jacobian contributions) More...

virtual void	BuildEquationSystem ()
	Build all forms comprising this EquationSystem. More...

virtual void	FormLinearSystem (mfem::OperatorHandle &op, mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
	Form linear components of system based on on- and off-diagonal bilinear form contributions, populate solution and RHS vectors of true DoFs, and apply constraints. More...

virtual void	FormSystemOperator (mfem::OperatorHandle &op, mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
	Form matrix-free representation of linear components of system operator. More...

virtual void	FormSystemMatrix (mfem::OperatorHandle &op, mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
	Form matrix representation of linear components of system operator as a HypreParMatrix. More...

void	FormJacobianMatrix (const mfem::Vector &u)
	Compute Jacobian matrix at the provided vector of true DoFs of trial variables. More...

template<class FormType >
void	ApplyDomainBLFIntegrators (const std::string &trial_var_name, const std::string &test_var_name, std::shared_ptr< FormType > form, NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &kernels_map, std::optional< mfem::real_t > scale_factor=std::nullopt)
	Template method for applying BilinearFormIntegrators on domains from kernels to a BilinearForm, or MixedBilinearForm. More...

void	ApplyDomainLFIntegrators (const std::string &test_var_name, std::shared_ptr< mfem::ParLinearForm > form, NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &kernels_map)
	Apply domain LinearFormIntegrators from kernels to the linear form associated with the supplied test variable. More...

void	ApplyDomainNLFIntegrators (const std::string &test_var_name, std::shared_ptr< mfem::ParNonlinearForm > form, NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &kernels_map, std::optional< mfem::real_t > scale_factor=std::nullopt)
	Apply domain NonlinearFormIntegrators from kernels to the nonlinear form associated with the supplied test variable. More...

template<class FormType >
void	ApplyBoundaryBLFIntegrators (const std::string &trial_var_name, const std::string &test_var_name, std::shared_ptr< FormType > form, NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &integrated_bc_map, std::optional< mfem::real_t > scale_factor=std::nullopt)
	Template method for applying BilinearFormIntegrators on boundaries from integrated boundary conditions to a BilinearForm, or MixedBilinearForm. More...

void	ApplyBoundaryLFIntegrators (const std::string &test_var_name, std::shared_ptr< mfem::ParLinearForm > form, NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &integrated_bc_map)
	Apply boundary LinearFormIntegrators from integrated boundary conditions to the linear form associated with the supplied test variable. More...

void	ApplyBoundaryNLFIntegrators (const std::string &test_var_name, std::shared_ptr< mfem::ParNonlinearForm > form, NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &integrated_bc_map, std::optional< mfem::real_t > scale_factor=std::nullopt)
	Apply boundary NonlinearFormIntegrators from integrated boundary conditions to the nonlinear form associated with the supplied test variable. More...

virtual bool	Complex () const
	Whether this a complex equation system. More...

Protected Attributes
std::vector< std::string >	_coupled_var_names
	Names of all trial variables of kernels and boundary conditions added to this EquationSystem. More...

std::vector< std::string >	_trial_var_names
	Subset of _coupled_var_names of all variables corresponding to gridfunctions with degrees of freedom that comprise the state vector of this EquationSystem. More...

std::vector< std::string >	_eliminated_var_names
	Names of all coupled variables without a corresponding test variable. More...

Moose::MFEM::GridFunctions	_eliminated_variables
	Pointers to coupled variables not part of the reduced EquationSystem. More...

std::vector< std::string >	_test_var_names
	Names of all test variables corresponding to linear forms in this equation system. More...

std::vector< mfem::ParFiniteElementSpace * >	_test_pfespaces
	Pointers to finite element spaces associated with test variables. More...

std::vector< mfem::ParFiniteElementSpace * >	_coupled_pfespaces
	Pointers to finite element spaces associated with coupled variables. More...

NamedFieldsMap< mfem::ParBilinearForm >	_blfs

NamedFieldsMap< mfem::ParLinearForm >	_lfs

NamedFieldsMap< mfem::ParNonlinearForm >	_nlfs

NamedFieldsMap< NamedFieldsMap< mfem::ParMixedBilinearForm > >	_mblfs

std::vector< std::unique_ptr< mfem::ParGridFunction > >	_var_ess_constraints
	Gridfunctions holding essential constraints from Dirichlet BCs. More...

std::vector< mfem::Array< int > >	_ess_tdof_lists

mfem::Array2D< const mfem::HypreParMatrix * >	_h_blocks

mfem::Array2D< const mfem::HypreParMatrix * >	_jacobian_blocks

NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel > > > >	_kernels_map
	Arrays to store kernels to act on each component of weak form. More...

NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC > > > >	_integrated_bc_map
	Arrays to store integrated BCs to act on each component of weak form. More...

NamedFieldsMap< std::vector< std::shared_ptr< MFEMEssentialBC > > >	_essential_bc_map
	Arrays to store essential BCs to act on each component of weak form. More...

mfem::OperatorHandle	_jacobian

mfem::OperatorHandle	_linear_operator

mfem::AssemblyLevel	_assembly_level

Moose::MFEM::GridFunctions *	_gfuncs

mfem::Array< int >	_block_true_offsets

bool	_non_linear = false

bool	_solver_requires_gradient = false

Private Attributes
mfem::Array< int >	_global_ess_markers

mfem::OperatorHandle	_mass_rhs
	The mass operator (e.g. the RHS operator for a generalized eigenproblem) More...

Friends
class	EigenproblemESProblemOperator

Detailed Description

Equation system specialization for eigenproblems.

Definition at line 21 of file EigenproblemEquationSystem.h.

Constructor & Destructor Documentation

◆ EigenproblemEquationSystem()

Moose::MFEM::EigenproblemEquationSystem::EigenproblemEquationSystem ( )

default

◆ ~EigenproblemEquationSystem()

Moose::MFEM::EigenproblemEquationSystem::~EigenproblemEquationSystem ( )

overridedefault

Member Function Documentation

◆ AddCoupledVariableNameIfMissing()

void Moose::MFEM::EquationSystem::AddCoupledVariableNameIfMissing ( const std::string & coupled_var_name )

protectedvirtualinherited

Add coupled variable to EquationSystem.

Definition at line 56 of file EquationSystem.C.

Referenced by Moose::MFEM::ComplexEquationSystem::AddComplexIntegratedBC(), Moose::MFEM::ComplexEquationSystem::AddComplexKernel(), Moose::MFEM::EquationSystem::AddIntegratedBC(), and Moose::MFEM::EquationSystem::AddKernel().

 {
   if (!VectorContainsName(_coupled_var_names, coupled_var_name))
     _coupled_var_names.push_back(coupled_var_name);
 }

◆ AddEliminatedVariableNameIfMissing()

void Moose::MFEM::EquationSystem::AddEliminatedVariableNameIfMissing ( const std::string & eliminated_var_name )

protectedvirtualinherited

Add eliminated variable to EquationSystem.

Definition at line 63 of file EquationSystem.C.

Referenced by Moose::MFEM::TimeDependentEquationSystem::AddKernel().

 {
   if (!VectorContainsName(_eliminated_var_names, eliminated_var_name))
     _eliminated_var_names.push_back(eliminated_var_name);
 }

◆ AddEssentialBC()

void Moose::MFEM::EquationSystem::AddEssentialBC ( std::shared_ptr< MFEMEssentialBC > bc )

virtualinherited

Add BC associated with essentially constrained DoFs on boundaries.

Definition at line 138 of file EquationSystem.C.

Referenced by MFEMProblem::addBoundaryCondition().

 {
   const auto & test_var_name = bc->getTestVariableName();
   AddTestVariableNameIfMissing(test_var_name);
   // Register new essential bc map if not present for the test variable
   if (!_essential_bc_map.Has(test_var_name))
   {
     auto bcs = std::make_shared<std::vector<std::shared_ptr<MFEMEssentialBC>>>();
     _essential_bc_map.Register(test_var_name, std::move(bcs));
   }
   _essential_bc_map.GetRef(test_var_name).push_back(std::move(bc));
 }

◆ AddIntegratedBC()

void Moose::MFEM::EquationSystem::AddIntegratedBC ( std::shared_ptr< MFEMIntegratedBC > kernel )

virtualinherited

Definition at line 115 of file EquationSystem.C.

Referenced by MFEMProblem::addBoundaryCondition().

 {
   const auto & trial_var_name = bc->getTrialVariableName();
   const auto & test_var_name = bc->getTestVariableName();
   AddCoupledVariableNameIfMissing(trial_var_name);
   AddTestVariableNameIfMissing(test_var_name);
   // Register new integrated bc map if not present for the test variable
   if (!_integrated_bc_map.Has(test_var_name))
   {
     auto integrated_bc_field_map = std::make_shared<
         Moose::MFEM::NamedFieldsMap<std::vector<std::shared_ptr<MFEMIntegratedBC>>>>();
     _integrated_bc_map.Register(test_var_name, std::move(integrated_bc_field_map));
   }
   // Register new integrated bc map if not present for the test/trial variable pair
   if (!_integrated_bc_map.Get(test_var_name)->Has(trial_var_name))
   {
     auto bcs = std::make_shared<std::vector<std::shared_ptr<MFEMIntegratedBC>>>();
     _integrated_bc_map.Get(test_var_name)->Register(trial_var_name, std::move(bcs));
   }
   _integrated_bc_map.GetRef(test_var_name).Get(trial_var_name)->push_back(std::move(bc));
 }

◆ AddKernel()

void Moose::MFEM::EquationSystem::AddKernel ( std::shared_ptr< MFEMKernel > kernel )

virtualinherited

Add kernels.

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 92 of file EquationSystem.C.

Referenced by Moose::MFEM::TimeDependentEquationSystem::AddKernel(), and MFEMProblem::addKernel().

 {
   const auto & trial_var_name = kernel->getTrialVariableName();
   const auto & test_var_name = kernel->getTestVariableName();
   AddCoupledVariableNameIfMissing(trial_var_name);
   AddTestVariableNameIfMissing(test_var_name);
   // Register new kernels map if not present for the test variable
   if (!_kernels_map.Has(test_var_name))
   {
     auto kernel_field_map =
         std::make_shared<Moose::MFEM::NamedFieldsMap<std::vector<std::shared_ptr<MFEMKernel>>>>();
     _kernels_map.Register(test_var_name, std::move(kernel_field_map));
   }
   // Register new kernels map if not present for the test/trial variable pair
   if (!_kernels_map.Get(test_var_name)->Has(trial_var_name))
   {
     auto kernels = std::make_shared<std::vector<std::shared_ptr<MFEMKernel>>>();
     _kernels_map.Get(test_var_name)->Register(trial_var_name, std::move(kernels));
   }
   _kernels_map.GetRef(test_var_name).Get(trial_var_name)->push_back(std::move(kernel));
 }

◆ AddTestVariableNameIfMissing()

void Moose::MFEM::EquationSystem::AddTestVariableNameIfMissing ( const std::string & test_var_name )

protectedvirtualinherited

Add test variable to EquationSystem.

Definition at line 70 of file EquationSystem.C.

Referenced by Moose::MFEM::ComplexEquationSystem::AddComplexEssentialBCs(), Moose::MFEM::ComplexEquationSystem::AddComplexIntegratedBC(), Moose::MFEM::ComplexEquationSystem::AddComplexKernel(), Moose::MFEM::EquationSystem::AddEssentialBC(), Moose::MFEM::EquationSystem::AddIntegratedBC(), Moose::MFEM::TimeDependentEquationSystem::AddKernel(), and Moose::MFEM::EquationSystem::AddKernel().

 {
   if (!VectorContainsName(_test_var_names, test_var_name))
     _test_var_names.push_back(test_var_name);
 }

◆ ApplyBoundaryBLFIntegrators()

template<class FormType >

void Moose::MFEM::EquationSystem::ApplyBoundaryBLFIntegrators	(	const std::string &	trial_var_name,
		const std::string &	test_var_name,
		std::shared_ptr< FormType >	form,
		NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &	integrated_bc_map,
		std::optional< mfem::real_t >	scale_factor = `std::nullopt`
	)

protectedinherited

Template method for applying BilinearFormIntegrators on boundaries from integrated boundary conditions to a BilinearForm, or MixedBilinearForm.

Definition at line 311 of file EquationSystem.h.

 {
   if (integrated_bc_map.Has(test_var_name) &&
       integrated_bc_map.Get(test_var_name)->Has(trial_var_name))
   {
     auto bcs = integrated_bc_map.GetRef(test_var_name).GetRef(trial_var_name);
     for (auto & bc : bcs)
     {
       mfem::BilinearFormIntegrator * integ = bc->createBFIntegrator();
 
       if (integ)
       {
         if (scale_factor.has_value())
           integ = new ScaleIntegrator(integ, scale_factor.value(), true);
         bc->isBoundaryRestricted()
             ? form->AddBoundaryIntegrator(std::move(integ), bc->getBoundaryMarkers())
             : form->AddBoundaryIntegrator(std::move(integ));
       }
     }
   }
 }

◆ ApplyBoundaryLFIntegrators()

void Moose::MFEM::EquationSystem::ApplyBoundaryLFIntegrators	(	const std::string &	test_var_name,
		std::shared_ptr< mfem::ParLinearForm >	form,
		NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &	integrated_bc_map
	)

protectedinherited

Apply boundary LinearFormIntegrators from integrated boundary conditions to the linear form associated with the supplied test variable.

Definition at line 650 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildLinearForms().

 {
   if (integrated_bc_map.Has(test_var_name) &&
       integrated_bc_map.Get(test_var_name)->Has(test_var_name))
   {
     auto bcs = integrated_bc_map.GetRef(test_var_name).GetRef(test_var_name);
     for (auto & bc : bcs)
     {
       mfem::LinearFormIntegrator * integ = bc->createLFIntegrator();
 
       if (integ)
       {
         bc->isBoundaryRestricted()
             ? form->AddBoundaryIntegrator(std::move(integ), bc->getBoundaryMarkers())
             : form->AddBoundaryIntegrator(std::move(integ));
       }
     }
   }
 }

◆ ApplyBoundaryNLFIntegrators()

void Moose::MFEM::EquationSystem::ApplyBoundaryNLFIntegrators	(	const std::string &	test_var_name,
		std::shared_ptr< mfem::ParNonlinearForm >	form,
		NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &	integrated_bc_map,
		std::optional< mfem::real_t >	scale_factor = `std::nullopt`
	)

protectedinherited

Apply boundary NonlinearFormIntegrators from integrated boundary conditions to the nonlinear form associated with the supplied test variable.

Definition at line 675 of file EquationSystem.C.

Referenced by Moose::MFEM::TimeDependentEquationSystem::BuildNonlinearForms(), and Moose::MFEM::EquationSystem::BuildNonlinearForms().

 {
   if (integrated_bc_map.Has(test_var_name))
     for (const auto & [trial_var_name, bcs] : integrated_bc_map.GetRef(test_var_name))
       for (auto & bc : *bcs)
         if (auto * integ = bc->createNLIntegrator())
         {
           if (_solver_requires_gradient && (test_var_name != trial_var_name))
             mooseError(
                 "Support for Off-diagonal MFEM nonlinear boundary integrators in conjunction with "
                 "a nonlinear solver that requires a gradient is not currently "
                 "implemented. Boundary condition '",
                 bc->name(),
                 "' contributes to test variable '",
                 test_var_name,
                 "' from trial variable '",
                 trial_var_name,
                 "'.");
 
           _non_linear = true;
           if (scale_factor.has_value())
             integ = new NLScaleIntegrator(integ, scale_factor.value(), true);
           bc->isBoundaryRestricted()
               ? form->AddBoundaryIntegrator(std::move(integ), bc->getBoundaryMarkers())
               : form->AddBoundaryIntegrator(std::move(integ));
         }
 }

◆ ApplyDomainBLFIntegrators()

template<class FormType >

void Moose::MFEM::EquationSystem::ApplyDomainBLFIntegrators	(	const std::string &	trial_var_name,
		const std::string &	test_var_name,
		std::shared_ptr< FormType >	form,
		NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &	kernels_map,
		std::optional< mfem::real_t >	scale_factor = `std::nullopt`
	)

protectedinherited

Template method for applying BilinearFormIntegrators on domains from kernels to a BilinearForm, or MixedBilinearForm.

Definition at line 283 of file EquationSystem.h.

 {
   if (kernels_map.Has(test_var_name) && kernels_map.Get(test_var_name)->Has(trial_var_name))
   {
     auto kernels = kernels_map.GetRef(test_var_name).GetRef(trial_var_name);
     for (auto & kernel : kernels)
     {
       mfem::BilinearFormIntegrator * integ = kernel->createBFIntegrator();
 
       if (integ)
       {
         if (scale_factor.has_value())
           integ = new ScaleIntegrator(integ, scale_factor.value(), true);
         kernel->isSubdomainRestricted()
             ? form->AddDomainIntegrator(std::move(integ), kernel->getSubdomainMarkers())
             : form->AddDomainIntegrator(std::move(integ));
       }
     }
   }
 }

◆ ApplyDomainLFIntegrators()

void Moose::MFEM::EquationSystem::ApplyDomainLFIntegrators	(	const std::string &	test_var_name,
		std::shared_ptr< mfem::ParLinearForm >	form,
		NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &	kernels_map
	)

protectedinherited

Apply domain LinearFormIntegrators from kernels to the linear form associated with the supplied test variable.

Definition at line 595 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildLinearForms().

 {
   if (kernels_map.Has(test_var_name) && kernels_map.Get(test_var_name)->Has(test_var_name))
   {
     auto kernels = kernels_map.GetRef(test_var_name).GetRef(test_var_name);
     for (auto & kernel : kernels)
     {
       mfem::LinearFormIntegrator * integ = kernel->createLFIntegrator();
 
       if (integ)
       {
         kernel->isSubdomainRestricted()
             ? form->AddDomainIntegrator(std::move(integ), kernel->getSubdomainMarkers())
             : form->AddDomainIntegrator(std::move(integ));
       }
     }
   }
 }

◆ ApplyDomainNLFIntegrators()

void Moose::MFEM::EquationSystem::ApplyDomainNLFIntegrators	(	const std::string &	test_var_name,
		std::shared_ptr< mfem::ParNonlinearForm >	form,
		NamedFieldsMap< NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &	kernels_map,
		std::optional< mfem::real_t >	scale_factor = `std::nullopt`
	)

protectedinherited

Apply domain NonlinearFormIntegrators from kernels to the nonlinear form associated with the supplied test variable.

Definition at line 618 of file EquationSystem.C.

Referenced by Moose::MFEM::TimeDependentEquationSystem::BuildNonlinearForms(), and Moose::MFEM::EquationSystem::BuildNonlinearForms().

 {
   if (kernels_map.Has(test_var_name))
     for (const auto & [trial_var_name, kernels] : kernels_map.GetRef(test_var_name))
       for (auto & kernel : *kernels)
         if (auto * integ = kernel->createNLIntegrator())
         {
           if (_solver_requires_gradient && (trial_var_name != test_var_name))
             mooseError("Support for off-diagonal MFEM nonlinear domain integrators in conjunction "
                        "with a nonlinear solver that requires a gradient is not currently "
                        "implemented. Kernel '",
                        kernel->name(),
                        "' contributes to test variable '",
                        test_var_name,
                        "' from trial variable '",
                        trial_var_name,
                        "'.");
 
           _non_linear = true;
           if (scale_factor.has_value())
             integ = new NLScaleIntegrator(integ, scale_factor.value(), true);
           kernel->isSubdomainRestricted()
               ? form->AddDomainIntegrator(std::move(integ), kernel->getSubdomainMarkers())
               : form->AddDomainIntegrator(std::move(integ));
         }
 }

◆ ApplyEssentialBC()

void Moose::MFEM::EquationSystem::ApplyEssentialBC	(	const std::string &	var_name,
		mfem::ParGridFunction &	trial_gf,
		mfem::Array< int > &	global_ess_markers
	)

protectedvirtualinherited

Apply essential BC(s) associated with var_name to set true DoFs of trial_gf and update markers of all essential boundaries.

Definition at line 207 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::ApplyEssentialBCs().

 {
   if (_essential_bc_map.Has(var_name))
   {
     auto & bcs = _essential_bc_map.GetRef(var_name);
     for (auto & bc : bcs)
     {
       // Set constrained DoFs values on essential boundaries
       bc->ApplyBC(trial_gf);
       // Fetch marker array labelling essential boundaries of current BC
       mfem::Array<int> ess_bdrs(bc->getBoundaryMarkers());
       // Add these boundary markers to the set of markers labelling all essential boundaries
       for (const auto i : make_range(trial_gf.ParFESpace()->GetParMesh()->bdr_attributes.Max()))
         global_ess_markers[i] = std::max(global_ess_markers[i], ess_bdrs[i]);
     }
   }
 }

◆ ApplyEssentialBCs()

void Moose::MFEM::EigenproblemEquationSystem::ApplyEssentialBCs ( )

overrideprotectedvirtual

Mark external boundaries as essential for eigenproblem BC elimination.

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 20 of file EigenproblemEquationSystem.C.

Referenced by BuildEigenproblemJacobian().

 {
   _ess_tdof_lists.resize(1);
   mfem::ParGridFunction & trial_gf = *(_var_ess_constraints.at(0));
   _global_ess_markers.SetSize(trial_gf.ParFESpace()->GetParMesh()->bdr_attributes.Max());
   _global_ess_markers = 0;
   trial_gf.Update();
   trial_gf = _gfuncs->GetRef(_trial_var_names.at(0));
   trial_gf.ParFESpace()->GetParMesh()->MarkExternalBoundaries(_global_ess_markers);
   trial_gf.ParFESpace()->GetEssentialTrueDofs(_global_ess_markers, _ess_tdof_lists.at(0));
 }

◆ BuildBilinearForms()

void Moose::MFEM::EquationSystem::BuildBilinearForms ( )

protectedvirtualinherited

Build bilinear forms (diagonal Jacobian contributions)

Reimplemented in Moose::MFEM::ComplexEquationSystem, and Moose::MFEM::TimeDependentEquationSystem.

Definition at line 526 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildEquationSystem().

 {
   // Register bilinear forms
   for (const auto i : index_range(_test_var_names))
   {
     auto test_var_name = _test_var_names.at(i);
     _blfs.Register(test_var_name, std::make_shared<mfem::ParBilinearForm>(_test_pfespaces.at(i)));
 
     // Apply kernels
     auto blf = _blfs.GetShared(test_var_name);
     blf->SetAssemblyLevel(_assembly_level);
     ApplyBoundaryBLFIntegrators<mfem::ParBilinearForm>(
         test_var_name, test_var_name, blf, _integrated_bc_map);
     ApplyDomainBLFIntegrators<mfem::ParBilinearForm>(
         test_var_name, test_var_name, blf, _kernels_map);
     // Assemble
     blf->Assemble();
   }
 }

◆ BuildEigenproblemJacobian()

void Moose::MFEM::EigenproblemEquationSystem::BuildEigenproblemJacobian ( mfem::BlockVector & trueX )

Build eigenproblem system, with essential boundary conditions accounted for.

Definition at line 65 of file EigenproblemEquationSystem.C.

Referenced by Moose::MFEM::EigenproblemESProblemOperator::BuildEquationSystemOperator().

 {
   mooseAssert(_test_var_names.size() == 1 && (_test_var_names.size() == _trial_var_names.size()) &&
                   (_test_var_names.at(0) == _trial_var_names.at(0)),
               "Eigensolve is only supported for single-variable, square systems");
 
   height = trueX.Size();
   width = trueX.Size();
   ApplyEssentialBCs();
   FormEigenproblemMatrix();
   FormMassMatrix();
 }

◆ BuildEquationSystem()

void Moose::MFEM::EquationSystem::BuildEquationSystem ( )

protectedvirtualinherited

Build all forms comprising this EquationSystem.

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 586 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystemProblemOperator::BuildEquationSystemOperator(), Moose::MFEM::EigenproblemESProblemOperator::BuildEquationSystemOperator(), and Moose::MFEM::TimeDependentEquationSystemProblemOperator::BuildEquationSystemOperator().

 {
   BuildBilinearForms();
   BuildMixedBilinearForms();
   BuildLinearForms();
   BuildNonlinearForms();
 }

◆ BuildLinearForms()

void Moose::MFEM::EquationSystem::BuildLinearForms ( )

protectedvirtualinherited

Build linear forms and eliminate constrained DoFs.

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 483 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildEquationSystem().

 {
   // Register linear forms
   for (const auto i : index_range(_test_var_names))
   {
     auto test_var_name = _test_var_names.at(i);
     _lfs.Register(test_var_name, std::make_shared<mfem::ParLinearForm>(_test_pfespaces.at(i)));
     _lfs.GetRef(test_var_name) = 0.0;
   }
 
   for (auto & test_var_name : _test_var_names)
   {
     // Apply kernels
     auto lf = _lfs.GetShared(test_var_name);
     ApplyDomainLFIntegrators(test_var_name, lf, _kernels_map);
     ApplyBoundaryLFIntegrators(test_var_name, lf, _integrated_bc_map);
     lf->Assemble();
   }
 
   // Apply essential boundary conditions
   ApplyEssentialBCs();
 
   // Eliminate trivially eliminated variables by subtracting contributions from linear forms
   EliminateCoupledVariables();
 }

◆ BuildMixedBilinearForms()

void Moose::MFEM::EquationSystem::BuildMixedBilinearForms ( )

protectedvirtualinherited

Build mixed bilinear forms (off-diagonal Jacobian contributions)

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 547 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildEquationSystem().

 {
   // Register mixed bilinear forms. Note that not all combinations may
   // have a kernel.
 
   // Create mblf for each test/coupled variable pair with an added kernel.
   // Mixed bilinear forms with coupled variables that are not trial variables are
   // associated with contributions from eliminated variables.
   for (const auto i : index_range(_test_var_names))
   {
     auto test_var_name = _test_var_names.at(i);
     auto test_mblfs = std::make_shared<Moose::MFEM::NamedFieldsMap<mfem::ParMixedBilinearForm>>();
     for (const auto j : index_range(_coupled_var_names))
     {
       const auto & coupled_var_name = _coupled_var_names.at(j);
       auto mblf = std::make_shared<mfem::ParMixedBilinearForm>(_coupled_pfespaces.at(j),
                                                                _test_pfespaces.at(i));
       // Register MixedBilinearForm if kernels exist for it, and assemble kernels
       if (_kernels_map.Has(test_var_name) &&
           _kernels_map.Get(test_var_name)->Has(coupled_var_name) &&
           test_var_name != coupled_var_name)
       {
         mblf->SetAssemblyLevel(_assembly_level);
         // Apply all mixed kernels with this test/trial pair
         ApplyDomainBLFIntegrators<mfem::ParMixedBilinearForm>(
             coupled_var_name, test_var_name, mblf, _kernels_map);
         // Assemble mixed bilinear forms
         mblf->Assemble();
         // Register mixed bilinear forms associated with a single trial variable
         // for the current test variable
         test_mblfs->Register(coupled_var_name, mblf);
       }
     }
     // Register all mixed bilinear form sets associated with a single test variable
     _mblfs.Register(test_var_name, test_mblfs);
   }
 }

◆ BuildNonlinearForms()

void Moose::MFEM::EquationSystem::BuildNonlinearForms ( )

protectedvirtualinherited

Build non-linear action forms.

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 510 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildEquationSystem().

 {
   // Register non-linear Action forms
   for (const auto i : index_range(_test_var_names))
   {
     auto test_var_name = _test_var_names.at(i);
     _nlfs.Register(test_var_name, std::make_shared<mfem::ParNonlinearForm>(_test_pfespaces.at(i)));
     // Apply kernels
     auto nlf = _nlfs.GetShared(test_var_name);
     nlf->SetEssentialTrueDofs(_ess_tdof_lists.at(i));
     ApplyDomainNLFIntegrators(test_var_name, nlf, _kernels_map, std::nullopt);
     ApplyBoundaryNLFIntegrators(test_var_name, nlf, _integrated_bc_map, std::nullopt);
   }
 }

◆ Complex()

virtual bool Moose::MFEM::EquationSystem::Complex ( ) const

inlineprotectedvirtualinherited

Whether this a complex equation system.

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 218 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::PrepareLinearSolver().

218 { return false; }

◆ ComputeNonlinearResidual()

void Moose::MFEM::EquationSystem::ComputeNonlinearResidual	(	const mfem::Vector &	u,
		mfem::Vector &	residual
	)		const

virtualinherited

Compute the contribution to the residual from nonlinear forms only.

Definition at line 406 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::Mult().

 {
   mooseAssert(_non_linear, "Should not be calling this method if our forms are not nonlinear");
   residual = 0.0;
 
   const mfem::BlockVector block_solution(const_cast<mfem::Vector &>(sol), _block_true_offsets);
   SetTrialVariablesFromTrueVectors(block_solution);
 
   mfem::BlockVector block_residual(residual, _block_true_offsets);
   for (unsigned int i = 0; i < _test_var_names.size(); i++)
   {
     auto & test_var_name = _test_var_names.at(i);
     auto nlf = _nlfs.GetShared(test_var_name);
     nlf->Mult(block_solution.GetBlock(i), block_residual.GetBlock(i));
     block_residual.GetBlock(i).SyncAliasMemory(block_residual);
   }
 }

◆ DeleteHBlocks()

void Moose::MFEM::EquationSystem::DeleteHBlocks ( )

protectedinherited

Deletes the HypreParMatrix associated with any pointer stored in _h_blocks, and then proceeds to delete all dynamically allocated memory for _h_blocks itself, resetting all dimensions to zero.

Definition at line 26 of file EquationSystem.C.

Referenced by Moose::MFEM::ComplexEquationSystem::FormSystemMatrix(), Moose::MFEM::EquationSystem::FormSystemMatrix(), and Moose::MFEM::EquationSystem::~EquationSystem().

 {
   for (const auto i : make_range(_h_blocks.NumRows()))
     for (const auto j : make_range(_h_blocks.NumCols()))
     {
       if (_jacobian_blocks.NumRows() && _jacobian_blocks(i, j) == _h_blocks(i, j))
         _jacobian_blocks(i, j) = nullptr;
       delete _h_blocks(i, j);
     }
   _h_blocks.DeleteAll();
 }

◆ DeleteJacobianBlocks()

void Moose::MFEM::EquationSystem::DeleteJacobianBlocks ( )

protectedinherited

Deletes the HypreParMatrix associated with any pointer stored in _jacobian_blocks, and then proceeds to delete all dynamically allocated memory for _jacobian_blocks itself, resetting all dimensions to zero.

Definition at line 39 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::FormJacobianMatrix(), and Moose::MFEM::EquationSystem::~EquationSystem().

 {
   for (const auto i : make_range(_jacobian_blocks.NumRows()))
     for (const auto j : make_range(_jacobian_blocks.NumCols()))
       if (!_h_blocks.NumRows() || _jacobian_blocks(i, j) != _h_blocks(i, j))
         delete _jacobian_blocks(i, j);
   _jacobian_blocks.DeleteAll();
 }

◆ EliminateCoupledVariables()

void Moose::MFEM::EquationSystem::EliminateCoupledVariables ( )

protectedvirtualinherited

Perform trivial eliminations of coupled variables lacking corresponding test variables.

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 252 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildLinearForms(), and Moose::MFEM::TimeDependentEquationSystem::EliminateCoupledVariables().

 {
   for (const auto & test_var_name : _test_var_names)
     for (const auto & eliminated_var_name : _eliminated_var_names)
       if (_mblfs.Has(test_var_name) && _mblfs.Get(test_var_name)->Has(eliminated_var_name) &&
           !VectorContainsName(_test_var_names, eliminated_var_name))
       {
         auto & mblf = *_mblfs.Get(test_var_name)->Get(eliminated_var_name);
         mblf.AddMult(*_eliminated_variables.Get(eliminated_var_name), *_lfs.Get(test_var_name), -1);
       }
 }

◆ FormEigenproblemMatrix()

void Moose::MFEM::EigenproblemEquationSystem::FormEigenproblemMatrix ( )

protected

Form HypreParMatrix matrix operator for the eigensolver with Dirichlet BC elimination.

Definition at line 33 of file EigenproblemEquationSystem.C.

Referenced by BuildEigenproblemJacobian().

 {
   auto & test_var_name = _test_var_names.at(0);
   auto blf = _blfs.Get(test_var_name);
 
   blf->EliminateEssentialBCDiag(_global_ess_markers, 1.0);
   blf->Finalize();
   _jacobian.Reset(blf->ParallelAssemble());
 }

◆ FormJacobianMatrix()

void Moose::MFEM::EquationSystem::FormJacobianMatrix ( const mfem::Vector & u )

protectedinherited

Compute Jacobian matrix at the provided vector of true DoFs of trial variables.

Definition at line 425 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::GetGradient().

 {
   DeleteJacobianBlocks();
   _jacobian_blocks.SetSize(_test_var_names.size(), _trial_var_names.size());
   _jacobian_blocks = nullptr;
 
   const mfem::BlockVector update_vector(const_cast<mfem::Vector &>(u), _block_true_offsets);
   for (const auto i : index_range(_test_var_names))
   {
     auto test_var_name = _test_var_names.at(i);
     if (_nlfs.Has(test_var_name))
     {
       auto nlf = _nlfs.Get(test_var_name);
       mfem::HypreParMatrix * nlf_jac =
           dynamic_cast<mfem::HypreParMatrix *>(&nlf->GetGradient(update_vector.GetBlock(i)));
       mooseAssert(nlf_jac,
                   "Jacobian contribution of nonlinear form associated with " + test_var_name +
                       " is not castable into a HypreParMatrix");
       _jacobian_blocks(i, i) = mfem::ParAdd(_h_blocks(i, i), nlf_jac);
     }
     else
       _jacobian_blocks(i, i) = _h_blocks(i, i);
     for (const auto j : index_range(_trial_var_names))
       if (i != j) // nlf->GetGradient only contributes to on-diagonal blocks
         _jacobian_blocks(i, j) = _h_blocks(i, j);
   }
   // Create monolithic matrix
   _jacobian.Reset(mfem::HypreParMatrixFromBlocks(_jacobian_blocks));
 }

◆ FormLinearSystem()

void Moose::MFEM::EquationSystem::FormLinearSystem	(	mfem::OperatorHandle &	op,
		mfem::BlockVector &	trueX,
		mfem::BlockVector &	trueRHS
	)

protectedvirtualinherited

Form linear components of system based on on- and off-diagonal bilinear form contributions, populate solution and RHS vectors of true DoFs, and apply constraints.

Definition at line 265 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::FormSystem().

 {
   mooseAssert(_test_var_names.size() == _trial_var_names.size(),
               "Number of test and trial variables must be the same for block matrix assembly.");
 
   if (_assembly_level == mfem::AssemblyLevel::LEGACY)
     FormSystemMatrix(op, trueX, trueRHS);
   else
   {
     mooseAssert(_test_var_names.size() == 1 && _test_var_names.size() == _trial_var_names.size(),
                 "Non-legacy assembly is only supported for single test and trial variable systems");
     FormSystemOperator(op, trueX, trueRHS);
   }
 }

◆ FormMassMatrix()

void Moose::MFEM::EigenproblemEquationSystem::FormMassMatrix ( )

protected

Form mass matrix for the eigensolver with Dirichlet BC elimination.

Definition at line 44 of file EigenproblemEquationSystem.C.

Referenced by BuildEigenproblemJacobian().

 {
   mfem::ConstantCoefficient one(1.0);
   mfem::ParFiniteElementSpace * fespace = _test_pfespaces.at(0);
   std::unique_ptr<mfem::ParBilinearForm> m = std::make_unique<mfem::ParBilinearForm>(fespace);
 
   if (fespace->GetTypicalFE()->GetRangeType() == mfem::FiniteElement::SCALAR)
     m->AddDomainIntegrator(new mfem::MassIntegrator(one));
   else
     m->AddDomainIntegrator(new mfem::VectorFEMassIntegrator(one));
 
   m->Assemble();
   // Shift the eigenvalue corresponding to eliminated dofs to a large value. The BC DoFs on the
   // stiffness matrix are set to 1 and the mass matrix BC DoFs are set to a small value eps, such
   // that the eigenvaluesd associate with these DOFs are ~1/eps.
   m->EliminateEssentialBCDiag(_global_ess_markers, std::numeric_limits<mfem::real_t>::min());
   m->Finalize();
   _mass_rhs.Reset(m->ParallelAssemble());
 }

◆ FormSystem()

void Moose::MFEM::EquationSystem::FormSystem	(	mfem::BlockVector &	trueX,
		mfem::BlockVector &	trueRHS
	)

inherited

Assemble the linear part of the operator, assemble the right-hand side, apply essential and eliminated-variable constraints, and populate the true-DoF vectors used by the solve.

Definition at line 374 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystemProblemOperator::BuildEquationSystemOperator(), and Moose::MFEM::TimeDependentEquationSystemProblemOperator::BuildEquationSystemOperator().

 {
   height = trueX.Size();
   width = trueRHS.Size();
   // Store block offsets
   _block_true_offsets.SetSize(trueX.NumBlocks() + 1);
   _block_true_offsets[0] = 0;
   for (unsigned i = 0; i < _trial_var_names.size(); i++)
     _block_true_offsets[i + 1] = trueX.BlockSize(i);
   _block_true_offsets.PartialSum();
   FormLinearSystem(_linear_operator, trueX, trueRHS);
 }

◆ FormSystemMatrix()

void Moose::MFEM::EquationSystem::FormSystemMatrix	(	mfem::OperatorHandle &	op,
		mfem::BlockVector &	trueX,
		mfem::BlockVector &	trueRHS
	)

protectedvirtualinherited

Form matrix representation of linear components of system operator as a HypreParMatrix.

Used when EquationSystem assembly level is set to 'LEGACY'.

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 310 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::FormLinearSystem().

 {
   // Allocate block operator
   DeleteHBlocks();
   _h_blocks.SetSize(_test_var_names.size(), _trial_var_names.size());
   _h_blocks = nullptr;
   // Zero out RHS and sync memory
   trueRHS = 0.0;
   trueRHS.SyncToBlocks();
 
   for (const auto i : index_range(_test_var_names))
   {
     auto test_var_name = _test_var_names.at(i);
 
     for (const auto j : index_range(_trial_var_names))
     {
       auto trial_var_name = _trial_var_names.at(j);
 
       mfem::Vector aux_x, aux_rhs;
       mfem::ParLinearForm aux_lf(_test_pfespaces.at(i));
       mfem::HypreParMatrix * aux_a = new mfem::HypreParMatrix;
 
       if (test_var_name == trial_var_name)
       {
         mooseAssert(i == j, "Trial and test variables must have the same ordering.");
         auto blf = _blfs.Get(test_var_name);
         blf->FormLinearSystem(_ess_tdof_lists.at(j),
                               *_var_ess_constraints.at(j),
                               *_lfs.Get(test_var_name),
                               *aux_a,
                               aux_x,
                               aux_rhs,
                               /*copy_interior=*/true);
         trueX.GetBlock(j) = aux_x;
       }
       else if (_mblfs.Has(test_var_name) && _mblfs.Get(test_var_name)->Has(trial_var_name))
       {
         auto mblf = _mblfs.Get(test_var_name)->Get(trial_var_name);
         mblf->FormRectangularLinearSystem(_ess_tdof_lists.at(j),
                                           _ess_tdof_lists.at(i),
                                           *_var_ess_constraints.at(j),
                                           aux_lf = 0,
                                           *aux_a,
                                           aux_x,
                                           aux_rhs);
       }
       else
         continue;
 
       trueRHS.GetBlock(i) += aux_rhs;
       _h_blocks(i, j) = aux_a;
     }
   }
   // Sync memory
   trueX.SyncFromBlocks();
   trueRHS.SyncFromBlocks();
 
   // Create monolithic matrix
   op.Reset(mfem::HypreParMatrixFromBlocks(_h_blocks));
 }

◆ FormSystemOperator()

void Moose::MFEM::EquationSystem::FormSystemOperator	(	mfem::OperatorHandle &	op,
		mfem::BlockVector &	trueX,
		mfem::BlockVector &	trueRHS
	)

protectedvirtualinherited

Form matrix-free representation of linear components of system operator.

Used when EquationSystem assembly level is set to 'FULL', 'ELEMENT', 'PARTIAL', or 'NONE'.

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 283 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::FormLinearSystem().

 {
   auto & test_var_name = _test_var_names.at(0);
   mfem::Vector aux_x, aux_rhs;
   mfem::OperatorPtr aux_a;
 
   auto blf = _blfs.Get(test_var_name);
   blf->FormLinearSystem(_ess_tdof_lists.at(0),
                         *_var_ess_constraints.at(0),
                         *_lfs.Get(test_var_name),
                         aux_a,
                         aux_x,
                         aux_rhs,
                         /*copy_interior=*/true);
 
   trueX.GetBlock(0) = aux_x;
   trueRHS.GetBlock(0) = aux_rhs;
   trueX.SyncFromBlocks();
   trueRHS.SyncFromBlocks();
 
   op.Reset(aux_a.Ptr());
   aux_a.SetOperatorOwner(false);
 }

◆ GetGradient()

mfem::Operator & Moose::MFEM::EquationSystem::GetGradient ( const mfem::Vector & u ) const

overrideinherited

Get Jacobian at the provided vector of true DoFs of trial variables.

Definition at line 456 of file EquationSystem.C.

 {
   if (_non_linear)
   {
     if (_assembly_level != mfem::AssemblyLevel::LEGACY)
       mooseError("MFEM nonlinear solvers that require GetGradient() currently require legacy "
                  "assembly in EquationSystem.");
     const_cast<EquationSystem *>(this)->FormJacobianMatrix(u);
   }
   else
     _jacobian = _linear_operator;
 
   return *_jacobian;
 }

◆ GetTestVarNames()

const std::vector<std::string>& Moose::MFEM::EquationSystem::GetTestVarNames ( ) const

inlineinherited

Definition at line 74 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystemProblemOperator::SetGridFunctions(), Moose::MFEM::ComplexEquationSystemProblemOperator::SetGridFunctions(), and Moose::MFEM::TimeDependentEquationSystemProblemOperator::SetGridFunctions().

74 { return _test_var_names; }

Moose::MFEM::EquationSystem::_test_var_names

std::vector< std::string > _test_var_names

Names of all test variables corresponding to linear forms in this equation system.

Definition: EquationSystem.h:232

◆ GetTrialVarNames()

const std::vector<std::string>& Moose::MFEM::EquationSystem::GetTrialVarNames ( ) const

inlineinherited

Definition at line 73 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystemProblemOperator::SetGridFunctions(), Moose::MFEM::ComplexEquationSystemProblemOperator::SetGridFunctions(), and Moose::MFEM::TimeDependentEquationSystemProblemOperator::SetGridFunctions().

73 { return _trial_var_names; }

Moose::MFEM::EquationSystem::_trial_var_names

std::vector< std::string > _trial_var_names

Subset of _coupled_var_names of all variables corresponding to gridfunctions with degrees of freedom ...

Definition: EquationSystem.h:226

◆ Init()

void Moose::MFEM::EquationSystem::Init	(	GridFunctions &	gridfunctions,
		ComplexGridFunctions &	cmplx_gridfunctions,
		mfem::AssemblyLevel	assembly_level
	)

virtualinherited

Initialise.

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 152 of file EquationSystem.C.

 {
   _assembly_level = assembly_level;
 
   if (cmplx_gridfunctions.size())
     mooseError("Complex variables have been created but the executioner numeric type has not been "
                "set to complex. Please set Executioner/numeric_type = complex.");
 
   // Extract which coupled variables are to be trivially eliminated and which are trial variables
   SetTrialVariableNames();
 
   for (auto & test_var_name : _test_var_names)
   {
     if (!gridfunctions.Has(test_var_name))
     {
       mooseError("MFEM variable ",
                  test_var_name,
                  " requested by equation system during initialization was "
                  "not found in gridfunctions");
     }
     // Store pointers to test FESpaces
     _test_pfespaces.push_back(gridfunctions.Get(test_var_name)->ParFESpace());
   }
 
   for (auto & trial_var_name : _trial_var_names)
   {
     if (!gridfunctions.Has(trial_var_name))
     {
       mooseError("MFEM variable ",
                  trial_var_name,
                  " requested by equation system during initialization was "
                  "not found in gridfunctions");
     }
     // Create auxiliary gridfunctions for storing essential constraints from Dirichlet conditions
     _var_ess_constraints.emplace_back(
         std::make_unique<mfem::ParGridFunction>(gridfunctions.Get(trial_var_name)->ParFESpace()));
   }
 
   // Store pointers to FESpaces of all coupled variables
   for (auto & coupled_var_name : _coupled_var_names)
     _coupled_pfespaces.push_back(gridfunctions.Get(coupled_var_name)->ParFESpace());
 
   // Store pointers to coupled variable GridFunctions that are to be eliminated prior to forming the
   // jacobian
   for (auto & eliminated_var_name : _eliminated_var_names)
     _eliminated_variables.Register(eliminated_var_name,
                                    gridfunctions.GetShared(eliminated_var_name));
 
   // Get a reference to the GridFunctions
   _gfuncs = &gridfunctions;
 }

◆ Mult()

void Moose::MFEM::EquationSystem::Mult	(	const mfem::Vector &	u,
		mfem::Vector &	residual
	)		const

overrideinherited

Compute residual y = Mu.

Definition at line 388 of file EquationSystem.C.

 {
   if (_non_linear)
   {
     ComputeNonlinearResidual(sol, residual);
     _linear_operator->AddMult(sol, residual);
   }
   else
   {
     residual = 0.0;
     _linear_operator->Mult(sol, residual);
   }
 
   sol.HostRead();
   residual.HostRead();
 }

◆ Nonlinear()

bool Moose::MFEM::EquationSystem::Nonlinear ( ) const

inlineinherited

Returns: Whether nonlinear integrators are present

Definition at line 79 of file EquationSystem.h.

Referenced by Moose::MFEM::ProblemOperatorBase::SolveWithOperator().

79 { return _non_linear; }

Moose::MFEM::EquationSystem::_non_linear

bool _non_linear

Definition: EquationSystem.h:270

◆ PrepareEigensolver()

void Moose::MFEM::EigenproblemEquationSystem::PrepareEigensolver ( EigensolverBase & solver )

Prepare the provided eigensolver.

Definition at line 79 of file EigenproblemEquationSystem.C.

 {
   solver.SetMassMatrix(_mass_rhs);
   solver.SetOperator(_jacobian);
 }

◆ PrepareLinearSolver()

void Moose::MFEM::EquationSystem::PrepareLinearSolver ( LinearSolverBase & solver )

inherited

Prepare the provided linear solver.

First calls SetupLOR on the solver if it's using a Low Order Refined methodology and then calls SetOperator on the solver with the assembled linear operator

Definition at line 709 of file EquationSystem.C.

Referenced by Moose::MFEM::ProblemOperatorBase::SolveWithOperator().

 {
   if (solver.IsLOR())
   {
     if (Complex())
       mooseError("LOR solve is not supported for complex equation systems.");
     if (_test_var_names.size() > 1)
       mooseError("LOR solve is only supported for single-variable systems");
     solver.SetupLOR(*_blfs.Get(_test_var_names.at(0)), _ess_tdof_lists.at(0));
   }
 
   mooseAssert(_linear_operator.Ptr(),
               "If we are preparing a linear solver, we better have a linear operator");
   solver.SetOperator(_linear_operator);
 }

◆ SetSolverRequiresGradient()

void Moose::MFEM::EquationSystem::SetSolverRequiresGradient ( bool requires_gradient )

inlineinherited

Set whether the nonlinear solver driving this equation system requires Jacobian information.

Definition at line 66 of file EquationSystem.h.

   {
     _solver_requires_gradient = requires_gradient;
   }

◆ SetTrialVariableNames()

void Moose::MFEM::EquationSystem::SetTrialVariableNames ( )

protectedvirtualinherited

Set trial variable names from subset of coupled variables that have an associated test variable.

Definition at line 77 of file EquationSystem.C.

Referenced by Moose::MFEM::ComplexEquationSystem::Init(), and Moose::MFEM::EquationSystem::Init().

 {
   // If a coupled variable has an equation associated with it,
   // add it to the set of trial variables.
   for (const auto & test_var_name : _test_var_names)
     if (VectorContainsName(_coupled_var_names, test_var_name))
       _trial_var_names.push_back(test_var_name);
 
   // Otherwise, add it to the set of eliminated variables.
   for (const auto & coupled_var_name : _coupled_var_names)
     if (!VectorContainsName(_test_var_names, coupled_var_name))
       _eliminated_var_names.push_back(coupled_var_name);
 }

◆ SetTrialVariablesFromTrueVectors()

void Moose::MFEM::EquationSystem::SetTrialVariablesFromTrueVectors ( const mfem::BlockVector & trueX ) const

virtualinherited

Update variable from solution vector after solve.

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 472 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::ComputeNonlinearResidual().

 {
   for (const auto i : index_range(_trial_var_names))
   {
     auto & trial_var_name = _trial_var_names.at(i);
     trueX.GetBlock(i).SyncMemory(trueX);
     _gfuncs->Get(trial_var_name)->Distribute(&(trueX.GetBlock(i)));
   }
 }

◆ VectorContainsName()

bool Moose::MFEM::EquationSystem::VectorContainsName	(	const std::vector< std::string > &	the_vector,
		const std::string &	name
	)		const

protectedinherited

Definition at line 49 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::AddCoupledVariableNameIfMissing(), Moose::MFEM::EquationSystem::AddEliminatedVariableNameIfMissing(), Moose::MFEM::EquationSystem::AddTestVariableNameIfMissing(), Moose::MFEM::EquationSystem::EliminateCoupledVariables(), and Moose::MFEM::EquationSystem::SetTrialVariableNames().

 {
   return std::find(the_vector.begin(), the_vector.end(), name) != the_vector.end();
 }

Friends And Related Function Documentation

◆ EigenproblemESProblemOperator

friend class EigenproblemESProblemOperator

friend

Definition at line 44 of file EigenproblemEquationSystem.h.

Member Data Documentation

◆ _assembly_level

mfem::AssemblyLevel Moose::MFEM::EquationSystem::_assembly_level

protectedinherited

Definition at line 263 of file EquationSystem.h.

Referenced by Moose::MFEM::TimeDependentEquationSystem::BuildBilinearForms(), Moose::MFEM::ComplexEquationSystem::BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildBilinearForms(), Moose::MFEM::TimeDependentEquationSystem::BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::FormLinearSystem(), Moose::MFEM::EquationSystem::GetGradient(), Moose::MFEM::ComplexEquationSystem::Init(), and Moose::MFEM::EquationSystem::Init().

◆ _blfs

NamedFieldsMap<mfem::ParBilinearForm> Moose::MFEM::EquationSystem::_blfs

protectedinherited

Definition at line 239 of file EquationSystem.h.

Referenced by Moose::MFEM::TimeDependentEquationSystem::BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildBilinearForms(), FormEigenproblemMatrix(), Moose::MFEM::EquationSystem::FormSystemMatrix(), Moose::MFEM::EquationSystem::FormSystemOperator(), and Moose::MFEM::EquationSystem::PrepareLinearSolver().

◆ _block_true_offsets

mfem::Array<int> Moose::MFEM::EquationSystem::_block_true_offsets

protectedinherited

Definition at line 268 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::ComputeNonlinearResidual(), Moose::MFEM::EquationSystem::FormJacobianMatrix(), and Moose::MFEM::EquationSystem::FormSystem().

◆ _coupled_pfespaces

std::vector<mfem::ParFiniteElementSpace *> Moose::MFEM::EquationSystem::_coupled_pfespaces

protectedinherited

Pointers to finite element spaces associated with coupled variables.

Definition at line 236 of file EquationSystem.h.

Referenced by Moose::MFEM::TimeDependentEquationSystem::BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), Moose::MFEM::ComplexEquationSystem::Init(), and Moose::MFEM::EquationSystem::Init().

◆ _coupled_var_names

std::vector<std::string> Moose::MFEM::EquationSystem::_coupled_var_names

protectedinherited

Names of all trial variables of kernels and boundary conditions added to this EquationSystem.

Definition at line 222 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AddCoupledVariableNameIfMissing(), Moose::MFEM::TimeDependentEquationSystem::BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), Moose::MFEM::ComplexEquationSystem::Init(), Moose::MFEM::EquationSystem::Init(), and Moose::MFEM::EquationSystem::SetTrialVariableNames().

◆ _eliminated_var_names

std::vector<std::string> Moose::MFEM::EquationSystem::_eliminated_var_names

protectedinherited

Names of all coupled variables without a corresponding test variable.

Definition at line 228 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AddEliminatedVariableNameIfMissing(), Moose::MFEM::TimeDependentEquationSystem::EliminateCoupledVariables(), Moose::MFEM::EquationSystem::EliminateCoupledVariables(), Moose::MFEM::ComplexEquationSystem::Init(), Moose::MFEM::EquationSystem::Init(), and Moose::MFEM::EquationSystem::SetTrialVariableNames().

◆ _eliminated_variables

Moose::MFEM::GridFunctions Moose::MFEM::EquationSystem::_eliminated_variables

protectedinherited

Pointers to coupled variables not part of the reduced EquationSystem.

Definition at line 230 of file EquationSystem.h.

Referenced by Moose::MFEM::TimeDependentEquationSystem::EliminateCoupledVariables(), Moose::MFEM::EquationSystem::EliminateCoupledVariables(), and Moose::MFEM::EquationSystem::Init().

◆ _ess_tdof_lists

std::vector<mfem::Array<int> > Moose::MFEM::EquationSystem::_ess_tdof_lists

protectedinherited

Definition at line 246 of file EquationSystem.h.

Referenced by ApplyEssentialBCs(), Moose::MFEM::ComplexEquationSystem::ApplyEssentialBCs(), Moose::MFEM::EquationSystem::ApplyEssentialBCs(), Moose::MFEM::TimeDependentEquationSystem::BuildNonlinearForms(), Moose::MFEM::EquationSystem::BuildNonlinearForms(), Moose::MFEM::ComplexEquationSystem::FormSystemMatrix(), Moose::MFEM::EquationSystem::FormSystemMatrix(), Moose::MFEM::ComplexEquationSystem::FormSystemOperator(), Moose::MFEM::EquationSystem::FormSystemOperator(), and Moose::MFEM::EquationSystem::PrepareLinearSolver().

◆ _essential_bc_map

NamedFieldsMap<std::vector<std::shared_ptr<MFEMEssentialBC> > > Moose::MFEM::EquationSystem::_essential_bc_map

protectedinherited

Arrays to store essential BCs to act on each component of weak form.

Named according to test variable.

Definition at line 257 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AddEssentialBC(), and Moose::MFEM::EquationSystem::ApplyEssentialBC().

◆ _gfuncs

Moose::MFEM::GridFunctions* Moose::MFEM::EquationSystem::_gfuncs

protectedinherited

Definition at line 266 of file EquationSystem.h.

Referenced by ApplyEssentialBCs(), Moose::MFEM::EquationSystem::ApplyEssentialBCs(), Moose::MFEM::EquationSystem::Init(), and Moose::MFEM::EquationSystem::SetTrialVariablesFromTrueVectors().

◆ _global_ess_markers

mfem::Array<int> Moose::MFEM::EigenproblemEquationSystem::_global_ess_markers

private

Definition at line 46 of file EigenproblemEquationSystem.h.

Referenced by ApplyEssentialBCs(), FormEigenproblemMatrix(), and FormMassMatrix().

◆ _h_blocks

mfem::Array2D<const mfem::HypreParMatrix *> Moose::MFEM::EquationSystem::_h_blocks

protectedinherited

Definition at line 248 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::DeleteHBlocks(), Moose::MFEM::EquationSystem::DeleteJacobianBlocks(), Moose::MFEM::EquationSystem::FormJacobianMatrix(), Moose::MFEM::ComplexEquationSystem::FormSystemMatrix(), and Moose::MFEM::EquationSystem::FormSystemMatrix().

◆ _integrated_bc_map

NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMIntegratedBC> > > > Moose::MFEM::EquationSystem::_integrated_bc_map

protectedinherited

Arrays to store integrated BCs to act on each component of weak form.

Named according to test and trial variables.

Definition at line 254 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AddIntegratedBC(), Moose::MFEM::TimeDependentEquationSystem::BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildLinearForms(), Moose::MFEM::TimeDependentEquationSystem::BuildMixedBilinearForms(), Moose::MFEM::TimeDependentEquationSystem::BuildNonlinearForms(), and Moose::MFEM::EquationSystem::BuildNonlinearForms().

◆ _jacobian

mfem::OperatorHandle Moose::MFEM::EquationSystem::_jacobian

mutableprotectedinherited

Definition at line 260 of file EquationSystem.h.

Referenced by FormEigenproblemMatrix(), Moose::MFEM::EquationSystem::FormJacobianMatrix(), Moose::MFEM::EquationSystem::GetGradient(), and PrepareEigensolver().

◆ _jacobian_blocks

mfem::Array2D<const mfem::HypreParMatrix *> Moose::MFEM::EquationSystem::_jacobian_blocks

protectedinherited

Definition at line 248 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::DeleteHBlocks(), Moose::MFEM::EquationSystem::DeleteJacobianBlocks(), and Moose::MFEM::EquationSystem::FormJacobianMatrix().

◆ _kernels_map

NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMKernel> > > > Moose::MFEM::EquationSystem::_kernels_map

protectedinherited

Arrays to store kernels to act on each component of weak form.

Named according to test and trial variables.

Definition at line 251 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AddKernel(), Moose::MFEM::TimeDependentEquationSystem::BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildLinearForms(), Moose::MFEM::TimeDependentEquationSystem::BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), Moose::MFEM::TimeDependentEquationSystem::BuildNonlinearForms(), and Moose::MFEM::EquationSystem::BuildNonlinearForms().

◆ _lfs

NamedFieldsMap<mfem::ParLinearForm> Moose::MFEM::EquationSystem::_lfs

protectedinherited

Definition at line 240 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::BuildLinearForms(), Moose::MFEM::TimeDependentEquationSystem::EliminateCoupledVariables(), Moose::MFEM::EquationSystem::EliminateCoupledVariables(), Moose::MFEM::EquationSystem::FormSystemMatrix(), and Moose::MFEM::EquationSystem::FormSystemOperator().

◆ _linear_operator

mfem::OperatorHandle Moose::MFEM::EquationSystem::_linear_operator

mutableprotectedinherited

Definition at line 262 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::FormSystem(), Moose::MFEM::EquationSystem::GetGradient(), Moose::MFEM::ComplexEquationSystem::Mult(), Moose::MFEM::EquationSystem::Mult(), and Moose::MFEM::EquationSystem::PrepareLinearSolver().

◆ _mass_rhs

mfem::OperatorHandle Moose::MFEM::EigenproblemEquationSystem::_mass_rhs

private

The mass operator (e.g. the RHS operator for a generalized eigenproblem)

Definition at line 48 of file EigenproblemEquationSystem.h.

Referenced by FormMassMatrix(), and PrepareEigensolver().

◆ _mblfs

NamedFieldsMap<NamedFieldsMap<mfem::ParMixedBilinearForm> > Moose::MFEM::EquationSystem::_mblfs

protectedinherited

Definition at line 242 of file EquationSystem.h.

Referenced by Moose::MFEM::TimeDependentEquationSystem::BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::EliminateCoupledVariables(), and Moose::MFEM::EquationSystem::FormSystemMatrix().

◆ _nlfs

NamedFieldsMap<mfem::ParNonlinearForm> Moose::MFEM::EquationSystem::_nlfs

protectedinherited

Definition at line 241 of file EquationSystem.h.

Referenced by Moose::MFEM::TimeDependentEquationSystem::BuildNonlinearForms(), Moose::MFEM::EquationSystem::BuildNonlinearForms(), Moose::MFEM::EquationSystem::ComputeNonlinearResidual(), and Moose::MFEM::EquationSystem::FormJacobianMatrix().

◆ _non_linear

bool Moose::MFEM::EquationSystem::_non_linear = false

protectedinherited

Definition at line 270 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::ApplyBoundaryNLFIntegrators(), Moose::MFEM::EquationSystem::ApplyDomainNLFIntegrators(), Moose::MFEM::EquationSystem::ComputeNonlinearResidual(), Moose::MFEM::EquationSystem::GetGradient(), Moose::MFEM::EquationSystem::Mult(), and Moose::MFEM::EquationSystem::Nonlinear().

◆ _solver_requires_gradient

bool Moose::MFEM::EquationSystem::_solver_requires_gradient = false

protectedinherited

Definition at line 272 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::ApplyBoundaryNLFIntegrators(), Moose::MFEM::EquationSystem::ApplyDomainNLFIntegrators(), and Moose::MFEM::EquationSystem::SetSolverRequiresGradient().

◆ _test_pfespaces

std::vector<mfem::ParFiniteElementSpace *> Moose::MFEM::EquationSystem::_test_pfespaces

protectedinherited

Pointers to finite element spaces associated with test variables.

Definition at line 234 of file EquationSystem.h.

◆ _test_var_names

std::vector<std::string> Moose::MFEM::EquationSystem::_test_var_names

protectedinherited

Names of all test variables corresponding to linear forms in this equation system.

Definition at line 232 of file EquationSystem.h.

◆ _trial_var_names

std::vector<std::string> Moose::MFEM::EquationSystem::_trial_var_names

protectedinherited

Subset of _coupled_var_names of all variables corresponding to gridfunctions with degrees of freedom that comprise the state vector of this EquationSystem.

This will differ from _coupled_var_names when time derivatives or other eliminated variables are present.

Definition at line 226 of file EquationSystem.h.

◆ _var_ess_constraints

std::vector<std::unique_ptr<mfem::ParGridFunction> > Moose::MFEM::EquationSystem::_var_ess_constraints

protectedinherited

Gridfunctions holding essential constraints from Dirichlet BCs.

Definition at line 245 of file EquationSystem.h.

Referenced by ApplyEssentialBCs(), Moose::MFEM::EquationSystem::ApplyEssentialBCs(), Moose::MFEM::EquationSystem::FormSystemMatrix(), Moose::MFEM::EquationSystem::FormSystemOperator(), and Moose::MFEM::EquationSystem::Init().

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

include/mfem/equation_systems/EigenproblemEquationSystem.h
src/mfem/equation_systems/EigenproblemEquationSystem.C

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ EigenproblemEquationSystem()

◆ ~EigenproblemEquationSystem()

Member Function Documentation

◆ AddCoupledVariableNameIfMissing()

◆ AddEliminatedVariableNameIfMissing()

◆ AddEssentialBC()

◆ AddIntegratedBC()

◆ AddKernel()

◆ AddTestVariableNameIfMissing()

◆ ApplyBoundaryBLFIntegrators()

◆ ApplyBoundaryLFIntegrators()

◆ ApplyBoundaryNLFIntegrators()

◆ ApplyDomainBLFIntegrators()

◆ ApplyDomainLFIntegrators()

◆ ApplyDomainNLFIntegrators()

◆ ApplyEssentialBC()

◆ ApplyEssentialBCs()

◆ BuildBilinearForms()

◆ BuildEigenproblemJacobian()

◆ BuildEquationSystem()

◆ BuildLinearForms()

◆ BuildMixedBilinearForms()

◆ BuildNonlinearForms()

◆ Complex()

◆ ComputeNonlinearResidual()

◆ DeleteHBlocks()

◆ DeleteJacobianBlocks()

◆ EliminateCoupledVariables()

◆ FormEigenproblemMatrix()

◆ FormJacobianMatrix()

◆ FormLinearSystem()

◆ FormMassMatrix()

◆ FormSystem()

◆ FormSystemMatrix()

◆ FormSystemOperator()

◆ GetGradient()

◆ GetTestVarNames()

◆ GetTrialVarNames()

◆ Init()

◆ Mult()

◆ Nonlinear()

◆ PrepareEigensolver()

◆ PrepareLinearSolver()

◆ SetSolverRequiresGradient()

◆ SetTrialVariableNames()

◆ SetTrialVariablesFromTrueVectors()

◆ VectorContainsName()

Friends And Related Function Documentation

◆ EigenproblemESProblemOperator

Member Data Documentation

◆ _assembly_level

◆ _blfs

◆ _block_true_offsets

◆ _coupled_pfespaces

◆ _coupled_var_names

◆ _eliminated_var_names

◆ _eliminated_variables

◆ _ess_tdof_lists

◆ _essential_bc_map

◆ _gfuncs

◆ _global_ess_markers

◆ _h_blocks

◆ _integrated_bc_map

◆ _jacobian

◆ _jacobian_blocks

◆ _kernels_map

◆ _lfs

◆ _linear_operator

◆ _mass_rhs

◆ _mblfs

◆ _nlfs

◆ _non_linear

◆ _solver_requires_gradient