MFEMTransient.C

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

#include "MFEMTransient.h"
#include "MFEMProblem.h"
#include "TimeDependentEquationSystemProblemOperator.h"
#include "TimeStepper.h"

registerMooseObject("MooseApp", MFEMTransient);

InputParameters
MFEMTransient::validParams()
{
  InputParameters params = MFEMProblemSolve::validParams();
  params += TransientBase::validParams();
  params.addClassDescription("Executioner for transient MFEM problems.");
  return params;
}

MFEMTransient::MFEMTransient(const InputParameters & params)
  : TransientBase(params),
    _mfem_problem(dynamic_cast<MFEMProblem &>(feProblem())),
    _mfem_problem_data(_mfem_problem.getProblemData()),
    _mfem_problem_solve(*this, getProblemOperators())
{
  // If no ProblemOperators have been added by the user, add a default
  if (getProblemOperators().empty())
  {
    _mfem_problem_data.eqn_system = std::make_shared<Moose::MFEM::TimeDependentEquationSystem>(
        _mfem_problem_data.time_derivative_map);
    auto problem_operator =
        std::make_shared<Moose::MFEM::TimeDependentEquationSystemProblemOperator>(_mfem_problem);
    addProblemOperator(std::move(problem_operator));
  }
}

void
MFEMTransient::init()
{
  TransientBase::init();

  // verify that the requested time integration scheme is actually supported by MFEM transient
  if (getTimeScheme() != Moose::TimeIntegratorType::TI_IMPLICIT_EULER)
    paramError("scheme",
               "Time Integration scheme \"" + stringify(getTimeScheme()) +
                   "\" is not supported by MFEMTransient Executioner.");

  if (_mfem_problem_data.nonlinear_solver)
    _mfem_problem_data.eqn_system->SetSolverRequiresGradient(
        _mfem_problem_data.nonlinear_solver->RequiresGradient());

  // Set up initial conditions
  _mfem_problem_data.eqn_system->Init(
      _mfem_problem_data.gridfunctions,
      _mfem_problem_data.cmplx_gridfunctions,
      getParam<MooseEnum>("assembly_level").getEnum<mfem::AssemblyLevel>());

  for (const auto & problem_operator : getProblemOperators())
  {
    problem_operator->SetGridFunctions();
    problem_operator->Init(_mfem_problem_data.f);
  }
}

void
MFEMTransient::takeStep(Real input_dt)
{
  _dt_old = _dt;

  if (input_dt == -1.0)
    _dt = computeConstrainedDT();
  else
    _dt = input_dt;

  _time_stepper->preSolve();

  // Unfortunately, time needs to be temporarily incremented so we get
  // meaningful console output in timestepSetup(). We decrement it back
  // immediately after so step() below behaves as expected.
  _time += _dt;
  _problem.timestepSetup();
  _time -= _dt;

  _problem.onTimestepBegin();
  _problem.execTransfers(EXEC_TIMESTEP_BEGIN);
  if (!_problem.execMultiApps(EXEC_TIMESTEP_BEGIN, true))
  {
    _last_solve_converged = false;
    return;
  }
  _problem.execute(EXEC_TIMESTEP_BEGIN);

  // Advance time step of the MFEM problem. Time is also updated here, and
  // _problem_operator->SetTime is called inside the ode_solver->Step method to
  // update the time used by time dependent (function) coefficients.
  _time_stepper->step();

  // Continue with usual TransientBase::takeStep() finalisation
  _last_solve_converged = _time_stepper->converged();

  if (!lastSolveConverged())
  {
    _console << "Aborting as solve did not converge" << std::endl;
    return;
  }

  _problem.execute(EXEC_TIMESTEP_END);
  _problem.execTransfers(EXEC_TIMESTEP_END);
  _problem.execMultiApps(EXEC_TIMESTEP_END, true);

  if (lastSolveConverged())
    _time_stepper->acceptStep();
  else
    _time_stepper->rejectStep();

  // Set time to time old, since final time is updated in TransientBase::endStep()
  _time = _time_old;

  _time_stepper->postSolve();
}

#endif