Moose::MFEM::TimeDependentEquationSystem Class Reference

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

#include <EquationSystem.h>

Inheritance diagram for Moose::MFEM::TimeDependentEquationSystem:

Public Member Functions
	TimeDependentEquationSystem (const Moose::MFEM::TimeDerivativeMap &time_derivative_map)
virtual void	Init (Moose::MFEM::GridFunctions &gridfunctions, mfem::AssemblyLevel assembly_level) override
	Initialise. More...
virtual void	SetTimeStep (mfem::real_t dt)
virtual void	UpdateEquationSystem ()
virtual void	AddKernel (std::shared_ptr< MFEMKernel > kernel) override
	Add kernels. More...
virtual void	BuildBilinearForms () override
	Build bilinear forms (diagonal Jacobian contributions) More...
virtual void	BuildMixedBilinearForms () override
	Build mixed bilinear forms (off-diagonal Jacobian contributions) More...
virtual void	ApplyEssentialBCs () override
	Update all essentially constrained true DoF markers and values on boundaries. More...
virtual void	EliminateCoupledVariables () override
	Perform trivial eliminations of coupled variables lacking corresponding test variables. More...
virtual void	FormLegacySystem (mfem::OperatorHandle &op, mfem::BlockVector &truedXdt, mfem::BlockVector &trueRHS) override
virtual void	FormSystem (mfem::OperatorHandle &op, mfem::BlockVector &truedXdt, mfem::BlockVector &trueRHS) override
template<class FormType >
void	ScaleAndAddBLFIntegrators (std::shared_ptr< FormType > source_blf, std::shared_ptr< FormType > target_blf, mfem::real_t scale_factor)
	Fetch all integrators on a source bilinear form, scale them by a real factor, and add to a second target bilienar form. More...
virtual void	AddTestVariableNameIfMissing (const std::string &test_var_name)
	Add test variable to EquationSystem. More...
virtual void	AddCoupledVariableNameIfMissing (const std::string &coupled_var_name)
	Add coupled variable to EquationSystem. 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	BuildLinearForms ()
	Build linear forms and eliminate constrained DoFs. More...
virtual void	ApplyEssentialBC (const std::string &test_var_name, mfem::ParGridFunction &trial_gf, mfem::Array< int > &global_ess_markers)
	Apply essential BC(s) associated with test_var_name to set true DoFs of trial_gf and update markers of all essential boundaries. More...
virtual void	BuildEquationSystem ()
	Build all forms comprising this EquationSystem. More...
