Class to store weak form components for time dependent PDEs. More...

#include <TimeDependentEquationSystem.h>

Inheritance diagram for Moose::MFEM::TimeDependentEquationSystem:

Public Member Functions
	TimeDependentEquationSystem (const Moose::MFEM::TimeDerivativeMap &time_derivative_map)

virtual void	SetTimeStep (mfem::real_t &dt)

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

virtual bool	IsTimeDependent () const override

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.

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

void	FormSystem (mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
	Build all weak-form components via BuildEquationSystem(), form the constrained linear part of the system, and populate the true-DoF vectors used by the solve.

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

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

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

mfem::OperatorHandle &	GetLinearOperator () const
	Get operator handle for linear component of system operator.

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

void	SetGradientRequired (bool requires_gradient)
	Set whether an external object (such as a nonlinear solver) requires Jacobian information for this EquationSystem.

void	SetCoefficientManager (CoefficientManager &coefficients)
	Set the coefficient manager to notify when trial variables are updated, so that stored projections of solution-dependent coefficients are invalidated.

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

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

const mfem::Array< int > &	GetBlockOffsets () const
	Getter for block true offsets associated with the EquationSystem operator.

mfem::ParBilinearForm &	GetBilinearForm (const std::string &test_var_name)

mfem::ParGridFunction &	GetGridFunction (const std::string &trial_var_name)

const mfem::Vector &	GetLinearizationPoint () const
	The true-DoF vector used for the most recent Jacobian linearization.

std::shared_ptr< mfem::ParBilinearForm >	BuildBilinearFormForFESpace (const std::string &var_name, mfem::ParFiniteElementSpace &fespace, mfem::AssemblyLevel assembly_level)
	Build a fresh ParBilinearForm on the given FESpace using the same kernels as the main system's bilinear form for var_name.

std::shared_ptr< mfem::ParNonlinearForm >	BuildNonlinearFormForFESpace (const std::string &var_name, mfem::ParFiniteElementSpace &fespace, mfem::AssemblyLevel assembly_level)
	Build a fresh ParNonlinearForm on the given FESpace using the same kernels as the main system's nonlinear form for var_name.

mfem::Array< int > &	GetEssentialBoundaryMarkers (const std::string &var_name)
	Return the essential boundary attribute marker array for a given trial variable.

virtual bool	IsComplex () const

virtual bool	IsEigen () const

bool	IsMultivariate () const

bool	IsNonlinear () const

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

Protected Member Functions
virtual void	BuildBilinearForms () override
	Build bilinear forms (diagonal Jacobian contributions)

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

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

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

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

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

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

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

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.

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.

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.

virtual void	ApplyEssentialBCs ()
	Update all essentially constrained true DoF markers and values on boundaries.

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

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.

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

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

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

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.

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.

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.

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.

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.

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.

Protected Attributes
mfem::real_t	_dt
	Timestep size.

Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel > > > >	_td_kernels_map

Moose::MFEM::NamedFieldsMap< mfem::ParBilinearForm >	_td_blfs
	Containers to store contributions to weak form of the form (F du/dt, v)

Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< mfem::ParMixedBilinearForm > >	_td_mblfs

const Moose::MFEM::TimeDerivativeMap &	_time_derivative_map
	Map between variable names and their time derivatives.

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

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.

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

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

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

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

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

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.

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

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

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.

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

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

mfem::OperatorHandle	_jacobian

mfem::OperatorHandle	_linear_operator

mfem::AssemblyLevel	_assembly_level

Moose::MFEM::GridFunctions *	_gfuncs

mfem::Array< int >	_block_true_offsets

const mfem::Vector *	_linearization_point = nullptr

bool	_non_linear = false

bool	_gradient_required = false

CoefficientManager *	_coefficient_manager = nullptr

Friends
class	TimeDependentEquationSystemProblemOperator

Detailed Description

Class to store weak form components for time dependent PDEs.

Definition at line 21 of file TimeDependentEquationSystem.h.

Constructor & Destructor Documentation

◆ TimeDependentEquationSystem()

Moose::MFEM::TimeDependentEquationSystem::TimeDependentEquationSystem ( const Moose::MFEM::TimeDerivativeMap & time_derivative_map )

Definition at line 16 of file TimeDependentEquationSystem.C.

  : _dt(1.0), _time_derivative_map(time_derivative_map)
{
}

Member Function Documentation

◆ AddCoupledVariableNameIfMissing()

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

protectedvirtualinherited

Add coupled variable to EquationSystem.

Definition at line 57 of file EquationSystem.C.

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

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

◆ AddEliminatedVariableNameIfMissing()

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

protectedvirtualinherited

Add eliminated variable to EquationSystem.

Definition at line 64 of file EquationSystem.C.

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

Referenced by AddKernel().

◆ AddEssentialBC()

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

virtualinherited

Add BC associated with essentially constrained DoFs on boundaries.

Definition at line 139 of file EquationSystem.C.

{
  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 116 of file EquationSystem.C.

{
  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::TimeDependentEquationSystem::AddKernel ( std::shared_ptr< MFEMKernel > kernel )

overridevirtual

Add kernels.

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 23 of file TimeDependentEquationSystem.C.

{
  if (!_time_derivative_map.isTimeDerivative(kernel->getTrialVariableName()))
  {
    EquationSystem::AddKernel(kernel);
    return;
  }
 
  const auto & trial_var_name =
      _time_derivative_map.getTimeIntegralName(kernel->getTrialVariableName());
  const auto & test_var_name = kernel->getTestVariableName();
  AddEliminatedVariableNameIfMissing(trial_var_name);
  AddTestVariableNameIfMissing(test_var_name);
  // Register new td kernels map if not present for the test variable
  if (!_td_kernels_map.Has(test_var_name))
  {
    auto kernel_field_map =
        std::make_shared<Moose::MFEM::NamedFieldsMap<std::vector<std::shared_ptr<MFEMKernel>>>>();
    _td_kernels_map.Register(test_var_name, std::move(kernel_field_map));
  }
  // Register new td kernels map if not present for the test/trial variable pair
  if (!_td_kernels_map.Get(test_var_name)->Has(trial_var_name))
  {
    auto kernels = std::make_shared<std::vector<std::shared_ptr<MFEMKernel>>>();
    _td_kernels_map.Get(test_var_name)->Register(trial_var_name, std::move(kernels));
  }
  _td_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 71 of file EquationSystem.C.

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

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

◆ 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 381 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->isDGBC() ? bc->isBoundaryRestricted()
                           ? form->AddBdrFaceIntegrator(std::move(integ), bc->getBoundaryMarkers())
                           : form->AddBdrFaceIntegrator(std::move(integ))
        : 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 641 of file EquationSystem.C.

{
  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->isDGBC() ? bc->isBoundaryRestricted()
                           ? form->AddBdrFaceIntegrator(std::move(integ), bc->getBoundaryMarkers())
                           : form->AddBdrFaceIntegrator(std::move(integ))
        : bc->isBoundaryRestricted()
            ? form->AddBoundaryIntegrator(std::move(integ), bc->getBoundaryMarkers())
            : form->AddBoundaryIntegrator(std::move(integ));
      }
    }
  }
}

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

◆ 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 669 of file EquationSystem.C.

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

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

◆ 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 352 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->isDGKernel() ? form->AddInteriorFaceIntegrator(std::move(integ))
        : 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 586 of file EquationSystem.C.

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

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

◆ 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 609 of file EquationSystem.C.

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

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

◆ 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 204 of file EquationSystem.C.

{
  if (_essential_bc_map.Has(var_name))
    for (auto & bc : _essential_bc_map.GetRef(var_name))
    {
      // 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(ess_bdrs.Size()))
        global_ess_markers[i] |= ess_bdrs[i];
    }
}

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

◆ ApplyEssentialBCs()

void Moose::MFEM::EquationSystem::ApplyEssentialBCs ( )

protectedvirtualinherited

Update all essentially constrained true DoF markers and values on boundaries.

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

Definition at line 222 of file EquationSystem.C.

{
  _ess_tdof_lists.resize(_trial_var_names.size());
  _ess_markers.resize(_trial_var_names.size());
  for (const auto i : index_range(_trial_var_names))
  {
    const auto & trial_var_name = _trial_var_names.at(i);
    mfem::ParGridFunction & trial_gf = *_var_ess_constraints.at(i);
 
    // Make sure we update the size, if this mesh has changed recently for instance
    trial_gf.Update();
 
    // Initial guess for iterative solvers (initial condition or the previous time step solution)
    trial_gf = _gfuncs->GetRef(trial_var_name);
 
    _ess_markers.at(i).SetSize(trial_gf.ParFESpace()->GetParMesh()->bdr_attributes.Max(), 0);
    // Set strongly constrained DoFs of trial_gf on essential boundaries and add markers for all
    // essential boundaries to the _ess_markers array
    ApplyEssentialBC(trial_var_name, trial_gf, _ess_markers.at(i));
    trial_gf.ParFESpace()->GetEssentialTrueDofs(_ess_markers.at(i), _ess_tdof_lists.at(i));
  }
}

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

◆ BuildBilinearFormForFESpace()

std::shared_ptr< mfem::ParBilinearForm > Moose::MFEM::EquationSystem::BuildBilinearFormForFESpace	(	const std::string &	var_name,
		mfem::ParFiniteElementSpace &	fespace,
		mfem::AssemblyLevel	assembly_level
	)

inherited

Build a fresh ParBilinearForm on the given FESpace using the same kernels as the main system's bilinear form for var_name.

Caller owns the returned form.

Definition at line 711 of file EquationSystem.C.

{
  auto blf = std::make_shared<mfem::ParBilinearForm>(&fespace);
  blf->SetAssemblyLevel(assembly_level);
  ApplyBoundaryBLFIntegrators<mfem::ParBilinearForm>(var_name, var_name, blf, _integrated_bc_map);
  ApplyDomainBLFIntegrators<mfem::ParBilinearForm>(var_name, var_name, blf, _kernels_map);
  blf->Assemble();
  blf->Finalize();
  return blf;
}

◆ BuildBilinearForms()

void Moose::MFEM::TimeDependentEquationSystem::BuildBilinearForms ( )

overrideprotectedvirtual

Build bilinear forms (diagonal Jacobian contributions)

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 53 of file TimeDependentEquationSystem.C.

{
  // Register bilinear forms
  for (const auto i : index_range(_test_var_names))
  {
    const auto & test_var_name = _test_var_names.at(i);
 
    // Apply kernels to blf
    _blfs.Register(test_var_name, std::make_shared<mfem::ParBilinearForm>(_test_pfespaces.at(i)));
    auto blf = _blfs.GetShared(test_var_name);
    blf->SetAssemblyLevel(_assembly_level);
    ApplyBoundaryBLFIntegrators<mfem::ParBilinearForm>(
        test_var_name, test_var_name, blf, _integrated_bc_map, _dt);
    ApplyDomainBLFIntegrators<mfem::ParBilinearForm>(
        test_var_name, test_var_name, blf, _kernels_map, _dt);
    // Apply dt*du/dt contributions from the operator on the trial variable
    ApplyDomainBLFIntegrators<mfem::ParBilinearForm>(
        test_var_name, test_var_name, blf, _td_kernels_map);
    // Assemble
    blf->Assemble();
    blf->Finalize();
 
    // Apply kernels to td_blf
    _td_blfs.Register(test_var_name,
                      std::make_shared<mfem::ParBilinearForm>(_test_pfespaces.at(i)));
    auto td_blf = _td_blfs.GetShared(test_var_name);
    td_blf->SetAssemblyLevel(_assembly_level);
    ApplyDomainBLFIntegrators<mfem::ParBilinearForm>(
        test_var_name, test_var_name, td_blf, _td_kernels_map);
    // Assemble
    td_blf->Assemble();
    td_blf->Finalize();
  }
}

◆ BuildEquationSystem()

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

virtualinherited

Build all forms comprising this EquationSystem.

Definition at line 577 of file EquationSystem.C.

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

Referenced by Moose::MFEM::EigenproblemESProblemOperator::FormEquationSystemOperator(), and Moose::MFEM::EquationSystem::FormSystem().

◆ BuildLinearForms()

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

protectedvirtualinherited

Build linear forms and eliminate constrained DoFs.

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 472 of file EquationSystem.C.

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

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

◆ BuildMixedBilinearForms()

void Moose::MFEM::TimeDependentEquationSystem::BuildMixedBilinearForms ( )

overrideprotectedvirtual

Build mixed bilinear forms (off-diagonal Jacobian contributions)

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 89 of file TimeDependentEquationSystem.C.

{
  // 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))
  {
    const 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 (test_var_name != coupled_var_name)
      {
        // Apply all mixed kernels with this test/trial pair
        ApplyBoundaryBLFIntegrators<mfem::ParMixedBilinearForm>(
            coupled_var_name, test_var_name, mblf, _integrated_bc_map, _dt);
        ApplyDomainBLFIntegrators<mfem::ParMixedBilinearForm>(
            coupled_var_name, test_var_name, mblf, _kernels_map, _dt);
        // Apply dt*du/dt contributions from the operator on the trial variable
        ApplyDomainBLFIntegrators<mfem::ParMixedBilinearForm>(
            coupled_var_name, test_var_name, mblf, _td_kernels_map);
        if (mblf->GetDBFI()->Size() || mblf->GetBBFI()->Size())
        {
          // Assemble mixed bilinear forms
          mblf->SetAssemblyLevel(_assembly_level);
          mblf->Assemble();
          mblf->Finalize();
          // 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);
  }
 
  // Register mixed bilinear forms. Note that not all combinations may
  // have a kernel.
 
  // Create mblf for each test/trial variable pair with an added kernel
  for (const auto i : index_range(_test_var_names))
  {
    const auto & test_var_name = _test_var_names.at(i);
    auto test_td_mblfs =
        std::make_shared<Moose::MFEM::NamedFieldsMap<mfem::ParMixedBilinearForm>>();
    for (const auto j : index_range(_trial_var_names))
    {
      const auto & trial_var_name = _trial_var_names.at(j);
      auto td_mblf = std::make_shared<mfem::ParMixedBilinearForm>(_test_pfespaces.at(j),
                                                                  _test_pfespaces.at(i));
      // Register MixedBilinearForm if kernels exist for it, and assemble kernels
      if (test_var_name != trial_var_name)
      {
        // Apply all mixed kernels with this test/trial pair
        ApplyDomainBLFIntegrators<mfem::ParMixedBilinearForm>(
            trial_var_name, test_var_name, td_mblf, _td_kernels_map);
        // Assemble mixed bilinear form
        if (td_mblf->GetDBFI()->Size() || td_mblf->GetBBFI()->Size())
        {
          td_mblf->SetAssemblyLevel(_assembly_level);
          td_mblf->Assemble();
          td_mblf->Finalize();
          // Register mixed bilinear forms associated with a single trial variable
          // for the current test variable
          test_td_mblfs->Register(trial_var_name, td_mblf);
        }
      }
    }
    // Register all mixed bilinear forms associated with a single test variable
    _td_mblfs.Register(test_var_name, test_td_mblfs);
  }
}

◆ BuildNonlinearFormForFESpace()

std::shared_ptr< mfem::ParNonlinearForm > Moose::MFEM::EquationSystem::BuildNonlinearFormForFESpace	(	const std::string &	var_name,
		mfem::ParFiniteElementSpace &	fespace,
		mfem::AssemblyLevel	assembly_level
	)

inherited

Build a fresh ParNonlinearForm on the given FESpace using the same kernels as the main system's nonlinear form for var_name.

Caller owns the returned form.

Definition at line 725 of file EquationSystem.C.

{
  auto nlf = std::make_shared<mfem::ParNonlinearForm>(&fespace);
  ApplyDomainNLFIntegrators(var_name, nlf, _kernels_map, std::nullopt);
  ApplyBoundaryNLFIntegrators(var_name, nlf, _integrated_bc_map, std::nullopt);
  return nlf;
}

◆ BuildNonlinearForms()

void Moose::MFEM::TimeDependentEquationSystem::BuildNonlinearForms ( )

overrideprotectedvirtual

Build non-linear action forms.

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 171 of file TimeDependentEquationSystem.C.

{
  // 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, _dt);
    ApplyBoundaryNLFIntegrators(test_var_name, nlf, _integrated_bc_map, _dt);
  }
}

◆ 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 391 of file EquationSystem.C.

{
  mooseAssert(IsNonlinear(), "Should not be calling this method if our forms are not nonlinear");
 
  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->AddMult(block_solution.GetBlock(i), block_residual.GetBlock(i));
    block_residual.GetBlock(i).SyncAliasMemory(block_residual);
  }
}

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

◆ 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 27 of file EquationSystem.C.

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

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

◆ 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 40 of file EquationSystem.C.

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

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

◆ EliminateCoupledVariables()

void Moose::MFEM::TimeDependentEquationSystem::EliminateCoupledVariables ( )

overrideprotectedvirtual

Perform trivial eliminations of coupled variables lacking corresponding test variables.

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 187 of file TimeDependentEquationSystem.C.

{
  for (const auto & test_var_name : _test_var_names)
  {
    auto & lf = *_lfs.Get(test_var_name) *= _dt;
    for (const auto & eliminated_var_name : _eliminated_var_names)
      if (eliminated_var_name == test_var_name)
      {
        // if implicit, add contribution to linear form from terms involving state
        // The AddMult method in mfem::BilinearForm is not defined for non-legacy assembly
        mfem::Vector lf_prev(lf.Size());
        auto & td_blf = *_td_blfs.Get(test_var_name);
        td_blf.Mult(*_eliminated_variables.Get(test_var_name), lf_prev);
        lf += lf_prev;
      }
      else if (_td_mblfs.Has(test_var_name) &&
               _td_mblfs.Get(test_var_name)->Has(eliminated_var_name))
      {
        auto & td_mblf = *_td_mblfs.Get(test_var_name)->Get(eliminated_var_name);
        td_mblf.AddMult(*_eliminated_variables.Get(eliminated_var_name), lf);
      }
  }
  // Eliminate contributions from other coupled variables.
  EquationSystem::EliminateCoupledVariables();
}

◆ 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 409 of file EquationSystem.C.

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

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

◆ 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 259 of file EquationSystem.C.

{
  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
    FormSystemOperator(op, trueX, trueRHS);
}

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

◆ FormSystem()

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

inherited

Build all weak-form components via BuildEquationSystem(), form the constrained linear part of the system, and populate the true-DoF vectors used by the solve.

For nonlinear problems, nonlinear forms are registered here but are not folded into the assembled linear operator. Their residual action is evaluated by Mult(), and any Jacobian contribution is formed at the current nonlinear iterate by GetGradient().

This is the single public entry point for callers that want the equation system prepared for a solve. Subclasses customize the form-building step by overriding BuildEquationSystem().

Definition at line 367 of file EquationSystem.C.

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

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

◆ 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 303 of file EquationSystem.C.

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

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

◆ 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 273 of file EquationSystem.C.

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

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

◆ GetBilinearForm()

mfem::ParBilinearForm & Moose::MFEM::EquationSystem::GetBilinearForm ( const std::string & test_var_name )

inlineinherited

Returns: a reference to the MFEM ParBilinearForm corresponding to test_var_name

Definition at line 106 of file EquationSystem.h.

  {
    return _blfs.GetRef(test_var_name);
  }

◆ GetBlockOffsets()

const mfem::Array< int > & Moose::MFEM::EquationSystem::GetBlockOffsets ( ) const

inlineinherited

Getter for block true offsets associated with the EquationSystem operator.

Definition at line 101 of file EquationSystem.h.

101{ return _block_true_offsets; }

◆ GetEssentialBoundaryMarkers()

mfem::Array< int > & Moose::MFEM::EquationSystem::GetEssentialBoundaryMarkers ( const std::string & var_name )

inherited

Return the essential boundary attribute marker array for a given trial variable.

The returned array has size == pmesh.bdr_attributes.Max() with 1 at essential boundaries.

Definition at line 736 of file EquationSystem.C.

{
  for (const auto i : index_range(_trial_var_names))
    if (_trial_var_names.at(i) == var_name)
      return _ess_markers.at(i);
 
  mooseError("No essential boundary markers found for variable '", var_name, "'.");
}

◆ 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 440 of file EquationSystem.C.

{
  _linearization_point = &u;
 
  if (IsNonlinear())
  {
    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;
}

◆ GetGridFunction()

mfem::ParGridFunction & Moose::MFEM::EquationSystem::GetGridFunction ( const std::string & trial_var_name )

inlineinherited

Returns: a reference to the MFEM ParGridFunction corresponding to trial_var_name

Definition at line 114 of file EquationSystem.h.

  {
    return _gfuncs->GetRef(trial_var_name);
  }

◆ GetLinearizationPoint()

const mfem::Vector & Moose::MFEM::EquationSystem::GetLinearizationPoint ( ) const

inherited

The true-DoF vector used for the most recent Jacobian linearization.

Definition at line 703 of file EquationSystem.C.

{
  if (!_linearization_point)
    mooseError("EquationSystem::GetLinearizationPoint() called before GetGradient().");
  return *_linearization_point;
}

◆ GetLinearOperator()

mfem::OperatorHandle & Moose::MFEM::EquationSystem::GetLinearOperator ( ) const

inlineinherited

Get operator handle for linear component of system operator.

Definition at line 80 of file EquationSystem.h.

80{ return _linear_operator; };

◆ GetTestVarNames()

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

inlineinherited

Definition at line 98 of file EquationSystem.h.

98{ return _test_var_names; }

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

◆ GetTrialVarNames()

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

inlineinherited

Definition at line 97 of file EquationSystem.h.

97{ return _trial_var_names; }

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

◆ 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 153 of file EquationSystem.C.

{
  _assembly_level = assembly_level;
 
  // 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;
}

◆ IsComplex()

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

inlinevirtualinherited

Returns: Whether this EquationSystem includes complex components

Reimplemented in Moose::MFEM::ComplexEquationSystem.

Definition at line 147 of file EquationSystem.h.

147{ return false; }

◆ IsEigen()

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

inlinevirtualinherited

Returns: Whether this EquationSystem represents an eigenproblem

Reimplemented in Moose::MFEM::EigenproblemEquationSystem.

Definition at line 149 of file EquationSystem.h.

149{ return false; }

◆ IsMultivariate()

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

inlineinherited

Returns: Whether this is a multivariate (maybe mixed) equation system

Definition at line 153 of file EquationSystem.h.

153{ return _test_var_names.size() > 1; }

◆ IsNonlinear()

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

inlineinherited

Returns: Whether nonlinear integrators are present in the equation system

Definition at line 155 of file EquationSystem.h.

155{ return _non_linear; }

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

◆ IsTimeDependent()

virtual bool Moose::MFEM::TimeDependentEquationSystem::IsTimeDependent ( ) const

inlineoverridevirtual

Returns: Whether this EquationSystem has time-dependent components

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 29 of file TimeDependentEquationSystem.h.

29{ return true; }

◆ Mult()

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

overrideinherited

Compute residual y = Mu.

Definition at line 382 of file EquationSystem.C.

{
  _linear_operator->Mult(sol, residual);
 
  if (IsNonlinear())
    ComputeNonlinearResidual(sol, residual);
}

◆ SetCoefficientManager()

void Moose::MFEM::EquationSystem::SetCoefficientManager ( CoefficientManager & coefficients )

inlineinherited

Set the coefficient manager to notify when trial variables are updated, so that stored projections of solution-dependent coefficients are invalidated.

Definition at line 90 of file EquationSystem.h.

  {
    _coefficient_manager = &coefficients;
  }

◆ SetGradientRequired()

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

inlineinherited

Set whether an external object (such as a nonlinear solver) requires Jacobian information for this EquationSystem.

Definition at line 86 of file EquationSystem.h.

86{ _gradient_required = requires_gradient; }

◆ SetTimeStep()

virtual void Moose::MFEM::TimeDependentEquationSystem::SetTimeStep ( mfem::real_t & dt )

inlinevirtual

Definition at line 26 of file TimeDependentEquationSystem.h.

26{ _dt = dt; };

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

◆ 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 78 of file EquationSystem.C.

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

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

◆ 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 458 of file EquationSystem.C.

{
  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)));
  }
  // Solution variables changed: stored projections of solution-dependent coefficients are stale.
  if (_coefficient_manager)
    _coefficient_manager->markSolutionChanged();
}

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

