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 ()
void	AddTrialVariableNameIfMissing (const std::string &trial_var_name) override
	Add trial variable to EquationSystem. More...
virtual void	SetTimeStep (double dt)
virtual void	UpdateEquationSystem ()
virtual void	AddKernel (std::shared_ptr< MFEMKernel > kernel) override
	Add kernels. More...
virtual void	BuildBilinearForms () override
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
const std::vector< std::string > &	TrialVarTimeDerivativeNames () const
virtual void	AddTestVariableNameIfMissing (const std::string &test_var_name)
	Add test variable to EquationSystem. More...
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)
	Build forms. More...
virtual void	BuildLinearForms ()
virtual void	BuildMixedBilinearForms ()
virtual void	BuildEquationSystem ()
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...
std::vector< std::string >	_trial_var_time_derivative_names
Moose::MFEM::NamedFieldsMap< Moose::MFEM::NamedFieldsMap< std::vector< std::shared_ptr< MFEMKernel > > > >	_td_kernels_map
Moose::MFEM::NamedFieldsMap< mfem::ParBilinearForm >	_td_blfs
	Container to store contributions to weak form of the form (F du/dt, v) More...
std::vector< std::string >	_trial_var_names
	Names of all variables corresponding to gridfunctions. More...
Moose::MFEM::GridFunctions	_trial_variables
	Pointers to trial variables. 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...
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
	Gridfunctions for setting Dirichlet BCs. More...
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
	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

Detailed Description

Class to store weak form components for time dependent PDEs.

Definition at line 283 of file EquationSystem.h.

Constructor & Destructor Documentation

TimeDependentEquationSystem()

Moose::MFEM::TimeDependentEquationSystem::TimeDependentEquationSystem

(

)

Definition at line 403 of file EquationSystem.C.

: _dt_coef(1.0) {}

Member Function Documentation

AddEssentialBC()

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

virtualinherited

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 )

virtualinherited

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

overridevirtual

Add kernels.

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 435 of file EquationSystem.C.

{
  if (kernel->getTrialVariableName() == GetTimeDerivativeName(kernel->getTestVariableName()))
  {
    auto trial_var_name = kernel->getTrialVariableName();
    auto test_var_name = kernel->getTestVariableName();
    AddTestVariableNameIfMissing(test_var_name);
    AddTrialVariableNameIfMissing(test_var_name);
    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 kernels map if not present for the test variable
    if (!_td_kernels_map.Get(test_var_name)->Has(test_var_name))
    {
      auto kernels = std::make_shared<std::vector<std::shared_ptr<MFEMKernel>>>();
      _td_kernels_map.Get(test_var_name)->Register(test_var_name, std::move(kernels));
    }
    _td_kernels_map.GetRef(test_var_name).Get(test_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 49 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::AddEssentialBC(), 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);
  }
}

AddTrialVariableNameIfMissing()

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

overridevirtual

Add trial variable to EquationSystem.

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 406 of file EquationSystem.C.

Referenced by AddKernel().

{
  // The TimeDependentEquationSystem operator expects to act on a vector of variable time
  // derivatives
  std::string var_time_derivative_name = GetTimeDerivativeName(var_name);

  if (!VectorContainsName(_trial_var_names, var_time_derivative_name))
  {
    _trial_var_names.push_back(var_time_derivative_name);
    _trial_var_time_derivative_names.push_back(var_time_derivative_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 230 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 256 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 182 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 206 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));
      }
    }
  }
}

ApplyEssentialBCs()

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

virtualinherited

Definition at line 117 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::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::TimeDependentEquationSystem::BuildBilinearForms ( )

overridevirtual

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 464 of file EquationSystem.C.

Referenced by UpdateEquationSystem().

{
  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>(
        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.Get(test_var_name);
    auto integs = blf->GetDBFI();
    auto b_integs = blf->GetBBFI();
    auto markers = blf->GetBBFI_Marker();

    mfem::SumIntegrator * sum = new mfem::SumIntegrator(false);
    ScaleIntegrator * scaled_sum = new ScaleIntegrator(sum, _dt_coef.constant, true);

    for (int i = 0; i < integs->Size(); ++i)
    {
      sum->AddIntegrator(*integs[i]);
    }

    for (int i = 0; i < b_integs->Size(); ++i)
    {
      td_blf->AddBoundaryIntegrator(new ScaleIntegrator(*b_integs[i], _dt_coef.constant, false),
                                    *(*markers[i]));
    }

    // scaled_sum is owned by td_blf
    td_blf->AddDomainIntegrator(scaled_sum);

    // Assemble form
    td_blf->Assemble();
  }
}

BuildEquationSystem()

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

virtualinherited

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  )

virtualinherited

Build linear system, with essential boundary conditions accounted for.

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

virtualinherited

Definition at line 314 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildEquationSystem(), and 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 ( )

virtualinherited

Definition at line 358 of file EquationSystem.C.

Referenced by Moose::MFEM::EquationSystem::BuildEquationSystem(), and 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 ( )

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

