MeshGeneratorSystem Class Reference

System that manages MeshGenerators. More...

#include <MeshGeneratorSystem.h>

Inheritance diagram for MeshGeneratorSystem:

Public Member Functions
	MeshGeneratorSystem (MooseApp &app)
void	executeMeshGenerators ()
	Execute and clear the Mesh Generators data structure.
void	addMeshGenerator (const std::string &type, const std::string &name, const InputParameters &params)
	Add a mesh generator that will act on the meshes in the system.
const MeshGenerator &	appendMeshGenerator (const std::string &type, const std::string &name, InputParameters params)
	Append a mesh generator that will act on the current final mesh generator in the system.
std::unique_ptr< libMesh::MeshBase > &	getMeshGeneratorOutput (const MeshGeneratorName &name)
	Get a reference to a pointer that will be the output of the MeshGenerator named name.
void	createAddedMeshGenerators ()
	Creates (constructs) all of the MeshGenerators that have been declared using addMeshGenerator().
std::vector< std::string >	getMeshGeneratorNames () const
	Get names of all mesh generators Note: This function should be called after all mesh generators are added with the 'add_mesh_generator' task.
std::unique_ptr< libMesh::MeshBase >	getSavedMesh (const std::string &name)
	Get the saved mesh by name.
std::vector< std::string >	getSavedMeshNames () const
	Get all user-defined saved meshes except main and main_displaced.
void	setCSGOnly ()
	Set whether mesh generator system is running in CSG-only mode to true.
bool	getCSGOnly () const
	Get whether mesh generator system is running in CSG-only mode.
const std::vector< std::vector< MeshGenerator * > > &	getOrderedMeshGenerators () const
bool	hasMeshGenerator (const MeshGeneratorName &name) const
const MeshGenerator &	getMeshGenerator (const std::string &name) const
bool	hasMeshGeneratorParams (const MeshGeneratorName &name) const
	Whether or not we know about the parameters for a MeshGenerator with the given name.
bool	appendingMeshGenerators () const
	Whether or not mesh generators are currently being appended (append_mesh_generator task)
bool	hasDataDrivenAllowed () const
void	dataDrivenError (const MeshGenerator &generator, const std::string &message) const
	Reports an error with the context of the data driven parameter, coming from the generator generator with message message.
MeshGeneratorName	getFinalMeshGeneratorName () const
	Get the name of the final mesh generator.
void	setVerbose (const bool verbose)
	Set the verbose flag.
void	saveOutputCSGBase (const MeshGeneratorName generator_name, std::unique_ptr< CSG::CSGBase > &csg_base)
	Saves the CSGBase object to the global map storage, _csg_base_output, for a particular mesh generator.
std::unique_ptr< CSG::CSGBase > &	getCSGBaseGeneratorOutput (const MeshGeneratorName &name)
	Returns the output CSGBase object associated with a particular mesh generator name.
PerfGraph &	perfGraph ()
	Get the PerfGraph.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static std::string	mainMeshGeneratorName ()
	The name reserved for the "main" mesh generator which is the one used for the numerical solver downstream.
static InputParameters	validParams ()

Static Public Attributes
static const std::string	data_driven_generator_param = "data_driven_generator"
	The name of the string parameter that sets the data driven generator.
static const std::string	allow_data_driven_param
	The name of the boolean parameter on the MooseApp that will enable data driven generation.

Protected Member Functions
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.
std::string	timedSectionName (const std::string &section_name) const

Protected Attributes
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.
const std::string	_prefix
	A prefix to use for all sections.
const Parallel::Communicator &	_communicator

Private Member Functions
std::vector< std::pair< std::string, MeshGeneratorName > >	getMeshGeneratorParamDependencies (const InputParameters &params, const bool allow_empty=false) const
	Gets the MeshGeneratorNames that are referenced in an object's parameters.
void	createMeshGeneratorOrder ()
	Order all of the _mesh_generators into _ordered_mesh_generators for later execution in executeMeshGenerators.
std::shared_ptr< MeshGenerator >	createMeshGenerator (const std::string &name)
	Internal method for actually constructing a mesh generator after it has been declared externally in addMeshGenerator (in Actions).
MeshGenerator &	getMeshGeneratorInternal (const std::string &name)
	Get a MeshGenerator with the name name.
const std::string &	getDataDrivenGeneratorName () const

Private Attributes
MooseApp &	_app
	The MooseApp that owns this system.
std::unordered_map< std::string, std::pair< std::string, InputParameters > >	_mesh_generator_params
	The MeshGenerators declared using addMeshGenerator(), cleared after createMeshGenerators() Key is the name, pair contains the type and the params.
std::map< std::string, std::shared_ptr< MeshGenerator > >	_mesh_generators
	Owning storage for mesh generators, map of name -> MeshGenerator.
std::vector< std::vector< MeshGenerator * > >	_ordered_mesh_generators
	Holds the ordered mesh generators from createMeshGeneratorOrder() until they are executed in executeMeshGenerators()
std::map< std::string, std::list< std::unique_ptr< libMesh::MeshBase > > >	_mesh_generator_outputs
	Holds the output for each mesh generator - including duplicates needed downstream.
std::string	_final_generator_name
	The final mesh generator name to use.
std::map< std::string, std::unique_ptr< libMesh::MeshBase > >	_save_in_meshes
	Holds the map of save in mesh -> name.
std::optional< std::string >	_data_driven_generator_name
	The name of the data driven generator, if any.
bool	_verbose
	Whether to print the names of the mesh generators being executed or not.
bool	_csg_only
	Whether mesh generator system is running in CSG-only mode.
std::map< std::string, std::list< std::unique_ptr< CSG::CSGBase > > >	_csg_base_outputs
	Holds the output CSGBase object for each mesh generator - including duplicates when needed by multiple downstream generators (key is MG name, value list is duplicates)

Detailed Description

System that manages MeshGenerators.

To be owned by the MooseApp.

Definition at line 31 of file MeshGeneratorSystem.h.

