MFEMProblem.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 "Attributes.h"
#include "ExternalProblem.h"
#include "MFEMProblemData.h"
#include "MFEMWeakFormBase.h"
#include "MFEMMesh.h"
#include "MFEMRefinementMarker.h"
#include "MFEMComplexVariable.h"
#include "MFEMProblemComposer.h"
#include "ProblemOperatorBase.h"
 
#include <map>
 
namespace Moose::MFEM
{
struct SolutionState;
}
 
class MFEMProblem : public ExternalProblem
{
public:
  static InputParameters validParams();
 
  MFEMProblem(const InputParameters & params);
 
  virtual ~MFEMProblem() {}
 
  virtual void initialSetup() override;
  virtual void execute(const ExecFlagType & exec_type) override;
  virtual void externalSolve() override {}
  virtual void syncSolutions(Direction) override {}
 
  virtual MFEMMesh & mesh() override;
  virtual const MFEMMesh & mesh() const override;
  using ExternalProblem::mesh;
 
  virtual std::vector<VariableName> getAuxVariableNames();
 
  template <typename T>
  std::vector<std::shared_ptr<T>>
  addObject(const std::string & type, const std::string & name, InputParameters & parameters)
  {
    return ExternalProblem::addObject<T>(type, name, parameters, /*threaded=*/false);
  }
 
  void addBoundaryCondition(const std::string & bc_name,
                            const std::string & name,
                            InputParameters & parameters) override;
 
  void addMaterial(const std::string & material_name,
                   const std::string & name,
                   InputParameters & parameters) override;
 
  void addFunctorMaterial(const std::string & material_name,
                          const std::string & name,
                          InputParameters & parameters) override;
 
  void addFESpace(const std::string & type, const std::string & name, InputParameters & parameters);
 
  void addFESpaceHierarchy(const std::string & type,
                           const std::string & name,
                           InputParameters & parameters);
 
  void setMesh();
 
  void addSubMesh(const std::string & type, const std::string & name, InputParameters & parameters);
 
  void addTransfer(const std::string & transfer_name,
                   const std::string & name,
                   InputParameters & parameters) override;
  virtual void addVariable(const std::string & var_type,
                           const std::string & var_name,
                           InputParameters & parameters) override;
 
  void addGridFunction(const std::string & var_type,
                       const std::string & var_name,
                       InputParameters & parameters);
 
  using ExternalProblem::addAuxVariable;
  void addAuxVariable(const std::string & var_type,
                      const std::string & var_name,
                      InputParameters & parameters) override;
 
  void
  addElementalFieldVariable(const std::string &, const std::string &, InputParameters &) override
  {
  }
 
  void addKernel(const std::string & kernel_name,
                 const std::string & name,
                 InputParameters & parameters) override;
 
  void addRealComponentToKernel(const std::string & kernel_name,
                                const std::string & name,
                                InputParameters & parameters);
 
  void addImagComponentToKernel(const std::string & kernel_name,
                                const std::string & name,
                                InputParameters & parameters);
 
  void addRealComponentToBC(const std::string & kernel_name,
                            const std::string & name,
                            InputParameters & parameters);
 
  void addImagComponentToBC(const std::string & kernel_name,
                            const std::string & name,
                            InputParameters & parameters);
 
  void addWeakForm(const std::string & weak_form_name,
                   const std::string & name,
                   InputParameters & parameters);
 
  virtual std::shared_ptr<MFEMWeakFormBase> addDefaultWeakForm();
 
  void setEquationSystems();
 
  std::shared_ptr<Moose::MFEM::EquationSystem>
  getEquationSystem(const std::string & weak_form_name = "") const;
 
  void addProblemComposer(const std::string & composer_type,
                          const std::string & name,
                          InputParameters & parameters);
 
  virtual std::shared_ptr<MFEMProblemComposer> addDefaultProblemComposer();
 
  void setProblemOperators();
 
  std::vector<std::shared_ptr<Moose::MFEM::ProblemOperatorBase>> & getProblemOperators();
 
  void addAuxKernel(const std::string & kernel_name,
                    const std::string & name,
                    InputParameters & parameters) override;
 
  void addFunction(const std::string & type,
                   const std::string & name,
                   InputParameters & parameters) override;
 
  void addInitialCondition(const std::string & ic_name,
                           const std::string & name,
                           InputParameters & parameters) override;
 
  void addPostprocessor(const std::string & type,
                        const std::string & name,
                        InputParameters & parameters) override;
 
