MeshGenerator.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 "MeshGenerator.h"
#include "MooseMesh.h"
#include "MooseApp.h"

#include "Exodus.h"
#include "Nemesis.h"

#include "libmesh/exodusII_io.h"
#include "libmesh/nemesis_io.h"

const std::string MeshGenerator::data_only_param = "_data_only";

InputParameters
MeshGenerator::validParams()
{
  InputParameters params = MooseObject::validParams();

  params.addParam<bool>("show_info",
                        false,
                        "Whether or not to show mesh info after generating the mesh "
                        "(bounding box, element types, sidesets, nodesets, subdomains, etc)");
  params.addParam<std::string>(
      "save_with_name",
      std::string(),
      "Keep the mesh from this mesh generator in memory with the name specified");

  params.addParam<bool>(
      "output", false, "Whether or not to output the mesh file after generating the mesh");
  params.addParam<bool>("nemesis",
                        false,
                        "Whether or not to output the mesh file in the nemesis"
                        "format (only if output = true)");

  params.addParamNamesToGroup("show_info output nemesis", "Debugging");
  params.addParamNamesToGroup("save_with_name", "Advanced");
  params.registerBase("MeshGenerator");

  params.addPrivateParam<bool>("_has_generate_data", false);
  params.addPrivateParam<bool>("_has_generate_csg", false);
  params.addPrivateParam<MooseMesh *>("_moose_mesh", nullptr);
  params.addPrivateParam<bool>(data_only_param, false);
  // Controls are not created early enough
  params.suppressParameter<std::vector<std::string>>("control_tags");

  return params;
}

MeshGenerator::MeshGenerator(const InputParameters & parameters)
  : MooseObject(parameters),
    MeshMetaDataInterface(this),
    _mesh(getParam<MooseMesh *>("_moose_mesh") ? getParam<MooseMesh *>("_moose_mesh")
                                               : _app.actionWarehouse().mesh().get()),
    _save_with_name(getParam<std::string>("save_with_name")),
    _data_only(getParam<bool>(data_only_param))
{
  const auto & system = _app.getMeshGeneratorSystem();
  if (isDataOnly())
  {
    // Skip the requirement for generateData() if we are generating CSG object
    if (!hasGenerateCSG() && !hasGenerateData())
      system.dataDrivenError(*this, "does not support data-driven generation");
    if (hasSaveMesh())
      system.dataDrivenError(*this, "has 'save_with_name' set");
  }
  if (_save_with_name == system.mainMeshGeneratorName())
    paramError(
        "save_with_name", "The user-defined mesh name: '", _save_with_name, "' is a reserved name");
  if (getParam<bool>("nemesis") && !getParam<bool>("output"))
    paramError("nemesis", "Should only be set to true if 'output=true'");
}

void
MeshGenerator::setHasGenerateData(InputParameters & params)
{
  params.set<bool>("_has_generate_data") = true;
}

bool
MeshGenerator::hasGenerateData(const InputParameters & params)
{
  return params.get<bool>("_has_generate_data");
}

void
MeshGenerator::setHasGenerateCSG(InputParameters & params)
{
  params.set<bool>("_has_generate_csg") = true;
}

bool
MeshGenerator::hasGenerateCSG(const InputParameters & params)
{
  return params.get<bool>("_has_generate_csg");
}

const MeshGeneratorName *
MeshGenerator::getMeshGeneratorNameFromParam(const std::string & param_name,
                                             const bool allow_invalid) const
{
  const auto valid_param = isParamValid(param_name);
  if (!allow_invalid)
  {
    if (!valid_param)
      mooseError("Failed to get a parameter with the name \"",
                 param_name,
                 "\" when getting a MeshGenerator.",
                 "\n\nKnown parameters:\n",
                 _pars);
    if (!_pars.isType<MeshGeneratorName>(param_name))
      paramError(param_name,
                 "Parameter of type \"",
                 _pars.type(param_name),
                 "\" is not an expected type for getting a MeshGenerator (should be of type "
                 "\"MeshGeneratorName\")");
  }
  else if (!valid_param)
    return nullptr;

  const auto & name = getParam<MeshGeneratorName>(param_name);
  checkGetMesh(name, param_name);

  return &name;
}