Constructor & Destructor Documentation

MeshGeneratorSystem()

MeshGeneratorSystem::MeshGeneratorSystem

(

MooseApp &

app

)

Definition at line 22 of file MeshGeneratorSystem.C.

  : PerfGraphInterface(app.perfGraph(), "MeshGeneratorSystem"),
    ParallelObject(app),
    _app(app),
    _verbose(false),
    _csg_only(false)
{
}

Member Function Documentation

addMeshGenerator()

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

Add a mesh generator that will act on the meshes in the system.

Parameters

type	The type of MeshGenerator
name	The name of the MeshGenerator
params	The params used to construct the MeshGenerator

Internally, this will store the parameters for future construction during the "add_mesh_generator" task. When called during the "create_mesh_generator" task (i.e., when creating mesh subgenerators), it will also construct the generator.

We don't construct them yet because we want to create them in order during createMeshGenerators() as much as possible so that we don't need lazy construction for things like mesh properties.

Definition at line 32 of file MeshGeneratorSystem.C.

{
  mooseAssert(!_mesh_generator_params.count(name), "Already exists");
  _mesh_generator_params.emplace(
      std::piecewise_construct, std::forward_as_tuple(name), std::forward_as_tuple(type, params));
 
  // This should be a sub mesh generator. We can assume this because if we're in the middle of
  // constructing mesh generators (not "adding" them, where we simply store their parameters)
  if (_app.constructingMeshGenerators())
    createMeshGenerator(name);
}

Referenced by CombineComponentsMeshes::act(), MooseApp::addMeshGenerator(), BatchMeshGeneratorAction::addMeshGenerators(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), and CylinderComponent::addMeshGenerators().

appendingMeshGenerators()

bool MeshGeneratorSystem::appendingMeshGenerators

(

)

const

Whether or not mesh generators are currently being appended (append_mesh_generator task)

Definition at line 679 of file MeshGeneratorSystem.C.

{
  return _app.actionWarehouse().getCurrentTaskName() == "append_mesh_generator";
}

Referenced by appendMeshGenerator(), and MooseApp::constructingMeshGenerators().

appendMeshGenerator()

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

Append a mesh generator that will act on the current final mesh generator in the system.

Parameters

type	The type of MeshGenerator
name	The name of the MeshGenerator
params	The params used to construct the MeshGenerator

This MeshGenerator must have a parameter "input" of type MeshGeneratorName for this to work, as said parameter is set to the current final generator

Note: This function must be called during the append_mesh_generator task.

Definition at line 47 of file MeshGeneratorSystem.C.

{
  if (!appendingMeshGenerators())
    mooseError("Can only call appendMeshGenerator() during the append_mesh_generator task");
  const auto param_name_mg_name_pairs = getMeshGeneratorParamDependencies(params, true);
 
  // Make sure this mesh generator has one and _only_ one input, in the "input" parameter,
  // Or several, listed in the "inputs" parameter
  if ((param_name_mg_name_pairs.size() == 0) ||
      (param_name_mg_name_pairs.size() == 1 && param_name_mg_name_pairs[0].first != "input" &&
       param_name_mg_name_pairs[0].first != "inputs") ||
      (param_name_mg_name_pairs.size() > 1 && param_name_mg_name_pairs[0].first != "inputs"))
    mooseError("While adding ",
               type,
               " '",
               name,
               "' via appendMeshGenerator():\nCan only append a mesh generator that takes a "
               "single input mesh generator via the parameter named 'input' or 'inputs'.");
 
  // If no final generator is set, we need to make sure that we have one; we will hit
  // this the first time we add an appended MeshGenerator and only need to do it once.
  // We'll then generate the final ordering within the execution phase. We'll also
  // clear the ordering because it could be invalid if we append any more generators,
  // and we'll be re-ordering within executeMeshgenerators() anyway (where we don't
  // keep track of any state for the sake of simpler logic)
  if (_final_generator_name.empty())
  {
    if (_mesh_generators.empty())
      mooseError("Cannot use appendMeshGenerator() because there is not a generator to append to!");
 
    createMeshGeneratorOrder();
    _ordered_mesh_generators.clear();
  }
 
  // Set the final generator as the input if a single generator
  mooseAssert(hasMeshGenerator(_final_generator_name), "Missing final generator");
  if (params.have_parameter<MeshGeneratorName>("input"))
    params.set<MeshGeneratorName>("input") = _final_generator_name;
  // We'll trust the final combiner generator with its list of inputs
 
  // Keep track of the new final generator
  _final_generator_name = name;
 
  // Need to add this to the param map so that createMeshGenerator can use it
  mooseAssert(!_mesh_generator_params.count(name), "Already exists");
  _mesh_generator_params.emplace(
      std::piecewise_construct, std::forward_as_tuple(name), std::forward_as_tuple(type, params));
 
  return *createMeshGenerator(name);
}

Referenced by CombineComponentsMeshes::act(), and MooseApp::appendMeshGenerator().

createAddedMeshGenerators()

void MeshGeneratorSystem::createAddedMeshGenerators

(

)

Creates (constructs) all of the MeshGenerators that have been declared using addMeshGenerator().

This parses the input parameters of type <MeshGenerator> and std::vector<MeshGeneratorName> to build the execution tree for the generators, and constructs them in dependency order

Sub generators are also generated within this phase, although the dependency resolution described above is only for the dependencies that we can parse using InputParameters. However, we require that sub generators be constructed within their dependency order (except for the last one, which may be coupled to via the generator creating said sub generator).

Should only be called by the CreateAddedMeshGenerator action during the create_added_mesh_generators task.

Definition at line 131 of file MeshGeneratorSystem.C.

