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;

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;

  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; }

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;
};