MeshGenerator.h

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
 
#pragma once
 
#include "MooseObject.h"
#include "MeshMetaDataInterface.h"
#include "MooseApp.h"
#include "CSGBase.h"
 
// Included so mesh generators don't need to include this when constructing MeshBase objects
#include "MooseMesh.h"
 
#include "libmesh/mesh_base.h"
#include "libmesh/parameters.h"
 
class MooseMesh;
namespace libMesh
{
class ReplicatedMesh;
class DistributedMesh;
}
 
class MeshGenerator : public MooseObject, public MeshMetaDataInterface
{
public:
  struct Comparator
  {
    bool operator()(const MeshGenerator * const & a, const MeshGenerator * const & b) const
    {
      return a->name() < b->name();
    }
  };
 
  static InputParameters validParams();
 
  static void setHasGenerateData(InputParameters & params);
  static bool hasGenerateData(const InputParameters & params);
 
  static void setHasGenerateCSG(InputParameters & params);
  static bool hasGenerateCSG(const InputParameters & params);
 
  static const std::string data_only_param;
 
  MeshGenerator(const InputParameters & parameters);
 
  virtual std::unique_ptr<MeshBase> generate() = 0;
 
  [[nodiscard]] std::unique_ptr<CSG::CSGBase> generateInternalCSG();
 
  [[nodiscard]] std::unique_ptr<MeshBase> generateInternal();
 
  const std::set<MeshGeneratorName> & getRequestedMeshGenerators() const
  {
    return _requested_mesh_generators;
  }
  const std::set<MeshGeneratorName> & getRequestedMeshGeneratorsForSub() const
  {
    return _requested_mesh_generators_for_sub;
  }
 
  class AddParentChildKey
  {
    friend class MeshGeneratorSystem;
    AddParentChildKey() {}
    AddParentChildKey(const AddParentChildKey &) {}
  };
 
  void addParentMeshGenerator(const MeshGenerator & mg, const AddParentChildKey);
  void addChildMeshGenerator(const MeshGenerator & mg, const AddParentChildKey);
 
  const std::set<const MeshGenerator *, Comparator> & getParentMeshGenerators() const
  {
    return _parent_mesh_generators;
  }
  const std::set<const MeshGenerator *, Comparator> & getChildMeshGenerators() const
  {
    return _child_mesh_generators;
  }
  const std::set<const MeshGenerator *, Comparator> & getSubMeshGenerators() const
  {
    return _sub_mesh_generators;
  }
 
  bool isParentMeshGenerator(const MeshGeneratorName & name, const bool direct = true) const;
 
  bool isChildMeshGenerator(const MeshGeneratorName & name, const bool direct = true) const;
 
  bool isNullMeshName(const MeshGeneratorName & name) const { return _null_mesh_names.count(name); }
 
  bool hasSaveMesh() const;
 
  bool hasOutput() const;
 
  const std::string & getSavedMeshName() const;
 
  bool hasGenerateData() const { return hasGenerateData(_pars); }
 
  bool hasGenerateCSG() const { return hasGenerateCSG(_pars); }
 
  bool isDataOnly() const { return _data_only; }
 
protected:
  virtual void generateData();
 
  virtual std::unique_ptr<CSG::CSGBase> generateCSG();
 
  template <typename T, typename... Args>
  T & declareMeshProperty(const std::string & data_name, Args &&... args);
  template <typename T>
  T & declareMeshProperty(const std::string & data_name, const T & data_value)
  {
    return declareMeshProperty<T, const T &>(data_name, data_value);
  }
 
  template <typename T, typename... Args>
  T & setMeshProperty(const std::string & data_name, Args &&... args);
  template <typename T>
  T & setMeshProperty(const std::string & data_name, const T & data_value)
  {
    return setMeshProperty<T, const T &>(data_name, data_value);
  }
 
  template <typename T>
  T & copyMeshProperty(const std::string & target_data_name,
                       const std::string & source_data_name,
                       const std::string & source_mesh)
  {
    return declareMeshProperty(target_data_name, getMeshProperty<T>(source_data_name, source_mesh));
  }
 
  template <typename T>
  T & copyMeshProperty(const std::string & source_data_name, const std::string & source_mesh)
  {
    return copyMeshProperty<T>(source_data_name, source_data_name, source_mesh);
  }
 
  [[nodiscard]] std::unique_ptr<MeshBase> & getMesh(const std::string & param_name,
                                                    const bool allow_invalid = false);
  [[nodiscard]] std::vector<std::unique_ptr<MeshBase> *> getMeshes(const std::string & param_name);
  [[nodiscard]] std::unique_ptr<MeshBase> &
  getMeshByName(const MeshGeneratorName & mesh_generator_name);
  [[nodiscard]] std::vector<std::unique_ptr<MeshBase> *>
  getMeshesByName(const std::vector<MeshGeneratorName> & mesh_generator_names);
 
  [[nodiscard]] std::unique_ptr<CSG::CSGBase> & getCSGBase(const std::string & param_name);
 
  [[nodiscard]] std::unique_ptr<CSG::CSGBase> &
  getCSGBaseByName(const MeshGeneratorName & mesh_generator_name);
 
  [[nodiscard]] std::vector<std::unique_ptr<CSG::CSGBase> *>
  getCSGBases(const std::string & param_name);
 