{
  mooseAssert(_app.actionWarehouse().getCurrentTaskName() == "create_added_mesh_generators",
              "Should not run now");
 
  // No generators were added via addMeshGenerator()
  if (_mesh_generator_params.empty())
    return;
 
  DependencyResolver<std::string> resolver;
 
  // Define the dependencies known so far
  for (const auto & [name, type_params_pair] : _mesh_generator_params)
  {
    resolver.addItem(name);
    for (const auto & param_dependency_pair :
         getMeshGeneratorParamDependencies(type_params_pair.second))
      resolver.addEdge(param_dependency_pair.second, name);
  }
 
  std::vector<std::vector<std::string>> ordered_generators;
  try
  {
    ordered_generators = resolver.getSortedValuesSets();
  }
  catch (CyclicDependencyException<std::string> & e)
  {
    mooseError("Cyclic dependencies detected in mesh generation: ",
               MooseUtils::join(e.getCyclicDependencies(), " <- "));
  }
 
  const auto & moose_mesh = _app.actionWarehouse().getMesh();
 
  // If there is no mesh
  if (!moose_mesh.get())
    mooseError("No mesh created. Either add a Mesh, an ActionComponents or a Components block");
 
  // If we're using data-driven generation, find that requirement now
  mooseAssert(!_data_driven_generator_name, "Should not be set");
  if (moose_mesh->parameters().get<bool>("_mesh_generator_mesh") &&
      moose_mesh->isParamValid(data_driven_generator_param))
  {
    if (!hasDataDrivenAllowed())
      moose_mesh->paramError(
          data_driven_generator_param,
          "This application does not support data-driven mesh generation.\n\nThis generation is an "
          "advanced feature and must be enabled on the application via the '",
          allow_data_driven_param,
          "' parameter.");
 
    mooseAssert(moose_mesh->type() == "MeshGeneratorMesh",
                "Assumption for mesh type is now invalid");
 
    _data_driven_generator_name = moose_mesh->getParam<std::string>(data_driven_generator_param);
    if (!_mesh_generator_params.count(*_data_driven_generator_name))
      moose_mesh->paramError(data_driven_generator_param,
                             "The data driven generator '",
                             *_data_driven_generator_name,
                             "' does not exist");
  }
 
  // Check compatibility for CLI / meshing options with csg_only
  const bool csg_only = getCSGOnly();
  if (csg_only && _data_driven_generator_name)
    moose_mesh->paramError(data_driven_generator_param,
                           "This parameter should not be set in conjunction with --csg-only");
 
  // Construct all of the mesh generators that we know exist
  for (const auto & generator_names : ordered_generators)
    for (const auto & generator_name : generator_names)
      if (auto it = _mesh_generator_params.find(generator_name); it != _mesh_generator_params.end())
      {
        auto & params = it->second.second;
 
        // Determine now if we need to run this in data only mode
        const bool data_only =
            (csg_only ||
             (_data_driven_generator_name && getDataDrivenGeneratorName() != generator_name &&
              resolver.dependsOn(getDataDrivenGeneratorName(), generator_name)));
        params.set<bool>(MeshGenerator::data_only_param) = data_only;
 
        createMeshGenerator(generator_name);
 
        if (csg_only && !getMeshGenerator(generator_name).hasGenerateCSG())
          mooseError("Mesh generator ",
                     generator_name,
                     " cannot be used in csg-only mode since it does not have a generateCSG "
                     "implementation");
 
        mooseAssert(data_only == getMeshGenerator(generator_name).isDataOnly(),
                    "Inconsistent data only");
      }
 
  mooseAssert(_mesh_generator_params.empty(), "Should be empty");
  mooseAssert(_final_generator_name.empty(), "Should be unset at this point");
 
  // Set the final generator if we have one set by the user
  // and if so make sure it also exists
  if (moose_mesh->parameters().get<bool>("_mesh_generator_mesh") &&
      moose_mesh->isParamValid("final_generator"))
  {
    mooseAssert(moose_mesh->type() == "MeshGeneratorMesh",
                "Assumption for mesh type is now invalid");
 
    _final_generator_name = moose_mesh->getParam<std::string>("final_generator");
    if (!hasMeshGenerator(_final_generator_name))
      moose_mesh->paramError("final_generator",
                             "The forced final MeshGenerator '",
                             _final_generator_name,
                             "' does not exist");
  }
}

Referenced by CreateAddedMeshGenerators::act().

createMeshGenerator()

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

private

Internal method for actually constructing a mesh generator after it has been declared externally in addMeshGenerator (in Actions).

Definition at line 496 of file MeshGeneratorSystem.C.