◆ VectorContainsName()

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

protectedinherited

Definition at line 50 of file EquationSystem.C.

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

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

Friends And Related Symbol Documentation

◆ TimeDependentEquationSystemProblemOperator

friend class TimeDependentEquationSystemProblemOperator

friend

Definition at line 51 of file TimeDependentEquationSystem.h.

Member Data Documentation

◆ _assembly_level

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

protectedinherited

Definition at line 329 of file EquationSystem.h.

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

◆ _blfs

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

protectedinherited

Definition at line 304 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::BuildBilinearForms(), BuildBilinearForms(), Moose::MFEM::EigenproblemEquationSystem::FormEigenproblemMatrix(), Moose::MFEM::EquationSystem::FormSystemMatrix(), Moose::MFEM::EquationSystem::FormSystemOperator(), and Moose::MFEM::EquationSystem::GetBilinearForm().

◆ _block_true_offsets

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

protectedinherited

Definition at line 334 of file EquationSystem.h.

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

◆ _coefficient_manager

CoefficientManager* Moose::MFEM::EquationSystem::_coefficient_manager = nullptr

protectedinherited

Definition at line 343 of file EquationSystem.h.

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

◆ _coupled_pfespaces

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

protectedinherited

Pointers to finite element spaces associated with coupled variables.

