Moose::MFEM::EquationSystem Class Reference

#include <EquationSystem.h>

Inheritance diagram for Moose::MFEM::EquationSystem:

Public Member Functions
	EquationSystem ()=default
	~EquationSystem () override
virtual void	AddTestVariableNameIfMissing (const std::string &test_var_name)
virtual void	AddTrialVariableNameIfMissing (const std::string &trial_var_name)
virtual void	AddKernel (std::shared_ptr< MFEMKernel > kernel)
virtual void	AddIntegratedBC (std::shared_ptr< MFEMIntegratedBC > kernel)
virtual void	AddEssentialBC (std::shared_ptr< MFEMEssentialBC > bc)
virtual void	ApplyEssentialBCs ()
virtual void	Init (Moose::MFEM::GridFunctions &gridfunctions, const Moose::MFEM::FESpaces &fespaces, mfem::AssemblyLevel assembly_level)
virtual void	BuildLinearForms ()
virtual void	BuildBilinearForms ()
virtual void	BuildMixedBilinearForms ()
virtual void	BuildEquationSystem ()
virtual void	FormLinearSystem (mfem::OperatorHandle &op, mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
virtual void	FormSystem (mfem::OperatorHandle &op, mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
virtual void	FormLegacySystem (mfem::OperatorHandle &op, mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
virtual void	BuildJacobian (mfem::BlockVector &trueX, mfem::BlockVector &trueRHS)
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)
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 ()
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
std::vector< std::string >	_trial_var_names
Moose::MFEM::GridFunctions	_trial_variables
std::vector< std::string >	_test_var_names
std::vector< mfem::ParFiniteElementSpace * >	_test_pfespaces
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 > >	_xs
std::vector< std::unique_ptr< mfem::ParGridFunction > >	_dxdts
mfem::Array2D< const mfem::HypreParMatrix * >	_h_blocks
Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel > > > >	_kernels_map
Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMIntegratedBC > > > >	_integrated_bc_map
Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMEssentialBC > > >	_essential_bc_map
mfem::OperatorHandle	_jacobian
mfem::AssemblyLevel	_assembly_level

Friends
class	EquationSystemProblemOperator
class	TimeDomainEquationSystemProblemOperator

Detailed Description

Definition at line 30 of file EquationSystem.h.

Constructor & Destructor Documentation

EquationSystem()

Moose::MFEM::EquationSystem::EquationSystem ( )

default

~EquationSystem()

Moose::MFEM::EquationSystem::~EquationSystem ( )

override

Definition at line 18 of file EquationSystem.C.

{ DeleteAllBlocks(); }

Member Function Documentation

AddEssentialBC()

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

virtual

Definition at line 104 of file EquationSystem.C.

{
  AddTestVariableNameIfMissing(bc->getTestVariableName());
  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 )

virtual

Definition at line 81 of file EquationSystem.C.

{
  AddTestVariableNameIfMissing(bc->getTestVariableName());
  AddTrialVariableNameIfMissing(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::EquationSystem::AddKernel ( std::shared_ptr< MFEMKernel >  kernel )

virtual

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 58 of file EquationSystem.C.

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

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

AddTestVariableNameIfMissing()

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

virtual

Definition at line 49 of file EquationSystem.C.

Referenced by AddEssentialBC(), AddIntegratedBC(), AddKernel(), and Moose::MFEM::TimeDependentEquationSystem::AddKernel().

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

AddTrialVariableNameIfMissing()

void Moose::MFEM::EquationSystem::AddTrialVariableNameIfMissing ( const std::string &  trial_var_name )

virtual

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 40 of file EquationSystem.C.

Referenced by AddIntegratedBC(), and AddKernel().

{
  if (!VectorContainsName(_trial_var_names, trial_var_name))
  {
    _trial_var_names.push_back(trial_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  )

protected

Definition at line 222 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  )

inlineprotected

Definition at line 248 of file EquationSystem.h.

Referenced by BuildLinearForms().

{
  if (integrated_bc_map.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  )

protected

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

Definition at line 174 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  )

inlineprotected

Definition at line 198 of file EquationSystem.h.

Referenced by BuildLinearForms().

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

ApplyEssentialBCs()

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

virtual

Definition at line 117 of file EquationSystem.C.

Referenced by BuildLinearForms().

{
  _ess_tdof_lists.resize(_test_var_names.size());
  for (const auto i : index_range(_test_var_names))
  {
    auto test_var_name = _test_var_names.at(i);
    if (!_essential_bc_map.Has(test_var_name))
      continue;

    // Set default value of gridfunction used in essential BC. Values
    // overwritten in applyEssentialBCs
    mfem::ParGridFunction & trial_gf(*(_xs.at(i)));
    auto * const pmesh = _test_pfespaces.at(i)->GetParMesh();
    mooseAssert(pmesh, "parallel mesh is null");

    auto bcs = _essential_bc_map.GetRef(test_var_name);
    mfem::Array<int> global_ess_markers(pmesh->bdr_attributes.Max());
    global_ess_markers = 0;
    for (auto & bc : bcs)
    {
      bc->ApplyBC(trial_gf);

      mfem::Array<int> ess_bdrs(bc->getBoundaryMarkers());
      for (auto it = 0; it != pmesh->bdr_attributes.Max(); ++it)
      {
        global_ess_markers[it] = std::max(global_ess_markers[it], ess_bdrs[it]);
      }
    }
    trial_gf.FESpace()->GetEssentialTrueDofs(global_ess_markers, _ess_tdof_lists.at(i));
  }
}

BuildBilinearForms()

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

virtual

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 337 of file EquationSystem.C.

Referenced by Moose::MFEM::TimeDependentEquationSystem::BuildBilinearForms(), and BuildEquationSystem().

{
  // Register bilinear forms
  for (const auto i : index_range(_test_var_names))
  {
    auto test_var_name = _test_var_names.at(i);
    _blfs.Register(test_var_name, std::make_shared<mfem::ParBilinearForm>(_test_pfespaces.at(i)));

    // Apply kernels
    auto blf = _blfs.GetShared(test_var_name);
    blf->SetAssemblyLevel(_assembly_level);
    ApplyBoundaryBLFIntegrators<mfem::ParBilinearForm>(
        test_var_name, test_var_name, blf, _integrated_bc_map);
    ApplyDomainBLFIntegrators<mfem::ParBilinearForm>(
        test_var_name, test_var_name, blf, _kernels_map);
    // Assemble
    blf->Assemble();
  }
}

BuildEquationSystem()

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

virtual

Definition at line 396 of file EquationSystem.C.

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

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

BuildJacobian()

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

virtual

Definition at line 254 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 ( )

virtual

Definition at line 314 of file EquationSystem.C.

Referenced by BuildEquationSystem(), and Moose::MFEM::TimeDependentEquationSystem::UpdateEquationSystem().

{
  // 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;
  }
  // Apply boundary conditions
  ApplyEssentialBCs();

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

BuildMixedBilinearForms()

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

virtual

Definition at line 358 of file EquationSystem.C.

Referenced by BuildEquationSystem(), and Moose::MFEM::TimeDependentEquationSystem::UpdateEquationSystem().

{
  // Register mixed bilinear forms. Note that not all combinations may
  // have a kernel

  // Create mblf for each test/trial pair
  for (const auto i : index_range(_test_var_names))
  {
    auto test_var_name = _test_var_names.at(i);
    auto test_mblfs = std::make_shared<Moose::MFEM::NamedFieldsMap<mfem::ParMixedBilinearForm>>();
    for (const auto j : index_range(_test_var_names))
    {
      auto trial_var_name = _trial_var_names.at(j);
      auto 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 (_kernels_map.Has(test_var_name) && _kernels_map.Get(test_var_name)->Has(trial_var_name) &&
          test_var_name != trial_var_name)
      {
        mblf->SetAssemblyLevel(_assembly_level);
        // Apply all mixed kernels with this test/trial pair
        ApplyDomainBLFIntegrators<mfem::ParMixedBilinearForm>(
            trial_var_name, test_var_name, mblf, _kernels_map);
        // Assemble mixed bilinear forms
        mblf->Assemble();
        // Register mixed bilinear forms associated with a single trial variable
        // for the current test variable
        test_mblfs->Register(trial_var_name, mblf);
      }
    }
    // Register all mixed bilinear form sets associated with a single test
    // variable
    _mblfs.Register(test_var_name, test_mblfs);
  }
}

DeleteAllBlocks()

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

protected

Definition at line 21 of file EquationSystem.C.

Referenced by FormLegacySystem(), Moose::MFEM::TimeDependentEquationSystem::FormLegacySystem(), and ~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();
}

FormLegacySystem()

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

virtual

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 193 of file EquationSystem.C.

Referenced by FormLinearSystem().

{

  // 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 = _blfs.Get(test_var_name);
    auto lf = _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), *(_xs.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(_test_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 (_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);
        mfem::HypreParMatrix * aux_a = new mfem::HypreParMatrix;
        mblf->FormRectangularLinearSystem(_ess_tdof_lists.at(j),
                                          _ess_tdof_lists.at(i),
                                          *(_xs.at(j)),
                                          aux_lf,
                                          *aux_a,
                                          aux_x,
                                          aux_rhs);
        _h_blocks(i, j) = aux_a;
        trueRHS.GetBlock(i) += aux_rhs;
      }
    }
  }
  // Sync memory
  for (const auto i : index_range(_test_var_names))
  {
    trueX.GetBlock(i).SyncAliasMemory(trueX);
    trueRHS.GetBlock(i).SyncAliasMemory(trueRHS);
  }

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

FormLinearSystem()

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

virtual

Definition at line 150 of file EquationSystem.C.

Referenced by 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::EquationSystem::FormSystem ( mfem::OperatorHandle &  op, mfem::BlockVector &  trueX, mfem::BlockVector &  trueRHS  )

virtual

Reimplemented in Moose::MFEM::TimeDependentEquationSystem.

Definition at line 171 of file EquationSystem.C.

Referenced by FormLinearSystem().

{
  auto & test_var_name = _test_var_names.at(0);
  auto blf = _blfs.Get(test_var_name);
  auto lf = _lfs.Get(test_var_name);
  mfem::BlockVector aux_x, aux_rhs;
  mfem::OperatorPtr aux_a;

  blf->FormLinearSystem(_ess_tdof_lists.at(0), *(_xs.at(0)), *lf, aux_a, aux_x, aux_rhs);

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

  op.Reset(aux_a.Ptr());
  aux_a.SetOperatorOwner(false);
}

GetGradient()

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

override

Compute J = M + grad_H(u)

Definition at line 270 of file EquationSystem.C.

{
  return *_jacobian;
}

Init()

void Moose::MFEM::EquationSystem::Init ( Moose::MFEM::GridFunctions &  gridfunctions, const Moose::MFEM::FESpaces &  fespaces, mfem::AssemblyLevel  assembly_level  )

virtual

Definition at line 288 of file EquationSystem.C.

{
  _assembly_level = assembly_level;

  for (auto & test_var_name : _test_var_names)
  {
    if (!gridfunctions.Has(test_var_name))
    {
      MFEM_ABORT("Test variable " << test_var_name
                                  << " requested by equation system during initialisation was "
                                     "not found in gridfunctions");
    }
    // Store pointers to variable FESpaces
    _test_pfespaces.push_back(gridfunctions.Get(test_var_name)->ParFESpace());
    // Create auxiliary gridfunctions for applying Dirichlet conditions
    _xs.emplace_back(
        std::make_unique<mfem::ParGridFunction>(gridfunctions.Get(test_var_name)->ParFESpace()));
    _dxdts.emplace_back(
        std::make_unique<mfem::ParGridFunction>(gridfunctions.Get(test_var_name)->ParFESpace()));
    _trial_variables.Register(test_var_name, gridfunctions.GetShared(test_var_name));
  }
}

Mult()

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

override

Compute residual y = Mu.

Definition at line 262 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  )

virtual

Definition at line 276 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)));
  }
}