{
  libmesh_parallel_only(comm());
  mooseAssert(_app.constructingMeshGenerators(), "Should not run now");
 
  const auto find_params = _mesh_generator_params.find(generator_name);
  mooseAssert(find_params != _mesh_generator_params.end(), "Not added");
  const auto & [type, params] = find_params->second;
  mooseAssert(comm().verify(type + generator_name), "Inconsistent construction order");
 
  std::shared_ptr<MeshGenerator> mg =
      _app.getFactory().create<MeshGenerator>(type, generator_name, params);
 
  if (mg->hasSaveMesh())
  {
    if (_save_in_meshes.count(mg->getSavedMeshName()))
      mg->paramError("save_with_name",
                     "The save with name '",
                     mg->getSavedMeshName(),
                     "' has already been used");
    _save_in_meshes.emplace(mg->getSavedMeshName(), nullptr);
  }
 
  // Setup the children and parents
  for (const auto & dependency : mg->getRequestedMeshGenerators())
  {
    // We _shouldn't_ hit this; now that we enforce construction ordering we do
    // all of this error checking at construction time because the info is available
    mooseAssert(hasMeshGenerator(dependency), "Missing dependency");
 
    auto & dependency_mg = getMeshGeneratorInternal(dependency);
    mg->addParentMeshGenerator(dependency_mg, MeshGenerator::AddParentChildKey());
    dependency_mg.addChildMeshGenerator(*mg, MeshGenerator::AddParentChildKey());
  }
 
  // Loop through all of the MeshGeneratorName and std::vector<MeshGeneratorName>
  // parameters (meshes that we should depend on), and make sure that either:
  // - We directly depend on them and requested a mesh from them
  // - We created a sub generator that depends on them and we declared it
  for (const auto & param_dependency_pair : getMeshGeneratorParamDependencies(mg->parameters()))
  {
    const auto & param_name = param_dependency_pair.first;
    const auto & dependency_name = param_dependency_pair.second;
 
    if (mg->isNullMeshName(dependency_name))
      continue;
 
    // True if this dependency was requested and is a parent
    if (mg->isParentMeshGenerator(dependency_name))
    {
      mooseAssert(mg->getRequestedMeshGenerators().count(dependency_name), "Wasn't requested");
      continue;
    }
 
    // Whether or not this is a dependency of at least one SubGenerator
    auto find_sub_dependency = std::find_if(mg->getSubMeshGenerators().begin(),
                                            mg->getSubMeshGenerators().end(),
                                            [&dependency_name](const auto & mg)
                                            { return mg->isParentMeshGenerator(dependency_name); });
    const auto is_sub_dependency = find_sub_dependency != mg->getSubMeshGenerators().end();
 
    // This should be used by a sub generator
    if (mg->getRequestedMeshGeneratorsForSub().count(dependency_name))
    {
      if (!is_sub_dependency)
        mg->mooseError("The sub generator dependency declared from MeshGenerator '",
                       dependency_name,
                       "' from the parameter '",
                       param_name,
                       "' was not used.\n\nDependencies that are declared by declareMeshForSub() "
                       "must be used as an input to a sub generator created by this object.");
    }
    // This was used by a sub generator but wasn't declared
    else if (is_sub_dependency)
      mg->mooseError(
          "The MeshGenerator '",
          dependency_name,
          "' was referenced in the parameter '",
          param_name,
          "' and used in the sub generator ",
          (*find_sub_dependency)->type(),
          " '",
          (*find_sub_dependency)->name(),
          "', but was not declared as a sub dependency.\n\nTo correct this, modify the code of ",
          mg->type(),
          " to include a call to declareMesh(es)ForSub(\"",
          param_name,
          "\") in the constructor.");
    // Isn't used at all
    else
      mg->mooseError(
          "You failed to request the generated mesh(es) for the parameter '",
          param_name,
          "'.\n\nIn specific, the mesh from MeshGenerator '",
          dependency_name,
          "' was not requested.\n\nTo correct this, you should remove the parameter if the "
          "mesh(es)\nare not needed, or request the mesh(es) with getMesh()/getMeshes().");
  }
 
  mooseAssert(!_mesh_generators.count(generator_name), "Already created");
  _mesh_generators.emplace(generator_name, mg);
  mooseAssert(!_mesh_generator_outputs.count(generator_name), "Already exists");
  _mesh_generator_outputs[generator_name];
  if (getCSGOnly())
  {
    mooseAssert(!_csg_base_outputs.count(generator_name), "CSG already exists");
    _csg_base_outputs[generator_name];
  }
  _mesh_generator_params.erase(find_params);
 
  return mg;
}

Referenced by addMeshGenerator(), appendMeshGenerator(), and createAddedMeshGenerators().

createMeshGeneratorOrder()

void MeshGeneratorSystem::createMeshGeneratorOrder ( )

private

Order all of the _mesh_generators into _ordered_mesh_generators for later execution in executeMeshGenerators.

Definition at line 245 of file MeshGeneratorSystem.C.

