MeshGeneratorSystem.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 "InputParameters.h"
#include "PerfGraphInterface.h"

#include "libmesh/parallel_object.h"
#include "libmesh/mesh_base.h"

class MooseApp;
class MeshGeneratorMesh;
class MeshGenerator;
namespace CSG
{
class CSGBase;
}

class MeshGeneratorSystem : public PerfGraphInterface, public libMesh::ParallelObject
{
public:
  MeshGeneratorSystem(MooseApp & app);

  static const std::string data_driven_generator_param;
  static const std::string allow_data_driven_param;

  void executeMeshGenerators();

  void addMeshGenerator(const std::string & type,
                        const std::string & name,
                        const InputParameters & params);

  const MeshGenerator &
  appendMeshGenerator(const std::string & type, const std::string & name, InputParameters params);

  [[nodiscard]] std::unique_ptr<libMesh::MeshBase> &
  getMeshGeneratorOutput(const MeshGeneratorName & name);

  void createAddedMeshGenerators();

  std::vector<std::string> getMeshGeneratorNames() const;

  [[nodiscard]] std::unique_ptr<libMesh::MeshBase> getSavedMesh(const std::string & name);

  std::vector<std::string> getSavedMeshNames() const;

  void setCSGOnly();

  bool getCSGOnly() const { return _csg_only; }

  const std::vector<std::vector<MeshGenerator *>> & getOrderedMeshGenerators() const
  {
    mooseAssert(_ordered_mesh_generators.size(), "Mesh generator order has not been set");
    return _ordered_mesh_generators;
  }

  bool hasMeshGenerator(const MeshGeneratorName & name) const;

  const MeshGenerator & getMeshGenerator(const std::string & name) const;

  bool hasMeshGeneratorParams(const MeshGeneratorName & name) const;

  bool appendingMeshGenerators() const;

  static std::string mainMeshGeneratorName() { return "main"; };

  bool hasBreakMeshByBlockGenerator() const { return _has_bmbb; }

  bool hasDataDrivenAllowed() const;

  void dataDrivenError(const MeshGenerator & generator, const std::string & message) const;

  MeshGeneratorName getFinalMeshGeneratorName() const { return _final_generator_name; }

  void setVerbose(const bool verbose) { _verbose = verbose; }

  void saveOutputCSGBase(const MeshGeneratorName generator_name,
                         std::unique_ptr<CSG::CSGBase> & csg_base);

  std::unique_ptr<CSG::CSGBase> & getCSGBaseGeneratorOutput(const MeshGeneratorName & name);

private:
  std::vector<std::pair<std::string, MeshGeneratorName>>
  getMeshGeneratorParamDependencies(const InputParameters & params,
                                    const bool allow_empty = false) const;

  void createMeshGeneratorOrder();

  std::shared_ptr<MeshGenerator> createMeshGenerator(const std::string & name);

  MeshGenerator & getMeshGeneratorInternal(const std::string & name)
  {
    return const_cast<MeshGenerator &>(std::as_const(*this).getMeshGenerator(name));
  }

  const std::string & getDataDrivenGeneratorName() const;

  MooseApp & _app;

  std::unordered_map<std::string, std::pair<std::string, InputParameters>> _mesh_generator_params;

  std::map<std::string, std::shared_ptr<MeshGenerator>> _mesh_generators;

  std::vector<std::vector<MeshGenerator *>> _ordered_mesh_generators;

  std::map<std::string, std::list<std::unique_ptr<libMesh::MeshBase>>> _mesh_generator_outputs;

  std::string _final_generator_name;

  std::map<std::string, std::unique_ptr<libMesh::MeshBase>> _save_in_meshes;

  std::optional<std::string> _data_driven_generator_name;

  bool _has_bmbb;

  bool _verbose;

  bool _csg_only;

  std::map<std::string, std::unique_ptr<CSG::CSGBase>> _csg_base_output;
};