  void addVectorPostprocessor(const std::string & type,
                              const std::string & name,
                              InputParameters & parameters) override;
 
  void addIndicator(const std::string & type,
                    const std::string & name,
                    InputParameters & parameters) override;
 
  void addMarker(const std::string & type,
                 const std::string & name,
                 InputParameters & parameters) override;
 
  virtual void addMFEMSolver(const std::string & user_object_name,
                             const std::string & name,
                             InputParameters & parameters);
 
  virtual void resolveMFEMSolvers();
 
  void executeMFEMObjects(const ExecFlagType & exec_type);
 
  InputParameters addMFEMFESpaceFromMOOSEVariable(InputParameters & moosevar_params);
 
  Moose::MFEM::CoefficientManager & getCoefficients() { return _problem_data.coefficients; }
 
  MFEMProblemData & getProblemData() { return _problem_data; }
 
  const MFEMProblemData & getProblemData() const { return _problem_data; }
 
  MPI_Comm getComm() { return getProblemData().comm; }
 
  const mfem::ParMesh & getMFEMVariableMesh(std::string var_name)
  {
    if (_problem_data.gridfunctions.Has(var_name))
      return *_problem_data.gridfunctions.Get(var_name)->ParFESpace()->GetParMesh();
    else if (_problem_data.cmplx_gridfunctions.Has(var_name))
      return *_problem_data.cmplx_gridfunctions.Get(var_name)->ParFESpace()->GetParMesh();
    else
      mooseError("Variable " + var_name +
                 " not found in MFEMProblem real or complex gridfunctions.");
  }
 
  void displaceMesh();
 
  void rebalanceMesh(mfem::ParMesh & pmesh);
 
  const mfem::ParGridFunction & getMeshDisplacementGridFunction();
 
  Moose::FEBackend feBackend() const override { return Moose::FEBackend::MFEM; }
 
  std::string solverTypeString(unsigned int solver_sys_num) override;
 
  void updateFESpaces();
 
  void updateGridFunctions();
 
  bool hRefine() { return _problem_data.refiner && _problem_data.refiner->hRefine(); }
 
  bool pRefine() { return _problem_data.refiner && _problem_data.refiner->pRefine(); }
 
  std::shared_ptr<mfem::ParGridFunction> getGridFunction(const std::string & name)
  {
    return _problem_data.gridfunctions.GetShared(name);
  }
 
  std::shared_ptr<mfem::ParComplexGridFunction> getComplexGridFunction(const std::string & name)
  {
    return _problem_data.cmplx_gridfunctions.GetShared(name);
  }
 
  enum class NumericType
  {
    REAL,
    COMPLEX
  };
 
  NumericType getNumericType() const { return _num_type; }
 
  template <typename T>
  T & getMFEMObject(const std::string & system,
                    const std::string & name,
                    const THREAD_ID tid = 0) const;
 
  bool hasMFEMObject(const std::string & system, const std::string & name) const;
 
  mfem::AssemblyLevel assemblyLevel() const { return _assembly_level; }
 
  void setAssemblyLevel(mfem::AssemblyLevel assembly_level) { _assembly_level = assembly_level; }
 
protected:
  void validateVariableNumericType(const std::string & var_type,
                                   const std::string & var_name) const;
 
  struct MFEMSolverDefinition
  {
    std::string type;
    InputParameters * parameters;
    bool referenced = false;
  };
 
  MFEMProblemData _problem_data;
 
  NumericType _num_type;
 
  std::map<std::string, MFEMSolverDefinition> _mfem_solver_definitions;
 
  Moose::MFEM::SolutionState & _solution_state_data;
 
  std::shared_ptr<MFEMProblemComposer> _problem_composer;
  std::vector<std::shared_ptr<Moose::MFEM::ProblemOperatorBase>> _problem_operators;
 
  mfem::AssemblyLevel _assembly_level{mfem::AssemblyLevel::LEGACY};
};
 
template <typename T>
T &
MFEMProblem::getMFEMObject(const std::string & system,
                           const std::string & name,
                           const THREAD_ID tid) const
{
  std::vector<T *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>(system)
      .condition<AttribThread>(tid)
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
    mooseError("Unable to find MFEM object with system '" + system + "' and name '" + name + "'");
  mooseAssert(objs.size() == 1, "Shouldn't find more than one object with given system and name");
  return *(objs[0]);
}
 
#endif