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
 
bool hasGenerateCSG () const
 
std::unique_ptr< CSG::CSGBase > generateInternalCSG ()
 Internal generation method for CSG object generation. More...
 
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
 
bool isKokkosObject () const
 Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes. More...
 
MooseApp & getMooseApp () const
 Get the MooseApp this class is associated with. More...
 
const std::string & type () const
 Get the type of this class. More...
 
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...
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParameters & parameters () const
 Get the parameters of the object. More...
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () const
 
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...
 
template<typename T >
bool haveParameter (const std::string &name) const
 Test if a parameter of the given name and type exists. More...
 
bool isParamValid (const std::string &name) const
 Test if the supplied parameter is valid. More...
 
bool isParamSetByUser (const std::string &name) const
 Test if the supplied parameter is set by a user, as opposed to not set or set to default. 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 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 paramWarning (const std::string &param, Args... args) const
 
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...
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 Deprecated message prefix; the error type is no longer used. More...
 
template<typename... Args>
void mooseError (Args &&... args) const
 Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available. More...
 
template<typename... Args>
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
template<typename... Args>
void mooseErrorNonPrefixed (Args &&... args) const
 Emits an error without the prefixing included in mooseError(). More...
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 Emits a warning prefixed with object name and type. More...
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 Emits a warning without the prefixing included in mooseWarning(). More...
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 Emits a deprecation warning prefixed with the object name and type, and a stack trace. More...
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 
template<typename... Args>
void mooseDeprecatedNoTrace (Args &&... args) const
 Emits a deprecation warning prefixed with the object name and type, and no stack trace. More...
 
template<typename... Args>
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
 External method for calling moose error with added object context. More...
 
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)
 
static void setHasGenerateCSG (InputParameters &params)
 Sets that a mesh generator has a generateCSG() implementation. More...
 
static bool hasGenerateCSG (const InputParameters &params)
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
 External method for calling moose error with added object context. More...
 

Public Attributes

 usingCombinedWarningSolutionWarnings
 
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 const std::string type_param = "_type"
 The name of the parameter that contains the object type. More...
 
static const std::string name_param = "_object_name"
 The name of the parameter that contains the object name. More...
 
static const std::string unique_name_param = "_unique_name"
 The name of the parameter that contains the unique object name. More...
 
static const std::string app_param = "_moose_app"
 The name of the parameter that contains the MooseApp. More...
 
static const std::string moose_base_param = "_moose_base"
 The name of the parameter that contains the moose system base. More...
 
static const std::string kokkos_object_param = "_kokkos_object"
 The name of the parameter that indicates an object is a Kokkos functor. 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

Real radialExpansionRatio (const Real t) const
 Calculate the share of the radial expansion to apply at the local node This share goes from 0 at the beginning of the extrusion to 1 at the end. More...
 
virtual void generateData ()
 Generate the mesh data. More...
 
virtual std::unique_ptr< CSG::CSGBase > generateCSG ()
 Generate the CSG representation of the mesh (or meshing operation) created by this mesh generator. 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...
 
std::unique_ptr< CSG::CSGBase > & getCSGBase (const std::string &param_name)
 Takes the name of a MeshGeneratorName parameter and then gets a pointer to the CSGBase object that MeshGenerator has created. More...
 
std::unique_ptr< CSG::CSGBase > & getCSGBaseByName (const MeshGeneratorName &mesh_generator_name)
 Like getCSGBase(), but takes the name of another MeshGenerator directly. More...
 
std::vector< std::unique_ptr< CSG::CSGBase > * > getCSGBases (const std::string &param_name)
 Like getCSGBase(), but for multiple generators. More...
 
std::vector< std::unique_ptr< CSG::CSGBase > * > getCSGBasesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
 Like getCSGBaseByName(), 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<bool warning>
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 Set solution invalid mark for the given solution ID. More...
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 
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...
 
std::unique_ptr< MeshBase > & _extrusion_curve
 Curve mesh to extrude along. More...
 
const RealVectorValue _start_extrusion_direction
 Extrusion direction to follow at the start (first layer) of the extrusion. More...
 
const RealVectorValue _end_extrusion_direction
 Extrusion direction for the final layer of the extrusion. More...
 
bool _extrude_along_curve
 Whether we are extruding along a curve. 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...
 
const Real _end_radial_extent
 Radial extent of the extruded geometry at the end of the extrusion. More...
 
const MooseEnum _radial_expansion_method
 Function type for modifying the radial extent of the extruded shape. More...
 
const Real _start_radial_growth_rate
 Derivative of the radial expansion function at the beginning of the extrusion. More...
 
const Real _end_radial_growth_rate
 Derivative of the radial expansion function at the end of the extrusion. 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...
 
Factory & _factory
 The Factory associated with the MooseApp. More...
 
ActionFactory & _action_factory
 Builds Actions. More...
 
const std::string & _type
 The type of this class. More...
 
const std::string & _name
 The name of this class. More...
 
const InputParameters & _pars
 The object's parameters. 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 169 of file AdvancedExtruderGenerator.C.

170  : MeshGenerator(parameters),
171  _input(getMesh("input")),
172  _heights(getParam<std::vector<Real>>("heights")),
173  _biases(isParamValid("biases") ? getParam<std::vector<Real>>("biases")
174  : std::vector<Real>(_heights.size(), 1.0)),
175  _num_layers(getParam<std::vector<unsigned int>>("num_layers")),
176  _subdomain_swaps(getParam<std::vector<std::vector<subdomain_id_type>>>("subdomain_swaps")),
177  _boundary_swaps(getParam<std::vector<std::vector<boundary_id_type>>>("boundary_swaps")),
178  _elem_integer_names_to_swap(getParam<std::vector<std::string>>("elem_integer_names_to_swap")),
179  _elem_integers_swaps(
180  getParam<std::vector<std::vector<std::vector<dof_id_type>>>>("elem_integers_swaps")),
181  _direction(isParamValid("direction") ? getParam<Point>("direction") : Point(0, 0, 0)),
182  _extrusion_curve(getMesh("extrusion_curve", true)),
183  _start_extrusion_direction(isParamValid("start_extrusion_direction")
184  ? getParam<RealVectorValue>("start_extrusion_direction").unit()
185  : Point(0, 0, 0)),
186  _end_extrusion_direction(isParamValid("end_extrusion_direction")
187  ? getParam<RealVectorValue>("end_extrusion_direction").unit()
188  : Point(0, 0, 0)),
189  _extrude_along_curve(isParamValid("extrusion_curve")),
190  _has_top_boundary(isParamValid("top_boundary")),
191  _top_boundary(isParamValid("top_boundary") ? getParam<BoundaryName>("top_boundary") : "0"),
192  _has_bottom_boundary(isParamValid("bottom_boundary")),
193  _bottom_boundary(isParamValid("bottom_boundary") ? getParam<BoundaryName>("bottom_boundary")
194  : "0"),
195  _upward_boundary_source_blocks(
196  isParamValid("upward_boundary_source_blocks")
197  ? getParam<std::vector<std::vector<subdomain_id_type>>>("upward_boundary_source_blocks")
198  : std::vector<std::vector<subdomain_id_type>>(_heights.size(),
199  std::vector<subdomain_id_type>())),
200  _upward_boundary_ids(
201  isParamValid("upward_boundary_ids")
202  ? getParam<std::vector<std::vector<boundary_id_type>>>("upward_boundary_ids")
203  : std::vector<std::vector<boundary_id_type>>(_heights.size(),
204  std::vector<boundary_id_type>())),
205  _downward_boundary_source_blocks(isParamValid("downward_boundary_source_blocks")
206  ? getParam<std::vector<std::vector<subdomain_id_type>>>(
207  "downward_boundary_source_blocks")
208  : std::vector<std::vector<subdomain_id_type>>(
209  _heights.size(), std::vector<subdomain_id_type>())),
210  _downward_boundary_ids(
211  isParamValid("downward_boundary_ids")
212  ? getParam<std::vector<std::vector<boundary_id_type>>>("downward_boundary_ids")
213  : std::vector<std::vector<boundary_id_type>>(_heights.size(),
214  std::vector<boundary_id_type>())),
215  _twist_pitch(getParam<Real>("twist_pitch")),
216  _end_radial_extent(getParam<Real>("end_radial_extent")),
217  _radial_expansion_method(getParam<MooseEnum>("radial_growth_method")),
218  _start_radial_growth_rate(getParam<Real>("start_radial_growth_rate")),
219  _end_radial_growth_rate(getParam<Real>("end_radial_growth_rate"))
220 {
221  if (_extrude_along_curve)
222  {
223  if (isParamSetByUser("heights"))
224  paramError("heights", "heights cannot be set if extruding along curve!");
225  if (isParamValid("biases"))
226  paramError("biases", "biases cannot be set if extruding along curve!");
227  if (isParamSetByUser("num_layers"))
228  paramError("num_layers", "num_layers cannot be set if extruding along curve!");
229  if (isParamValid("direction"))
230  paramError("direction", "direction cannot be set if extruding along curve!");
231  }
232  else
233  {
234  if (!_direction.norm())
235  paramError("direction", "Must have some length!");
236  _direction /= _direction.norm();
237  }
238 
239  unsigned int num_elevations;
240  if (_extrude_along_curve)
241  num_elevations = 1;
242  else
243  {
244  num_elevations = _heights.size();
245  if (_num_layers.size() != num_elevations)
246  paramError(
247  "heights", "The length of 'heights' and 'num_layers' must be the same in ", name());
248  }
249 
250  if (_subdomain_swaps.size() && (_subdomain_swaps.size() != num_elevations))
251  {
252  if (_extrude_along_curve)
253  paramError("subdomain_swaps",
254  "If specified, 'subdomain_swaps' (" + std::to_string(_subdomain_swaps.size()) +
255  ") must be equal to 1 when extruding along a curve.");
256  else
257  {
258  paramError("subdomain_swaps",
259  "If specified, 'subdomain_swaps' (" + std::to_string(_subdomain_swaps.size()) +
260  ") must be the same length as 'heights' (" + std::to_string(num_elevations) +
261  ") in ",
262  name());
263  }
264  }
265 
266  try
267  {
268  MooseMeshUtils::idSwapParametersProcessor(
269  name(), "subdomain_swaps", _subdomain_swaps, _subdomain_swap_pairs);
270  }
271  catch (const MooseException & e)
272  {
273  paramError("subdomain_swaps", e.what());
274  }
275 
276  if (_boundary_swaps.size() && (_boundary_swaps.size() != num_elevations))
277  {
278  if (_extrude_along_curve)
279  {
280  paramError("boundary_swaps",
281  "If specified, 'boundary_swaps' (" + std::to_string(_boundary_swaps.size()) +
282  ") must be the same length as 'heights' (" + std::to_string(num_elevations) +
283  ") in ",
284  name());
285  }
286  else
287  {
288  paramError("boundary_swaps",
289  "If specified, 'boundary_swaps' (" + std::to_string(_boundary_swaps.size()) +
290  ") must be equal to 1 when extruding along a curve.");
291  }
292  }
293 
294  try
295  {
296  MooseMeshUtils::idSwapParametersProcessor(
297  name(), "boundary_swaps", _boundary_swaps, _boundary_swap_pairs);
298  }
299  catch (const MooseException & e)
300  {
301  paramError("boundary_swaps", e.what());
302  }
303 
304  if (_elem_integers_swaps.size() &&
305  _elem_integers_swaps.size() != _elem_integer_names_to_swap.size())
306  paramError("elem_integers_swaps",
307  "If specified, 'elem_integers_swaps' must have the same length as the length of "
308  "'elem_integer_names_to_swap'.");
309 
310  for (const auto & unit_elem_integers_swaps : _elem_integers_swaps)
311  if (unit_elem_integers_swaps.size() != num_elevations)
312  paramError("elem_integers_swaps",
313  "If specified, each element of 'elem_integers_swaps' must have the same length as "
314  "the length of 'heights'.");
315 
316  try
317  {
318  MooseMeshUtils::extraElemIntegerSwapParametersProcessor(name(),
319  num_elevations,
320  _elem_integer_names_to_swap.size(),
321  _elem_integers_swaps,
322  _elem_integers_swap_pairs);
323  }
324  catch (const MooseException & e)
325  {
326  paramError("elem_integers_swaps", e.what());
327  }
328 
329  if (!_extrude_along_curve)
330  {
331  bool has_negative_entry = false;
332  bool has_positive_entry = false;
333  for (const auto & h : _heights)
334  {
335  if (h > 0.0)
336  has_positive_entry = true;
337  else
338  has_negative_entry = true;
339  }
340 
341  if (has_negative_entry && has_positive_entry)
342  paramError("heights", "Cannot have both positive and negative heights!");
343  if (_biases.size() != _heights.size())
344  paramError("biases", "Size of this parameter, if provided, must be the same as heights.");
345  }
346 
347  if ((_upward_boundary_source_blocks.size() || _upward_boundary_ids.size()) &&
348  (_upward_boundary_source_blocks.size() != _upward_boundary_ids.size() ||
349  _upward_boundary_ids.size() != num_elevations))
350  {
351  if (_extrude_along_curve)
352  paramError(
353  "upward_boundary_ids",
354  "This parameter must have the same length (" +
355  std::to_string(_upward_boundary_ids.size()) + ") as upward_boundary_source_blocks (" +
356  std::to_string(_upward_boundary_source_blocks.size()) + ") and num_elevations (" +
357  std::to_string(num_elevations) +
358  "). Note that the number of heights is set to 1 when extruding along a curve.");
359  else
360  {
361  paramError("upward_boundary_ids",
362  "This parameter must have the same length (" +
363  std::to_string(_upward_boundary_ids.size()) +
364  ") as upward_boundary_source_blocks (" +
365  std::to_string(_upward_boundary_source_blocks.size()) + ") and heights (" +
366  std::to_string(num_elevations) + ")");
367  }
368  }
369 
370  for (unsigned int i = 0; i < _upward_boundary_source_blocks.size(); i++)
371  if (_upward_boundary_source_blocks[i].size() != _upward_boundary_ids[i].size())
372  paramError("upward_boundary_ids",
373  "Every element of this parameter must have the same length as the corresponding "
374  "element of upward_boundary_source_blocks.");
375 
376  if ((_downward_boundary_source_blocks.size() || _downward_boundary_ids.size()) &&
377  (_downward_boundary_source_blocks.size() != _downward_boundary_ids.size() ||
378  _downward_boundary_ids.size() != num_elevations))
379  {
380  if (_extrude_along_curve)
381  paramError(
382  "downward_boundary_ids",
383  "This parameter must have the same length (" +
384  std::to_string(_downward_boundary_ids.size()) +
385  ") as downward_boundary_source_blocks (" +
386  std::to_string(_downward_boundary_source_blocks.size()) + ") and (" +
387  std::to_string(num_elevations) +
388  "). Note that the number of heights is set to 1 when extruding along a curve.");
389  else
390  {
391  paramError("downward_boundary_ids",
392  "This parameter must have the same length (" +
393  std::to_string(_downward_boundary_ids.size()) +
394  ") as downward_boundary_source_blocks (" +
395  std::to_string(_downward_boundary_source_blocks.size()) + ") and heights (" +
396  std::to_string(num_elevations) + ")");
397  }
398  }
399  for (unsigned int i = 0; i < _downward_boundary_source_blocks.size(); i++)
400  if (_downward_boundary_source_blocks[i].size() != _downward_boundary_ids[i].size())
401  paramError("downward_boundary_ids",
402  "Every element of this parameter must have the same length as the corresponding "
403  "element of downward_boundary_source_blocks.");
404 }
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
AdvancedExtruderGenerator::_end_extrusion_direction
const RealVectorValue _end_extrusion_direction
Extrusion direction for the final layer of the extrusion.
Definition: AdvancedExtruderGenerator.h:72
MooseException::what
virtual const char * what() const
Get out the error message.
Definition: MooseException.h:60
AdvancedExtruderGenerator::_end_radial_extent
const Real _end_radial_extent
Radial extent of the extruded geometry at the end of the extrusion.
Definition: AdvancedExtruderGenerator.h:99
AdvancedExtruderGenerator::_extrusion_curve
std::unique_ptr< MeshBase > & _extrusion_curve
Curve mesh to extrude along.
Definition: AdvancedExtruderGenerator.h:68
MooseBase::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: MooseBase.h:467
MooseBase::getParam
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBase.h:416
MooseBase::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
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:57
AdvancedExtruderGenerator::_twist_pitch
const Real _twist_pitch
Axial pitch for a full rotation.
Definition: AdvancedExtruderGenerator.h:95
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:89
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:86
AdvancedExtruderGenerator::_start_radial_growth_rate
const Real _start_radial_growth_rate
Derivative of the radial expansion function at the beginning of the extrusion.
Definition: AdvancedExtruderGenerator.h:103
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
boundary_id_type
int8_t boundary_id_type
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:186
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:92
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:54
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:407
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
AdvancedExtruderGenerator::_end_radial_growth_rate
const Real _end_radial_growth_rate
Derivative of the radial expansion function at the end of the extrusion.
Definition: AdvancedExtruderGenerator.h:105
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
AdvancedExtruderGenerator::_extrude_along_curve
bool _extrude_along_curve
Whether we are extruding along a curve.
Definition: AdvancedExtruderGenerator.h:74
MooseException
Provides a way for users to bail out of the current solve.
Definition: MooseException.h:20
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
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
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:83
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:665
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:209
AdvancedExtruderGenerator::_radial_expansion_method
const MooseEnum _radial_expansion_method
Function type for modifying the radial extent of the extruded shape.
Definition: AdvancedExtruderGenerator.h:101
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
MooseBase::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
Definition: MooseBase.h:215
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
AdvancedExtruderGenerator::_start_extrusion_direction
const RealVectorValue _start_extrusion_direction
Extrusion direction to follow at the start (first layer) of the extrusion.
Definition: AdvancedExtruderGenerator.h:70

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 441 of file MeshGenerator.C.

442 {
443  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
444  _child_mesh_generators.insert(&mg);
445 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3221
MeshGenerator::_child_mesh_generators
std::set< const MeshGenerator *, Comparator > _child_mesh_generators
The MeshGenerators that are children to this MeshGenerator.
Definition: MeshGenerator.h:519
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385

◆ 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 593 of file MeshGenerator.h.

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

596 {
597  InputParameters subgenerator_params = _app.getFactory().getValidParams(type);
598 
599  subgenerator_params.setParameters(extra_input_parameters...);
600 
601  addMeshSubgenerator(type, name, subgenerator_params);
602 }
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:67
MooseApp::getFactory
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition: MooseApp.h:406
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
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:593
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
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:1579

◆ 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 410 of file MeshGenerator.C.

413 {
414  if (!_app.constructingMeshGenerators())
415  mooseError("Can only call addMeshSubgenerator() during MeshGenerator construction");
416 
417  // In case the user forgot it
418  params.set<MooseApp *>(MooseBase::app_param) = &_app;
419 
420  // Set this to be data-only if this generator is data only
421  params.set<bool>(data_only_param) = isDataOnly();
422 
423  _app.addMeshGenerator(type, name, params);
424  _sub_mesh_generators.insert(&std::as_const(_app).getMeshGenerator(name));
425 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3221
MooseBase::app_param
static const std::string app_param
The name of the parameter that contains the MooseApp.
Definition: MooseBase.h:59
MeshGenerator::data_only_param
static const std::string data_only_param
The name of the private parameter for setting data only.
Definition: MeshGenerator.h:76
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition: InputParameters.h:1560
MooseApp
Base class for MOOSE-based applications.
Definition: MooseApp.h:108
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
MeshGenerator::_sub_mesh_generators
std::set< const MeshGenerator *, Comparator > _sub_mesh_generators
The sub MeshGenerators constructed by this MeshGenerator.
Definition: MeshGenerator.h:521
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:876
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
MeshGenerator::isDataOnly
bool isDataOnly() const
Definition: MeshGenerator.h:214

◆ 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 434 of file MeshGenerator.C.

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

◆ 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 303 of file MeshGenerator.C.

Referenced by DistributedRectilinearMeshGenerator::generate().

304 {
305  mooseAssert(_mesh, "Need a MooseMesh object");
306  return _mesh->buildTypedMesh<DistributedMesh>(dim);
307 }
Moose::dim
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:163
MeshGenerator::_mesh
MooseMesh *const _mesh
Pointer to the owning mesh.
Definition: MeshGenerator.h:462
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:2249

◆ 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 289 of file MeshGenerator.C.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), FileMeshGenerator::generate(), ElementGenerator::generate(), BlockToMeshConverterGenerator::generate(), SphereMeshGenerator::generate(), ExamplePatchMeshGenerator::generate(), GeneratedMeshGenerator::generate(), CartesianMeshGenerator::generate(), PolyLineMeshGenerator::generate(), AnnularMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), MeshExtruderGenerator::generate(), generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), Boundary2DDelaunayGenerator::generate(), and TransfiniteMeshGenerator::generate().