Definition at line 301 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), Moose::MFEM::ComplexEquationSystem::BuildMixedBilinearForms(), BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::Init(), and Moose::MFEM::ComplexEquationSystem::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 287 of file EquationSystem.h.

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

◆ _dt

mfem::real_t Moose::MFEM::TimeDependentEquationSystem::_dt

protected

Timestep size.

Definition at line 38 of file TimeDependentEquationSystem.h.

Referenced by BuildBilinearForms(), BuildMixedBilinearForms(), BuildNonlinearForms(), EliminateCoupledVariables(), and SetTimeStep().

◆ _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 293 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AddEliminatedVariableNameIfMissing(), Moose::MFEM::EquationSystem::EliminateCoupledVariables(), Moose::MFEM::ComplexEquationSystem::EliminateCoupledVariables(), EliminateCoupledVariables(), Moose::MFEM::EquationSystem::Init(), Moose::MFEM::ComplexEquationSystem::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 295 of file EquationSystem.h.

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

◆ _ess_markers

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

protectedinherited

Definition at line 312 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::ApplyEssentialBCs(), Moose::MFEM::ComplexEquationSystem::ApplyEssentialBCs(), Moose::MFEM::EigenproblemEquationSystem::ApplyEssentialBCs(), Moose::MFEM::EigenproblemEquationSystem::FormEigenproblemMatrix(), Moose::MFEM::EigenproblemEquationSystem::FormMassMatrix(), and Moose::MFEM::EquationSystem::GetEssentialBoundaryMarkers().