{
  mooseAssert(_app.constructingMeshGenerators() ||
                  _app.actionWarehouse().getCurrentTaskName() == "execute_mesh_generators",
              "Incorrect call time");
  mooseAssert(_ordered_mesh_generators.empty(), "Already ordered");
  mooseAssert(_mesh_generators.size(), "No mesh generators to order");
 
  TIME_SECTION("createMeshGeneratorOrder", 1, "Ordering Mesh Generators");
 
  // We dare not sort these based on address!
  DependencyResolver<MeshGenerator *, MeshGenerator::Comparator> resolver;
 
  // The mesh generators that must be called
  // This is needed to mark the generators that could be cut due to a
  // final generator being set, but should still be called because they're
  // either being saved in memory or as output
  std::vector<std::string> required_generators;
  for (const auto & it : _mesh_generators)
    if (it.second->hasSaveMesh() || it.second->hasOutput())
      required_generators.push_back(it.second->name());
 
  // The mesh generator tree should have all the mesh generators that
  // The final generator depends on and all the mesh generators
  // with 'save in' flag. Here we loop over all the mesh generators
  // and conditionally add all of the dependencies into the resolver
  for (const auto & it : _mesh_generators)
  {
    MeshGenerator * mg = it.second.get();
 
    // The mesh generator has to meet one of the following conditions:
    // Final mesh generator is not set, so we build the whole tree
    if (_final_generator_name.empty() ||
        // This mesh generator is the final generator
        mg->name() == _final_generator_name ||
        // This needs to be saved or output
        mg->hasSaveMesh() || mg->hasOutput() ||
        // Final mesh generator set and is a child of this generator
        (_final_generator_name.size() && mg->isChildMeshGenerator(_final_generator_name, false)) ||
        // This is a dependency of a generator that needs to be saved or output
        std::find_if(required_generators.begin(),
                     required_generators.end(),
                     [&mg](const auto & name) { return mg->isChildMeshGenerator(name, false); }) !=
            required_generators.end())
    {
      resolver.addItem(mg);
      for (const auto & dep_mg : mg->getParentMeshGenerators())
        resolver.addEdge(&getMeshGeneratorInternal(dep_mg->name()), mg);
    }
  }
 
  // ...and sort them
  try
  {
    _ordered_mesh_generators = resolver.getSortedValuesSets();
  }
  // It is _quite_ hard to trigger this to test it. I've tried to no avail.
  // Now that we...
  // - check and sort up front
  // - know if dependencies exist at the time of requesting them
  // - require that sub generators depend only on other sub generators in an object's
  //   tree + input dependencies that we explicitly declare
  // I don't think it's possible. But we'll leave it here anyway and it
  // definitely will not be covered
  catch (CyclicDependencyException<MeshGenerator *, MeshGenerator::Comparator> & e)
  {
    const auto & cycle = e.getCyclicDependencies();
    std::vector<std::string> names(cycle.size());
    for (const auto i : index_range(cycle))
      names[i] = cycle[i]->name();
 
    mooseError("Cyclic dependencies detected in mesh generation: ",
               MooseUtils::join(names, " <- "));
  }
 
  mooseAssert(_ordered_mesh_generators.size(), "No mesh generators found");
 
  const auto & final_generators = _ordered_mesh_generators.back();
 
  // We haven't forced a final generator yet
  if (_final_generator_name.empty())
  {
    mooseAssert(final_generators.size(), "Empty vector");
 
    // See if we have multiple independent trees of generators
    const auto ancestor_list = resolver.getAncestors(final_generators.back());
    if (ancestor_list.size() != resolver.size() && _final_generator_name.empty())
    {
      // Need to remove duplicates and possibly perform a difference so we'll import our list
      // into a set for these operations.
      std::set<MeshGenerator *, MeshGenerator::Comparator> ancestors(ancestor_list.begin(),
                                                                     ancestor_list.end());
      // Get all of the items from the resolver so we can compare against the tree from the
      // final generator we just pulled.
      const auto & allValues = resolver.getSortedValues();
      decltype(ancestors) all(allValues.begin(), allValues.end());
 
      decltype(ancestors) ind_tree;
      std::set_difference(all.begin(),
                          all.end(),
                          ancestors.begin(),
                          ancestors.end(),
                          std::inserter(ind_tree, ind_tree.end()));
 
      std::ostringstream oss;
      oss << "Your MeshGenerator tree contains multiple possible generator outputs :\n\""
          << final_generators.back()->name()
          << "\" and one or more of the following from an independent set: \"";
      bool first = true;
      for (const auto & gen : ind_tree)
      {
        if (!first)
          oss << ", ";
        else
          first = false;
 
        oss << gen->name();
      }
      oss << "\"\n\nThis may be due to a missing dependency or may be intentional. Please either\n"
             "- check that all the mesh generators are connected as a tree and culminate in a "
             "single final mesh. Having one wrong 'input=mg' parameter is the most common error\n"
             "- add additional dependencies to remove the ambiguity if you are using a user-built "
             "MeshGenerator\n"
             "- if you intend to execute a subset of the defined generators (uncommon), select the"
             " final MeshGenerator in the [Mesh] block with the \"final_generator\" parameter.";
      mooseError(oss.str());
    }
 
    _final_generator_name = final_generators.back()->name();
  }
  else
    mooseAssert(hasMeshGenerator(_final_generator_name), "Missing the preset final generator");
}

Referenced by appendMeshGenerator(), and executeMeshGenerators().

dataDrivenError()

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

Reports an error with the context of the data driven parameter, coming from the generator generator with message message.

Should be used to throw errors from within a MeshGenerator with more context.

Definition at line 698 of file MeshGeneratorSystem.C.

{
  const auto & moose_mesh = _app.actionWarehouse().getMesh();
  moose_mesh->paramError(data_driven_generator_param,
                         "The generator '",
                         getDataDrivenGeneratorName(),
                         "' cannot be used in data-driven mode because the parent ",
                         generator.typeAndName(),
                         " ",
                         message);
}

Referenced by MeshGenerator::MeshGenerator().

executeMeshGenerators()

void MeshGeneratorSystem::executeMeshGenerators

(

)

Execute and clear the Mesh Generators data structure.

Definition at line 380 of file MeshGeneratorSystem.C.

{
  libmesh_parallel_only(comm());
 
  // we do not need to do this when there are no mesh generators
  if (_mesh_generators.empty())
    return;
 
  // Order the generators
  createMeshGeneratorOrder();
 
  // Save all meshes marked to to_save_in_meshes and save in error checking
  std::map<std::string, std::unique_ptr<MeshBase> *> to_save_in_meshes;
  for (const auto & generator_set : _ordered_mesh_generators)
    for (const auto & generator : generator_set)
      if (generator->hasSaveMesh())
      {
        if (_final_generator_name == generator->name())
          generator->paramError("save_with_name",
                                "Cannot use the save in capability with the final mesh generator");
        if (getCSGOnly())
          generator->paramError("save_with_name", "Cannot use in conjunction with --csg-only");
        to_save_in_meshes.emplace(generator->getSavedMeshName(),
                                  &getMeshGeneratorOutput(generator->name()));
      }
  // Grab the outputs from the final generator so MeshGeneratorMesh can pick it up
  to_save_in_meshes.emplace(mainMeshGeneratorName(),
                            &getMeshGeneratorOutput(_final_generator_name));
 
  // Run the MeshGenerators in the proper order
  for (const auto & generator_set : _ordered_mesh_generators)
  {
    for (const auto & generator : generator_set)
    {
      mooseAssert(comm().verify(generator->typeAndName().size()) &&
                      comm().verify(generator->typeAndName()),
                  "Mesh generator generation is parallel inconsistent; about to execute "
                      << generator->typeAndName());
 
      const auto & name = generator->name();
      if (_verbose)
        _app._console << " [DBG] Executing mesh generator (" << COLOR_GREEN << std::setw(20) << name
                      << COLOR_DEFAULT << ") in type (" << COLOR_GREEN << generator->type()
                      << COLOR_DEFAULT << ")" << std::endl;
      auto current_mesh = generator->generateInternal();
 
      if (!generator->isDataOnly())
        mooseAssert(comm().verify(current_mesh->is_prepared()),
                    "Mesh prepared state after " << generator->typeAndName()
                                                 << " is parallel inconsistent");
 
      mooseAssert(comm().verify(generator->typeAndName().size()) &&
                      comm().verify(generator->typeAndName()),
                  "Mesh generator generation is parallel inconsistent; just executed "
                      << generator->typeAndName());
 
      // Only generating data for this generator
      if (generator->isDataOnly())
      {
        mooseAssert(!current_mesh, "Should not have a mesh");
        continue;
      }
 
#ifdef DEBUG
      // Assert that the mesh is either marked as not prepared or if it is marked as prepared,
      // that it's *actually* prepared.
      //
      // In newer version of libMesh, this also asserts that a mesh
      // marked as partially prepared is indeed prepared in (at least)
      // the aspects which are so marked.
      if (!MeshTools::valid_is_prepared(*current_mesh))
        generator->mooseError(
            "The generated mesh is marked as (at least partially) prepared but is not "
            "prepared in the marked sense(s). Please edit the '",
            generator->type(),
            "' class to call 'unset_is_prepared()', or more fine-grained "
            "alternatives as appropriate.");
#endif
 
      // Now we need to possibly give this mesh to downstream generators
      auto & outputs = _mesh_generator_outputs[name];
 
      if (outputs.size())
      {
        auto & first_output = *outputs.begin();
 
        first_output = std::move(current_mesh);
 
        const auto & copy_from = *first_output;
 
        auto output_it = ++outputs.begin();
 
        // For all of the rest we need to make a copy
        for (; output_it != outputs.end(); ++output_it)
          (*output_it) = copy_from.clone();
      }
    }
  }
 
  // No save in meshes exist in csg only mode
  if (getCSGOnly())
    return;
 
  // Grab all the valid save in meshes from the temporary map to_save_in_meshes
  // and store them in _save_in_meshes
  for (auto & [name, mesh_ptr] : to_save_in_meshes)
  {
    mooseAssert(mesh_ptr, "Invalid pointer");
    mooseAssert(*mesh_ptr, "Invalid pointer");
    if (name != mainMeshGeneratorName())
      mooseAssert(_save_in_meshes.count(name), "Mesh has not been requested for save");
    _save_in_meshes[name] = std::move(*mesh_ptr);
  }
}