const std::vector<MeshGeneratorName> &
MeshGenerator::getMeshGeneratorNamesFromParam(const std::string & param_name) const
{
  if (!isParamValid(param_name))
    mooseError("Failed to get a parameter with the name \"",
               param_name,
               "\" when getting MeshGenerators.",
               "\n\nKnown parameters:\n",
               _pars);
  if (!_pars.isType<std::vector<MeshGeneratorName>>(param_name))
    paramError(param_name,
               "Parameter of type \"",
               _pars.type(param_name),
               "\" is not an expected type for getting MeshGenerators (should be of type "
               "\"std::vector<MeshGeneratorName>\")");

  const auto & names = getParam<std::vector<MeshGeneratorName>>(param_name);
  for (const auto & name : names)
    checkGetMesh(name, param_name);

  return names;
}

void
MeshGenerator::checkGetMesh(const MeshGeneratorName & mesh_generator_name,
                            const std::string & param_name) const
{
  mooseAssert(!mesh_generator_name.empty(), "Empty name");
  const auto & mg_sys = _app.getMeshGeneratorSystem();
  if (!hasGenerateCSG() && !_app.constructingMeshGenerators())
    mooseError("Cannot get a mesh outside of construction");
  if (!mg_sys.hasMeshGenerator(mesh_generator_name) && !isNullMeshName(mesh_generator_name))
  {
    std::stringstream error;
    error << "The requested MeshGenerator with name '" << mesh_generator_name << "' ";
    if (mg_sys.hasMeshGeneratorParams(mesh_generator_name))
      error << "was found, but has not been constructed yet.\n\nThis can occur when your "
               "dependencies are not properly defined and we cannot infer the proper construction "
               "order of your MeshGenerators.\n\nThe most likely case is a sub generator whose "
               "input(s) are not declared as a sub dependency in the generator creating them.";
    else
      error << "was not found.\nMesh generators that can be found: "
            << Moose::stringify(mg_sys.getMeshGeneratorNames());

    if (param_name.size())
      paramError(param_name, error.str());
    else
      mooseError(error.str());
  }
}

std::unique_ptr<MeshBase> &
MeshGenerator::getMesh(const std::string & param_name, const bool allow_invalid /* = false */)
{
  const MeshGeneratorName * name = getMeshGeneratorNameFromParam(param_name, allow_invalid);
  if (!name)
    return _null_mesh;
  return getMeshByName(*name);
}

std::vector<std::unique_ptr<MeshBase> *>
MeshGenerator::getMeshes(const std::string & param_name)
{
  return getMeshesByName(getMeshGeneratorNamesFromParam(param_name));
}

std::unique_ptr<MeshBase> &
MeshGenerator::getMeshByName(const MeshGeneratorName & mesh_generator_name)
{
  checkGetMesh(mesh_generator_name, "");
  if (isNullMeshName(mesh_generator_name))
    return _null_mesh;

  _requested_mesh_generators.insert(mesh_generator_name);
  auto & mesh = _app.getMeshGeneratorSystem().getMeshGeneratorOutput(mesh_generator_name);
  _requested_meshes.emplace_back(mesh_generator_name, &mesh);
  return mesh;
}

std::vector<std::unique_ptr<MeshBase> *>
MeshGenerator::getMeshesByName(const std::vector<MeshGeneratorName> & mesh_generator_names)
{
  std::vector<std::unique_ptr<MeshBase> *> meshes;
  for (const auto & name : mesh_generator_names)
    meshes.push_back(&getMeshByName(name));
  return meshes;
}

std::unique_ptr<CSG::CSGBase> &
MeshGenerator::getCSGBase(const std::string & param_name)
{
  const MeshGeneratorName * name = getMeshGeneratorNameFromParam(param_name, false);
  if (!name)
    return _null_csg_base;
  return getCSGBaseByName(*name);
}

std::unique_ptr<CSG::CSGBase> &
MeshGenerator::getCSGBaseByName(const MeshGeneratorName & mesh_generator_name)
{
  checkGetMesh(mesh_generator_name, "");
  if (isNullMeshName(mesh_generator_name))
    return _null_csg_base;

  auto & csg_base = _app.getMeshGeneratorSystem().getCSGBaseGeneratorOutput(mesh_generator_name);
  _requested_csg_bases.emplace_back(mesh_generator_name, &csg_base);
  return csg_base;
}