◆ _ess_tdof_lists

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

protectedinherited

Definition at line 311 of file EquationSystem.h.

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

◆ _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 323 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 332 of file EquationSystem.h.

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

◆ _gradient_required

bool Moose::MFEM::EquationSystem::_gradient_required = false

protectedinherited

Definition at line 340 of file EquationSystem.h.

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

◆ _h_blocks

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

protectedinherited

Definition at line 314 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::DeleteHBlocks(), Moose::MFEM::EquationSystem::DeleteJacobianBlocks(), Moose::MFEM::EquationSystem::FormJacobianMatrix(), Moose::MFEM::EquationSystem::FormSystemMatrix(), and Moose::MFEM::ComplexEquationSystem::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 320 of file EquationSystem.h.

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

◆ _jacobian

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

mutableprotectedinherited

Definition at line 326 of file EquationSystem.h.

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

◆ _jacobian_blocks

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

protectedinherited

Definition at line 314 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 317 of file EquationSystem.h.

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

◆ _lfs

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

protectedinherited

Definition at line 305 of file EquationSystem.h.

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

◆ _linear_operator

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

mutableprotectedinherited

Definition at line 328 of file EquationSystem.h.

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

◆ _linearization_point

const mfem::Vector* Moose::MFEM::EquationSystem::_linearization_point = nullptr