void	AssembleJacobian (Moose::MFEM::NamedFieldsMap< mfem::ParBilinearForm > &jac_blfs, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< mfem::ParMixedBilinearForm >> &jac_mblfs, Moose::MFEM::NamedFieldsMap< mfem::ParLinearForm > &rhs_lfs, std::vector< mfem::Array< int >> &ess_tdof_lists, std::vector< std::unique_ptr< mfem::ParGridFunction >> &var_ess_constraints, mfem::OperatorHandle &op, mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
	Form Jacobian operator based on on- and off-diagonal bilinear form contributions, populate solution and RHS vectors of true DoFs, and apply constraints. More...
virtual void	FormLinearSystem (mfem::OperatorHandle &op, mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
	Form linear system, with essential boundary conditions accounted for. More...
virtual void	BuildJacobian (mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
	Build linear system, with essential boundary conditions accounted for. More...
void	Mult (const mfem::Vector &u, mfem::Vector &residual) const override
	Compute residual y = Mu. More...
mfem::Operator &	GetGradient (const mfem::Vector &u) const override
	Compute J = M + grad_H(u) More...
virtual void	RecoverFEMSolution (mfem::BlockVector &trueX, Moose::MFEM::GridFunctions &gridfunctions)
	Update variable from solution vector after solve. More...
const std::vector< std::string > &	TrialVarNames () const
const std::vector< std::string > &	TestVarNames () const

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

Protected Member Functions
void	DeleteAllBlocks ()
	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...
bool	VectorContainsName (const std::vector< std::string > &the_vector, const std::string &name) const
template<class FormType >
void	ApplyDomainBLFIntegrators (const std::string &trial_var_name, const std::string &test_var_name, std::shared_ptr< FormType > form, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &kernels_map)
	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, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &kernels_map)
template<class FormType >
void	ApplyBoundaryBLFIntegrators (const std::string &trial_var_name, const std::string &test_var_name, std::shared_ptr< FormType > form, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &integrated_bc_map)
void	ApplyBoundaryLFIntegrators (const std::string &test_var_name, std::shared_ptr< mfem::ParLinearForm > form, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &integrated_bc_map)

Protected Attributes
mfem::ConstantCoefficient	_dt_coef
	Coefficient for timestep scaling. More...
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) More...
Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< mfem::ParMixedBilinearForm > >	_td_mblfs
std::vector< std::unique_ptr< mfem::ParGridFunction > >	_td_var_ess_constraints
	Gridfunctions holding essential constraints from Dirichlet BCs. More...
const Moose::MFEM::TimeDerivativeMap &	_time_derivative_map
	Map between variable names and their time derivatives. More...
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...
Moose::MFEM::NamedFieldsMap< mfem::ParBilinearForm >	_blfs
Moose::MFEM::NamedFieldsMap< mfem::ParLinearForm >	_lfs
Moose::MFEM::NamedFieldsMap< mfem::ParNonlinearForm >	_nlfs
Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< mfem::ParMixedBilinearForm > >	_mblfs
std::vector< std::unique_ptr< mfem::ParGridFunction > >	_var_ess_constraints
	Gridfunctions holding essential constraints from Dirichlet BCs. More...
mfem::Array2D< const mfem::HypreParMatrix * >	_h_blocks
Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel > > > >	_kernels_map
	Arrays to store kernels to act on each component of weak form. More...
Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC > > > >	_integrated_bc_map
	Arrays to store integrated BCs to act on each component of weak form. More...
Moose::MFEM::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::AssemblyLevel	_assembly_level

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

Detailed Description

Class to store weak form components for time dependent PDEs.

Definition at line 322 of file EquationSystem.h.

Constructor & Destructor Documentation

TimeDependentEquationSystem()

Moose::MFEM::TimeDependentEquationSystem::TimeDependentEquationSystem

(

const Moose::MFEM::TimeDerivativeMap &

time_derivative_map

)

Definition at line 464 of file EquationSystem.C.

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

Member Function Documentation

AddCoupledVariableNameIfMissing()

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

virtualinherited

Add coupled variable to EquationSystem.

Definition at line 38 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::AddIntegratedBC(), Moose::MFEM::EquationSystem::AddKernel(), AddKernel(), and SetTrialVariableNames().

{
  if (!VectorContainsName(_coupled_var_names, coupled_var_name))
    _coupled_var_names.push_back(coupled_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 112 of file EquationSystem.C.

{
  auto test_var_name = bc->getTestVariableName();
  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 89 of file EquationSystem.C.

{
  AddTestVariableNameIfMissing(bc->getTestVariableName());
  AddCoupledVariableNameIfMissing(bc->getTrialVariableName());
  auto trial_var_name = bc->getTrialVariableName();
  auto test_var_name = bc->getTestVariableName();
  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 526 of file EquationSystem.C.

{
  const auto & trial_var_name = kernel->getTrialVariableName();
  const auto & test_var_name = kernel->getTestVariableName();

  if (_time_derivative_map.isTimeDerivative(trial_var_name))
  {
    AddTestVariableNameIfMissing(test_var_name);
    AddCoupledVariableNameIfMissing(trial_var_name);

    // Register new 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));
    }
    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));
  }
  else
  {
    EquationSystem::AddKernel(kernel);
  }
}

AddTestVariableNameIfMissing()

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

virtualinherited

Add test variable to EquationSystem.

Definition at line 45 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::AddIntegratedBC(), Moose::MFEM::EquationSystem::AddKernel(), and 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, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &  integrated_bc_map  )

protectedinherited

Definition at line 269 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 != nullptr)
      {
        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, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC >>>> &  integrated_bc_map  )

inlineprotectedinherited

Definition at line 295 of file EquationSystem.h.

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 != nullptr)
      {
        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, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &  kernels_map  )

protectedinherited

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

Definition at line 221 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 != nullptr)
      {
        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, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel >>>> &  kernels_map  )

inlineprotectedinherited

Definition at line 245 of file EquationSystem.h.

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 != nullptr)
      {
        kernel->isSubdomainRestricted()
            ? form->AddDomainIntegrator(std::move(integ), kernel->getSubdomainMarkers())
            : form->AddDomainIntegrator(std::move(integ));
      }
    }
  }
}

