16 #include "libmesh/mesh_tools.h" 22 "allow_data_driven_mesh_generation";
35 const std::string & name,
40 std::piecewise_construct, std::forward_as_tuple(
name), std::forward_as_tuple(type, params));
47 if (type ==
"BreakMeshByBlockGenerator")
53 const std::string & name,
57 mooseError(
"Can only call appendMeshGenerator() during the append_mesh_generator task");
62 if ((param_name_mg_name_pairs.size() == 0) ||
63 (param_name_mg_name_pairs.size() == 1 && param_name_mg_name_pairs[0].first !=
"input" &&
64 param_name_mg_name_pairs[0].first !=
"inputs") ||
65 (param_name_mg_name_pairs.size() > 1 && param_name_mg_name_pairs[0].first !=
"inputs"))
70 "' via appendMeshGenerator():\nCan only append a mesh generator that takes a " 71 "single input mesh generator via the parameter named 'input' or 'inputs'.");
82 mooseError(
"Cannot use appendMeshGenerator() because there is not a generator to append to!");
100 std::piecewise_construct, std::forward_as_tuple(
name), std::forward_as_tuple(type, params));
105 std::vector<std::pair<std::string, MeshGeneratorName>>
107 const bool allow_empty )
const 109 std::vector<std::pair<std::string, MeshGeneratorName>> dependencies;
111 auto add_dependency =
112 [&dependencies, &allow_empty](
const auto & param_name,
const auto & dependency)
114 if (dependency.size() || allow_empty)
115 dependencies.emplace_back(param_name, dependency);
118 for (
const auto & [
name, param] : params)
119 if (
const auto dependency =
120 dynamic_cast<const Parameters::Parameter<MeshGeneratorName> *
>(param.get()))
121 add_dependency(
name, dependency->get());
122 else if (
const auto dependencies =
123 dynamic_cast<const Parameters::Parameter<std::vector<MeshGeneratorName>
> *>(
126 if (allow_empty && dependencies->get().empty())
127 add_dependency(
name, std::string());
128 for (
const auto & dependency : dependencies->get())
129 add_dependency(
name, dependency);
139 "Should not run now");
151 for (
const auto & param_dependency_pair :
153 resolver.
addEdge(param_dependency_pair.second,
name);
156 std::vector<std::vector<std::string>> ordered_generators;
163 mooseError(
"Cyclic dependencies detected in mesh generation: ",
170 if (!moose_mesh.get())
171 mooseError(
"No mesh created. Either add a Mesh, an ActionComponents or a Components block");
175 if (moose_mesh->parameters().get<
bool>(
"_mesh_generator_mesh") &&
179 moose_mesh->paramError(
181 "This application does not support data-driven mesh generation.\n\nThis generation is an " 182 "advanced feature and must be enabled on the application via the '",
186 mooseAssert(moose_mesh->type() ==
"MeshGeneratorMesh",
187 "Assumption for mesh type is now invalid");
192 "The data driven generator '",
198 for (
const auto & generator_names : ordered_generators)
199 for (
const auto & generator_name : generator_names)
202 auto & params = it->second.second;
213 "Inconsistent data only");
221 if (moose_mesh->parameters().get<
bool>(
"_mesh_generator_mesh") &&
222 moose_mesh->isParamValid(
"final_generator"))
224 mooseAssert(moose_mesh->type() ==
"MeshGeneratorMesh",
225 "Assumption for mesh type is now invalid");
229 moose_mesh->paramError(
"final_generator",
230 "The forced final MeshGenerator '",
241 "Incorrect call time");
245 TIME_SECTION(
"createMeshGeneratorOrder", 1,
"Ordering Mesh Generators");
254 std::vector<std::string> required_generators;
256 if (it.second->hasSaveMesh() || it.second->hasOutput())
257 required_generators.push_back(it.second->name());
277 std::find_if(required_generators.begin(),
278 required_generators.end(),
280 required_generators.end())
304 std::vector<std::string> names(cycle.size());
306 names[i] = cycle[i]->
name();
308 mooseError(
"Cyclic dependencies detected in mesh generation: ",
319 mooseAssert(final_generators.size(),
"Empty vector");
322 const auto ancestor_list = resolver.
getAncestors(final_generators.back());
327 std::set<MeshGenerator *, MeshGenerator::Comparator> ancestors(ancestor_list.begin(),
328 ancestor_list.end());
332 decltype(ancestors) all(allValues.begin(), allValues.end());
334 decltype(ancestors) ind_tree;
335 std::set_difference(all.begin(),
339 std::inserter(ind_tree, ind_tree.end()));
341 std::ostringstream oss;
342 oss <<
"Your MeshGenerator tree contains multiple possible generator outputs :\n\"" 343 << final_generators.back()->name()
344 <<
"\" and one or more of the following from an independent set: \"";
346 for (
const auto & gen : ind_tree)
355 oss <<
"\"\n\nThis may be due to a missing dependency or may be intentional. Please either\n" 356 "- check that all the mesh generators are connected as a tree and culminate in a " 357 "single final mesh. Having one wrong 'input=mg' parameter is the most common error\n" 358 "- add additional dependencies to remove the ambiguity if you are using a user-built " 360 "- if you intend to execute a subset of the defined generators (uncommon), select the" 361 " final MeshGenerator in the [Mesh] block with the \"final_generator\" parameter.";
374 libmesh_parallel_only(
comm());
384 std::map<std::string, std::unique_ptr<MeshBase> *> to_save_in_meshes;
386 for (
const auto & generator : generator_set)
387 if (generator->hasSaveMesh())
390 generator->paramError(
"save_with_name",
391 "Cannot use the save in capability with the final mesh generator");
392 to_save_in_meshes.emplace(generator->getSavedMeshName(),
402 for (
const auto & generator : generator_set)
404 const auto &
name = generator->name();
406 _app.
_console <<
" [DBG] Executing mesh generator (" << COLOR_GREEN << std::setw(20) <<
name 407 << COLOR_DEFAULT <<
") in type (" << COLOR_GREEN << generator->type()
408 << COLOR_DEFAULT <<
")" << std::endl;
409 auto current_mesh = generator->generateInternal();
412 if (generator->isDataOnly())
414 mooseAssert(!current_mesh,
"Should not have a mesh");
421 if (!
_has_bmbb && !MeshTools::valid_is_prepared(*current_mesh))
422 generator->mooseError(
"The generated mesh is marked as prepared but is not actually " 423 "prepared. Please edit the '",
425 "' class to call 'set_isnt_prepared()'");
433 auto & first_output = *outputs.begin();
435 first_output = std::move(current_mesh);
437 const auto & copy_from = *first_output;
439 auto output_it = ++outputs.begin();
442 for (; output_it != outputs.end(); ++output_it)
443 (*output_it) = copy_from.clone();
450 for (
auto & [
name, mesh_ptr] : to_save_in_meshes)
452 mooseAssert(mesh_ptr,
"Invalid pointer");
453 mooseAssert(*mesh_ptr,
"Invalid pointer");
460 std::shared_ptr<MeshGenerator>
463 libmesh_parallel_only(
comm());
468 const auto & [type, params] = find_params->second;
469 mooseAssert(
comm().verify(type + generator_name),
"Inconsistent construction order");
471 std::shared_ptr<MeshGenerator> mg =
474 if (mg->hasSaveMesh())
478 "The save with name '",
479 mg->getSavedMeshName(),
480 "' has already been used");
485 for (
const auto & dependency : mg->getRequestedMeshGenerators())
502 const auto & param_name = param_dependency_pair.first;
503 const auto & dependency_name = param_dependency_pair.second;
505 if (mg->isNullMeshName(dependency_name))
509 if (mg->isParentMeshGenerator(dependency_name))
511 mooseAssert(mg->getRequestedMeshGenerators().count(dependency_name),
"Wasn't requested");
516 auto find_sub_dependency = std::find_if(mg->getSubMeshGenerators().begin(),
517 mg->getSubMeshGenerators().end(),
518 [&dependency_name](
const auto & mg)
519 {
return mg->isParentMeshGenerator(dependency_name); });
520 const auto is_sub_dependency = find_sub_dependency != mg->getSubMeshGenerators().end();
523 if (mg->getRequestedMeshGeneratorsForSub().count(dependency_name))
525 if (!is_sub_dependency)
526 mg->mooseError(
"The sub generator dependency declared from MeshGenerator '",
528 "' from the parameter '",
530 "' was not used.\n\nDependencies that are declared by declareMeshForSub() " 531 "must be used as an input to a sub generator created by this object.");
534 else if (is_sub_dependency)
536 "The MeshGenerator '",
538 "' was referenced in the parameter '",
540 "' and used in the sub generator ",
541 (*find_sub_dependency)->type(),
543 (*find_sub_dependency)->name(),
544 "', but was not declared as a sub dependency.\n\nTo correct this, modify the code of ",
546 " to include a call to declareMesh(es)ForSub(\"",
548 "\") in the constructor.");
552 "You failed to request the generated mesh(es) for the parameter '",
554 "'.\n\nIn specific, the mesh from MeshGenerator '",
556 "' was not requested.\n\nTo correct this, you should remove the parameter if the " 557 "mesh(es)\nare not needed, or request the mesh(es) with getMesh()/getMeshes().");
569 std::unique_ptr<MeshBase> &
574 "Incorrect call time");
578 it->second.push_back(
nullptr);
579 return it->second.back();
599 mooseError(
"Failed to find a MeshGenerator with the name '",
name,
"'");
600 mooseAssert(it->second,
"Invalid shared pointer");
604 std::vector<std::string>
607 std::vector<std::string> names;
609 names.push_back(pair.first);
613 std::vector<std::string>
616 std::vector<std::string> names;
618 names.push_back(pair.first);
622 std::unique_ptr<MeshBase>
627 mooseError(
"Failed to find a saved mesh with the name '",
name,
"'");
629 auto & mesh_unique_ptr = find_mesh->second;
630 if (!mesh_unique_ptr)
631 mooseError(
"While getting the saved mesh generator '",
633 "', said mesh has already been retrieved");
635 return std::move(mesh_unique_ptr);
659 const std::string & message)
const 665 "' cannot be used in data-driven mode because the parent ",
std::string name(const ElemQuality q)
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
std::string _final_generator_name
The final mesh generator name to use.
MeshGeneratorSystem(MooseApp &app)
std::string join(Iterator begin, Iterator end, const std::string &delimiter)
Python-like join function for strings over an iterator range.
static const std::string data_only_param
The name of the private parameter for setting data only.
std::shared_ptr< MeshGenerator > createMeshGenerator(const std::string &name)
Internal method for actually constructing a mesh generator after it has been declared externally in a...
bool isChildMeshGenerator(const MeshGeneratorName &name, const bool direct=true) const
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.
bool hasSaveMesh() const
Return whether or not to save the current mesh.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
std::map< std::string, std::unique_ptr< libMesh::MeshBase > > _save_in_meshes
Holds the map of save in mesh -> name.
std::size_t size() const
Returns the number of unique items stored in the dependency resolver.
bool hasDataDrivenAllowed() const
const std::vector< T > & getSortedValues()
This function also returns dependency resolved values but with a simpler single vector interface...
const std::shared_ptr< MooseMesh > & getMesh() const
std::unique_ptr< libMesh::MeshBase > getSavedMesh(const std::string &name)
Get the saved mesh by name.
std::vector< std::string > getMeshGeneratorNames() const
Get names of all mesh generators Note: This function should be called after all mesh generators are a...
bool dependsOn(const T &key, const T &value)
Return true if key depends on value.
Base class for MOOSE-based applications.
void executeMeshGenerators()
Execute and clear the Mesh Generators data structure.
std::optional< std::string > _data_driven_generator_name
The name of the data driven generator, if any.
const Parallel::Communicator & comm() const
std::list< T > getAncestors(const T &key)
Returns a list of all values that a given key depends on.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
const std::vector< std::vector< T > > & getSortedValuesSets()
Returns a vector of sets that represent dependency resolved values.
void addEdge(const T &a, const T &b)
Add an edge between nodes 'a' and 'b'.
const InputParameters & parameters()
Get the parameters of the object.
virtual const std::string & name() const
Get the name of the class.
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
bool _verbose
Whether to print the names of the mesh generators being executed or not.
void addMeshGenerator(const std::string &type, const std::string &name, const InputParameters ¶ms)
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.
void addItem(const T &value)
Add an independent item to the set.
MooseApp & _app
The MooseApp that owns this system.
virtual std::unique_ptr< Base > create()=0
void createAddedMeshGenerators()
Creates (constructs) all of the MeshGenerators that have been declared using addMeshGenerator().
ActionWarehouse & actionWarehouse()
Return a writable reference to the ActionWarehouse associated with this app.
std::string typeAndName() const
Get the class's combined type and name; useful in error handling.
void paramError(const std::string ¶m, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
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.
Interface for objects interacting with the PerfGraph.
std::vector< std::string > getSavedMeshNames() const
Get all user-defined saved meshes except main and main_displaced.
static std::string mainMeshGeneratorName()
The name reserved for the "main" mesh generator which is the one used for the numerical solver downst...
std::map< std::string, std::shared_ptr< MeshGenerator > > _mesh_generators
Owning storage for mesh generators, map of name -> MeshGenerator.
const std::string & getCurrentTaskName() const
void createMeshGeneratorOrder()
Order all of the _mesh_generators into _ordered_mesh_generators for later execution in executeMeshGen...
const std::vector< T > & getCyclicDependencies() const
Class that is used as a parameter to add[Parent/Child]() that allows only MeshGeneratorSystem methods...
static const std::string data_driven_generator_param
The name of the string parameter that sets the data driven generator.
const std::set< const MeshGenerator *, Comparator > & getParentMeshGenerators() const
Gets the MeshGenerators that are parents to this MeshGenerator.
bool hasMeshGenerator(const MeshGeneratorName &name) 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 w...
const MeshGenerator & getMeshGenerator(const std::string &name) const
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
bool appendingMeshGenerators() const
Whether or not mesh generators are currently being appended (append_mesh_generator task) ...
static const std::string allow_data_driven_param
The name of the boolean parameter on the MooseApp that will enable data driven generation.
const std::string & getDataDrivenGeneratorName() const
MeshGenerator & getMeshGeneratorInternal(const std::string &name)
Get a MeshGenerator with the name name.
bool _has_bmbb
Whether any of the mesh generators are a BreakMeshByBlockGenerator.
MeshGenerators are objects that can modify or add to an existing mesh.
auto index_range(const T &sizable)
std::unordered_map< std::string, std::pair< std::string, InputParameters > > _mesh_generator_params
The MeshGenerators declared using addMeshGenerator(), cleared after createMeshGenerators() Key is the...
bool hasMeshGeneratorParams(const MeshGeneratorName &name) const
Whether or not we know about the parameters for a MeshGenerator with the given name.
std::vector< std::pair< std::string, MeshGeneratorName > > getMeshGeneratorParamDependencies(const InputParameters ¶ms, const bool allow_empty=false) const
Gets the MeshGeneratorNames that are referenced in an object's parameters.
std::vector< std::vector< MeshGenerator * > > _ordered_mesh_generators
Holds the ordered mesh generators from createMeshGeneratorOrder() until they are executed in executeM...