Referenced by ExecuteMeshGenerators::act().

getCSGBaseGeneratorOutput()

std::unique_ptr< CSG::CSGBase > & MeshGeneratorSystem::getCSGBaseGeneratorOutput

(

const MeshGeneratorName &

name

)

Returns the output CSGBase object associated with a particular mesh generator name.

Parameters

name	Name of mesh generator

Returns

Pointer to CSGBase object associated with mesh generator name

Definition at line 739 of file MeshGeneratorSystem.C.

{
  mooseAssert(_app.constructingMeshGenerators() ||
                  _app.actionWarehouse().getCurrentTaskName() == "execute_mesh_generators",
              "Incorrect call time");
 
  auto it = _csg_base_outputs.find(name);
  mooseAssert(it != _csg_base_outputs.end(), "CSG mesh not initialized");
  it->second.push_back(nullptr);
  return it->second.back();
}

Referenced by MeshGenerator::getCSGBaseByName().

getCSGOnly()

bool MeshGeneratorSystem::getCSGOnly ( ) const

inline

Get whether mesh generator system is running in CSG-only mode.

Definition at line 135 of file MeshGeneratorSystem.h.

{ return _csg_only; }

Referenced by createAddedMeshGenerators(), createMeshGenerator(), and executeMeshGenerators().

getDataDrivenGeneratorName()

const std::string & MeshGeneratorSystem::getDataDrivenGeneratorName ( ) const

private

Returns

The data driven generator name (can only be called when set)

Definition at line 691 of file MeshGeneratorSystem.C.

{
  mooseAssert(_data_driven_generator_name, "Not set");
  return *_data_driven_generator_name;
}

Referenced by createAddedMeshGenerators(), and dataDrivenError().

getFinalMeshGeneratorName()

MeshGeneratorName MeshGeneratorSystem::getFinalMeshGeneratorName ( ) const

inline

Get the name of the final mesh generator.

Definition at line 188 of file MeshGeneratorSystem.h.

{ return _final_generator_name; }

Referenced by CombineComponentsMeshes::act(), and CSGOnlyAction::act().

getMeshGenerator()

const MeshGenerator & MeshGeneratorSystem::getMeshGenerator

(

const std::string &

name

)

const

Returns

The MeshGenerator with the name name.

Definition at line 635 of file MeshGeneratorSystem.C.

{
  const auto it = _mesh_generators.find(name);
  if (it == _mesh_generators.end())
    mooseError("Failed to find a MeshGenerator with the name '", name, "'");
  mooseAssert(it->second, "Invalid shared pointer");
  return *it->second;
}

Referenced by createAddedMeshGenerators(), and MooseApp::getMeshGenerator().

getMeshGeneratorInternal()

MeshGenerator & MeshGeneratorSystem::getMeshGeneratorInternal ( const std::string &  name )

inlineprivate

Get a MeshGenerator with the name name.

We add the "internal" here so that we allow objects that have non-const access to MooseApp to call getMeshGenerator without a const_cast. If the name was the same, you'd get an error about trying to access a private method.

Definition at line 244 of file MeshGeneratorSystem.h.

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

Referenced by createMeshGenerator(), and createMeshGeneratorOrder().

getMeshGeneratorNames()

std::vector< std::string > MeshGeneratorSystem::getMeshGeneratorNames

(

)

const

Get names of all mesh generators Note: This function should be called after all mesh generators are added with the 'add_mesh_generator' task.

The returned value will be undefined and depends on the ordering that mesh generators are added by MOOSE if the function is called during the 'add_mesh_generator' task.

Definition at line 645 of file MeshGeneratorSystem.C.

{
  std::vector<std::string> names;
  for (auto & pair : _mesh_generators)
    names.push_back(pair.first);
  return names;
}

Referenced by CombineComponentsMeshes::act(), and MooseApp::getMeshGeneratorNames().

getMeshGeneratorOutput()

std::unique_ptr< MeshBase > & MeshGeneratorSystem::getMeshGeneratorOutput