ApplyEssentialBC()

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

virtualinherited

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

Definition at line 159 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::ApplyEssentialBCs(), and 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 (auto it = 0; it != trial_gf.ParFESpace()->GetParMesh()->bdr_attributes.Max(); ++it)
        global_ess_markers[it] = std::max(global_ess_markers[it], ess_bdrs[it]);
    }
  }
}

ApplyEssentialBCs()

void Moose::MFEM::TimeDependentEquationSystem::ApplyEssentialBCs ( )

overridevirtual

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

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 646 of file EquationSystem.C.

{
  _ess_tdof_lists.resize(_test_var_names.size());
  for (const auto i : index_range(_test_var_names))
  {
    const auto & test_var_name = _test_var_names.at(i);
    const auto time_derivative_test_var_name =
        _time_derivative_map.getTimeDerivativeName(test_var_name);
    mfem::ParGridFunction & trial_gf = *(_var_ess_constraints.at(i));
    mfem::ParGridFunction & trial_gf_time_derivative = *(_td_var_ess_constraints.at(i));
    mfem::Array<int> global_ess_markers(trial_gf.ParFESpace()->GetParMesh()->bdr_attributes.Max());
    global_ess_markers = 0;
    // Set strongly constrained DoFs of trial_gf on essential boundaries and add markers for all
    // essential boundaries to the global_ess_markers array
    EquationSystem::ApplyEssentialBC(test_var_name, trial_gf, global_ess_markers);
    // Update solution values on Dirichlet values to be in terms of du/dt instead of u
    *_td_var_ess_constraints.at(i).get() = *(_var_ess_constraints.at(i).get());
    *_td_var_ess_constraints.at(i).get() -= *_eliminated_variables.Get(test_var_name);
    *_td_var_ess_constraints.at(i).get() /= _dt_coef.constant;
    // Apply any remaining Dirichlet BCs specified directly on du/dt
    EquationSystem::ApplyEssentialBC(
        time_derivative_test_var_name, trial_gf_time_derivative, global_ess_markers);
    trial_gf.ParFESpace()->GetEssentialTrueDofs(global_ess_markers, _ess_tdof_lists.at(i));
  }
}

AssembleJacobian()

void Moose::MFEM::EquationSystem::AssembleJacobian ( Moose::MFEM::NamedFieldsMap< mfem::ParBilinearForm > &  jac_blfs, Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< mfem::ParMixedBilinearForm >> &  jac_mblfs, Moose::MFEM::NamedFieldsMap< mfem::ParLinearForm > &  rhs_lfs, std::vector< mfem::Array< int >> &  ess_tdof_lists, std::vector< std::unique_ptr< mfem::ParGridFunction >> &  var_ess_constraints, mfem::OperatorHandle &  op, mfem::BlockVector &  trueX, mfem::BlockVector &  trueRHS  )

inherited

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

Definition at line 261 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::FormLegacySystem(), and FormLegacySystem().

{
  // Allocate block operator
  DeleteAllBlocks();
  _h_blocks.SetSize(_test_var_names.size(), _test_var_names.size());
  // Form diagonal blocks.
  for (const auto i : index_range(_test_var_names))
  {
    auto & test_var_name = _test_var_names.at(i);
    auto blf = jac_blfs.Get(test_var_name);
    auto lf = rhs_lfs.Get(test_var_name);
    mfem::Vector aux_x, aux_rhs;
    mfem::HypreParMatrix * aux_a = new mfem::HypreParMatrix;
    blf->FormLinearSystem(
        ess_tdof_lists.at(i), *(var_ess_constraints.at(i)), *lf, *aux_a, aux_x, aux_rhs);
    _h_blocks(i, i) = aux_a;
    trueX.GetBlock(i) = aux_x;
    trueRHS.GetBlock(i) = aux_rhs;
  }

  // Form off-diagonal blocks
  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));
      aux_lf = 0.0;
      if (jac_mblfs.Has(test_var_name) && jac_mblfs.Get(test_var_name)->Has(trial_var_name))
      {
        auto mblf = jac_mblfs.Get(test_var_name)->Get(trial_var_name);
        mfem::HypreParMatrix * aux_a = new mfem::HypreParMatrix;
        mblf->FormRectangularLinearSystem(ess_tdof_lists.at(j),
                                          ess_tdof_lists.at(i),
                                          *(var_ess_constraints.at(j)),
                                          aux_lf,
                                          *aux_a,
                                          aux_x,
                                          aux_rhs);
        _h_blocks(i, j) = aux_a;
        trueRHS.GetBlock(i) += aux_rhs;
      }
    }
  }
  // Sync memory
  trueX.SyncFromBlocks();
  trueRHS.SyncFromBlocks();

  // Create monolithic matrix
  op.Reset(mfem::HypreParMatrixFromBlocks(_h_blocks));
}

