ComplexEquationSystem.h

Go to the documentation of this file.

#ifdef MOOSE_MFEM_ENABLED
 
#pragma once
 
#include "libmesh/ignore_warnings.h"
#include "mfem/miniapps/common/pfem_extras.hpp"
#include "libmesh/restore_warnings.h"
#include "EquationSystem.h"
#include "MFEMComplexKernel.h"
#include "MFEMComplexIntegratedBC.h"
#include "MFEMComplexEssentialBC.h"
 
namespace Moose::MFEM
{
/*
Class to store weak form components (bilinear and linear forms, and optionally
mixed and nonlinear forms) and build methods
*/
class ComplexEquationSystem : public EquationSystem
{
public:
  ComplexEquationSystem() = default;
  ~ComplexEquationSystem() = default;
 
  // Build forms
  virtual void Init(GridFunctions & gridfunctions,
                    ComplexGridFunctions & cmplx_gridfunctions,
                    mfem::AssemblyLevel assembly_level) override;
 
  virtual void Mult(const mfem::Vector & x, mfem::Vector & y) const override;
 
  virtual void BuildEquationSystem() override;
 
  virtual void BuildLinearForms() override;
 
  virtual void BuildBilinearForms() override;
 
  virtual void ApplyComplexEssentialBC(const std::string & var_name,
                                       mfem::ParComplexGridFunction & trial_gf,
                                       mfem::Array<int> & global_ess_markers);
  virtual void ApplyEssentialBCs() override;
 
  void AddComplexKernel(std::shared_ptr<MFEMComplexKernel> kernel);
 
  void AddComplexIntegratedBC(std::shared_ptr<MFEMComplexIntegratedBC> bc);
 
  void AddComplexEssentialBCs(std::shared_ptr<MFEMComplexEssentialBC> bc);
 
  virtual void FormSystemOperator(mfem::OperatorHandle & op,
                                  mfem::BlockVector & trueX,
                                  mfem::BlockVector & trueRHS) override;
 
  virtual void FormSystemMatrix(mfem::OperatorHandle & op,
                                mfem::BlockVector & trueX,
                                mfem::BlockVector & trueRHS) override;
 
  virtual void SetTrialVariablesFromTrueVectors(const mfem::BlockVector & trueX) const override;
 
  template <class FormType>
  void ApplyDomainBLFIntegrators(
      const std::string & trial_var_name,
      const std::string & test_var_name,
      std::shared_ptr<FormType> form,
      NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexKernel>>>> &
          kernels_map);
 
  inline void ApplyDomainLFIntegrators(
      const std::string & test_var_name,
      std::shared_ptr<mfem::ParComplexLinearForm> form,
      NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexKernel>>>> &
          kernels_map);
 
  template <class FormType>
  void ApplyBoundaryBLFIntegrators(
      const std::string & trial_var_name,
      const std::string & test_var_name,
      std::shared_ptr<FormType> form,
      NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexIntegratedBC>>>> &
          integrated_bc_map);
 
  inline void ApplyBoundaryLFIntegrators(
      const std::string & test_var_name,
      std::shared_ptr<mfem::ParComplexLinearForm> form,
      NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexIntegratedBC>>>> &
          integrated_bc_map);
 
  bool IsComplex() const override { return true; }
 
protected:
  // Complex Linear and Bilinear Forms
  NamedFieldsMap<mfem::ParSesquilinearForm> _slfs;
  NamedFieldsMap<mfem::ParComplexLinearForm> _clfs;
 
  // Complex kernels and integrated BCs
  NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexKernel>>>>
      _cmplx_kernels_map;
  NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexIntegratedBC>>>>
      _cmplx_integrated_bc_map;
 
  // Complex essential BCs
  NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexEssentialBC>>> _cmplx_essential_bc_map;
 
  ComplexGridFunctions _cmplx_eliminated_variables;
 
  std::vector<std::unique_ptr<mfem::ParComplexGridFunction>> _cmplx_var_ess_constraints;
 
  // Pointer to complex GridFunctions to enable updates during nonlinear iterations
  Moose::MFEM::ComplexGridFunctions * _complex_gfuncs;
};
 
template <class FormType>
void
ComplexEquationSystem::ApplyDomainBLFIntegrators(
    const std::string & trial_var_name,
    const std::string & test_var_name,
    std::shared_ptr<FormType> form,
    NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexKernel>>>> & kernels_map)
{
  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_real = kernel->getRealBFIntegrator();
      mfem::BilinearFormIntegrator * integ_imag = kernel->getImagBFIntegrator();
 
      if (integ_real || integ_imag)
      {
        kernel->isSubdomainRestricted()
            ? form->AddDomainIntegrator(
                  std::move(integ_real), std::move(integ_imag), kernel->getSubdomainMarkers())
            : form->AddDomainIntegrator(std::move(integ_real), std::move(integ_imag));
      }
    }
  }
}
 
inline void
ComplexEquationSystem::ApplyDomainLFIntegrators(
    const std::string & test_var_name,
    std::shared_ptr<mfem::ParComplexLinearForm> form,
    NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexKernel>>>> & kernels_map)
{
  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_real = kernel->getRealLFIntegrator();
      mfem::LinearFormIntegrator * integ_imag = kernel->getImagLFIntegrator();
 
      if (integ_real || integ_imag)
      {
        kernel->isSubdomainRestricted()
            ? form->AddDomainIntegrator(
                  std::move(integ_real), std::move(integ_imag), kernel->getSubdomainMarkers())
            : form->AddDomainIntegrator(std::move(integ_real), std::move(integ_imag));
      }
    }
  }
}
 
template <class FormType>
void
ComplexEquationSystem::ApplyBoundaryBLFIntegrators(
    const std::string & trial_var_name,
    const std::string & test_var_name,
    std::shared_ptr<FormType> form,
    NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexIntegratedBC>>>> &
        integrated_bc_map)
{
  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_real = bc->getRealBFIntegrator();
      mfem::BilinearFormIntegrator * integ_imag = bc->getImagBFIntegrator();
 
      if (integ_real || integ_imag)
      {
        bc->isBoundaryRestricted()
            ? form->AddBoundaryIntegrator(
                  std::move(integ_real), std::move(integ_imag), bc->getBoundaryMarkers())
            : form->AddBoundaryIntegrator(std::move(integ_real), std::move(integ_imag));
      }
    }
  }
}
 
inline void
ComplexEquationSystem::ApplyBoundaryLFIntegrators(
    const std::string & test_var_name,
    std::shared_ptr<mfem::ParComplexLinearForm> form,
    NamedFieldsMap<NamedFieldsMap<std::vector<std::shared_ptr<MFEMComplexIntegratedBC>>>> &
        integrated_bc_map)
{
  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_real = bc->getRealLFIntegrator();
      mfem::LinearFormIntegrator * integ_imag = bc->getImagLFIntegrator();
 
      if (integ_real || integ_imag)
      {
        bc->isBoundaryRestricted()
            ? form->AddBoundaryIntegrator(
                  std::move(integ_real), std::move(integ_imag), bc->getBoundaryMarkers())
            : form->AddBoundaryIntegrator(std::move(integ_real), std::move(integ_imag));
      }
    }
  }
}
 
}
 
#endif