mutableprotectedinherited

Definition at line 336 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::GetGradient(), and Moose::MFEM::EquationSystem::GetLinearizationPoint().

◆ _mblfs

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

protectedinherited

Definition at line 307 of file EquationSystem.h.

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

◆ _nlfs

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

protectedinherited

Definition at line 306 of file EquationSystem.h.

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

◆ _non_linear

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

protectedinherited

Definition at line 338 of file EquationSystem.h.

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

◆ _td_blfs

Moose::MFEM::NamedFieldsMap<mfem::ParBilinearForm> Moose::MFEM::TimeDependentEquationSystem::_td_blfs

protected

Containers to store contributions to weak form of the form (F du/dt, v)

Definition at line 43 of file TimeDependentEquationSystem.h.

Referenced by BuildBilinearForms(), and EliminateCoupledVariables().

◆ _td_kernels_map

Moose::MFEM::NamedFieldsMap<Moose::MFEM::NamedFieldsMap<std::vector<std::shared_ptr<MFEMKernel> > > > Moose::MFEM::TimeDependentEquationSystem::_td_kernels_map

protected

Definition at line 41 of file TimeDependentEquationSystem.h.

Referenced by AddKernel(), BuildBilinearForms(), and BuildMixedBilinearForms().

◆ _td_mblfs