BuildBilinearForms()

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

overridevirtual

Build bilinear forms (diagonal Jacobian contributions)

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 557 of file EquationSystem.C.

{
  EquationSystem::BuildBilinearForms();

  // Build and assemble bilinear forms acting on time derivatives
  for (const auto i : index_range(_test_var_names))
  {
    auto test_var_name = _test_var_names.at(i);

    _td_blfs.Register(test_var_name,
                      std::make_shared<mfem::ParBilinearForm>(_test_pfespaces.at(i)));

    // Apply kernels to td_blf
    auto td_blf = _td_blfs.GetShared(test_var_name);
    td_blf->SetAssemblyLevel(_assembly_level);
    ApplyBoundaryBLFIntegrators<mfem::ParBilinearForm>(
        test_var_name, test_var_name, td_blf, _integrated_bc_map);
    ApplyDomainBLFIntegrators<mfem::ParBilinearForm>(
        _time_derivative_map.getTimeDerivativeName(test_var_name),
        test_var_name,
        td_blf,
        _td_kernels_map);

    // Recover and scale integrators from blf. This is to apply the dt*du/dt contributions from the
    // operator on the trial variable in the implicit integration scheme
    auto blf = _blfs.GetShared(test_var_name);
    ScaleAndAddBLFIntegrators(blf, td_blf, _dt_coef.constant);
    // Assemble form
    td_blf->Assemble();
  }
}

BuildEquationSystem()

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

virtualinherited

Build all forms comprising this EquationSystem.

Definition at line 457 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystemProblemOperator::Init(), Moose::MFEM::TimeDomainEquationSystemProblemOperator::Init(), and UpdateEquationSystem().

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

BuildJacobian()

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

virtualinherited

Build linear system, with essential boundary conditions accounted for.

Definition at line 334 of file EquationSystem.C.

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

{
  height = trueX.Size();
  width = trueRHS.Size();
  FormLinearSystem(_jacobian, trueX, trueRHS);
}

BuildLinearForms()

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

virtualinherited

Build linear forms and eliminate constrained DoFs.

Definition at line 368 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::TimeDependentEquationSystem::BuildMixedBilinearForms ( )

overridevirtual

Build mixed bilinear forms (off-diagonal Jacobian contributions)

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 590 of file EquationSystem.C.

{
  EquationSystem::BuildMixedBilinearForms();
  // 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 (_td_kernels_map.Has(test_var_name) &&
          _td_kernels_map.Get(test_var_name)->Has(trial_var_name) &&
          _time_derivative_map.getTimeDerivativeName(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);
      }
      // Recover and scale integrators from the mblf acting on the time integral of the trial
      // variable corresponding to coupled_var_name. This is to apply the dt*du/dt contributions
      // from the operator on the trial variable in the implicit integration scheme
      const auto & trial_var_time_integral_name =
          _time_derivative_map.getTimeIntegralName(trial_var_name);
      if (_mblfs.Has(test_var_name) && _mblfs.Get(test_var_name)->Has(trial_var_time_integral_name))
      {
        // Recover and scale integrators from mblf. This is to apply the dt*du/dt contributions
        // from the operator on the trial variable in the implicit integration scheme
        auto mblf = _mblfs.Get(test_var_name)->GetShared(trial_var_time_integral_name);
        ScaleAndAddBLFIntegrators(mblf, td_mblf, _dt_coef.constant);
      }
      // If implicit contributions exist, scale them by timestep and add to td_mblf
      if (td_mblf->GetDBFI()->Size() || td_mblf->GetBBFI()->Size())
      {
        // Assemble mixed bilinear form
        td_mblf->SetAssemblyLevel(_assembly_level);
        td_mblf->Assemble();
        // 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);
  }
}

DeleteAllBlocks()