(

const MeshGeneratorName &

name

)

Get a reference to a pointer that will be the output of the MeshGenerator named name.

Definition at line 610 of file MeshGeneratorSystem.C.

{
  mooseAssert(_app.constructingMeshGenerators() ||
                  _app.actionWarehouse().getCurrentTaskName() == "execute_mesh_generators",
              "Incorrect call time");
 
  auto it = _mesh_generator_outputs.find(name);
  mooseAssert(it != _mesh_generator_outputs.end(), "Not initialized");
  it->second.push_back(nullptr);
  return it->second.back();
}

Referenced by executeMeshGenerators(), and MeshGenerator::getMeshByName().

getMeshGeneratorParamDependencies()

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

private

Gets the MeshGeneratorNames that are referenced in an object's parameters.

The result is returned as a pair of param name -> MeshGeneratorName in order to provide context.

The allow_empty param sets whether or not to report names that are empty.

Definition at line 101 of file MeshGeneratorSystem.C.

{
  std::vector<std::pair<std::string, MeshGeneratorName>> dependencies;
 
  auto add_dependency =
      [&dependencies, &allow_empty](const auto & param_name, const auto & dependency)
  {
    if (dependency.size() || allow_empty)
      dependencies.emplace_back(param_name, dependency);
  };
 
  for (const auto & [name, param] : params)
    if (const auto dependency =
            dynamic_cast<const libMesh::Parameters::Parameter<MeshGeneratorName> *>(param.get()))
      add_dependency(name, dependency->get());
    else if (const auto dependencies = dynamic_cast<
                 const libMesh::Parameters::Parameter<std::vector<MeshGeneratorName>> *>(
                 param.get()))
    {
      if (allow_empty && dependencies->get().empty())
        add_dependency(name, std::string());
      for (const auto & dependency : dependencies->get())
        add_dependency(name, dependency);
    }
 
  return dependencies;
}

Referenced by appendMeshGenerator(), createAddedMeshGenerators(), and createMeshGenerator().

getOrderedMeshGenerators()

const std::vector< std::vector< MeshGenerator * > > & MeshGeneratorSystem::getOrderedMeshGenerators ( ) const

inline

Definition at line 137 of file MeshGeneratorSystem.h.

  {
    mooseAssert(_ordered_mesh_generators.size(), "Mesh generator order has not been set");
    return _ordered_mesh_generators;
  }

Referenced by CSGOnlyAction::act().

getSavedMesh()

std::unique_ptr< MeshBase > MeshGeneratorSystem::getSavedMesh

(

const std::string &

name

)

Get the saved mesh by name.

Definition at line 663 of file MeshGeneratorSystem.C.

{
  auto find_mesh = _save_in_meshes.find(name);
  if (find_mesh == _save_in_meshes.end())
    mooseError("Failed to find a saved mesh with the name '", name, "'");
 
  auto & mesh_unique_ptr = find_mesh->second;
  if (!mesh_unique_ptr)
    mooseError("While getting the saved mesh generator '",
               name,
               "', said mesh has already been retrieved");
 
  return std::move(mesh_unique_ptr);
}

Referenced by SetupMeshAction::act(), MooseApp::getMeshGeneratorMesh(), BoundaryMeshBuilder::initialSetup(), and MeshGeneratorComponent::setupComponent().

getSavedMeshNames()

std::vector< std::string > MeshGeneratorSystem::getSavedMeshNames

(

)

const

Get all user-defined saved meshes except main and main_displaced.

Definition at line 654 of file MeshGeneratorSystem.C.

{
  std::vector<std::string> names;
  for (auto & pair : _save_in_meshes)
    names.push_back(pair.first);
  return names;
}

hasDataDrivenAllowed()

bool MeshGeneratorSystem::hasDataDrivenAllowed

(

)

const

Returns

Whether or not data driven generation is enabled in the app

Definition at line 685 of file MeshGeneratorSystem.C.

{
  return _app.parameters().get<bool>(allow_data_driven_param);
}

Referenced by createAddedMeshGenerators().

hasMeshGenerator()

bool MeshGeneratorSystem::hasMeshGenerator

(

const MeshGeneratorName &

name

)

const

Returns

Whether or not a mesh generator exists with the name name.

Definition at line 623 of file MeshGeneratorSystem.C.

{
  return _mesh_generators.count(name);
}

Referenced by appendMeshGenerator(), createAddedMeshGenerators(), createMeshGenerator(), createMeshGeneratorOrder(), and MooseApp::hasMeshGenerator().

hasMeshGeneratorParams()

bool MeshGeneratorSystem::hasMeshGeneratorParams

(

const MeshGeneratorName &

name

)

const

Whether or not we know about the parameters for a MeshGenerator with the given name.

This is primarily for error checking. If MeshGenerator dependencies are screwed up, someone could be looking for a MeshGenerator that hasn't been constructed yet. With this, at least we can give the user some context that we know the generator exists, just that the dependencies are hosed.

Definition at line 629 of file MeshGeneratorSystem.C.

{
  return _mesh_generator_params.count(name);
}

mainMeshGeneratorName()

static std::string MeshGeneratorSystem::mainMeshGeneratorName ( )

inlinestatic

The name reserved for the "main" mesh generator which is the one used for the numerical solver downstream.

Definition at line 172 of file MeshGeneratorSystem.h.

{ return "main"; };

Referenced by executeMeshGenerators(), and MooseApp::getMeshGeneratorMesh().

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level, const std::string &  live_message, const bool  print_dots = true  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns

The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

saveOutputCSGBase()

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

Saves the CSGBase object to the global map storage, _csg_base_output, for a particular mesh generator.

Note that this moves the memory ownership of the CSGBase to the MeshGeneratorSystem.

Parameters

generator_name	Name of mesh generator
csg_base	Pointer to CSGBase object created by mesh generator

Definition at line 718 of file MeshGeneratorSystem.C.

