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 "MFEMSteady.h"
      13             : #include "MFEMProblem.h"
      14             : #include "EquationSystemProblemOperator.h"
      15             : 
      16             : registerMooseObject("MooseApp", MFEMSteady);
      17             : 
      18             : InputParameters
      19        9868 : MFEMSteady::validParams()
      20             : {
      21        9868 :   InputParameters params = MFEMProblemSolve::validParams();
      22        9868 :   params += Executioner::validParams();
      23       19736 :   params.addClassDescription("Executioner for steady state MFEM problems.");
      24       29604 :   params.addParam<Real>("time", 0.0, "System time");
      25        9868 :   return params;
      26           0 : }
      27             : 
      28         258 : MFEMSteady::MFEMSteady(const InputParameters & params)
      29             :   : Executioner(params),
      30         258 :     _mfem_problem(dynamic_cast<MFEMProblem &>(feProblem())),
      31         258 :     _mfem_problem_data(_mfem_problem.getProblemData()),
      32         258 :     _mfem_problem_solve(*this, getProblemOperators()),
      33         516 :     _system_time(getParam<Real>("time")),
      34         258 :     _time_step(_mfem_problem.timeStep()),
      35         516 :     _time([this]() -> Real & { return this->_mfem_problem.time() = this->_system_time; }()),
      36         258 :     _last_solve_converged(false)
      37             : {
      38             :   // If no ProblemOperators have been added by the user, add a default
      39         258 :   if (getProblemOperators().empty())
      40             :   {
      41         258 :     _mfem_problem_data.eqn_system = std::make_shared<Moose::MFEM::EquationSystem>();
      42             :     auto problem_operator =
      43         258 :         std::make_shared<Moose::MFEM::EquationSystemProblemOperator>(_mfem_problem);
      44         258 :     addProblemOperator(std::move(problem_operator));
      45         258 :   }
      46         258 : }
      47             : 
      48             : void
      49         258 : MFEMSteady::init()
      50             : {
      51         258 :   _mfem_problem.execute(EXEC_PRE_MULTIAPP_SETUP);
      52         258 :   _mfem_problem.initialSetup();
      53             : 
      54             :   // Set up initial conditions
      55         258 :   _mfem_problem_data.eqn_system->Init(
      56         258 :       _mfem_problem_data.gridfunctions,
      57         774 :       getParam<MooseEnum>("assembly_level").getEnum<mfem::AssemblyLevel>());
      58             : 
      59         516 :   for (const auto & problem_operator : getProblemOperators())
      60             :   {
      61         258 :     problem_operator->SetGridFunctions();
      62         258 :     problem_operator->Init(_mfem_problem_data.f);
      63             :   }
      64         258 : }
      65             : 
      66             : void
      67         258 : MFEMSteady::execute()
      68             : {
      69         258 :   if (_app.isRecovering())
      70             :   {
      71           0 :     _console << "\nCannot recover steady solves!\nExiting...\n" << std::endl;
      72           0 :     return;
      73             :   }
      74             : 
      75         258 :   _time_step = 0;
      76         258 :   _time = _time_step;
      77         258 :   _mfem_problem.outputStep(EXEC_INITIAL);
      78         258 :   _time = _system_time;
      79             : 
      80         258 :   preExecute();
      81             : 
      82         258 :   _mfem_problem.advanceState();
      83             : 
      84             :   // first step in any steady state solve is always 1 (preserving backwards compatibility)
      85         258 :   _time_step = 1;
      86         258 :   _mfem_problem.timestepSetup();
      87             : 
      88         258 :   _last_solve_converged = _mfem_problem_solve.solve();
      89             : 
      90         258 :   _mfem_problem.computeIndicators();
      91         258 :   _mfem_problem.computeMarkers();
      92             : 
      93             :   // need to keep _time in sync with _time_step to get correct output
      94         258 :   _time = _time_step;
      95         258 :   _mfem_problem.outputStep(EXEC_TIMESTEP_END);
      96         258 :   _time = _system_time;
      97             : 
      98             :   {
      99        1290 :     TIME_SECTION("final", 1, "Executing Final Objects")
     100         258 :     _mfem_problem.execMultiApps(EXEC_FINAL);
     101         258 :     _mfem_problem.finalizeMultiApps();
     102         258 :     _mfem_problem.postExecute();
     103         258 :     _mfem_problem.execute(EXEC_FINAL);
     104         258 :     _time = _time_step;
     105         258 :     _mfem_problem.outputStep(EXEC_FINAL);
     106         258 :     _time = _system_time;
     107         258 :   }
     108             : 
     109         258 :   postExecute();
     110             : }
     111             : 
     112             : #endif