Moose::MFEM::NamedFieldsMap<Moose::MFEM::NamedFieldsMap<mfem::ParMixedBilinearForm> > Moose::MFEM::TimeDependentEquationSystem::_td_mblfs

protected

Definition at line 45 of file TimeDependentEquationSystem.h.

Referenced by BuildMixedBilinearForms(), and EliminateCoupledVariables().

◆ _test_pfespaces

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

protectedinherited

Pointers to finite element spaces associated with test variables.

Definition at line 299 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::BuildBilinearForms(), Moose::MFEM::ComplexEquationSystem::BuildBilinearForms(), BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildLinearForms(), Moose::MFEM::ComplexEquationSystem::BuildLinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), Moose::MFEM::ComplexEquationSystem::BuildMixedBilinearForms(), BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::BuildNonlinearForms(), BuildNonlinearForms(), Moose::MFEM::EigenproblemEquationSystem::FormMassMatrix(), Moose::MFEM::EquationSystem::FormSystemMatrix(), Moose::MFEM::ComplexEquationSystem::FormSystemMatrix(), Moose::MFEM::EquationSystem::Init(), and Moose::MFEM::ComplexEquationSystem::Init().

◆ _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 297 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AddTestVariableNameIfMissing(), Moose::MFEM::EquationSystem::BuildBilinearForms(), Moose::MFEM::ComplexEquationSystem::BuildBilinearForms(), BuildBilinearForms(), Moose::MFEM::EigenproblemEquationSystem::BuildEigenproblemJacobian(), Moose::MFEM::EquationSystem::BuildLinearForms(), Moose::MFEM::ComplexEquationSystem::BuildLinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), Moose::MFEM::ComplexEquationSystem::BuildMixedBilinearForms(), BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::BuildNonlinearForms(), BuildNonlinearForms(), Moose::MFEM::EquationSystem::ComputeNonlinearResidual(), Moose::MFEM::EquationSystem::EliminateCoupledVariables(), Moose::MFEM::ComplexEquationSystem::EliminateCoupledVariables(), EliminateCoupledVariables(), Moose::MFEM::EigenproblemEquationSystem::FormEigenproblemMatrix(), Moose::MFEM::EquationSystem::FormJacobianMatrix(), Moose::MFEM::EquationSystem::FormLinearSystem(), Moose::MFEM::EquationSystem::FormSystemMatrix(), Moose::MFEM::ComplexEquationSystem::FormSystemMatrix(), Moose::MFEM::EquationSystem::FormSystemOperator(), Moose::MFEM::ComplexEquationSystem::FormSystemOperator(), Moose::MFEM::EquationSystem::GetTestVarNames(), Moose::MFEM::EquationSystem::Init(), Moose::MFEM::ComplexEquationSystem::Init(), Moose::MFEM::EquationSystem::IsMultivariate(), and Moose::MFEM::EquationSystem::SetTrialVariableNames().

