MFEMLORLinearSolverBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#ifdef MOOSE_MFEM_ENABLED
 
#pragma once
 
#include "MFEMLinearSolverBase.h"
 
namespace Moose::MFEM
{
template <class MFEMSolverType>
class LORLinearSolverBase : public LinearSolverBase
{
public:
  static InputParameters validParams();
 
  LORLinearSolverBase(const InputParameters & parameters);
 
protected:
  virtual void SetSolverParameters(MFEMSolverType & solver) = 0;
 
  virtual void UpdateEquationSystemContext() override;
 
  bool _lor;
  mfem::ParBilinearForm * _a;
  mfem::Array<int> _ess_bdr_markers;
  mfem::Array<int> _ess_tdofs;
 
private:
  void SetLORSolver();
 
  virtual void CheckSpectralEquivalence(mfem::ParBilinearForm & blf) const;
 
  virtual void SetupLOR();
};
 
template <class MFEMSolverType>
InputParameters
LORLinearSolverBase<MFEMSolverType>::validParams()
{
  InputParameters params = LinearSolverBase::validParams();
  params.addParam<bool>("low_order_refined", false, "Set usage of Low-Order Refined solver.");
  return params;
}
 
template <class MFEMSolverType>
LORLinearSolverBase<MFEMSolverType>::LORLinearSolverBase(const InputParameters & parameters)
  : LinearSolverBase(parameters), _lor(parameters.get<bool>("low_order_refined"))
{
}
 
template <typename T, typename... Ts>
constexpr bool is_any_of_v = (std::is_same_v<T, Ts> || ...);
 
template <class MFEMSolverType>
void
LORLinearSolverBase<MFEMSolverType>::CheckSpectralEquivalence(mfem::ParBilinearForm & blf) const
{
  if (auto fec = dynamic_cast<const mfem::H1_FECollection *>(blf.FESpace()->FEColl()))
  {
    if (fec->GetBasisType() != mfem::BasisType::GaussLobatto)
      mooseError("Low-Order-Refined solver requires the FESpace basis to be GaussLobatto "
                 "for H1 elements.");
  }
  else if (auto fec = dynamic_cast<const mfem::ND_FECollection *>(blf.FESpace()->FEColl()))
  {
    if (fec->GetClosedBasisType() != mfem::BasisType::GaussLobatto ||
        fec->GetOpenBasisType() != mfem::BasisType::IntegratedGLL)
      mooseError("Low-Order-Refined solver requires the FESpace closed-basis to be GaussLobatto "
                 "and the open-basis to be IntegratedGLL for ND elements.");
  }
  else if (auto fec = dynamic_cast<const mfem::RT_FECollection *>(blf.FESpace()->FEColl()))
  {
    if (fec->GetClosedBasisType() != mfem::BasisType::GaussLobatto ||
        fec->GetOpenBasisType() != mfem::BasisType::IntegratedGLL)
      mooseError("Low-Order-Refined solver requires the FESpace closed-basis to be GaussLobatto "
                 "and the open-basis to be IntegratedGLL for RT elements.");
  }
}
 
template <class MFEMSolverType>
void
LORLinearSolverBase<MFEMSolverType>::UpdateEquationSystemContext()
{
  if (!_lor)
    return;
 
  if (isParamSetByUser("preconditioner"))
    paramError("preconditioner", "LOR solver cannot take a preconditioner");
 
  SetupLOR();
 
  if constexpr (is_any_of_v<MFEMSolverType, mfem::HypreAMS, mfem::HypreADS>)
    if (_a->ParFESpace()->GetMesh()->GetTypicalElementGeometry() != mfem::Geometry::Type::CUBE)
      mooseError("LOR HypreAMS/ADS Solver only supports hex meshes.");
 
  SetLORSolver();
}
 
template <class MFEMSolverType>
void
LORLinearSolverBase<MFEMSolverType>::SetupLOR()
{
  if (!_equation_system)
    mooseError("LOR solver setup requires an EquationSystem to be defined.");
  if (_equation_system->IsComplex())
    mooseError("LOR solve is not supported for complex equation systems.");
  if (_equation_system->IsMultivariate())
    mooseError("LOR solve is only supported for single-variable systems");
 
  const auto & test_var_name = _equation_system->GetTestVarNames().at(0);
  _a = &_equation_system->GetBilinearForm(test_var_name);
  CheckSpectralEquivalence(*_a);
  _ess_bdr_markers = _equation_system->GetEssentialBoundaryMarkers(test_var_name);
  _a->ParFESpace()->GetEssentialTrueDofs(_ess_bdr_markers, _ess_tdofs);
}
 
template <class MFEMSolverType>
void
LORLinearSolverBase<MFEMSolverType>::SetLORSolver()
{
  mfem::LORSolver<MFEMSolverType> * lor_solver;
  if constexpr (is_any_of_v<MFEMSolverType, mfem::HypreGMRES, mfem::HypreFGMRES, mfem::HyprePCG>)
  {
    mfem::ParLORDiscretization lor_disc(*_a, _ess_tdofs);
    lor_solver = new mfem::LORSolver<MFEMSolverType>(lor_disc, _a->ParFESpace()->GetComm());
  }
  else
    lor_solver = new mfem::LORSolver<MFEMSolverType>(*_a, _ess_tdofs);
  SetSolverParameters(lor_solver->GetSolver());
  SetSolver(lor_solver);
}
 
} // namespace Moose::MFEM
 
#endif