FormLegacySystem()

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

overridevirtual

Reimplemented from Moose::MFEM::EquationSystem.

Definition at line 514 of file EquationSystem.C.

{

  // 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 td_blf = _td_blfs.Get(test_var_name);
    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
    // variable at previous timestep: {
    blf->AddMult(*_trial_variables.Get(test_var_name), *lf, -1.0);
    // }
    mfem::Vector aux_x, aux_rhs;
    // Update solution values on Dirichlet values to be in terms of du/dt instead of u
    mfem::Vector bc_x = *(_xs.at(i).get());
    bc_x -= *_trial_variables.Get(test_var_name);
    bc_x /= _dt_coef.constant;

    // Form linear system for operator acting on vector of du/dt
    mfem::HypreParMatrix * aux_a = new mfem::HypreParMatrix;
    td_blf->FormLinearSystem(_ess_tdof_lists.at(i), bc_x, *lf, *aux_a, aux_x, aux_rhs);
    _h_blocks(i, i) = aux_a;
    truedXdt.GetBlock(i) = aux_x;
    trueRHS.GetBlock(i) = aux_rhs;
  }

  truedXdt.SyncFromBlocks();
  trueRHS.SyncFromBlocks();

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

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

{
  auto & test_var_name = _test_var_names.at(0);
  auto td_blf = _td_blfs.Get(test_var_name);
  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
  // variable at previous timestep: {

  // The AddMult method in mfem::BilinearForm is not defined for non-legacy assembly
  mfem::Vector lf_prev(lf->Size());
  blf->Mult(*_trial_variables.Get(test_var_name), lf_prev);
  *lf -= lf_prev;
  // }
  mfem::Vector aux_x, aux_rhs;
  // Update solution values on Dirichlet values to be in terms of du/dt instead of u
  mfem::Vector bc_x = *(_xs.at(0).get());
  bc_x -= *_trial_variables.Get(test_var_name);
  bc_x /= _dt_coef.constant;

  // Form linear system for operator acting on vector of du/dt
  mfem::OperatorPtr aux_a;
  td_blf->FormLinearSystem(_ess_tdof_lists.at(0), bc_x, *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 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  )

virtualinherited

Build forms.

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

overrideinherited

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  )

virtualinherited

Update variable from solution vector after solve.

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

SetTimeStep()

void Moose::MFEM::TimeDependentEquationSystem::SetTimeStep ( double  dt )

virtual

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

TestVarNames()

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

inlineinherited

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

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

{ return _trial_var_names; }

TrialVarTimeDerivativeNames()

const std::vector< std::string > & Moose::MFEM::TimeDependentEquationSystem::TrialVarTimeDerivativeNames ( ) const

inline

Definition at line 316 of file EquationSystem.h.

{
  return _trial_var_time_derivative_names;
}

UpdateEquationSystem()

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

virtual

Definition at line 592 of file EquationSystem.C.

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

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

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::AddTestVariableNameIfMissing(), Moose::MFEM::EquationSystem::AddTrialVariableNameIfMissing(), and AddTrialVariableNameIfMissing().

{

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

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

_blfs

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

protectedinherited

Definition at line 116 of file EquationSystem.h.

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

_dt_coef

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

protected

Coefficient for timestep scaling.

Definition at line 306 of file EquationSystem.h.

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

_dxdts

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

protectedinherited

Definition at line 158 of file EquationSystem.h.

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

_ess_tdof_lists

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

inherited

Definition at line 84 of file EquationSystem.h.

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

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

_h_blocks

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

protectedinherited

Definition at line 160 of file EquationSystem.h.

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

_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 170 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 175 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 165 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 117 of file EquationSystem.h.

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

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

_nlfs

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

protectedinherited

Definition at line 118 of file EquationSystem.h.

_td_blfs

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

protected

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

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

Referenced by AddKernel(), and BuildBilinearForms().

_test_pfespaces

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

protectedinherited

Pointers to finite element spaces associated with test variables.

Definition at line 113 of file EquationSystem.h.

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

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

_trial_var_names

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

protectedinherited

Names of all variables corresponding to gridfunctions.

This may differ from test_var_names when time derivatives are present.

Definition at line 107 of file EquationSystem.h.

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

_trial_var_time_derivative_names

std::vector<std::string> Moose::MFEM::TimeDependentEquationSystem::_trial_var_time_derivative_names

protected

Definition at line 307 of file EquationSystem.h.

Referenced by AddTrialVariableNameIfMissing(), and TrialVarTimeDerivativeNames().

_trial_variables

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

protectedinherited

Pointers to trial variables.

Definition at line 109 of file EquationSystem.h.

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

_xs

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

protectedinherited

Gridfunctions for setting Dirichlet BCs.

Definition at line 157 of file EquationSystem.h.

Referenced by Moose::MFEM::EquationSystem::ApplyEssentialBCs(), Moose::MFEM::EquationSystem::FormLegacySystem(), FormLegacySystem(), Moose::MFEM::EquationSystem::FormSystem(), 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