SetupMeshCompleteAction.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
 
#include "SetupMeshCompleteAction.h"
#include "MooseMesh.h"
#include "Moose.h"
#include "Adaptivity.h"
#include "MooseApp.h"
#include "FEProblemBase.h"
 
#include "libmesh/periodic_boundaries.h"
 
registerMooseAction("MooseApp", SetupMeshCompleteAction, "prepare_mesh");
 
registerMooseAction("MooseApp",
                    SetupMeshCompleteAction,
                    "delete_remote_elements_after_late_geometric_ghosting");
 
registerMooseAction("MooseApp", SetupMeshCompleteAction, "uniform_refine_mesh");
 
registerMooseAction("MooseApp", SetupMeshCompleteAction, "setup_mesh_complete");
 
registerMooseAction("MooseApp", SetupMeshCompleteAction, "post_mesh_prepared");
 
InputParameters
SetupMeshCompleteAction::validParams()
{
  InputParameters params = Action::validParams();
  params.addClassDescription("Perform operations on the mesh in preparation for a simulation.");
 
  params.addParam<std::vector<std::string>>(
      "displacements",
      "The variables corresponding to the x y z displacements of the mesh.  If "
      "this is provided then the displacements will be taken into account during "
      "the computation. Creation of the displaced mesh can be suppressed even if "
      "this is set by setting 'use_displaced_mesh = false'.");
  params.addParam<bool>(
      "use_displaced_mesh",
      true,
      "Create the displaced mesh if the 'displacements' "
      "parameter is set. If this is 'false', a displaced mesh will not be created, "
      "regardless of whether 'displacements' is set.");
 
  return params;
}
 
SetupMeshCompleteAction::SetupMeshCompleteAction(const InputParameters & params) : Action(params) {}
 
void
SetupMeshCompleteAction::act()
{
  if (!_mesh)
    mooseError("No mesh file was supplied and no generation block was provided");
 
  if (_current_task == "uniform_refine_mesh")
  {
    // we don't need to run mesh modifiers *again* after they ran already during the mesh
    // splitting process
    // A uniform refinement is helpful for some instances when using a pre-split mesh.
    // For example, a 'coarse' mesh might completely resolve geometry (also is large)
    // but does not have enough resolution for the interior. For this scenario,
    // we pre-split the coarse mesh, and load the pre-split mesh in parallel,
    // and then do a few levels of uniform refinements to have a fine mesh that
    // potentially resolves physics features.
    if (_mesh->isSplit() && _mesh->skipRefineWhenUseSplit())
      return;
 
    // uniform refinement has been done on master, so skip
    if (_app.useMasterMesh())
      return;
 
    if (_app.getExodusFileRestart() == false)
    {
      if (_app.isRecovering() == false || !_app.isUltimateMaster())
      {
        TIME_SECTION("uniformRefine", 2, "Uniformly Refining");
 
        if (_mesh->uniformRefineLevel())
        {
          if (!_mesh->interiorLowerDBlocks().empty() || !_mesh->boundaryLowerDBlocks().empty())
            mooseError("HFEM does not support mesh uniform refinement currently.");
 
          Adaptivity::uniformRefine(_mesh.get());
          // After refinement we need to make sure that all of our MOOSE-specific containers are
          // up-to-date
          _mesh->meshChanged();
        }
      }
    }
  }
  else if (_current_task == "delete_remote_elements_after_late_geometric_ghosting")
  {
    TIME_SECTION("deleteRemoteElems", 2, "Deleting Remote Elements");
 
    if (_displaced_mesh &&
        (_mesh->needsRemoteElemDeletion() != _displaced_mesh->needsRemoteElemDeletion()))
      mooseError("Our reference and displaced meshes are not in sync with respect to whether we "
                 "should delete remote elements.");
 
    // We currently only trigger the needsRemoteDeletion flag if somebody has requested a late
    // geometric ghosting functor and/or we have a displaced mesh
    if (_mesh->needsRemoteElemDeletion())
    {
      // Must make sure to create the mortar meshes to build our data structures that ensure we will
      // keep the correct elements in the mesh around
      _problem->updateMortarMesh();
      _mesh->deleteRemoteElements();
      if (_displaced_mesh)
        _displaced_mesh->deleteRemoteElements();
    }
  }
  else if (_current_task == "post_mesh_prepared")
  {
    // The reference mesh's geometry and topology are finalized by this point, so this is the single
    // point where the displaced mesh is created: a clone of the finished reference mesh. The
    // displaced mesh must be an exact copy of the reference mesh, and complete_preparation() (which
    // may perform partitioning) run separately on two previously-identical meshes can produce
    // different results (we've seen this even with Metis partitioning), so cloning is the only way
    // to guarantee the meshes are identical. Mesh preparation, including partitioning, is deferred
    // until the split_mesh task when splitting a mesh (--split-mesh), so the reference mesh may
    // still be unprepared here in that case; that's fine because such runs have no displaced mesh
    // to create either.
    if (_app.useMasterMesh())
    {
      if (_app.masterDisplacedMesh())
        _displaced_mesh = _app.masterDisplacedMesh()->safeClone();
    }
    else if (isParamValid("displacements") && getParam<bool>("use_displaced_mesh"))
    {
      TIME_SECTION("constructDisplacedMesh", 2, "Constructing Displaced Mesh");
 
      // libMesh finds the neighbor across a disjoint neighbor boundary pair by matching side
      // positions, which fails on a displaced mesh once the two sides have moved apart
      if (const auto * pairs = _mesh->getMesh().get_disjoint_neighbor_boundary_pairs();
          pairs && !pairs->empty())
        paramError("displacements",
                   "A displaced mesh cannot be used with a mesh that has disjoint neighbor "
                   "boundary pairs, such as those created by BreakMeshByBlockGenerator. Set "
                   "'use_displaced_mesh = false' in the [Mesh] block and use the Lagrangian "
                   "solid mechanics kernels ('new_system = true'), or use the mortar-based "
                   "cohesive zone model, which does not rely on pairing elements through the "
                   "disjoint neighbor machinery.");
 
      mooseAssert(_mesh->prepared(), "The reference mesh should already be fully prepared here");
      _displaced_mesh = _mesh->safeClone();
      _displaced_mesh->isDisplaced(true);
 
      const auto & displacements = getParam<std::vector<std::string>>("displacements");
      if (displacements.size() < _mesh->dimension())
        mooseError("Number of displacements must be greater than or equal to the dimension of "
                   "the mesh!");
    }
  }
  else
  {
    TIME_SECTION("completeSetupUndisplaced", 2, "Setting Up Undisplaced Mesh");
    _mesh->prepare();
  }
}