std::vector<std::unique_ptr<CSG::CSGBase> *>
MeshGenerator::getCSGBases(const std::string & param_name)
{
  return getCSGBasesByName(getMeshGeneratorNamesFromParam(param_name));
}

std::vector<std::unique_ptr<CSG::CSGBase> *>
MeshGenerator::getCSGBasesByName(const std::vector<MeshGeneratorName> & mesh_generator_names)
{
  std::vector<std::unique_ptr<CSG::CSGBase> *> csg_bases;
  for (const auto & name : mesh_generator_names)
    csg_bases.push_back(&getCSGBaseByName(name));
  return csg_bases;
}

void
MeshGenerator::declareMeshForSub(const std::string & param_name)
{
  declareMeshForSubByName(*getMeshGeneratorNameFromParam(param_name, false));
}

void
MeshGenerator::declareMeshesForSub(const std::string & param_name)
{
  declareMeshesForSubByName(getMeshGeneratorNamesFromParam(param_name));
}

void
MeshGenerator::declareMeshForSubByName(const MeshGeneratorName & mesh_generator_name)
{
  checkGetMesh(mesh_generator_name, "");
  if (isNullMeshName(mesh_generator_name))
    return;

  _requested_mesh_generators_for_sub.insert(mesh_generator_name);
}

void
MeshGenerator::declareMeshesForSubByName(
    const std::vector<MeshGeneratorName> & mesh_generator_names)
{
  for (const auto & name : mesh_generator_names)
    declareMeshForSubByName(name);
}

std::unique_ptr<MeshBase>
MeshGenerator::buildMeshBaseObject(unsigned int dim)
{
  mooseAssert(_mesh, "Need a MooseMesh object");
  return _mesh->buildMeshBaseObject(dim);
}

std::unique_ptr<ReplicatedMesh>
MeshGenerator::buildReplicatedMesh(unsigned int dim)
{
  mooseAssert(_mesh, "Need a MooseMesh object");
  return _mesh->buildTypedMesh<ReplicatedMesh>(dim);
}

std::unique_ptr<DistributedMesh>
MeshGenerator::buildDistributedMesh(unsigned int dim)
{
  mooseAssert(_mesh, "Need a MooseMesh object");
  return _mesh->buildTypedMesh<DistributedMesh>(dim);
}

std::unique_ptr<MeshBase>
MeshGenerator::generateInternal()
{
  libmesh_parallel_only(comm());
  mooseAssert(comm().verify(type() + name()), "Inconsistent execution ordering");

  if (hasGenerateData())
    generateData();

  if (isDataOnly())
    return nullptr;

  auto mesh = generate();
  if (!mesh)
    mooseError("A mesh was not generated by this generator (it was nullptr).");

  for (const auto & [requested_name, requested_mesh] : _requested_meshes)
    if (*requested_mesh)
      mooseError(
          "The mesh from input ",
          _app.getMeshGenerator(requested_name).type(),
          " '",
          _app.getMeshGenerator(requested_name).name(),
          "' was not moved.\n\nThe MeshGenerator system requires that the memory from all input "
          "meshes\nare managed by the requesting MeshGenerator during the generate phase.\n\nThis "
          "is achieved with a std::move() operation within the generate() method.");

  if (getParam<bool>("show_info"))
  {
    if (!mesh->is_prepared())
      mesh->prepare_for_use();

    const auto mesh_info = mesh->get_info(/* verbosity = */ 2);

    // We will prefix all information with "type() 'name()':" because this could potentially
    // output a ton of information and looks a bit better with a prefix
    std::stringstream oss;
    const auto split = MooseUtils::split(mesh_info, "\n");
    if (split.size())
      for (std::size_t i = 0; i < split.size() - 1; ++i) // ignore the last line break
        oss << COLOR_CYAN << "" << type() << " '" << name() << "': " << COLOR_DEFAULT << split[i]
            << std::endl;
    _console << oss.str() << std::flush;
  }

  // output the current mesh block to file
  if (hasOutput())
  {
    if (!mesh->is_prepared())
      mesh->prepare_for_use();

    if (!getParam<bool>("nemesis"))
    {
      libMesh::ExodusII_IO exio(*mesh);

      if (mesh->mesh_dimension() == 1)
        exio.write_as_dimension(3);

      // Avoid truncating names
      exio.set_max_name_length(80);

      // Default to non-HDF5 output for wider compatibility
      exio.set_hdf5_writing(false);

      exio.write(name() + "_in.e");
    }
    else
    {
      libMesh::Nemesis_IO nemesis_io(*mesh);

      // Default to non-HDF5 output for wider compatibility
      nemesis_io.set_hdf5_writing(false);

      nemesis_io.write(name() + "_in.e");
    }
  }

  return mesh;
}