{
  auto & outputs = _csg_base_outputs[generator_name];
 
  // Store CSGBase instance for any downstream MG's that request it, creating copies
  // as needed
  if (outputs.size())
  {
    // Set first output to csg_base
    auto & first_output = *outputs.begin();
    first_output = std::move(csg_base);
    const auto & copy_from = *first_output;
    auto output_it = ++outputs.begin();
    // For all of the rest we create a clone of csg_base
    for (; output_it != outputs.end(); ++output_it)
      (*output_it) = copy_from.clone();
  }
}

Referenced by CSGOnlyAction::act().

setCSGOnly()

void MeshGeneratorSystem::setCSGOnly

(

)

Set whether mesh generator system is running in CSG-only mode to true.

Definition at line 712 of file MeshGeneratorSystem.C.

{
  _csg_only = true;
}

Referenced by CSGOnlyAction::act().

setVerbose()

void MeshGeneratorSystem::setVerbose ( const bool  verbose )

inline

Set the verbose flag.

Definition at line 191 of file MeshGeneratorSystem.h.

{ _verbose = verbose; }

Referenced by SetupDebugAction::SetupDebugAction().

timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name ) const

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

validParams()

InputParameters PerfGraphInterface::validParams ( )

staticinherited

Definition at line 16 of file PerfGraphInterface.C.

{
  InputParameters params = emptyInputParameters();
  return params;
}

Referenced by Convergence::validParams().

Member Data Documentation

_app

MooseApp& MeshGeneratorSystem::_app

private

The MooseApp that owns this system.

Definition at line 255 of file MeshGeneratorSystem.h.

Referenced by addMeshGenerator(), appendingMeshGenerators(), createAddedMeshGenerators(), createMeshGenerator(), createMeshGeneratorOrder(), dataDrivenError(), executeMeshGenerators(), getCSGBaseGeneratorOutput(), getMeshGeneratorOutput(), and hasDataDrivenAllowed().

_csg_base_outputs

std::map<std::string, std::list<std::unique_ptr<CSG::CSGBase> > > MeshGeneratorSystem::_csg_base_outputs

private

Holds the output CSGBase object for each mesh generator - including duplicates when needed by multiple downstream generators (key is MG name, value list is duplicates)

Definition at line 286 of file MeshGeneratorSystem.h.

Referenced by createMeshGenerator(), getCSGBaseGeneratorOutput(), and saveOutputCSGBase().

_csg_only

bool MeshGeneratorSystem::_csg_only

private

Whether mesh generator system is running in CSG-only mode.

Definition at line 283 of file MeshGeneratorSystem.h.

Referenced by getCSGOnly(), and setCSGOnly().

_data_driven_generator_name

std::optional<std::string> MeshGeneratorSystem::_data_driven_generator_name

private

The name of the data driven generator, if any.

Definition at line 277 of file MeshGeneratorSystem.h.

Referenced by createAddedMeshGenerators(), and getDataDrivenGeneratorName().

_final_generator_name

std::string MeshGeneratorSystem::_final_generator_name

private

The final mesh generator name to use.

Definition at line 271 of file MeshGeneratorSystem.h.

Referenced by appendMeshGenerator(), createAddedMeshGenerators(), createMeshGeneratorOrder(), executeMeshGenerators(), and getFinalMeshGeneratorName().

_mesh_generator_outputs

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

private

Holds the output for each mesh generator - including duplicates needed downstream.

Definition at line 268 of file MeshGeneratorSystem.h.

Referenced by createMeshGenerator(), executeMeshGenerators(), and getMeshGeneratorOutput().

_mesh_generator_params

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

private

The MeshGenerators declared using addMeshGenerator(), cleared after createMeshGenerators() Key is the name, pair contains the type and the params.

Definition at line 259 of file MeshGeneratorSystem.h.

Referenced by addMeshGenerator(), appendMeshGenerator(), createAddedMeshGenerators(), createMeshGenerator(), and hasMeshGeneratorParams().

_mesh_generators

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

private

Owning storage for mesh generators, map of name -> MeshGenerator.

Definition at line 262 of file MeshGeneratorSystem.h.

Referenced by appendMeshGenerator(), createMeshGenerator(), createMeshGeneratorOrder(), executeMeshGenerators(), getMeshGenerator(), getMeshGeneratorNames(), and hasMeshGenerator().

_ordered_mesh_generators

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

private

Holds the ordered mesh generators from createMeshGeneratorOrder() until they are executed in executeMeshGenerators()

Definition at line 265 of file MeshGeneratorSystem.h.

Referenced by appendMeshGenerator(), createMeshGeneratorOrder(), executeMeshGenerators(), and getOrderedMeshGenerators().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_save_in_meshes

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

private

Holds the map of save in mesh -> name.

Definition at line 274 of file MeshGeneratorSystem.h.

Referenced by createMeshGenerator(), executeMeshGenerators(), getSavedMesh(), and getSavedMeshNames().

_verbose

bool MeshGeneratorSystem::_verbose

private

Whether to print the names of the mesh generators being executed or not.

Definition at line 280 of file MeshGeneratorSystem.h.

Referenced by executeMeshGenerators(), and setVerbose().

allow_data_driven_param

const std::string MeshGeneratorSystem::allow_data_driven_param

static

Initial value:

=
    "allow_data_driven_mesh_generation"

The name of the boolean parameter on the MooseApp that will enable data driven generation.

Definition at line 39 of file MeshGeneratorSystem.h.

Referenced by createAddedMeshGenerators(), hasDataDrivenAllowed(), and MooseApp::validParams().

data_driven_generator_param

const std::string MeshGeneratorSystem::data_driven_generator_param = "data_driven_generator"

static

The name of the string parameter that sets the data driven generator.

Definition at line 37 of file MeshGeneratorSystem.h.

Referenced by createAddedMeshGenerators(), dataDrivenError(), and MeshGeneratorMesh::validParams().

---

The documentation for this class was generated from the following files:

• include/base/MeshGeneratorSystem.h
• src/base/MeshGeneratorSystem.C