https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
AdvancedExtruderGenerator Class Reference

Extrudes a mesh to another dimension. More...

#include <AdvancedExtruderGenerator.h>

Inheritance diagram for AdvancedExtruderGenerator:
[legend]

Public Types

using DataFileParameterType = DataFileName
 The parameter type this interface expects for a data file name. More...
 

Public Member Functions

 AdvancedExtruderGenerator (const InputParameters &parameters)
 
std::unique_ptr< MeshBase > generate () override
 Generate / modify the mesh. More...
 
bool hasGenerateData () const
 
std::unique_ptr< MeshBase > generateInternal ()
 Internal generation method - this is what is actually called within MooseApp to execute the MeshGenerator. More...
 
const std::set< MeshGeneratorName > & getRequestedMeshGenerators () const
 
const std::set< MeshGeneratorName > & getRequestedMeshGeneratorsForSub () const
 
void addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)
 Adds the MeshGenerator mg as a parent. More...
 
void addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)
 Adds the MeshGenerator mg as a child. More...
 
const std::set< const MeshGenerator *, Comparator > & getParentMeshGenerators () const
 Gets the MeshGenerators that are parents to this MeshGenerator. More...
 
const std::set< const MeshGenerator *, Comparator > & getChildMeshGenerators () const
 Gets the MeshGenerators that are children to this MeshGenerator. More...
 
const std::set< const MeshGenerator *, Comparator > & getSubMeshGenerators () const
 Gets the MeshGenerators that are children to this MeshGenerator. More...
 
bool isParentMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const
 
bool isChildMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const
 
bool isNullMeshName (const MeshGeneratorName &name) const
 
bool hasSaveMesh () const
 Return whether or not to save the current mesh. More...
 
bool hasOutput () const
 
const std::string & getSavedMeshName () const
 Return the name of the saved mesh. More...
 
bool isDataOnly () const
 
virtual bool enabled () const
 Return the enabled status of the object. More...
 
std::shared_ptr< MooseObject > getSharedPtr ()
 Get another shared pointer to this object that has the same ownership group. More...
 
std::shared_ptr< const MooseObject > getSharedPtr () const
 
MooseApp & getMooseApp () const
 Get the MooseApp this class is associated with. More...
 
const std::string & type () const
 Get the type of this class. More...
 
virtual const std::string & name () const
 Get the name of the class. More...
 
std::string typeAndName () const
 Get the class's combined type and name; useful in error handling. More...
 
std::string errorPrefix (const std::string &error_type) const
 
void callMooseError (std::string msg, const bool with_prefix) const
 Calls moose error with the message msg. More...
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 The unique parameter name of a valid parameter of this object for accessing parameter controls. More...
 
const InputParameters & parameters () const
 Get the parameters of the object. More...
 
MooseObjectName uniqueName () const
 The unique name for accessing input parameters of this object in the InputParameterWarehouse. More...
 
template<typename T >
const T & getParam (const std::string &name) const
 Retrieve a parameter for the object. More...
 
template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 Retrieve two parameters and provide pair of parameters for the object. More...
 
template<typename T >
const T * queryParam (const std::string &name) const
 Query a parameter for the object. More...
 
template<typename T >
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 Retrieve a renamed parameter for the object. More...
 
template<typename T >
T getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...
 
bool isParamValid (const std::string &name) const
 Test if the supplied parameter is valid. More...
 
bool isParamSetByUser (const std::string &nm) const
 Test if the supplied parameter is set by a user, as opposed to not set or set to default. More...
 
template<typename... Args>
void paramError (const std::string &param, Args... args) const
 Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
 
template<typename... Args>
void paramWarning (const std::string &param, Args... args) const
 Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
 
template<typename... Args>
void paramInfo (const std::string &param, Args... args) const
 Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 Connect controllable parameter of this action with the controllable parameters of the objects added by this action. More...
 
template<typename... Args>
void mooseError (Args &&... args) const
 Emits an error prefixed with object name and type. More...
 
template<typename... Args>
void mooseErrorNonPrefixed (Args &&... args) const
 Emits an error without the prefixing included in mooseError(). More...
 
template<typename... Args>
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 Emits a documented error with object name and type. More...
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 Emits a warning prefixed with object name and type. More...
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 Emits a warning without the prefixing included in mooseWarning(). More...
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 
template<typename... Args>
void mooseInfo (Args &&... args) const
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 
std::string getDataFileName (const std::string &param) const
 Deprecated method. More...
 
std::string getDataFileNameByName (const std::string &relative_path) const
 Deprecated method. More...
 
std::string getDataFilePath (const std::string &relative_path) const
 Returns the path of a data file for a given relative file path. More...
 

Static Public Member Functions

static InputParameters validParams ()
 
static void setHasGenerateData (InputParameters &params)
 Sets that a mesh generator has a generateData() implementation. More...
 
static bool hasGenerateData (const InputParameters &params)
 

Public Attributes

const ConsoleStream _console
 An instance of helper class to write streams to the Console objects. More...
 

Static Public Attributes

static const std::string data_only_param = "_data_only"
 The name of the private parameter for setting data only. More...
 
static constexpr auto SYSTEM = "MeshMetaData"
 The system name used when initializing the Restartable interface. More...
 
static constexpr auto NAME = "<empty>"
 The data name used when initializing the Restartable interface for non-MeshGenerator objects. More...
 

Protected Member Functions

virtual void generateData ()
 Generate the mesh data. More...
 
template<typename T >
T & copyMeshProperty (const std::string &target_data_name, const std::string &source_data_name, const std::string &source_mesh)
 Method for copying attribute from input mesh meta-data store to current mesh meta-data store. More...
 
template<typename T >
T & copyMeshProperty (const std::string &source_data_name, const std::string &source_mesh)
 Method for copying attribute from input mesh meta-data store to current mesh meta-data store, keeping source and target data names the same. More...
 
std::unique_ptr< MeshBase > & getMesh (const std::string &param_name, const bool allow_invalid=false)
 Takes the name of a MeshGeneratorName parameter and then gets a pointer to the Mesh that MeshGenerator is going to create. More...
 
std::vector< std::unique_ptr< MeshBase > * > getMeshes (const std::string &param_name)
 Like getMesh(), but for multiple generators. More...
 
std::unique_ptr< MeshBase > & getMeshByName (const MeshGeneratorName &mesh_generator_name)
 Like getMesh(), but takes the name of another MeshGenerator directly. More...
 
std::vector< std::unique_ptr< MeshBase > * > getMeshesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
 Like getMeshByName(), but for multiple generators. More...
 
void declareMeshForSub (const std::string &param_name)
 Declares that a MeshGenerator referenced in the InputParameters is to be used as a dependency of a sub MeshGenerator created by this MeshGenerator (see addSubMeshGenerator) More...
 
void declareMeshesForSub (const std::string &param_name)
 Like declareMeshForSub(), but for multiple generators. More...
 
void declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)
 Like declareMeshForSub(), but takes the name of another MeshGenerator directly. More...
 
void declareMeshesForSubByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
 Like declareMeshForSubByName(), but for multiple generators. More...
 
std::unique_ptr< MeshBase > buildMeshBaseObject (unsigned int dim=libMesh::invalid_uint)
 Build a MeshBase object whose underlying type will be determined by the Mesh input file block. More...
 
std::unique_ptr< ReplicatedMesh > buildReplicatedMesh (unsigned int dim=libMesh::invalid_uint)
 Build a replicated mesh. More...
 
std::unique_ptr< DistributedMesh > buildDistributedMesh (unsigned int dim=libMesh::invalid_uint)
 Build a distributed mesh that has correct remote element removal behavior and geometric ghosting functors based on the simulation objects. More...
 
template<typename... Ts>
void addMeshSubgenerator (const std::string &type, const std::string &name, Ts... extra_input_parameters)
 Construct a "subgenerator", a different MeshGenerator subclass that will be added to the same MooseApp on the fly. More...
 
void addMeshSubgenerator (const std::string &type, const std::string &name, InputParameters params)
 Construct a "subgenerator", as above. More...
 
void declareNullMeshName (const MeshGeneratorName &name)
 Registers the name name as a "null" mesh, which is a MeshGenerator used in InputParameters that will not represent an input mesh when requested via getMesh. More...
 
template<typename T >
const T & getMeshProperty (const std::string &data_name, const std::string &prefix)
 Method for retrieving a property with the given type and name exists in the mesh meta-data store. More...
 
template<typename T >
const T & getMeshProperty (const std::string &data_name)
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
template<typename T >
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name) const
 
template<typename T >
bool hasMeshProperty (const std::string &data_name) const
 
std::string meshPropertyName (const std::string &data_name) const
 
template<typename T , typename... Args>
T & declareMeshProperty (const std::string &data_name, Args &&... args)
 Methods for writing out attributes to the mesh meta-data store, which can be retrieved from most other MOOSE systems and is recoverable. More...
 
template<typename T >
T & declareMeshProperty (const std::string &data_name, const T &data_value)
 
template<typename T , typename... Args>
T & setMeshProperty (const std::string &data_name, Args &&... args)
 Method for updating attributes to the mesh meta-data store, which can only be invoked in the MeshGenerator generate routine only if the mesh generator property has already been declared. More...
 
template<typename T >
T & setMeshProperty (const std::string &data_name, const T &data_value)
 

Static Protected Member Functions

static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

std::unique_ptr< MeshBase > & _input
 Mesh that comes from another generator. More...
 
const std::vector< Real > & _heights
 Height of each elevation. More...
 
const std::vector< Real > _biases
 Bias growth factor of each elevation. More...
 
const std::vector< unsigned int > & _num_layers
 Number of layers in each elevation. More...
 
const std::vector< std::vector< subdomain_id_type > > & _subdomain_swaps
 Subdomains to swap out for each elevation. More...
 
const std::vector< std::vector< boundary_id_type > > & _boundary_swaps
 Boundaries to swap out for each elevation. More...
 
const std::vector< std::string > & _elem_integer_names_to_swap
 Names and indices of extra element integers to swap. More...
 
std::vector< unsigned int > _elem_integer_indices_to_swap
 
const std::vector< std::vector< std::vector< dof_id_type > > > & _elem_integers_swaps
 Extra element integers to swap out for each elevation and each element interger name. More...
 
std::vector< std::unordered_map< subdomain_id_type, subdomain_id_type > > _subdomain_swap_pairs
 Easier to work with version of _sudomain_swaps. More...
 
std::vector< std::unordered_map< boundary_id_type, boundary_id_type > > _boundary_swap_pairs
 Easier to work with version of _boundary_swaps. More...
 
std::vector< std::unordered_map< dof_id_type, dof_id_type > > _elem_integers_swap_pairs
 Easier to work with version of _elem_integers_swaps. More...
 
Point _direction
 The direction of the extrusion. More...
 
const bool _has_top_boundary
 
const BoundaryName _top_boundary
 
const bool _has_bottom_boundary
 
const BoundaryName _bottom_boundary
 
const std::vector< std::vector< subdomain_id_type > > _upward_boundary_source_blocks
 The list of input mesh's blocks that need to be assigned upward boundary interfaces for each layer of elevation. More...
 
const std::vector< std::vector< boundary_id_type > > _upward_boundary_ids
 Upward boundary interfaces for each layer of elevation. More...
 
const std::vector< std::vector< subdomain_id_type > > _downward_boundary_source_blocks
 The list of input mesh's blocks that need to be assigned downward boundary interfaces for each layer of elevation. More...
 
const std::vector< std::vector< boundary_id_type > > _downward_boundary_ids
 Downward boundary interfaces for each layer of elevation. More...
 
const Real _twist_pitch
 Axial pitch for a full rotation. More...
 
MooseMesh *const _mesh
 Pointer to the owning mesh. More...
 
const bool & _enabled
 Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects. More...
 
MooseApp & _app
 The MOOSE application this is associated with. More...
 
const std::string _type
 The type of this class. More...
 
const std::string _name
 The name of this class. More...
 
const InputParameters & _pars
 Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...
 
Factory & _factory
 The Factory associated with the MooseApp. More...
 
ActionFactory & _action_factory
 Builds Actions. More...
 
const Parallel::Communicator & _communicator
 

Detailed Description

Extrudes a mesh to another dimension.

Definition at line 19 of file AdvancedExtruderGenerator.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName
inherited

The parameter type this interface expects for a data file name.

Definition at line 27 of file DataFileInterface.h.

Constructor & Destructor Documentation

◆ AdvancedExtruderGenerator()

AdvancedExtruderGenerator::AdvancedExtruderGenerator ( const InputParameters &  parameters)

Definition at line 134 of file AdvancedExtruderGenerator.C.

135  : MeshGenerator(parameters),
136  _input(getMesh("input")),
137  _heights(getParam<std::vector<Real>>("heights")),
138  _biases(isParamValid("biases") ? getParam<std::vector<Real>>("biases")
139  : std::vector<Real>(_heights.size(), 1.0)),
140  _num_layers(getParam<std::vector<unsigned int>>("num_layers")),
141  _subdomain_swaps(getParam<std::vector<std::vector<subdomain_id_type>>>("subdomain_swaps")),
142  _boundary_swaps(getParam<std::vector<std::vector<boundary_id_type>>>("boundary_swaps")),
143  _elem_integer_names_to_swap(getParam<std::vector<std::string>>("elem_integer_names_to_swap")),
144  _elem_integers_swaps(
145  getParam<std::vector<std::vector<std::vector<dof_id_type>>>>("elem_integers_swaps")),
146  _direction(getParam<Point>("direction")),
147  _has_top_boundary(isParamValid("top_boundary")),
148  _top_boundary(isParamValid("top_boundary") ? getParam<BoundaryName>("top_boundary") : "0"),
149  _has_bottom_boundary(isParamValid("bottom_boundary")),
150  _bottom_boundary(isParamValid("bottom_boundary") ? getParam<BoundaryName>("bottom_boundary")
151  : "0"),
152  _upward_boundary_source_blocks(
153  isParamValid("upward_boundary_source_blocks")
154  ? getParam<std::vector<std::vector<subdomain_id_type>>>("upward_boundary_source_blocks")
155  : std::vector<std::vector<subdomain_id_type>>(_heights.size(),
156  std::vector<subdomain_id_type>())),
157  _upward_boundary_ids(
158  isParamValid("upward_boundary_ids")
159  ? getParam<std::vector<std::vector<boundary_id_type>>>("upward_boundary_ids")
160  : std::vector<std::vector<boundary_id_type>>(_heights.size(),
161  std::vector<boundary_id_type>())),
162  _downward_boundary_source_blocks(isParamValid("downward_boundary_source_blocks")
163  ? getParam<std::vector<std::vector<subdomain_id_type>>>(
164  "downward_boundary_source_blocks")
165  : std::vector<std::vector<subdomain_id_type>>(
166  _heights.size(), std::vector<subdomain_id_type>())),
167  _downward_boundary_ids(
168  isParamValid("downward_boundary_ids")
169  ? getParam<std::vector<std::vector<boundary_id_type>>>("downward_boundary_ids")
170  : std::vector<std::vector<boundary_id_type>>(_heights.size(),
171  std::vector<boundary_id_type>())),
172  _twist_pitch(getParam<Real>("twist_pitch"))
173 {
174  if (!_direction.norm())
175  paramError("direction", "Must have some length!");
176 
177  // Normalize it
178  _direction /= _direction.norm();
179 
180  const auto num_elevations = _heights.size();
181 
182  if (_num_layers.size() != num_elevations)
183  paramError("heights", "The length of 'heights' and 'num_layers' must be the same in ", name());
184 
185  if (_subdomain_swaps.size() && (_subdomain_swaps.size() != num_elevations))
186  paramError("subdomain_swaps",
187  "If specified, 'subdomain_swaps' (" + std::to_string(_subdomain_swaps.size()) +
188  ") must be the same length as 'heights' (" + std::to_string(num_elevations) +
189  ") in ",
190  name());
191 
192  try
193  {
194  MooseMeshUtils::idSwapParametersProcessor(
195  name(), "subdomain_swaps", _subdomain_swaps, _subdomain_swap_pairs);
196  }
197  catch (const MooseException & e)
198  {
199  paramError("subdomain_swaps", e.what());
200  }
201 
202  if (_boundary_swaps.size() && (_boundary_swaps.size() != num_elevations))
203  paramError("boundary_swaps",
204  "If specified, 'boundary_swaps' (" + std::to_string(_boundary_swaps.size()) +
205  ") must be the same length as 'heights' (" + std::to_string(num_elevations) +
206  ") in ",
207  name());
208 
209  try
210  {
211  MooseMeshUtils::idSwapParametersProcessor(
212  name(), "boundary_swaps", _boundary_swaps, _boundary_swap_pairs);
213  }
214  catch (const MooseException & e)
215  {
216  paramError("boundary_swaps", e.what());
217  }
218 
219  if (_elem_integers_swaps.size() &&
220  _elem_integers_swaps.size() != _elem_integer_names_to_swap.size())
221  paramError("elem_integers_swaps",
222  "If specified, 'elem_integers_swaps' must have the same length as the length of "
223  "'elem_integer_names_to_swap'.");
224 
225  for (const auto & unit_elem_integers_swaps : _elem_integers_swaps)
226  if (unit_elem_integers_swaps.size() != num_elevations)
227  paramError("elem_integers_swaps",
228  "If specified, each element of 'elem_integers_swaps' must have the same length as "
229  "the length of 'heights'.");
230 
231  try
232  {
233  MooseMeshUtils::extraElemIntegerSwapParametersProcessor(name(),
234  num_elevations,
235  _elem_integer_names_to_swap.size(),
236  _elem_integers_swaps,
237  _elem_integers_swap_pairs);
238  }
239  catch (const MooseException & e)
240  {
241  paramError("elem_integers_swaps", e.what());
242  }
243 
244  bool has_negative_entry = false;
245  bool has_positive_entry = false;
246  for (const auto & h : _heights)
247  {
248  if (h > 0.0)
249  has_positive_entry = true;
250  else
251  has_negative_entry = true;
252  }
253 
254  if (has_negative_entry && has_positive_entry)
255  paramError("heights", "Cannot have both positive and negative heights!");
256  if (_biases.size() != _heights.size())
257  paramError("biases", "Size of this parameter, if provided, must be the same as heights.");
258 
259  if (_upward_boundary_source_blocks.size() != _upward_boundary_ids.size() ||
260  _upward_boundary_ids.size() != num_elevations)
261  paramError("upward_boundary_ids",
262  "This parameter must have the same length (" +
263  std::to_string(_upward_boundary_ids.size()) +
264  ") as upward_boundary_source_blocks (" +
265  std::to_string(_upward_boundary_source_blocks.size()) + ") and heights (" +
266  std::to_string(num_elevations) + ")");
267  for (unsigned int i = 0; i < _upward_boundary_source_blocks.size(); i++)
268  if (_upward_boundary_source_blocks[i].size() != _upward_boundary_ids[i].size())
269  paramError("upward_boundary_ids",
270  "Every element of this parameter must have the same length as the corresponding "
271  "element of upward_boundary_source_blocks.");
272 
273  if (_downward_boundary_source_blocks.size() != _downward_boundary_ids.size() ||
274  _downward_boundary_ids.size() != num_elevations)
275  paramError("downward_boundary_ids",
276  "This parameter must have the same length (" +
277  std::to_string(_downward_boundary_ids.size()) +
278  ") as downward_boundary_source_blocks (" +
279  std::to_string(_downward_boundary_source_blocks.size()) + ") and heights (" +
280  std::to_string(num_elevations) + ")");
281  for (unsigned int i = 0; i < _downward_boundary_source_blocks.size(); i++)
282  if (_downward_boundary_source_blocks[i].size() != _downward_boundary_ids[i].size())
283  paramError("downward_boundary_ids",
284  "Every element of this parameter must have the same length as the corresponding "
285  "element of downward_boundary_source_blocks.");
286 }
AdvancedExtruderGenerator::_boundary_swap_pairs
std::vector< std::unordered_map< boundary_id_type, boundary_id_type > > _boundary_swap_pairs
Easier to work with version of _boundary_swaps.
Definition: AdvancedExtruderGenerator.h:58
AdvancedExtruderGenerator::_input
std::unique_ptr< MeshBase > & _input
Mesh that comes from another generator.
Definition: AdvancedExtruderGenerator.h:30
MooseException::what
virtual const char * what() const
Get out the error message.
Definition: MooseException.h:60
AdvancedExtruderGenerator::_direction
Point _direction
The direction of the extrusion.
Definition: AdvancedExtruderGenerator.h:64
AdvancedExtruderGenerator::_heights
const std::vector< Real > & _heights
Height of each elevation.
Definition: AdvancedExtruderGenerator.h:33
MeshGenerator::MeshGenerator
MeshGenerator(const InputParameters &parameters)
Definition: MeshGenerator.C:56
AdvancedExtruderGenerator::_twist_pitch
const Real _twist_pitch
Axial pitch for a full rotation.
Definition: AdvancedExtruderGenerator.h:85
AdvancedExtruderGenerator::_downward_boundary_source_blocks
const std::vector< std::vector< subdomain_id_type > > _downward_boundary_source_blocks
The list of input mesh&#39;s blocks that need to be assigned downward boundary interfaces for each layer ...
Definition: AdvancedExtruderGenerator.h:79
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
AdvancedExtruderGenerator::_upward_boundary_ids
const std::vector< std::vector< boundary_id_type > > _upward_boundary_ids
Upward boundary interfaces for each layer of elevation.
Definition: AdvancedExtruderGenerator.h:76
MooseBaseParameterInterface::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBaseParameterInterface.h:122
MeshGenerator::getMesh
std::unique_ptr< MeshBase > & getMesh(const std::string &param_name, const bool allow_invalid=false)
Takes the name of a MeshGeneratorName parameter and then gets a pointer to the Mesh that MeshGenerato...
Definition: MeshGenerator.C:172
AdvancedExtruderGenerator::_downward_boundary_ids
const std::vector< std::vector< boundary_id_type > > _downward_boundary_ids
Downward boundary interfaces for each layer of elevation.
Definition: AdvancedExtruderGenerator.h:82
MooseBaseParameterInterface::getParam
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBaseParameterInterface.h:215
MooseMeshUtils::idSwapParametersProcessor
void idSwapParametersProcessor(const std::string &class_name, const std::string &id_name, const std::vector< std::vector< T >> &id_swaps, std::vector< std::unordered_map< T, T >> &id_swap_pairs, const unsigned int row_index_shift=0)
Reprocess the swap related input parameters to make pairs out of them to ease further processing...
Definition: MooseMeshUtils.h:365
AdvancedExtruderGenerator::_subdomain_swap_pairs
std::vector< std::unordered_map< subdomain_id_type, subdomain_id_type > > _subdomain_swap_pairs
Easier to work with version of _sudomain_swaps.
Definition: AdvancedExtruderGenerator.h:55
MooseBaseParameterInterface::paramError
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition: MooseBaseParameterInterface.h:255
AdvancedExtruderGenerator::_subdomain_swaps
const std::vector< std::vector< subdomain_id_type > > & _subdomain_swaps
Subdomains to swap out for each elevation.
Definition: AdvancedExtruderGenerator.h:42
AdvancedExtruderGenerator::_boundary_swaps
const std::vector< std::vector< boundary_id_type > > & _boundary_swaps
Boundaries to swap out for each elevation.
Definition: AdvancedExtruderGenerator.h:45
MooseException
Provides a way for users to bail out of the current solve.
Definition: MooseException.h:20
AdvancedExtruderGenerator::_elem_integers_swaps
const std::vector< std::vector< std::vector< dof_id_type > > > & _elem_integers_swaps
Extra element integers to swap out for each elevation and each element interger name.
Definition: AdvancedExtruderGenerator.h:52
AdvancedExtruderGenerator::_biases
const std::vector< Real > _biases
Bias growth factor of each elevation.
Definition: AdvancedExtruderGenerator.h:36
MooseBaseParameterInterface::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBaseParameterInterface.h:62
AdvancedExtruderGenerator::_upward_boundary_source_blocks
const std::vector< std::vector< subdomain_id_type > > _upward_boundary_source_blocks
The list of input mesh&#39;s blocks that need to be assigned upward boundary interfaces for each layer of...
Definition: AdvancedExtruderGenerator.h:73
AdvancedExtruderGenerator::_num_layers
const std::vector< unsigned int > & _num_layers
Number of layers in each elevation.
Definition: AdvancedExtruderGenerator.h:39
MooseMeshUtils::extraElemIntegerSwapParametersProcessor
void extraElemIntegerSwapParametersProcessor(const std::string &class_name, const unsigned int num_sections, const unsigned int num_integers, const std::vector< std::vector< std::vector< dof_id_type >>> &elem_integers_swaps, std::vector< std::unordered_map< dof_id_type, dof_id_type >> &elem_integers_swap_pairs)
Reprocess the elem_integers_swaps into maps so they are easier to use.
Definition: MooseMeshUtils.C:552
AdvancedExtruderGenerator::_elem_integer_names_to_swap
const std::vector< std::string > & _elem_integer_names_to_swap
Names and indices of extra element integers to swap.
Definition: AdvancedExtruderGenerator.h:48
AdvancedExtruderGenerator::_elem_integers_swap_pairs
std::vector< std::unordered_map< dof_id_type, dof_id_type > > _elem_integers_swap_pairs
Easier to work with version of _elem_integers_swaps.
Definition: AdvancedExtruderGenerator.h:61