void Moose::MFEM::EquationSystem::DeleteAllBlocks ( )

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

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

{
  for (const auto i : make_range(_h_blocks.NumRows()))
    for (const auto j : make_range(_h_blocks.NumCols()))
      delete _h_blocks(i, j);
  _h_blocks.DeleteAll();
}

EliminateCoupledVariables()

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

overridevirtual

Perform trivial eliminations of coupled variables lacking corresponding test variables.

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 673 of file EquationSystem.C.

{
  // Eliminate contributions from variables at previous timestep.
  for (const auto i : index_range(_test_var_names))
  {
    auto & test_var_name = _test_var_names.at(i);
    auto blf = _blfs.Get(test_var_name);
    auto lf = _lfs.Get(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());
    blf->Mult(*_eliminated_variables.Get(test_var_name), lf_prev);
    *lf -= lf_prev;
  }
  // Eliminate contributions from other coupled variables.
  EquationSystem::EliminateCoupledVariables();
}

FormLegacySystem()

void Moose::MFEM::TimeDependentEquationSystem::FormLegacySystem ( mfem::OperatorHandle &  op, mfem::BlockVector &  truedXdt, mfem::BlockVector &  trueRHS  )

overridevirtual

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 692 of file EquationSystem.C.

{
  // Form linear system for operator acting on vector of du/dt
  AssembleJacobian(
      _td_blfs, _td_mblfs, _lfs, _ess_tdof_lists, _td_var_ess_constraints, op, truedXdt, trueRHS);
}

FormLinearSystem()

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

virtualinherited

Form linear system, with essential boundary conditions accounted for.

Definition at line 217 of file EquationSystem.C.

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

{

  switch (_assembly_level)
  {
    case mfem::AssemblyLevel::LEGACY:
      FormLegacySystem(op, trueX, trueRHS);
      break;
    default:
      mooseAssert(_test_var_names.size() == 1,
                  "Non-legacy assembly is only supported for single-variable systems");
      mooseAssert(
          _test_var_names.size() == _trial_var_names.size(),
          "Non-legacy assembly is only supported for single test and trial variable systems");
      FormSystem(op, trueX, trueRHS);
  }
}

FormSystem()

void Moose::MFEM::TimeDependentEquationSystem::FormSystem ( mfem::OperatorHandle &  op, mfem::BlockVector &  truedXdt, mfem::BlockVector &  trueRHS  )

overridevirtual

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 702 of file EquationSystem.C.

{
  auto & test_var_name = _test_var_names.at(0);
  auto td_blf = _td_blfs.Get(test_var_name);
  auto lf = _lfs.Get(test_var_name);

  // Form linear system for operator acting on vector of du/dt
  mfem::OperatorPtr aux_a;
  mfem::Vector aux_x, aux_rhs;
  td_blf->FormLinearSystem(
      _ess_tdof_lists.at(0), *(_td_var_ess_constraints.at(0)), *lf, aux_a, aux_x, aux_rhs);

  truedXdt.GetBlock(0) = aux_x;
  trueRHS.GetBlock(0) = aux_rhs;
  truedXdt.SyncFromBlocks();
  trueRHS.SyncFromBlocks();

  // Create monolithic matrix
  op.Reset(aux_a.Ptr());
  aux_a.SetOperatorOwner(false);
}

GetGradient()

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

overrideinherited

Compute J = M + grad_H(u)

Definition at line 350 of file EquationSystem.C.

{
  return *_jacobian;
}

Init()

void Moose::MFEM::TimeDependentEquationSystem::Init ( Moose::MFEM::GridFunctions &  gridfunctions, mfem::AssemblyLevel  assembly_level  )

overridevirtual

Initialise.

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 471 of file EquationSystem.C.

{
  EquationSystem::Init(gridfunctions, assembly_level);
  for (auto & test_var_name : _test_var_names)
    _td_var_ess_constraints.emplace_back(
        std::make_unique<mfem::ParGridFunction>(gridfunctions.Get(test_var_name)->ParFESpace()));
}

Mult()

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

overrideinherited

Compute residual y = Mu.

Definition at line 342 of file EquationSystem.C.

{
  _jacobian->Mult(x, residual);
  x.HostRead();
  residual.HostRead();
}

RecoverFEMSolution()

void Moose::MFEM::EquationSystem::RecoverFEMSolution ( mfem::BlockVector &  trueX, Moose::MFEM::GridFunctions &  gridfunctions  )

