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 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 _verbose;
 
  bool _csg_only;
 
  std::map<std::string, std::list<std::unique_ptr<CSG::CSGBase>>> _csg_base_outputs;
};