std::unique_ptr<CSG::CSGBase>
MeshGenerator::generateInternalCSG()
{
  mooseAssert(isDataOnly(), "Trying to use csg-only mode while not in data-driven mode");
  auto csg_obj = generateCSG();
  mooseAssert(csg_obj, "Null CSG object");
  for (const auto & [requested_name, requested_csg] : _requested_csg_bases)
    if (*requested_csg)
      mooseError(
          "The CSGBase object from input ",
          _app.getMeshGenerator(requested_name).type(),
          " '",
          _app.getMeshGenerator(requested_name).name(),
          "' was not moved.\n\nThe MeshGenerator system requires that the memory from all input "
          "meshes\nare managed by the requesting MeshGenerator during the generate phase.\n\nThis "
          "is achieved with a std::move() operation within the generateCSG() method.");

  return csg_obj;
}

void
MeshGenerator::addMeshSubgenerator(const std::string & type,
                                   const std::string & name,
                                   InputParameters params)
{
  if (!_app.constructingMeshGenerators())
    mooseError("Can only call addMeshSubgenerator() during MeshGenerator construction");

  // In case the user forgot it
  params.set<MooseApp *>(MooseBase::app_param) = &_app;

  // Set this to be data-only if this generator is data only
  params.set<bool>(data_only_param) = isDataOnly();

  _app.addMeshGenerator(type, name, params);
  _sub_mesh_generators.insert(&std::as_const(_app).getMeshGenerator(name));
}

RestartableDataValue &
MeshGenerator::setMeshPropertyHelper(const std::string & data_name)
{
  return _app.getRestartableMetaData(meshPropertyName(data_name), MooseApp::MESH_META_DATA, 0);
}

void
MeshGenerator::addParentMeshGenerator(const MeshGenerator & mg, const AddParentChildKey)
{
  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
  _parent_mesh_generators.insert(&mg);
}

void
MeshGenerator::addChildMeshGenerator(const MeshGenerator & mg, const AddParentChildKey)
{
  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
  _child_mesh_generators.insert(&mg);
}

bool
MeshGenerator::isParentMeshGenerator(const MeshGeneratorName & name,
                                     const bool direct /* = true */) const
{
  return std::find_if(getParentMeshGenerators().begin(),
                      getParentMeshGenerators().end(),
                      [&name, &direct](const auto & mg)
                      {
                        return mg->name() == name ||
                               (!direct && mg->isParentMeshGenerator(name, /* direct = */ false));
                      }) != getParentMeshGenerators().end();
}

bool
MeshGenerator::isChildMeshGenerator(const MeshGeneratorName & name,
                                    const bool direct /* = true */) const
{
  return std::find_if(getChildMeshGenerators().begin(),
                      getChildMeshGenerators().end(),
                      [&name, &direct](const auto & mg)
                      {
                        return mg->name() == name ||
                               (!direct && mg->isChildMeshGenerator(name, /* direct = */ false));
                      }) != getChildMeshGenerators().end();
}

void
MeshGenerator::declareNullMeshName(const MeshGeneratorName & name)
{
  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
  mooseAssert(!_null_mesh_names.count(name), "Already declared");
  _null_mesh_names.insert(name);
}

bool
MeshGenerator::hasSaveMesh() const
{
  return _save_with_name.size();
}

bool
MeshGenerator::hasOutput() const
{
  return getParam<bool>("output");
}

const std::string &
MeshGenerator::getSavedMeshName() const
{
  return _save_with_name;
}

void
MeshGenerator::generateData()
{
  mooseAssert(!hasGenerateData(), "Inconsistent flag");
  mooseError("This MeshGenerator does not have a generateData() implementation.");
}

[[nodiscard]] std::unique_ptr<CSG::CSGBase>
MeshGenerator::generateCSG()
{
  mooseAssert(!hasGenerateCSG(), "Inconsistent flag");
  mooseError("This MeshGenerator does not have a generateCSG() implementation.");
}