290 {
291  mooseAssert(_mesh, "Need a MooseMesh object");
292  return _mesh->buildMeshBaseObject(dim);
293 }
Moose::dim
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:163
MeshGenerator::_mesh
MooseMesh *const _mesh
Pointer to the owning mesh.
Definition: MeshGenerator.h:462
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:2944

◆ 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 296 of file MeshGenerator.C.

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

297 {
298  mooseAssert(_mesh, "Need a MooseMesh object");
299  return _mesh->buildTypedMesh<ReplicatedMesh>(dim);
300 }
Moose::dim
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:163
MeshGenerator::_mesh
MooseMesh *const _mesh
Pointer to the owning mesh.
Definition: MeshGenerator.h:462
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:2249

◆ callMooseError() [1/2]

void MooseBase::callMooseError ( std::string  msg,
const bool  with_prefix,
const hit::Node *  node = nullptr,
const bool  show_trace = true 
) const
inherited

External method for calling moose error with added object context.

Parameters
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix
show_traceWhether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

Referenced by InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

109 {
110  callMooseError(&_app, _pars, msg, with_prefix, node, show_trace);
111 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105

◆ callMooseError() [2/2]

void MooseBase::callMooseError ( MooseApp *const  app,
const InputParameters &  params,
std::string  msg,
const bool  with_prefix,
const hit::Node *  node,
const bool  show_trace = true 
)
staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters
appThe app pointer (if available); adds multiapp context and clears the console
paramsThe parameters, needed to obtain object information
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix
show_traceWhether or not to show a stack trace, defaults to true

Definition at line 114 of file MooseBase.C.

120 {
121  if (!node)
122  node = MooseBase::getHitNode(params);
123 
124  std::string multiapp_prefix = "";
125  if (app)
126  {
127  if (!app->isUltimateMaster())
128  multiapp_prefix = app->name();
129  app->getOutputWarehouse().mooseConsole();
130  }
131 
132  if (with_prefix)
133  // False here because the hit context will get processed by the node
134  msg = messagePrefix(params, false) + msg;
135 
136  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
137 }
MooseApp::isUltimateMaster
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition: MooseApp.h:840
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
moose::internal::mooseErrorRaw
void mooseErrorRaw(std::string msg, const std::string &prefix="", const hit::Node *node=nullptr, const bool show_trace=true)
Main callback for emitting a moose error.
Definition: MooseError.C:53
OutputWarehouse::mooseConsole
void mooseConsole()
Send current output buffer to Console output objects.
Definition: OutputWarehouse.C:199
MooseBase::getHitNode
const hit::Node * getHitNode() const
Definition: MooseBase.h:136
MooseApp::getOutputWarehouse
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2136
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:266

◆ connectControllableParams()

void MooseBase::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 77 of file MooseBase.C.

81 {
82  auto & factory = _app.getFactory();
83  auto & ip_warehouse = _app.getInputParameterWarehouse();
84 
85  MooseObjectParameterName primary_name(uniqueName(), parameter);
86  const auto base_type = factory.getValidParams(object_type).getBase();
87  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
88  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
89 
90  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
91  for (const auto & tag : tags)
92  {
93  if (!tag.empty())
94  {
95  // Only adds the parameter with the different control tags if the derived class
96  // properly registers the parameter to its own syntax
97  MooseObjectParameterName tagged_name(tag, name(), parameter);
98  ip_warehouse.addControllableParameterConnection(
99  tagged_name, secondary_name, /*error_on_empty=*/false);
100  }
101  }
102 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
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:2305
MooseApp::getInputParameterWarehouse
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition: MooseApp.C:2594
MooseBase::uniqueName
MooseObjectName uniqueName() const
Definition: MooseBase.C:69
MooseApp::getFactory
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition: MooseApp.h:406
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
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 263 of file MeshGenerator.h.

266  {
267  return declareMeshProperty(target_data_name, getMeshProperty<T>(source_data_name, source_mesh));
268  }
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:535

◆ 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 276 of file MeshGenerator.h.

277  {
278  return copyMeshProperty<T>(source_data_name, source_data_name, source_mesh);
279  }

◆ declareMeshesForSub()

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

Like declareMeshForSub(), but for multiple generators.

Definition at line 265 of file MeshGenerator.C.

266 {
267  declareMeshesForSubByName(getMeshGeneratorNamesFromParam(param_name));
268 }
MeshGenerator::declareMeshesForSubByName
void declareMeshesForSubByName(const std::vector< MeshGeneratorName > &mesh_generator_names)
Like declareMeshForSubByName(), but for multiple generators.
Definition: MeshGenerator.C:281
MeshGenerator::getMeshGeneratorNamesFromParam
const std::vector< MeshGeneratorName > & getMeshGeneratorNamesFromParam(const std::string &param_name) const
Helper for getting a std::vector<MeshGeneratorName> parameter.
Definition: MeshGenerator.C:135

◆ declareMeshesForSubByName()

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

Like declareMeshForSubByName(), but for multiple generators.

Definition at line 281 of file MeshGenerator.C.

Referenced by MeshGenerator::declareMeshesForSub().

283 {
284  for (const auto & name : mesh_generator_names)
285  declareMeshForSubByName(name);
286 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshGenerator::declareMeshForSubByName
void declareMeshForSubByName(const MeshGeneratorName &mesh_generator_name)
Like declareMeshForSub(), but takes the name of another MeshGenerator directly.
Definition: MeshGenerator.C:271

◆ 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 259 of file MeshGenerator.C.

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

260 {
261  declareMeshForSubByName(*getMeshGeneratorNameFromParam(param_name, false));
262 }
MeshGenerator::declareMeshForSubByName
void declareMeshForSubByName(const MeshGeneratorName &mesh_generator_name)
Like declareMeshForSub(), but takes the name of another MeshGenerator directly.
Definition: MeshGenerator.C:271
MeshGenerator::getMeshGeneratorNameFromParam
const MeshGeneratorName * getMeshGeneratorNameFromParam(const std::string &param_name, const bool allow_invalid) const
Helper for getting a MeshGeneratorName parameter.
Definition: MeshGenerator.C:106

◆ declareMeshForSubByName()

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

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

Definition at line 271 of file MeshGenerator.C.

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

272 {
273  checkGetMesh(mesh_generator_name, "");
274  if (isNullMeshName(mesh_generator_name))
275  return;
276 
277  _requested_mesh_generators_for_sub.insert(mesh_generator_name);
278 }
MeshGenerator::isNullMeshName
bool isNullMeshName(const MeshGeneratorName &name) const
Definition: MeshGenerator.h:184
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:502
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:158

◆ 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 535 of file MeshGenerator.h.

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

536 {
537  if (!_app.constructingMeshGenerators())
538  mooseError("Can only call declareMeshProperty() during MeshGenerator construction");
539 
540  // We sort construction ordering so that we _must_ declare before retrieving
541  if (hasMeshProperty(data_name))
542  mooseError("While declaring mesh property '",
543  data_name,
544  "' with type '",
545  MooseUtils::prettyCppType<T>(),
546  "',\nsaid property has already been declared with type '",
547  setMeshPropertyHelper(data_name).type(),
548  "'");
549 
550  const auto full_name = meshPropertyName(data_name);
551  auto new_T_value =
552  std::make_unique<RestartableData<T>>(full_name, nullptr, std::forward<Args>(args)...);
553  auto value =
554  &_app.registerRestartableData(std::move(new_T_value), 0, false, MooseApp::MESH_META_DATA);
555  mooseAssert(value->declared(), "Should be declared");
556 
557  RestartableData<T> * T_value = dynamic_cast<RestartableData<T> *>(value);
558  mooseAssert(T_value, "Bad cast");
559 
560  return T_value->set();
561 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3221
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:428
MooseApp::MESH_META_DATA
static const RestartableDataMapName MESH_META_DATA
Definition: MooseApp.h:135
MeshMetaDataInterface::meshPropertyName
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
Definition: MeshMetaDataInterface.C:41
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:2176
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
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
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition: MeshMetaDataInterface.C:33

◆ declareMeshProperty() [2/2]

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

Definition at line 236 of file MeshGenerator.h.

237  {
238  return declareMeshProperty<T, const T &>(data_name, data_value);
239  }

◆ 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 474 of file MeshGenerator.C.

475 {
476  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
477  mooseAssert(!_null_mesh_names.count(name), "Already declared");
478  _null_mesh_names.insert(name);
479 }
MooseApp::constructingMeshGenerators
virtual bool constructingMeshGenerators() const
Whether this app is constructing mesh generators.
Definition: MooseApp.C:3221
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:524
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385

◆ enabled()

virtual bool MooseObject::enabled ( ) const
inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

Referenced by EigenKernel::enabled().

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

◆ errorPrefix()

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

Deprecated message prefix; the error type is no longer used.

Definition at line 274 of file MooseBase.h.

274 { return messagePrefix(); }
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:266

◆ flagInvalidSolutionInternal()

template<bool warning>
template void SolutionInvalidInterface::flagInvalidSolutionInternal< false > ( const InvalidSolutionID  invalid_solution_id) const
protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

43 {
44  mooseAssert(
45  warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
46  "Inconsistent warning flag");
47  auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
48  if constexpr (!warning)
49  if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
50  solution_invalidity.printDebug(invalid_solution_id);
51  return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
52 }
SolutionInvalidInterface::_si_problem
const FEProblemBase * _si_problem
A pointer to FEProblem base.
Definition: SolutionInvalidInterface.h:114
SolutionInvalidity::printDebug
void printDebug(InvalidSolutionID _invalid_solution_id) const
Immediately print the section and message for debug purpose.
Definition: SolutionInvalidity.C:208
MooseBase::getMooseApp
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:87
MooseApp::solutionInvalidity
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
Definition: MooseApp.h:184
moose::internal::getSolutionInvalidityRegistry
SolutionInvalidityRegistry & getSolutionInvalidityRegistry()
Get the global SolutionInvalidityRegistry singleton.
Definition: SolutionInvalidityRegistry.C:18
FEProblemBase::immediatelyPrintInvalidSolution
bool immediatelyPrintInvalidSolution() const
Whether or not the solution invalid warnings are printed out immediately.
Definition: FEProblemBase.h:2372
SolutionInvalidInterface::_si_moose_base
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
Definition: SolutionInvalidInterface.h:111

◆ generate()

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

Generate / modify the mesh.

Implements MeshGenerator.

Definition at line 407 of file AdvancedExtruderGenerator.C.

408 {
409  // Note: bulk of this code originally from libmesh mesh_modification.C
410  // Original copyright: Copyright (C) 2002-2019 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
411  // Original license is LGPL so it can be used here.
412 
413  auto mesh = buildMeshBaseObject(_input->mesh_dimension() + 1);
414  mesh->set_mesh_dimension(_input->mesh_dimension() + 1);
415 
416  // Check if the element integer names are existent in the input mesh.
417  for (const auto i : make_range(_elem_integer_names_to_swap.size()))
418  if (_input->has_elem_integer(_elem_integer_names_to_swap[i]))
419  _elem_integer_indices_to_swap.push_back(
420  _input->get_elem_integer_index(_elem_integer_names_to_swap[i]));
421  else
422  paramError("elem_integer_names_to_swap",
423  "Element ",
424  i + 1,
425  " of 'elem_integer_names_to_swap' in is not a valid extra element integer of the "
426  "input mesh.");
427 
428  // prepare for transferring extra element integers from original mesh to the extruded mesh.
429  const unsigned int num_extra_elem_integers = _input->n_elem_integers();
430  std::vector<std::string> id_names;
431 
432  for (unsigned int i = 0; i < num_extra_elem_integers; i++)
433  {
434  id_names.push_back(_input->get_elem_integer_name(i));
435  if (!mesh->has_elem_integer(id_names[i]))
436  mesh->add_elem_integer(id_names[i]);
437  }
438 
439  // retrieve subdomain/sideset/nodeset name maps
440  if (!_input->preparation().has_cached_elem_data)
441  _input->cache_elem_data();
442  const auto & input_subdomain_map = _input->get_subdomain_name_map();
443  const auto & input_sideset_map = _input->get_boundary_info().get_sideset_name_map();
444  const auto & input_nodeset_map = _input->get_boundary_info().get_nodeset_name_map();
445 
446  // Check that the swaps source blocks are present in the mesh
447  for (const auto & swap : _subdomain_swaps)
448  for (const auto i : index_range(swap))
449  if (i % 2 == 0 && !MooseMeshUtils::hasSubdomainID(*_input, swap[i]))
450  paramError("subdomain_swaps", "The block '", swap[i], "' was not found within the mesh");
451 
452  // Check that the swaps source boundaries are present in the mesh
453  for (const auto & swap : _boundary_swaps)
454  for (const auto i : index_range(swap))
455  if (i % 2 == 0 && !MooseMeshUtils::hasBoundaryID(*_input, swap[i]))
456  paramError("boundary_swaps", "The boundary '", swap[i], "' was not found within the mesh");
457 
458  // Check that the source blocks for layer top/bottom boundaries exist in the mesh
459  for (const auto & layer_vec : _upward_boundary_source_blocks)
460  for (const auto bid : layer_vec)
461  if (!MooseMeshUtils::hasSubdomainID(*_input, bid))
462  paramError(
463  "upward_boundary_source_blocks", "The block '", bid, "' was not found within the mesh");
464  for (const auto & layer_vec : _downward_boundary_source_blocks)
465  for (const auto bid : layer_vec)
466  if (!MooseMeshUtils::hasSubdomainID(*_input, bid))
467  paramError("downward_boundary_source_blocks",
468  "The block '",
469  bid,
470  "' was not found within the mesh");
471 
472  // Move the meshes as requested by the mesh generator system
473  std::unique_ptr<MeshBase> input = std::move(_input);
474  std::unique_ptr<MeshBase> extrusion_curve;
475  if (_extrude_along_curve)
476  extrusion_curve = std::move(_extrusion_curve);
477 
478  // We must serialize the curve to know how to extrude across all ranks
479  std::unique_ptr<libMesh::MeshSerializer> serializer;
480  if (_extrude_along_curve)
481  serializer = std::make_unique<libMesh::MeshSerializer>(*extrusion_curve);
482 
483  // If we're using a distributed mesh... then make sure we don't have any remote elements hanging
484  // around
485  if (!input->is_serial())
486  {
487  input->delete_remote_elements();
488  // This should be a no-op, and yet, it's needed for two THM tests
489  mesh->delete_remote_elements();
490  }
491 
492  if (input->n_nodes() != input->max_node_id())
493  input->renumber_nodes_and_elements();
494 
495  if (input->n_nodes() != input->max_node_id())
496  mooseError(
497  "You must allow renumbering, because the extruded mesh should be contiguously numbered. "
498  "Alternatively, you can use a separate mesh generator (MeshRepairGenerator with the "
499  "renumber_contiguously parameter for example) to renumber the nodes contiguously.");
500 
501  unsigned int total_num_layers;
502  unsigned int total_num_elevations;
503  if (!_extrude_along_curve)
504  {
505  total_num_layers = std::accumulate(_num_layers.begin(), _num_layers.end(), 0);
506  total_num_elevations = _heights.size();
507  }
508  else
509  {
510  total_num_layers = extrusion_curve->n_elem();
511  total_num_elevations = 1;
512  }
513 
514  dof_id_type orig_elem = input->n_elem();
515  dof_id_type orig_nodes = input->n_nodes();
516 
517 #ifdef LIBMESH_ENABLE_UNIQUE_ID
518  unique_id_type orig_unique_ids = input->parallel_max_unique_id();
519  bool has_poly_midnodes = false;
520 #endif
521 
522  bool has_polygons = false;
523  unsigned int order = 1;
524 
525  BoundaryInfo & boundary_info = mesh->get_boundary_info();
526  const BoundaryInfo & input_boundary_info = input->get_boundary_info();
527 
528  // Determine boundary IDs for the new user provided boundary names
529  std::vector<BoundaryName> new_boundary_names;
530  if (_has_bottom_boundary)
531  new_boundary_names.push_back(_bottom_boundary);
532  if (_has_top_boundary)
533  new_boundary_names.push_back(_top_boundary);
534  std::vector<boundary_id_type> new_boundary_ids =
535  MooseMeshUtils::getBoundaryIDs(*input, new_boundary_names, true);
536  const auto user_bottom_boundary_id =
537  _has_bottom_boundary ? new_boundary_ids.front() : libMesh::BoundaryInfo::invalid_id;
538  const auto user_top_boundary_id =
539  _has_top_boundary ? new_boundary_ids.back() : libMesh::BoundaryInfo::invalid_id;
540 
541  // We know a priori how many elements we'll need
542  mesh->reserve_elem(total_num_layers * orig_elem);
543 
544  // Look for higher order elements which introduce an extra layer
545  std::set<ElemType> higher_orders = {EDGE3, EDGE4, TRI6, TRI7, QUAD8, QUAD9};
546  bool extruding_quad_eights = false;
547  std::vector<ElemType> types;
548  MeshTools::elem_types(*input, types);
549  for (const auto elem_type : types)
550  {
551  if (higher_orders.count(elem_type))
552  order = 2;
553  if (elem_type == QUAD8)
554  extruding_quad_eights = true;
555  }
556  mesh->comm().max(order);
557  mesh->comm().max(extruding_quad_eights);
558 
559  // Reserve for the max number possibly needed
560  mesh->reserve_nodes((order * total_num_layers + 1) * orig_nodes);
561 
562  // Container to catch the boundary IDs handed back by the BoundaryInfo object
563  std::vector<boundary_id_type> ids_to_copy;
564 
565  // We need to compute the distance to the axis
566  Real start_radial_extent = 0;
567  Point reference_point;
568  if (_extrude_along_curve)
569  reference_point = *(extrusion_curve->node_ptr(0));
570  else if (!MooseUtils::absoluteFuzzyEqual(_twist_pitch, 0.))
571  // Backwards compatibility: we were twisting along an axis going through the origin
572  reference_point = Point(0, 0, 0);
573  else
574  reference_point = MooseMeshUtils::meshCentroidCalculator(*input);
575 
576  if (_end_radial_extent)
577  {
578  // the center is at the curve if we are extruding along a curve, and the centroid of the mesh
579  // otherwise
580  RealVectorValue reference_direction;
581  if (_extrude_along_curve)
582  reference_direction =
583  _start_extrusion_direction.norm_sq() > 0
584  ? _start_extrusion_direction
585  : RealVectorValue(
586  (*(extrusion_curve->node_ptr(1)) - *(extrusion_curve->node_ptr(0))).unit());
587  else
588  reference_direction = _direction;
589 
590  // now we measure the initial radial extent
591  start_radial_extent =
592  MooseMeshUtils::computeMaxDistanceToAxis(*input, reference_point, reference_direction);
593  }
594 
595  // Compute the total extrusion distance along the axis
596  Real total_extrusion_distance_at_axis;
597  if (_extrude_along_curve)
598  {
599  if (!extrusion_curve->is_prepared())
600  extrusion_curve->prepare_for_use();
601  total_extrusion_distance_at_axis = MeshTools::volume(*extrusion_curve);
602  }
603  else
604  total_extrusion_distance_at_axis = std::accumulate(_heights.begin(), _heights.end(), 0);
605 
606  // Create translated layers of nodes in the direction of extrusion
607  for (const auto & node : input->node_ptr_range())
608  {
609  unsigned int current_node_layer = 0;
610  Point orig_node_to_previous;
611  Point orig_node_to_current;
612  Real sum_step_sizes = 0.;
613  Real sum_step_sizes_at_axis = 0.;
614  // Initial distance from the node to the extrusion axis
615  Real start_node_radius = (*node - reference_point).norm();
616 
617  // e is the elevation layer ordering
618  for (const auto e : make_range(total_num_elevations))
619  {
620  unsigned int num_layers = libMesh::invalid_uint;
621  Real height = std::numeric_limits<Real>::max(), bias = std::numeric_limits<Real>::max();
622  if (_extrude_along_curve)
623  {
624  num_layers = extrusion_curve->n_elem();
625  }
626  else
627  {
628  num_layers = _num_layers[e];
629  height = _heights[e];
630  bias = _biases[e];
631  }
632 
633  // In first layer we also add the base nodes, hence the "plus one"
634  unsigned int num_heights_at_elevation = order * num_layers + (e == 0 ? 1 : 0);
635  // Keep track of the plane normal to the extrusion
636  RealVectorValue prev_intersecting_plane_normal_vec = _start_extrusion_direction;
637 
638  // k is the element layer ordering within each elevation layer
639  for (const auto k : make_range(num_heights_at_elevation))
640  {
641  // Compute 'orig_node_to_current', the update vector
642  // For the first layer we don't need to move
643  if (e == 0 && k == 0)
644  orig_node_to_current.zero();
645  else
646  {
647  // Shift the previous position by a certain fraction of 'height' along the extrusion
648  // direction to get the new position.
649 
650  // Compute orig_node_to_current before any transformation
651  Real step_size = 0;
652  Real step_size_at_axis = 0;
653  if (_extrude_along_curve)
654  {
655  // current point in extrusion curve
656  const Node * P_current = extrusion_curve->node_ptr(k);
657  // previous point in extrusion curve
658  const Node * P_prev = extrusion_curve->node_ptr(k - 1);
659 
660  // Quantities for the previous position of the extruded node
661  const auto old_node = orig_node_to_previous + *node;
662  RealVectorValue b_vec = old_node - *P_prev;
663  Real node_distance_to_curve = b_vec.norm();
664 
665  // Node does not lie exactly on the extrusion curve we are following
666  if (node_distance_to_curve > libMesh::TOLERANCE)
667  {
668  // normal vector to the plane to extrude the point into
669  RealVectorValue intersecting_plane_normal_vec;
670 
671  // Select the extrusion direction based on the curve or the user parameters
672  if (k == 1)
673  {
674  const auto P_next = extrusion_curve->node_ptr(k + 1);
675  intersecting_plane_normal_vec =
676  0.5 * (_start_extrusion_direction + (*P_next - *P_current).unit());
677  }
678  else if (k < order * num_layers - 1)
679  {
680  const auto P_next = extrusion_curve->node_ptr(k + 1);
681  // this approximates the derivative at the spline point
682  intersecting_plane_normal_vec = *P_next - *P_prev;
683  }
684  else
685  {
686  intersecting_plane_normal_vec = (_end_extrusion_direction.norm_sq() > 0)
687  ? _end_extrusion_direction
688  : RealVectorValue(*P_current - *P_prev);
689  }
690  intersecting_plane_normal_vec /= intersecting_plane_normal_vec.norm();
691 
692  Point new_node_point;
693  // If the extrusion direction and the previous plane normal are aligned,
694  // we can't define a rotation axis. We simply translate the points
695  if (MooseUtils::absoluteFuzzyEqual(
696  prev_intersecting_plane_normal_vec.cross(intersecting_plane_normal_vec)
697  .norm_sq(),
698  0))
699  new_node_point = old_node + *P_current - *P_prev;
700  // We use a rotation from the previous extrusion plane normal to the current one
701  // We have tried in the past:
702  // - assuming (P_prev, P_current, old_node, current_node) are coplanar
703  // - assuming (P_prev, P_current) and (old_node, current_node) are parallel
704  // Both result in a slight deformation of the shape during extrusion.
705  else
706  {
707  auto axis = prev_intersecting_plane_normal_vec.cross(intersecting_plane_normal_vec);
708  const auto sin_th = axis.norm();
709  axis /= sin_th;
710  Real cos_th = prev_intersecting_plane_normal_vec * intersecting_plane_normal_vec;
711  // Rodrigues formula for rotation
712  const auto new_v = cos_th * b_vec + axis.cross(b_vec) * sin_th +
713  axis * (axis * b_vec) * (1. - cos_th);
714 
715  mooseAssert(MooseUtils::absoluteFuzzyEqual(new_v.norm(), b_vec.norm()),
716  "Radial extent be conserved");
717  new_node_point = *P_current + new_v;
718  }
719 
720  orig_node_to_current = new_node_point - *node;
721 
722  step_size = (orig_node_to_current - orig_node_to_previous).norm();
723  step_size_at_axis = (*P_current - *P_prev).norm();
724  prev_intersecting_plane_normal_vec = intersecting_plane_normal_vec;
725  }
726  // Point is on the axis of the line
727  else
728  {
729  _direction = *P_current - *P_prev;
730  _direction /= _direction.norm();
731  mooseAssert(std::abs(_direction.norm() - 1.0) < libMesh::TOLERANCE,
732  "Norm of direction vector is not 1!");
733 
734  // Calculate step size.
735  // Note: orig_node_to_previous + *node is the vector description of the
736  // previously-created node
737  step_size = ((*P_current - (orig_node_to_previous + *node)) * _direction);
738  step_size_at_axis = step_size;
739  orig_node_to_current = orig_node_to_previous + _direction * step_size;
740  }
741  }
742  // Extruding in a fixed direction (not along a curve)
743  else
744  {
745  // Divide by the order to avoid applying the bias to the nodes within a higher order
746  // element
747  auto layer_index = (k - (e == 0 ? 1 : 0)) / order + 1;
748  step_size = MooseUtils::absoluteFuzzyEqual(bias, 1.0)
749  ? height / (Real)num_layers / (Real)order
750  : height * std::pow(bias, (Real)(layer_index - 1)) * (1.0 - bias) /
751  (1.0 - std::pow(bias, (Real)(num_layers))) / (Real)order;
752  step_size_at_axis = step_size;
753  orig_node_to_current =
754  orig_node_to_previous +
755  _direction * step_size; // update distance from starting node to new node
756  }
757 
758  // Keep track of the cumulative step size as an extrusion axis coordinate
759  sum_step_sizes += step_size;
760  sum_step_sizes_at_axis += step_size_at_axis;
761 
762  // Handle radial expansion. No need to perform expansion at the centerline
763  if (_end_radial_extent && start_node_radius > libMesh::TOLERANCE)
764  {
765  // How far along we are in the extrusion, measured at the axis (=curve when extruding
766  // along a curve)
767  Real tm1 =
768  (sum_step_sizes_at_axis - step_size_at_axis) / total_extrusion_distance_at_axis;
769  Real t = sum_step_sizes_at_axis / total_extrusion_distance_at_axis;
770 
771  // Direction of radial expansion.
772  RealVectorValue node_to_extrusion_axis;
773  if (_extrude_along_curve)
774  node_to_extrusion_axis =
775  *node + orig_node_to_current - *(extrusion_curve->node_ptr(k));
776  // The radial expansion has to be performed in the rotated frame
777  else if (!MooseUtils::absoluteFuzzyEqual(_twist_pitch, 0.))
778  node_to_extrusion_axis =
779  *node + orig_node_to_current - (reference_point + _direction * sum_step_sizes);
780  // when extruding in a straight line with no twisting, we can use the original radial
781  // direction
782  else
783  node_to_extrusion_axis = *node - reference_point;
784 
785  // Fraction of the total starting radius the node lives in
786  const auto radius_scaling = start_node_radius / start_radial_extent;
787  // Calculate weighting for expansion
788  const auto radial_ratio_m1 = AdvancedExtruderGenerator::radialExpansionRatio(tm1);
789  const auto radial_ratio = AdvancedExtruderGenerator::radialExpansionRatio(t);
790 
791  // Compute change in step
792  orig_node_to_current += (start_radial_extent * (radial_ratio_m1 - radial_ratio) +
793  (radial_ratio - radial_ratio_m1) * _end_radial_extent) *
794  radius_scaling * node_to_extrusion_axis.unit();
795  }
796 
797  // Handle helicoidal extrusion
798  if (!MooseUtils::absoluteFuzzyEqual(_twist_pitch, 0.))
799  {
800  // twist 1 should be 'normal' to the extruded shape
801  RealVectorValue twist1 = _direction.cross(*node);
802  // This happens for any node on the helicoidal extrusion axis
803  if (!MooseUtils::absoluteFuzzyEqual(twist1.norm(), .0))
804  twist1 /= twist1.norm();
805  const RealVectorValue twist2 = twist1.cross(_direction);
806 
807  auto twist =
808  (cos(2. * libMesh::pi * current_node_layer * step_size / _twist_pitch) -
809  cos(2. * libMesh::pi * (current_node_layer - 1) * step_size / _twist_pitch)) *
810  twist2 +
811  (sin(2. * libMesh::pi * current_node_layer * step_size / _twist_pitch) -
812  sin(2. * libMesh::pi * (current_node_layer - 1) * step_size / _twist_pitch)) *
813  twist1;
814 
815  // If we normalize twist, we must multiply by 2 * sin(libMesh::pi * step_size /
816  // _twist_pitch) if (!MooseUtils::absoluteFuzzyEqual(twist.norm(), .0))
817  // twist /= twist.norm();
818 
819  // Get a point on the extrusion axis (around which we currently twist the geometry)
820  // at the local elevation height to be able to compute the distance to the axis
821  Point extrusion_axis_at_elevation;
822  Point prev_extrusion_axis_at_elevation;
823  if (_extrude_along_curve)
824  {
825  extrusion_axis_at_elevation = *extrusion_curve->node_ptr(k);
826  prev_extrusion_axis_at_elevation = *extrusion_curve->node_ptr(k - 1);
827  }
828  else
829  {
830  // We can't use old and current step updates because they have been "twisted"
831  extrusion_axis_at_elevation = reference_point + _direction * sum_step_sizes;
832  prev_extrusion_axis_at_elevation =
833  reference_point + _direction * (sum_step_sizes - step_size);
834  }
835 
836  // Scale with how far the node is from the extrusion axis, before twisting
837  twist *= (*node + orig_node_to_current - extrusion_axis_at_elevation).norm();
838 
839  // No need to twist or expand the point on the axis
840  if (!MooseUtils::absoluteFuzzyEqual(twist1.norm(), .0))
841  orig_node_to_current += twist;
842  }
843  }
844 
845  // Add the new node to the mesh
846  Node * new_node = mesh->add_point(*node + orig_node_to_current,
847  node->id() + (current_node_layer * orig_nodes),
848  node->processor_id());
849 
850 #ifdef LIBMESH_ENABLE_UNIQUE_ID
851  // Let's give the base of the extruded mesh the same
852  // unique_ids as the source mesh, in case anyone finds that
853  // a useful map to preserve.
854  const unique_id_type uid = (current_node_layer == 0)
855  ? node->unique_id()
856  : orig_unique_ids +
857  (current_node_layer - 1) * (orig_elem + orig_nodes) +
858  node->id();
859  new_node->set_unique_id(uid);
860 #endif
861 
862  // Add the new node to the extruded boundaries
863  input_boundary_info.boundary_ids(node, ids_to_copy);
864  if (_boundary_swap_pairs.empty())
865  boundary_info.add_node(new_node, ids_to_copy);
866  else
867  for (const auto & id_to_copy : ids_to_copy)
868  {
869  boundary_info.add_node(new_node,
870  _boundary_swap_pairs[e].count(id_to_copy)
871  ? _boundary_swap_pairs[e][id_to_copy]
872  : id_to_copy);
873  }
874 
875  orig_node_to_previous = orig_node_to_current;
876  current_node_layer++;
877  }
878  }
879  }
880 
881  const auto & side_ids = input_boundary_info.get_side_boundary_ids();
882 
883  boundary_id_type next_side_id =
884  side_ids.empty() ? 0 : cast_int<boundary_id_type>(*side_ids.rbegin() + 1);
885 
886  // side_ids may not include ids from remote elements, in which case
887  // some processors may have underestimated the next_side_id; let's
888  // fix that.
889  input->comm().max(next_side_id);
890 
891  // Map to keep track of polygon sides of polygonal prisms
892  std::map<std::array<unsigned int, 3>, std::shared_ptr<libMesh::Polygon>> poly_extruded_sides;
893 
894  // Build the extruded elements
895  for (const auto & elem : input->element_ptr_range())
896  {
897  const ElemType etype = elem->type();
898 
899  // build_extrusion currently only works on coarse meshes
900  libmesh_assert(!elem->parent());
901 
902  unsigned int current_layer = 0;
903 
904  for (unsigned int e = 0; e != total_num_elevations; e++)
905  {
906  auto num_layers = !_extrude_along_curve ? _num_layers[e] : extrusion_curve->n_nodes() - 1;
907 
908  for (unsigned int k = 0; k != num_layers; ++k)
909  {
910  std::unique_ptr<Elem> new_elem;
911  bool is_flipped(false);
912  switch (etype)
913  {
914  case EDGE2:
915  {
916  new_elem = std::make_unique<Quad4>();
917  new_elem->set_node(
918  0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
919  new_elem->set_node(
920  1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
921  new_elem->set_node(
922  2, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
923  new_elem->set_node(
924  3, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
925 
926  if (elem->neighbor_ptr(0) == remote_elem)
927  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
928  if (elem->neighbor_ptr(1) == remote_elem)
929  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
930 
931  break;
932  }
933  case EDGE3:
934  {
935  new_elem = std::make_unique<Quad9>();
936  new_elem->set_node(
937  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
938  new_elem->set_node(
939  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
940  new_elem->set_node(
941  2,
942  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
943  new_elem->set_node(
944  3,
945  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
946  new_elem->set_node(
947  4, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
948  new_elem->set_node(
949  5,
950  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
951  new_elem->set_node(
952  6,
953  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
954  new_elem->set_node(
955  7,
956  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
957  new_elem->set_node(
958  8,
959  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
960 
961  if (elem->neighbor_ptr(0) == remote_elem)
962  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
963  if (elem->neighbor_ptr(1) == remote_elem)
964  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
965 
966  break;
967  }
968  case TRI3:
969  {
970  new_elem = std::make_unique<Prism6>();
971  new_elem->set_node(
972  0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
973  new_elem->set_node(
974  1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
975  new_elem->set_node(
976  2, mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * orig_nodes)));
977  new_elem->set_node(
978  3, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
979  new_elem->set_node(
980  4, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
981  new_elem->set_node(
982  5, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer + 1) * orig_nodes)));
983 
984  if (elem->neighbor_ptr(0) == remote_elem)
985  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
986  if (elem->neighbor_ptr(1) == remote_elem)
987  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
988  if (elem->neighbor_ptr(2) == remote_elem)
989  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
990 
991  if (new_elem->volume() < 0.0)
992  {
993  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
994  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
995  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
996  is_flipped = true;
997  }
998 
999  break;
1000  }
1001  case TRI6:
1002  {
1003  new_elem = std::make_unique<Prism18>();
1004  new_elem->set_node(
1005  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1006  new_elem->set_node(
1007  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1008  new_elem->set_node(
1009  2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1010  new_elem->set_node(
1011  3,
1012  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1013  new_elem->set_node(
1014  4,
1015  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1016  new_elem->set_node(
1017  5,
1018  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1019  new_elem->set_node(
1020  6, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
1021  new_elem->set_node(
1022  7, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
1023  new_elem->set_node(
1024  8, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
1025  new_elem->set_node(
1026  9,
1027  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1028  new_elem->set_node(
1029  10,
1030  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1031  new_elem->set_node(
1032  11,
1033  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1034  new_elem->set_node(
1035  12,
1036  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
1037  new_elem->set_node(
1038  13,
1039  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
1040  new_elem->set_node(
1041  14,
1042  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
1043  new_elem->set_node(
1044  15,
1045  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
1046  new_elem->set_node(
1047  16,
1048  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
1049  new_elem->set_node(
1050  17,
1051  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
1052 
1053  if (elem->neighbor_ptr(0) == remote_elem)
1054  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
1055  if (elem->neighbor_ptr(1) == remote_elem)
1056  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
1057  if (elem->neighbor_ptr(2) == remote_elem)
1058  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
1059 
1060  if (new_elem->volume() < 0.0)
1061  {
1062  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
1063  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
1064  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
1065  MooseMeshUtils::swapNodesInElem(*new_elem, 6, 12);
1066  MooseMeshUtils::swapNodesInElem(*new_elem, 7, 13);
1067  MooseMeshUtils::swapNodesInElem(*new_elem, 8, 14);
1068  is_flipped = true;
1069  }
1070 
1071  break;
1072  }
1073  case TRI7:
1074  {
1075  new_elem = std::make_unique<Prism21>();
1076  new_elem->set_node(
1077  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1078  new_elem->set_node(
1079  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1080  new_elem->set_node(
1081  2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1082  new_elem->set_node(
1083  3,
1084  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1085  new_elem->set_node(
1086  4,
1087  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1088  new_elem->set_node(
1089  5,
1090  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1091  new_elem->set_node(
1092  6, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
1093  new_elem->set_node(
1094  7, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
1095  new_elem->set_node(
1096  8, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
1097  new_elem->set_node(
1098  9,
1099  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1100  new_elem->set_node(
1101  10,
1102  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1103  new_elem->set_node(
1104  11,
1105  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1106  new_elem->set_node(
1107  12,
1108  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
1109  new_elem->set_node(
1110  13,
1111  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
1112  new_elem->set_node(
1113  14,
1114  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
1115  new_elem->set_node(
1116  15,
1117  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
1118  new_elem->set_node(
1119  16,
1120  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
1121  new_elem->set_node(
1122  17,
1123  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
1124  new_elem->set_node(
1125  18, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
1126  new_elem->set_node(
1127  19,
1128  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
1129  new_elem->set_node(
1130  20,
1131  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 1) * orig_nodes)));
1132 
1133  if (elem->neighbor_ptr(0) == remote_elem)
1134  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
1135  if (elem->neighbor_ptr(1) == remote_elem)
1136  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
1137  if (elem->neighbor_ptr(2) == remote_elem)
1138  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
1139 
1140  if (new_elem->volume() < 0.0)
1141  {
1142  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
1143  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
1144  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
1145  MooseMeshUtils::swapNodesInElem(*new_elem, 6, 12);
1146  MooseMeshUtils::swapNodesInElem(*new_elem, 7, 13);
1147  MooseMeshUtils::swapNodesInElem(*new_elem, 8, 14);
1148  MooseMeshUtils::swapNodesInElem(*new_elem, 18, 19);
1149  is_flipped = true;
1150  }
1151 
1152  break;
1153  }
1154  case QUAD4:
1155  {
1156  new_elem = std::make_unique<Hex8>();
1157  new_elem->set_node(
1158  0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
1159  new_elem->set_node(
1160  1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
1161  new_elem->set_node(
1162  2, mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * orig_nodes)));
1163  new_elem->set_node(
1164  3, mesh->node_ptr(elem->node_ptr(3)->id() + (current_layer * orig_nodes)));
1165  new_elem->set_node(
1166  4, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
1167  new_elem->set_node(
1168  5, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
1169  new_elem->set_node(
1170  6, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer + 1) * orig_nodes)));
1171  new_elem->set_node(
1172  7, mesh->node_ptr(elem->node_ptr(3)->id() + ((current_layer + 1) * orig_nodes)));
1173 
1174  if (elem->neighbor_ptr(0) == remote_elem)
1175  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
1176  if (elem->neighbor_ptr(1) == remote_elem)
1177  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
1178  if (elem->neighbor_ptr(2) == remote_elem)
1179  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
1180  if (elem->neighbor_ptr(3) == remote_elem)
1181  new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
1182 
1183  if (new_elem->volume() < 0.0)
1184  {
1185  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
1186  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
1187  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
1188  MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
1189  is_flipped = true;
1190  }
1191 
1192  break;
1193  }
1194  case QUAD8:
1195  {
1196  new_elem = std::make_unique<Hex20>();
1197  new_elem->set_node(
1198  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1199  new_elem->set_node(
1200  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1201  new_elem->set_node(
1202  2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1203  new_elem->set_node(
1204  3, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
1205  new_elem->set_node(
1206  4,
1207  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1208  new_elem->set_node(
1209  5,
1210  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1211  new_elem->set_node(
1212  6,
1213  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1214  new_elem->set_node(
1215  7,
1216  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
1217  new_elem->set_node(
1218  8, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
1219  new_elem->set_node(
1220  9, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
1221  new_elem->set_node(
1222  10, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
1223  new_elem->set_node(
1224  11, mesh->node_ptr(elem->node_ptr(7)->id() + (2 * current_layer * orig_nodes)));
1225  new_elem->set_node(
1226  12,
1227  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1228  new_elem->set_node(
1229  13,
1230  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1231  new_elem->set_node(
1232  14,
1233  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1234  new_elem->set_node(
1235  15,
1236  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
1237  new_elem->set_node(
1238  16,
1239  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
1240  new_elem->set_node(
1241  17,
1242  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
1243  new_elem->set_node(
1244  18,
1245  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
1246  new_elem->set_node(
1247  19,
1248  mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 2) * orig_nodes)));
1249 
1250  if (elem->neighbor_ptr(0) == remote_elem)
1251  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
1252  if (elem->neighbor_ptr(1) == remote_elem)
1253  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
1254  if (elem->neighbor_ptr(2) == remote_elem)
1255  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
1256  if (elem->neighbor_ptr(3) == remote_elem)
1257  new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
1258 
1259  if (new_elem->volume() < 0.0)
1260  {
1261  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
1262  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
1263  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
1264  MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
1265  MooseMeshUtils::swapNodesInElem(*new_elem, 8, 16);
1266  MooseMeshUtils::swapNodesInElem(*new_elem, 9, 17);
1267  MooseMeshUtils::swapNodesInElem(*new_elem, 10, 18);
1268  MooseMeshUtils::swapNodesInElem(*new_elem, 11, 19);
1269  is_flipped = true;
1270  }
1271 
1272  break;
1273  }
1274  case QUAD9:
1275  {
1276  new_elem = std::make_unique<Hex27>();
1277  new_elem->set_node(
1278  0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1279  new_elem->set_node(
1280  1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1281  new_elem->set_node(
1282  2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1283  new_elem->set_node(
1284  3, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
1285  new_elem->set_node(
1286  4,
1287  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1288  new_elem->set_node(
1289  5,
1290  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1291  new_elem->set_node(
1292  6,
1293  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1294  new_elem->set_node(
1295  7,
1296  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
1297  new_elem->set_node(
1298  8, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
1299  new_elem->set_node(
1300  9, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
1301  new_elem->set_node(
1302  10, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
1303  new_elem->set_node(
1304  11, mesh->node_ptr(elem->node_ptr(7)->id() + (2 * current_layer * orig_nodes)));
1305  new_elem->set_node(
1306  12,
1307  mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1308  new_elem->set_node(
1309  13,
1310  mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1311  new_elem->set_node(
1312  14,
1313  mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1314  new_elem->set_node(
1315  15,
1316  mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
1317  new_elem->set_node(
1318  16,
1319  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
1320  new_elem->set_node(
1321  17,
1322  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
1323  new_elem->set_node(
1324  18,
1325  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
1326  new_elem->set_node(
1327  19,
1328  mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 2) * orig_nodes)));
1329  new_elem->set_node(
1330  20, mesh->node_ptr(elem->node_ptr(8)->id() + (2 * current_layer * orig_nodes)));
1331  new_elem->set_node(
1332  21,
1333  mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
1334  new_elem->set_node(
1335  22,
1336  mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
1337  new_elem->set_node(
1338  23,
1339  mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 1) * orig_nodes)));
1340  new_elem->set_node(
1341  24,
1342  mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 1) * orig_nodes)));
1343  new_elem->set_node(
1344  25,
1345  mesh->node_ptr(elem->node_ptr(8)->id() + ((2 * current_layer + 2) * orig_nodes)));
1346  new_elem->set_node(
1347  26,
1348  mesh->node_ptr(elem->node_ptr(8)->id() + ((2 * current_layer + 1) * orig_nodes)));
1349 
1350  if (elem->neighbor_ptr(0) == remote_elem)
1351  new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
1352  if (elem->neighbor_ptr(1) == remote_elem)
1353  new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
1354  if (elem->neighbor_ptr(2) == remote_elem)
1355  new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
1356  if (elem->neighbor_ptr(3) == remote_elem)
1357  new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
1358 
1359  if (new_elem->volume() < 0.0)
1360  {
1361  MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
1362  MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
1363  MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
1364  MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
1365  MooseMeshUtils::swapNodesInElem(*new_elem, 8, 16);
1366  MooseMeshUtils::swapNodesInElem(*new_elem, 9, 17);
1367  MooseMeshUtils::swapNodesInElem(*new_elem, 10, 18);
1368  MooseMeshUtils::swapNodesInElem(*new_elem, 11, 19);
1369  MooseMeshUtils::swapNodesInElem(*new_elem, 20, 25);
1370  is_flipped = true;
1371  }
1372 
1373  break;
1374  }
1375  case libMesh::C0POLYGON:
1376  {
1377  has_polygons = true;
1378  const auto num_sides = elem->n_sides();
1379  std::vector<std::shared_ptr<libMesh::Polygon>> sides;
1380  sides.reserve(2 + num_sides);
1381  if (2 * elem->n_nodes() > libMesh::C0Polygon::max_n_nodes)
1382  mooseError("Too many nodes in polygons to extrude it. Max number of the prism "
1383  "polyhedral nodes after extrusion: " +
1384  std::to_string(libMesh::C0Polygon::max_n_nodes));
1385  // Make a copy of the original element to use as a side
1386  auto new_ptr = std::make_shared<libMesh::C0Polygon>(num_sides);
1387  for (const auto node_i : make_range(elem->n_nodes()))
1388  {
1389  // This one will be oriented outwards, it should be OK though, polyhedron code does
1390  // not mind
1391  new_ptr->set_node(
1392  node_i,
1393  mesh->node_ptr(elem->node_ptr(node_i)->id() + (current_layer * orig_nodes)));
1394  }
1395  sides.push_back(new_ptr);
1396  // Form the next horizontal side
1397  auto translated_side = std::make_shared<libMesh::C0Polygon>(num_sides);
1398  for (const auto node_i : make_range(elem->n_nodes()))
1399  translated_side->set_node(node_i,
1400  mesh->node_ptr(elem->node_ptr(node_i)->id() +
1401  ((current_layer + 1) * orig_nodes)));
1402  sides.push_back(translated_side);
1403 
1404  // Form the vertical sides
1405  for (const auto side_i : make_range(num_sides))
1406  {
1407  // If the side already exists, use that
1408  std::array<unsigned int, 3> side_key = {
1409  current_layer,
1410  static_cast<unsigned int>(
1411  std::min(elem->node_ptr(side_i)->id(),
1412  elem->node_ptr((side_i + 1) % num_sides)->id())),
1413  static_cast<unsigned int>(
1414  std::max(elem->node_ptr(side_i)->id(),
1415  elem->node_ptr((side_i + 1) % num_sides)->id()))};
1416  if (poly_extruded_sides.count(side_key))
1417  {
1418  sides.push_back(poly_extruded_sides[side_key]);
1419  continue;
1420  }
1421 
1422  // They are all quads, but constructor expects polygons
1423  auto vert_side = std::make_shared<libMesh::C0Polygon>(4);
1424  vert_side->set_node(
1425  0, mesh->node_ptr(elem->node_ptr(side_i)->id() + (current_layer * orig_nodes)));
1426  vert_side->set_node(1,
1427  mesh->node_ptr(elem->node_ptr((side_i + 1) % num_sides)->id() +
1428  (current_layer * orig_nodes)));
1429  vert_side->set_node(2,
1430  mesh->node_ptr(elem->node_ptr((side_i + 1) % num_sides)->id() +
1431  ((current_layer + 1) * orig_nodes)));
1432  vert_side->set_node(3,
1433  mesh->node_ptr(elem->node_ptr(side_i)->id() +
1434  ((current_layer + 1) * orig_nodes)));
1435  sides.push_back(vert_side);
1436 
1437  poly_extruded_sides.insert(std::make_pair(side_key, vert_side));
1438  }
1439  mooseAssert(sides.size() == 2 + num_sides, "Unexpected size of side vector");
1440 
1441  // Create the element from the sides, let libMesh figure out the orientation
1442  std::unique_ptr<libMesh::Node> mid_elem_node;
1443  new_elem = std::make_unique<libMesh::C0Polyhedron>(sides, mid_elem_node);
1444  if (mid_elem_node)
1445  {
1446 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1447  // Number it at the end for convenience
1448  // use the element ID to be able to set in parallel
1449  unsigned int total_new_node_layers = total_num_layers * order;
1450  unsigned int last_uid = orig_unique_ids + (total_new_node_layers - 1) * orig_elem +
1451  total_new_node_layers * orig_nodes + elem->unique_id();
1452  mid_elem_node->set_unique_id(last_uid);
1453  has_poly_midnodes = true;
1454 #endif
1455  mesh->add_node(std::move(mid_elem_node));
1456  }
1457 
1458  break;
1459  }
1460  default:
1461  mooseError("Extrusion is not implemented for element type " + Moose::stringify(etype));
1462  }
1463 
1464  new_elem->set_id(elem->id() + (current_layer * orig_elem));
1465  new_elem->processor_id() = elem->processor_id();
1466 
1467 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1468  // Let's give the base of the extruded mesh the same
1469  // unique_ids as the source mesh, in case anyone finds that
1470  // a useful map to preserve.
1471  const unique_id_type uid = (current_layer == 0)
1472  ? elem->unique_id()
1473  : orig_unique_ids +
1474  (current_layer - 1) * (orig_elem + orig_nodes) +
1475  orig_nodes + elem->id();
1476 
1477  new_elem->set_unique_id(uid);
1478 #endif
1479 
1480  // maintain the subdomain_id
1481  new_elem->subdomain_id() = elem->subdomain_id();
1482 
1483  // define upward boundaries
1484  if (k == num_layers - 1)
1485  {
1486  // Identify the side index of the new element that is part of the upward boundary
1487  const unsigned short top_id =
1488  new_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1489  // Assign sideset id to the side if the element belongs to a specified
1490  // upward_boundary_source_blocks
1491  if (_upward_boundary_source_blocks.size() || _upward_boundary_ids.size())
1492  for (unsigned int i = 0; i < _upward_boundary_source_blocks[e].size(); i++)
1493  if (new_elem->subdomain_id() == _upward_boundary_source_blocks[e][i])
1494  boundary_info.add_side(
1495  new_elem.get(), is_flipped ? 0 : top_id, _upward_boundary_ids[e][i]);
1496  }
1497  // define downward boundaries
1498  if (k == 0)
1499  {
1500  const unsigned short top_id =
1501  new_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1502  if (_downward_boundary_source_blocks.size() || _downward_boundary_ids.size())
1503  for (unsigned int i = 0; i < _downward_boundary_source_blocks[e].size(); i++)
1504  if (new_elem->subdomain_id() == _downward_boundary_source_blocks[e][i])
1505  boundary_info.add_side(
1506  new_elem.get(), is_flipped ? top_id : 0, _downward_boundary_ids[e][i]);
1507  }
1508 
1509  // perform subdomain swaps
1510  if (_subdomain_swap_pairs.size())
1511  {
1512  auto & elevation_swap_pairs = _subdomain_swap_pairs[e];
1513 
1514  auto new_id_it = elevation_swap_pairs.find(elem->subdomain_id());
1515 
1516  if (new_id_it != elevation_swap_pairs.end())
1517  new_elem->subdomain_id() = new_id_it->second;
1518  }
1519 
1520  Elem * added_elem = mesh->add_elem(std::move(new_elem));
1521 
1522  // maintain extra integers
1523  for (unsigned int i = 0; i < num_extra_elem_integers; i++)
1524  added_elem->set_extra_integer(i, elem->get_extra_integer(i));
1525 
1526  if (_elem_integers_swap_pairs.size())
1527  {
1528  for (unsigned int i = 0; i < _elem_integer_indices_to_swap.size(); i++)
1529  {
1530  auto & elevation_extra_swap_pairs = _elem_integers_swap_pairs[i * _heights.size() + e];
1531 
1532  auto new_extra_id_it = elevation_extra_swap_pairs.find(
1533  elem->get_extra_integer(_elem_integer_indices_to_swap[i]));
1534 
1535  if (new_extra_id_it != elevation_extra_swap_pairs.end())
1536  added_elem->set_extra_integer(_elem_integer_indices_to_swap[i],
1537  new_extra_id_it->second);
1538  }
1539  }
1540 
1541  // Copy any old boundary ids on all sides
1542  for (auto s : elem->side_index_range())
1543  {
1544  input_boundary_info.boundary_ids(elem, s, ids_to_copy);
1545 
1546  if (added_elem->dim() == 3)
1547  {
1548  // For 2D->3D extrusion, we give the boundary IDs
1549  // for side s on the old element to side s+1 on the
1550  // new element. This is just a happy coincidence as
1551  // far as I can tell...
1552  if (_boundary_swap_pairs.empty())
1553  boundary_info.add_side(added_elem, cast_int<unsigned short>(s + 1), ids_to_copy);
1554  else
1555  for (const auto & id_to_copy : ids_to_copy)
1556  boundary_info.add_side(added_elem,
1557  cast_int<unsigned short>(s + 1),
1558  _boundary_swap_pairs[e].count(id_to_copy)
1559  ? _boundary_swap_pairs[e][id_to_copy]
1560  : id_to_copy);
1561  }
1562  else
1563  {
1564  // For 1D->2D extrusion, the boundary IDs map as:
1565  // Old elem -> New elem
1566  // 0 -> 3
1567  // 1 -> 1
1568  libmesh_assert_less(s, 2);
1569  const unsigned short sidemap[2] = {3, 1};
1570  if (_boundary_swap_pairs.empty())
1571  boundary_info.add_side(added_elem, sidemap[s], ids_to_copy);
1572  else
1573  for (const auto & id_to_copy : ids_to_copy)
1574  boundary_info.add_side(added_elem,
1575  sidemap[s],
1576  _boundary_swap_pairs[e].count(id_to_copy)
1577  ? _boundary_swap_pairs[e][id_to_copy]
1578  : id_to_copy);
1579  }
1580  }
1581 
1582  // Give new boundary ids to bottom and top
1583  if (current_layer == 0)
1584  {
1585  const unsigned short top_id =
1586  added_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1587  if (_has_bottom_boundary)
1588  {
1589  mooseAssert(user_bottom_boundary_id != libMesh::BoundaryInfo::invalid_id,
1590  "We should have retrieved a proper boundary ID");
1591  boundary_info.add_side(added_elem, is_flipped ? top_id : 0, user_bottom_boundary_id);
1592  }
1593  else
1594  boundary_info.add_side(added_elem, is_flipped ? top_id : 0, next_side_id);
1595  }
1596 
1597  if (current_layer == total_num_layers - 1)
1598  {
1599  // For 2D->3D extrusion, the "top" ID is 1+the original
1600  // element's number of sides. For 1D->2D extrusion, the
1601  // "top" ID is side 2.
1602  const unsigned short top_id =
1603  added_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1604 
1605  if (_has_top_boundary)
1606  {
1607  mooseAssert(user_top_boundary_id != libMesh::BoundaryInfo::invalid_id,
1608  "We should have retrieved a proper boundary ID");
1609  boundary_info.add_side(added_elem, is_flipped ? 0 : top_id, user_top_boundary_id);
1610  }
1611  else
1612  boundary_info.add_side(
1613  added_elem, is_flipped ? 0 : top_id, cast_int<boundary_id_type>(next_side_id + 1));
1614  }
1615 
1616  current_layer++;
1617  }
1618  }
1619  }
1620 
1621  if (has_polygons && !input->is_serial())
1622  mooseError("Distributed meshes are not supported when extruding polygons at this time.");
1623 
1624 #ifdef LIBMESH_ENABLE_UNIQUE_ID
1625  // Update the value of next_unique_id based on newly created nodes and elements
1626  // Note: Number of element layers is one less than number of node layers
1627  unsigned int total_new_node_layers = total_num_layers * order;
1628  unsigned int new_unique_ids = orig_unique_ids + (total_new_node_layers - 1) * orig_elem +
1629  total_new_node_layers * orig_nodes;
1630  // Maximum case for the unique ids: all poly elements have a midnode
1631  if (has_poly_midnodes)
1632  new_unique_ids += orig_elem;
1633  mesh->set_next_unique_id(new_unique_ids);
1634 #endif
1635 
1636  // Copy all the subdomain/sideset/nodeset name maps to the extruded mesh
1637  if (!input_subdomain_map.empty())
1638  mesh->set_subdomain_name_map().insert(input_subdomain_map.begin(), input_subdomain_map.end());
1639  if (!input_sideset_map.empty())
1640  mesh->get_boundary_info().set_sideset_name_map().insert(input_sideset_map.begin(),
1641  input_sideset_map.end());
1642  if (!input_nodeset_map.empty())
1643  mesh->get_boundary_info().set_nodeset_name_map().insert(input_nodeset_map.begin(),
1644  input_nodeset_map.end());
1645 
1646  if (_has_bottom_boundary)
1647  boundary_info.sideset_name(new_boundary_ids.front()) = new_boundary_names.front();
1648  if (_has_top_boundary)
1649  boundary_info.sideset_name(new_boundary_ids.back()) = new_boundary_names.back();
1650 
1651  mesh->unset_is_prepared();
1652  // Creating the layered meshes creates a lot of leftover nodes, notably in the boundary_info,
1653  // which will crash both paraview and trigger exodiff. Best to be safe.
1654  if (extruding_quad_eights)
1655  mesh->prepare_for_use();
1656 
1657  return mesh;
1658 }
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
Eigen::internal::abs
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:50
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
AdvancedExtruderGenerator::_end_extrusion_direction
const RealVectorValue _end_extrusion_direction
Extrusion direction for the final layer of the extrusion.
Definition: AdvancedExtruderGenerator.h:72
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
libMesh::invalid_uint
const unsigned int invalid_uint
QUAD8
QUAD8
AdvancedExtruderGenerator::_end_radial_extent
const Real _end_radial_extent
Radial extent of the extruded geometry at the end of the extrusion.
Definition: AdvancedExtruderGenerator.h:99
AdvancedExtruderGenerator::_extrusion_curve
std::unique_ptr< MeshBase > & _extrusion_curve
Curve mesh to extrude along.
Definition: AdvancedExtruderGenerator.h:68
MooseBase::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: MooseBase.h:467
libMesh::TOLERANCE
static constexpr Real TOLERANCE
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:495
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:95
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:89
CompileTimeDerivatives::max
auto max(const L &left, const R &right)
Definition: CompileTimeDerivatives.h:276
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:86
QUAD4
QUAD4
MooseMeshUtils::hasSubdomainID
bool hasSubdomainID(const MeshBase &input_mesh, const SubdomainID &id)
Whether a particular subdomain ID exists in the mesh.
VectorValue< Real >::unit
TypeVector< Real > unit() const
VectorValue< Real >::norm_sq
auto norm_sq() const
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
sides
char ** sides
Definition: PetscDMMoose.C:1750
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:92
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:118
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
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
libMesh::MeshTools::volume
Real volume(const MeshBase &mesh, unsigned int dim=libMesh::invalid_uint)
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
AdvancedExtruderGenerator::_extrude_along_curve
bool _extrude_along_curve
Whether we are extruding along a curve.
Definition: AdvancedExtruderGenerator.h:74
AdvancedExtruderGenerator::radialExpansionRatio
Real radialExpansionRatio(const Real t) const
Calculate the share of the radial expansion to apply at the local node This share goes from 0 at the ...
Definition: AdvancedExtruderGenerator.C:1661
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
EDGE2
EDGE2
norm
auto norm(const T &a)
AdvancedExtruderGenerator::_biases
const std::vector< Real > _biases
Bias growth factor of each elevation.
Definition: AdvancedExtruderGenerator.h:36
make_range
IntRange< T > make_range(T beg, T end)
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
TRI7
TRI7
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:83
AdvancedExtruderGenerator::_num_layers
const std::vector< unsigned int > & _num_layers
Number of layers in each elevation.
Definition: AdvancedExtruderGenerator.h:39
MooseMeshUtils::meshCentroidCalculator
Point meshCentroidCalculator(const MeshBase &mesh)
Calculates the centroid of a MeshBase.
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:289
MooseMeshUtils::computeMaxDistanceToAxis
Real computeMaxDistanceToAxis(const MeshBase &mesh, const Point &origin, const RealVectorValue &direction)
Computes the maximum distance from all nodes of a mesh to a general axis.
CompileTimeDerivatives::min
auto min(const L &left, const R &right)
Definition: CompileTimeDerivatives.h:269
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
libMesh::C0Polygon::max_n_nodes
static const unsigned int max_n_nodes
AdvancedExtruderGenerator::_start_extrusion_direction
const RealVectorValue _start_extrusion_direction
Extrusion direction to follow at the start (first layer) of the extrusion.
Definition: AdvancedExtruderGenerator.h:70
dof_id_type
uint8_t dof_id_type
libMesh::pi
const Real pi
remote_elem
const RemoteElem * remote_elem

◆ generateCSG()

std::unique_ptr< CSG::CSGBase > MeshGenerator::generateCSG ( )
protectedvirtualinherited

Generate the CSG representation of the mesh (or meshing operation) created by this mesh generator.

Definition at line 507 of file MeshGenerator.C.

Referenced by MeshGenerator::generateInternalCSG().

508 {
509  mooseAssert(!hasGenerateCSG(), "Inconsistent flag");
510  mooseError("This MeshGenerator does not have a generateCSG() implementation.");
511 }
MeshGenerator::hasGenerateCSG
bool hasGenerateCSG() const
Definition: MeshGenerator.h:209
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281

◆ generateData()

void MeshGenerator::generateData ( )
protectedvirtualinherited

Generate the mesh data.

Reimplemented in AddMetaDataGenerator.

Definition at line 500 of file MeshGenerator.C.

Referenced by MeshGenerator::generateInternal().

501 {
502  mooseAssert(!hasGenerateData(), "Inconsistent flag");
503  mooseError("This MeshGenerator does not have a generateData() implementation.");
504 }
MeshGenerator::hasGenerateData
bool hasGenerateData() const
Definition: MeshGenerator.h:204
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281

◆ 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 310 of file MeshGenerator.C.

311 {
312  libmesh_parallel_only(comm());
313  mooseAssert(comm().verify(type() + name()), "Inconsistent execution ordering");
314 
315  if (hasGenerateData())
316  generateData();
317 
318  if (isDataOnly())
319  return nullptr;
320 
321  auto mesh = generate();
322  if (!mesh)
323  mooseError("A mesh was not generated by this generator (it was nullptr).");
324 
325  for (const auto & [requested_name, requested_mesh] : _requested_meshes)
326  if (*requested_mesh)
327  mooseError(
328  "The mesh from input ",
329  _app.getMeshGenerator(requested_name).type(),
330  " '",
331  _app.getMeshGenerator(requested_name).name(),
332  "' was not moved.\n\nThe MeshGenerator system requires that the memory from all input "
333  "meshes\nare managed by the requesting MeshGenerator during the generate phase.\n\nThis "
334  "is achieved with a std::move() operation within the generate() method.");
335 
336  if (getParam<bool>("show_info"))
337  {
338  if (!mesh->is_prepared())
339  mesh->prepare_for_use();
340 
341  const auto mesh_info = mesh->get_info(/* verbosity = */ 2);
342 
343  // We will prefix all information with "type() 'name()':" because this could potentially
344  // output a ton of information and looks a bit better with a prefix
345  std::stringstream oss;
346  const auto split = MooseUtils::split(mesh_info, "\n");
347  if (split.size())
348  for (std::size_t i = 0; i < split.size() - 1; ++i) // ignore the last line break
349  oss << COLOR_CYAN << "" << type() << " '" << name() << "': " << COLOR_DEFAULT << split[i]
350  << std::endl;
351  _console << oss.str() << std::flush;
352  }
353 
354  // output the current mesh block to file
355  if (hasOutput())
356  {
357  if (!mesh->is_prepared())
358  mesh->prepare_for_use();
359 
360  if (!getParam<bool>("nemesis"))
361  {
362  libMesh::ExodusII_IO exio(*mesh);
363 
364  if (mesh->mesh_dimension() == 1)
365  exio.write_as_dimension(3);
366 
367  // Avoid truncating names
368  exio.set_max_name_length(80);
369 
370  // Default to non-HDF5 output for wider compatibility
371  exio.set_hdf5_writing(false);
372 
373  exio.write(name() + "_in.e");
374  }
375  else
376  {
377  libMesh::Nemesis_IO nemesis_io(*mesh);
378 
379  // Default to non-HDF5 output for wider compatibility
380  nemesis_io.set_hdf5_writing(false);
381 
382  nemesis_io.write(name() + "_in.e");
383  }
384  }
385 
386  return mesh;
387 }
MooseApp::getMeshGenerator
const MeshGenerator & getMeshGenerator(const std::string &name) const
Definition: MooseApp.h:894
libMesh::ExodusII_IO
MeshGenerator::generateData
virtual void generateData()
Generate the mesh data.
Definition: MeshGenerator.C:500
mesh
MeshBase & mesh
MeshGenerator::hasOutput
bool hasOutput() const
Definition: MeshGenerator.C:488
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
MeshGenerator::hasGenerateData
bool hasGenerateData() const
Definition: MeshGenerator.h:204
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:505
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
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:93
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
split
tbb::split split
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
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:214
MooseUtils::split
std::vector< std::string > split(const std::string &str, const std::string &delimiter, std::size_t max_count)
Definition: MooseUtils.C:1020

◆ generateInternalCSG()

std::unique_ptr< CSG::CSGBase > MeshGenerator::generateInternalCSG ( )
inherited

Internal generation method for CSG object generation.

Definition at line 390 of file MeshGenerator.C.

391 {
392  mooseAssert(isDataOnly(), "Trying to use csg-only mode while not in data-driven mode");
393  auto csg_obj = generateCSG();
394  mooseAssert(csg_obj, "Null CSG object");
395  for (const auto & [requested_name, requested_csg] : _requested_csg_bases)
396  if (*requested_csg)
397  mooseError(
398  "The CSGBase object from input ",
399  _app.getMeshGenerator(requested_name).type(),
400  " '",
401  _app.getMeshGenerator(requested_name).name(),
402  "' was not moved.\n\nThe MeshGenerator system requires that the memory from all input "
403  "meshes\nare managed by the requesting MeshGenerator during the generate phase.\n\nThis "
404  "is achieved with a std::move() operation within the generateCSG() method.");
405 
406  return csg_obj;
407 }
MooseApp::getMeshGenerator
const MeshGenerator & getMeshGenerator(const std::string &name) const
Definition: MooseApp.h:894
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
MeshGenerator::_requested_csg_bases
std::vector< std::pair< std::string, std::unique_ptr< CSG::CSGBase > * > > _requested_csg_bases
The CSGBase objects that were requested by this MeshGenerator; used to verify that any input meshes t...
Definition: MeshGenerator.h:508
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
MeshGenerator::isDataOnly
bool isDataOnly() const
Definition: MeshGenerator.h:214
MeshGenerator::generateCSG
virtual std::unique_ptr< CSG::CSGBase > generateCSG()
Generate the CSG representation of the mesh (or meshing operation) created by this mesh generator...
Definition: MeshGenerator.C:507

◆ getBase()

const std::string& MooseBase::getBase ( ) const
inlineinherited
Returns
The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

147 { return _pars.getBase(); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
InputParameters::getBase
const std::string & getBase() const
Definition: InputParameters.C:505

◆ getCheckedPointerParam()

template<typename T >
T MooseBase::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 460 of file MooseBase.h.

461 {
462  return _pars.getCheckedPointerParam<T>(name, error_string);
463 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
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:1754
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ getChildMeshGenerators()

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

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 148 of file MeshGenerator.h.

Referenced by MeshGenerator::isChildMeshGenerator().

149  {
150  return _child_mesh_generators;
151  }
MeshGenerator::_child_mesh_generators
std::set< const MeshGenerator *, Comparator > _child_mesh_generators
The MeshGenerators that are children to this MeshGenerator.
Definition: MeshGenerator.h:519

◆ getCSGBase()

std::unique_ptr< CSG::CSGBase > & MeshGenerator::getCSGBase ( const std::string &  param_name)
protectedinherited

Takes the name of a MeshGeneratorName parameter and then gets a pointer to the CSGBase object that MeshGenerator has created.

NOTE: You MUST catch this by reference!

Parameters
param_nameThe name of the parameter that contains the name of the MeshGenerator
Returns
The CSGBase object generated by that MeshGenerator

Definition at line 223 of file MeshGenerator.C.

224 {
225  const MeshGeneratorName * name = getMeshGeneratorNameFromParam(param_name, false);
226  if (!name)
227  return _null_csg_base;
228  return getCSGBaseByName(*name);
229 }
MeshGenerator::_null_csg_base
std::unique_ptr< CSG::CSGBase > _null_csg_base
A nullptr to use for when inputs aren&#39;t specified.
Definition: MeshGenerator.h:514
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshGenerator::getCSGBaseByName
std::unique_ptr< CSG::CSGBase > & getCSGBaseByName(const MeshGeneratorName &mesh_generator_name)
Like getCSGBase(), but takes the name of another MeshGenerator directly.
Definition: MeshGenerator.C:232
MeshGenerator::getMeshGeneratorNameFromParam
const MeshGeneratorName * getMeshGeneratorNameFromParam(const std::string &param_name, const bool allow_invalid) const
Helper for getting a MeshGeneratorName parameter.
Definition: MeshGenerator.C:106

◆ getCSGBaseByName()

std::unique_ptr< CSG::CSGBase > & MeshGenerator::getCSGBaseByName ( const MeshGeneratorName &  mesh_generator_name)
protectedinherited

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

NOTE: You MUST catch this by reference!

Parameters
mesh_generator_nameThe name of the MeshGenerator associated with the CSGBase object
Returns
The CSGBase pointer generated by that MeshGenerator

Definition at line 232 of file MeshGenerator.C.

Referenced by MeshGenerator::getCSGBase(), and MeshGenerator::getCSGBasesByName().

233 {
234  checkGetMesh(mesh_generator_name, "");
235  if (isNullMeshName(mesh_generator_name))
236  return _null_csg_base;
237 
238  auto & csg_base = _app.getMeshGeneratorSystem().getCSGBaseGeneratorOutput(mesh_generator_name);
239  _requested_csg_bases.emplace_back(mesh_generator_name, &csg_base);
240  return csg_base;
241 }
MeshGeneratorSystem::getCSGBaseGeneratorOutput
std::unique_ptr< CSG::CSGBase > & getCSGBaseGeneratorOutput(const MeshGeneratorName &name)
Returns the output CSGBase object associated with a particular mesh generator name.
Definition: MeshGeneratorSystem.C:726
MeshGenerator::_null_csg_base
std::unique_ptr< CSG::CSGBase > _null_csg_base
A nullptr to use for when inputs aren&#39;t specified.
Definition: MeshGenerator.h:514
MeshGenerator::isNullMeshName
bool isNullMeshName(const MeshGeneratorName &name) const
Definition: MeshGenerator.h:184
MeshGenerator::_requested_csg_bases
std::vector< std::pair< std::string, std::unique_ptr< CSG::CSGBase > * > > _requested_csg_bases
The CSGBase objects that were requested by this MeshGenerator; used to verify that any input meshes t...
Definition: MeshGenerator.h:508
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
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:158
MooseApp::getMeshGeneratorSystem
MeshGeneratorSystem & getMeshGeneratorSystem()
Gets the system that manages the MeshGenerators.
Definition: MooseApp.h:860

◆ getCSGBases()

std::vector< std::unique_ptr< CSG::CSGBase > * > MeshGenerator::getCSGBases ( const std::string &  param_name)
protectedinherited

Like getCSGBase(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters
param_nameThe name of the parameter that contains the names of MeshGenerator objects
Returns
Vector of CSGBase pointers associated with input parameter

Definition at line 244 of file MeshGenerator.C.

245 {
246  return getCSGBasesByName(getMeshGeneratorNamesFromParam(param_name));
247 }
MeshGenerator::getMeshGeneratorNamesFromParam
const std::vector< MeshGeneratorName > & getMeshGeneratorNamesFromParam(const std::string &param_name) const
Helper for getting a std::vector<MeshGeneratorName> parameter.
Definition: MeshGenerator.C:135
MeshGenerator::getCSGBasesByName
std::vector< std::unique_ptr< CSG::CSGBase > * > getCSGBasesByName(const std::vector< MeshGeneratorName > &mesh_generator_names)
Like getCSGBaseByName(), but for multiple generators.
Definition: MeshGenerator.C:250

◆ getCSGBasesByName()

std::vector< std::unique_ptr< CSG::CSGBase > * > MeshGenerator::getCSGBasesByName ( const std::vector< MeshGeneratorName > &  mesh_generator_names)
protectedinherited

Like getCSGBaseByName(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters
mesh_generator_namesThe names of MeshGenerator objects
Returns
Vector of CSGBase pointers associated with input parameter

Definition at line 250 of file MeshGenerator.C.

Referenced by MeshGenerator::getCSGBases().

251 {
252  std::vector<std::unique_ptr<CSG::CSGBase> *> csg_bases;
253  for (const auto & name : mesh_generator_names)
254  csg_bases.push_back(&getCSGBaseByName(name));
255  return csg_bases;
256 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshGenerator::getCSGBaseByName
std::unique_ptr< CSG::CSGBase > & getCSGBaseByName(const MeshGeneratorName &mesh_generator_name)
Like getCSGBase(), but takes the name of another MeshGenerator directly.
Definition: MeshGenerator.C:232

◆ 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 }
MooseBase::getParam
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition: MooseBase.h:416
MooseBase::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Emits a deprecation warning prefixed with the object name and type, and a stack trace.
Definition: MooseBase.h:327
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
MooseBase::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Emits a deprecation warning prefixed with the object name and type, and a stack trace.
Definition: MooseBase.h:327
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  // This will search the data paths for this relative path
50  std::optional<std::string> error;
51  Moose::DataFileUtils::Path found_path;
52  {
53  // Throw on error so that if getPath() fails, we can throw an error
54  // with the context of _parent.mooseError()
55  Moose::ScopedThrowOnError scoped_throw_on_error;
56 
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 
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 }
MooseBase::mooseInfo
void mooseInfo(Args &&... args) const
Definition: MooseBase.h:344
Moose::DataFileUtils::Path::context
Context context
Context for the file (where it came from)
Definition: DataFileUtils.h:52
Moose::DataFileUtils::Context::DATA
From installed/in-tree data.
Moose::DataFileUtils::getPath
Path getPath(std::string path, const GetPathOptions &options={})
Get the data path for a given path, searching the registered data.
Definition: DataFileUtils.C:22
Moose::DataFileUtils::Path
Representation of a data file path.
Definition: DataFileUtils.h:40
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:54
Moose::ScopedThrowOnError
Scoped helper for setting Moose::_throw_on_error during this scope.
Definition: Moose.h:295
MooseBase::mooseWarning
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:309
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
DataFileInterface::_parent
const ParallelParamObject & _parent
Definition: DataFileInterface.h:58

◆ getHitNode()

const hit::Node* MooseBase::getHitNode ( ) const
inlineinherited
Returns
The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

136 { return getHitNode(_pars); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MooseBase::getHitNode
const hit::Node * getHitNode() const
Definition: MooseBase.h:136

◆ 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 186 of file MeshGenerator.C.

187 {
188  const MeshGeneratorName * name = getMeshGeneratorNameFromParam(param_name, allow_invalid);
189  if (!name)
190  return _null_mesh;
191  return getMeshByName(*name);
192 }
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:201
MeshGenerator::_null_mesh
std::unique_ptr< MeshBase > _null_mesh
A nullptr to use for when inputs aren&#39;t specified.
Definition: MeshGenerator.h:511
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshGenerator::getMeshGeneratorNameFromParam
const MeshGeneratorName * getMeshGeneratorNameFromParam(const std::string &param_name, const bool allow_invalid) const
Helper for getting a MeshGeneratorName parameter.
Definition: MeshGenerator.C:106

◆ 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 201 of file MeshGenerator.C.

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

202 {
203  checkGetMesh(mesh_generator_name, "");
204  if (isNullMeshName(mesh_generator_name))
205  return _null_mesh;
206 
207  _requested_mesh_generators.insert(mesh_generator_name);
208  auto & mesh = _app.getMeshGeneratorSystem().getMeshGeneratorOutput(mesh_generator_name);
209  _requested_meshes.emplace_back(mesh_generator_name, &mesh);
210  return mesh;
211 }
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:597
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:511
MeshGenerator::isNullMeshName
bool isNullMeshName(const MeshGeneratorName &name) const
Definition: MeshGenerator.h:184
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:505
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:500
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
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:158
MooseApp::getMeshGeneratorSystem
MeshGeneratorSystem & getMeshGeneratorSystem()
Gets the system that manages the MeshGenerators.
Definition: MooseApp.h:860

◆ 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 195 of file MeshGenerator.C.

196 {
197  return getMeshesByName(getMeshGeneratorNamesFromParam(param_name));
198 }
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:214
MeshGenerator::getMeshGeneratorNamesFromParam
const std::vector< MeshGeneratorName > & getMeshGeneratorNamesFromParam(const std::string &param_name) const
Helper for getting a std::vector<MeshGeneratorName> parameter.
Definition: MeshGenerator.C:135

◆ 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 214 of file MeshGenerator.C.

Referenced by MeshGenerator::getMeshes().

215 {
216  std::vector<std::unique_ptr<MeshBase> *> meshes;
217  for (const auto & name : mesh_generator_names)
218  meshes.push_back(&getMeshByName(name));
219  return meshes;
220 }
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:201
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ 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 142 of file MeshMetaDataInterface.h.

144 {
145  if (!hasMeshProperty(data_name, prefix))
146  mooseErrorInternal("Failed to get mesh property '", prefix, "/", data_name, "'");
147 
148  auto value = &getMeshPropertyInternal(data_name, prefix);
149  mooseAssert(value->declared(), "Value has not been declared");
150  const RestartableData<T> * T_value = dynamic_cast<const RestartableData<T> *>(value);
151  if (!T_value)
152  mooseErrorInternal("While retrieving mesh property '",
153  prefix,
154  "/",
155  data_name,
156  "' with type '",
157  MooseUtils::prettyCppType<T>(),
158  "',\nthe property exists with different type '",
159  value->type(),
160  "'");
161  return T_value->get();
162 }
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:132
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:33
MeshMetaDataInterface::getMeshPropertyInternal
const RestartableDataValue & getMeshPropertyInternal(const std::string &data_name, const std::string &prefix) const
Helper for getting a mesh property.
Definition: MeshMetaDataInterface.C:54

◆ getMeshProperty() [2/2]

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

Definition at line 64 of file MeshMetaDataInterface.h.

65  {
66  return getMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
67  }
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:47

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const
inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

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

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

◆ getParam() [1/2]

template<typename T >
const T & MooseBase::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 416 of file MooseBase.h.

Referenced by CreateDisplacedProblemAction::act(), CommonOutputAction::act(), CylinderComponent::addMeshGenerators(), FEProblemBase::addOutput(), DiffusionPhysicsBase::addPostprocessors(), ArrayParsedAux::ArrayParsedAux(), BicubicSplineFunction::BicubicSplineFunction(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Console::Console(), FEProblemBase::createTagSolutions(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), AccumulateReporter::declareLateValues(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MFEMEigenvaluesPostprocessor::execute(), FEProblemSolve::FEProblemSolve(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), ParsedSubdomainGeneratorBase::functionInitialize(), FVInterfaceKernel::FVInterfaceKernel(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), OrientSurfaceMeshGenerator::generate(), CoarsenBlockGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), BreakMeshByBlockGenerator::generate(), BlockDeletionGenerator::generate(), MeshExtruderGenerator::generate(), XYDelaunayGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), MFEMExecutedObject::getRequestedItems(), GhostingUserObject::GhostingUserObject(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), IterationAdaptiveDT::init(), AdvancedOutput::init(), AdvancedOutput::initAvailableLists(), AttribThread::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), MultiSystemSolveObject::MultiSystemSolveObject(), NEML2ModelExecutor::NEML2ModelExecutor(), NestedDivision::NestedDivision(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), Output::setWallTimeIntervalFromCommandLineParam(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

417 {
418  return InputParameters::getParamHelper<T>(name, _pars);
419 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ getParam() [2/2]

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > > MooseBase::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 453 of file MooseBase.h.

454 {
455  return _pars.get<T1, T2>(param1, param2);
456 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
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:2305

◆ getParentMeshGenerators()

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

Gets the MeshGenerators that are parents to this MeshGenerator.

Definition at line 141 of file MeshGenerator.h.

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

142  {
143  return _parent_mesh_generators;
144  }
MeshGenerator::_parent_mesh_generators
std::set< const MeshGenerator *, Comparator > _parent_mesh_generators
The MeshGenerators that are parents to this MeshGenerator.
Definition: MeshGenerator.h:517

◆ getRenamedParam()

template<typename T >
const T & MooseBase::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 430 of file MooseBase.h.

431 {
432  // Most important: accept new parameter
433  if (isParamSetByUser(new_name) && !isParamValid(old_name))
434  return getParam<T>(new_name);
435  // Second most: accept old parameter
436  if (isParamValid(old_name) && !isParamSetByUser(new_name))
437  return getParam<T>(old_name);
438  // Third most: accept default for new parameter
439  if (isParamValid(new_name) && !isParamValid(old_name))
440  return getParam<T>(new_name);
441  // Refuse: no default, no value passed
442  if (!isParamValid(old_name) && !isParamValid(new_name))
443  mooseError("parameter '" + new_name +
444  "' is being retrieved without being set.\nDid you misspell it?");
445  // Refuse: both old and new parameters set by user
446  else
447  mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
448  old_name + "'");
449 }
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:209
MooseBase::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
Definition: MooseBase.h:215

◆ 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 99 of file MeshGenerator.h.

100  {
101  return _requested_mesh_generators;
102  }
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:500

◆ 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 107 of file MeshGenerator.h.

108  {
109  return _requested_mesh_generators_for_sub;
110  }
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:502

◆ getSavedMeshName()

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

Return the name of the saved mesh.

Definition at line 494 of file MeshGenerator.C.

495 {
496  return _save_with_name;
497 }
MeshGenerator::_save_with_name
const std::string & _save_with_name
A user-defined name to save the mesh.
Definition: MeshGenerator.h:527

◆ 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 70 of file MooseObject.C.

Referenced by MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), and WebServerControl::addServerAction().

71 {
72  try
73  {
74  return shared_from_this();
75  }
76  catch (std::bad_weak_ptr &)
77  {
78  mooseError(not_shared_error);
79  }
80 }
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281

◆ getSharedPtr() [2/2]

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

Definition at line 83 of file MooseObject.C.

84 {
85  try
86  {
87  return shared_from_this();
88  }
89  catch (std::bad_weak_ptr &)
90  {
91  mooseError(not_shared_error);
92  }
93 }
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281

◆ getSubMeshGenerators()

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

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 155 of file MeshGenerator.h.

156  {
157  return _sub_mesh_generators;
158  }
MeshGenerator::_sub_mesh_generators
std::set< const MeshGenerator *, Comparator > _sub_mesh_generators
The sub MeshGenerators constructed by this MeshGenerator.
Definition: MeshGenerator.h:521

◆ hasBase()

bool MooseBase::hasBase ( ) const
inlineinherited
Returns
Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142 { return _pars.hasBase(); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
InputParameters::hasBase
bool hasBase() const
Definition: InputParameters.C:499

◆ hasGenerateCSG() [1/2]

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

Definition at line 100 of file MeshGenerator.C.

101 {
102  return params.get<bool>("_has_generate_csg");
103 }
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:2305

◆ hasGenerateCSG() [2/2]

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

Definition at line 209 of file MeshGenerator.h.

Referenced by MeshGenerator::checkGetMesh(), MeshGenerator::generateCSG(), MeshGenerator::hasGenerateCSG(), and MeshGenerator::MeshGenerator().

209 { return hasGenerateCSG(_pars); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MeshGenerator::hasGenerateCSG
bool hasGenerateCSG() const
Definition: MeshGenerator.h:209

◆ 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 88 of file MeshGenerator.C.

89 {
90  return params.get<bool>("_has_generate_data");
91 }
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:2305

◆ hasGenerateData() [2/2]

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

Definition at line 204 of file MeshGenerator.h.

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

204 { return hasGenerateData(_pars); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MeshGenerator::hasGenerateData
bool hasGenerateData() const
Definition: MeshGenerator.h:204

◆ 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 33 of file MeshMetaDataInterface.C.

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

35 {
36  return _meta_data_app.hasRestartableMetaData(meshPropertyName(data_name, prefix),
37  MooseApp::MESH_META_DATA);
38 }
MooseApp::hasRestartableMetaData
bool hasRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname) const
Definition: MooseApp.C:2228
MooseApp::MESH_META_DATA
static const RestartableDataMapName MESH_META_DATA
Definition: MooseApp.h:135
MeshMetaDataInterface::meshPropertyName
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
Definition: MeshMetaDataInterface.C:41
MeshMetaDataInterface::_meta_data_app
MooseApp & _meta_data_app
Reference to the application.
Definition: MeshMetaDataInterface.h:122

◆ 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 166 of file MeshMetaDataInterface.h.

168 {
169  if (!hasMeshProperty(data_name, prefix))
170  return false;
171  const auto & value = getMeshPropertyInternal(data_name, prefix);
172  return dynamic_cast<const RestartableData<T> *>(&value) != nullptr;
173 }
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:33
MeshMetaDataInterface::getMeshPropertyInternal
const RestartableDataValue & getMeshPropertyInternal(const std::string &data_name, const std::string &prefix) const
Helper for getting a mesh property.
Definition: MeshMetaDataInterface.C:54

◆ 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 82 of file MeshMetaDataInterface.h.

83  {
84  return hasMeshProperty(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:47
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition: MeshMetaDataInterface.C:33

◆ 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 90 of file MeshMetaDataInterface.h.

91  {
92  return hasMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
93  }
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:47

◆ hasOutput()

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

Definition at line 488 of file MeshGenerator.C.

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

489 {
490  return getParam<bool>("output");
491 }

◆ hasSaveMesh()

bool MeshGenerator::hasSaveMesh ( ) const
inherited

Return whether or not to save the current mesh.

Definition at line 482 of file MeshGenerator.C.

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

483 {
484  return _save_with_name.size();
485 }
MeshGenerator::_save_with_name
const std::string & _save_with_name
A user-defined name to save the mesh.
Definition: MeshGenerator.h:527

◆ haveParameter()

template<typename T >
bool MooseBase::haveParameter ( const std::string &  name) const
inlineinherited

Test if a parameter of the given name and type exists.

Parameters
nameThe name of the parameter to test

Definition at line 200 of file MooseBase.h.

201  {
202  return _pars.have_parameter<T>(name);
203  }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
InputParameters::have_parameter
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Definition: InputParameters.h:2364

◆ 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 461 of file MeshGenerator.C.

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder().

463 {
464  return std::find_if(getChildMeshGenerators().begin(),
465  getChildMeshGenerators().end(),
466  [&name, &direct](const auto & mg)
467  {
468  return mg->name() == name ||
469  (!direct && mg->isChildMeshGenerator(name, /* direct = */ false));
470  }) != getChildMeshGenerators().end();
471 }
MeshGenerator::getChildMeshGenerators
const std::set< const MeshGenerator *, Comparator > & getChildMeshGenerators() const
Gets the MeshGenerators that are children to this MeshGenerator.
Definition: MeshGenerator.h:148
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ isDataOnly()

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

Definition at line 214 of file MeshGenerator.h.

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

214 { 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:530

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const
inlineinherited

Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

Definition at line 63 of file MooseObject.h.

Referenced by BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

63 { return parameters().isKokkosObject(); }
MooseBase::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseBase.h:131
InputParameters::isKokkosObject
bool isKokkosObject() const
Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_obje...
Definition: InputParameters.C:433

◆ 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 184 of file MeshGenerator.h.

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

184 { 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:524
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103

◆ isParamSetByUser()

bool MooseBase::isParamSetByUser ( const std::string &  name) const
inlineinherited

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

Parameters
nameThe name of the parameter to test

Definition at line 215 of file MooseBase.h.

Referenced by SetupDebugAction::act(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MortarConstraintBase::MortarConstraintBase(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::runInputFile(), MooseApp::runInputs(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

216  {
217  return _pars.isParamSetByUser(name);
218  }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.
Definition: InputParameters.C:1260

◆ isParamValid()

bool MooseBase::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 209 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), AutoCheckpointAction::act(), CopyNodalVarsAction::act(), SetupMeshAction::act(), SetupDebugAction::act(), ComposeTimeStepperAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), AddVariableAction::act(), CommonOutputAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), TimedSubdomainModifier::buildFromFile(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentJunction::ComponentJunction(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), FEProblemSolve::convergenceSetup(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenProblemSolve::EigenProblemSolve(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), BSplineCurveGenerator::endDirection(), BSplineCurveGenerator::endPoint(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), OrientSurfaceMeshGenerator::generate(), RenumberBySubdomainGenerator::generate(), SubdomainPerElementGenerator::generate(), BlockDeletionGenerator::generate(), BSplineCurveGenerator::generate(), ConcentricCircleMeshGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), SideSetsFromNodeSetsGenerator::generate(), MeshExtruderGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYZDelaunayGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), ManifoldSubdomainGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), AddPeriodicBCAction::getVariables(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), EigenProblemSolve::initialSetup(), ParsedConvergence::initialSetup(), SolutionScalarAux::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionAux::initialSetup(), PIDTransientControl::initialSetup(), Console::initialSetup(), MooseParsedVectorFunction::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), PNGOutput::makePNG(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< Real >::MooseVariableFV(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), EqualValueBoundaryConstraint::pickPrimaryNode(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), MooseMesh::prepare(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusIIOrNemesis(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), SurfaceMeshGeneratorBase::setup(), Split::setup(), SideSetsGeneratorBase::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), BSplineCurveGenerator::startDirection(), BSplineCurveGenerator::startPoint(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), PIDTransientControl::timestepSetup(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

209 { return _pars.isParamValid(name); }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
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:386

◆ 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 448 of file MeshGenerator.C.

450 {
451  return std::find_if(getParentMeshGenerators().begin(),
452  getParentMeshGenerators().end(),
453  [&name, &direct](const auto & mg)
454  {
455  return mg->name() == name ||
456  (!direct && mg->isParentMeshGenerator(name, /* direct = */ false));
457  }) != getParentMeshGenerators().end();
458 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MeshGenerator::getParentMeshGenerators
const std::set< const MeshGenerator *, Comparator > & getParentMeshGenerators() const
Gets the MeshGenerators that are parents to this MeshGenerator.
Definition: MeshGenerator.h:141

◆ 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 41 of file MeshMetaDataInterface.C.

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

42 {
43  return std::string(SYSTEM) + "/" + prefix + "/" + data_name;
44 }
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 103 of file MeshMetaDataInterface.h.

104  {
105  return meshPropertyName(data_name, meshPropertyPrefix(data_name));
106  }
MeshMetaDataInterface::meshPropertyName
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
Definition: MeshMetaDataInterface.C:41
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:47

◆ messagePrefix()

std::string MooseBase::messagePrefix ( const bool  hit_prefix = true) const
inlineinherited
Returns
A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 266 of file MooseBase.h.

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

267  {
268  return messagePrefix(_pars, hit_prefix);
269  }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:266

◆ mooseDeprecated() [1/2]

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

Definition at line 87 of file SolutionInvalidInterface.h.

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

88  {
89  _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
90  flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
91  }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
SolutionInvalidInterface::_si_moose_base
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
Definition: SolutionInvalidInterface.h:111

◆ mooseDeprecated() [2/2]

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

Emits a deprecation warning prefixed with the object name and type, and a stack trace.

Definition at line 327 of file MooseBase.h.

Referenced by MooseApp::addCapability(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), MooseApp::getRecoverFileBase(), MooseApp::hasRecoverFileBase(), and MooseApp::setupOptions().

328  {
329  moose::internal::mooseDeprecatedStream(
330  _console, false, true, true, messagePrefix(true), std::forward<Args>(args)...);
331  }
moose::internal::mooseDeprecatedStream
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, const bool show_trace, Args &&... args)
Definition: MooseError.h:252
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:266

◆ mooseDeprecatedNoTrace()

template<typename... Args>
void MooseBase::mooseDeprecatedNoTrace ( Args &&...  args) const
inlineinherited

Emits a deprecation warning prefixed with the object name and type, and no stack trace.

Definition at line 337 of file MooseBase.h.

338  {
339  moose::internal::mooseDeprecatedStream(
340  _console, false, true, false, messagePrefix(true), std::forward<Args>(args)...);
341  }
moose::internal::mooseDeprecatedStream
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, const bool show_trace, Args &&... args)
Definition: MooseError.h:252
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:266

◆ mooseDocumentedError()

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

Definition at line 287 of file MooseBase.h.

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

290  {
291  callMooseError(moose::internal::formatMooseDocumentedError(
292  repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
293  /* with_prefix = */ true);
294  }
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105
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:142

◆ mooseError()

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

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 281 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), CheckIntegrityAction::act(), CreateExecutionerAction::act(), AddICAction::act(), AddBoundsVectorsAction::act(), AddVectorPostprocessorAction::act(), InitProblemAction::act(), AddMeshGeneratorAction::act(), CheckFVBCAction::act(), SetupMeshCompleteAction::act(), AddFVICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), AdaptivityAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), SplitMeshAction::act(), AddTimeStepperAction::act(), ChainControlSetupAction::act(), DeprecatedBlockAction::act(), SetupDebugAction::act(), CSGOnlyAction::act(), SetupTimeStepperAction::act(), SetupPredictorAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), SetAdaptivityOptionsAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), AddPeriodicBCAction::act(), Action::Action(), FEProblemBase::adaptMesh(), ADArrayReaction::ADArrayReaction(), MooseVariableFV< Real >::adCurlSln(), MooseVariableFV< Real >::adCurlSlnNeighbor(), AddActionComponentAction::AddActionComponentAction(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DiffusionCG::addBoundaryConditionsFromComponents(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), MooseApp::addCapabilityInternal(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), 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(), LinearFVFluxKernel::addMatrixContribution(), ComponentJunction::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMEigenproblem::addMFEMSolver(), MFEMProblem::addMFEMSolver(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), Action::addRelationshipManager(), LinearFVFluxKernel::addRightHandSideContribution(), FEProblemBase::addScalarKernel(), WebServerControl::addServerAction(), MFEMEigenproblem::addVariable(), AddVariableAction::addVariable(), SubProblem::addVectorTag(), MooseLinearVariableFV< Real >::adError(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), NEML2ModelExecutor::advanceState(), AdvectiveFluxAux::AdvectiveFluxAux(), MooseVariableBase::allDofIndices(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), ArrayVariableValueVolumeHistogram::ArrayVariableValueVolumeHistogram(), MooseApp::attachRelationshipManagers(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), PiecewiseTabularInterface::buildFromFile(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularInterface::buildFromJSON(), TimedSubdomainModifier::buildFromParameters(), PiecewiseTabularInterface::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), MooseMesh::buildLowerDMesh(), TiledMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), 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(), DefaultMultiAppFixedPointConvergence::checkIterationType(), DefaultNonlinearConvergence::checkIterationType(), DefaultSteadyStateConvergence::checkIterationType(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), Moose::PeriodicBCHelper::checkPeriodicParams(), FEProblemBase::checkProblemIntegrity(), Sampler::checkReinitStatus(), MultiAppGeneralFieldKDTreeTransferBase::checkRestrictionsForSource(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::checkSiblingsTransferSupported(), Moose::MFEM::LinearSolverBase::CheckSpectralEquivalence(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), FEProblemBase::checkUserObjectNameCollision(), FEProblemBase::checkUserObjects(), Moose::PetscSupport::checkUserProvidedPetscOption(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), DomainUserObject::checkVariable(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), LibmeshPartitioner::clone(), MooseMesh::clone(), CombinerGenerator::CombinerGenerator(), ComparisonPostprocessor::comparisonIsTrue(), MFEMComplexAuxKernel::complexAdd(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), FEProblemBase::computeBounds(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), BoundaryLinearFVFluxIntegral::computeFaceInfoIntegral(), 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(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MaterialBase::computeProperties(), BoundaryLinearFVFluxIntegral::computeQpIntegral(), SideFVFluxBCIntegral::computeQpIntegral(), ScalarKernel::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), NodalEqualValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), NodeElemConstraint::computeQpJacobian(), ADArrayNodalKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), MassMatrix::computeQpResidual(), HDGKernel::computeQpResidual(), DiffusionLHDGDirichletBC::computeQpResidual(), DiffusionLHDGPrescribedGradientBC::computeQpResidual(), NodalEqualValueConstraint::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(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::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(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), CoupledForceNodalKernel::CoupledForceNodalKernel(), MultiApp::createApp(), MFEML2ZienkiewiczZhuIndicator::createEstimator(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), MooseVariableFV< Real >::curlPhi(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), SidesetInfoVectorPostprocessor::dataHelper(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyInternal(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), DefaultSteadyStateConvergence::DefaultSteadyStateConvergence(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), BicubicSplineFunction::derivative(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseApp::determineLibtorchDeviceType(), FEProblemBase::determineSolverSystem(), DGKernel::DGKernel(), MeshDiagnosticsGenerator::diagnosticsLog(), DistributedPositions::DistributedPositions(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), MooseVariableFV< Real >::divPhi(), FunctorRelationshipManager::dofmap_reinit(), EigenProblem::doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), EigenProblem::EigenProblem(), EigenProblemSolve::EigenProblemSolve(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementIntegerAux::ElementIntegerAux(), ElementMaterialSampler::ElementMaterialSampler(), ElementQualityAux::ElementQualityAux(), ElementUOAux::ElementUOAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), DistributedRectilinearMeshGenerator::elemId(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), EigenKernel::enabled(), MooseApp::errorCheck(), 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(), NodalValueSampler::execute(), MFEMMultiAppTransfer::execute(), PositionsFunctorValueSampler::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), ElementQualityChecker::execute(), MFEMEigenvaluesPostprocessor::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), InterfaceQpUserObjectBase::execute(), TransientBase::execute(), LeastSquaresFit::execute(), LeastSquaresFitHistory::execute(), VectorPostprocessorComparison::execute(), Eigenvalue::execute(), WebServerControl::execute(), TimeExtremeValue::execute(), NEML2Assembly::execute(), DomainUserObject::execute(), NEML2FEInterpolation::execute(), FEProblemBase::execute(), FEProblemBase::executeControls(), MooseApp::executeExecutioner(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MFEMProblem::executeMFEMObjects(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), MultiAppMFEMTolibMeshShapeEvaluationTransfer::extractlibMeshNodePositions(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), NEML2ModelExecutor::extractOutputs(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), NEML2ModelExecutor::fillInputs(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), ParsedVectorReporter::finalize(), ParsedVectorVectorRealReductionReporter::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), DiscreteVariableResidualNorm::finalize(), NearestPointAverage::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), NEML2Assembly::finalize(), MooseApp::finalizeRestore(), Transfer::find_sys(), MFEMCutTransitionSubMesh::findFaceNormal(), DiracKernelInfo::findPoint(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), LinearFVBoundaryCondition::functorFaceArg(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVMassMatrix::FVMassMatrix(), FVMatAdvection::FVMatAdvection(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), GapValueAux::GapValueAux(), WorkBalance::gather(), ElementSubdomainModifierBase::gatherPatchElements(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), ElementOrderConversionGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), CoarsenBlockGenerator::generate(), MeshRepairGenerator::generate(), SideSetsFromPointsGenerator::generate(), SmoothMeshGenerator::generate(), StitchMeshGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), MeshDiagnosticsGenerator::generate(), ParsedGenerateNodeset::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), SideSetsFromAllNormalsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), XYZDelaunayGenerator::generate(), MeshExtruderGenerator::generate(), CombinerGenerator::generate(), generate(), MeshCollectionGenerator::generate(), SpiralAnnularMeshGenerator::generate(), XYMeshLineCutter::generate(), Boundary2DDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), 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(), NEML2BatchIndexGenerator::getBatchIndex(), MooseMesh::getBlockConnectedBlocks(), VariableOldValueBounds::getBound(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), WebServerControl::getClientInfo(), MooseMesh::getCoarseningMap(), NodalPatchRecoveryBase::getCoefficients(), 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(), WebServerControl::Response::getError(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MFEMVectorFESpace::getFECName(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVAdvectedInterpolationMethod(), FEProblemBase::getFVFaceInterpolationMethod(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getFVMatsAndDependencies(), MooseMesh::getGeneralAxisymmetricCoordAxis(), MaterialPropertyInterface::getGenericMaterialPropertyByName(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), MaterialPropertyInterface::getKokkosBlockMaterialProperty(), FEProblemBase::getKokkosFunction(), FunctionInterface::getKokkosFunctionByName(), MaterialPropertyInterface::getKokkosMaterialPropertyByName(), FEProblemBase::getKokkosUserObject(), MFEMMultiAppTransfer::getlibMeshEquationSystem(), FEProblemBase::getLinearConvergenceNames(), SolutionUserObjectBase::getLocalVarIndex(), Material::getMaterialByName(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MFEMProblem::getMFEMObject(), MFEMProblem::getMFEMVariableMesh(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), NEML2FEInterpolation::getMOOSEVariable(), 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(), FEProblemBase::getPostprocessorObjectByName(), PostprocessorInterface::getPostprocessorValueByNameInternal(), Times::getPreviousTime(), EqualValueBoundaryConstraint::getPrimaryNodeIDByCoord(), ComponentMaterialPropertyInterface::getPropertyValue(), InterfaceQpUserObjectBase::getQpValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), FEProblemBase::getSampler(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), MooseObject::getSharedPtr(), InterfaceQpUserObjectBase::getSideAverageValue(), PhysicsBase::getSolverSystem(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSteadyStateConvergenceName(), MooseMesh::getSubdomainBoundaryIds(), TimedSubdomainModifier::getSubdomainIDAndCheck(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), 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(), AddPeriodicBCAction::getVariables(), JSONFileReader::getVector(), VectorPostprocessorInterface::getVectorPostprocessorName(), FEProblemBase::getVectorPostprocessorObjectByName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingFromUOAux::GhostingFromUOAux(), EqualValueBoundaryConstraint::ghostPrimary(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), Function::gradient(), MooseLinearVariableFV< Real >::gradientStateError(), FEProblemBase::handleException(), Terminator::handleMessage(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), HDGKernel::HDGKernel(), TransientBase::incrementStepOrReject(), NEML2Action::inferMOOSEIOType(), FixedPointIterationAdaptiveDT::init(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), EigenExecutionerBase::init(), ExplicitTimeIntegrator::init(), TransientBase::init(), FEProblem::init(), AddAuxVariableAction::init(), IterationAdaptiveDT::init(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), MultiApp::init(), FEProblemBase::initialAdaptMesh(), NestedDivision::initialize(), DistributedPositions::initialize(), TransformedPositions::initialize(), ReporterPositions::initialize(), ElementGroupCentroidPositions::initialize(), FunctorPositions::initialize(), ReporterTimes::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SteffensenSolve::initialSetup(), SolutionIC::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), PiecewiseLinearBase::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), ChainControlDataPostprocessor::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), EigenProblemSolve::initialSetup(), SolutionScalarAux::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVAdvection::initialSetup(), ExplicitTimeIntegrator::initialSetup(), SolutionAux::initialSetup(), LinearFVDiffusion::initialSetup(), ReferenceResidualConvergence::initialSetup(), NodalVariableValue::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), ElementSubdomainModifierBase::initialSetup(), Exodus::initialSetup(), CSV::initialSetup(), MooseParsedFunction::initialSetup(), AuxKernelBase::initialSetup(), NEML2FEInterpolation::initialSetup(), SolutionUserObjectBase::initialSetup(), FEProblemBase::initialSetup(), SubProblem::initialSetup(), AdvancedOutput::initOutputList(), 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(), MooseApp::libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MooseApp::loadLibraryAndDependencies(), 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(), NEML2ModelExecutor::meshChanged(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), MFEMComplexExteriorProductAux::MFEMComplexExteriorProductAux(), MFEMComplexInnerProductAux::MFEMComplexInnerProductAux(), MFEMCrossProductAux::MFEMCrossProductAux(), MFEMEigenproblem::MFEMEigenproblem(), MFEMInnerProductAux::MFEMInnerProductAux(), MFEMNDtoRTAux::MFEMNDtoRTAux(), MFEMValueSamplerBase::MFEMValueSamplerBase(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableConstMonomial::MooseVariableConstMonomial(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), NearestNodeDistanceAux::NearestNodeDistanceAux(), FEProblemBase::needsPreviousNewtonIteration(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), MooseVariableFV< Real >::nodalDofIndex(), MooseVariableFV< Real >::nodalDofIndexNeighbor(), MooseLinearVariableFV< Real >::nodalError(), MooseVariableFV< Real >::nodalMatrixTagValue(), 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(), MooseApp::outputMachineReadableData(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), Nemesis::outputSetup(), 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(), EqualValueBoundaryConstraint::pickPrimaryNode(), PIDTransientControl::PIDTransientControl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseFunction::PiecewiseFunction(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), PiecewiseTabularBase::PiecewiseTabularBase(), PiecewiseTabularInterface::PiecewiseTabularInterface(), ProjectSideSetOntoLevelSetGenerator::pointPairLevelSetInterception(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), SolutionUserObjectBase::pointValueGradientWrapper(), SolutionUserObjectBase::pointValueWrapper(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), AStableDirk4::postResidual(), LStableDirk4::postResidual(), ExplicitRK2::postResidual(), EigenProblem::postScaleEigenVector(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), ADKernelValueTempl< T >::precomputeQpJacobian(), FunctorKernel::precomputeQpResidual(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), ElementSubdomainModifierBase::prepareVariableForReinitialization(), FixedPointSolve::printFixedPointConvergenceReason(), MultiAppMFEMTolibMeshShapeEvaluationTransfer::projectlibMeshNodalValues(), PseudoTimestep::PseudoTimestep(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusIIOrNemesis(), SolutionUserObjectBase::readXda(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), MFEMTransient::relativeSolutionDifferenceNorm(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), 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(), ADArrayNodalKernel::setJacobian(), MFEMPetscNonlinearSolver::SetLinearSolver(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), FVPointValueConstraint::setMyElem(), FEProblemBase::setNonlocalCouplingMatrix(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), Split::setup(), TransientMultiApp::setupApp(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), MFEMCGSolver::SetupLOR(), MFEMGMRESSolver::SetupLOR(), MFEMHyprePCG::SetupLOR(), MFEMHypreFGMRES::SetupLOR(), MFEMHypreAMS::SetupLOR(), MFEMHypreADS::SetupLOR(), MFEMHypreGMRES::SetupLOR(), MFEMMUMPS::SetupLOR(), MFEMSuperLU::SetupLOR(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), 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(), MooseVariableBase::sizeMatrixTagData(), SmoothMeshGenerator::SmoothMeshGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObjectBase::SolutionUserObjectBase(), Moose::MFEM::LinearSolverBase::Solve(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TimeIntegrator::solve(), FEProblemBase::solverSysNum(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialPoints(), NearestPointAverage::spatialValue(), NearestPointIntegralVariablePostprocessor::spatialValue(), UserObject::spatialValue(), MeshDivisionFunctorReductionVectorPostprocessor::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), MeshRepairGenerator::splitNonConvexPolygons(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), 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(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), MooseLinearVariableFV< Real >::timeIntegratorError(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriodBase::TimePeriodBase(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), MultiAppMFEMCopyTransfer::transferVariables(), MultiApplibMeshToMFEMShapeEvaluationTransfer::transferVariables(), MultiAppMFEMShapeEvaluationTransfer::transferVariables(), MultiAppMFEMTolibMeshShapeEvaluationTransfer::transferVariables(), TransformedPositions::TransformedPositions(), FEProblemBase::trustUserCouplingMatrix(), ParsedCurveGenerator::tSectionSpaceDefiner(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), MooseBase::uniqueName(), Positions::unrollMultiDPositions(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), Checkpoint::updateCheckpointFiles(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), SolutionUserObjectBase::updateInterpolationBracketingTimeIndices(), FEProblemBase::updateMaxQps(), NEML2FEInterpolation::updatePhi(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointAverage::userObjectValue(), NearestPointIntegralVariablePostprocessor::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(), MooseApp::writeRestartableMetaData(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

282  {
283  callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
284  }
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105

◆ mooseErrorNonPrefixed()

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

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

Definition at line 300 of file MooseBase.h.

301  {
302  callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
303  }
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
External method for calling moose error with added object context.
Definition: MooseBase.C:105

◆ mooseInfo()

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

Definition at line 344 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldKDTreeTransferBase::evaluateNearestNodeFromKDTrees(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), PolyLineMeshFollowingNodeSetGenerator::generate(), ManifoldSubdomainGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), MultiAppTransfer::mapBackWithoutCollapsing(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), and TransientBase::TransientBase().

345  {
346  moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
347  }
moose::internal::mooseInfoStream
void mooseInfoStream(S &oss, Args &&... args)
Definition: MooseError.h:245
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:266

◆ mooseWarning() [1/2]

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

Definition at line 73 of file SolutionInvalidInterface.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::addFunction(), MooseMesh::addPeriodicVariable(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkPolygons(), 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(), RenumberBySubdomainGenerator::generate(), BSplineCurveGenerator::generate(), StitchMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), ParsedGenerateSideset::generate(), SurfaceSubdomainsDelaunayRemesher::generate(), SurfaceMeshGeneratorBase::get2DElemNormal(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), MFEMVectorFESpace::getFECName(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), ElementGroupCentroidPositions::initialize(), SphericalGridDivision::initialize(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MFEMRefinementMarker::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), ElementSubdomainModifierBase::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), PNGOutput::makePNG(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MaterialOutputAction::outputHelper(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

74  {
75  _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
76  flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
77  }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
SolutionInvalidInterface::_si_moose_base
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
Definition: SolutionInvalidInterface.h:111

◆ mooseWarning() [2/2]

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

Emits a warning prefixed with object name and type.

Definition at line 309 of file MooseBase.h.

Referenced by DiracKernelInfo::findPoint(), DataFileInterface::getDataFilePath(), MooseApp::loadLibraryAndDependencies(), and MooseBase::paramWarning().

310  {
311  moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
312  }
moose::internal::mooseWarningStream
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:197
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition: ConsoleStreamInterface.h:31
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition: MooseBase.h:266

◆ mooseWarningNonPrefixed() [1/2]

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

Definition at line 80 of file SolutionInvalidInterface.h.

81  {
82  _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
83  flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
84  }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
SolutionInvalidInterface::_si_moose_base
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
Definition: SolutionInvalidInterface.h:111

◆ mooseWarningNonPrefixed() [2/2]

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

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

Definition at line 318 of file MooseBase.h.

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

◆ name()

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

Get the name of the class.

Returns
The name of the class

Definition at line 103 of file MooseBase.h.

Referenced by AddElementalFieldAction::act(), CopyNodalVarsAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), SetupTimeIntegratorAction::act(), AddActionComponentAction::act(), SetupResidualDebugAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), CommonOutputAction::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(), Registry::addDataFilePathCapability(), 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::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addIndicator(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), BoundaryIntegralValueConstraint::additionalROVariables(), DiffusionLHDGKernel::additionalROVariables(), IPHDGAssemblyHelper::additionalROVariables(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), MFEMProblem::addMarker(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMPreconditioner(), MFEMEigenproblem::addMFEMSolver(), MFEMProblem::addMFEMSolver(), Registry::addMissingDataFilePath(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), InitialConditionWarehouse::addObject(), FEProblemBase::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), InitialConditionBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), UserObjectBase::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), InitialConditionBase::addUserObjectDependencyHelper(), AuxKernelBase::addUserObjectDependencyHelper(), UserObjectBase::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), MFEMProblem::addVectorPostprocessor(), FEProblemBase::addVectorPostprocessor(), AuxKernelBase::addVectorPostprocessorDependencyHelper(), UserObjectBase::addVectorPostprocessorDependencyHelper(), MooseLinearVariableFV< Real >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator(), NEML2ModelExecutor::advanceState(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), Registry::appNameFromAppPath(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), Function::average(), MultiApp::backup(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromXY(), MooseMesh::buildNodeListFromSideList(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), ParsedConvergence::checkConvergence(), DefaultNonlinearConvergence::checkConvergence(), Registry::checkDataFilePathName(), FEProblemBase::checkDependMaterialsHelper(), TaggingInterface::checkForNans(), SamplerBase::checkForStandardFieldVariableType(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Moose::Kokkos::Material::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), FEProblemBase::checkUserObjectNameCollision(), DomainUserObject::checkVariable(), BlockRestrictable::checkVariable(), Coupleable::checkWritableVar(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MooseBase::connectControllableParams(), ConstantPostprocessor::ConstantPostprocessor(), Coupleable::coupledName(), CommonOutputAction::create(), MultiApp::createApp(), MooseApp::createExecutors(), MeshGeneratorSystem::createMeshGeneratorOrder(), MooseApp::createRecoverablePerfGraph(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), DebugResidualAux::DebugResidualAux(), MaterialBase::declareADProperty(), MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), Registry::determineDataFilePath(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementDamper::ElementDamper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), SideValueSampler::execute(), RestartableDataReporter::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), WebServerControl::execute(), MultiAppGeneralFieldTransfer::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), NEML2ModelExecutor::fillInputs(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FunctionIC::functionName(), FVFunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), MooseServer::gatherDocumentSymbols(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), SideSetsFromNodeSetsGenerator::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ManifoldSubdomainGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MooseMesh::getBoundaryString(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), MFEMProblem::getComplexGridFunction(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), MeshGenerator::getCSGBase(), MeshGenerator::getCSGBasesByName(), Registry::getDataFilePath(), UserObjectBase::getDependObjects(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), MooseApp::getExecutor(), FEProblemBase::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVAdvectedInterpolationMethod(), FEProblemBase::getFVFaceInterpolationMethod(), FEProblemBase::getFVInterpolationMethod(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), AuxKernelTempl< Real >::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), FEProblemBase::getKokkosFunction(), FEProblemBase::getKokkosUserObject(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), AuxKernelTempl< Real >::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), AuxKernelTempl< Real >::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), AuxKernelTempl< Real >::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MFEMObject::getMatrixCoefficient(), MFEMObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MFEMProblem::getMFEMObject(), ActionWarehouse::getMooseAppName(), NEML2FEInterpolation::getMOOSEVariable(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), MooseServer::getObjectParameters(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), OutputWarehouse::getOutput(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MFEMExecutedObject::getRequestedItems(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMObject::getScalarCoefficient(), MFEMObject::getScalarCoefficientByName(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MFEMExecutedObject::getSuppliedItems(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMObject::getVectorCoefficient(), MFEMObject::getVectorCoefficientByName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasDistribution(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), FEProblemBase::hasFVInterpolationMethod(), MooseApp::hasMeshGenerator(), MFEMProblem::hasMFEMObject(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), MooseBase::haveParameter(), NEML2Action::inferMOOSEIOType(), IterationAdaptiveDT::init(), AddVariableAction::init(), AdvancedOutput::init(), AdvancedOutput::initAvailableLists(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), JSONOutput::initialSetup(), SideFVFluxBCIntegral::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), MultiAppGeneralFieldFunctorTransfer::initialSetup(), NodalVariableValue::initialSetup(), Console::initialSetup(), AuxKernelBase::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< JvarMapKernelInterface< GenericKernelGrad< is_ad > > >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< Real >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), Material::Material(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), NEML2ModelExecutor::meshChanged(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< Real >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NEML2PreKernel::NEML2PreKernel(), NodalDamper::NodalDamper(), MooseLinearVariableFV< Real >::nodalError(), 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(), Nemesis::outputPostprocessors(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), SolutionInvalidInterface::paramWarning(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseFunction::PiecewiseFunction(), MooseApp::possiblyLoadRestartableMetaData(), MFEMExecutedObject::postprocessorDependencyKey(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), AppFactory::reg(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), FEProblemBase::setAuxKernelParamsAndLog(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), MooseMesh::setSubdomainName(), SurfaceMeshGeneratorBase::setup(), NodeSetsGeneratorBase::setup(), Split::setup(), SideSetsGeneratorBase::setup(), TransientMultiApp::setupApp(), NEML2Action::setupOutputMappings(), FullSolveMultiApp::showStatusMessage(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), SubProblem::storeSubdomainZeroMatProp(), ConstraintWarehouse::subdomainsCovered(), MaterialBase::subdomainSetup(), SumPostprocessor::SumPostprocessor(), MFEMPostprocessor::suppliedPostprocessorName(), MFEMVectorPostprocessor::suppliedVectorPostprocessorName(), NEML2FEInterpolation::syncWithMainThread(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< Real >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), MultiAppMFEMCopyTransfer::transferVariables(), MultiAppMFEMShapeEvaluationTransfer::transferVariables(), TransientMultiApp::TransientMultiApp(), MooseServer::traverseParseTreeAndFillSymbols(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVFluxBC::uOnGhost(), FVFluxBC::uOnUSub(), UserObjectBase::UserObjectBase(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), MFEMExecutedObject::variableDependencyKey(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), MFEMExecutedObject::vectorPostprocessorDependencyKey(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

104  {
105  mooseAssert(_name.size(), "Empty name");
106  return _name;
107  }
MooseBase::_name
const std::string & _name
The name of this class.
Definition: MooseBase.h:391

◆ paramError()

template<typename... Args>
void MooseBase::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 467 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), SetupDebugAction::act(), CommonOutputAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), 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(), ArrayReactionNodalKernelTempl< is_ad >::ArrayReactionNodalKernelTempl(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelBase::AuxKernelBase(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundaryIntegralValueConstraint::BoundaryIntegralValueConstraint(), BoundaryLinearFVFluxIntegral::BoundaryLinearFVFluxIntegral(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), MFEMMesh::buildMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), checkComponent(), Moose::Kokkos::ParsedObjectBase::checkDuplicateSymbols(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentJunction::ComponentJunction(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), MultiAppGeneralFieldTransfer::correctSolutionVectorValues(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), DebugResidualAux::DebugResidualAux(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), EigenProblemSolve::EigenProblemSolve(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ElementNormalAux::ElementNormalAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), 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(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), AddMetaDataGenerator::generate(), BlockToMeshConverterGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), CoarsenBlockGenerator::generate(), BlockDeletionGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakMeshByBlockGenerator::generate(), ElementsToTetrahedronsConverter::generate(), FillBetweenCurvesGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), FillBetweenSidesetsGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), XYZDelaunayGenerator::generate(), generate(), BreakMeshByElementGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedExtraElementIDGenerator::generate(), CombinerGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), StackGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), ParsedCurveGenerator::generate(), XYMeshLineCutter::generate(), CutMeshByLevelSetGeneratorBase::generate(), Boundary2DDelaunayGenerator::generate(), SurfaceSubdomainsDelaunayRemesher::generate(), ManifoldSubdomainGenerator::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), BoundaryLayerUtils::generateOffsetPolyline(), GenericConstantStdVectorMaterialTempl< is_ad >::GenericConstantStdVectorMaterialTempl(), 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(), AddPeriodicBCAction::getVariables(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), JSONOutput::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppGeneralFieldKDTreeTransferBase::initialSetup(), FullSolveMultiApp::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), ElementSubdomainModifierBase::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(), MatReactionTempl< false >::MatReactionTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMComplexSumAux::MFEMComplexSumAux(), MFEMFunctorMaterial::MFEMFunctorMaterial(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMMultiAppTransfer::MFEMMultiAppTransfer(), MFEMNDtoRTAux::MFEMNDtoRTAux(), MFEMSumAux::MFEMSumAux(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), 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(), NEML2PreKernel::NEML2PreKernel(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), RankTwoTensorFromComponentProperties::RankTwoTensorFromComponentProperties(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusIIOrNemesis(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), SurfaceMeshGeneratorBase::setup(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), CylinderComponent::setupComponent(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupInputMappings(), FEProblemSolve::setupMultiSystemFixedPointRelaxationFactors(), NEML2Action::setupParameterDerivativeMappings(), NEML2Action::setupParameterMappings(), SetupQuadratureAction::SetupQuadratureAction(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), CylinderComponent::translation(), MeshTriangulationUtils::triangulateWithDelaunay(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), TimeSequenceStepperBase::updateSequence(), UserObjectBase::UserObjectBase(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

468 {
469  _pars.paramError(param, std::forward<Args>(args)...);
470 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
InputParameters::paramError
void paramError(const std::string &param, Args... args) const
Emits a parameter error prefixed with the parameter location and object information if available...
Definition: InputParameters.h:2472

◆ parameters()

const InputParameters& MooseBase::parameters ( ) const
inlineinherited

Get the parameters of the object.

Returns
The parameters of the object

Definition at line 131 of file MooseBase.h.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), CSGOnlyAction::act(), 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(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addIndicator(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), MFEMProblem::addMarker(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMPreconditioner(), MFEMEigenproblem::addMFEMSolver(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), MFEMEigenproblem::addVariable(), MFEMProblem::addVariable(), DisplacedProblem::addVariable(), MFEMProblem::addVectorPostprocessor(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), MooseMeshUtils::copyIntoMesh(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), EigenProblemSolve::EigenProblemSolve(), ElementMaterialSampler::ElementMaterialSampler(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), ElementSubdomainModifierBase::extrapolatePolynomial(), FEProblem::FEProblem(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainGeneratorBase::generate(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), Moose::PeriodicBCHelper::getParams(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), AuxKernelBase::getVariableHelper(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), MeshGeneratorSystem::hasDataDrivenAllowed(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MooseObject::isKokkosObject(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MooseServer::parseDocumentForDiagnostics(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), FEProblemBase::setResidualObjectParamsAndLog(), SideSetsGeneratorBase::setup(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), Moose::PetscSupport::storePetscOptions(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

131 { return _pars; }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394

◆ paramInfo()

template<typename... Args>
void MooseBase::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 481 of file MooseBase.h.

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

482 {
483  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
484 }
InputParameters::paramMessage
std::string paramMessage(const std::string &param, Args... args) const
Definition: InputParameters.h:2463
MooseBase::mooseInfo
void mooseInfo(Args &&... args) const
Definition: MooseBase.h:344
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394

◆ paramWarning() [1/2]

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

Definition at line 94 of file SolutionInvalidInterface.h.

Referenced by GridPartitioner::_do_partition(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

95  {
96  _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
97  flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
98  param + "'");
99  }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
SolutionInvalidInterface::_si_moose_base
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
Definition: SolutionInvalidInterface.h:111

◆ paramWarning() [2/2]

template<typename... Args>
void MooseBase::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 474 of file MooseBase.h.

475 {
476  mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
477 }
InputParameters::paramMessage
std::string paramMessage(const std::string &param, Args... args) const
Definition: InputParameters.h:2463
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
MooseBase::mooseWarning
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition: MooseBase.h:309

◆ queryParam()

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

Query a parameter for the object.

If a parameter of the given name and type does not exist or 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 423 of file MooseBase.h.

Referenced by MFEMExecutedObject::getRequestedItems().

424 {
425  return haveParameter<T>(name) && isParamValid(name) ? &getParam<T>(name) : nullptr;
426 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseBase.h:209

◆ radialExpansionRatio()

Real AdvancedExtruderGenerator::radialExpansionRatio ( const Real  t) const
protected

Calculate the share of the radial expansion to apply at the local node This share goes from 0 at the beginning of the extrusion to 1 at the end.

Parameters
tcoordinate along the curve (in the axial direction of extrusion)

Definition at line 1661 of file AdvancedExtruderGenerator.C.

Referenced by generate().

1662 {
1663  // NOTE: All functions added to this method must obey the following: f(0)=0, f(1)=1 for all t in
1664  // [0,1].
1665  switch (_radial_expansion_method)
1666  {
1667  case 0:
1668  return t;
1669  // Only linear and cubic implemented
1670  default:
1671  return (-2. + _start_radial_growth_rate + _end_radial_growth_rate) * MathUtils::pow(t, 3) +
1672  (3. - (2. * _start_radial_growth_rate + _end_radial_growth_rate)) *
1673  MathUtils::pow(t, 2) +
1674  _start_radial_growth_rate * t;
1675  }
1676 }
AdvancedExtruderGenerator::_start_radial_growth_rate
const Real _start_radial_growth_rate
Derivative of the radial expansion function at the beginning of the extrusion.
Definition: AdvancedExtruderGenerator.h:103
AdvancedExtruderGenerator::_end_radial_growth_rate
const Real _end_radial_growth_rate
Derivative of the radial expansion function at the end of the extrusion.
Definition: AdvancedExtruderGenerator.h:105
MathUtils::pow
T pow(T x, int e)
Definition: MathUtils.h:91
AdvancedExtruderGenerator::_radial_expansion_method
const MooseEnum _radial_expansion_method
Function type for modifying the radial extent of the extruded shape.
Definition: AdvancedExtruderGenerator.h:101

◆ registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal ( const std::string &  message,
const bool  warning 
) const
protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

57 {
58  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
59  _si_moose_base.type(), message, warning);
60 }
moose::internal::SolutionInvalidityRegistry::registerInvalidity
InvalidSolutionID registerInvalidity(const std::string &object_type, const std::string &message, const bool warning)
Call to register an invalid calculation.
Definition: SolutionInvalidityRegistry.C:33
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93
moose::internal::getSolutionInvalidityRegistry
SolutionInvalidityRegistry & getSolutionInvalidityRegistry()
Get the global SolutionInvalidityRegistry singleton.
Definition: SolutionInvalidityRegistry.C:18
SolutionInvalidInterface::_si_moose_base
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
Definition: SolutionInvalidInterface.h:111

◆ setHasGenerateCSG()

void MeshGenerator::setHasGenerateCSG ( InputParameters &  params)
staticinherited

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

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

Definition at line 94 of file MeshGenerator.C.

95 {
96  params.set<bool>("_has_generate_csg") = true;
97 }
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition: InputParameters.h:1560

◆ 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 82 of file MeshGenerator.C.

Referenced by AddMetaDataGenerator::validParams().

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

◆ 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 565 of file MeshGenerator.h.

566 {
567  if (_app.actionWarehouse().getCurrentTaskName() != "execute_mesh_generators")
568  mooseError("Updating mesh meta data with setMeshProperty() can only be called during "
569  "MeshGenerator::generate()");
570 
571  if (!hasMeshProperty(data_name))
572  mooseError("Failed to get the mesh property '", data_name, "'");
573  RestartableDataValue * value = &setMeshPropertyHelper(data_name);
574  RestartableData<T> * T_value = dynamic_cast<RestartableData<T> *>(value);
575  if (!T_value)
576  mooseError("While retrieving mesh property '",
577  data_name,
578  "' with type '",
579  MooseUtils::prettyCppType<T>(),
580  "',\nthe property was found with type '",
581  value->type(),
582  "'");
583 
584  // Set the value if someone provided arguments to set it to
585  if constexpr (sizeof...(args) > 0)
586  T_value->set() = T(std::forward<Args>(args)...);
587 
588  return T_value->set();
589 }
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:428
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:216
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:385
ActionWarehouse::getCurrentTaskName
const std::string & getCurrentTaskName() const
Definition: ActionWarehouse.h:290
RestartableData
Concrete definition of a parameter value for a specified type.
Definition: RestartableData.h:215
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition: MeshMetaDataInterface.C:33
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 251 of file MeshGenerator.h.

252  {
253  return setMeshProperty<T, const T &>(data_name, data_value);
254  }

◆ 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 93 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::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), MFEMEigenproblem::addMFEMSolver(), FEProblemBase::addObject(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), MooseServer::addValuesToList(), MFEMProblem::addVectorPostprocessor(), DisplacedProblem::addVectorTag(), SubProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelBase::AuxKernelBase(), FEProblemBase::backupMultiApps(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildLowerDMesh(), MooseMesh::buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), FEProblemBase::checkUserObjectNameCollision(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), 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(), HFEMTrialJump::computeQpOffDiagJacobian(), HFEMTestJump::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), ArrayHFEMDiffusion::computeQpResidual(), DGConvection::computeQpResidual(), HFEMDiffusion::computeQpResidual(), ScalarKernel::computeQpResidual(), InterfaceDiffusion::computeQpResidual(), ADMatInterfaceReaction::computeQpResidual(), InterfaceReaction::computeQpResidual(), ADDGAdvection::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), DGDiffusion::computeQpResidual(), LinearNodalConstraint::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(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), SteadyBase::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), MooseServer::gatherDocumentReferencesLocations(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), SubdomainPerElementGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), Boundary2DDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MultiAppTransfer::getAppInfo(), TransfiniteMeshGenerator::getEdge(), ElementGenerator::getElemType(), MooseServer::getInputLookupDefinitionNodes(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), MaterialOutputAction::getParams(), ReporterData::getReporterInfo(), FEProblemBase::getTransfers(), FEProblemBase::getUOQuery(), DisplacedProblem::getVectorTags(), SubProblem::getVectorTags(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), NEML2Action::inferMOOSEIOType(), AdvancedOutput::initAvailableLists(), FunctorPositions::initialize(), FunctorTimes::initialize(), MultiAppConservativeTransfer::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVAdvection::initialSetup(), LinearFVDiffusion::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MFEMProblem::mesh(), MooseObject::MooseObject(), 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(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), Reporter::store(), MooseBase::typeAndName(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), UserObjectInterface::userObjectType(), and AdvancedOutput::wantOutput().

94  {
95  mooseAssert(_type.size(), "Empty type");
96  return _type;
97  }
MooseBase::_type
const std::string & _type
The type of this class.
Definition: MooseBase.h:388

◆ 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 57 of file MooseBase.C.

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

58 {
59  return type() + std::string(" \"") + name() + std::string("\"");
60 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:93

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const
inherited
Returns
The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

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

70 {
71  if (!_pars.have_parameter<std::string>(unique_name_param))
72  mooseError("uniqueName(): Object does not have a unique name");
73  return MooseObjectName(_pars.get<std::string>(unique_name_param));
74 }
MooseBase::_pars
const InputParameters & _pars
The object&#39;s parameters.
Definition: MooseBase.h:394
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:2305
MooseBase::unique_name_param
static const std::string unique_name_param
The name of the parameter that contains the unique object name.
Definition: MooseBase.h:57
InputParameters::have_parameter
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Definition: InputParameters.h:2364
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition: MooseBase.h:281
MooseObjectName
A class for storing the names of MooseObject by tag and object name.
Definition: MooseObjectName.h:40

◆ uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string &  parameter_name) const
inherited
Returns
The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

64 {
65  return MooseObjectParameterName(getBase(), name(), parameter_name);
66 }
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:103
MooseObjectParameterName
A class for storing an input parameter name.
Definition: MooseObjectParameterName.h:26
MooseBase::getBase
const std::string & getBase() const
Definition: MooseBase.h:147

◆ validParams()

InputParameters AdvancedExtruderGenerator::validParams ( )
static

Definition at line 56 of file AdvancedExtruderGenerator.C.

57 {
58  InputParameters params = MeshGenerator::validParams();
59 
60  params.addClassDescription(
61  "Extrudes a 1D mesh into 2D, or a 2D mesh into 3D, and supports a variable height for each "
62  "elevation, variable number of layers within each elevation, variable growth factors of "
63  "axial element sizes within each elevation and remap subdomain_ids, boundary_ids and element "
64  "extra integers within each elevation as well as interface boundaries between neighboring "
65  "elevation layers, as well as following a 1D curve and modifying the radial (normal to "
66  "the extrusion axis) extent of the geometry.");
67 
68  params.addRequiredParam<MeshGeneratorName>("input", "The mesh to extrude");
69 
70  // User input of extrusion heights / axial discretization
71  params.addParam<std::vector<Real>>("heights", {}, "The height of each elevation");
72  params.addRangeCheckedParam<std::vector<Real>>(
73  "biases", "biases>0.0", "The axial growth factor used for mesh biasing for each elevation.");
74  params.addParam<std::vector<unsigned int>>(
75  "num_layers",
76  {},
77  "The number of layers for each elevation - must be num_elevations in length!");
78 
79  // Swaps on every height
80  params.addParam<std::vector<std::vector<subdomain_id_type>>>(
81  "subdomain_swaps",
82  {},
83  "For each row, every two entries are interpreted as a pair of "
84  "'from' and 'to' to remap the subdomains for that elevation");
85  params.addParam<std::vector<std::vector<boundary_id_type>>>(
86  "boundary_swaps",
87  {},
88  "For each row, every two entries are interpreted as a pair of "
89  "'from' and 'to' to remap the boundaries for that elevation");
90  params.addParam<std::vector<std::string>>(
91  "elem_integer_names_to_swap",
92  {},
93  "Array of element extra integer names that need to be swapped during extrusion.");
94  params.addParam<std::vector<std::vector<std::vector<dof_id_type>>>>(
95  "elem_integers_swaps",
96  {},
97  "For each row, every two entries are interpreted as a pair of 'from' and 'to' to remap the "
98  "element extra integer for that elevation. If multiple element extra integers need to be "
99  "swapped, the enties are stacked based on the order provided in "
100  "'elem_integer_names_to_swap' to form the third dimension.");
101 
102  // Direction parameter
103  params.addParam<Point>("direction",
104  "A vector that points in the direction to extrude (note, this will be "
105  "normalized internally - so don't worry about it here)");
106  params.addParam<MeshGeneratorName>(
107  "extrusion_curve",
108  "Name of the mesh generator providing the line mesh curve to be extruded along. The "
109  "extrusion path follows the node order in the line mesh");
110  params.addParam<RealVectorValue>(
111  "start_extrusion_direction",
112  "A vector that points in the starting direction for extruding along a curve. This vector "
113  "should be the tangent vector at the FIRST node of the extrusion curve. Vector will be "
114  "normalized in code, so don't worry about it here.");
115  params.addParam<RealVectorValue>(
116  "end_extrusion_direction",
117  "A vector that points in the ending direction for extruding along a curve. This vector "
118  "should be the tangent vector at the LAST node of the extrusion curve. Vector will be "
119  "normalized in code, so don't worry about it here.");
120 
121  // Boundaries and interfaces
122  params.addParam<BoundaryName>(
123  "top_boundary",
124  "The boundary name to set on the top boundary. If omitted an ID will be generated.");
125  params.addParam<BoundaryName>(
126  "bottom_boundary",
127  "The boundary name to set on the bottom boundary. If omitted an ID will be generated.");
128  params.addParam<std::vector<std::vector<subdomain_id_type>>>(
129  "upward_boundary_source_blocks", "Block ids used to generate upward interface boundaries.");
130  params.addParam<std::vector<std::vector<boundary_id_type>>>("upward_boundary_ids",
131  "Upward interface boundary ids.");
132  params.addParam<std::vector<std::vector<subdomain_id_type>>>(
133  "downward_boundary_source_blocks",
134  "Block ids used to generate downward interface boundaries.");
135  params.addParam<std::vector<std::vector<boundary_id_type>>>("downward_boundary_ids",
136  "Downward interface boundary ids.");
137 
138  // Radial transformations
139  params.addParam<Real>("twist_pitch",
140  0,
141  "Pitch for helicoidal extrusion around an axis going through the origin "
142  "following the direction vector");
143  params.addParam<Real>("end_radial_extent",
144  0,
145  "If modifying the radial extent of the extruded geometry, final radial "
146  "extent to reach at the end of the extrusion process");
147  MooseEnum radial_growth_methods("linear cubic", "linear");
148  params.addParam<MooseEnum>("radial_growth_method",
149  radial_growth_methods,
150  "Functional form to change radius while extruding along curve.");
151  params.addParam<Real>("start_radial_growth_rate", 1., "Starting rate of radial expansion.");
152  params.addParam<Real>("end_radial_growth_rate", 1., "Ending rate of radial expansion.");
153 
154  params.addParamNamesToGroup(
155  "top_boundary bottom_boundary upward_boundary_source_blocks upward_boundary_ids "
156  "downward_boundary_source_blocks downward_boundary_ids",
157  "Boundary Assignment");
158  params.addParamNamesToGroup(
159  "subdomain_swaps boundary_swaps elem_integer_names_to_swap elem_integers_swaps", "ID Swap");
160  params.addParamNamesToGroup("extrusion_curve start_extrusion_direction end_extrusion_direction",
161  "Extrusion along curve");
162  params.addParamNamesToGroup("twist_pitch end_radial_extent radial_growth_method "
163  "start_radial_growth_rate end_radial_growth_rate",
164  "Radial transformation");
165 
166  return params;
167 }
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Definition: InputParameters.h:67
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:1770
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:54
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:81
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:1796
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
Definition: InputParameters.h:1911
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:994

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory
protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.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 385 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 80 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(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), 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(), SidesetAroundSubdomainUpdater::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), OrientSurfaceMeshGenerator::generate(), CoarsenBlockGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::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(), WebServerControl::outputMessage(), 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(), EigenProblem::solve(), FEProblemSolve::solve(), FixedPointSolve::solve(), NonlinearSystem::solve(), LinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), FixedPointSolve::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), MFEMTransient::takeStep(), TransientBase::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), 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 92 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 89 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 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _end_extrusion_direction

const RealVectorValue AdvancedExtruderGenerator::_end_extrusion_direction
protected

Extrusion direction for the final layer of the extrusion.

Definition at line 72 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _end_radial_extent

const Real AdvancedExtruderGenerator::_end_radial_extent
protected

Radial extent of the extruded geometry at the end of the extrusion.

Definition at line 99 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _end_radial_growth_rate

const Real AdvancedExtruderGenerator::_end_radial_growth_rate
protected

Derivative of the radial expansion function at the end of the extrusion.

Definition at line 105 of file AdvancedExtruderGenerator.h.

Referenced by radialExpansionRatio().

◆ _extrude_along_curve

bool AdvancedExtruderGenerator::_extrude_along_curve
protected

Whether we are extruding along a curve.

Definition at line 74 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _extrusion_curve

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

Curve mesh to extrude along.

Definition at line 68 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _factory

Factory& ParallelParamObject::_factory
protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

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

◆ _has_bottom_boundary

const bool AdvancedExtruderGenerator::_has_bottom_boundary
protected

Definition at line 79 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _has_top_boundary

const bool AdvancedExtruderGenerator::_has_top_boundary
protected

Definition at line 76 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 462 of file MeshGenerator.h.

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

◆ _name

const std::string& MooseBase::_name
protectedinherited

The name of this class.

Definition at line 391 of file MooseBase.h.

Referenced by AddBCAction::act(), AddConstraintAction::act(), AddDGKernelAction::act(), PartitionerAction::act(), AddMaterialAction::act(), AddDamperAction::act(), ReadExecutorParamsAction::act(), AddNodalKernelAction::act(), AddIndicatorAction::act(), AddVectorPostprocessorAction::act(), AddMultiAppAction::act(), AddMeshGeneratorAction::act(), AddTransferAction::act(), AddScalarKernelAction::act(), AddFVInterfaceKernelAction::act(), AddUserObjectAction::act(), AddFVInitialConditionAction::act(), AddInterfaceKernelAction::act(), AddFunctorMaterialAction::act(), AddInitialConditionAction::act(), AddKernelAction::act(), AddPostprocessorAction::act(), AddDiracKernelAction::act(), AddMarkerAction::act(), AddPositionsAction::act(), AddReporterAction::act(), AddTimesAction::act(), AddFieldSplitAction::act(), AddFVKernelAction::act(), AddFVBCAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddFunctionAction::act(), AddMeshDivisionAction::act(), AddFVInterpolationMethodAction::act(), AddTimeStepperAction::act(), AddHDGKernelAction::act(), AddDistributionAction::act(), AddConvergenceAction::act(), AddOutputAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddCorrectorAction::act(), AddMeshModifiersAction::act(), AddMFEMComplexKernelComponentAction::act(), AddSamplerAction::act(), AddMFEMComplexBCComponentAction::act(), AddControlAction::act(), AddMFEMFESpaceAction::act(), AddMFEMPreconditionerAction::act(), AddMFEMSubMeshAction::act(), AddMFEMSolverAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenPointVectorsGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), 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& MooseBase::_pars
protectedinherited

The object's parameters.

Definition at line 394 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddMFEMComplexKernelComponentAction::act(), AddMFEMComplexBCComponentAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), MooseBase::haveParameter(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _radial_expansion_method

const MooseEnum AdvancedExtruderGenerator::_radial_expansion_method
protected

Function type for modifying the radial extent of the extruded shape.

Definition at line 101 of file AdvancedExtruderGenerator.h.

Referenced by radialExpansionRatio().

◆ _start_extrusion_direction

const RealVectorValue AdvancedExtruderGenerator::_start_extrusion_direction
protected

Extrusion direction to follow at the start (first layer) of the extrusion.

Definition at line 70 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _start_radial_growth_rate

const Real AdvancedExtruderGenerator::_start_radial_growth_rate
protected

Derivative of the radial expansion function at the beginning of the extrusion.

Definition at line 103 of file AdvancedExtruderGenerator.h.

Referenced by radialExpansionRatio().

◆ _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 77 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _twist_pitch

const Real AdvancedExtruderGenerator::_twist_pitch
protected

Axial pitch for a full rotation.

Definition at line 95 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _type

const std::string& MooseBase::_type
protectedinherited

The type of this class.

Definition at line 388 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseBase::MooseBase(), 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 86 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 83 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ app_param

const std::string MooseBase::app_param = "_moose_app"
staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), Factory::getValidParams(), ActionFactory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ 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 76 of file MeshGenerator.h.

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

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"
staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"
staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ 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.

◆ name_param

const std::string MooseBase::name_param = "_object_name"
staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), ActionFactory::create(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ 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().

◆ type_param

const std::string MooseBase::type_param = "_type"
staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"
staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings
inherited

Definition at line 67 of file MooseObject.h.

The documentation for this class was generated from the following files:
Generated on Wed Jun 24 2026 08:08:24 for https://mooseframework.inl.gov by   doxygen 1.8.14