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             : #include "LevelSetReinitializationMultiApp.h"
      11             : #include "LevelSetReinitializationProblem.h"
      12             : 
      13             : #include "Executioner.h"
      14             : 
      15             : // libMesh
      16             : #include "libmesh/mesh_tools.h"
      17             : 
      18             : registerMooseObject("LevelSetApp", LevelSetReinitializationMultiApp);
      19             : 
      20             : InputParameters
      21          94 : LevelSetReinitializationMultiApp::validParams()
      22             : {
      23          94 :   InputParameters params = MultiApp::validParams();
      24          94 :   params.addClassDescription(
      25             :       "MultiApp capable of performing repeated complete solves for level set reinitialization.");
      26         188 :   params.addParam<unsigned int>(
      27         188 :       "interval", 1, "Time step interval when to perform reinitialization.");
      28             : 
      29          94 :   params.suppressParameter<std::vector<Point>>("positions");
      30          94 :   params.suppressParameter<std::vector<FileName>>("positions_file");
      31          94 :   params.suppressParameter<bool>("output_in_position");
      32          94 :   params.suppressParameter<std::vector<Real>>("reset_time");
      33          94 :   params.suppressParameter<std::vector<unsigned int>>("reset_apps");
      34          94 :   params.suppressParameter<Real>("move_time");
      35          94 :   params.suppressParameter<std::vector<unsigned int>>("move_apps");
      36          94 :   params.suppressParameter<std::vector<Point>>("move_positions");
      37             : 
      38          94 :   return params;
      39           0 : }
      40             : 
      41          47 : LevelSetReinitializationMultiApp::LevelSetReinitializationMultiApp(
      42          47 :     const InputParameters & parameters)
      43          94 :   : MultiApp(parameters), _level_set_problem(NULL), _interval(getParam<unsigned int>("interval"))
      44             : {
      45          47 : }
      46             : 
      47             : void
      48          45 : LevelSetReinitializationMultiApp::initialSetup()
      49             : {
      50          45 :   MultiApp::initialSetup();
      51             : 
      52          45 :   if (_has_an_app)
      53             :   {
      54          45 :     Executioner * ex = _apps[0]->getExecutioner();
      55             : 
      56          45 :     if (!ex)
      57           0 :       mooseError("Executioner does not exist!");
      58             : 
      59          45 :     ex->init();
      60             : 
      61          45 :     _executioner = ex;
      62             : 
      63          45 :     _level_set_problem = dynamic_cast<LevelSetReinitializationProblem *>(&appProblemBase(0));
      64          45 :     if (!_level_set_problem)
      65           0 :       mooseError("The Problem type must be LevelSetReinitializationProblem.");
      66             :   }
      67          45 : }
      68             : 
      69             : bool
      70          86 : LevelSetReinitializationMultiApp::solveStep(Real /*dt*/,
      71             :                                             Real /*target_time*/,
      72             :                                             bool /*auto_advance*/)
      73             : {
      74             :   // Do nothing if not on interval
      75          86 :   if ((_fe_problem.timeStep() % _interval) != 0)
      76             :     return true;
      77             : 
      78          86 :   if (!_has_an_app)
      79             :     return true;
      80             : 
      81          86 :   _console << "Solving Reinitialization problem." << std::endl;
      82             : 
      83             :   int rank;
      84             :   int ierr;
      85          86 :   ierr = MPI_Comm_rank(_orig_comm, &rank);
      86          86 :   mooseCheckMPIErr(ierr);
      87             : 
      88             :   bool last_solve_converged = true;
      89             : 
      90          86 :   _level_set_problem->resetTime();
      91          86 :   _executioner->execute();
      92          86 :   if (!_executioner->lastSolveConverged())
      93             :     last_solve_converged = false;
      94             : 
      95             :   return last_solve_converged;
      96             : }