Member Function Documentation

◆ addChildMeshGenerator()

void MeshGenerator::addChildMeshGenerator ( const MeshGenerator &  mg,
const AddParentChildKey   
)
inherited

Adds the MeshGenerator mg as a child.

Protected by the AddParentChildKey so that parents can only be added by the MooseApp.

Definition at line 365 of file MeshGenerator.C.

366 {
367  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
368  _child_mesh_generators.insert(&mg);
369 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3463
MeshGenerator::_child_mesh_generators
std::set< const MeshGenerator *, Comparator > _child_mesh_generators
The MeshGenerators that are children to this MeshGenerator.
Definition: MeshGenerator.h:439
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84

◆ addMeshSubgenerator() [1/2]

template<typename... Ts>
void MeshGenerator::addMeshSubgenerator ( const std::string &  type,
const std::string &  name,
Ts...  extra_input_parameters 
)
protectedinherited

Construct a "subgenerator", a different MeshGenerator subclass that will be added to the same MooseApp on the fly.

Parameters
typeThe type of MeshGenerator
nameThe name of the MeshGenerator
extra_input_parameters... Additional InputParameters to pass

Sub generators must be added in the order that they are executed.

Any input dependencies for a sub generator that come from inputs for this generator must first be declared with the declareMesh(es)ForSub() method.

You can use the output of a sub generator as a mesh in this generator by calling getMesh() with the sub generator's name after adding said sub generator.

Definition at line 513 of file MeshGenerator.h.

Referenced by OverlayMeshGenerator::OverlayMeshGenerator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

516 {
517  InputParameters subgenerator_params = _app.getFactory().getValidParams(type);
518 
519  subgenerator_params.setParameters(extra_input_parameters...);
520 
521  addMeshSubgenerator(type, name, subgenerator_params);
522 }
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition: Factory.C:68
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Definition: InputParameters.h:66
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseApp::getFactory
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition: MooseApp.h:434
MeshGenerator::addMeshSubgenerator
void addMeshSubgenerator(const std::string &type, const std::string &name, Ts... extra_input_parameters)
Construct a "subgenerator", a different MeshGenerator subclass that will be added to the same MooseAp...
Definition: MeshGenerator.h:513
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:51
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
InputParameters::setParameters
void setParameters(const std::string &name, const T &value, Ts... extra_input_parameters)
Given a series of parameters names and values, sets each name to the corresponding value...
Definition: InputParameters.h:1447

◆ addMeshSubgenerator() [2/2]

void MeshGenerator::addMeshSubgenerator ( const std::string &  type,
const std::string &  name,
InputParameters  params 
)
protectedinherited

Construct a "subgenerator", as above.

User code is responsible for constructing valid InputParameters.

Parameters
typeThe type of MeshGenerator
nameThe name of the MeshGenerator
paramsThe parameters to use to construct the MeshGenerator

Definition at line 334 of file MeshGenerator.C.

337 {
338  if (!_app.constructingMeshGenerators())
339  mooseError("Can only call addMeshSubgenerator() during MeshGenerator construction");
340 
341  // In case the user forgot it
342  params.set<MooseApp *>("_moose_app") = &_app;
343 
344  // Set this to be data-only if this generator is data only
345  params.set<bool>(data_only_param) = isDataOnly();
346 
347  _app.addMeshGenerator(type, name, params);
348  _sub_mesh_generators.insert(&std::as_const(_app).getMeshGenerator(name));
349 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3463
MeshGenerator::data_only_param
static const std::string data_only_param
The name of the private parameter for setting data only.
Definition: MeshGenerator.h:62
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition: InputParameters.h:1428
MooseApp
Base class for MOOSE-based applications.
Definition: MooseApp.h:85
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:51
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
MeshGenerator::_sub_mesh_generators
std::set< const MeshGenerator *, Comparator > _sub_mesh_generators
The sub MeshGenerators constructed by this MeshGenerator.
Definition: MeshGenerator.h:441
MooseApp::addMeshGenerator
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.
Definition: MooseApp.h:883
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29
MeshGenerator::isDataOnly
bool isDataOnly() const
Definition: MeshGenerator.h:190

◆ addParentMeshGenerator()

void MeshGenerator::addParentMeshGenerator ( const MeshGenerator &  mg,
const AddParentChildKey   
)
inherited

Adds the MeshGenerator mg as a parent.

Protected by the AddParentChildKey so that parents can only be added by the MooseApp.

Definition at line 358 of file MeshGenerator.C.

359 {
360  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
361  _parent_mesh_generators.insert(&mg);
362 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3463
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
MeshGenerator::_parent_mesh_generators
std::set< const MeshGenerator *, Comparator > _parent_mesh_generators
The MeshGenerators that are parents to this MeshGenerator.
Definition: MeshGenerator.h:437

◆ buildDistributedMesh()

std::unique_ptr< DistributedMesh > MeshGenerator::buildDistributedMesh ( unsigned int  dim = libMesh::invalid_uint)
protectedinherited

Build a distributed mesh that has correct remote element removal behavior and geometric ghosting functors based on the simulation objects.

Parameters
dimThe logical dimension of the mesh, e.g. 3 for hexes/tets, 2 for quads/tris. If the caller doesn't specify a value for dim, then the value in the Mesh input file block will be used

Definition at line 253 of file MeshGenerator.C.

Referenced by DistributedRectilinearMeshGenerator::generate().

254 {
255  mooseAssert(_mesh, "Need a MooseMesh object");
256  return _mesh->buildTypedMesh<DistributedMesh>(dim);
257 }
Moose::dim
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:153
MeshGenerator::_mesh
MooseMesh *const _mesh
Pointer to the owning mesh.
Definition: MeshGenerator.h:388
MooseMesh::buildTypedMesh
std::unique_ptr< T > buildTypedMesh(unsigned int dim=libMesh::invalid_uint)
Shortcut method to construct a unique pointer to a libMesh mesh instance.
Definition: MooseMesh.h:2090

◆ buildMeshBaseObject()

std::unique_ptr< MeshBase > MeshGenerator::buildMeshBaseObject ( unsigned int  dim = libMesh::invalid_uint)
protectedinherited

Build a MeshBase object whose underlying type will be determined by the Mesh input file block.

Parameters
dimThe logical dimension of the mesh, e.g. 3 for hexes/tets, 2 for quads/tris. If the caller doesn't specify a value for dim, then the value in the Mesh input file block will be used

Definition at line 239 of file MeshGenerator.C.

Referenced by BlockToMeshConverterGenerator::generate(), ElementGenerator::generate(), FileMeshGenerator::generate(), SphereMeshGenerator::generate(), PolyLineMeshGenerator::generate(), ExamplePatchMeshGenerator::generate(), AnnularMeshGenerator::generate(), CartesianMeshGenerator::generate(), GeneratedMeshGenerator::generate(), generate(), MeshExtruderGenerator::generate(), and TransfiniteMeshGenerator::generate().

240 {
241  mooseAssert(_mesh, "Need a MooseMesh object");
242  return _mesh->buildMeshBaseObject(dim);
243 }
Moose::dim
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:153
MeshGenerator::_mesh
MooseMesh *const _mesh
Pointer to the owning mesh.
Definition: MeshGenerator.h:388
MooseMesh::buildMeshBaseObject
std::unique_ptr< MeshBase > buildMeshBaseObject(unsigned int dim=libMesh::invalid_uint)
Method to construct a libMesh::MeshBase object that is normally set and used by the MooseMesh object ...
Definition: MooseMesh.C:2851

◆ buildReplicatedMesh()

std::unique_ptr< ReplicatedMesh > MeshGenerator::buildReplicatedMesh ( unsigned int  dim = libMesh::invalid_uint)
protectedinherited

Build a replicated mesh.

Parameters
dimThe logical dimension of the mesh, e.g. 3 for hexes/tets, 2 for quads/tris. If the caller doesn't specify a value for dim, then the value in the Mesh input file block will be used

Definition at line 246 of file MeshGenerator.C.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), ConcentricCircleMeshGenerator::generate(), ImageMeshGenerator::generate(), ParsedCurveGenerator::generate(), RinglebMeshGenerator::generate(), and SpiralAnnularMeshGenerator::generate().

247 {
248  mooseAssert(_mesh, "Need a MooseMesh object");
249  return _mesh->buildTypedMesh<ReplicatedMesh>(dim);
250 }
Moose::dim
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:153
MeshGenerator::_mesh
MooseMesh *const _mesh
Pointer to the owning mesh.
Definition: MeshGenerator.h:388
MooseMesh::buildTypedMesh
std::unique_ptr< T > buildTypedMesh(unsigned int dim=libMesh::invalid_uint)
Shortcut method to construct a unique pointer to a libMesh mesh instance.
Definition: MooseMesh.h:2090

◆ callMooseError()

void MooseBase::callMooseError ( std::string  msg,
const bool  with_prefix 
) const
inherited

Calls moose error with the message msg.

Will prefix the message with the subapp name if one exists.

If with_prefix, then add the prefix from errorPrefix() to the error.

Definition at line 33 of file MooseBase.C.

Referenced by InputParameters::callMooseErrorHelper(), MooseBaseErrorInterface::mooseDocumentedError(), MooseBaseErrorInterface::mooseError(), MooseBaseErrorInterface::mooseErrorNonPrefixed(), and MooseBaseParameterInterface::paramError().

34 {
35  _app.getOutputWarehouse().mooseConsole();
36  const std::string prefix = _app.isUltimateMaster() ? "" : _app.name();
37  if (with_prefix)
38  msg = errorPrefix("error") + msg;
39  moose::internal::mooseErrorRaw(msg, prefix);
40 }
MooseApp::isUltimateMaster
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:847
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseBase::errorPrefix
std::string errorPrefix(const std::string &error_type) const
Definition: MooseBase.C:43
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
moose::internal::mooseErrorRaw
void mooseErrorRaw(std::string msg, const std::string prefix="")
Definition: MooseError.C:53
OutputWarehouse::mooseConsole
void mooseConsole()
Send current output buffer to Console output objects.
Definition: OutputWarehouse.C:199
MooseApp::getOutputWarehouse
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2381

◆ connectControllableParams()

void MooseBaseParameterInterface::connectControllableParams ( const std::string &  parameter,
const std::string &  object_type,
const std::string &  object_name,
const std::string &  object_parameter 
) const
inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters
parameterName of the controllable parameter of this action
object_typeType of the object added by this action.
object_nameName of the object added by this action.
object_parameterName of the parameter of the object.

Definition at line 33 of file MooseBaseParameterInterface.C.

37 {
38  MooseObjectParameterName primary_name(uniqueName(), parameter);
39  const auto base_type = _factory.getValidParams(object_type).get<std::string>("_moose_base");
40  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
41  _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
42  primary_name, secondary_name);
43 
44  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
45  for (const auto & tag : tags)
46  {
47  if (!tag.empty())
48  {
49  // Only adds the parameter with the different control tags if the derived class
50  // properly registers the parameter to its own syntax
51  MooseObjectParameterName tagged_name(tag, _moose_base.name(), parameter);
52  _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
53  tagged_name, secondary_name, /*error_on_empty=*/false);
54  }
55  }
56 }
InputParameterWarehouse::addControllableParameterConnection
void addControllableParameterConnection(const MooseObjectParameterName &primary, const MooseObjectParameterName &secondary, bool error_on_empty=true)
Method for linking control parameters of different names.
Definition: InputParameterWarehouse.C:173
MooseBaseParameterInterface::_moose_base
const MooseBase & _moose_base
The MooseBase object that inherits this class.
Definition: MooseBaseParameterInterface.h:183
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2172
MooseApp::getInputParameterWarehouse
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition: MooseApp.C:2839
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition: Factory.C:68
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseBase::getMooseApp
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:45
MooseBaseParameterInterface::_factory
Factory & _factory
The Factory associated with the MooseApp.
Definition: MooseBaseParameterInterface.h:176
MooseBaseParameterInterface::uniqueName
MooseObjectName uniqueName() const
The unique name for accessing input parameters of this object in the InputParameterWarehouse.
Definition: MooseBaseParameterInterface.h:67
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173
MooseObjectParameterName
A class for storing an input parameter name.
Definition: MooseObjectParameterName.h:26

◆ copyMeshProperty() [1/2]

template<typename T >
T& MeshGenerator::copyMeshProperty ( const std::string &  target_data_name,
const std::string &  source_data_name,
const std::string &  source_mesh 
)
inlineprotectedinherited

Method for copying attribute from input mesh meta-data store to current mesh meta-data store.

This may often be avoided as getMeshProperty calls can traverse the tree of mesh generators to find a metadata instance

Definition at line 233 of file MeshGenerator.h.

236  {
237  return declareMeshProperty(target_data_name, getMeshProperty<T>(source_data_name, source_mesh));
238  }
MeshGenerator::declareMeshProperty
T & declareMeshProperty(const std::string &data_name, Args &&... args)
Methods for writing out attributes to the mesh meta-data store, which can be retrieved from most othe...
Definition: MeshGenerator.h:455

◆ copyMeshProperty() [2/2]

template<typename T >
T& MeshGenerator::copyMeshProperty ( const std::string &  source_data_name,
const std::string &  source_mesh 
)
inlineprotectedinherited

Method for copying attribute from input mesh meta-data store to current mesh meta-data store, keeping source and target data names the same.

This may often be avoided as getMeshProperty calls can traverse the tree of mesh generators to find a metadata instance

Definition at line 246 of file MeshGenerator.h.

247  {
248  return copyMeshProperty<T>(source_data_name, source_data_name, source_mesh);
249  }

◆ declareMeshesForSub()

void MeshGenerator::declareMeshesForSub ( const std::string &  param_name)
protectedinherited

Like declareMeshForSub(), but for multiple generators.

Definition at line 215 of file MeshGenerator.C.

216 {
217  declareMeshesForSubByName(getMeshGeneratorNamesFromParam(param_name));
218 }
MeshGenerator::declareMeshesForSubByName
void declareMeshesForSubByName(const std::vector< MeshGeneratorName > &mesh_generator_names)
Like declareMeshForSubByName(), but for multiple generators.
Definition: MeshGenerator.C:231
MeshGenerator::getMeshGeneratorNamesFromParam
const std::vector< MeshGeneratorName > & getMeshGeneratorNamesFromParam(const std::string &param_name) const
Helper for getting a std::vector<MeshGeneratorName> parameter.
Definition: MeshGenerator.C:121

◆ declareMeshesForSubByName()

void MeshGenerator::declareMeshesForSubByName ( const std::vector< MeshGeneratorName > &  mesh_generator_names)
protectedinherited

Like declareMeshForSubByName(), but for multiple generators.

Definition at line 231 of file MeshGenerator.C.

Referenced by MeshGenerator::declareMeshesForSub().

233 {
234  for (const auto & name : mesh_generator_names)
235  declareMeshForSubByName(name);
236 }
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MeshGenerator::declareMeshForSubByName
void declareMeshForSubByName(const MeshGeneratorName &mesh_generator_name)
Like declareMeshForSub(), but takes the name of another MeshGenerator directly.
Definition: MeshGenerator.C:221

◆ declareMeshForSub()

void MeshGenerator::declareMeshForSub ( const std::string &  param_name)
protectedinherited

Declares that a MeshGenerator referenced in the InputParameters is to be used as a dependency of a sub MeshGenerator created by this MeshGenerator (see addSubMeshGenerator)

You must declare all such MeshGenerators that are passed by parameter to this MeshGenerator but instead used in a sub MeshGenerator. This is in order to declare the intention to use an input mesh as a dependency for a sub generator instead of this one.

Definition at line 209 of file MeshGenerator.C.

Referenced by OverlayMeshGenerator::OverlayMeshGenerator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

210 {
211  declareMeshForSubByName(*getMeshGeneratorNameFromParam(param_name, false));
212 }
MeshGenerator::declareMeshForSubByName
void declareMeshForSubByName(const MeshGeneratorName &mesh_generator_name)
Like declareMeshForSub(), but takes the name of another MeshGenerator directly.
Definition: MeshGenerator.C:221
MeshGenerator::getMeshGeneratorNameFromParam
const MeshGeneratorName * getMeshGeneratorNameFromParam(const std::string &param_name, const bool allow_invalid) const
Helper for getting a MeshGeneratorName parameter.
Definition: MeshGenerator.C:92

◆ declareMeshForSubByName()

void MeshGenerator::declareMeshForSubByName ( const MeshGeneratorName &  mesh_generator_name)
protectedinherited

Like declareMeshForSub(), but takes the name of another MeshGenerator directly.

Definition at line 221 of file MeshGenerator.C.

Referenced by MeshGenerator::declareMeshesForSubByName(), and MeshGenerator::declareMeshForSub().