◆ _time_derivative_map

const Moose::MFEM::TimeDerivativeMap& Moose::MFEM::TimeDependentEquationSystem::_time_derivative_map

protected

Map between variable names and their time derivatives.

Definition at line 48 of file TimeDependentEquationSystem.h.

Referenced by AddKernel().

◆ _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 291 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 310 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::ApplyEssentialBCs(), Moose::MFEM::EigenproblemEquationSystem::ApplyEssentialBCs(), Moose::MFEM::EigenproblemEquationSystem::CheckProblemIsHomogeneous(), 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/TimeDependentEquationSystem.h
src/mfem/equation_systems/TimeDependentEquationSystem.C

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ TimeDependentEquationSystem()

Member Function Documentation

◆ AddCoupledVariableNameIfMissing()

◆ AddEliminatedVariableNameIfMissing()

◆ AddEssentialBC()

◆ AddIntegratedBC()

◆ AddKernel()

◆ AddTestVariableNameIfMissing()

◆ ApplyBoundaryBLFIntegrators()

◆ ApplyBoundaryLFIntegrators()

◆ ApplyBoundaryNLFIntegrators()

◆ ApplyDomainBLFIntegrators()

◆ ApplyDomainLFIntegrators()

◆ ApplyDomainNLFIntegrators()