TestVarNames()

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

inline

Definition at line 87 of file EquationSystem.h.

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

{ return _test_var_names; }

TrialVarNames()

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

inline

Definition at line 86 of file EquationSystem.h.

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

{ return _trial_var_names; }

VectorContainsName()

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

protected

Definition at line 30 of file EquationSystem.C.

Referenced by AddTestVariableNameIfMissing(), AddTrialVariableNameIfMissing(), and Moose::MFEM::TimeDependentEquationSystem::AddTrialVariableNameIfMissing().

{

  auto iter = std::find(the_vector.begin(), the_vector.end(), name);

  return (iter != the_vector.end());
}

Friends And Related Function Documentation

EquationSystemProblemOperator

friend class EquationSystemProblemOperator

friend

Definition at line 34 of file EquationSystem.h.

TimeDomainEquationSystemProblemOperator

friend class TimeDomainEquationSystemProblemOperator

friend

Definition at line 35 of file EquationSystem.h.

Member Data Documentation

_assembly_level

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

protected

Definition at line 169 of file EquationSystem.h.

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

_blfs

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

protected

Definition at line 112 of file EquationSystem.h.

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

_dxdts

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

protected

Definition at line 154 of file EquationSystem.h.

Referenced by Init().

_ess_tdof_lists

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

