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 MFEM_ENABLED

#pragma once
#include "ExternalProblem.h"
#include "MFEMProblemData.h"
#include "MFEMMesh.h"
#include "MFEMExecutioner.h"

class MFEMProblem : public ExternalProblem
{
public:
  static InputParameters validParams();

  MFEMProblem(const InputParameters & params);
  virtual ~MFEMProblem() {}

  virtual void initialSetup() override;
  virtual void externalSolve() override {}
  virtual bool nlConverged(const unsigned int) override { return true; }
  virtual void syncSolutions(Direction) override {}

  virtual MFEMMesh & mesh() override;
  virtual const MFEMMesh & mesh() const override;
  using ExternalProblem::mesh;

  virtual std::vector<VariableName> getAuxVariableNames();

  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 & user_object_name,
                  const std::string & name,
                  InputParameters & parameters);
  void setDevice();

  void setMesh();

  void initProblemOperator();

  void addSubMesh(const std::string & user_object_name,
                  const std::string & name,
                  InputParameters & parameters);

  void addTransfer(const std::string & transfer_name,
                   const std::string & name,
                   InputParameters & parameters) override;
  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 addKernel(const std::string & kernel_name,
                 const std::string & name,
                 InputParameters & parameters) override;

  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 addMFEMPreconditioner(const std::string & user_object_name,
                             const std::string & name,
                             InputParameters & parameters);

  void addMFEMSolver(const std::string & user_object_name,
                     const std::string & name,
                     InputParameters & parameters);

  void addMFEMNonlinearSolver();

  InputParameters addMFEMFESpaceFromMOOSEVariable(InputParameters & moosevar_params);

  Moose::MFEM::CoefficientManager & getCoefficients() { return _problem_data.coefficients; }

  MFEMProblemData & getProblemData() { return _problem_data; }

  void displaceMesh();

  std::optional<std::reference_wrapper<mfem::ParGridFunction const>>
  getMeshDisplacementGridFunction();

  Moose::FEBackend feBackend() const override { return Moose::FEBackend::MFEM; }

  std::string solverTypeString(unsigned int solver_sys_num) override;

  std::shared_ptr<mfem::ParGridFunction> getGridFunction(const std::string & name);

protected:
  MFEMProblemData _problem_data;
};

#endif