◆ ApplyEssentialBC()

◆ ApplyEssentialBCs()

◆ BuildBilinearFormForFESpace()

◆ BuildBilinearForms()

◆ BuildEquationSystem()

◆ BuildLinearForms()

◆ BuildMixedBilinearForms()

◆ BuildNonlinearFormForFESpace()

◆ BuildNonlinearForms()

◆ ComputeNonlinearResidual()

◆ DeleteHBlocks()

◆ DeleteJacobianBlocks()

◆ EliminateCoupledVariables()

◆ FormJacobianMatrix()

◆ FormLinearSystem()

◆ FormSystem()

◆ FormSystemMatrix()

◆ FormSystemOperator()

◆ GetBilinearForm()

◆ GetBlockOffsets()

◆ GetEssentialBoundaryMarkers()

◆ GetGradient()

◆ GetGridFunction()

◆ GetLinearizationPoint()

◆ GetLinearOperator()

◆ GetTestVarNames()

◆ GetTrialVarNames()

◆ Init()

◆ IsComplex()

◆ IsEigen()

◆ IsMultivariate()

◆ IsNonlinear()

◆ IsTimeDependent()

◆ Mult()

◆ SetCoefficientManager()

◆ SetGradientRequired()

◆ SetTimeStep()

◆ SetTrialVariableNames()

◆ SetTrialVariablesFromTrueVectors()

◆ VectorContainsName()

Friends And Related Symbol Documentation

◆ TimeDependentEquationSystemProblemOperator

Member Data Documentation

◆ _assembly_level

◆ _blfs

◆ _block_true_offsets

◆ _coefficient_manager

◆ _coupled_pfespaces

◆ _coupled_var_names

◆ _dt

◆ _eliminated_var_names

◆ _eliminated_variables

◆ _ess_markers

◆ _ess_tdof_lists

◆ _essential_bc_map

◆ _gfuncs

◆ _gradient_required

◆ _h_blocks

◆ _integrated_bc_map

◆ _jacobian