Definition at line 84 of file EquationSystem.h.

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

_essential_bc_map

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

protected

Definition at line 165 of file EquationSystem.h.

Referenced by AddEssentialBC(), and ApplyEssentialBCs().

_h_blocks

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

protected

Definition at line 156 of file EquationSystem.h.

Referenced by DeleteAllBlocks(), FormLegacySystem(), and Moose::MFEM::TimeDependentEquationSystem::FormLegacySystem().

_integrated_bc_map

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

protected

Definition at line 164 of file EquationSystem.h.

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

_jacobian

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

mutableprotected

Definition at line 167 of file EquationSystem.h.

Referenced by BuildJacobian(), GetGradient(), and Mult().

_kernels_map

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

protected

Definition at line 161 of file EquationSystem.h.

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

_lfs

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

protected

Definition at line 113 of file EquationSystem.h.

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

_mblfs

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

protected

Definition at line 116 of file EquationSystem.h.

Referenced by BuildMixedBilinearForms(), and FormLegacySystem().

_nlfs

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

protected

Definition at line 114 of file EquationSystem.h.

_test_pfespaces

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

protected

Definition at line 109 of file EquationSystem.h.

Referenced by ApplyEssentialBCs(), BuildBilinearForms(), Moose::MFEM::TimeDependentEquationSystem::BuildBilinearForms(), BuildLinearForms(), BuildMixedBilinearForms(), FormLegacySystem(), and Init().