virtualinherited

Update variable from solution vector after solve.

Definition at line 356 of file EquationSystem.C.

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

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

ScaleAndAddBLFIntegrators()

template<class FormType >

void Moose::MFEM::TimeDependentEquationSystem::ScaleAndAddBLFIntegrators ( std::shared_ptr< FormType >  source_blf, std::shared_ptr< FormType >  target_blf, mfem::real_t  scale_factor  )

inline

Fetch all integrators on a source bilinear form, scale them by a real factor, and add to a second target bilienar form.

Useful for scaling bilinear form integrators by timesteps.

Definition at line 349 of file EquationSystem.h.

Referenced by BuildBilinearForms(), and BuildMixedBilinearForms().

  {
    // Add and scale all domain integrators existing on source_blf to target_blf
    auto domain_integrators = source_blf->GetDBFI();
    auto domain_markers = source_blf->GetDBFI_Marker();
    for (int i = 0; i < domain_integrators->Size(); ++i)
      target_blf->AddDomainIntegrator(
          new ScaleIntegrator(*domain_integrators[i], scale_factor, false), *(*domain_markers[i]));
    // Add and scale all boundary integrators existing on source_blf to target_blf
    auto boundary_integrators = source_blf->GetBBFI();
    auto boundary_markers = source_blf->GetBBFI_Marker();
    for (int i = 0; i < boundary_integrators->Size(); ++i)
      target_blf->AddBoundaryIntegrator(
          new ScaleIntegrator(*boundary_integrators[i], scale_factor, false),
          *(*boundary_markers[i]));
  }

SetTimeStep()

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

virtual

Definition at line 481 of file EquationSystem.C.

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

{
  if (fabs(dt - _dt_coef.constant) > 1.0e-12 * dt)
  {
    _dt_coef.constant = dt;
    for (auto test_var_name : _test_var_names)
    {
      auto blf = _blfs.Get(test_var_name);
      blf->Update();
      blf->Assemble();
    }
  }
}

SetTrialVariableNames()

void Moose::MFEM::TimeDependentEquationSystem::SetTrialVariableNames ( )

overrideprivatevirtual

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

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 496 of file EquationSystem.C.

{
  // The TimeDependentEquationSystem operator expects to act on a vector of variable time
  // derivatives, so the trial variable must be the time derivative of the 'base' variable. The base
  // variable (test_var_name) without derivatives applied must also be coupled in implicit
  // timestepping schemes for the elimination of 'old' variable values from the previous timestep
  for (const auto & test_var_name : _test_var_names)
  {
    AddCoupledVariableNameIfMissing(test_var_name);
    AddCoupledVariableNameIfMissing(_time_derivative_map.getTimeDerivativeName(test_var_name));
  }

  // If a coupled variable does not have an equation associated with it,
  // add it to the set of eliminated variables.
  for (const auto & test_var_name : _test_var_names)
  {
    const auto time_derivative_test_var_name =
        _time_derivative_map.getTimeDerivativeName(test_var_name);
    for (const auto & coupled_var_name : _coupled_var_names)
    {
      if (time_derivative_test_var_name != coupled_var_name &&
          !VectorContainsName(_eliminated_var_names, coupled_var_name))
        _eliminated_var_names.push_back(coupled_var_name);
    }
    if (!VectorContainsName(_trial_var_names, time_derivative_test_var_name))
      _trial_var_names.push_back(time_derivative_test_var_name);
  }
}

TestVarNames()

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

inlineinherited

Definition at line 116 of file EquationSystem.h.

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

{ return _test_var_names; }

TrialVarNames()

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

inlineinherited

Definition at line 115 of file EquationSystem.h.

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

{ return _trial_var_names; }

UpdateEquationSystem()

void Moose::MFEM::TimeDependentEquationSystem::UpdateEquationSystem ( )

virtual

Definition at line 727 of file EquationSystem.C.

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

{
  EquationSystem::BuildEquationSystem();
}

VectorContainsName()

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

protectedinherited

Definition at line 30 of file EquationSystem.C.

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

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

Member Data Documentation

_assembly_level

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

protectedinherited

Definition at line 216 of file EquationSystem.h.

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

_blfs

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

protectedinherited