222 {
223  checkGetMesh(mesh_generator_name, "");
224  if (isNullMeshName(mesh_generator_name))
225  return;
226 
227  _requested_mesh_generators_for_sub.insert(mesh_generator_name);
228 }
MeshGenerator::isNullMeshName
bool isNullMeshName(const MeshGeneratorName &name) const
Definition: MeshGenerator.h:165
MeshGenerator::_requested_mesh_generators_for_sub
std::set< MeshGeneratorName > _requested_mesh_generators_for_sub
The names of the MeshGenerators that were requested in the declareMeshForSub methods.
Definition: MeshGenerator.h:428
MeshGenerator::checkGetMesh
void checkGetMesh(const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const
Helper for performing error checking in the getMesh methods.
Definition: MeshGenerator.C:144

◆ declareMeshProperty() [1/2]

template<typename T , typename... Args>
T & MeshGenerator::declareMeshProperty ( const std::string &  data_name,
Args &&...  args 
)
protectedinherited

Methods for writing out attributes to the mesh meta-data store, which can be retrieved from most other MOOSE systems and is recoverable.

Definition at line 455 of file MeshGenerator.h.

Referenced by AddMetaDataGenerator::AddMetaDataGenerator(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), MeshGenerator::copyMeshProperty(), DistributedRectilinearMeshGenerator::DistributedRectilinearMeshGenerator(), ImageMeshGenerator::ImageMeshGenerator(), RinglebMeshGenerator::RinglebMeshGenerator(), and SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator().

456 {
457  if (!_app.constructingMeshGenerators())
458  mooseError("Can only call declareMeshProperty() during MeshGenerator construction");
459 
460  // We sort construction ordering so that we _must_ declare before retrieving
461  if (hasMeshProperty(data_name))
462  mooseError("While declaring mesh property '",
463  data_name,
464  "' with type '",
465  MooseUtils::prettyCppType<T>(),
466  "',\nsaid property has already been declared with type '",
467  setMeshPropertyHelper(data_name).type(),
468  "'");
469 
470  const auto full_name = meshPropertyName(data_name);
471  auto new_T_value =
472  std::make_unique<RestartableData<T>>(full_name, nullptr, std::forward<Args>(args)...);
473  auto value =
474  &_app.registerRestartableData(std::move(new_T_value), 0, false, MooseApp::MESH_META_DATA);
475  mooseAssert(value->declared(), "Should be declared");
476 
477  RestartableData<T> * T_value = dynamic_cast<RestartableData<T> *>(value);
478  mooseAssert(T_value, "Bad cast");
479 
480  return T_value->set();
481 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3463
MeshGenerator::setMeshPropertyHelper
RestartableDataValue & setMeshPropertyHelper(const std::string &data_name)
Helper for getting a writable reference to a mesh property, used in declareMeshProperty and setMeshPr...
Definition: MeshGenerator.C:352
MooseApp::MESH_META_DATA
static const RestartableDataMapName MESH_META_DATA
Definition: MooseApp.h:112
MeshMetaDataInterface::meshPropertyName
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
Definition: MeshMetaDataInterface.C:33
value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
MooseApp::registerRestartableData
RestartableDataValue & registerRestartableData(std::unique_ptr< RestartableDataValue > data, THREAD_ID tid, bool read_only, const RestartableDataMapName &metaname="")
Definition: MooseApp.C:2421
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
RestartableDataValue::type
virtual std::string type() const =0
String identifying the type of parameter stored.
RestartableData
Concrete definition of a parameter value for a specified type.
Definition: RestartableData.h:215
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition: MeshMetaDataInterface.C:25

◆ declareMeshProperty() [2/2]

template<typename T >
T& MeshGenerator::declareMeshProperty ( const std::string &  data_name,
const T &  data_value 
)
inlineprotectedinherited

Definition at line 206 of file MeshGenerator.h.

207  {
208  return declareMeshProperty<T, const T &>(data_name, data_value);
209  }

◆ declareNullMeshName()

void MeshGenerator::declareNullMeshName ( const MeshGeneratorName &  name)
protectedinherited

Registers the name name as a "null" mesh, which is a MeshGenerator used in InputParameters that will not represent an input mesh when requested via getMesh.

An example use case for this is when you as a developer want users to represent a hole in a mesh pattern that is defined in input.

Definition at line 398 of file MeshGenerator.C.

399 {
400  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
401  mooseAssert(!_null_mesh_names.count(name), "Already declared");
402  _null_mesh_names.insert(name);
403 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3463
MeshGenerator::_null_mesh_names
std::set< std::string > _null_mesh_names
The declared "null" mesh names that will not represent a mesh in input; see declareNullMeshName() ...
Definition: MeshGenerator.h:444
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84

◆ enabled()

virtual bool MooseObject::enabled ( ) const
inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 40 of file MooseObject.h.

Referenced by EigenKernel::enabled().

40 { return _enabled; }
MooseObject::_enabled
const bool & _enabled
Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.
Definition: MooseObject.h:51

◆ errorPrefix()

std::string MooseBase::errorPrefix ( const std::string &  error_type) const
inherited
Returns
A prefix to be used in errors that contains the input file location associated with this object (if any) and the name and type of the object.

Definition at line 43 of file MooseBase.C.

Referenced by MooseBase::callMooseError(), MooseBaseErrorInterface::mooseDeprecated(), MooseBaseErrorInterface::mooseInfo(), MooseBaseErrorInterface::mooseWarning(), and MooseBaseParameterInterface::paramErrorMsg().

44 {
45  std::stringstream oss;
46  if (const auto node = _params.getHitNode())
47  if (!node->isRoot())
48  oss << node->fileLocation() << ":\n";
49  oss << "The following " << error_type << " occurred in the ";
50  if (const auto base_ptr = _params.getBase())
51  oss << *base_ptr;
52  else
53  oss << "object";
54  oss << " '" << name() << "' of type " << type() << ".\n\n";
55  return oss.str();
56 }
InputParameters::getHitNode
const hit::Node * getHitNode(const std::string &param) const
Definition: InputParameters.C:1516
InputParameters::getBase
std::optional< std::string > getBase() const
Definition: InputParameters.C:495
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseBase::_params
const InputParameters & _params
The object&#39;s parameteres.
Definition: MooseBase.h:94
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:51

◆ generate()

std::unique_ptr< MeshBase > AdvancedExtruderGenerator::generate ( )
overridevirtual

Generate / modify the mesh.

Implements MeshGenerator.

Definition at line 289 of file AdvancedExtruderGenerator.C.

290 {
291  // Note: bulk of this code originally from libmesh mesh_modification.C
292  // Original copyright: Copyright (C) 2002-2019 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
293  // Original license is LGPL so it can be used here.
294 
295  auto mesh = buildMeshBaseObject(_input->mesh_dimension() + 1);
296  mesh->set_mesh_dimension(_input->mesh_dimension() + 1);
297 
298  // Check if the element integer names are existent in the input mesh.
299  for (unsigned int i = 0; i < _elem_integer_names_to_swap.size(); i++)
300  if (_input->has_elem_integer(_elem_integer_names_to_swap[i]))
301  _elem_integer_indices_to_swap.push_back(
302  _input->get_elem_integer_index(_elem_integer_names_to_swap[i]));
303  else
304  paramError("elem_integer_names_to_swap",
305  "Element ",
306  i + 1,
307  " of 'elem_integer_names_to_swap' in is not a valid extra element integer of the "
308  "input mesh.");
309 
310  // prepare for transferring extra element integers from original mesh to the extruded mesh.
311  const unsigned int num_extra_elem_integers = _input->n_elem_integers();
312  std::vector<std::string> id_names;
313 
314  for (unsigned int i = 0; i < num_extra_elem_integers; i++)
315  {
316  id_names.push_back(_input->get_elem_integer_name(i));
317  if (!mesh->has_elem_integer(id_names[i]))
318  mesh->add_elem_integer(id_names[i]);
319  }
320 
321  // retrieve subdomain/sideset/nodeset name maps
322  const auto & input_subdomain_map = _input->get_subdomain_name_map();
323  const auto & input_sideset_map = _input->get_boundary_info().get_sideset_name_map();
324  const auto & input_nodeset_map = _input->get_boundary_info().get_nodeset_name_map();
325 
326  // Check that the swaps source blocks are present in the mesh
327  for (const auto & swap : _subdomain_swaps)
328  for (const auto i : index_range(swap))
329  if (i % 2 == 0 && !MooseMeshUtils::hasSubdomainID(*_input, swap[i]))
330  paramError("subdomain_swaps", "The block '", swap[i], "' was not found within the mesh");
331 
332  // Check that the swaps source boundaries are present in the mesh
333  for (const auto & swap : _boundary_swaps)
334  for (const auto i : index_range(swap))
335  if (i % 2 == 0 && !MooseMeshUtils::hasBoundaryID(*_input, swap[i]))
336  paramError("boundary_swaps", "The boundary '", swap[i], "' was not found within the mesh");
337 
338  // Check that the source blocks for layer top/bottom boundaries exist in the mesh
339  for (const auto & layer_vec : _upward_boundary_source_blocks)
340  for (const auto bid : layer_vec)
341  if (!MooseMeshUtils::hasSubdomainID(*_input, bid))
342  paramError(
343  "upward_boundary_source_blocks", "The block '", bid, "' was not found within the mesh");
344  for (const auto & layer_vec : _downward_boundary_source_blocks)
345  for (const auto bid : layer_vec)
346  if (!MooseMeshUtils::hasSubdomainID(*_input, bid))
347  paramError("downward_boundary_source_blocks",
348  "The block '",
349  bid,
350  "' was not found within the mesh");
351 
352  std::unique_ptr<MeshBase> input = std::move(_input);
353 
354  // If we're using a distributed mesh... then make sure we don't have any remote elements hanging
355  // around
356  if (!input->is_serial())
357  mesh->delete_remote_elements();
358 
359  unsigned int total_num_layers = std::accumulate(_num_layers.begin(), _num_layers.end(), 0);
360 
361  auto total_num_elevations = _heights.size();
362 
363  dof_id_type orig_elem = input->n_elem();
364  dof_id_type orig_nodes = input->n_nodes();
365 
366 #ifdef LIBMESH_ENABLE_UNIQUE_ID
367  unique_id_type orig_unique_ids = input->parallel_max_unique_id();
368 #endif
369 
370  unsigned int order = 1;
371 
372  BoundaryInfo & boundary_info = mesh->get_boundary_info();
373  const BoundaryInfo & input_boundary_info = input->get_boundary_info();
374 
375  // Determine boundary IDs for the new user provided boundary names
376  std::vector<BoundaryName> new_boundary_names;
377  if (_has_bottom_boundary)
378  new_boundary_names.push_back(_bottom_boundary);
379  if (_has_top_boundary)
380  new_boundary_names.push_back(_top_boundary);
381  std::vector<boundary_id_type> new_boundary_ids =
382  MooseMeshUtils::getBoundaryIDs(*input, new_boundary_names, true);
383  const auto user_bottom_boundary_id =
384  _has_bottom_boundary ? new_boundary_ids.front() : libMesh::BoundaryInfo::invalid_id;
385  const auto user_top_boundary_id =
386  _has_top_boundary ? new_boundary_ids.back() : libMesh::BoundaryInfo::invalid_id;
387 
388  // We know a priori how many elements we'll need
389  mesh->reserve_elem(total_num_layers * orig_elem);
390 
391  // Look for higher order elements which introduce an extra layer
392  std::set<ElemType> higher_orders = {EDGE3, EDGE4, TRI6, TRI7, QUAD8, QUAD9};
393  bool extruding_quad_eights = false;
394  std::vector<ElemType> types;
395  MeshTools::elem_types(*input, types);
396  for (const auto elem_type : types)
397  {
398  if (higher_orders.count(elem_type))
399  order = 2;
400  if (elem_type == QUAD8)
401  extruding_quad_eights = true;
402  }
403  mesh->comm().max(order);
404  mesh->comm().max(extruding_quad_eights);
405 
406  // Reserve for the max number possibly needed
407  mesh->reserve_nodes((order * total_num_layers + 1) * orig_nodes);
408 
409  // Container to catch the boundary IDs handed back by the BoundaryInfo object
410  std::vector<boundary_id_type> ids_to_copy;
411 
412  Point old_distance;
413  Point current_distance;
414 
415  // Create translated layers of nodes in the direction of extrusion
416  for (const auto & node : input->node_ptr_range())
417  {
418  unsigned int current_node_layer = 0;
419 
420  old_distance.zero();
421 
422  // e is the elevation layer ordering
423  for (unsigned int e = 0; e < total_num_elevations; e++)
424  {
425  auto num_layers = _num_layers[e];
426 
427  auto height = _heights[e];
428 
429  auto bias = _biases[e];
430 
431  // k is the element layer ordering within each elevation layer
432  for (unsigned int k = 0; k < order * num_layers + (e == 0 ? 1 : 0); ++k)
433  {
434  // For the first layer we don't need to move
435  if (e == 0 && k == 0)
436  current_distance.zero();
437  else
438  {
439  // Shift the previous position by a certain fraction of 'height' along the extrusion
440  // direction to get the new position.
441  auto layer_index = (k - (e == 0 ? 1 : 0)) / order + 1;
442 
443  const auto step_size = MooseUtils::absoluteFuzzyEqual(bias, 1.0)
444  ? height / (Real)num_layers / (Real)order
445  : height * std::pow(bias, (Real)(layer_index - 1)) *
446  (1.0 - bias) /
447  (1.0 - std::pow(bias, (Real)(num_layers))) / (Real)order;
448 
449  current_distance = old_distance + _direction * step_size;
450 
451  // Handle helicoidal extrusion
452  if (!MooseUtils::absoluteFuzzyEqual(_twist_pitch, 0.))
453  {
454  // twist 1 should be 'normal' to the extruded shape
455  RealVectorValue twist1 = _direction.cross(*node);
456  // This happens for any node on the helicoidal extrusion axis
457  if (!MooseUtils::absoluteFuzzyEqual(twist1.norm(), .0))
458  twist1 /= twist1.norm();
459  const RealVectorValue twist2 = twist1.cross(_direction);
460 
461  auto twist = (cos(2. * libMesh::pi * layer_index * step_size / _twist_pitch) -
462  cos(2. * libMesh::pi * (layer_index - 1) * step_size / _twist_pitch)) *
463  twist2 +
464  (sin(2. * libMesh::pi * layer_index * step_size / _twist_pitch) -
465  sin(2. * libMesh::pi * (layer_index - 1) * step_size / _twist_pitch)) *
466  twist1;
467  twist *= std::sqrt(node->norm_sq() + libMesh::Utility::pow<2>(_direction * (*node)));
468  current_distance += twist;
469  }
470  }
471 
472  Node * new_node = mesh->add_point(*node + current_distance,
473  node->id() + (current_node_layer * orig_nodes),
474  node->processor_id());
475 
476 #ifdef LIBMESH_ENABLE_UNIQUE_ID
477  // Let's give the base of the extruded mesh the same
478  // unique_ids as the source mesh, in case anyone finds that
479  // a useful map to preserve.
480  const unique_id_type uid = (current_node_layer == 0)
481  ? node->unique_id()
482  : orig_unique_ids +
483  (current_node_layer - 1) * (orig_nodes + orig_elem) +
484  node->id();
485 
486  new_node->set_unique_id(uid);
487 #endif
488 
489  input_boundary_info.boundary_ids(node, ids_to_copy);
490  if (_boundary_swap_pairs.empty())
491  boundary_info.add_node(new_node, ids_to_copy);
492  else
493  for (const auto & id_to_copy : ids_to_copy)
494  {
495  boundary_info.add_node(new_node,
496  _boundary_swap_pairs[e].count(id_to_copy)
497  ? _boundary_swap_pairs[e][id_to_copy]
498  : id_to_copy);
499  }
500 
501  old_distance = current_distance;
502  current_node_layer++;
503  }
504  }
505  }
506 
507  const auto & side_ids = input_boundary_info.get_side_boundary_ids();
508 
509  boundary_id_type next_side_id =
510  side_ids.empty() ? 0 : cast_int<boundary_id_type>(*side_ids.rbegin() + 1);
511 
512  // side_ids may not include ids from remote elements, in which case
513  // some processors may have underestimated the next_side_id; let's
514  // fix that.
515  input->comm().max(next_side_id);
516 
517  for (const auto & elem : input->element_ptr_range())
518  {
519  const ElemType etype = elem->type();
520 
521  // build_extrusion currently only works on coarse meshes
522  libmesh_assert(!elem->parent());
523 
524  unsigned int current_layer = 0;
525 
526  for (unsigned int e = 0; e != total_num_elevations; e++)
527  {
528  auto num_layers = _num_layers[e];
529 
530  for (unsigned int k = 0; k != num_layers; ++k)
531  {
532  std::unique_ptr<Elem> new_elem;
533  bool is_flipped(false);
534  switch (etype)
535  {
536  case EDGE2:
537  {
538  new_elem = std::make_unique<Quad4>();
539  new_elem->set_node(
540  0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
541  new_elem->set_node(
542  1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
543  new_elem->set_node(
544  2, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
545  new_elem->set_node(
546  3, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
547 
548  if (elem->neighbor_ptr(0) == remote_elem)
549  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
550  if (elem->neighbor_ptr(1) == remote_elem)
551  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
552 
553  break;
554  }
555  case EDGE3:
556  {
557  new_elem = std::make_unique<Quad9>();
558  new_elem->set_node(
559  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
560  new_elem->set_node(
561  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
562  new_elem->set_node(
563  2,
564  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
565  new_elem->set_node(
566  3,
567  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
568  new_elem->set_node(
569  4, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
570  new_elem->set_node(
571  5,
572  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
573  new_elem->set_node(
574  6,
575  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
576  new_elem->set_node(
577  7,
578  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
579  new_elem->set_node(
580  8,
581  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
582 
583  if (elem->neighbor_ptr(0) == remote_elem)
584  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
585  if (elem->neighbor_ptr(1) == remote_elem)
586  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
587 
588  break;
589  }
590  case TRI3:
591  {
592  new_elem = std::make_unique<Prism6>();
593  new_elem->set_node(
594  0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
595  new_elem->set_node(
596  1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
597  new_elem->set_node(
598  2, mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * orig_nodes)));
599  new_elem->set_node(
600  3, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
601  new_elem->set_node(
602  4, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
603  new_elem->set_node(
604  5, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer + 1) * orig_nodes)));
605 
606  if (elem->neighbor_ptr(0) == remote_elem)
607  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
608  if (elem->neighbor_ptr(1) == remote_elem)
609  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
610  if (elem->neighbor_ptr(2) == remote_elem)
611  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
612 
613  if (new_elem->volume() < 0.0)
614  {
615  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
616  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
617  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
618  is_flipped = true;
619  }
620 
621  break;
622  }
623  case TRI6:
624  {
625  new_elem = std::make_unique<Prism18>();
626  new_elem->set_node(
627  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
628  new_elem->set_node(
629  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
630  new_elem->set_node(
631  2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
632  new_elem->set_node(
633  3,
634  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
635  new_elem->set_node(
636  4,
637  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
638  new_elem->set_node(
639  5,
640  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
641  new_elem->set_node(
642  6, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
643  new_elem->set_node(
644  7, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
645  new_elem->set_node(
646  8, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
647  new_elem->set_node(
648  9,
649  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
650  new_elem->set_node(
651  10,
652  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
653  new_elem->set_node(
654  11,
655  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
656  new_elem->set_node(
657  12,
658  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
659  new_elem->set_node(
660  13,
661  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
662  new_elem->set_node(
663  14,
664  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
665  new_elem->set_node(
666  15,
667  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
668  new_elem->set_node(
669  16,
670  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
671  new_elem->set_node(
672  17,
673  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
674 
675  if (elem->neighbor_ptr(0) == remote_elem)
676  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
677  if (elem->neighbor_ptr(1) == remote_elem)
678  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
679  if (elem->neighbor_ptr(2) == remote_elem)
680  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
681 
682  if (new_elem->volume() < 0.0)
683  {
684  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
685  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
686  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
687  MooseMeshUtils::swapNodesInElem(*new_elem, 6, 12);
688  MooseMeshUtils::swapNodesInElem(*new_elem, 7, 13);
689  MooseMeshUtils::swapNodesInElem(*new_elem, 8, 14);
690  is_flipped = true;
691  }
692 
693  break;
694  }
695  case TRI7:
696  {
697  new_elem = std::make_unique<Prism21>();
698  new_elem->set_node(
699  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
700  new_elem->set_node(
701  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
702  new_elem->set_node(
703  2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
704  new_elem->set_node(
705  3,
706  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
707  new_elem->set_node(
708  4,
709  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
710  new_elem->set_node(
711  5,
712  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
713  new_elem->set_node(
714  6, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
715  new_elem->set_node(
716  7, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
717  new_elem->set_node(
718  8, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
719  new_elem->set_node(
720  9,
721  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
722  new_elem->set_node(
723  10,
724  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
725  new_elem->set_node(
726  11,
727  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
728  new_elem->set_node(
729  12,
730  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
731  new_elem->set_node(
732  13,
733  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
734  new_elem->set_node(
735  14,
736  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
737  new_elem->set_node(
738  15,
739  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
740  new_elem->set_node(
741  16,
742  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
743  new_elem->set_node(
744  17,
745  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
746  new_elem->set_node(
747  18, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
748  new_elem->set_node(
749  19,
750  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
751  new_elem->set_node(
752  20,
753  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 1) * orig_nodes)));
754 
755  if (elem->neighbor_ptr(0) == remote_elem)
756  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
757  if (elem->neighbor_ptr(1) == remote_elem)
758  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
759  if (elem->neighbor_ptr(2) == remote_elem)
760  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
761 
762  if (new_elem->volume() < 0.0)
763  {
764  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
765  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
766  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
767  MooseMeshUtils::swapNodesInElem(*new_elem, 6, 12);
768  MooseMeshUtils::swapNodesInElem(*new_elem, 7, 13);
769  MooseMeshUtils::swapNodesInElem(*new_elem, 8, 14);
770  MooseMeshUtils::swapNodesInElem(*new_elem, 18, 19);
771  is_flipped = true;
772  }
773 
774  break;
775  }
776  case QUAD4:
777  {
778  new_elem = std::make_unique<Hex8>();
779  new_elem->set_node(
780  0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
781  new_elem->set_node(
782  1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
783  new_elem->set_node(
784  2, mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * orig_nodes)));
785  new_elem->set_node(
786  3, mesh->node_ptr(elem->node_ptr(3)->id() + (current_layer * orig_nodes)));
787  new_elem->set_node(
788  4, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
789  new_elem->set_node(
790  5, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
791  new_elem->set_node(
792  6, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer + 1) * orig_nodes)));
793  new_elem->set_node(
794  7, mesh->node_ptr(elem->node_ptr(3)->id() + ((current_layer + 1) * orig_nodes)));
795 
796  if (elem->neighbor_ptr(0) == remote_elem)
797  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
798  if (elem->neighbor_ptr(1) == remote_elem)
799  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
800  if (elem->neighbor_ptr(2) == remote_elem)
801  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
802  if (elem->neighbor_ptr(3) == remote_elem)
803  new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
804 
805  if (new_elem->volume() < 0.0)
806  {
807  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
808  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
809  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
810  MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
811  is_flipped = true;
812  }
813 
814  break;
815  }
816  case QUAD8:
817  {
818  new_elem = std::make_unique<Hex20>();
819  new_elem->set_node(
820  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
821  new_elem->set_node(
822  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
823  new_elem->set_node(
824  2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
825  new_elem->set_node(
826  3, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
827  new_elem->set_node(
828  4,
829  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
830  new_elem->set_node(
831  5,
832  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
833  new_elem->set_node(
834  6,
835  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
836  new_elem->set_node(
837  7,
838  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
839  new_elem->set_node(
840  8, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
841  new_elem->set_node(
842  9, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
843  new_elem->set_node(
844  10, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
845  new_elem->set_node(
846  11, mesh->node_ptr(elem->node_ptr(7)->id() + (2 * current_layer * orig_nodes)));
847  new_elem->set_node(
848  12,
849  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
850  new_elem->set_node(
851  13,
852  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
853  new_elem->set_node(
854  14,
855  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
856  new_elem->set_node(
857  15,
858  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
859  new_elem->set_node(
860  16,
861  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
862  new_elem->set_node(
863  17,
864  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
865  new_elem->set_node(
866  18,
867  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
868  new_elem->set_node(
869  19,
870  mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 2) * orig_nodes)));
871 
872  if (elem->neighbor_ptr(0) == remote_elem)
873  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
874  if (elem->neighbor_ptr(1) == remote_elem)
875  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
876  if (elem->neighbor_ptr(2) == remote_elem)
877  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
878  if (elem->neighbor_ptr(3) == remote_elem)
879  new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
880 
881  if (new_elem->volume() < 0.0)
882  {
883  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
884  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
885  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
886  MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
887  MooseMeshUtils::swapNodesInElem(*new_elem, 8, 16);
888  MooseMeshUtils::swapNodesInElem(*new_elem, 9, 17);
889  MooseMeshUtils::swapNodesInElem(*new_elem, 10, 18);
890  MooseMeshUtils::swapNodesInElem(*new_elem, 11, 19);
891  is_flipped = true;
892  }
893 
894  break;
895  }
896  case QUAD9:
897  {
898  new_elem = std::make_unique<Hex27>();
899  new_elem->set_node(
900  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
901  new_elem->set_node(
902  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
903  new_elem->set_node(
904  2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
905  new_elem->set_node(
906  3, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
907  new_elem->set_node(
908  4,
909  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
910  new_elem->set_node(
911  5,
912  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
913  new_elem->set_node(
914  6,
915  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
916  new_elem->set_node(
917  7,
918  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
919  new_elem->set_node(
920  8, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
921  new_elem->set_node(
922  9, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
923  new_elem->set_node(
924  10, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
925  new_elem->set_node(
926  11, mesh->node_ptr(elem->node_ptr(7)->id() + (2 * current_layer * orig_nodes)));
927  new_elem->set_node(
928  12,
929  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
930  new_elem->set_node(
931  13,
932  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
933  new_elem->set_node(
934  14,
935  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
936  new_elem->set_node(
937  15,
938  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
939  new_elem->set_node(
940  16,
941  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
942  new_elem->set_node(
943  17,
944  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
945  new_elem->set_node(
946  18,
947  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
948  new_elem->set_node(
949  19,
950  mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 2) * orig_nodes)));
951  new_elem->set_node(
952  20, mesh->node_ptr(elem->node_ptr(8)->id() + (2 * current_layer * orig_nodes)));
953  new_elem->set_node(
954  21,
955  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
956  new_elem->set_node(
957  22,
958  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
959  new_elem->set_node(
960  23,
961  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 1) * orig_nodes)));
962  new_elem->set_node(
963  24,
964  mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 1) * orig_nodes)));
965  new_elem->set_node(
966  25,
967  mesh->node_ptr(elem->node_ptr(8)->id() + ((2 * current_layer + 2) * orig_nodes)));
968  new_elem->set_node(
969  26,
970  mesh->node_ptr(elem->node_ptr(8)->id() + ((2 * current_layer + 1) * orig_nodes)));
971 
972  if (elem->neighbor_ptr(0) == remote_elem)
973  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
974  if (elem->neighbor_ptr(1) == remote_elem)
975  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
976  if (elem->neighbor_ptr(2) == remote_elem)
977  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
978  if (elem->neighbor_ptr(3) == remote_elem)
979  new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
980 
981  if (new_elem->volume() < 0.0)
982  {
983  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
984  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
985  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
986  MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
987  MooseMeshUtils::swapNodesInElem(*new_elem, 8, 16);
988  MooseMeshUtils::swapNodesInElem(*new_elem, 9, 17);
989  MooseMeshUtils::swapNodesInElem(*new_elem, 10, 18);
990  MooseMeshUtils::swapNodesInElem(*new_elem, 11, 19);
991  MooseMeshUtils::swapNodesInElem(*new_elem, 20, 25);
992  is_flipped = true;
993  }
994 
995  break;
996  }
997  default:
998  mooseError("Extrusion is not implemented for element type " + Moose::stringify(etype));
999  }
1000 
1001  new_elem->set_id(elem->id() + (current_layer * orig_elem));
1002  new_elem->processor_id() = elem->processor_id();
1003 
1004 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1005  // Let's give the base of the extruded mesh the same
1006  // unique_ids as the source mesh, in case anyone finds that
1007  // a useful map to preserve.
1008  const unique_id_type uid = (current_layer == 0)
1009  ? elem->unique_id()
1010  : orig_unique_ids +
1011  (current_layer - 1) * (orig_nodes + orig_elem) +
1012  orig_nodes + elem->id();
1013 
1014  new_elem->set_unique_id(uid);
1015 #endif
1016 
1017  // maintain the subdomain_id
1018  new_elem->subdomain_id() = elem->subdomain_id();
1019 
1020  // define upward boundaries
1021  if (k == num_layers - 1)
1022  {
1023  // Identify the side index of the new element that is part of the upward boundary
1024  const unsigned short top_id =
1025  new_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1026  // Assign sideset id to the side if the element belongs to a specified
1027  // upward_boundary_source_blocks
1028  for (unsigned int i = 0; i < _upward_boundary_source_blocks[e].size(); i++)
1029  if (new_elem->subdomain_id() == _upward_boundary_source_blocks[e][i])
1030  boundary_info.add_side(
1031  new_elem.get(), is_flipped ? 0 : top_id, _upward_boundary_ids[e][i]);
1032  }
1033  // define downward boundaries
1034  if (k == 0)
1035  {
1036  const unsigned short top_id =
1037  new_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1038  for (unsigned int i = 0; i < _downward_boundary_source_blocks[e].size(); i++)
1039  if (new_elem->subdomain_id() == _downward_boundary_source_blocks[e][i])
1040  boundary_info.add_side(
1041  new_elem.get(), is_flipped ? top_id : 0, _downward_boundary_ids[e][i]);
1042  }
1043 
1044  // perform subdomain swaps
1045  if (_subdomain_swap_pairs.size())
1046  {
1047  auto & elevation_swap_pairs = _subdomain_swap_pairs[e];
1048 
1049  auto new_id_it = elevation_swap_pairs.find(elem->subdomain_id());
1050 
1051  if (new_id_it != elevation_swap_pairs.end())
1052  new_elem->subdomain_id() = new_id_it->second;
1053  }
1054 
1055  Elem * added_elem = mesh->add_elem(std::move(new_elem));
1056 
1057  // maintain extra integers
1058  for (unsigned int i = 0; i < num_extra_elem_integers; i++)
1059  added_elem->set_extra_integer(i, elem->get_extra_integer(i));
1060 
1061  if (_elem_integers_swap_pairs.size())
1062  {
1063  for (unsigned int i = 0; i < _elem_integer_indices_to_swap.size(); i++)
1064  {
1065  auto & elevation_extra_swap_pairs = _elem_integers_swap_pairs[i * _heights.size() + e];
1066 
1067  auto new_extra_id_it = elevation_extra_swap_pairs.find(
1068  elem->get_extra_integer(_elem_integer_indices_to_swap[i]));
1069 
1070  if (new_extra_id_it != elevation_extra_swap_pairs.end())
1071  added_elem->set_extra_integer(_elem_integer_indices_to_swap[i],
1072  new_extra_id_it->second);
1073  }
1074  }
1075 
1076  // Copy any old boundary ids on all sides
1077  for (auto s : elem->side_index_range())
1078  {
1079  input_boundary_info.boundary_ids(elem, s, ids_to_copy);
1080 
1081  if (added_elem->dim() == 3)
1082  {
1083  // For 2D->3D extrusion, we give the boundary IDs
1084  // for side s on the old element to side s+1 on the
1085  // new element. This is just a happy coincidence as
1086  // far as I can tell...
1087  if (_boundary_swap_pairs.empty())
1088  boundary_info.add_side(added_elem, cast_int<unsigned short>(s + 1), ids_to_copy);
1089  else
1090  for (const auto & id_to_copy : ids_to_copy)
1091  boundary_info.add_side(added_elem,
1092  cast_int<unsigned short>(s + 1),
1093  _boundary_swap_pairs[e].count(id_to_copy)
1094  ? _boundary_swap_pairs[e][id_to_copy]
1095  : id_to_copy);
1096  }
1097  else
1098  {
1099  // For 1D->2D extrusion, the boundary IDs map as:
1100  // Old elem -> New elem
1101  // 0 -> 3
1102  // 1 -> 1
1103  libmesh_assert_less(s, 2);
1104  const unsigned short sidemap[2] = {3, 1};
1105  if (_boundary_swap_pairs.empty())
1106  boundary_info.add_side(added_elem, sidemap[s], ids_to_copy);
1107  else
1108  for (const auto & id_to_copy : ids_to_copy)
1109  boundary_info.add_side(added_elem,
1110  sidemap[s],
1111  _boundary_swap_pairs[e].count(id_to_copy)
1112  ? _boundary_swap_pairs[e][id_to_copy]
1113  : id_to_copy);
1114  }
1115  }
1116 
1117  // Give new boundary ids to bottom and top
1118  if (current_layer == 0)
1119  {
1120  const unsigned short top_id =
1121  added_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1122  if (_has_bottom_boundary)
1123  {
1124  mooseAssert(user_bottom_boundary_id != libMesh::BoundaryInfo::invalid_id,
1125  "We should have retrieved a proper boundary ID");
1126  boundary_info.add_side(added_elem, is_flipped ? top_id : 0, user_bottom_boundary_id);
1127  }
1128  else
1129  boundary_info.add_side(added_elem, is_flipped ? top_id : 0, next_side_id);
1130  }
1131 
1132  if (current_layer == total_num_layers - 1)
1133  {
1134  // For 2D->3D extrusion, the "top" ID is 1+the original
1135  // element's number of sides. For 1D->2D extrusion, the
1136  // "top" ID is side 2.
1137  const unsigned short top_id =
1138  added_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1139 
1140  if (_has_top_boundary)
1141  {
1142  mooseAssert(user_top_boundary_id != libMesh::BoundaryInfo::invalid_id,
1143  "We should have retrieved a proper boundary ID");
1144  boundary_info.add_side(added_elem, is_flipped ? 0 : top_id, user_top_boundary_id);
1145  }
1146  else
1147  boundary_info.add_side(
1148  added_elem, is_flipped ? 0 : top_id, cast_int<boundary_id_type>(next_side_id + 1));
1149  }
1150 
1151  current_layer++;
1152  }
1153  }
1154  }
1155 
1156 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1157  // Update the value of next_unique_id based on newly created nodes and elements
1158  // Note: Number of element layers is one less than number of node layers
1159  unsigned int total_new_node_layers = total_num_layers * order;
1160  unsigned int new_unique_ids = orig_unique_ids + (total_new_node_layers - 1) * orig_elem +
1161  total_new_node_layers * orig_nodes;
1162  mesh->set_next_unique_id(new_unique_ids);
1163 #endif
1164 
1165  // Copy all the subdomain/sideset/nodeset name maps to the extruded mesh
1166  if (!input_subdomain_map.empty())
1167  mesh->set_subdomain_name_map().insert(input_subdomain_map.begin(), input_subdomain_map.end());
1168  if (!input_sideset_map.empty())
1169  mesh->get_boundary_info().set_sideset_name_map().insert(input_sideset_map.begin(),
1170  input_sideset_map.end());
1171  if (!input_nodeset_map.empty())
1172  mesh->get_boundary_info().set_nodeset_name_map().insert(input_nodeset_map.begin(),
1173  input_nodeset_map.end());
1174 
1175  if (_has_bottom_boundary)
1176  boundary_info.sideset_name(new_boundary_ids.front()) = new_boundary_names.front();
1177  if (_has_top_boundary)
1178  boundary_info.sideset_name(new_boundary_ids.back()) = new_boundary_names.back();
1179 
1180  mesh->set_isnt_prepared();
1181  // Creating the layered meshes creates a lot of leftover nodes, notably in the boundary_info,
1182  // which will crash both paraview and trigger exodiff. Best to be safe.
1183  if (extruding_quad_eights)
1184  mesh->prepare_for_use();
1185 
1186  return mesh;
1187 }
MooseMeshUtils::swapNodesInElem
void swapNodesInElem(Elem &elem, const unsigned int nd1, const unsigned int nd2)
Swap two nodes within an element.
AdvancedExtruderGenerator::_boundary_swap_pairs
std::vector< std::unordered_map< boundary_id_type, boundary_id_type > > _boundary_swap_pairs
Easier to work with version of _boundary_swaps.
Definition: AdvancedExtruderGenerator.h:58
ElemType
ElemType
libMesh::MeshTools::elem_types
void elem_types(const MeshBase &mesh, std::vector< ElemType > &et)
AdvancedExtruderGenerator::_input
std::unique_ptr< MeshBase > & _input
Mesh that comes from another generator.
Definition: AdvancedExtruderGenerator.h:30
CompileTimeDerivatives::sin
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sin(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tan
VectorValue< Real >::norm
auto norm() const -> decltype(std::norm(Real()))
MooseUtils::absoluteFuzzyEqual
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:380
QUAD8
QUAD8
EDGE4
EDGE4
MooseUtils::swap
void swap(std::vector< T > &data, const std::size_t idx0, const std::size_t idx1, const libMesh::Parallel::Communicator &comm)
Swap function for serial or distributed vector of data.
Definition: Shuffle.h:494
AdvancedExtruderGenerator::_elem_integer_indices_to_swap
std::vector< unsigned int > _elem_integer_indices_to_swap
Definition: AdvancedExtruderGenerator.h:49
AdvancedExtruderGenerator::_direction
Point _direction
The direction of the extrusion.
Definition: AdvancedExtruderGenerator.h:64
mesh
MeshBase & mesh
AdvancedExtruderGenerator::_heights
const std::vector< Real > & _heights
Height of each elevation.
Definition: AdvancedExtruderGenerator.h:33
MooseMeshUtils::hasBoundaryID
bool hasBoundaryID(const MeshBase &input_mesh, const BoundaryID id)
Whether a particular boundary ID exists in the mesh.
AdvancedExtruderGenerator::_twist_pitch
const Real _twist_pitch
Axial pitch for a full rotation.
Definition: AdvancedExtruderGenerator.h:85
AdvancedExtruderGenerator::_downward_boundary_source_blocks
const std::vector< std::vector< subdomain_id_type > > _downward_boundary_source_blocks
The list of input mesh&#39;s blocks that need to be assigned downward boundary interfaces for each layer ...
Definition: AdvancedExtruderGenerator.h:79
TRI3
TRI3
AdvancedExtruderGenerator::_upward_boundary_ids
const std::vector< std::vector< boundary_id_type > > _upward_boundary_ids
Upward boundary interfaces for each layer of elevation.
Definition: AdvancedExtruderGenerator.h:76
QUAD4
QUAD4
MooseMeshUtils::hasSubdomainID
bool hasSubdomainID(const MeshBase &input_mesh, const SubdomainID &id)
Whether a particular subdomain ID exists in the mesh.
boundary_id_type
int8_t boundary_id_type
libMesh::BoundaryInfo::invalid_id
static const boundary_id_type invalid_id
CompileTimeDerivatives::cos
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template cos(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cos
TRI6
TRI6
AdvancedExtruderGenerator::_downward_boundary_ids
const std::vector< std::vector< boundary_id_type > > _downward_boundary_ids
Downward boundary interfaces for each layer of elevation.
Definition: AdvancedExtruderGenerator.h:82
libmesh_assert
libmesh_assert(ctx)
MooseMeshUtils::getBoundaryIDs
std::vector< BoundaryID > getBoundaryIDs(const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
Gets the boundary IDs with their names.
Definition: MooseMeshUtils.C:105
AdvancedExtruderGenerator::_subdomain_swap_pairs
std::vector< std::unordered_map< subdomain_id_type, subdomain_id_type > > _subdomain_swap_pairs
Easier to work with version of _sudomain_swaps.
Definition: AdvancedExtruderGenerator.h:55
MooseBaseParameterInterface::paramError
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition: MooseBaseParameterInterface.h:255
VectorValue< Real >::cross
TypeVector< typename CompareTypes< Real, T2 >::supertype > cross(const TypeVector< T2 > &v) const
Moose::stringify
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
AdvancedExtruderGenerator::_subdomain_swaps
const std::vector< std::vector< subdomain_id_type > > & _subdomain_swaps
Subdomains to swap out for each elevation.
Definition: AdvancedExtruderGenerator.h:42
AdvancedExtruderGenerator::_boundary_swaps
const std::vector< std::vector< boundary_id_type > > & _boundary_swaps
Boundaries to swap out for each elevation.
Definition: AdvancedExtruderGenerator.h:45
top_id
const boundary_id_type top_id
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
EDGE2
EDGE2
CompileTimeDerivatives::sqrt
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sqrt(_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh
AdvancedExtruderGenerator::_biases
const std::vector< Real > _biases
Bias growth factor of each elevation.
Definition: AdvancedExtruderGenerator.h:36
TRI7
TRI7
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29
QUAD9
QUAD9
AdvancedExtruderGenerator::_upward_boundary_source_blocks
const std::vector< std::vector< subdomain_id_type > > _upward_boundary_source_blocks
The list of input mesh&#39;s blocks that need to be assigned upward boundary interfaces for each layer of...
Definition: AdvancedExtruderGenerator.h:73
AdvancedExtruderGenerator::_num_layers
const std::vector< unsigned int > & _num_layers
Number of layers in each elevation.
Definition: AdvancedExtruderGenerator.h:39
MeshGenerator::buildMeshBaseObject
std::unique_ptr< MeshBase > buildMeshBaseObject(unsigned int dim=libMesh::invalid_uint)
Build a MeshBase object whose underlying type will be determined by the Mesh input file block...
Definition: MeshGenerator.C:239
EDGE3
EDGE3
AdvancedExtruderGenerator::_elem_integer_names_to_swap
const std::vector< std::string > & _elem_integer_names_to_swap
Names and indices of extra element integers to swap.
Definition: AdvancedExtruderGenerator.h:48
std::pow
MooseUnits pow(const MooseUnits &, int)
Definition: Units.C:537
unique_id_type
uint8_t unique_id_type
index_range
auto index_range(const T &sizable)
AdvancedExtruderGenerator::_elem_integers_swap_pairs
std::vector< std::unordered_map< dof_id_type, dof_id_type > > _elem_integers_swap_pairs
Easier to work with version of _elem_integers_swaps.
Definition: AdvancedExtruderGenerator.h:61
CompileTimeDerivatives::pow< 2 >
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template pow< 2 >(tan(_arg))+1.0) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(sqrt
dof_id_type
uint8_t dof_id_type
libMesh::pi
const Real pi
remote_elem
const RemoteElem * remote_elem

◆ generateData()

void MeshGenerator::generateData ( )
protectedvirtualinherited

Generate the mesh data.

Reimplemented in AddMetaDataGenerator.

Definition at line 424 of file MeshGenerator.C.

Referenced by MeshGenerator::generateInternal().

425 {
426  mooseAssert(!hasGenerateData(), "Inconsistent flag");
427  mooseError("This MeshGenerator does not have a generateData() implementation.");
428 }
MeshGenerator::hasGenerateData
bool hasGenerateData() const
Definition: MeshGenerator.h:185
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29

◆ generateInternal()

std::unique_ptr< MeshBase > MeshGenerator::generateInternal ( )
inherited

Internal generation method - this is what is actually called within MooseApp to execute the MeshGenerator.

Definition at line 260 of file MeshGenerator.C.

261 {
262  libmesh_parallel_only(comm());
263  mooseAssert(comm().verify(type() + name()), "Inconsistent execution ordering");
264 
265  if (hasGenerateData())
266  generateData();
267 
268  if (isDataOnly())
269  return nullptr;
270 
271  auto mesh = generate();
272  if (!mesh)
273  mooseError("A mesh was not generated by this generator (it was nullptr).");
274 
275  for (const auto & [requested_name, requested_mesh] : _requested_meshes)
276  if (*requested_mesh)
277  mooseError(
278  "The mesh from input ",
279  _app.getMeshGenerator(requested_name).type(),
280  " '",
281  _app.getMeshGenerator(requested_name).name(),
282  "' was not moved.\n\nThe MeshGenerator system requires that the memory from all input "
283  "meshes\nare managed by the requesting MeshGenerator during the generate phase.\n\nThis "
284  "is achieved with a std::move() operation within the generate() method.");
285 
286  if (getParam<bool>("show_info"))
287  {
288  const auto mesh_info = mesh->get_info(/* verbosity = */ 2);
289 
290  // We will prefix all information with "type() 'name()':" because this could potentially
291  // output a ton of information and looks a bit better with a prefix
292  std::stringstream oss;
293  const auto split = MooseUtils::split(mesh_info, "\n");
294  if (split.size())
295  for (std::size_t i = 0; i < split.size() - 1; ++i) // ignore the last line break
296  oss << COLOR_CYAN << "" << type() << " '" << name() << "': " << COLOR_DEFAULT << split[i]
297  << std::endl;
298  _console << oss.str() << std::flush;
299  }
300 
301  // output the current mesh block to file
302  if (hasOutput())
303  {
304  if (!mesh->is_prepared())
305  mesh->prepare_for_use();
306 
307  if (!getParam<bool>("nemesis"))
308  {
309  libMesh::ExodusII_IO exio(*mesh);
310 
311  if (mesh->mesh_dimension() == 1)
312  exio.write_as_dimension(3);
313 
314  // Default to non-HDF5 output for wider compatibility
315  exio.set_hdf5_writing(false);
316 
317  exio.write(name() + "_in.e");
318  }
319  else
320  {
321  libMesh::Nemesis_IO nemesis_io(*mesh);
322 
323  // Default to non-HDF5 output for wider compatibility
324  nemesis_io.set_hdf5_writing(false);
325 
326  nemesis_io.write(name() + "_in.e");
327  }
328  }
329 
330  return mesh;
331 }
MooseApp::getMeshGenerator
const MeshGenerator & getMeshGenerator(const std::string &name) const
Definition: MooseApp.h:901
libMesh::ExodusII_IO
MeshGenerator::generateData
virtual void generateData()
Generate the mesh data.
Definition: MeshGenerator.C:424
mesh
MeshBase & mesh
MeshGenerator::hasOutput
bool hasOutput() const
Definition: MeshGenerator.C:412
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
MeshGenerator::hasGenerateData
bool hasGenerateData() const
Definition: MeshGenerator.h:185
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseUtils::split
std::vector< std::string > split(const std::string &str, const std::string &delimiter, std::size_t max_count=std::numeric_limits< std::size_t >::max())
Python like split functions for strings.
Definition: MooseUtils.C:1126
MeshGenerator::_requested_meshes
std::vector< std::pair< std::string, std::unique_ptr< MeshBase > * > > _requested_meshes
The meshes that were requested by this MeshGenerator; used to verify that any input meshes that are r...
Definition: MeshGenerator.h:431
libMesh::Nemesis_IO
MeshGenerator::generate
virtual std::unique_ptr< MeshBase > generate()=0
Generate / modify the mesh.
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:51
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
split
tbb::split split
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
MeshGenerator::isDataOnly
bool isDataOnly() const
Definition: MeshGenerator.h:190

◆ getCheckedPointerParam()

template<typename T >
T MooseBaseParameterInterface::getCheckedPointerParam ( const std::string &  name,
const std::string &  error_string = "" 
) const
inherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 286 of file MooseBaseParameterInterface.h.

288 {
289  return parameters().getCheckedPointerParam<T>(name, error_string);
290 }
name
std::string name(const ElemQuality q)
InputParameters::getCheckedPointerParam
T getCheckedPointerParam(const std::string &name, const std::string &error_string="") const
Verifies that the requested parameter exists and is not NULL and returns it to the caller...
Definition: InputParameters.h:1612
MooseBaseParameterInterface::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBaseParameterInterface.h:62

◆ getChildMeshGenerators()

const std::set<const MeshGenerator *, Comparator>& MeshGenerator::getChildMeshGenerators ( ) const
inlineinherited

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 129 of file MeshGenerator.h.

Referenced by MeshGenerator::isChildMeshGenerator().

130  {
131  return _child_mesh_generators;
132  }
MeshGenerator::_child_mesh_generators
std::set< const MeshGenerator *, Comparator > _child_mesh_generators
The MeshGenerators that are children to this MeshGenerator.
Definition: MeshGenerator.h:439

◆ getDataFileName()

std::string DataFileInterface::getDataFileName ( const std::string &  param) const
inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

22 {
23  _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
24  "within the InputParameters.\nUse getParam<DataFileName>(\"",
25  param,
26  "\") instead.");
27  return _parent.getParam<DataFileName>(param);
28 }
MooseBaseErrorInterface::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Definition: MooseBaseErrorInterface.h:91
MooseBaseParameterInterface::getParam
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBaseParameterInterface.h:215
DataFileInterface::_parent
const ParallelParamObject & _parent
Definition: DataFileInterface.h:58

◆ getDataFileNameByName()

std::string DataFileInterface::getDataFileNameByName ( const std::string &  relative_path) const
inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

32 {
33  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
34  relative_path,
35  "\") instead.");
36  return getDataFilePath(relative_path);
37 }
DataFileInterface::getDataFilePath
std::string getDataFilePath(const std::string &relative_path) const
Returns the path of a data file for a given relative file path.
Definition: DataFileInterface.C:40
MooseBaseErrorInterface::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Definition: MooseBaseErrorInterface.h:91
DataFileInterface::_parent
const ParallelParamObject & _parent
Definition: DataFileInterface.h:58

◆ getDataFilePath()

std::string DataFileInterface::getDataFilePath ( const std::string &  relative_path) const
inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

Referenced by DataFileInterface::getDataFileNameByName().

41 {
42  // This should only ever be used with relative paths. There is no point to
43  // use this search path with an absolute path.
44  if (std::filesystem::path(relative_path).is_absolute())
45  _parent.mooseWarning("While using getDataFilePath(\"",
46  relative_path,
47  "\"): This API should not be used for absolute paths.");
48 
49  // Throw on error so that if getPath() fails, we can throw an error
50  // with the context of _parent.mooseError()
51  const auto throw_on_error_before = Moose::_throw_on_error;
52  Moose::_throw_on_error = true;
53  std::optional<std::string> error;
54 
55  // This will search the data paths for this relative path
56  Moose::DataFileUtils::Path found_path;
57  try
58  {
59  found_path = Moose::DataFileUtils::getPath(relative_path);
60  }
61  catch (std::exception & e)
62  {
63  error = e.what();
64  }
65 
66  Moose::_throw_on_error = throw_on_error_before;
67  if (error)
68  _parent.mooseError(*error);
69 
70  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
71  "Should only ever obtain data");
72  mooseAssert(found_path.data_name, "Should be set");
73 
74  const std::string msg =
75  "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
76  _parent.mooseInfo(msg);
77 
78  return found_path.path;
79 }
Moose::DataFileUtils::Path::context
Context context
Context for the file (where it came from)
Definition: DataFileUtils.h:48
MooseBaseErrorInterface::mooseInfo
void mooseInfo(Args &&... args) const
Definition: MooseBaseErrorInterface.h:98
MooseBaseErrorInterface::mooseWarning
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:75
Moose::DataFileUtils::Path
Representation of a data file path.
Definition: DataFileUtils.h:36
Moose::DataFileUtils::getPath
Path getPath(std::string path, const std::optional< std::string > &base=std::optional< std::string >())
Get the data path for a given path, searching the registered data.
Definition: DataFileUtils.C:22
Moose::DataFileUtils::Path::data_name
std::optional< std::string > data_name
The name of the data registry the file came from (with context == DATA)
Definition: DataFileUtils.h:50
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29
Moose::_throw_on_error
bool _throw_on_error
Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or wh...
Definition: Moose.C:758
DataFileInterface::_parent
const ParallelParamObject & _parent
Definition: DataFileInterface.h:58

◆ getMesh()

std::unique_ptr< MeshBase > & MeshGenerator::getMesh ( const std::string &  param_name,
const bool  allow_invalid = false 
)
protectedinherited

Takes the name of a MeshGeneratorName parameter and then gets a pointer to the Mesh that MeshGenerator is going to create.

That MeshGenerator is made to be a dependency of this one, so will generate() its mesh first.

Parameters
param_nameThe name of the parameter that contains the name of the MeshGenerator
allow_invalidIf true, will allow for invalid parameters and will return a nullptr mesh if said parameter does not exist
Returns
The Mesh generated by that MeshGenerator

NOTE: You MUST catch this by reference!

Definition at line 172 of file MeshGenerator.C.

173 {
174  const MeshGeneratorName * name = getMeshGeneratorNameFromParam(param_name, allow_invalid);
175  if (!name)
176  return _null_mesh;
177  return getMeshByName(*name);
178 }
MeshGenerator::getMeshByName
std::unique_ptr< MeshBase > & getMeshByName(const MeshGeneratorName &mesh_generator_name)
Like getMesh(), but takes the name of another MeshGenerator directly.
Definition: MeshGenerator.C:187
MeshGenerator::_null_mesh
std::unique_ptr< MeshBase > _null_mesh
A nullptr to use for when inputs aren&#39;t specified.
Definition: MeshGenerator.h:434
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MeshGenerator::getMeshGeneratorNameFromParam
const MeshGeneratorName * getMeshGeneratorNameFromParam(const std::string &param_name, const bool allow_invalid) const
Helper for getting a MeshGeneratorName parameter.
Definition: MeshGenerator.C:92

◆ getMeshByName()

std::unique_ptr< MeshBase > & MeshGenerator::getMeshByName ( const MeshGeneratorName &  mesh_generator_name)
protectedinherited

Like getMesh(), but takes the name of another MeshGenerator directly.

NOTE: You MUST catch this by reference!

Returns
The Mesh generated by that MeshGenerator

Definition at line 187 of file MeshGenerator.C.

Referenced by MeshGenerator::getMesh(), MeshGenerator::getMeshesByName(), OverlayMeshGenerator::OverlayMeshGenerator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

188 {
189  checkGetMesh(mesh_generator_name, "");
190  if (isNullMeshName(mesh_generator_name))
191  return _null_mesh;
192 
193  _requested_mesh_generators.insert(mesh_generator_name);
194  auto & mesh = _app.getMeshGeneratorSystem().getMeshGeneratorOutput(mesh_generator_name);
195  _requested_meshes.emplace_back(mesh_generator_name, &mesh);
196  return mesh;
197 }
MeshGeneratorSystem::getMeshGeneratorOutput
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.
Definition: MeshGeneratorSystem.C:570
mesh
MeshBase & mesh
MeshGenerator::_null_mesh
std::unique_ptr< MeshBase > _null_mesh
A nullptr to use for when inputs aren&#39;t specified.
Definition: MeshGenerator.h:434
MeshGenerator::isNullMeshName
bool isNullMeshName(const MeshGeneratorName &name) const
Definition: MeshGenerator.h:165
MeshGenerator::_requested_meshes
std::vector< std::pair< std::string, std::unique_ptr< MeshBase > * > > _requested_meshes
The meshes that were requested by this MeshGenerator; used to verify that any input meshes that are r...
Definition: MeshGenerator.h:431
MeshGenerator::_requested_mesh_generators
std::set< MeshGeneratorName > _requested_mesh_generators
The names of the MeshGenerators that were requested in the getMesh methods.
Definition: MeshGenerator.h:426
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
MeshGenerator::checkGetMesh
void checkGetMesh(const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const
Helper for performing error checking in the getMesh methods.
Definition: MeshGenerator.C:144
MooseApp::getMeshGeneratorSystem
MeshGeneratorSystem & getMeshGeneratorSystem()
Gets the system that manages the MeshGenerators.
Definition: MooseApp.h:867

◆ getMeshes()

std::vector< std::unique_ptr< MeshBase > * > MeshGenerator::getMeshes ( const std::string &  param_name)
protectedinherited

Like getMesh(), but for multiple generators.

Returns
The generated meshes

Definition at line 181 of file MeshGenerator.C.

182 {
183  return getMeshesByName(getMeshGeneratorNamesFromParam(param_name));
184 }
MeshGenerator::getMeshesByName
std::vector< std::unique_ptr< MeshBase > * > getMeshesByName(const std::vector< MeshGeneratorName > &mesh_generator_names)
Like getMeshByName(), but for multiple generators.
Definition: MeshGenerator.C:200
MeshGenerator::getMeshGeneratorNamesFromParam
const std::vector< MeshGeneratorName > & getMeshGeneratorNamesFromParam(const std::string &param_name) const
Helper for getting a std::vector<MeshGeneratorName> parameter.
Definition: MeshGenerator.C:121

◆ getMeshesByName()

std::vector< std::unique_ptr< MeshBase > * > MeshGenerator::getMeshesByName ( const std::vector< MeshGeneratorName > &  mesh_generator_names)
protectedinherited

Like getMeshByName(), but for multiple generators.

Returns
The generated meshes

Definition at line 200 of file MeshGenerator.C.

Referenced by MeshGenerator::getMeshes().

201 {
202  std::vector<std::unique_ptr<MeshBase> *> meshes;
203  for (const auto & name : mesh_generator_names)
204  meshes.push_back(&getMeshByName(name));
205  return meshes;
206 }
MeshGenerator::getMeshByName
std::unique_ptr< MeshBase > & getMeshByName(const MeshGeneratorName &mesh_generator_name)
Like getMesh(), but takes the name of another MeshGenerator directly.
Definition: MeshGenerator.C:187
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57

◆ getMeshProperty() [1/2]

template<typename T >
const T & MeshMetaDataInterface::getMeshProperty ( const std::string &  data_name,
const std::string &  prefix 
)
protectedinherited

Method for retrieving a property with the given type and name exists in the mesh meta-data store.

This method will throw an error if the property does not exist.

Definition at line 134 of file MeshMetaDataInterface.h.

136 {
137  if (!hasMeshProperty(data_name, prefix))
138  mooseErrorInternal("Failed to get mesh property '", prefix, "/", data_name, "'");
139 
140  auto value = &getMeshPropertyInternal(data_name, prefix);
141  mooseAssert(value->declared(), "Value has not been declared");
142  const RestartableData<T> * T_value = dynamic_cast<const RestartableData<T> *>(value);
143  if (!T_value)
144  mooseErrorInternal("While retrieving mesh property '",
145  prefix,
146  "/",
147  data_name,
148  "' with type '",
149  MooseUtils::prettyCppType<T>(),
150  "',\nthe property exists with different type '",
151  value->type(),
152  "'");
153  return T_value->get();
154 }
MeshMetaDataInterface::mooseErrorInternal
void mooseErrorInternal(Args &&... args) const
Helper for forwarding a mooseError to an object&#39;s mooseError if it is available (said error will prov...
Definition: MeshMetaDataInterface.h:124
value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
RestartableData
Concrete definition of a parameter value for a specified type.
Definition: RestartableData.h:215
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition: MeshMetaDataInterface.C:25
MeshMetaDataInterface::getMeshPropertyInternal
const RestartableDataValue & getMeshPropertyInternal(const std::string &data_name, const std::string &prefix) const
Helper for getting a mesh property.
Definition: MeshMetaDataInterface.C:46

◆ getMeshProperty() [2/2]

template<typename T >
const T& MeshMetaDataInterface::getMeshProperty ( const std::string &  data_name)
inlineprotectedinherited

Definition at line 56 of file MeshMetaDataInterface.h.

57  {
58  return getMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
59  }
MeshMetaDataInterface::meshPropertyPrefix
virtual std::string meshPropertyPrefix(const std::string &data_name) const
The default prefix to use for getting/seeing if mesh properties exist.
Definition: MeshMetaDataInterface.C:39

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const
inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), MooseBaseParameterInterface::connectControllableParams(), Coupleable::Coupleable(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), DefaultConvergenceBase::getSharedExecutionerParam(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

45 { return _app; }
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84

◆ getParam() [1/2]

template<typename T >
const T & MooseBaseParameterInterface::getParam ( const std::string &  name) const
inherited

Retrieve a parameter for the object.

Parameters
nameThe name of the parameter
Returns
The value of the parameter

Definition at line 215 of file MooseBaseParameterInterface.h.

Referenced by CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), DiffusionPhysicsBase::addPostprocessors(), ADNodalKernel::ADNodalKernel(), ArrayParsedAux::ArrayParsedAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), ComponentPhysicsInterface::ComponentPhysicsInterface(), FunctorAux::computeValue(), FEProblemBase::createTagSolutions(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), AccumulateReporter::declareLateValues(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ParsedSubdomainGeneratorBase::functionInitialize(), FVInterfaceKernel::FVInterfaceKernel(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), MeshExtruderGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), GhostingUserObject::GhostingUserObject(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), IterationAdaptiveDT::init(), AdvancedOutput::init(), AttribThread::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MultiSystemSolveObject::MultiSystemSolveObject(), NEML2ModelExecutor::NEML2ModelExecutor(), NestedDivision::NestedDivision(), ConsoleUtils::outputExecutionInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

216 {
217  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0), &_moose_base);
218 }
MooseBaseParameterInterface::_moose_base
const MooseBase & _moose_base
The MooseBase object that inherits this class.
Definition: MooseBaseParameterInterface.h:183
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173
InputParameters::getParamHelper
static const T & getParamHelper(const std::string &name, const InputParameters &pars, const T *the_type, const MooseBase *moose_base=nullptr)
Definition: InputParameters.h:2133

◆ getParam() [2/2]

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > > MooseBaseParameterInterface::getParam ( const std::string &  param1,
const std::string &  param2 
) const
inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters
param1The name of first parameter
param2The name of second parameter
Returns
Vector of pairs of first and second parameters

Definition at line 279 of file MooseBaseParameterInterface.h.

280 {
281  return _pars.get<T1, T2>(param1, param2);
282 }
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2172
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173

◆ getParentMeshGenerators()

const std::set<const MeshGenerator *, Comparator>& MeshGenerator::getParentMeshGenerators ( ) const
inlineinherited

Gets the MeshGenerators that are parents to this MeshGenerator.

Definition at line 122 of file MeshGenerator.h.

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder(), and MeshGenerator::isParentMeshGenerator().

123  {
124  return _parent_mesh_generators;
125  }
MeshGenerator::_parent_mesh_generators
std::set< const MeshGenerator *, Comparator > _parent_mesh_generators
The MeshGenerators that are parents to this MeshGenerator.
Definition: MeshGenerator.h:437

◆ getRenamedParam()

template<typename T >
const T & MooseBaseParameterInterface::getRenamedParam ( const std::string &  old_name,
const std::string &  new_name 
) const
inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters
old_namethe old name for the parameter
new_namethe new name for the parameter

Definition at line 229 of file MooseBaseParameterInterface.h.

231 {
232  // this enables having a default on the new parameter but bypassing it with the old one
233  // Most important: accept new parameter
234  if (isParamSetByUser(new_name) && !isParamValid(old_name))
235  return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
236  // Second most: accept old parameter
237  else if (isParamValid(old_name) && !isParamSetByUser(new_name))
238  return InputParameters::getParamHelper(old_name, _pars, static_cast<T *>(0), &_moose_base);
239  // Third most: accept default for new parameter
240  else if (isParamValid(new_name) && !isParamValid(old_name))
241  return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
242  // Refuse: no default, no value passed
243  else if (!isParamValid(old_name) && !isParamValid(new_name))
244  mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
245  "' is being retrieved without being set.\n"
246  "Did you misspell it?");
247  // Refuse: both old and new parameters set by user
248  else
249  mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
250  "' may not be provided alongside former parameter '" + old_name + "'");
251 }
MooseBaseParameterInterface::_moose_base
const MooseBase & _moose_base
The MooseBase object that inherits this class.
Definition: MooseBaseParameterInterface.h:183
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
MooseBaseParameterInterface::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBaseParameterInterface.h:122
MooseBaseParameterInterface::isParamSetByUser
bool isParamSetByUser(const std::string &nm) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
Definition: MooseBaseParameterInterface.h:128
InputParameters::blockFullpath
std::string blockFullpath() const
Definition: InputParameters.C:1508
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173
InputParameters::getParamHelper
static const T & getParamHelper(const std::string &name, const InputParameters &pars, const T *the_type, const MooseBase *moose_base=nullptr)
Definition: InputParameters.h:2133

◆ getRequestedMeshGenerators()

const std::set<MeshGeneratorName>& MeshGenerator::getRequestedMeshGenerators ( ) const
inlineinherited
Returns
The names of the MeshGenerators that were requested in the getMesh methods

Definition at line 80 of file MeshGenerator.h.

81  {
82  return _requested_mesh_generators;
83  }
MeshGenerator::_requested_mesh_generators
std::set< MeshGeneratorName > _requested_mesh_generators
The names of the MeshGenerators that were requested in the getMesh methods.
Definition: MeshGenerator.h:426

◆ getRequestedMeshGeneratorsForSub()

const std::set<MeshGeneratorName>& MeshGenerator::getRequestedMeshGeneratorsForSub ( ) const
inlineinherited
Returns
The names of the MeshGenerators that were requested in the declareMeshForSub methods

Definition at line 88 of file MeshGenerator.h.

89  {
90  return _requested_mesh_generators_for_sub;
91  }
MeshGenerator::_requested_mesh_generators_for_sub
std::set< MeshGeneratorName > _requested_mesh_generators_for_sub
The names of the MeshGenerators that were requested in the declareMeshForSub methods.
Definition: MeshGenerator.h:428

◆ getSavedMeshName()

const std::string & MeshGenerator::getSavedMeshName ( ) const
inherited

Return the name of the saved mesh.

Definition at line 418 of file MeshGenerator.C.

419 {
420  return _save_with_name;
421 }
MeshGenerator::_save_with_name
const std::string & _save_with_name
A user-defined name to save the mesh.
Definition: MeshGenerator.h:447

◆ getSharedPtr() [1/2]

std::shared_ptr< MooseObject > MooseObject::getSharedPtr ( )
inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 68 of file MooseObject.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), and MFEMProblem::addMFEMSolver().

69 {
70  try
71  {
72  return shared_from_this();
73  }
74  catch (std::bad_weak_ptr &)
75  {
76  mooseError(not_shared_error);
77  }
78 }
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29

◆ getSharedPtr() [2/2]

std::shared_ptr< const MooseObject > MooseObject::getSharedPtr ( ) const
inherited

Definition at line 81 of file MooseObject.C.

82 {
83  try
84  {
85  return shared_from_this();
86  }
87  catch (std::bad_weak_ptr &)
88  {
89  mooseError(not_shared_error);
90  }
91 }
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29

◆ getSubMeshGenerators()

const std::set<const MeshGenerator *, Comparator>& MeshGenerator::getSubMeshGenerators ( ) const
inlineinherited

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 136 of file MeshGenerator.h.

137  {
138  return _sub_mesh_generators;
139  }
MeshGenerator::_sub_mesh_generators
std::set< const MeshGenerator *, Comparator > _sub_mesh_generators
The sub MeshGenerators constructed by this MeshGenerator.
Definition: MeshGenerator.h:441

◆ hasGenerateData() [1/2]

bool MeshGenerator::hasGenerateData ( const InputParameters &  params)
staticinherited
Returns
Whether or not the mesh generator noted by the given parameters has a generateData() implementation

Definition at line 86 of file MeshGenerator.C.

87 {
88  return params.get<bool>("_has_generate_data");
89 }
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2172

◆ hasGenerateData() [2/2]

bool MeshGenerator::hasGenerateData ( ) const
inlineinherited
Returns
Whether or not this generator has a generateData() implementation

Definition at line 185 of file MeshGenerator.h.

Referenced by MeshGenerator::generateData(), MeshGenerator::generateInternal(), MeshGenerator::hasGenerateData(), and MeshGenerator::MeshGenerator().

185 { return hasGenerateData(_pars); }
MeshGenerator::hasGenerateData
bool hasGenerateData() const
Definition: MeshGenerator.h:185
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173

◆ hasMeshProperty() [1/4]

bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name,
const std::string &  prefix 
) const
protectedinherited
Returns
Whether or not a mesh meta-data exists.

Definition at line 25 of file MeshMetaDataInterface.C.

Referenced by MeshGenerator::declareMeshProperty(), MeshMetaDataInterface::getMeshProperty(), MeshMetaDataInterface::hasMeshProperty(), and MeshGenerator::setMeshProperty().

27 {
28  return _meta_data_app.hasRestartableMetaData(meshPropertyName(data_name, prefix),
29  MooseApp::MESH_META_DATA);
30 }
MooseApp::hasRestartableMetaData
bool hasRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname) const
Definition: MooseApp.C:2473
MooseApp::MESH_META_DATA
static const RestartableDataMapName MESH_META_DATA
Definition: MooseApp.h:112
MeshMetaDataInterface::meshPropertyName
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
Definition: MeshMetaDataInterface.C:33
MeshMetaDataInterface::_meta_data_app
MooseApp & _meta_data_app
Reference to the application.
Definition: MeshMetaDataInterface.h:114

◆ hasMeshProperty() [2/4]

template<typename T >
bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name,
const std::string &  prefix 
) const
protectedinherited
Returns
Whether or not a mesh meta-data exists with the given type.

Definition at line 158 of file MeshMetaDataInterface.h.

160 {
161  if (!hasMeshProperty(data_name, prefix))
162  return false;
163  const auto & value = getMeshPropertyInternal(data_name, prefix);
164  return dynamic_cast<const RestartableData<T> *>(&value) != nullptr;
165 }
value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
RestartableData
Concrete definition of a parameter value for a specified type.
Definition: RestartableData.h:215
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition: MeshMetaDataInterface.C:25
MeshMetaDataInterface::getMeshPropertyInternal
const RestartableDataValue & getMeshPropertyInternal(const std::string &data_name, const std::string &prefix) const
Helper for getting a mesh property.
Definition: MeshMetaDataInterface.C:46

◆ hasMeshProperty() [3/4]

bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name) const
inlineprotectedinherited
Returns
Whether or not a mesh meta-data exists with the default prefix.

Definition at line 74 of file MeshMetaDataInterface.h.

75  {
76  return hasMeshProperty(data_name, meshPropertyPrefix(data_name));
77  }
MeshMetaDataInterface::meshPropertyPrefix
virtual std::string meshPropertyPrefix(const std::string &data_name) const
The default prefix to use for getting/seeing if mesh properties exist.
Definition: MeshMetaDataInterface.C:39
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition: MeshMetaDataInterface.C:25

◆ hasMeshProperty() [4/4]

template<typename T >
bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name) const
inlineprotectedinherited
Returns
Whether or not a mesh meta-data exists with the default prefix and the given type.

Definition at line 82 of file MeshMetaDataInterface.h.

83  {
84  return hasMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
85  }
MeshMetaDataInterface::meshPropertyPrefix
virtual std::string meshPropertyPrefix(const std::string &data_name) const
The default prefix to use for getting/seeing if mesh properties exist.
Definition: MeshMetaDataInterface.C:39

◆ hasOutput()

bool MeshGenerator::hasOutput ( ) const
inherited
Returns
Whether or not to output this mesh generator separately (output parameter is set)

Definition at line 412 of file MeshGenerator.C.

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder(), and MeshGenerator::generateInternal().

413 {
414  return getParam<bool>("output");
415 }

◆ hasSaveMesh()

bool MeshGenerator::hasSaveMesh ( ) const
inherited

Return whether or not to save the current mesh.

Definition at line 406 of file MeshGenerator.C.

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder(), and MeshGenerator::MeshGenerator().

407 {
408  return _save_with_name.size();
409 }
MeshGenerator::_save_with_name
const std::string & _save_with_name
A user-defined name to save the mesh.
Definition: MeshGenerator.h:447

◆ isChildMeshGenerator()

bool MeshGenerator::isChildMeshGenerator ( const MeshGeneratorName &  name,
const bool  direct = true 
) const
inherited
Returns
Whether or not the MeshGenerator with the name name is a child of this MeshGenerator.

If direct = true, check only immediate children of this generator. Otherwise, check all children.

Definition at line 385 of file MeshGenerator.C.

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder().

387 {
388  return std::find_if(getChildMeshGenerators().begin(),
389  getChildMeshGenerators().end(),
390  [&name, &direct](const auto & mg)
391  {
392  return mg->name() == name ||
393  (!direct && mg->isChildMeshGenerator(name, /* direct = */ false));
394  }) != getChildMeshGenerators().end();
395 }
MeshGenerator::getChildMeshGenerators
const std::set< const MeshGenerator *, Comparator > & getChildMeshGenerators() const
Gets the MeshGenerators that are children to this MeshGenerator.
Definition: MeshGenerator.h:129
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57

◆ isDataOnly()

bool MeshGenerator::isDataOnly ( ) const
inlineinherited
Returns
Whether or not this generator is to be generated in data-only mode

Definition at line 190 of file MeshGenerator.h.

Referenced by MeshGenerator::addMeshSubgenerator(), MeshGenerator::generateInternal(), and MeshGenerator::MeshGenerator().

190 { return _data_only; }
MeshGenerator::_data_only
const bool _data_only
Whether or not this mesh generator will run in data only mode.
Definition: MeshGenerator.h:450

◆ isNullMeshName()

bool MeshGenerator::isNullMeshName ( const MeshGeneratorName &  name) const
inlineinherited
Returns
Whether or not the name name is registered as a "null" mesh, that is, a MeshGenerator that will not represent an input mesh when requested via getMesh.

See declareNullMeshName().

Definition at line 165 of file MeshGenerator.h.

Referenced by MeshGenerator::checkGetMesh(), MeshGenerator::declareMeshForSubByName(), and MeshGenerator::getMeshByName().

165 { return _null_mesh_names.count(name); }
MeshGenerator::_null_mesh_names
std::set< std::string > _null_mesh_names
The declared "null" mesh names that will not represent a mesh in input; see declareNullMeshName() ...
Definition: MeshGenerator.h:444
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57

◆ isParamSetByUser()

bool MooseBaseParameterInterface::isParamSetByUser ( const std::string &  nm) const
inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters
nmThe name of the parameter to test

Definition at line 128 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), LibtorchNeuralNetControl::conditionalParameterError(), DiffusionPhysicsBase::DiffusionPhysicsBase(), ElementSubdomainModifierBase::ElementSubdomainModifierBase(), MooseBaseParameterInterface::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MFEMSolverBase::setPreconditioner(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

128 { return _pars.isParamSetByUser(nm); }
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.
Definition: InputParameters.C:1178
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173

◆ isParamValid()

bool MooseBaseParameterInterface::isParamValid ( const std::string &  name) const
inlineinherited

Test if the supplied parameter is valid.

Parameters
nameThe name of the parameter to test

Definition at line 122 of file MooseBaseParameterInterface.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), CopyNodalVarsAction::act(), SetupMeshAction::act(), SetupDebugAction::act(), ComposeTimeStepperAction::act(), AddVariableAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), CommonOutputAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), DiffusionPhysicsBase::addPostprocessors(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinerGenerator::CombinerGenerator(), FunctorAux::computeValue(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), Eigenvalue::Eigenvalue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FieldSplitPreconditioner::FieldSplitPreconditioner(), FileOutput::FileOutput(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), AddMetaDataGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), BlockDeletionGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), MeshExtruderGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYZDelaunayGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBaseParameterInterface::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionScalarAux::initialSetup(), ParsedConvergence::initialSetup(), SolutionAux::initialSetup(), Console::initialSetup(), MooseParsedVectorFunction::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MatDiffusionBase< Real >::MatDiffusionBase(), MeshGeneratorComponent::MeshGeneratorComponent(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< Real >::MooseVariableFV(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ParsedCurveGenerator::ParsedCurveGenerator(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), MooseMesh::prepare(), MooseBaseParameterInterface::queryParam(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusII(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), Split::setup(), SideSetsGeneratorBase::setup(), SetupMeshAction::setupMesh(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), FEProblemSolve::solve(), WebServerControl::startServer(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

122 { return _pars.isParamValid(name); }
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173
InputParameters::isParamValid
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.
Definition: InputParameters.C:390

◆ isParentMeshGenerator()

bool MeshGenerator::isParentMeshGenerator ( const MeshGeneratorName &  name,
const bool  direct = true 
) const
inherited
Returns
Whether or not the MeshGenerator with the name name is a parent of this MeshGenerator.

If direct = true, check only immediate parents of this generator. Otherwise, check all parents.

Definition at line 372 of file MeshGenerator.C.

374 {
375  return std::find_if(getParentMeshGenerators().begin(),
376  getParentMeshGenerators().end(),
377  [&name, &direct](const auto & mg)
378  {
379  return mg->name() == name ||
380  (!direct && mg->isParentMeshGenerator(name, /* direct = */ false));
381  }) != getParentMeshGenerators().end();
382 }
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MeshGenerator::getParentMeshGenerators
const std::set< const MeshGenerator *, Comparator > & getParentMeshGenerators() const
Gets the MeshGenerators that are parents to this MeshGenerator.
Definition: MeshGenerator.h:122

◆ meshPropertyName() [1/2]

std::string MeshMetaDataInterface::meshPropertyName ( const std::string &  data_name,
const std::string &  prefix 
)
staticprotectedinherited
Returns
The full name for mesh property data.

Definition at line 33 of file MeshMetaDataInterface.C.

Referenced by MeshGenerator::declareMeshProperty(), MeshMetaDataInterface::getMeshPropertyInternal(), MeshMetaDataInterface::hasMeshProperty(), MeshMetaDataInterface::meshPropertyName(), and MeshGenerator::setMeshPropertyHelper().

34 {
35  return std::string(SYSTEM) + "/" + prefix + "/" + data_name;
36 }
MeshMetaDataInterface::SYSTEM
static constexpr auto SYSTEM
The system name used when initializing the Restartable interface.
Definition: MeshMetaDataInterface.h:30

◆ meshPropertyName() [2/2]

std::string MeshMetaDataInterface::meshPropertyName ( const std::string &  data_name) const
inlineprotectedinherited
Returns
The default mesh property name for mesh property data

Definition at line 95 of file MeshMetaDataInterface.h.

96  {
97  return meshPropertyName(data_name, meshPropertyPrefix(data_name));
98  }
MeshMetaDataInterface::meshPropertyName
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
Definition: MeshMetaDataInterface.C:33
MeshMetaDataInterface::meshPropertyPrefix
virtual std::string meshPropertyPrefix(const std::string &data_name) const
The default prefix to use for getting/seeing if mesh properties exist.
Definition: MeshMetaDataInterface.C:39

◆ mooseDeprecated()

template<typename... Args>
void MooseBaseErrorInterface::mooseDeprecated ( Args &&...  args) const
inlineinherited

Definition at line 91 of file MooseBaseErrorInterface.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), and UserForcingFunction::UserForcingFunction().

92  {
93  moose::internal::mooseDeprecatedStream(
94  _console, false, true, _moose_base.errorPrefix("deprecation"), std::forward<Args>(args)...);
95  }
MooseBase::errorPrefix
std::string errorPrefix(const std::string &error_type) const
Definition: MooseBase.C:43
MooseBaseErrorInterface::_moose_base
const MooseBase & _moose_base
The MooseBase class deriving from this interface.
Definition: MooseBaseErrorInterface.h:106
moose::internal::mooseDeprecatedStream
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, Args &&... args)
Definition: MooseError.h:239
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31

◆ mooseDocumentedError()

template<typename... Args>
void MooseBaseErrorInterface::mooseDocumentedError ( const std::string &  repo_name,
const unsigned int  issue_num,
Args &&...  args 
) const
inlineinherited

Emits a documented error with object name and type.

Documented errors are errors that have an issue associated with them.

The repository name repo_name links a named repository to a URL and should be registered at the application level with registerRepository(). See Moose.C for an example of the "moose" repository registration.

Parameters
repo_nameThe repository name where the issue resides
issue_numThe number of the issue
argsThe error message to be combined

Definition at line 61 of file MooseBaseErrorInterface.h.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

64  {
65  std::ostringstream oss;
66  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
67  const auto msg = moose::internal::formatMooseDocumentedError(repo_name, issue_num, oss.str());
68  _moose_base.callMooseError(msg, /* with_prefix = */ true);
69  }
moose::internal::mooseStreamAll
void mooseStreamAll(std::ostringstream &ss)
All of the following are not meant to be called directly - they are called by the normal macros (moos...
Definition: MooseError.C:94
MooseBaseErrorInterface::_moose_base
const MooseBase & _moose_base
The MooseBase class deriving from this interface.
Definition: MooseBaseErrorInterface.h:106
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix) const
Calls moose error with the message msg.
Definition: MooseBase.C:33
moose::internal::formatMooseDocumentedError
std::string formatMooseDocumentedError(const std::string &repo_name, const unsigned int issue_num, const std::string &msg)
Formats a documented error.
Definition: MooseError.C:99

◆ mooseError()

template<typename... Args>
void MooseBaseErrorInterface::mooseError ( Args &&...  args) const
inlineinherited

Emits an error prefixed with object name and type.

Definition at line 29 of file MooseBaseErrorInterface.h.

Referenced by CopyMeshPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), AutoCheckpointAction::act(), AddFVICAction::act(), CheckFVBCAction::act(), CreateExecutionerAction::act(), AddBoundsVectorsAction::act(), AddVectorPostprocessorAction::act(), InitProblemAction::act(), SetupMeshCompleteAction::act(), AddICAction::act(), AddMeshGeneratorAction::act(), CheckIntegrityAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), ChainControlSetupAction::act(), DeprecatedBlockAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), AddTimeStepperAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), SetAdaptivityOptionsAction::act(), MaterialOutputAction::act(), AddMFEMSubMeshAction::act(), CommonOutputAction::act(), AddPeriodicBCAction::act(), Action::Action(), FEProblemBase::adaptMesh(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), MooseVariableFV< Real >::adCurlSln(), MooseVariableFV< Real >::adCurlSlnNeighbor(), AddActionComponentAction::AddActionComponentAction(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DiffusionCG::addBoundaryConditionsFromComponents(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), DistributedRectilinearMeshGenerator::addElement(), FEProblemBase::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFVInitialCondition(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInitialCondition(), PhysicsComponentInterface::addInitialConditionsFromComponents(), FEProblemBase::addInterfaceKernel(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), MFEMProblem::addMaterial(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addOutput(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DiracKernelBase::addPoint(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addScalarKernel(), AddVariableAction::addVariable(), FEProblemBase::addVectorPostprocessor(), SubProblem::addVectorTag(), MooseLinearVariableFV< Real >::adError(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), AdvectiveFluxAux::AdvectiveFluxAux(), MooseVariableBase::allDofIndices(), NEML2ModelExecutor::applyPredictor(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), AddPeriodicBCAction::autoTranslationBoundaries(), AuxKernelTempl< Real >::AuxKernelTempl(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), TimedSubdomainModifier::buildFromParameters(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), MooseMesh::buildLowerDMesh(), TiledMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildSideList(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), FEProblemBase::checkExceptionAndStopSolve(), NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), ExplicitTimeIntegrator::checkLinearConvergence(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), Sampler::checkReinitStatus(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::checkSiblingsTransferSupported(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), FEProblemBase::checkUserObjects(), Moose::PetscSupport::checkUserProvidedPetscOption(), DomainUserObject::checkVariable(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), LibmeshPartitioner::clone(), MooseMesh::clone(), CombinerGenerator::CombinerGenerator(), ComparisonPostprocessor::comparisonIsTrue(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), FEProblemBase::computeBounds(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), InternalSideIntegralPostprocessor::computeFaceInfoIntegral(), SideIntegralPostprocessor::computeFaceInfoIntegral(), MooseVariableFieldBase::computeFaceValues(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), FVFluxKernel::computeJacobian(), NodalConstraint::computeJacobian(), FEProblemBase::computeJacobianTags(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), EigenProblem::computeMatricesTags(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), FVElementalKernel::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MaterialBase::computeProperties(), SideFVFluxBCIntegral::computeQpIntegral(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), NodalEqualValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), NodeElemConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), MassMatrix::computeQpResidual(), HDGKernel::computeQpResidual(), DiffusionLHDGDirichletBC::computeQpResidual(), NodalEqualValueConstraint::computeQpResidual(), DiffusionLHDGPrescribedGradientBC::computeQpResidual(), IPHDGBC::computeQpResidual(), KernelValue::computeQpResidual(), TorchScriptMaterial::computeQpValues(), InterfaceQpValueUserObject::computeRealValue(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FVFluxBC::computeResidual(), FVFluxKernel::computeResidual(), NodalConstraint::computeResidual(), FVFluxKernel::computeResidualAndJacobian(), ResidualObject::computeResidualAndJacobian(), FEProblemBase::computeResidualAndJacobian(), HDGKernel::computeResidualAndJacobianOnSide(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), KernelScalarBase::computeScalarOffDiagJacobian(), ADKernelScalarBase::computeScalarQpResidual(), ADMortarScalarBase::computeScalarQpResidual(), MortarScalarBase::computeScalarQpResidual(), KernelScalarBase::computeScalarQpResidual(), TimeStepper::computeStep(), ImplicitEuler::computeTimeDerivatives(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CentralDifference::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), MultiAppGeometricInterpolationTransfer::computeTransformation(), BuildArrayVariableAux::computeValue(), TagVectorArrayVariableAux::computeValue(), NearestNodeValueAux::computeValue(), ProjectionAux::computeValue(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), ParsedConvergence::convertRealToBool(), CopyMeshPartitioner::CopyMeshPartitioner(), CoupledForceNodalKernel::CoupledForceNodalKernel(), MultiApp::createApp(), AddVariableAction::createInitialConditionAction(), Function::curl(), MooseVariableFV< Real >::curlPhi(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), SidesetInfoVectorPostprocessor::dataHelper(), DebugResidualAux::DebugResidualAux(), ReporterTransferInterface::declareClone(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), BicubicSplineFunction::derivative(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), FEProblemBase::determineSolverSystem(), DGKernel::DGKernel(), MeshDiagnosticsGenerator::diagnosticsLog(), DistributedPositions::DistributedPositions(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), MooseVariableFV< Real >::divPhi(), FunctorRelationshipManager::dofmap_reinit(), EigenProblem::doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementIntegerAux::ElementIntegerAux(), ElementMaterialSampler::ElementMaterialSampler(), ElementQualityAux::ElementQualityAux(), ElementSubdomainModifierBase::ElementSubdomainModifierBase(), ElementUOAux::ElementUOAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), DistributedRectilinearMeshGenerator::elemId(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), SideIntegralPostprocessor::errorNoFaceInfo(), SideIntegralFunctorPostprocessorTempl< false >::errorNoFaceInfo(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), FixedPointSolve::examineFixedPointConvergence(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), RealToBoolChainControl::execute(), RestartableDataReporter::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), NodalValueSampler::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorTransfer::execute(), ElementQualityChecker::execute(), PositionsFunctorValueSampler::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppCopyTransfer::execute(), WebServerControl::execute(), InterfaceQpUserObjectBase::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), LeastSquaresFit::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFitHistory::execute(), TimeExtremeValue::execute(), Eigenvalue::execute(), DomainUserObject::execute(), FEProblemBase::execute(), FEProblemBase::executeControls(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), NEML2ModelExecutor::extractOutputs(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), NEML2ModelExecutor::fillInputs(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), NearestPointAverage::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), Transfer::find_sys(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVMassMatrix::FVMassMatrix(), FVMatAdvection::FVMatAdvection(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), GapValueAux::GapValueAux(), WorkBalance::gather(), ElementOrderConversionGenerator::generate(), BlockToMeshConverterGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SmoothMeshGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), MeshDiagnosticsGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), MeshRepairGenerator::generate(), SideSetsFromPointsGenerator::generate(), CombinerGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), MeshExtruderGenerator::generate(), generate(), MeshCollectionGenerator::generate(), ParsedGenerateNodeset::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), StitchedMeshGenerator::generate(), XYZDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), SpiralAnnularMeshGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), RandomICBase::generateRandom(), GenericConstantMaterialTempl< is_ad >::GenericConstantMaterialTempl(), GenericConstantVectorMaterialTempl< is_ad >::GenericConstantVectorMaterialTempl(), GenericFunctionMaterialTempl< is_ad >::GenericFunctionMaterialTempl(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), DisplacedProblem::getActualFieldVariable(), FEProblemBase::getActualFieldVariable(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), MooseMesh::getAxisymmetricRadialCoord(), MFEMFESpace::getBasis(), NEML2BatchIndexGenerator::getBatchIndex(), MooseMesh::getBlockConnectedBlocks(), VariableOldValueBounds::getBound(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), MooseMesh::getCoarseningMap(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), FEProblemBase::getConvergence(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PropertyReadFile::getData(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), FEProblemBase::getDistribution(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), GhostingUserObject::getElementalValue(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), PropertyReadFile::getElementData(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), MultiAppFieldTransfer::getEquationSystem(), MultiApp::getExecutioner(), MFEMVectorFESpace::getFECName(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVMatsAndDependencies(), MooseMesh::getGeneralAxisymmetricCoordAxis(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), FEProblemBase::getLinearConvergenceNames(), SolutionUserObjectBase::getLocalVarIndex(), Material::getMaterialByName(), FEProblemBase::getMaterialData(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), FEProblemBase::getMultiAppFixedPointConvergenceName(), DistributedRectilinearMeshGenerator::getNeighbors(), Times::getNextTime(), MooseMesh::getNodeBlockIds(), PropertyReadFile::getNodeData(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearConvergenceNames(), EigenProblem::getNonlinearEigenSystem(), FEProblemBase::getNonlinearSystem(), NEML2ModelExecutor::getOutput(), NEML2ModelExecutor::getOutputDerivative(), NEML2ModelExecutor::getOutputParameterDerivative(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), PlaneIDMeshGenerator::getPlaneID(), Positions::getPosition(), Positions::getPositions(), FEProblemBase::getPositionsObject(), Positions::getPositionsVector2D(), Positions::getPositionsVector3D(), Positions::getPositionsVector4D(), PostprocessorInterface::getPostprocessorValueByNameInternal(), Times::getPreviousTime(), ComponentMaterialPropertyInterface::getPropertyValue(), InterfaceQpUserObjectBase::getQpValue(), MooseMesh::getRefinementMap(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), FEProblemBase::getSampler(), WebServerControl::getScalarJSONValue(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), MooseObject::getSharedPtr(), InterfaceQpUserObjectBase::getSideAverageValue(), PhysicsBase::getSolverSystem(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), MooseMesh::getSubdomainBoundaryIds(), TimedSubdomainModifier::getSubdomainIDAndCheck(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), Times::getTimeAtIndex(), FEProblemBase::getTimeFromStateArg(), TransientBase::getTimeIntegratorNames(), Times::getTimes(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), NumRelationshipManagers::getValue(), VectorPostprocessorComponent::getValue(), Residual::getValue(), SideAverageValue::getValue(), JSONFileReader::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), JSONFileReader::getVector(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingFromUOAux::GhostingFromUOAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), Function::gradient(), FEProblemBase::handleException(), Terminator::handleMessage(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), HDGKernel::HDGKernel(), TransientBase::incrementStepOrReject(), FixedPointIterationAdaptiveDT::init(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), ExplicitTimeIntegrator::init(), EigenExecutionerBase::init(), TransientBase::init(), FEProblem::init(), AddAuxVariableAction::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), MultiApp::init(), FEProblemBase::initialAdaptMesh(), NestedDivision::initialize(), TransformedPositions::initialize(), ReporterPositions::initialize(), DistributedPositions::initialize(), ElementGroupCentroidPositions::initialize(), FunctorPositions::initialize(), ReporterTimes::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SteffensenSolve::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), PiecewiseLinearBase::initialSetup(), ChainControlDataPostprocessor::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), SolutionScalarAux::initialSetup(), LinearFVAdvection::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVDiffusion::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), SolutionAux::initialSetup(), ExplicitTimeIntegrator::initialSetup(), ReferenceResidualConvergence::initialSetup(), NodalVariableValue::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), Exodus::initialSetup(), CSV::initialSetup(), MooseParsedFunction::initialSetup(), SolutionUserObjectBase::initialSetup(), FEProblemBase::initialSetup(), SubProblem::initialSetup(), AdvancedOutput::initOutputList(), MFEMProblem::initProblemOperator(), AdvancedOutput::initShowHideLists(), Function::integral(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), InternalSideIndicatorBase::InternalSideIndicatorBase(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MultiAppGeneralFieldTransfer::locatePointReceivers(), LowerBoundNodalKernel::LowerBoundNodalKernel(), MooseLinearVariableFV< Real >::lowerDError(), PNGOutput::makePNG(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), MassMatrix::MassMatrix(), Material::Material(), MaterialRealTensorValueAuxTempl< is_ad >::MaterialRealTensorValueAuxTempl(), MaterialRealVectorValueAuxTempl< T, is_ad, is_functor >::MaterialRealVectorValueAuxTempl(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableConstMonomial::MooseVariableConstMonomial(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), NearestNodeValueAux::NearestNodeValueAux(), FEProblemBase::needsPreviousNewtonIteration(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), MooseVariableFV< Real >::nodalDofIndex(), MooseVariableFV< Real >::nodalDofIndexNeighbor(), MooseLinearVariableFV< Real >::nodalError(), MooseVariableFV< Real >::nodalMatrixTagValue(), NodalPatchRecoveryBase::nodalPatchRecovery(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalScalarKernel::NodalScalarKernel(), MooseVariableFV< Real >::nodalValueArray(), MooseVariableFV< Real >::nodalValueOldArray(), MooseVariableFV< Real >::nodalValueOlderArray(), NodalVariableValue::NodalVariableValue(), MooseVariableFV< Real >::nodalVectorTagValue(), DistributedRectilinearMeshGenerator::nodeId(), MooseVariableFV< Real >::numberOfDofsNeighbor(), NumDOFs::NumDOFs(), NumFailedTimeSteps::NumFailedTimeSteps(), DistributedRectilinearMeshGenerator::numNeighbors(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), XDA::output(), SolutionHistory::output(), Exodus::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), Exodus::outputSetup(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), DistributedRectilinearMeshGenerator::paritionSquarely(), PiecewiseBilinear::parse(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), MultiAppConservativeTransfer::performAdjustment(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), MooseVariableFV< Real >::phiLowerSize(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), PiecewiseTabularBase::PiecewiseTabularBase(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), SolutionUserObjectBase::pointValueGradientWrapper(), SolutionUserObjectBase::pointValueWrapper(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), LStableDirk4::postResidual(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), EigenProblem::postScaleEigenVector(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), ADKernelValueTempl< T >::precomputeQpJacobian(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), FixedPointSolve::printFixedPointConvergenceReason(), PseudoTimestep::PseudoTimestep(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusII(), SolutionUserObjectBase::readXda(), CoarsenBlockGenerator::recursiveCoarsen(), FunctorRelationshipManager::redistribute(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Sampler::reinit(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), PhysicsBase::reportPotentiallyMissedParameters(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), PiecewiseMultiInterpolation::sample(), ScalarComponentIC::ScalarComponentIC(), MortarScalarBase::scalarVariable(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), BicubicSplineFunction::secondDerivative(), MooseVariableFV< Real >::secondPhi(), MooseVariableFV< Real >::secondPhiFace(), MooseVariableFV< Real >::secondPhiFaceNeighbor(), MooseVariableFV< Real >::secondPhiNeighbor(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), FEProblemBase::setCoupling(), PiecewiseBase::setData(), FileOutput::setFileBaseInternal(), MooseMesh::setGeneralAxisymmetricCoordAxes(), FEProblemSolve::setInnerSolve(), MeshGenerator::setMeshProperty(), FVPointValueConstraint::setMyElem(), FEProblemBase::setNonlocalCouplingMatrix(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), AddPeriodicBCAction::setPeriodicVars(), MFEMSolverBase::setPreconditioner(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), Split::setup(), TransientMultiApp::setupApp(), SetupMeshAction::setupMesh(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), TimePeriodBase::setupTimes(), IntegratedBCBase::shouldApply(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SideAdvectiveFluxIntegralTempl< is_ad >::SideAdvectiveFluxIntegralTempl(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObjectBase::SolutionUserObjectBase(), TimeIntegrator::solve(), FEProblemBase::solverSysNum(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialPoints(), NearestPointAverage::spatialValue(), NearestPointIntegralVariablePostprocessor::spatialValue(), MeshDivisionFunctorReductionVectorPostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), WebServerControl::stringifyJSONType(), MultiAppGeometricInterpolationTransfer::subdomainIDsNode(), Constraint::subdomainSetup(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), MaterialBase::subdomainSetup(), FEProblemBase::swapBackMaterialsNeighbor(), DisplacedProblem::systemBaseLinear(), Console::systemInfoFlags(), FEProblemBase::systemNumForVariable(), TerminateChainControl::terminate(), Terminator::Terminator(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), Function::timeDerivative(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeExtremeValue::TimeExtremeValue(), Function::timeIntegral(), MooseLinearVariableFV< Real >::timeIntegratorError(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriodBase::TimePeriodBase(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppDofCopyTransfer::transfer(), MultiAppMFEMCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransformedPositions::TransformedPositions(), FEProblemBase::trustUserCouplingMatrix(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), Positions::unrollMultiDPositions(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), Checkpoint::updateCheckpointFiles(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObjectBase::updateExodusBracketingTimeIndices(), FEProblemBase::updateMaxQps(), MFEMHypreADS::updateSolver(), MFEMHypreAMS::updateSolver(), MFEMHypreBoomerAMG::updateSolver(), MFEMHypreFGMRES::updateSolver(), MFEMGMRESSolver::updateSolver(), MFEMOperatorJacobiSmoother::updateSolver(), MFEMHyprePCG::updateSolver(), MFEMCGSolver::updateSolver(), MFEMHypreGMRES::updateSolver(), MFEMSuperLU::updateSolver(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointIntegralVariablePostprocessor::userObjectValue(), NearestPointAverage::userObjectValue(), BoundingBoxIC::value(), PiecewiseConstantFromCSV::value(), IntegralPreservingFunctionIC::value(), Axisymmetric2D3DSolutionFunction::value(), Function::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), AddVariableAction::variableType(), VariableValueVolumeHistogram::VariableValueVolumeHistogram(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), VectorNodalBC::VectorNodalBC(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), VTKOutput::VTKOutput(), WebServerControl::WebServerControl(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

30  {
31  std::ostringstream oss;
32  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
33  _moose_base.callMooseError(oss.str(), /* with_prefix = */ true);
34  }
moose::internal::mooseStreamAll
void mooseStreamAll(std::ostringstream &ss)
All of the following are not meant to be called directly - they are called by the normal macros (moos...
Definition: MooseError.C:94
MooseBaseErrorInterface::_moose_base
const MooseBase & _moose_base
The MooseBase class deriving from this interface.
Definition: MooseBaseErrorInterface.h:106
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix) const
Calls moose error with the message msg.
Definition: MooseBase.C:33

◆ mooseErrorNonPrefixed()

template<typename... Args>
void MooseBaseErrorInterface::mooseErrorNonPrefixed ( Args &&...  args) const
inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 40 of file MooseBaseErrorInterface.h.

41  {
42  std::ostringstream oss;
43  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
44  _moose_base.callMooseError(oss.str(), /* with_prefix = */ false);
45  }
moose::internal::mooseStreamAll
void mooseStreamAll(std::ostringstream &ss)
All of the following are not meant to be called directly - they are called by the normal macros (moos...
Definition: MooseError.C:94
MooseBaseErrorInterface::_moose_base
const MooseBase & _moose_base
The MooseBase class deriving from this interface.
Definition: MooseBaseErrorInterface.h:106
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix) const
Calls moose error with the message msg.
Definition: MooseBase.C:33

◆ mooseInfo()

template<typename... Args>
void MooseBaseErrorInterface::mooseInfo ( Args &&...  args) const
inlineinherited

Definition at line 98 of file MooseBaseErrorInterface.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MFEMScalarFESpace::getFECName(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), SolutionUserObjectBase::SolutionUserObjectBase(), and SymmetryTransformGenerator::SymmetryTransformGenerator().

99  {
100  moose::internal::mooseInfoStream(
101  _console, _moose_base.errorPrefix("information"), std::forward<Args>(args)...);
102  }
moose::internal::mooseInfoStream
void mooseInfoStream(S &oss, Args &&... args)
Definition: MooseError.h:232
MooseBase::errorPrefix
std::string errorPrefix(const std::string &error_type) const
Definition: MooseBase.C:43
MooseBaseErrorInterface::_moose_base
const MooseBase & _moose_base
The MooseBase class deriving from this interface.
Definition: MooseBaseErrorInterface.h:106
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31

◆ mooseWarning()

template<typename... Args>
void MooseBaseErrorInterface::mooseWarning ( Args &&...  args) const
inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 75 of file MooseBaseErrorInterface.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::addFunction(), MooseMesh::addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchedMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), DataFileInterface::getDataFilePath(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), SphericalGridDivision::initialize(), CylindricalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), CartesianGridDivision::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

76  {
77  moose::internal::mooseWarningStream(
78  _console, _moose_base.errorPrefix("warning"), std::forward<Args>(args)...);
79  }
MooseBase::errorPrefix
std::string errorPrefix(const std::string &error_type) const
Definition: MooseBase.C:43
moose::internal::mooseWarningStream
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:184
MooseBaseErrorInterface::_moose_base
const MooseBase & _moose_base
The MooseBase class deriving from this interface.
Definition: MooseBaseErrorInterface.h:106
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31

◆ mooseWarningNonPrefixed()

template<typename... Args>
void MooseBaseErrorInterface::mooseWarningNonPrefixed ( Args &&...  args) const
inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 85 of file MooseBaseErrorInterface.h.

86  {
87  moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
88  }
moose::internal::mooseWarningStream
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:184
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31

◆ name()

virtual const std::string& MooseBase::name ( ) const
inlinevirtualinherited

Get the name of the class.

Returns
The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

Referenced by AddElementalFieldAction::act(), CopyNodalVarsAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), DeprecatedBlockAction::act(), SetupTimeIntegratorAction::act(), AddActionComponentAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), Registry::addDataFilePath(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), SubProblem::addFunctor(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), InitialConditionBase::addPostprocessorDependencyHelper(), UserObject::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), InitialConditionBase::addUserObjectDependencyHelper(), UserObject::addUserObjectDependencyHelper(), AuxKernelTempl< Real >::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), UserObject::addVectorPostprocessorDependencyHelper(), Output::advancedExecuteOn(), AdvancedExtruderGenerator(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), Registry::appNameFromAppPath(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), AuxKernelTempl< Real >::AuxKernelTempl(), Function::average(), MultiApp::backup(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), MFEMFESpace::buildFEC(), PiecewiseTabularBase::buildFromFile(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), DefaultNonlinearConvergence::checkConvergence(), ParsedConvergence::checkConvergence(), FEProblemBase::checkDependMaterialsHelper(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), Checkpoint::checkpointInfo(), Coupleable::checkWritableVar(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MooseBaseParameterInterface::connectControllableParams(), ConstantPostprocessor::ConstantPostprocessor(), CommonOutputAction::create(), MultiApp::createApp(), MooseApp::createExecutors(), MeshGeneratorSystem::createMeshGeneratorOrder(), MooseApp::createRecoverablePerfGraph(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), MaterialBase::declareADProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), Registry::determineDataFilePath(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), MooseBase::errorPrefix(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), RestartableDataReporter::execute(), PointValue::execute(), MultiAppNearestNodeTransfer::execute(), WebServerControl::execute(), MultiAppGeneralFieldTransfer::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), MultiApp::fillPositions(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionDT::FunctionDT(), FunctionIC::functionName(), FVFunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), MooseServer::gatherDocumentSymbols(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), ParsedExtraElementIDGenerator::generate(), StitchedMeshGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MeshGenerator::generateInternal(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MultiApp::getBoundingBox(), MooseApp::getCheckpointDirectories(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), Registry::getDataFilePath(), UserObject::getDependObjects(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), MooseApp::getExecutor(), FEProblemBase::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), AuxKernelTempl< Real >::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), Material::getMaterialProperty(), AuxKernelTempl< Real >::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), AuxKernelTempl< Real >::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), AuxKernelTempl< Real >::getMaterialPropertyOlder(), MFEMGeneralUserObject::getMatrixCoefficient(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), ActionWarehouse::getMooseAppName(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), MooseServer::getObjectParameters(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), OutputWarehouse::getOutput(), MooseApp::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMGeneralUserObject::getScalarCoefficient(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMGeneralUserObject::getVectorCoefficient(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), MooseApp::hasMeshGenerator(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), IterationAdaptiveDT::init(), AddVariableAction::init(), AdvancedOutput::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), JSONOutput::initialSetup(), SideFVFluxBCIntegral::initialSetup(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), NodalVariableValue::initialSetup(), Console::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MeshGenerator::isChildMeshGenerator(), MeshGenerator::isNullMeshName(), MooseApp::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), Marker::Marker(), MaterialBase::markMatPropRequested(), MatDiffusionBase< Real >::MatDiffusionBase(), Material::Material(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshGenerator::meshPropertyPrefix(), MooseApp::MooseApp(), OutputWarehouse::mooseConsole(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), Registry::objData(), MeshGenerator::Comparator::operator()(), ProgressOutput::output(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), ParsedCurveGenerator::ParsedCurveGenerator(), MooseServer::parseDocumentForDiagnostics(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), MooseApp::possiblyLoadRestartableMetaData(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), AppFactory::reg(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), GlobalParamsAction::remove(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), GlobalParamsAction::setDoubleIndexParam(), OutputWarehouse::setFileNumbers(), GlobalParamsAction::setParam(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), GlobalParamsAction::setScalarParam(), MooseMesh::setSubdomainName(), GlobalParamsAction::setTripleIndexParam(), NodeSetsGeneratorBase::setup(), Split::setup(), SideSetsGeneratorBase::setup(), TransientMultiApp::setupApp(), GlobalParamsAction::setVectorParam(), FullSolveMultiApp::showStatusMessage(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), SubProblem::storeSubdomainZeroMatProp(), MaterialBase::subdomainSetup(), TaggingInterface::TaggingInterface(), VectorPostprocessorVisualizationAux::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), TransientMultiApp::TransientMultiApp(), MooseServer::traverseParseTreeAndFillSymbols(), MooseBase::typeAndName(), MooseBaseParameterInterface::uniqueParameterName(), FVFluxBC::uOnGhost(), FVFluxBC::uOnUSub(), UserObject::UserObject(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

57 { return _name; }
MooseBase::_name
const std::string _name
The name of this class.
Definition: MooseBase.h:90

◆ paramError()

template<typename... Args>
void MooseBaseParameterInterface::paramError ( const std::string &  param,
Args...  args 
) const
inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 255 of file MooseBaseParameterInterface.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), SetupDebugAction::act(), CommonOutputAction::act(), AddPeriodicBCAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADNodalKernel::ADNodalKernel(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelTempl< Real >::AuxKernelTempl(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), PiecewiseTabularBase::buildFromFile(), MFEMMesh::buildMesh(), CartesianGridDivision::CartesianGridDivision(), checkComponent(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), FunctorAux::computeValue(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), ReporterPointSource::fillPoint(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), ForcingFunctionAux::ForcingFunctionAux(), FullSolveMultiApp::FullSolveMultiApp(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorCoordinatesFunctionAux::FunctorCoordinatesFunctionAux(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ElementsToTetrahedronsConverter::generate(), AddMetaDataGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PlaneIDMeshGenerator::generate(), BlockToMeshConverterGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), generate(), CircularBoundaryCorrectionGenerator::generate(), BreakMeshByElementGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), StackGenerator::generate(), StitchedMeshGenerator::generate(), XYZDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), ComponentBoundaryConditionInterface::getBoundaryCondition(), MultiApp::getCommandLineArgs(), PropertyReadFile::getData(), PropertyReadFile::getFileNames(), Sampler::getGlobalSamples(), ComponentInitialConditionInterface::getInitialCondition(), NEML2Action::getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), Sampler::getNextLocalRow(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), JSONOutput::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), ElementSubdomainModifierBase::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), SampledOutput::initSample(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestNodeValueAux::NearestNodeValueAux(), NEML2Action::NEML2Action(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshGenerator::PolyLineMeshGenerator(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupParameterDerivativeMappings(), TimeSequenceStepperBase::setupSequence(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), SymmetryTransformGenerator::SymmetryTransformGenerator(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), UserObject::UserObject(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), ParsedMaterialBase::validateVectorNames(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

256 {
257  Moose::show_trace = false;
258  _moose_base.callMooseError(paramErrorMsg(param, std::forward<Args>(args)...),
259  /* with_prefix = */ false);
260  Moose::show_trace = true;
261 }
Moose::show_trace
bool show_trace
Set to true (the default) to print the stack trace with error and warning messages - false to omit it...
Definition: Moose.C:761
MooseBaseParameterInterface::_moose_base
const MooseBase & _moose_base
The MooseBase object that inherits this class.
Definition: MooseBaseParameterInterface.h:183
MooseBaseParameterInterface::paramErrorMsg
std::string paramErrorMsg(const std::string &param, Args... args) const
Definition: MooseBaseParameterInterface.h:186
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix) const
Calls moose error with the message msg.
Definition: MooseBase.C:33

◆ parameters()

const InputParameters& MooseBaseParameterInterface::parameters ( ) const
inlineinherited

Get the parameters of the object.

Returns
The parameters of the object

Definition at line 62 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), AddActionComponentAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), MFEMProblem::addAuxVariable(), DisplacedProblem::addAuxVariable(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), MFEMProblem::addVariable(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelTempl< Real >::AuxKernelTempl(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementMaterialSampler::ElementMaterialSampler(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainGeneratorBase::generate(), MooseBaseParameterInterface::getCheckedPointerParam(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MFEMCGSolver::MFEMCGSolver(), MFEMGMRESSolver::MFEMGMRESSolver(), MFEMHypreADS::MFEMHypreADS(), MFEMHypreAMS::MFEMHypreAMS(), MFEMHypreBoomerAMG::MFEMHypreBoomerAMG(), MFEMHypreFGMRES::MFEMHypreFGMRES(), MFEMHypreGMRES::MFEMHypreGMRES(), MFEMHyprePCG::MFEMHyprePCG(), MFEMOperatorJacobiSmoother::MFEMOperatorJacobiSmoother(), MFEMSuperLU::MFEMSuperLU(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), OverlayMeshGenerator::OverlayMeshGenerator(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), FEProblemBase::setResidualObjectParamsAndLog(), SideSetsGeneratorBase::setup(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), Moose::PetscSupport::storePetscOptions(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

62 { return _pars; }
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173

◆ paramInfo()

template<typename... Args>
void MooseBaseParameterInterface::paramInfo ( const std::string &  param,
Args...  args 
) const
inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 272 of file MooseBaseParameterInterface.h.

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

273 {
274  mooseInfo(paramErrorMsg(param, std::forward<Args>(args)...));
275 }
mooseInfo
void mooseInfo(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
Definition: MooseError.h:369
MooseBaseParameterInterface::paramErrorMsg
std::string paramErrorMsg(const std::string &param, Args... args) const
Definition: MooseBaseParameterInterface.h:186

◆ paramWarning()

template<typename... Args>
void MooseBaseParameterInterface::paramWarning ( const std::string &  param,
Args...  args 
) const
inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 265 of file MooseBaseParameterInterface.h.

Referenced by GridPartitioner::_do_partition(), EigenProblem::checkProblemIntegrity(), CombinerGenerator::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

266 {
267  mooseWarning(paramErrorMsg(param, std::forward<Args>(args)...));
268 }
mooseWarning
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:336
MooseBaseParameterInterface::paramErrorMsg
std::string paramErrorMsg(const std::string &param, Args... args) const
Definition: MooseBaseParameterInterface.h:186

◆ queryParam()

template<typename T >
const T * MooseBaseParameterInterface::queryParam ( const std::string &  name) const
inherited

Query a parameter for the object.

If the parameter is not valid, nullptr will be returned

Parameters
nameThe name of the parameter
Returns
A pointer to the parameter value, if it exists

Definition at line 222 of file MooseBaseParameterInterface.h.

223 {
224  return isParamValid(name) ? &getParam<T>(name) : nullptr;
225 }
name
std::string name(const ElemQuality q)
MooseBaseParameterInterface::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBaseParameterInterface.h:122

◆ setHasGenerateData()

void MeshGenerator::setHasGenerateData ( InputParameters &  params)
staticinherited

Sets that a mesh generator has a generateData() implementation.

This must be called in the validParams() implementation for all mesh generators that implement generateData().

Definition at line 80 of file MeshGenerator.C.

Referenced by AddMetaDataGenerator::validParams().

81 {
82  params.set<bool>("_has_generate_data") = true;
83 }
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition: InputParameters.h:1428

◆ setMeshProperty() [1/2]

template<typename T , typename... Args>
T & MeshGenerator::setMeshProperty ( const std::string &  data_name,
Args &&...  args 
)
protectedinherited

Method for updating attributes to the mesh meta-data store, which can only be invoked in the MeshGenerator generate routine only if the mesh generator property has already been declared.

Definition at line 485 of file MeshGenerator.h.

486 {
487  if (_app.actionWarehouse().getCurrentTaskName() != "execute_mesh_generators")
488  mooseError("Updating mesh meta data with setMeshProperty() can only be called during "
489  "MeshGenerator::generate()");
490 
491  if (!hasMeshProperty(data_name))
492  mooseError("Failed to get the mesh property '", data_name, "'");
493  RestartableDataValue * value = &setMeshPropertyHelper(data_name);
494  RestartableData<T> * T_value = dynamic_cast<RestartableData<T> *>(value);
495  if (!T_value)
496  mooseError("While retrieving mesh property '",
497  data_name,
498  "' with type '",
499  MooseUtils::prettyCppType<T>(),
500  "',\nthe property was found with type '",
501  value->type(),
502  "'");
503 
504  // Set the value if someone provided arguments to set it to
505  if constexpr (sizeof...(args) > 0)
506  T_value->set() = T(std::forward<Args>(args)...);
507 
508  return T_value->set();
509 }
MeshGenerator::setMeshPropertyHelper
RestartableDataValue & setMeshPropertyHelper(const std::string &data_name)
Helper for getting a writable reference to a mesh property, used in declareMeshProperty and setMeshPr...
Definition: MeshGenerator.C:352
value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
MooseApp::actionWarehouse
ActionWarehouse & actionWarehouse()
Return a writable reference to the ActionWarehouse associated with this app.
Definition: MooseApp.h:226
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
ActionWarehouse::getCurrentTaskName
const std::string & getCurrentTaskName() const
Definition: ActionWarehouse.h:280
RestartableData
Concrete definition of a parameter value for a specified type.
Definition: RestartableData.h:215
MooseBaseErrorInterface::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
Definition: MooseBaseErrorInterface.h:29
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition: MeshMetaDataInterface.C:25
RestartableDataValue
Abstract definition of a RestartableData value.
Definition: RestartableData.h:31

◆ setMeshProperty() [2/2]

template<typename T >
T& MeshGenerator::setMeshProperty ( const std::string &  data_name,
const T &  data_value 
)
inlineprotectedinherited

Definition at line 221 of file MeshGenerator.h.

222  {
223  return setMeshProperty<T, const T &>(data_name, data_value);
224  }

◆ type()

const std::string& MooseBase::type ( ) const
inlineinherited

Get the type of this class.

Returns
the name of the type of this class

Definition at line 51 of file MooseBase.h.

Referenced by CreateProblemDefaultAction::act(), SetupDebugAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addConvergence(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addObject(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addTimeIntegrator(), MooseServer::addValuesToList(), DisplacedProblem::addVectorTag(), SubProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelTempl< Real >::AuxKernelTempl(), FEProblemBase::backupMultiApps(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildLowerDMesh(), MooseMesh::buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), ADDGKernel::computeElemNeighJacobian(), DGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), ADDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), LowerDIntegratedBC::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDJacobian(), DGLowerDKernel::computeLowerDJacobian(), ArrayDGLowerDKernel::computeLowerDJacobian(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpJacobian(), ArrayHFEMDiffusion::computeLowerDQpJacobian(), HFEMDirichletBC::computeLowerDQpJacobian(), HFEMDiffusion::computeLowerDQpJacobian(), ArrayHFEMDirichletBC::computeLowerDQpOffDiagJacobian(), HFEMDirichletBC::computeLowerDQpOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDQpOffDiagJacobian(), ArrayDGLowerDKernel::computeLowerDQpOffDiagJacobian(), FEProblemBase::computeMultiAppsDT(), ADDGKernel::computeOffDiagElemNeighJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), DGConvection::computeQpJacobian(), ScalarKernel::computeQpJacobian(), InterfaceDiffusion::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), InterfaceReaction::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), DGDiffusion::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), HFEMTestJump::computeQpOffDiagJacobian(), HFEMTrialJump::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), HFEMDiffusion::computeQpResidual(), ArrayHFEMDiffusion::computeQpResidual(), DGConvection::computeQpResidual(), ScalarKernel::computeQpResidual(), InterfaceDiffusion::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), ADMatInterfaceReaction::computeQpResidual(), InterfaceReaction::computeQpResidual(), ADDGAdvection::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), DGDiffusion::computeQpResidual(), ADDGDiffusion::computeQpResidual(), HFEMTestJump::computeQpResidual(), HFEMTrialJump::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), DisplacedProblem::createQRules(), FEProblemBase::createQRules(), MooseApp::createRecoverablePerfGraph(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), MooseBase::errorPrefix(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), WebServerControl::execute(), SteadyBase::execute(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), MooseServer::gatherDocumentReferencesLocations(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateInternal(), MultiAppTransfer::getAppInfo(), TransfiniteMeshGenerator::getEdge(), ElementGenerator::getElemType(), MooseServer::getInputLookupDefinitionNodes(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), MaterialOutputAction::getParams(), ReporterData::getReporterInfo(), FEProblemBase::getTransfers(), DisplacedProblem::getVectorTags(), SubProblem::getVectorTags(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), AdvancedOutput::initAvailableLists(), FunctorPositions::initialize(), FunctorTimes::initialize(), MultiAppConservativeTransfer::initialSetup(), LinearFVAdvection::initialSetup(), LinearFVDiffusion::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MFEMProblem::mesh(), MooseApp::MooseApp(), MooseObject::MooseObject(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), DisplacedProblem::numVectorTags(), SubProblem::numVectorTags(), Console::output(), AdvancedOutput::output(), ConsoleUtils::outputExecutionInformation(), SampledOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), MooseMesh::prepare(), ProjectedStatefulMaterialStorageAction::processProperty(), MooseApp::recursivelyCreateExecutors(), SolutionInvalidInterface::registerInvalidSolutionInternal(), FEProblemBase::restoreMultiApps(), MeshRepairGenerator::separateSubdomainsByElementType(), FEProblemBase::setCoupling(), MooseApp::setupOptions(), WebServerControl::startServer(), MooseBase::typeAndName(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), UserObjectInterface::userObjectType(), and AdvancedOutput::wantOutput().

51 { return _type; }
MooseBase::_type
const std::string _type
The type of this class.
Definition: MooseBase.h:87

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const
inherited

Get the class's combined type and name; useful in error handling.

Returns
The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 27 of file MooseBase.C.

Referenced by MaterialPropertyStorage::addProperty(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

28 {
29  return type() + std::string(" \"") + name() + std::string("\"");
30 }
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:51

◆ uniqueName()

MooseObjectName MooseBaseParameterInterface::uniqueName ( ) const
inlineinherited

The unique name for accessing input parameters of this object in the InputParameterWarehouse.

Definition at line 67 of file MooseBaseParameterInterface.h.

Referenced by MooseBaseParameterInterface::connectControllableParams(), and Action::uniqueActionName().

68  {
69  return MooseObjectName(_pars.get<std::string>("_unique_name"));
70  }
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2172
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173
MooseObjectName
A class for storing the names of MooseObject by tag and object name.
Definition: MooseObjectName.h:40

◆ uniqueParameterName()

MooseObjectParameterName MooseBaseParameterInterface::uniqueParameterName ( const std::string &  parameter_name) const
inlineinherited

The unique parameter name of a valid parameter of this object for accessing parameter controls.

Definition at line 52 of file MooseBaseParameterInterface.h.

53  {
54  return MooseObjectParameterName(
55  _pars.get<std::string>("_moose_base"), _moose_base.name(), parameter_name);
56  }
MooseBaseParameterInterface::_moose_base
const MooseBase & _moose_base
The MooseBase object that inherits this class.
Definition: MooseBaseParameterInterface.h:183
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition: InputParameters.h:2172
MooseBase::name
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseBaseParameterInterface::_pars
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseBaseParameterInterface.h:173
MooseObjectParameterName
A class for storing an input parameter name.
Definition: MooseObjectParameterName.h:26

◆ validParams()

InputParameters AdvancedExtruderGenerator::validParams ( )
static

Definition at line 50 of file AdvancedExtruderGenerator.C.

51 {
52  InputParameters params = MeshGenerator::validParams();
53 
54  params.addRequiredParam<MeshGeneratorName>("input", "The mesh to extrude");
55 
56  params.addClassDescription(
57  "Extrudes a 1D mesh into 2D, or a 2D mesh into 3D, can have a variable height for each "
58  "elevation, variable number of layers within each elevation, variable growth factors of "
59  "axial element sizes within each elevation and remap subdomain_ids, boundary_ids and element "
60  "extra integers within each elevation as well as interface boundaries between neighboring "
61  "elevation layers.");
62 
63  params.addRequiredParam<std::vector<Real>>("heights", "The height of each elevation");
64 
65  params.addRangeCheckedParam<std::vector<Real>>(
66  "biases", "biases>0.0", "The axial growth factor used for mesh biasing for each elevation.");
67 
68  params.addRequiredParam<std::vector<unsigned int>>(
69  "num_layers", "The number of layers for each elevation - must be num_elevations in length!");
70 
71  params.addParam<std::vector<std::vector<subdomain_id_type>>>(
72  "subdomain_swaps",
73  {},
74  "For each row, every two entries are interpreted as a pair of "
75  "'from' and 'to' to remap the subdomains for that elevation");
76 
77  params.addParam<std::vector<std::vector<boundary_id_type>>>(
78  "boundary_swaps",
79  {},
80  "For each row, every two entries are interpreted as a pair of "
81  "'from' and 'to' to remap the boundaries for that elevation");
82 
83  params.addParam<std::vector<std::string>>(
84  "elem_integer_names_to_swap",
85  {},
86  "Array of element extra integer names that need to be swapped during extrusion.");
87 
88  params.addParam<std::vector<std::vector<std::vector<dof_id_type>>>>(
89  "elem_integers_swaps",
90  {},
91  "For each row, every two entries are interpreted as a pair of 'from' and 'to' to remap the "
92  "element extra integer for that elevation. If multiple element extra integers need to be "
93  "swapped, the enties are stacked based on the order provided in "
94  "'elem_integer_names_to_swap' to form the third dimension.");
95 
96  params.addRequiredParam<Point>(
97  "direction",
98  "A vector that points in the direction to extrude (note, this will be "
99  "normalized internally - so don't worry about it here)");
100 
101  params.addParam<BoundaryName>(
102  "top_boundary",
103  "The boundary name to set on the top boundary. If omitted an ID will be generated.");
104 
105  params.addParam<BoundaryName>(
106  "bottom_boundary",
107  "The boundary name to set on the bottom boundary. If omitted an ID will be generated.");
108 
109  params.addParam<std::vector<std::vector<subdomain_id_type>>>(
110  "upward_boundary_source_blocks", "Block ids used to generate upward interface boundaries.");
111 
112  params.addParam<std::vector<std::vector<boundary_id_type>>>("upward_boundary_ids",
113  "Upward interface boundary ids.");
114 
115  params.addParam<std::vector<std::vector<subdomain_id_type>>>(
116  "downward_boundary_source_blocks",
117  "Block ids used to generate downward interface boundaries.");
118 
119  params.addParam<std::vector<std::vector<boundary_id_type>>>("downward_boundary_ids",
120  "Downward interface boundary ids.");
121  params.addParamNamesToGroup(
122  "top_boundary bottom_boundary upward_boundary_source_blocks upward_boundary_ids "
123  "downward_boundary_source_blocks downward_boundary_ids",
124  "Boundary Assignment");
125  params.addParamNamesToGroup(
126  "subdomain_swaps boundary_swaps elem_integer_names_to_swap elem_integers_swaps", "ID Swap");
127  params.addParam<Real>("twist_pitch",
128  0,
129  "Pitch for helicoidal extrusion around an axis going through the origin "
130  "following the direction vector");
131  return params;
132 }
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Definition: InputParameters.h:66
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
This method adds a parameter and documentation string to the InputParameters object that will be extr...
Definition: InputParameters.h:1628
MeshGenerator::validParams
static InputParameters validParams()
Definition: MeshGenerator.C:23
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...
Definition: InputParameters.C:82
InputParameters::addParam
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
Definition: InputParameters.h:1654
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
Definition: InputParameters.h:1769
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...
Definition: InputParameters.C:930

Member Data Documentation

◆ _action_factory

ActionFactory& MooseBaseParameterInterface::_action_factory
protectedinherited

Builds Actions.

Definition at line 179 of file MooseBaseParameterInterface.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ _app

MooseApp& MooseBase::_app
protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

◆ _biases

const std::vector<Real> AdvancedExtruderGenerator::_biases
protected

Bias growth factor of each elevation.

Definition at line 36 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _bottom_boundary

const BoundaryName AdvancedExtruderGenerator::_bottom_boundary
protected

Definition at line 70 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _boundary_swap_pairs

std::vector<std::unordered_map<boundary_id_type, boundary_id_type> > AdvancedExtruderGenerator::_boundary_swap_pairs
protected

Easier to work with version of _boundary_swaps.

Definition at line 58 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _boundary_swaps

const std::vector<std::vector<boundary_id_type> >& AdvancedExtruderGenerator::_boundary_swaps
protected

Boundaries to swap out for each elevation.

Definition at line 45 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console
inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MeshOnlyAction::act(), SetupDebugAction::act(), MaterialOutputAction::act(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkRelativeConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), LinearSystem::computeLinearSystemTags(), FEProblemBase::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MFEMSteady::execute(), MessageFromInput::execute(), SteadyBase::execute(), Eigenvalue::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), CoarsenBlockGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseBaseErrorInterface::mooseDeprecated(), MooseBaseErrorInterface::mooseInfo(), MooseBaseErrorInterface::mooseWarning(), MooseBaseErrorInterface::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ReporterDebugOutput::output(), PerfGraphOutput::output(), SolutionInvalidityOutput::output(), MaterialPropertyDebugOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), PicardSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), EigenProblem::solve(), NonlinearSystem::solve(), LinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), FixedPointSolve::solveStep(), PerfGraphLivePrint::start(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), TerminateChainControl::terminate(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

◆ _direction

Point AdvancedExtruderGenerator::_direction
protected

The direction of the extrusion.

Definition at line 64 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _downward_boundary_ids

const std::vector<std::vector<boundary_id_type> > AdvancedExtruderGenerator::_downward_boundary_ids
protected

Downward boundary interfaces for each layer of elevation.

Definition at line 82 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _downward_boundary_source_blocks

const std::vector<std::vector<subdomain_id_type> > AdvancedExtruderGenerator::_downward_boundary_source_blocks
protected

The list of input mesh's blocks that need to be assigned downward boundary interfaces for each layer of elevation.

Definition at line 79 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _elem_integer_indices_to_swap

std::vector<unsigned int> AdvancedExtruderGenerator::_elem_integer_indices_to_swap
protected

Definition at line 49 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _elem_integer_names_to_swap

const std::vector<std::string>& AdvancedExtruderGenerator::_elem_integer_names_to_swap
protected

Names and indices of extra element integers to swap.

Definition at line 48 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _elem_integers_swap_pairs

std::vector<std::unordered_map<dof_id_type, dof_id_type> > AdvancedExtruderGenerator::_elem_integers_swap_pairs
protected

Easier to work with version of _elem_integers_swaps.

Definition at line 61 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _elem_integers_swaps

const std::vector<std::vector<std::vector<dof_id_type> > >& AdvancedExtruderGenerator::_elem_integers_swaps
protected

Extra element integers to swap out for each elevation and each element interger name.

Definition at line 52 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator().

◆ _enabled

const bool& MooseObject::_enabled
protectedinherited

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition at line 51 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _factory

Factory& MooseBaseParameterInterface::_factory
protectedinherited

The Factory associated with the MooseApp.

Definition at line 176 of file MooseBaseParameterInterface.h.

Referenced by ElementIDOutputAction::act(), AutoCheckpointAction::act(), PartitionerAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), AdaptivityAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), SetupPreconditionerAction::act(), SetupResidualDebugAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), SetAdaptivityOptionsAction::act(), DisplayGhostingAction::act(), AddControlAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), AddNodalNormalsAction::act(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), SampledOutput::cloneMesh(), MooseBaseParameterInterface::connectControllableParams(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), and ProjectedStatefulMaterialStorageAction::processProperty().

◆ _has_bottom_boundary

const bool AdvancedExtruderGenerator::_has_bottom_boundary
protected

Definition at line 69 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _has_top_boundary

const bool AdvancedExtruderGenerator::_has_top_boundary
protected

Definition at line 66 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _heights

const std::vector<Real>& AdvancedExtruderGenerator::_heights
protected

Height of each elevation.

Definition at line 33 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _input

std::unique_ptr<MeshBase>& AdvancedExtruderGenerator::_input
protected

Mesh that comes from another generator.

Definition at line 30 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _mesh

MooseMesh* const MeshGenerator::_mesh
protectedinherited

Pointer to the owning mesh.

Definition at line 388 of file MeshGenerator.h.

Referenced by MeshGenerator::buildDistributedMesh(), MeshGenerator::buildMeshBaseObject(), MeshGenerator::buildReplicatedMesh(), and DistributedRectilinearMeshGenerator::generate().

◆ _name

const std::string MooseBase::_name
protectedinherited

The name of this class.

Definition at line 90 of file MooseBase.h.

Referenced by AddBCAction::act(), AddConstraintAction::act(), AddFVInitialConditionAction::act(), AddPostprocessorAction::act(), AddVectorPostprocessorAction::act(), AddKernelAction::act(), AddInitialConditionAction::act(), PartitionerAction::act(), AddFunctorMaterialAction::act(), AddNodalKernelAction::act(), AddDiracKernelAction::act(), AddInterfaceKernelAction::act(), AddMarkerAction::act(), AddIndicatorAction::act(), AddScalarKernelAction::act(), AddMeshGeneratorAction::act(), AddDamperAction::act(), AddFVInterfaceKernelAction::act(), AddMultiAppAction::act(), AddMaterialAction::act(), AddTransferAction::act(), ReadExecutorParamsAction::act(), AddUserObjectAction::act(), AddDGKernelAction::act(), AddPositionsAction::act(), AddReporterAction::act(), AddTimesAction::act(), AddFieldSplitAction::act(), AddFVKernelAction::act(), AddFVBCAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddFunctionAction::act(), AddConvergenceAction::act(), AddMeshDivisionAction::act(), AddHDGKernelAction::act(), AddTimeStepperAction::act(), AddDistributionAction::act(), AddOutputAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddCorrectorAction::act(), AddMeshModifiersAction::act(), AddSamplerAction::act(), AddControlAction::act(), AddMFEMSolverAction::act(), AddMFEMPreconditionerAction::act(), AddMFEMSubMeshAction::act(), AddMFEMFESpaceAction::act(), AddPeriodicBCAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::name(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseBase::setData(), and AddVariableAction::varName().

◆ _num_layers

const std::vector<unsigned int>& AdvancedExtruderGenerator::_num_layers
protected

Number of layers in each elevation.

Definition at line 39 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _pars

const InputParameters& MooseBaseParameterInterface::_pars
protectedinherited

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition at line 173 of file MooseBaseParameterInterface.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), MooseBaseParameterInterface::connectControllableParams(), Console::Console(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MaterialBase::getGenericZeroMaterialProperty(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBaseParameterInterface::getParam(), MooseBaseParameterInterface::getRenamedParam(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBaseParameterInterface::isParamSetByUser(), MooseBaseParameterInterface::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBaseParameterInterface::MooseBaseParameterInterface(), MooseBaseParameterInterface::paramErrorMsg(), GlobalParamsAction::parameters(), MooseBaseParameterInterface::parameters(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseBaseParameterInterface::uniqueName(), and MooseBaseParameterInterface::uniqueParameterName().

◆ _subdomain_swap_pairs

std::vector<std::unordered_map<subdomain_id_type, subdomain_id_type> > AdvancedExtruderGenerator::_subdomain_swap_pairs
protected

Easier to work with version of _sudomain_swaps.

Definition at line 55 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _subdomain_swaps

const std::vector<std::vector<subdomain_id_type> >& AdvancedExtruderGenerator::_subdomain_swaps
protected

Subdomains to swap out for each elevation.

Definition at line 42 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _top_boundary

const BoundaryName AdvancedExtruderGenerator::_top_boundary
protected

Definition at line 67 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _twist_pitch

const Real AdvancedExtruderGenerator::_twist_pitch
protected

Axial pitch for a full rotation.

Definition at line 85 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _type

const std::string MooseBase::_type
protectedinherited

The type of this class.

Definition at line 87 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _upward_boundary_ids

const std::vector<std::vector<boundary_id_type> > AdvancedExtruderGenerator::_upward_boundary_ids
protected

Upward boundary interfaces for each layer of elevation.

Definition at line 76 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _upward_boundary_source_blocks

const std::vector<std::vector<subdomain_id_type> > AdvancedExtruderGenerator::_upward_boundary_source_blocks
protected

The list of input mesh's blocks that need to be assigned upward boundary interfaces for each layer of elevation.

Definition at line 73 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ data_only_param

const std::string MeshGenerator::data_only_param = "_data_only"
staticinherited

The name of the private parameter for setting data only.

Definition at line 62 of file MeshGenerator.h.

Referenced by MeshGenerator::addMeshSubgenerator(), MeshGeneratorSystem::createAddedMeshGenerators(), and MeshGenerator::validParams().

◆ NAME

constexpr auto MeshMetaDataInterface::NAME = "<empty>"
staticinherited

The data name used when initializing the Restartable interface for non-MeshGenerator objects.

Definition at line 33 of file MeshMetaDataInterface.h.

◆ SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"
staticinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

The documentation for this class was generated from the following files:
Generated on Fri Jul 18 2025 13:31:26 for https://mooseframework.inl.gov by   doxygen 1.8.14