SetupMeshCompleteAction.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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

#include "SetupMeshCompleteAction.h"
#include "MooseMesh.h"
#include "Moose.h"
#include "Adaptivity.h"
#include "MooseApp.h"

registerMooseAction("MooseApp", SetupMeshCompleteAction, "prepare_mesh");

registerMooseAction("MooseApp",
                    SetupMeshCompleteAction,
                    "delete_remote_elements_post_equation_systems_init");

registerMooseAction("MooseApp", SetupMeshCompleteAction, "execute_mesh_modifiers");

registerMooseAction("MooseApp", SetupMeshCompleteAction, "uniform_refine_mesh");

registerMooseAction("MooseApp", SetupMeshCompleteAction, "setup_mesh_complete");

template <>
InputParameters
validParams<SetupMeshCompleteAction>()
{
  InputParameters params = validParams<Action>();
  return params;
}

SetupMeshCompleteAction::SetupMeshCompleteAction(InputParameters params)
  : Action(params), _uniform_refine_timer(registerTimedSection("uniformRefine", 2))
{
}

bool
SetupMeshCompleteAction::completeSetup(MooseMesh * mesh)
{
  bool prepared = mesh->prepared();

  if (!prepared)
    mesh->prepare();

  // Clear the modifiers, they are not used again during the simulation after the mesh has been
  // completed
  _app.clearMeshModifiers();

  return prepared;
}

void
SetupMeshCompleteAction::act()
{
  if (!_mesh)
    mooseError("No mesh file was supplied and no generation block was provided");

  if (_current_task == "execute_mesh_modifiers")
  {
    // we don't need to run mesh modifiers *again* after they ran already during the mesh
    // splitting process
    if (_app.isUseSplit())
      return;
    _app.executeMeshModifiers();
  }
  else if (_current_task == "uniform_refine_mesh")
  {
    // we don't need to run mesh modifiers *again* after they ran already during the mesh
    // splitting process
    if (_app.isUseSplit())
      return;

    if (_app.setFileRestart() == false && _app.isRecovering() == false)
    {
      if (_mesh->uniformRefineLevel())
      {
        TIME_SECTION(_uniform_refine_timer);

        Adaptivity::uniformRefine(_mesh.get());

        if (_displaced_mesh)
          Adaptivity::uniformRefine(_displaced_mesh.get());
      }
    }
  }
  else if (_current_task == "delete_remote_elements_post_equation_systems_init")
  {
    if (_mesh->needsRemoteElemDeletion())
    {
      _mesh->getMesh().delete_remote_elements();
      if (_displaced_mesh)
        _displaced_mesh->getMesh().delete_remote_elements();
    }
  }
  else
  {
    // Prepare the mesh (may occur multiple times)
    completeSetup(_mesh.get());

    if (_displaced_mesh)
      completeSetup(_displaced_mesh.get());
  }
}