Definition at line 156 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::BuildBilinearForms(), BuildBilinearForms(), EliminateCoupledVariables(), Moose::MFEM::EquationSystem::FormLegacySystem(), Moose::MFEM::EquationSystem::FormSystem(), and SetTimeStep().

_coupled_pfespaces

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

protectedinherited

Pointers to finite element spaces associated with coupled variables.

Definition at line 153 of file EquationSystem.h.

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

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

_dt_coef

mfem::ConstantCoefficient Moose::MFEM::TimeDependentEquationSystem::_dt_coef

protected

Coefficient for timestep scaling.

Definition at line 370 of file EquationSystem.h.

Referenced by ApplyEssentialBCs(), BuildBilinearForms(), BuildMixedBilinearForms(), 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 145 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::EliminateCoupledVariables(), Moose::MFEM::EquationSystem::Init(), Moose::MFEM::EquationSystem::SetTrialVariableNames(), and 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 147 of file EquationSystem.h.

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

_ess_tdof_lists

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

inherited

Definition at line 113 of file EquationSystem.h.

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

_essential_bc_map

Moose::MFEM::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 212 of file EquationSystem.h.

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

_h_blocks

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

protectedinherited

Definition at line 199 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AssembleJacobian(), and Moose::MFEM::EquationSystem::DeleteAllBlocks().

_integrated_bc_map

Moose::MFEM::NamedFieldsMap< Moose::MFEM::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 209 of file EquationSystem.h.

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

_jacobian

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

mutableprotectedinherited

Definition at line 214 of file EquationSystem.h.

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

_kernels_map

Moose::MFEM::NamedFieldsMap<Moose::MFEM::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 204 of file EquationSystem.h.

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

_lfs

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

protectedinherited

Definition at line 157 of file EquationSystem.h.

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

_mblfs

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

protectedinherited

Definition at line 160 of file EquationSystem.h.

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

_nlfs

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

protectedinherited

Definition at line 158 of file EquationSystem.h.

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

Referenced by BuildBilinearForms(), FormLegacySystem(), and FormSystem().

_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 373 of file EquationSystem.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 377 of file EquationSystem.h.

Referenced by BuildMixedBilinearForms(), and FormLegacySystem().

_td_var_ess_constraints

std::vector<std::unique_ptr<mfem::ParGridFunction> > Moose::MFEM::TimeDependentEquationSystem::_td_var_ess_constraints

protected

Gridfunctions holding essential constraints from Dirichlet BCs.

Definition at line 380 of file EquationSystem.h.

Referenced by ApplyEssentialBCs(), FormLegacySystem(), FormSystem(), and Init().

_test_pfespaces

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

protectedinherited

Pointers to finite element spaces associated with test variables.

Definition at line 151 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AssembleJacobian(), Moose::MFEM::EquationSystem::BuildBilinearForms(), BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildLinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), BuildMixedBilinearForms(), and Moose::MFEM::EquationSystem::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 149 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::AddTestVariableNameIfMissing(), Moose::MFEM::EquationSystem::ApplyEssentialBCs(), ApplyEssentialBCs(), Moose::MFEM::EquationSystem::AssembleJacobian(), Moose::MFEM::EquationSystem::BuildBilinearForms(), BuildBilinearForms(), Moose::MFEM::EquationSystem::BuildLinearForms(), Moose::MFEM::EquationSystem::BuildMixedBilinearForms(), BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::EliminateCoupledVariables(), EliminateCoupledVariables(), Moose::MFEM::EquationSystem::FormLinearSystem(), Moose::MFEM::EquationSystem::FormSystem(), FormSystem(), Moose::MFEM::EquationSystem::Init(), Init(), SetTimeStep(), Moose::MFEM::EquationSystem::SetTrialVariableNames(), SetTrialVariableNames(), and Moose::MFEM::EquationSystem::TestVarNames().

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

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

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

Referenced by Moose::MFEM::EquationSystem::AssembleJacobian(), BuildMixedBilinearForms(), Moose::MFEM::EquationSystem::FormLinearSystem(), Moose::MFEM::EquationSystem::RecoverFEMSolution(), Moose::MFEM::EquationSystem::SetTrialVariableNames(), SetTrialVariableNames(), and Moose::MFEM::EquationSystem::TrialVarNames().

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

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

---

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

• include/mfem/equation_systems/EquationSystem.h
• src/mfem/equation_systems/EquationSystem.C