Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #ifdef MOOSE_MFEM_ENABLED
      11             : 
      12             : #include "MFEMTransient.h"
      13             : #include "MFEMProblem.h"
      14             : #include "TimeDomainEquationSystemProblemOperator.h"
      15             : #include "TimeStepper.h"
      16             : 
      17             : registerMooseObject("MooseApp", MFEMTransient);
      18             : 
      19             : InputParameters
      20        9336 : MFEMTransient::validParams()
      21             : {
      22        9336 :   InputParameters params = MFEMProblemSolve::validParams();
      23        9336 :   params += TransientBase::validParams();
      24        9336 :   params.addClassDescription("Executioner for transient MFEM problems.");
      25        9336 :   return params;
      26           0 : }
      27             : 
      28         113 : MFEMTransient::MFEMTransient(const InputParameters & params)
      29             :   : TransientBase(params),
      30         113 :     _mfem_problem(dynamic_cast<MFEMProblem &>(feProblem())),
      31         113 :     _mfem_problem_data(_mfem_problem.getProblemData()),
      32         226 :     _mfem_problem_solve(*this, getProblemOperators())
      33             : {
      34             :   // If no ProblemOperators have been added by the user, add a default
      35         113 :   if (getProblemOperators().empty())
      36             :   {
      37         113 :     _mfem_problem_data.eqn_system = std::make_shared<Moose::MFEM::TimeDependentEquationSystem>();
      38             :     auto problem_operator =
      39         113 :         std::make_shared<Moose::MFEM::TimeDomainEquationSystemProblemOperator>(_mfem_problem);
      40         113 :     addProblemOperator(std::move(problem_operator));
      41         113 :   }
      42         113 : }
      43             : 
      44             : void
      45         113 : MFEMTransient::init()
      46             : {
      47         113 :   TransientBase::init();
      48             : 
      49             :   // Set up initial conditions
      50         113 :   _mfem_problem_data.eqn_system->Init(
      51         113 :       _mfem_problem_data.gridfunctions,
      52         113 :       _mfem_problem_data.fespaces,
      53         339 :       getParam<MooseEnum>("assembly_level").getEnum<mfem::AssemblyLevel>());
      54             : 
      55         226 :   for (const auto & problem_operator : getProblemOperators())
      56             :   {
      57         113 :     problem_operator->SetGridFunctions();
      58         113 :     problem_operator->Init(_mfem_problem_data.f);
      59             :   }
      60         113 : }
      61             : 
      62             : void
      63         641 : MFEMTransient::takeStep(Real input_dt)
      64             : {
      65         641 :   _dt_old = _dt;
      66             : 
      67         641 :   if (input_dt == -1.0)
      68         578 :     _dt = computeConstrainedDT();
      69             :   else
      70          63 :     _dt = input_dt;
      71             : 
      72         641 :   _time_stepper->preSolve();
      73             : 
      74             :   // Unfortunately, time needs to be temporarily incremented so we get
      75             :   // meaningful console output in timestepSetup(). We decrement it back
      76             :   // immediately after so step() below behaves as expected.
      77         641 :   _time += _dt;
      78         641 :   _problem.timestepSetup();
      79         641 :   _time -= _dt;
      80             : 
      81         641 :   _problem.onTimestepBegin();
      82             : 
      83             :   // Advance time step of the MFEM problem. Time is also updated here, and
      84             :   // _problem_operator->SetTime is called inside the ode_solver->Step method to
      85             :   // update the time used by time dependent (function) coefficients.
      86         641 :   _time_stepper->step();
      87             : 
      88             :   // Continue with usual TransientBase::takeStep() finalisation
      89         641 :   _last_solve_converged = _time_stepper->converged();
      90             : 
      91         641 :   if (!lastSolveConverged())
      92             :   {
      93           0 :     _console << "Aborting as solve did not converge" << std::endl;
      94           0 :     return;
      95             :   }
      96             : 
      97         641 :   if (lastSolveConverged())
      98         641 :     _time_stepper->acceptStep();
      99             :   else
     100           0 :     _time_stepper->rejectStep();
     101             : 
     102             :   // Set time to time old, since final time is updated in TransientBase::endStep()
     103         641 :   _time = _time_old;
     104             : 
     105         641 :   _time_stepper->postSolve();
     106             : }
     107             : 
     108             : #endif