_test_var_names

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

protected

Definition at line 108 of file EquationSystem.h.

Referenced by AddTestVariableNameIfMissing(), ApplyEssentialBCs(), BuildBilinearForms(), Moose::MFEM::TimeDependentEquationSystem::BuildBilinearForms(), BuildLinearForms(), BuildMixedBilinearForms(), FormLegacySystem(), Moose::MFEM::TimeDependentEquationSystem::FormLegacySystem(), FormLinearSystem(), FormSystem(), Moose::MFEM::TimeDependentEquationSystem::FormSystem(), Init(), Moose::MFEM::TimeDependentEquationSystem::SetTimeStep(), and TestVarNames().

_trial_var_names

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

protected

Definition at line 103 of file EquationSystem.h.

Referenced by AddTrialVariableNameIfMissing(), Moose::MFEM::TimeDependentEquationSystem::AddTrialVariableNameIfMissing(), BuildMixedBilinearForms(), FormLegacySystem(), FormLinearSystem(), RecoverFEMSolution(), and TrialVarNames().

_trial_variables

Moose::MFEM::GridFunctions Moose::MFEM::EquationSystem::_trial_variables

protected

Definition at line 105 of file EquationSystem.h.

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

_xs

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

protected

Definition at line 153 of file EquationSystem.h.

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

---

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

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