  [[nodiscard]] std::vector<std::unique_ptr<CSG::CSGBase> *>
  getCSGBasesByName(const std::vector<MeshGeneratorName> & mesh_generator_names);
 
  void declareMeshForSub(const std::string & param_name);
  void declareMeshesForSub(const std::string & param_name);
  void declareMeshForSubByName(const MeshGeneratorName & mesh_generator_name);
  void declareMeshesForSubByName(const std::vector<MeshGeneratorName> & mesh_generator_names);
 
  [[nodiscard]] std::unique_ptr<MeshBase>
  buildMeshBaseObject(unsigned int dim = libMesh::invalid_uint);
 
  [[nodiscard]] std::unique_ptr<ReplicatedMesh>
  buildReplicatedMesh(unsigned int dim = libMesh::invalid_uint);
 
  [[nodiscard]] std::unique_ptr<DistributedMesh>
  buildDistributedMesh(unsigned int dim = libMesh::invalid_uint);
 
  template <typename... Ts>
  void addMeshSubgenerator(const std::string & type,
                           const std::string & name,
                           Ts... extra_input_parameters);
 
  void
  addMeshSubgenerator(const std::string & type, const std::string & name, InputParameters params);
 
  void declareNullMeshName(const MeshGeneratorName & name);
 
  MooseMesh * const _mesh;
 
private:
  virtual std::string meshPropertyPrefix(const std::string &) const override final
  {
    return name();
  }
 
  void checkGetMesh(const MeshGeneratorName & mesh_generator_name,
                    const std::string & param_name) const;
 
  const MeshGeneratorName * getMeshGeneratorNameFromParam(const std::string & param_name,
                                                          const bool allow_invalid) const;
  const std::vector<MeshGeneratorName> &
  getMeshGeneratorNamesFromParam(const std::string & param_name) const;
 
  RestartableDataValue & setMeshPropertyHelper(const std::string & data_name);
 
  std::set<MeshGeneratorName> _requested_mesh_generators;
  std::set<MeshGeneratorName> _requested_mesh_generators_for_sub;
  std::vector<std::pair<std::string, std::unique_ptr<MeshBase> *>> _requested_meshes;
  std::vector<std::pair<std::string, std::unique_ptr<CSG::CSGBase> *>> _requested_csg_bases;
 
  std::unique_ptr<MeshBase> _null_mesh = nullptr;
 
  std::unique_ptr<CSG::CSGBase> _null_csg_base = nullptr;
 
  std::set<const MeshGenerator *, Comparator> _parent_mesh_generators;
  std::set<const MeshGenerator *, Comparator> _child_mesh_generators;
  std::set<const MeshGenerator *, Comparator> _sub_mesh_generators;
 
  std::set<std::string> _null_mesh_names;
 
  const std::string & _save_with_name;
 
  const bool _data_only;
};
 
template <typename T, typename... Args>
T &
MeshGenerator::declareMeshProperty(const std::string & data_name, Args &&... args)
{
  if (!_app.constructingMeshGenerators())
    mooseError("Can only call declareMeshProperty() during MeshGenerator construction");
 
  // We sort construction ordering so that we _must_ declare before retrieving
  if (hasMeshProperty(data_name))
    mooseError("While declaring mesh property '",
               data_name,
               "' with type '",
               MooseUtils::prettyCppType<T>(),
               "',\nsaid property has already been declared with type '",
               setMeshPropertyHelper(data_name).type(),
               "'");
 
  const auto full_name = meshPropertyName(data_name);
  auto new_T_value =
      std::make_unique<RestartableData<T>>(full_name, nullptr, std::forward<Args>(args)...);
  auto value =
      &_app.registerRestartableData(std::move(new_T_value), 0, false, MooseApp::MESH_META_DATA);
  mooseAssert(value->declared(), "Should be declared");
 
  RestartableData<T> * T_value = dynamic_cast<RestartableData<T> *>(value);
  mooseAssert(T_value, "Bad cast");
 
  return T_value->set();
}
 
template <typename T, typename... Args>
T &
MeshGenerator::setMeshProperty(const std::string & data_name, Args &&... args)
{
  if (_app.actionWarehouse().getCurrentTaskName() != "execute_mesh_generators")
    mooseError("Updating mesh meta data with setMeshProperty() can only be called during "
               "MeshGenerator::generate()");
 
  if (!hasMeshProperty(data_name))
    mooseError("Failed to get the mesh property '", data_name, "'");
  RestartableDataValue * value = &setMeshPropertyHelper(data_name);
  RestartableData<T> * T_value = dynamic_cast<RestartableData<T> *>(value);
  if (!T_value)
    mooseError("While retrieving mesh property '",
               data_name,
               "' with type '",
               MooseUtils::prettyCppType<T>(),
               "',\nthe property was found with type '",
               value->type(),
               "'");
 
  // Set the value if someone provided arguments to set it to
  if constexpr (sizeof...(args) > 0)
    T_value->set() = T(std::forward<Args>(args)...);
 
  return T_value->set();
}
 
template <typename... Ts>
void
MeshGenerator::addMeshSubgenerator(const std::string & type,
                                   const std::string & name,
                                   Ts... extra_input_parameters)
{
  InputParameters subgenerator_params = _app.getFactory().getValidParams(type);
 
  subgenerator_params.setParameters(extra_input_parameters...);
 
  addMeshSubgenerator(type, name, subgenerator_params);
}