www.mooseframework.org
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
ConcentricCircleMeshGenerator Class Reference

Generates a mesh based on concentric circles, given all the parameters. More...

#include <ConcentricCircleMeshGenerator.h>

Inheritance diagram for ConcentricCircleMeshGenerator:
[legend]

Public Types

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

Public Member Functions

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

Static Public Member Functions

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

Public Attributes

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

Static Public Attributes

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

Protected Member Functions

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

Static Protected Member Functions

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

Protected Attributes

unsigned int _num_sectors
 Number of sectors in one quadrant. More...
 
std::vector< Real_radii
 Radii of concentric circles. More...
 
std::vector< unsigned int_rings
 Number of rings in each circle or in the enclosing square. More...
 
bool _has_outer_square
 Adding the enclosing square is optional. More...
 
Real _pitch
 
bool _preserve_volumes
 Volume preserving function is optional. More...
 
unsigned int _smoothing_max_it
 Iteration number for Laplace smoothing. More...
 
MooseEnum _portion
 Control of which portion of mesh will be developed. More...
 
MooseMesh *const _mesh
 Pointer to the owning mesh. More...
 
const bool & _enabled
 Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects. More...
 
MooseApp_app
 The MOOSE application this is associated with. More...
 
const std::string _type
 The type of this class. More...
 
const std::string _name
 The name of this class. More...
 
const InputParameters_pars
 Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...
 
Factory_factory
 The Factory associated with the MooseApp. More...
 
ActionFactory_action_factory
 Builds Actions. More...
 
const Parallel::Communicator & _communicator
 

Detailed Description

Generates a mesh based on concentric circles, given all the parameters.

Definition at line 18 of file ConcentricCircleMeshGenerator.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface< MooseObject >::DataFileParameterType = DataFileName
inherited

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

Definition at line 26 of file DataFileInterface.h.

Constructor & Destructor Documentation

◆ ConcentricCircleMeshGenerator()

ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator ( const InputParameters parameters)

Definition at line 59 of file ConcentricCircleMeshGenerator.C.

61  _num_sectors(getParam<unsigned int>("num_sectors")),
62  _radii(getParam<std::vector<Real>>("radii")),
63  _rings(getParam<std::vector<unsigned int>>("rings")),
64  _has_outer_square(getParam<bool>("has_outer_square")),
65  _pitch(getParam<Real>("pitch")),
66  _preserve_volumes(getParam<bool>("preserve_volumes")),
67  _smoothing_max_it(getParam<unsigned int>("smoothing_max_it")),
68  _portion(getParam<MooseEnum>("portion"))
69 {
70  declareMeshProperty("use_distributed_mesh", false);
71 
72  if (_num_sectors % 2 != 0)
73  paramError("num_sectors", "must be an even number.");
74 
75  // radii data check
76  for (unsigned i = 0; i < _radii.size() - 1; ++i)
77  {
78  if (_radii[i] == 0.0)
79  paramError("radii", "must be positive numbers.");
80  if (_radii[i] > _radii[i + 1])
81  paramError("radii",
82  "must be provided in order by starting with the smallest radius providing the "
83  "following gradual radii.");
84  }
85 
86  // size of 'rings' check
88  {
89  if (_rings.size() != _radii.size() + 1)
90  paramError("rings", "The size of 'rings' must be equal to the size of 'radii' plus 1.");
91  }
92  else
93  {
94  if (_rings.size() != _radii.size())
95  paramError("rings", "The size of 'rings' must be equal to the size of 'radii'.");
96  }
97  // pitch / 2 must be bigger than any raddi.
99  for (unsigned i = 0; i < _radii.size(); ++i)
100  if (_pitch / 2 < _radii[i])
101  paramError("pitch", "The pitch / 2 must be larger than any radii.");
102 }
unsigned int _smoothing_max_it
Iteration number for Laplace smoothing.
bool _preserve_volumes
Volume preserving function is optional.
MeshGenerator(const InputParameters &parameters)
Definition: MeshGenerator.C:54
std::vector< Real > _radii
Radii of concentric circles.
std::vector< unsigned int > _rings
Number of rings in each circle or in the enclosing square.
bool _has_outer_square
Adding the enclosing square is optional.
MooseEnum _portion
Control of which portion of mesh will be developed.
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
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 ...
const InputParameters & parameters() const
Get the parameters of the object.
unsigned int _num_sectors
Number of sectors in one quadrant.
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...

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

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

◆ addMeshSubgenerator() [1/2]

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

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

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

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

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

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

Definition at line 513 of file MeshGenerator.h.

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

516 {
517  InputParameters subgenerator_params = _app.getFactory().getValidParams(type);
518 
519  subgenerator_params.setParameters(extra_input_parameters...);
520 
521  addMeshSubgenerator(type, name, subgenerator_params);
522 }
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition: Factory.C:67
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition: MooseApp.h:396
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...
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:51
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
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...

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

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

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

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

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

Referenced by DistributedRectilinearMeshGenerator::generate().

248 {
249  mooseAssert(_mesh, "Need a MooseMesh object");
250  return _mesh->buildTypedMesh<DistributedMesh>(dim);
251 }
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:148
MooseMesh *const _mesh
Pointer to the owning mesh.
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:2031

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

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

234 {
235  mooseAssert(_mesh, "Need a MooseMesh object");
236  return _mesh->buildMeshBaseObject(dim);
237 }
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:148
MooseMesh *const _mesh
Pointer to the owning mesh.
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:2603

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

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

241 {
242  mooseAssert(_mesh, "Need a MooseMesh object");
243  return _mesh->buildTypedMesh<ReplicatedMesh>(dim);
244 }
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:148
MooseMesh *const _mesh
Pointer to the owning mesh.
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:2031

◆ callMooseError()

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

Calls moose error with the message msg.

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

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

Definition at line 33 of file MooseBase.C.

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

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

◆ connectControllableParams()

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

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

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

Definition at line 33 of file MooseBaseParameterInterface.C.

37 {
38  MooseObjectParameterName primary_name(uniqueName(), parameter);
39  const auto base_type = _factory.getValidParams(object_type).get<std::string>("_moose_base");
40  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
42  primary_name, secondary_name);
43 
44  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
45  for (const auto & tag : tags)
46  {
47  if (!tag.empty())
48  {
49  MooseObjectParameterName tagged_name(tag, _moose_base.name(), parameter);
51  tagged_name, secondary_name);
52  }
53  }
54 }
void addControllableParameterConnection(const MooseObjectParameterName &primary, const MooseObjectParameterName &secondary, bool error_on_empty=true)
Method for linking control parameters of different names.
const MooseBase & _moose_base
The MooseBase object that inherits this class.
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.
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition: MooseApp.C:2218
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition: Factory.C:67
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:45
Factory & _factory
The Factory associated with the MooseApp.
MooseObjectName uniqueName() const
The unique name for accessing input parameters of this object in the InputParameterWarehouse.
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
A class for storing an input parameter name.

◆ copyMeshProperty() [1/2]

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

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

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

Definition at line 233 of file MeshGenerator.h.

236  {
237  return declareMeshProperty(target_data_name, getMeshProperty<T>(source_data_name, source_mesh));
238  }
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...

◆ copyMeshProperty() [2/2]

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

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

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

Definition at line 246 of file MeshGenerator.h.

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

◆ declareMeshesForSub()

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

Like declareMeshForSub(), but for multiple generators.

Definition at line 209 of file MeshGenerator.C.

210 {
212 }
void declareMeshesForSubByName(const std::vector< MeshGeneratorName > &mesh_generator_names)
Like declareMeshForSubByName(), but for multiple generators.
const std::vector< MeshGeneratorName > & getMeshGeneratorNamesFromParam(const std::string &param_name) const
Helper for getting a std::vector<MeshGeneratorName> parameter.

◆ declareMeshesForSubByName()

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

Like declareMeshForSubByName(), but for multiple generators.

Definition at line 225 of file MeshGenerator.C.

Referenced by MeshGenerator::declareMeshesForSub().

227 {
228  for (const auto & name : mesh_generator_names)
230 }
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
void declareMeshForSubByName(const MeshGeneratorName &mesh_generator_name)
Like declareMeshForSub(), but takes the name of another MeshGenerator directly.

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

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

204 {
206 }
void declareMeshForSubByName(const MeshGeneratorName &mesh_generator_name)
Like declareMeshForSub(), but takes the name of another MeshGenerator directly.
const MeshGeneratorName * getMeshGeneratorNameFromParam(const std::string &param_name, const bool allow_invalid) const
Helper for getting a MeshGeneratorName parameter.
Definition: MeshGenerator.C:88

◆ declareMeshForSubByName()

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

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

Definition at line 215 of file MeshGenerator.C.

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

216 {
217  checkGetMesh(mesh_generator_name, "");
218  if (isNullMeshName(mesh_generator_name))
219  return;
220 
221  _requested_mesh_generators_for_sub.insert(mesh_generator_name);
222 }
bool isNullMeshName(const MeshGeneratorName &name) const
std::set< MeshGeneratorName > _requested_mesh_generators_for_sub
The names of the MeshGenerators that were requested in the declareMeshForSub methods.
void checkGetMesh(const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const
Helper for performing error checking in the getMesh methods.

◆ declareMeshProperty() [1/2]

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

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

Definition at line 455 of file MeshGenerator.h.

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

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

◆ declareMeshProperty() [2/2]

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

Definition at line 206 of file MeshGenerator.h.

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

◆ declareNullMeshName()

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

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

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

Definition at line 392 of file MeshGenerator.C.

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

◆ enabled()

virtual bool MooseObject::enabled ( ) const
inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

Referenced by EigenKernel::enabled().

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

◆ errorPrefix()

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

Definition at line 43 of file MooseBase.C.

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

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

◆ generate()

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

Generate / modify the mesh.

Implements MeshGenerator.

Definition at line 105 of file ConcentricCircleMeshGenerator.C.

106 {
107  auto mesh = buildReplicatedMesh(2);
108  BoundaryInfo & boundary_info = mesh->get_boundary_info();
109 
110  // Creating real mesh concentric circles
111  // i: index for _rings, j: index for _radii
112  std::vector<Real> total_concentric_circles;
113  unsigned int j = 0;
114  while (j < _radii.size())
115  {
116  unsigned int i = 0;
117  if (j == 0)
118  while (i < _rings[j])
119  {
120  total_concentric_circles.push_back(_radii[j] / (_num_sectors / 2 + _rings[j]) *
121  (i + _num_sectors / 2 + 1));
122  ++i;
123  }
124  else
125  while (i < _rings[j])
126  {
127  total_concentric_circles.push_back(_radii[j - 1] +
128  (_radii[j] - _radii[j - 1]) / _rings[j] * (i + 1));
129  ++i;
130  }
131  ++j;
132  }
133 
134  // volume preserving function is used to conserve volume.
135  const Real d_angle = M_PI / 2 / _num_sectors;
136 
137  if (_preserve_volumes)
138  {
139  Real original_radius = 0.0;
140  for (unsigned i = 0; i < total_concentric_circles.size(); ++i)
141  {
142  // volume preserving function for the center circle
143  if (i == 0)
144  {
145  const Real target_area = M_PI * Utility::pow<2>(total_concentric_circles[i]);
146  Real modified_radius = std::sqrt(2 * target_area / std::sin(d_angle) / _num_sectors / 4);
147  original_radius = total_concentric_circles[i];
148  total_concentric_circles[i] = modified_radius;
149  }
150  else
151  {
152  // volume preserving functions for outer circles
153  const Real target_area = M_PI * (Utility::pow<2>(total_concentric_circles[i]) -
154  Utility::pow<2>(original_radius));
155  Real modified_radius = std::sqrt(target_area / std::sin(d_angle) / _num_sectors / 2 +
156  Utility::pow<2>(total_concentric_circles[i - 1]));
157  original_radius = total_concentric_circles[i];
158  total_concentric_circles[i] = modified_radius;
159  }
160  }
161  }
162 
163  // number of total nodes
164  unsigned num_total_nodes = 0;
165 
166  if (_has_outer_square)
167  num_total_nodes = Utility::pow<2>(_num_sectors / 2 + 1) +
168  (_num_sectors + 1) * total_concentric_circles.size() +
169  Utility::pow<2>(_rings.back() + 2) + _num_sectors * (_rings.back() + 1) - 1;
170  else
171  num_total_nodes = Utility::pow<2>(_num_sectors / 2 + 1) +
172  (_num_sectors + 1) * total_concentric_circles.size();
173 
174  std::vector<Node *> nodes(num_total_nodes);
175 
176  unsigned node_id = 0;
177 
178  // for adding nodes for the square at the center of the circle
179  Real xx = total_concentric_circles[0] / (_num_sectors / 2 + 1) * _num_sectors / 2;
180  Point p1 = Point(xx, 0, 0);
181  Point p2 = Point(0, xx, 0);
182  Point p3 = Point(xx * std::sqrt(2.0) / 2, xx * std::sqrt(2.0) / 2, 0);
183  for (unsigned i = 0; i <= _num_sectors / 2; ++i)
184  {
185  Real fx = i / (_num_sectors / 2.0);
186  for (unsigned j = 0; j <= _num_sectors / 2; ++j)
187  {
188  Real fy = j / (_num_sectors / 2.0);
189  Point p = p1 * fx * (1 - fy) + p2 * fy * (1 - fx) + p3 * fx * fy;
190  nodes[node_id] = mesh->add_point(p, node_id);
191  ++node_id;
192  }
193  }
194 
195  // for adding the outer layers of the square
196  Real current_radius = total_concentric_circles[0];
197 
198  // for adding the outer circles of the square.
199  for (unsigned layers = 0; layers < total_concentric_circles.size(); ++layers)
200  {
201  current_radius = total_concentric_circles[layers];
202  for (unsigned num_outer_nodes = 0; num_outer_nodes <= _num_sectors; ++num_outer_nodes)
203  {
204  const Real x = current_radius * std::cos(num_outer_nodes * d_angle);
205  const Real y = current_radius * std::sin(num_outer_nodes * d_angle);
206  nodes[node_id] = mesh->add_point(Point(x, y, 0.0), node_id);
207  ++node_id;
208  }
209  }
210 
211  // adding nodes for the enclosing square.
212  // adding nodes for the left edge of the square.
213  // applying the method for partitioning the line segments.
214 
215  if (_has_outer_square)
216  {
217  // putting nodes for the left side of the enclosing square.
218  for (unsigned i = 0; i <= _num_sectors / 2; ++i)
219  {
220  const Real a1 = (_pitch / 2) * i / (_num_sectors / 2 + _rings.back() + 1);
221  const Real b1 = _pitch / 2;
222 
223  const Real a2 = total_concentric_circles.back() * std::cos(M_PI / 2 - i * d_angle);
224  const Real b2 = total_concentric_circles.back() * std::sin(M_PI / 2 - i * d_angle);
225 
226  for (unsigned j = 0; j <= _rings.back(); ++j)
227  {
228  Real x = ((_rings.back() + 1 - j) * a1 + j * a2) / (_rings.back() + 1);
229  Real y = ((_rings.back() + 1 - j) * b1 + j * b2) / (_rings.back() + 1);
230  nodes[node_id] = mesh->add_point(Point(x, y, 0.0), node_id);
231  ++node_id;
232  }
233  }
234  // putting nodes for the center part of the enclosing square.
235  unsigned k = 1;
236  for (unsigned i = 1; i <= _rings.back() + 1; ++i)
237  {
238  const Real a1 =
239  (_pitch / 2) * (i + _num_sectors / 2) / (_num_sectors / 2 + _rings.back() + 1);
240  const Real b1 = _pitch / 2;
241 
242  const Real a2 = _pitch / 2;
243  const Real b2 = (_pitch / 2) * (_num_sectors / 2) / (_num_sectors / 2 + _rings.back() + 1);
244 
245  const Real a3 = total_concentric_circles.back() * std::cos(M_PI / 4);
246  const Real b3 = total_concentric_circles.back() * std::sin(M_PI / 4);
247 
248  const Real a4 = ((_rings.back() + 1 - k) * a3 + k * a2) / (_rings.back() + 1);
249  const Real b4 = ((_rings.back() + 1 - k) * b3 + k * b2) / (_rings.back() + 1);
250 
251  for (unsigned j = 0; j <= _rings.back() + 1; ++j)
252  {
253  Real x = ((_rings.back() + 1 - j) * a1 + j * a4) / (_rings.back() + 1);
254  Real y = ((_rings.back() + 1 - j) * b1 + j * b4) / (_rings.back() + 1);
255  nodes[node_id] = mesh->add_point(Point(x, y, 0.0), node_id);
256  ++node_id;
257  }
258  ++k;
259  }
260 
261  // putting nodes for the right part of the enclosing square.
262  for (unsigned i = 1; i <= _num_sectors / 2; ++i)
263  {
264  const Real a1 = _pitch / 2;
265  const Real b1 =
266  (_pitch / 2) * (_num_sectors / 2 - i) / (_num_sectors / 2 + _rings.back() + 1);
267 
268  const Real a2 = total_concentric_circles.back() * std::cos(M_PI / 4 - i * d_angle);
269  const Real b2 = total_concentric_circles.back() * std::sin(M_PI / 4 - i * d_angle);
270 
271  for (unsigned j = 0; j <= _rings.back(); ++j)
272  {
273  Real x = ((_rings.back() + 1 - j) * a1 + j * a2) / (_rings.back() + 1);
274  Real y = ((_rings.back() + 1 - j) * b1 + j * b2) / (_rings.back() + 1);
275  nodes[node_id] = mesh->add_point(Point(x, y, 0.0), node_id);
276  ++node_id;
277  }
278  }
279  }
280 
281  // Currently, index, limit, counter variables use the int type because of the 'modulo' function.
282  // adding elements
283  int index = 0;
284  int limit = 0;
285  int standard = static_cast<int>(_num_sectors);
286 
287  // This is to set the limit for the index
288  if (standard > 4)
289  {
290  int additional_term = 0;
291  int counter = standard;
292  while (counter > 4)
293  {
294  counter = counter - 2;
295  additional_term = additional_term + counter;
296  }
297  limit = standard + additional_term;
298  }
299  else if (standard == 4)
300  limit = standard;
301 
302  // SubdomainIDs set up
303  std::vector<unsigned int> subdomainIDs;
304 
305  if (_has_outer_square)
306  for (unsigned int i = 0; i < _rings.size() - 1; ++i)
307  for (unsigned int j = 0; j < _rings[i]; ++j)
308  subdomainIDs.push_back(i + 1);
309  else
310  for (unsigned int i = 0; i < _rings.size(); ++i)
311  for (unsigned int j = 0; j < _rings[i]; ++j)
312  subdomainIDs.push_back(i + 1);
313 
314  // adding elements in the square
315  while (index <= limit)
316  {
317  // inner circle area (polygonal core)
318  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
319  elem->set_node(0) = nodes[index];
320  elem->set_node(1) = nodes[index + _num_sectors / 2 + 1];
321  elem->set_node(2) = nodes[index + _num_sectors / 2 + 2];
322  elem->set_node(3) = nodes[index + 1];
323  elem->subdomain_id() = subdomainIDs[0];
324 
325  if (index < standard / 2)
326  boundary_info.add_side(elem, 3, 1);
327  if (index % (standard / 2 + 1) == 0)
328  boundary_info.add_side(elem, 0, 2);
329 
330  ++index;
331 
332  // increment by 2 indices is necessary depending on where the index points to.
333  if ((index - standard / 2) % (standard / 2 + 1) == 0)
334  ++index;
335  }
336 
337  index = (_num_sectors / 2 + 1) * (_num_sectors / 2);
338  limit = (_num_sectors / 2) * (_num_sectors / 2 + 2);
339 
340  // adding elements in one outer layer of the square (right side)
341  while (index < limit)
342  {
343  // inner circle elements touching B
344  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
345  elem->set_node(0) = nodes[index];
346  elem->set_node(1) = nodes[index + _num_sectors / 2 + 1];
347  elem->set_node(2) = nodes[index + _num_sectors / 2 + 2];
348  elem->set_node(3) = nodes[index + 1];
349  elem->subdomain_id() = subdomainIDs[0];
350 
351  if (index == (standard / 2 + 1) * (standard / 2))
352  boundary_info.add_side(elem, 0, 2);
353 
354  ++index;
355  }
356 
357  // adding elements in one outer layer of the square (left side)
358  int counter = 0;
359  while (index != standard / 2)
360  {
361  // inner circle elements touching C
362  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
363  elem->set_node(0) = nodes[index];
364  elem->set_node(1) = nodes[index + (_num_sectors / 2 + 1) + counter * (_num_sectors / 2 + 2)];
365  elem->set_node(2) =
366  nodes[index + (_num_sectors / 2 + 1) + counter * (_num_sectors / 2 + 2) + 1];
367  elem->set_node(3) = nodes[index - _num_sectors / 2 - 1];
368  elem->subdomain_id() = subdomainIDs[0];
369 
370  if (index == standard + 1)
371  boundary_info.add_side(elem, 2, 1);
372 
373  index = index - _num_sectors / 2 - 1;
374  ++counter;
375  }
376 
377  counter = 0;
378  // adding elements for other concentric circles
379  index = Utility::pow<2>(standard / 2 + 1);
380  limit = Utility::pow<2>(standard / 2 + 1) +
381  (_num_sectors + 1) * (total_concentric_circles.size() - 1);
382 
383  int num_nodes_boundary = Utility::pow<2>(standard / 2 + 1) + standard + 1;
384 
385  while (index < limit)
386  {
387  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
388  elem->set_node(0) = nodes[index];
389  elem->set_node(1) = nodes[index + standard + 1];
390  elem->set_node(2) = nodes[index + standard + 2];
391  elem->set_node(3) = nodes[index + 1];
392 
393  for (int i = 0; i < static_cast<int>(subdomainIDs.size() - 1); ++i)
394  if (index < limit - (standard + 1) * i && index >= limit - (standard + 1) * (i + 1))
395  elem->subdomain_id() = subdomainIDs[subdomainIDs.size() - 1 - i];
396 
397  const int initial = Utility::pow<2>(standard / 2 + 1);
398  const int final = Utility::pow<2>(standard / 2 + 1) + standard - 1;
399 
400  if ((index - initial) % (standard + 1) == 0)
401  boundary_info.add_side(elem, 0, 2);
402  if ((index - final) % (standard + 1) == 0)
403  boundary_info.add_side(elem, 2, 1);
404  if (!_has_outer_square)
405  if (index >= limit - (standard + 1))
406  boundary_info.add_side(elem, 1, 3);
407 
408  // index increment is for adding nodes for a next element.
409  ++index;
410 
411  // increment by 2 indices may be necessary depending on where the index points to.
412  // this varies based on the algorithms provided for the specific element and node placement.
413  if (index == (num_nodes_boundary + counter * (standard + 1)) - 1)
414  {
415  ++index;
416  ++counter;
417  }
418  }
419 
420  // Enclosing square sections
421  // ABCA
422  // C B
423  // B C
424  // ACBA
425 
426  // adding elements for the enclosing square. (top left)
427  int initial =
428  Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size();
429 
430  int initial2 =
431  Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size();
432 
433  if (_has_outer_square)
434  {
435  if (_rings.back() != 0) // this must be condition up front.
436  {
437  index = Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size();
438  limit = Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size() +
439  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 3 -
440  _rings.back() * (_rings.back() + 2) - (_rings.back() + 1);
441  while (index <= limit)
442  {
443  // outer square sector C
444  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
445  elem->set_node(0) = nodes[index];
446  elem->set_node(1) = nodes[index + 1];
447  elem->set_node(2) = nodes[index + 1 + _rings.back() + 1];
448  elem->set_node(3) = nodes[index + 1 + _rings.back()];
449  elem->subdomain_id() = subdomainIDs.back() + 1;
450 
451  if (index < (initial2 + static_cast<int>(_rings.back())))
452  boundary_info.add_side(elem, 0, 1);
453 
454  if (index == initial)
455  boundary_info.add_side(elem, 3, 4);
456 
457  ++index;
458 
459  // As mentioned before, increment by 2 indices may be required depending on where the index
460  // points to.
461  if ((index - initial) % static_cast<int>(_rings.back()) == 0)
462  {
463  ++index;
464  initial = initial + (static_cast<int>(_rings.back()) + 1);
465  }
466  }
467 
468  // adding elements for the enclosing square. (top right)
469  initial = Utility::pow<2>(standard / 2 + 1) +
470  (standard + 1) * total_concentric_circles.size() +
471  (_rings.back() + 1) * (standard / 2 + 1);
472 
473  limit = Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size() +
474  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 3 -
475  (_rings.back() + 2);
476 
477  while (index <= limit)
478  {
479  // outer square sector A
480  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
481  elem->set_node(3) = nodes[index];
482  elem->set_node(2) = nodes[index + _rings.back() + 2];
483  elem->set_node(1) = nodes[index + _rings.back() + 3];
484  elem->set_node(0) = nodes[index + 1];
485  elem->subdomain_id() = subdomainIDs.back() + 1;
486 
487  if (index >= static_cast<int>(limit - (_rings.back() + 1)))
488  boundary_info.add_side(elem, 1, 3);
489 
490  if ((index - initial) % static_cast<int>(_rings.back() + 2) == 0)
491  boundary_info.add_side(elem, 2, 4);
492 
493  ++index;
494 
495  if ((index - initial) % static_cast<int>(_rings.back() + 1) == 0)
496  {
497  ++index;
498  initial = initial + (static_cast<int>(_rings.back()) + 2);
499  }
500  }
501 
502  // adding elements for the enclosing square. (one center quad)
503  int index1 = Utility::pow<2>(standard / 2 + 1) +
504  (standard + 1) * (total_concentric_circles.size() - 1) + standard / 2;
505 
506  int index2 = Utility::pow<2>(standard / 2 + 1) +
507  (standard + 1) * total_concentric_circles.size() +
508  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 3 -
509  _rings.back() * (_rings.back() + 2) - (_rings.back() + 1);
510 
511  // pointy tips of the A sectors, touching the inner circle
512  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
513  elem->set_node(3) = nodes[index1];
514  elem->set_node(2) = nodes[index2];
515  elem->set_node(1) = nodes[index2 + _rings.back() + 1];
516  elem->set_node(0) = nodes[index2 + _rings.back() + 2];
517  elem->subdomain_id() = subdomainIDs.back() + 1;
518 
519  // adding elements for the left mid part.
520  index = Utility::pow<2>(standard / 2 + 1) + standard / 2 +
521  (standard + 1) * (total_concentric_circles.size() - 1);
522  limit = index + standard / 2 - 1;
523 
524  while (index <= limit)
525  {
526  // outer square elements in sector C touching the inner circle
527  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
528  elem->set_node(3) = nodes[index];
529  elem->set_node(2) = nodes[index + 1];
530  elem->set_node(1) = nodes[index2 - _rings.back() - 1];
531  elem->set_node(0) = nodes[index2];
532  elem->subdomain_id() = subdomainIDs.back() + 1;
533 
534  if (index == limit)
535  boundary_info.add_side(elem, 1, 1);
536 
537  ++index;
538 
539  // two different indices are used to add nodes for an element.
540  index2 = index2 - _rings.back() - 1;
541  }
542 
543  // adding elements for the right mid part.
544  index1 = Utility::pow<2>(standard / 2 + 1) + standard / 2 +
545  (standard + 1) * (total_concentric_circles.size() - 1);
546  index2 = Utility::pow<2>(standard / 2 + 1) +
547  (standard + 1) * total_concentric_circles.size() +
548  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 2 +
549  (_rings.back() + 1);
550  int index3 =
551  Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size() +
552  (_rings.back() + 1) * (standard / 2) - 1 + (_rings.back() + 1) + (_rings.back() + 2);
553 
554  // elements clockwise from the A sector tips
555  elem = mesh->add_elem(std::make_unique<Quad4>());
556  elem->set_node(0) = nodes[index1];
557  elem->set_node(1) = nodes[index1 - 1];
558  elem->set_node(2) = nodes[index2];
559  elem->set_node(3) = nodes[index3];
560  elem->subdomain_id() = subdomainIDs.back() + 1;
561 
562  if (standard == 2)
563  boundary_info.add_side(elem, 1, 2);
564 
565  // adding elements for the right mid bottom part.
566 
567  index = Utility::pow<2>(standard / 2 + 1) + standard / 2 +
568  (standard + 1) * (total_concentric_circles.size() - 1) - 2;
569  index1 = Utility::pow<2>(standard / 2 + 1) +
570  (standard + 1) * total_concentric_circles.size() +
571  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 2 +
572  (_rings.back() + 1) * 2;
573 
574  limit = Utility::pow<2>(standard / 2 + 1) + standard / 2 +
575  (standard + 1) * (total_concentric_circles.size() - 1) - standard / 2;
576 
577  if (standard != 2)
578  {
579  while (index >= limit)
580  {
581  // outer square elements in sector B touching the inner circle
582  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
583  elem->set_node(0) = nodes[index];
584  elem->set_node(1) = nodes[index1];
585  elem->set_node(2) = nodes[index1 - (_rings.back() + 1)];
586  elem->set_node(3) = nodes[index + 1];
587  elem->subdomain_id() = subdomainIDs.back() + 1;
588 
589  if (index == limit)
590  boundary_info.add_side(elem, 0, 2);
591  --index;
592  index1 = index1 + (_rings.back() + 1);
593  }
594  }
595 
596  // adding elements for the right low part.
597  index = Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size() +
598  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 2;
599 
600  index1 = index - (_rings.back() + 2);
601  // dummy condition for elem definition
602  if (standard >= 2)
603  {
604  // single elements between A and B on the outside of the square
605  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
606  elem->set_node(3) = nodes[index];
607  elem->set_node(2) = nodes[index + 1];
608  elem->set_node(1) = nodes[index + 2];
609  elem->set_node(0) = nodes[index1];
610  elem->subdomain_id() = subdomainIDs.back() + 1;
611 
612  boundary_info.add_side(elem, 2, 3);
613 
614  if (standard == 2)
615  boundary_info.add_side(elem, 1, 2);
616  }
617 
618  index = Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size() +
619  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 2 -
620  (_rings.back() + 2);
621 
622  limit = Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size() +
623  (_rings.back() + 1) * (standard / 2) + (_rings.back() + 2) * 2 - 2;
624 
625  int k = 1;
626  while (index > limit)
627  {
628  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
629  elem->set_node(3) = nodes[index];
630  elem->set_node(2) = nodes[index + (_rings.back() + 2) * k + k + 1];
631  elem->set_node(1) = nodes[index + (_rings.back() + 2) * k + k + 2];
632  elem->set_node(0) = nodes[index - _rings.back() - 2];
633  elem->subdomain_id() = subdomainIDs.back() + 1;
634  index = index - (_rings.back() + 2);
635  ++k;
636 
637  if (standard == 2)
638  boundary_info.add_side(elem, 1, 2);
639  }
640 
641  index = Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size() +
642  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 1;
643  initial = Utility::pow<2>(standard / 2 + 1) +
644  (standard + 1) * total_concentric_circles.size() +
645  (_rings.back() + 1) * (standard / 2) + Utility::pow<2>(_rings.back() + 2) - 1;
646  limit = Utility::pow<2>(standard / 2 + 1) + (standard + 1) * total_concentric_circles.size() +
647  (_rings.back() + 1) * (standard / 2) * 2 + Utility::pow<2>(_rings.back() + 2) - 2 -
648  _rings.back() - 1;
649 
650  initial2 = Utility::pow<2>(standard / 2 + 1) +
651  (standard + 1) * total_concentric_circles.size() +
652  (_rings.back() + 1) * (standard / 2) * 2 + Utility::pow<2>(_rings.back() + 2) - 2 -
653  (_rings.back() + 1) * 2;
654 
655  if (standard > 2)
656  {
657  while (index < limit)
658  {
659  Elem * elem = mesh->add_elem(std::make_unique<Quad4>());
660  elem->set_node(0) = nodes[index];
661  elem->set_node(1) = nodes[index + 1];
662  elem->set_node(2) = nodes[index + 1 + _rings.back() + 1];
663  elem->set_node(3) = nodes[index + 1 + _rings.back()];
664  elem->subdomain_id() = subdomainIDs.back() + 1;
665 
666  if (index > initial2)
667  boundary_info.add_side(elem, 2, 2);
668 
669  if ((index - initial) == 0)
670  boundary_info.add_side(elem, 3, 3);
671 
672  ++index;
673 
674  if ((index - initial) % static_cast<int>(_rings.back()) == 0)
675  {
676  ++index;
677  initial = initial + (static_cast<int>(_rings.back()) + 1);
678  }
679  }
680  }
681  }
682  }
683 
684  // This is to set boundary names.
685  boundary_info.sideset_name(1) = "left";
686  boundary_info.sideset_name(2) = "bottom";
687 
688  if (!_has_outer_square)
689  boundary_info.sideset_name(3) = "outer";
690  else
691  {
692  boundary_info.sideset_name(3) = "right";
693  boundary_info.sideset_name(4) = "top";
694  }
695 
696  if (_portion == "top_left")
697  {
698  MeshTools::Modification::rotate(*mesh, 90, 0, 0);
699  boundary_info.sideset_name(1) = "bottom";
700  boundary_info.sideset_name(2) = "right";
701 
702  if (!_has_outer_square)
703  boundary_info.sideset_name(3) = "outer";
704  else
705  {
706  boundary_info.sideset_name(3) = "top";
707  boundary_info.sideset_name(4) = "left";
708  }
709  }
710  else if (_portion == "bottom_left")
711  {
712  MeshTools::Modification::rotate(*mesh, 180, 0, 0);
713  boundary_info.sideset_name(1) = "right";
714  boundary_info.sideset_name(2) = "top";
715 
716  if (!_has_outer_square)
717  boundary_info.sideset_name(3) = "outer";
718  else
719  {
720  boundary_info.sideset_name(3) = "left";
721  boundary_info.sideset_name(4) = "bottom";
722  }
723  }
724  else if (_portion == "bottom_right")
725  {
726  MeshTools::Modification::rotate(*mesh, 270, 0, 0);
727  boundary_info.sideset_name(1) = "top";
728  boundary_info.sideset_name(2) = "left";
729 
730  if (!_has_outer_square)
731  boundary_info.sideset_name(3) = "outer";
732  else
733  {
734  boundary_info.sideset_name(3) = "bottom";
735  boundary_info.sideset_name(4) = "right";
736  }
737  }
738 
739  else if (_portion == "top_half")
740  {
741  ReplicatedMesh other_mesh(*mesh);
742  // This is to rotate the mesh and also to reset boundary IDs.
743  MeshTools::Modification::rotate(other_mesh, 90, 0, 0);
744  if (_has_outer_square)
745  {
746  MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
747  MeshTools::Modification::change_boundary_id(other_mesh, 2, 6);
748  MeshTools::Modification::change_boundary_id(other_mesh, 3, 7);
749  MeshTools::Modification::change_boundary_id(other_mesh, 4, 1);
750  MeshTools::Modification::change_boundary_id(other_mesh, 5, 2);
751  MeshTools::Modification::change_boundary_id(other_mesh, 6, 3);
752  MeshTools::Modification::change_boundary_id(other_mesh, 7, 4);
753  mesh->prepare_for_use();
754  other_mesh.prepare_for_use();
755  mesh->stitch_meshes(other_mesh, 1, 3, TOLERANCE, true, /*verbose=*/false);
756  mesh->get_boundary_info().sideset_name(1) = "left";
757  mesh->get_boundary_info().sideset_name(2) = "bottom";
758  mesh->get_boundary_info().sideset_name(3) = "right";
759  mesh->get_boundary_info().sideset_name(4) = "top";
760  }
761  else
762  {
763  MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
764  MeshTools::Modification::change_boundary_id(other_mesh, 2, 1);
765  MeshTools::Modification::change_boundary_id(other_mesh, 5, 2);
766  mesh->prepare_for_use();
767  other_mesh.prepare_for_use();
768  mesh->stitch_meshes(other_mesh, 1, 1, TOLERANCE, true, /*verbose=*/false);
769 
770  MeshTools::Modification::change_boundary_id(*mesh, 2, 1);
771  MeshTools::Modification::change_boundary_id(*mesh, 3, 2);
772  mesh->get_boundary_info().sideset_name(1) = "bottom";
773  mesh->get_boundary_info().sideset_name(2) = "outer";
774  }
775  other_mesh.clear();
776  }
777 
778  else if (_portion == "right_half")
779  {
780  ReplicatedMesh other_mesh(*mesh);
781  // This is to rotate the mesh and also to reset boundary IDs.
782  MeshTools::Modification::rotate(other_mesh, 270, 0, 0);
783  if (_has_outer_square)
784  {
785  MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
786  MeshTools::Modification::change_boundary_id(other_mesh, 2, 6);
787  MeshTools::Modification::change_boundary_id(other_mesh, 3, 7);
788  MeshTools::Modification::change_boundary_id(other_mesh, 4, 3);
789  MeshTools::Modification::change_boundary_id(other_mesh, 5, 4);
790  MeshTools::Modification::change_boundary_id(other_mesh, 6, 1);
791  MeshTools::Modification::change_boundary_id(other_mesh, 7, 2);
792  mesh->prepare_for_use();
793  other_mesh.prepare_for_use();
794  mesh->stitch_meshes(other_mesh, 2, 4, TOLERANCE, true, /*verbose=*/false);
795  mesh->get_boundary_info().sideset_name(1) = "left";
796  mesh->get_boundary_info().sideset_name(2) = "bottom";
797  mesh->get_boundary_info().sideset_name(3) = "right";
798  mesh->get_boundary_info().sideset_name(4) = "top";
799  }
800  else
801  {
802  MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
803  MeshTools::Modification::change_boundary_id(other_mesh, 2, 1);
804  MeshTools::Modification::change_boundary_id(other_mesh, 5, 2);
805  mesh->prepare_for_use();
806  other_mesh.prepare_for_use();
807  mesh->stitch_meshes(other_mesh, 2, 2, TOLERANCE, true, /*verbose=*/false);
808 
809  MeshTools::Modification::change_boundary_id(*mesh, 3, 2);
810  mesh->get_boundary_info().sideset_name(1) = "left";
811  mesh->get_boundary_info().sideset_name(2) = "outer";
812  }
813  other_mesh.clear();
814  }
815  else if (_portion == "left_half")
816  {
817  ReplicatedMesh other_mesh(*mesh);
818 
819  // This is to rotate the mesh and to reset boundary IDs.
820  MeshTools::Modification::rotate(other_mesh, 90, 0, 0);
821  MeshTools::Modification::rotate(*mesh, 180, 0, 0);
822  if (_has_outer_square)
823  {
824  // The other mesh is created by rotating the original mesh about 90 degrees.
825  MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
826  MeshTools::Modification::change_boundary_id(other_mesh, 2, 6);
827  MeshTools::Modification::change_boundary_id(other_mesh, 3, 7);
828  MeshTools::Modification::change_boundary_id(other_mesh, 4, 1);
829  MeshTools::Modification::change_boundary_id(other_mesh, 5, 2);
830  MeshTools::Modification::change_boundary_id(other_mesh, 6, 3);
831  MeshTools::Modification::change_boundary_id(other_mesh, 7, 4);
832  // The original mesh is then rotated about 180 degrees.
833  MeshTools::Modification::change_boundary_id(*mesh, 1, 5);
834  MeshTools::Modification::change_boundary_id(*mesh, 2, 6);
835  MeshTools::Modification::change_boundary_id(*mesh, 3, 7);
836  MeshTools::Modification::change_boundary_id(*mesh, 4, 2);
837  MeshTools::Modification::change_boundary_id(*mesh, 5, 3);
838  MeshTools::Modification::change_boundary_id(*mesh, 6, 4);
839  MeshTools::Modification::change_boundary_id(*mesh, 7, 1);
840  mesh->prepare_for_use();
841  other_mesh.prepare_for_use();
842  mesh->stitch_meshes(other_mesh, 4, 2, TOLERANCE, true, /*verbose=*/false);
843  mesh->get_boundary_info().sideset_name(1) = "left";
844  mesh->get_boundary_info().sideset_name(2) = "bottom";
845  mesh->get_boundary_info().sideset_name(3) = "right";
846  mesh->get_boundary_info().sideset_name(4) = "top";
847  }
848  else
849  {
850  MeshTools::Modification::change_boundary_id(*mesh, 1, 5);
851  MeshTools::Modification::change_boundary_id(*mesh, 2, 1);
852  MeshTools::Modification::change_boundary_id(*mesh, 5, 2);
853  mesh->prepare_for_use();
854  other_mesh.prepare_for_use();
855  mesh->stitch_meshes(other_mesh, 1, 1, TOLERANCE, true, /*verbose=*/false);
856 
857  MeshTools::Modification::change_boundary_id(*mesh, 2, 1);
858  MeshTools::Modification::change_boundary_id(*mesh, 3, 2);
859  mesh->get_boundary_info().sideset_name(1) = "right";
860  mesh->get_boundary_info().sideset_name(2) = "outer";
861  }
862  other_mesh.clear();
863  }
864  else if (_portion == "bottom_half")
865  {
866  ReplicatedMesh other_mesh(*mesh);
867  // This is to rotate the mesh and also to reset boundary IDs.
868  MeshTools::Modification::rotate(other_mesh, 180, 0, 0);
869  MeshTools::Modification::rotate(*mesh, 270, 0, 0);
870  if (_has_outer_square)
871  {
872  // The other mesh is created by rotating the original mesh about 180 degrees.
873  MeshTools::Modification::change_boundary_id(other_mesh, 1, 5);
874  MeshTools::Modification::change_boundary_id(other_mesh, 2, 6);
875  MeshTools::Modification::change_boundary_id(other_mesh, 3, 7);
876  MeshTools::Modification::change_boundary_id(other_mesh, 4, 2);
877  MeshTools::Modification::change_boundary_id(other_mesh, 5, 3);
878  MeshTools::Modification::change_boundary_id(other_mesh, 6, 4);
879  MeshTools::Modification::change_boundary_id(other_mesh, 7, 1);
880  // The original mesh is rotated about 270 degrees.
881  MeshTools::Modification::change_boundary_id(*mesh, 1, 5);
882  MeshTools::Modification::change_boundary_id(*mesh, 2, 6);
883  MeshTools::Modification::change_boundary_id(*mesh, 3, 7);
884  MeshTools::Modification::change_boundary_id(*mesh, 4, 3);
885  MeshTools::Modification::change_boundary_id(*mesh, 5, 4);
886  MeshTools::Modification::change_boundary_id(*mesh, 6, 1);
887  MeshTools::Modification::change_boundary_id(*mesh, 7, 2);
888  mesh->prepare_for_use();
889  other_mesh.prepare_for_use();
890  mesh->stitch_meshes(other_mesh, 1, 3, TOLERANCE, true, /*verbose=*/false);
891  mesh->get_boundary_info().sideset_name(1) = "left";
892  mesh->get_boundary_info().sideset_name(2) = "bottom";
893  mesh->get_boundary_info().sideset_name(3) = "right";
894  mesh->get_boundary_info().sideset_name(4) = "top";
895  }
896  else
897  {
898  MeshTools::Modification::change_boundary_id(*mesh, 1, 5);
899  MeshTools::Modification::change_boundary_id(*mesh, 2, 1);
900  MeshTools::Modification::change_boundary_id(*mesh, 5, 2);
901  mesh->prepare_for_use();
902  other_mesh.prepare_for_use();
903  mesh->stitch_meshes(other_mesh, 1, 1, TOLERANCE, true, /*verbose=*/false);
904 
905  MeshTools::Modification::change_boundary_id(*mesh, 2, 1);
906  MeshTools::Modification::change_boundary_id(*mesh, 3, 2);
907  mesh->get_boundary_info().sideset_name(1) = "top";
908  mesh->get_boundary_info().sideset_name(2) = "outer";
909  }
910  other_mesh.clear();
911  }
912  else if (_portion == "full")
913  {
914  ReplicatedMesh portion_two(*mesh);
915 
916  // This is to rotate the mesh and also to reset boundary IDs.
917  MeshTools::Modification::rotate(portion_two, 90, 0, 0);
918 
919  if (_has_outer_square)
920  {
921  // Portion 2: 2nd quadrant
922  MeshTools::Modification::change_boundary_id(portion_two, 1, 5);
923  MeshTools::Modification::change_boundary_id(portion_two, 2, 6);
924  MeshTools::Modification::change_boundary_id(portion_two, 3, 7);
925  MeshTools::Modification::change_boundary_id(portion_two, 4, 1);
926  MeshTools::Modification::change_boundary_id(portion_two, 5, 2);
927  MeshTools::Modification::change_boundary_id(portion_two, 6, 3);
928  MeshTools::Modification::change_boundary_id(portion_two, 7, 4);
929  mesh->prepare_for_use();
930  portion_two.prepare_for_use();
931  // 'top_half'
932  mesh->stitch_meshes(portion_two, 1, 3, TOLERANCE, true, /*verbose=*/false);
933 
934  // 'bottom_half'
935  ReplicatedMesh portion_bottom(*mesh);
936  MeshTools::Modification::rotate(portion_bottom, 180, 0, 0);
937  MeshTools::Modification::change_boundary_id(portion_bottom, 1, 5);
938  MeshTools::Modification::change_boundary_id(portion_bottom, 2, 6);
939  MeshTools::Modification::change_boundary_id(portion_bottom, 3, 7);
940  MeshTools::Modification::change_boundary_id(portion_bottom, 4, 2);
941  MeshTools::Modification::change_boundary_id(portion_bottom, 5, 3);
942  MeshTools::Modification::change_boundary_id(portion_bottom, 6, 4);
943  MeshTools::Modification::change_boundary_id(portion_bottom, 7, 1);
944  mesh->prepare_for_use();
945  portion_bottom.prepare_for_use();
946  // 'full'
947  mesh->stitch_meshes(portion_bottom, 2, 4, TOLERANCE, true, /*verbose=*/false);
948 
949  mesh->get_boundary_info().sideset_name(1) = "left";
950  mesh->get_boundary_info().sideset_name(2) = "bottom";
951  mesh->get_boundary_info().sideset_name(3) = "right";
952  mesh->get_boundary_info().sideset_name(4) = "top";
953  portion_bottom.clear();
954  }
955  else
956  {
957  MeshTools::Modification::change_boundary_id(portion_two, 1, 5);
958  MeshTools::Modification::change_boundary_id(portion_two, 2, 1);
959  MeshTools::Modification::change_boundary_id(portion_two, 5, 2);
960  // 'top half'
961  mesh->prepare_for_use();
962  portion_two.prepare_for_use();
963  mesh->stitch_meshes(portion_two, 1, 1, TOLERANCE, true, /*verbose=*/false);
964  // 'bottom half'
965  ReplicatedMesh portion_bottom(*mesh);
966  MeshTools::Modification::rotate(portion_bottom, 180, 0, 0);
967  // 'full'
968  mesh->prepare_for_use();
969  portion_bottom.prepare_for_use();
970  mesh->stitch_meshes(portion_bottom, 2, 2, TOLERANCE, true, /*verbose=*/false);
971  MeshTools::Modification::change_boundary_id(*mesh, 3, 1);
972  mesh->get_boundary_info().sideset_name(1) = "outer";
973  portion_bottom.clear();
974  }
975  portion_two.clear();
976  }
977 
978  if (_portion != "top_half" && _portion != "right_half" && _portion != "left_half" &&
979  _portion != "bottom_half" && _portion != "full")
980  mesh->prepare_for_use();
981 
982  // Laplace smoothing
983  LaplaceMeshSmoother lms(*mesh);
984  lms.smooth(_smoothing_max_it);
985 
986  mesh->prepare_for_use();
987  return dynamic_pointer_cast<MeshBase>(mesh);
988 }
unsigned int _smoothing_max_it
Iteration number for Laplace smoothing.
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sin(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tan
std::unique_ptr< ReplicatedMesh > buildReplicatedMesh(unsigned int dim=libMesh::invalid_uint)
Build a replicated mesh.
MeshBase & mesh
bool _preserve_volumes
Volume preserving function is optional.
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
ADRealEigenVector< T, D, asd > sqrt(const ADRealEigenVector< T, D, asd > &)
std::vector< Real > _radii
Radii of concentric circles.
std::vector< unsigned int > _rings
Number of rings in each circle or in the enclosing square.
bool _has_outer_square
Adding the enclosing square is optional.
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template cos(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cos
MooseEnum _portion
Control of which portion of mesh will be developed.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
unsigned int _num_sectors
Number of sectors in one quadrant.
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template pow< 2 >(tan(_arg))+1.0) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(sqrt

◆ generateData()

void MeshGenerator::generateData ( )
protectedvirtualinherited

Generate the mesh data.

Reimplemented in AddMetaDataGenerator.

Definition at line 418 of file MeshGenerator.C.

Referenced by MeshGenerator::generateInternal().

419 {
420  mooseAssert(!hasGenerateData(), "Inconsistent flag");
421  mooseError("This MeshGenerator does not have a generateData() implementation.");
422 }
bool hasGenerateData() const
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.

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

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

◆ getCheckedPointerParam()

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

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

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

Definition at line 268 of file MooseBaseParameterInterface.h.

270 {
271  return parameters().getCheckedPointerParam<T>(name, error_string);
272 }
std::string name(const ElemQuality q)
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...
const InputParameters & parameters() const
Get the parameters of the object.

◆ getChildMeshGenerators()

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

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 129 of file MeshGenerator.h.

Referenced by MeshGenerator::isChildMeshGenerator().

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

◆ getDataFileName()

std::string DataFileInterface< MooseObject >::getDataFileName ( const std::string &  param) const
inherited

Returns the path of a data file for a given FileName type parameter, searching (in the following order)

  • relative to the input file directory
  • relative to the running binary (assuming the application is installed)
  • relative to all registered data file directories

Definition at line 24 of file DataFileInterface.C.

25 {
26  // The path from the parameters, which has not been modified because it is a DataFileName
27  const auto & value = _parent.template getParam<DataFileParameterType>(param);
28  if (value.empty())
29  _parent.paramInfo(param, "Data file name is empty");
30 
31  const std::filesystem::path value_path = std::filesystem::path(std::string(value));
32 
33  // If the file is absolute, we should reference that directly and don't need to add
34  // any info beacuse this is not ambiguous
35  if (value_path.is_absolute() && MooseUtils::checkFileReadable(value, false, false, false))
36  return value;
37 
38  // Look relative to the input file
39  const auto base = _parent.parameters().getParamFileBase(param);
40  const std::string relative_to_context = std::filesystem::absolute(base / value_path).c_str();
41  if (MooseUtils::checkFileReadable(relative_to_context, false, false, false))
42  {
43  _parent.paramInfo(param, "Data file '", value, "' found relative to the input file.");
44  return relative_to_context;
45  }
46 
47  // Isn't absolute and couldn't find relative to the input file, so search the data
48  return getDataFileNameByName(value, &param);
49 }
std::string getDataFileNameByName(const std::string &name, const std::string *param=nullptr) const
Returns the path of a data file for a given relative file path.
std::filesystem::path getParamFileBase(const std::string &param_name) const
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
bool checkFileReadable(const std::string &filename, bool check_line_endings=false, bool throw_on_unreadable=true, bool check_for_git_lfs_pointer=true)
Checks to see if a file is readable (exists and permissions)
Definition: MooseUtils.C:256
const InputParameters & parameters() const
Get the parameters of the object.
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 in...

◆ getDataFileNameByName()

std::string DataFileInterface< MooseObject >::getDataFileNameByName ( const std::string &  name,
const std::string *  param = nullptr 
) 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. The optional param pointer can be used to turn the mooseErrors this function emits into paramErrors

  • relative to the running binary (assuming the application is installed)
  • relative to all registered data file directories

Definition at line 53 of file DataFileInterface.C.

55 {
57  const auto share_dir = MooseUtils::pathjoin(Moose::getExecutablePath(), "..", "share");
58  if (MooseUtils::pathIsDirectory(share_dir))
59  {
60  const auto dirs = MooseUtils::listDir(share_dir, false);
61  for (const auto & data_dir : dirs)
62  {
63  const auto path = MooseUtils::pathjoin(data_dir, "data", relative_path);
64  if (MooseUtils::checkFileReadable(path, false, false, false))
65  {
66  if (param)
68  *param, "Data file '", path, "' found in an installed app distribution.");
69  else
70  mooseInfo("Data file '", path, "' found in an installed app distribution.");
71  return path;
72  }
73  }
74  }
75 
77  for (const auto & data_dir : Registry::getRegistry().getDataFilePaths())
78  {
79  const auto path = MooseUtils::pathjoin(data_dir, relative_path);
80  if (MooseUtils::checkFileReadable(path, false, false, false))
81  {
82  if (param)
83  _parent.paramInfo(*param, "Data file '", path, "' found in a source repository.");
84  else
85  mooseInfo("Data file '", path, "' found in a source repository.");
86  return path;
87  }
88  }
89 
90  mooseException(param ? _parent.parameters().inputLocation(*param) : _parent.name(),
91  ": Unable to find data file '",
92  relative_path,
93  "' anywhere");
94 }
static Registry & getRegistry()
Get the global Registry singleton.
Definition: Registry.C:21
std::string getExecutablePath()
This function returns the PATH of the running executable.
bool pathIsDirectory(const std::string &path)
Definition: MooseUtils.C:247
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
void mooseInfo(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
Definition: MooseError.h:329
bool checkFileReadable(const std::string &filename, bool check_line_endings=false, bool throw_on_unreadable=true, bool check_for_git_lfs_pointer=true)
Checks to see if a file is readable (exists and permissions)
Definition: MooseUtils.C:256
std::string inputLocation(const std::string &param) const
std::filesystem::path pathjoin(const std::filesystem::path &p)
Definition: MooseUtils.C:58
std::list< std::string > listDir(const std::string path, bool files_only=false)
Definition: MooseUtils.C:768
const InputParameters & parameters() const
Get the parameters of the object.
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 in...

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

167 {
168  const MeshGeneratorName * name = getMeshGeneratorNameFromParam(param_name, allow_invalid);
169  if (!name)
170  return _null_mesh;
171  return getMeshByName(*name);
172 }
std::unique_ptr< MeshBase > & getMeshByName(const MeshGeneratorName &mesh_generator_name)
Like getMesh(), but takes the name of another MeshGenerator directly.
std::unique_ptr< MeshBase > _null_mesh
A nullptr to use for when inputs aren&#39;t specified.
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
const MeshGeneratorName * getMeshGeneratorNameFromParam(const std::string &param_name, const bool allow_invalid) const
Helper for getting a MeshGeneratorName parameter.
Definition: MeshGenerator.C:88

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

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

182 {
183  checkGetMesh(mesh_generator_name, "");
184  if (isNullMeshName(mesh_generator_name))
185  return _null_mesh;
186 
187  _requested_mesh_generators.insert(mesh_generator_name);
188  auto & mesh = _app.getMeshGeneratorSystem().getMeshGeneratorOutput(mesh_generator_name);
189  _requested_meshes.emplace_back(mesh_generator_name, &mesh);
190  return mesh;
191 }
std::unique_ptr< MeshBase > & getMeshGeneratorOutput(const MeshGeneratorName &name)
Get a reference to a pointer that will be the output of the MeshGenerator named name.
MeshBase & mesh
std::unique_ptr< MeshBase > _null_mesh
A nullptr to use for when inputs aren&#39;t specified.
bool isNullMeshName(const MeshGeneratorName &name) const
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...
std::set< MeshGeneratorName > _requested_mesh_generators
The names of the MeshGenerators that were requested in the getMesh methods.
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
void checkGetMesh(const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const
Helper for performing error checking in the getMesh methods.
MeshGeneratorSystem & getMeshGeneratorSystem()
Gets the system that manages the MeshGenerators.
Definition: MooseApp.h:820

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

176 {
178 }
std::vector< std::unique_ptr< MeshBase > * > getMeshesByName(const std::vector< MeshGeneratorName > &mesh_generator_names)
Like getMeshByName(), but for multiple generators.
const std::vector< MeshGeneratorName > & getMeshGeneratorNamesFromParam(const std::string &param_name) const
Helper for getting a std::vector<MeshGeneratorName> parameter.

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

Referenced by MeshGenerator::getMeshes().

195 {
196  std::vector<std::unique_ptr<MeshBase> *> meshes;
197  for (const auto & name : mesh_generator_names)
198  meshes.push_back(&getMeshByName(name));
199  return meshes;
200 }
std::unique_ptr< MeshBase > & getMeshByName(const MeshGeneratorName &mesh_generator_name)
Like getMesh(), but takes the name of another MeshGenerator directly.
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57

◆ getMeshProperty() [1/2]

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

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

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

Definition at line 134 of file MeshMetaDataInterface.h.

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

◆ getMeshProperty() [2/2]

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

Definition at line 56 of file MeshMetaDataInterface.h.

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

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const
inlineinherited

◆ getParam() [1/2]

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

Retrieve a parameter for the object.

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

Definition at line 204 of file MooseBaseParameterInterface.h.

Referenced by CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), ADNodalKernel::ADNodalKernel(), ArrayParsedAux::ArrayParsedAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), PiecewiseTabularBase::buildFromJSON(), PhysicsBase::checkVectorParamsNoOverlap(), PhysicsBase::checkVectorParamsSameLength(), FEProblemBase::createTagSolutions(), AccumulateReporter::declareLateValues(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FVInterfaceKernel::FVInterfaceKernel(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), BlockDeletionGenerator::generate(), MeshExtruderGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), MooseApp::getCheckpointDirectories(), ExecutorInterface::getExecutor(), GhostingUserObject::GhostingUserObject(), TimeSequenceStepper::init(), IterationAdaptiveDT::init(), AdvancedOutput::init(), AttribThread::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), NestedDivision::NestedDivision(), ConsoleUtils::outputExecutionInformation(), ParsedAux::ParsedAux(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

205 {
206  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0), &_moose_base);
207 }
const MooseBase & _moose_base
The MooseBase object that inherits this class.
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
static const T & getParamHelper(const std::string &name, const InputParameters &pars, const T *the_type, const MooseBase *moose_base=nullptr)

◆ getParam() [2/2]

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

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

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

Definition at line 261 of file MooseBaseParameterInterface.h.

262 {
263  return _pars.get<T1, T2>(param1, param2);
264 }
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.
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

◆ getParentMeshGenerators()

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

Gets the MeshGenerators that are parents to this MeshGenerator.

Definition at line 122 of file MeshGenerator.h.

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

123  {
125  }
std::set< const MeshGenerator *, Comparator > _parent_mesh_generators
The MeshGenerators that are parents to this MeshGenerator.

◆ getRenamedParam()

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

Retrieve a renamed parameter for the object.

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

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

Definition at line 211 of file MooseBaseParameterInterface.h.

213 {
214  // this enables having a default on the new parameter but bypassing it with the old one
215  // Most important: accept new parameter
216  if (isParamSetByUser(new_name) && !isParamValid(old_name))
217  return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
218  // Second most: accept old parameter
219  else if (isParamValid(old_name) && !isParamSetByUser(new_name))
220  return InputParameters::getParamHelper(old_name, _pars, static_cast<T *>(0), &_moose_base);
221  // Third most: accept default for new parameter
222  else if (isParamValid(new_name) && !isParamValid(old_name))
223  return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
224  // Refuse: no default, no value passed
225  else if (!isParamValid(old_name) && !isParamValid(new_name))
226  mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
227  "' is being retrieved without being set.\n"
228  "Did you misspell it?");
229  // Refuse: both old and new parameters set by user
230  else
231  mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
232  "' may not be provided alongside former parameter '" + old_name + "'");
233 }
const MooseBase & _moose_base
The MooseBase object that inherits this class.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
bool isParamSetByUser(const std::string &nm) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
std::string blockFullpath() const
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
static const T & getParamHelper(const std::string &name, const InputParameters &pars, const T *the_type, const MooseBase *moose_base=nullptr)

◆ getRequestedMeshGenerators()

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

Definition at line 80 of file MeshGenerator.h.

81  {
83  }
std::set< MeshGeneratorName > _requested_mesh_generators
The names of the MeshGenerators that were requested in the getMesh methods.

◆ getRequestedMeshGeneratorsForSub()

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

Definition at line 88 of file MeshGenerator.h.

89  {
91  }
std::set< MeshGeneratorName > _requested_mesh_generators_for_sub
The names of the MeshGenerators that were requested in the declareMeshForSub methods.

◆ getSavedMeshName()

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

Return the name of the saved mesh.

Definition at line 412 of file MeshGenerator.C.

413 {
414  return _save_with_name;
415 }
const std::string & _save_with_name
A user-defined name to save the mesh.

◆ getSubMeshGenerators()

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

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 136 of file MeshGenerator.h.

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

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

83 {
84  return params.get<bool>("_has_generate_data");
85 }
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.

◆ hasGenerateData() [2/2]

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

Definition at line 185 of file MeshGenerator.h.

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

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

◆ hasMeshProperty() [1/4]

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

Definition at line 25 of file MeshMetaDataInterface.C.

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

27 {
28  return _meta_data_app.hasRestartableMetaData(meshPropertyName(data_name, prefix),
30 }
bool hasRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname) const
Definition: MooseApp.C:1852
static const RestartableDataMapName MESH_META_DATA
Definition: MooseApp.h:95
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
MooseApp & _meta_data_app
Reference to the application.

◆ hasMeshProperty() [2/4]

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

Definition at line 158 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [3/4]

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

Definition at line 74 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [4/4]

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

Definition at line 82 of file MeshMetaDataInterface.h.

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

◆ hasOutput()

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

Definition at line 406 of file MeshGenerator.C.

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

407 {
408  return getParam<bool>("output");
409 }

◆ hasSaveMesh()

bool MeshGenerator::hasSaveMesh ( ) const
inherited

Return whether or not to save the current mesh.

Definition at line 400 of file MeshGenerator.C.

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

401 {
402  return _save_with_name.size();
403 }
const std::string & _save_with_name
A user-defined name to save the mesh.

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

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder().

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

◆ isDataOnly()

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

Definition at line 190 of file MeshGenerator.h.

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

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

◆ isNullMeshName()

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

See declareNullMeshName().

Definition at line 165 of file MeshGenerator.h.

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

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

◆ isParamSetByUser()

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

◆ isParamValid()

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

Test if the supplied parameter is valid.

Parameters
nameThe name of the parameter to test

Definition at line 111 of file MooseBaseParameterInterface.h.

Referenced by CopyNodalVarsAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), CommonOutputAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionCG::addNonlinearVariables(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), GeneratedMesh::buildMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), PhysicsBase::checkParamsBothSetOrNotSet(), PhysicsBase::checkVectorParamsSameLength(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), CombinerGenerator::CombinerGenerator(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), Eigenvalue::Eigenvalue(), ElementExtremeFunctorValueTempl< is_ad >::ElementExtremeFunctorValueTempl(), ElementExtremeValue::ElementExtremeValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FieldSplitPreconditioner::FieldSplitPreconditioner(), FileOutput::FileOutput(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), ExtraNodesetGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), AddMetaDataGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), FileMeshGenerator::generate(), BlockDeletionGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainMeshGenerator::generate(), MeshExtruderGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBaseParameterInterface::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionScalarAux::initialSetup(), SolutionAux::initialSetup(), Console::initialSetup(), MooseParsedVectorFunction::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MatDiffusionBase< Real >::MatDiffusionBase(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< Real >::MooseVariableFV(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), NodalExtremeValue::NodalExtremeValue(), EigenExecutionerBase::normalizeSolution(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ParsedCurveGenerator::ParsedCurveGenerator(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PicardSolve::PicardSolve(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), MooseMesh::prepare(), MultiApp::readCommandLineArguments(), SolutionUserObject::readExodusII(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), MooseMesh::setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), Split::setup(), SideSetsGeneratorBase::setup(), SetupMeshAction::setupMesh(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideExtremeValue::SideExtremeValue(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObject::SolutionUserObject(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

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

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

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

◆ meshPropertyName() [1/2]

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

Definition at line 33 of file MeshMetaDataInterface.C.

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

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

◆ meshPropertyName() [2/2]

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

Definition at line 95 of file MeshMetaDataInterface.h.

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

◆ mooseDeprecated()

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

Definition at line 67 of file MooseBaseErrorInterface.h.

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

68  {
69  moose::internal::mooseDeprecatedStream(_console, false, true, std::forward<Args>(args)...);
70  }
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, Args &&... args)
Definition: MooseError.h:236
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.

◆ mooseError()

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

Emits an error prefixed with object name and type.

Definition at line 29 of file MooseBaseErrorInterface.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), SetupMeshCompleteAction::act(), AddVectorPostprocessorAction::act(), AutoCheckpointAction::act(), CheckIntegrityAction::act(), CreateExecutionerAction::act(), AddMeshGeneratorAction::act(), InitProblemAction::act(), CheckFVBCAction::act(), AddICAction::act(), AddFVICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), SetupTimeStepperAction::act(), SetupPredictorAction::act(), AddTimeStepperAction::act(), DeprecatedBlockAction::act(), SetAdaptivityOptionsAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::adaptMesh(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), FEProblemBase::addConstraint(), DistributedRectilinearMeshGenerator::addElement(), FEProblemBase::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFVInitialCondition(), ADDGKernel::ADDGKernel(), FEProblemBase::addInitialCondition(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addOutput(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DiracKernelBase::addPoint(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), FEProblemBase::addPostprocessor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), Action::addRelationshipManager(), FEProblemBase::addReporter(), AddVariableAction::addVariable(), FEProblemBase::addVectorPostprocessor(), SubProblem::addVectorTag(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), AdvectiveFluxAux::AdvectiveFluxAux(), MooseVariableBase::allDofIndices(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayParsedAux::ArrayParsedAux(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), AddPeriodicBCAction::autoTranslationBoundaries(), AuxKernelTempl< Real >::AuxKernelTempl(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), MooseMesh::buildLowerDMesh(), TiledMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildSideList(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), UserObjectInterface::castUserObject(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), SubProblem::checkBoundaryMatProps(), MooseMesh::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), MooseMesh::checkDuplicateSubdomainNames(), FEProblemBase::checkExceptionAndStopSolve(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), ExplicitTimeIntegrator::checkLinearConvergence(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), Sampler::checkReinitStatus(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::checkSiblingsTransferSupported(), MaterialBase::checkStatefulSanity(), FEProblemBase::checkUserObjects(), DomainUserObject::checkVariable(), MultiAppTransfer::checkVariable(), PhysicsBase::checkVectorParamsNoOverlap(), LibmeshPartitioner::clone(), MooseMesh::clone(), CombinerGenerator::CombinerGenerator(), ComparisonPostprocessor::comparisonIsTrue(), ElementSubdomainModifier::complementMovingBoundaryID(), ElementSubdomainModifier::complementMovingBoundaryName(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), FEProblemBase::computeBounds(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), InternalSideIntegralPostprocessor::computeFaceInfoIntegral(), SideIntegralPostprocessor::computeFaceInfoIntegral(), MooseVariableFieldBase::computeFaceValues(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), FVFluxKernel::computeJacobian(), NodalConstraint::computeJacobian(), FEProblemBase::computeJacobianTags(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), EigenProblem::computeMatricesTags(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), FVElementalKernel::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MaterialBase::computeProperties(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), NodalEqualValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), NodalEqualValueConstraint::computeQpResidual(), KernelValue::computeQpResidual(), InterfaceQpValueUserObject::computeRealValue(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FVFluxBC::computeResidual(), FVFluxKernel::computeResidual(), NodalConstraint::computeResidual(), FVFluxKernel::computeResidualAndJacobian(), ResidualObject::computeResidualAndJacobian(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualL2Norm(), 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(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), CoupledForceNodalKernel::CoupledForceNodalKernel(), MultiApp::createApp(), AddVariableAction::createInitialConditionAction(), Function::curl(), MooseVariableFV< Real >::curlPhi(), SidesetInfoVectorPostprocessor::dataHelper(), ReporterTransferInterface::declareClone(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), BicubicSplineFunction::derivative(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), FEProblemBase::determineNonlinearSystem(), DGKernel::DGKernel(), MeshDiagnosticsGenerator::diagnosticsLog(), DistributedPositions::DistributedPositions(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), MooseVariableFV< Real >::divPhi(), FunctorRelationshipManager::dofmap_reinit(), EigenProblem::doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementIntegerAux::ElementIntegerAux(), ElementQualityAux::ElementQualityAux(), ElementUOAux::ElementUOAux(), DistributedRectilinearMeshGenerator::elemId(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), MooseMesh::errorIfDistributedMesh(), SideIntegralPostprocessor::errorNoFaceInfo(), SideIntegralFunctorPostprocessorTempl< is_ad >::errorNoFaceInfo(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), RestartableDataReporter::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), NodalValueSampler::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorTransfer::execute(), ElementQualityChecker::execute(), PositionsFunctorValueSampler::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), GreaterThanLessThanPostprocessor::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), InterfaceQpUserObjectBase::execute(), LeastSquaresFit::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFitHistory::execute(), TimeExtremeValue::execute(), Eigenvalue::execute(), DomainUserObject::execute(), FEProblemBase::execute(), FEProblemBase::executeControls(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FileOutput::FileOutput(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), VerifyNodalUniqueID::finalize(), VerifyElementUniqueID::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), NearestPointAverage::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), Transfer::find_sys(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), MaterialOutputAction::functorMaterialOutputHelper(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVMassMatrix::FVMassMatrix(), FVMatAdvection::FVMatAdvection(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), GapValueAux::GapValueAux(), WorkBalance::gather(), FileMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ExtraNodesetGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SmoothMeshGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), BlockToMeshConverterGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), CoarsenBlockGenerator::generate(), CutMeshByPlaneGenerator::generate(), FlipSidesetGenerator::generate(), MeshRepairGenerator::generate(), SideSetsFromPointsGenerator::generate(), MeshDiagnosticsGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), StitchedMeshGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), SpiralAnnularMeshGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), RandomICBase::generateRandom(), GenericConstantMaterialTempl< is_ad >::GenericConstantMaterialTempl(), GenericConstantVectorMaterialTempl< is_ad >::GenericConstantVectorMaterialTempl(), GenericFunctionMaterialTempl< is_ad >::GenericFunctionMaterialTempl(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), DisplacedProblem::getActualFieldVariable(), FEProblemBase::getActualFieldVariable(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), MooseMesh::getAxisymmetricRadialCoord(), MooseMesh::getBlockConnectedBlocks(), VariableOldValueBounds::getBound(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), MooseMesh::getCoarseningMap(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PropertyReadFile::getData(), TransfiniteMeshGenerator::getDiscreteEdge(), FEProblemBase::getDistribution(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), GhostingUserObject::getElementalValue(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), PropertyReadFile::getElementData(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), MultiAppFieldTransfer::getEquationSystem(), MultiApp::getExecutioner(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), FEProblemBase::getFunction(), SubProblem::getFunctor(), MooseMesh::getGeneralAxisymmetricCoordAxis(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), BatchMaterial< Tuple, Output, Input >::getIndex(), DistributedRectilinearMeshGenerator::getIndices(), SolutionUserObject::getLocalVarIndex(), Material::getMaterialByName(), FEProblemBase::getMaterialData(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), DistributedRectilinearMeshGenerator::getNeighbors(), Times::getNextTime(), MooseMesh::getNodeBlockIds(), PropertyReadFile::getNodeData(), MooseMesh::getNodeList(), EigenProblem::getNonlinearEigenSystem(), FEProblemBase::getNonlinearSystem(), MooseMesh::getPairedBoundaryMapping(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), PlaneIDMeshGenerator::getPlaneID(), Positions::getPosition(), Positions::getPositions(), FEProblemBase::getPositionsObject(), Positions::getPositionsVector2D(), Positions::getPositionsVector3D(), Positions::getPositionsVector4D(), PostprocessorInterface::getPostprocessorValueByNameInternal(), Times::getPreviousTime(), InterfaceQpUserObjectBase::getQpValue(), MooseMesh::getRefinementMap(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), FEProblemBase::getSampler(), JSONFileReader::getScalar(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), InterfaceQpUserObjectBase::getSideAverageValue(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), MooseMesh::getSubdomainBoundaryIds(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), Times::getTimeAtIndex(), FEProblemBase::getTimeFromStateArg(), Transient::getTimeIntegratorName(), Times::getTimes(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorComponent::getValue(), NumRelationshipManagers::getValue(), Residual::getValue(), SideAverageValue::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), JSONFileReader::getVector(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingAux::GhostingAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), Function::gradient(), FEProblemBase::handleException(), Terminator::handleMessage(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), ExplicitTimeIntegrator::init(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Transient::init(), AddAuxVariableAction::init(), Eigenvalue::init(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), MultiApp::init(), FEProblemBase::initialAdaptMesh(), NestedDivision::initialize(), DistributedPositions::initialize(), ReporterPositions::initialize(), TransformedPositions::initialize(), FunctorPositions::initialize(), ReporterTimes::initialize(), ElementGroupCentroidPositions::initialize(), FunctorTimes::initialize(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), PiecewiseLinearBase::initialSetup(), ReferenceResidualProblem::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), SolutionScalarAux::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), SolutionAux::initialSetup(), NodalVariableValue::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), Exodus::initialSetup(), CSV::initialSetup(), MooseParsedFunction::initialSetup(), SolutionUserObject::initialSetup(), FEProblemBase::initialSetup(), SubProblem::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Function::integral(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MultiAppGeneralFieldTransfer::locatePointReceivers(), LowerBoundNodalKernel::LowerBoundNodalKernel(), MooseVariableFV< Real >::lowerDError(), PNGOutput::makePNG(), ReporterPointMarker::markerSetup(), MassMatrix::MassMatrix(), Material::Material(), MaterialOutputAction::materialOutputHelper(), MaterialRealTensorValueAux::MaterialRealTensorValueAux(), MaterialRealVectorValueAuxTempl< is_ad >::MaterialRealVectorValueAuxTempl(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), SubProblem::meshChanged(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), MooseVariableBase::MooseVariableBase(), MooseVariableConstMonomial::MooseVariableConstMonomial(), MoveNodeGenerator::MoveNodeGenerator(), ElementSubdomainModifier::movingBoundaryID(), ElementSubdomainModifier::movingBoundaryName(), MultiApp::MultiApp(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), NearestNodeValueAux::NearestNodeValueAux(), FEProblemBase::needsPreviousNewtonIteration(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), MooseVariableFV< Real >::nodalDofIndex(), MooseVariableFV< Real >::nodalDofIndexNeighbor(), MooseVariableFV< Real >::nodalMatrixTagValue(), NodalPatchRecoveryBase::nodalPatchRecovery(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalScalarKernel::NodalScalarKernel(), MooseVariableFV< Real >::nodalValueArray(), MooseVariableFV< Real >::nodalValueOldArray(), MooseVariableFV< Real >::nodalValueOlderArray(), NodalVariableValue::NodalVariableValue(), MooseVariableFV< Real >::nodalVectorTagValue(), DistributedRectilinearMeshGenerator::nodeId(), PhysicsBase::nonlinearVariableExists(), MooseVariableFV< Real >::numberOfDofsNeighbor(), NumDOFs::NumDOFs(), NumFailedTimeSteps::NumFailedTimeSteps(), DistributedRectilinearMeshGenerator::numNeighbors(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), XDA::output(), SolutionHistory::output(), Exodus::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), Exodus::outputSetup(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), DistributedRectilinearMeshGenerator::paritionSquarely(), PiecewiseBilinear::parse(), ParsedAux::ParsedAux(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), MultiAppConservativeTransfer::performAdjustment(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), MooseVariableFV< Real >::phiLowerSize(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), Executioner::picardSolve(), PIDTransientControl::PIDTransientControl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), PiecewiseTabularBase::PiecewiseTabularBase(), CutMeshByPlaneGenerator::pointPairPlaneInterception(), SolutionUserObject::pointValueGradientWrapper(), SolutionUserObject::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(), Predictor::Predictor(), Transient::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), FixedPointSolve::printFixedPointConvergenceReason(), PseudoTimestep::PseudoTimestep(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObject::readExodusII(), SolutionUserObject::readXda(), CoarsenBlockGenerator::recursiveCoarsen(), FunctorRelationshipManager::redistribute(), ReferenceResidualProblem::ReferenceResidualProblem(), Sampler::reinit(), EqualValueEmbeddedConstraint::reinitConstraint(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), PiecewiseMultiInterpolation::sample(), ScalarComponentIC::ScalarComponentIC(), MortarScalarBase::scalarVariable(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), BicubicSplineFunction::secondDerivative(), MooseVariableFV< Real >::secondPhi(), MooseVariableFV< Real >::secondPhiFace(), MooseVariableFV< Real >::secondPhiFaceNeighbor(), MooseVariableFV< Real >::secondPhiNeighbor(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), FEProblemBase::setCoupling(), PiecewiseBase::setData(), FileOutput::setFileBaseInternal(), MooseMesh::setGeneralAxisymmetricCoordAxes(), FEProblemSolve::setInnerSolve(), MeshGenerator::setMeshProperty(), FVPointValueConstraint::setMyElem(), FEProblemBase::setNonlocalCouplingMatrix(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), Split::setup(), TransientMultiApp::setupApp(), SetupMeshAction::setupMesh(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), TimePeriodBase::setupTimes(), SideAdvectiveFluxIntegralTempl< is_ad >::SideAdvectiveFluxIntegralTempl(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObject::SolutionUserObject(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialPoints(), NearestPointAverage::spatialValue(), NearestPointIntegralVariablePostprocessor::spatialValue(), MeshDivisionFunctorReductionVectorPostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), StitchedMesh::StitchedMesh(), MultiAppGeometricInterpolationTransfer::subdomainIDsNode(), Constraint::subdomainSetup(), GeneralUserObject::subdomainSetup(), NodalUserObject::subdomainSetup(), MaterialBase::subdomainSetup(), FEProblemBase::swapBackMaterialsNeighbor(), Console::systemInfoFlags(), Terminator::Terminator(), CutMeshByPlaneGenerator::tet4ElemCutter(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), Function::timeDerivative(), TimeExtremeValue::TimeExtremeValue(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriodBase::TimePeriodBase(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransformedPositions::TransformedPositions(), FEProblemBase::trustUserCouplingMatrix(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), Positions::unrollMultiDPositions(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), Checkpoint::updateCheckpointFiles(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObject::updateExodusBracketingTimeIndices(), FEProblemBase::updateMaxQps(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointAverage::userObjectValue(), NearestPointIntegralVariablePostprocessor::userObjectValue(), BoundingBoxIC::value(), PiecewiseConstantFromCSV::value(), IntegralPreservingFunctionIC::value(), Axisymmetric2D3DSolutionFunction::value(), Function::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), 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(), VTKOutput::VTKOutput(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

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

◆ mooseErrorNonPrefixed()

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

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

Definition at line 40 of file MooseBaseErrorInterface.h.

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

◆ mooseInfo()

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

◆ mooseWarning()

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

Emits a warning prefixed with object name and type.

Definition at line 51 of file MooseBaseErrorInterface.h.

Referenced by AddKernelAction::act(), SetupMeshAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), BoundsBase::BoundsBase(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), PhysicsBase::checkRequiredTasks(), OversampleOutput::cloneMesh(), GapValueAux::computeValue(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), Positions::getNearestPositionIndex(), LineValueSampler::getValue(), Terminator::handleMessage(), ElementGroupCentroidPositions::initialize(), CartesianGridDivision::initialize(), SphericalGridDivision::initialize(), CylindricalGridDivision::initialize(), ReferenceResidualProblem::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

52  {
54  _console, _moose_base.errorPrefix("warning"), std::forward<Args>(args)...);
55  }
std::string errorPrefix(const std::string &error_type) const
Definition: MooseBase.C:43
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:181
const MooseBase & _moose_base
The MooseBase class deriving from this interface.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.

◆ mooseWarningNonPrefixed()

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

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

Definition at line 61 of file MooseBaseErrorInterface.h.

62  {
63  moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
64  }
void mooseWarningStream(S &oss, Args &&... args)
Definition: MooseError.h:181
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.

◆ name()

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

Get the name of the class.

Returns
The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

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

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

◆ paramError()

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

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

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

Definition at line 237 of file MooseBaseParameterInterface.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), ADDGKernel::ADDGKernel(), DiffusionCG::addNonlinearVariables(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADNodalKernel::ADNodalKernel(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayVacuumBC::ArrayVacuumBC(), AuxKernelTempl< Real >::AuxKernelTempl(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), PiecewiseTabularBase::buildFromFile(), CartesianGridDivision::CartesianGridDivision(), UserObjectInterface::castUserObject(), checkComponent(), MeshGenerator::checkGetMesh(), PostprocessorInterface::checkParam(), PhysicsBase::checkParamsBothSetOrNotSet(), Checkpoint::Checkpoint(), PhysicsBase::checkSecondParamSetOnlyIfFirstOneTrue(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), PhysicsBase::checkVectorParamsSameLength(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinerGenerator::CombinerGenerator(), CompositionDT::CompositionDT(), ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementExtremeFunctorValueTempl< is_ad >::ElementExtremeFunctorValueTempl(), ElementExtremeValue::ElementExtremeValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), ReporterPointSource::errorCheck(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), FEProblemSolve::FEProblemSolve(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), ReporterPointSource::fillPoint(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicator::finalize(), FixedPointSolve::FixedPointSolve(), ForcingFunctionAux::ForcingFunctionAux(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), BoundaryDeletionGenerator::generate(), ElementsToTetrahedronsConverter::generate(), ExtraNodesetGenerator::generate(), FillBetweenSidesetsGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), AddMetaDataGenerator::generate(), FillBetweenCurvesGenerator::generate(), BlockToMeshConverterGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), CutMeshByPlaneGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainMeshGenerator::generate(), CoarsenBlockGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), StackGenerator::generate(), StitchedMeshGenerator::generate(), AdvancedExtruderGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), PropertyReadFile::getData(), Sampler::getGlobalSamples(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), Sampler::getNextLocalRow(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), HFEMDirichletBC::HFEMDirichletBC(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), MultiAppCloneReporterTransfer::initialSetup(), ReferenceResidualProblem::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MoosePreconditioner::MoosePreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), PatchMeshGenerator::PatchMeshGenerator(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshGenerator::PolyLineMeshGenerator(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObject::readXda(), ReferenceResidualProblem::ReferenceResidualProblem(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setPartitioner(), SideSetsGeneratorBase::setup(), TimeSequenceStepperBase::setupSequence(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), SymmetryTransformGenerator::SymmetryTransformGenerator(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), UserObject::UserObject(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYMeshLineCutter::XYMeshLineCutter().

238 {
239  Moose::show_trace = false;
240  _moose_base.callMooseError(paramErrorMsg(param, std::forward<Args>(args)...),
241  /* with_prefix = */ false);
242  Moose::show_trace = true;
243 }
bool show_trace
Set to true (the default) to print the stack trace with error and warning messages - false to omit it...
Definition: Moose.C:642
const MooseBase & _moose_base
The MooseBase object that inherits this class.
std::string paramErrorMsg(const std::string &param, Args... args) const
void callMooseError(std::string msg, const bool with_prefix) const
Calls moose error with the message msg.
Definition: MooseBase.C:33

◆ parameters()

const InputParameters& MooseBaseParameterInterface::parameters ( ) const
inlineinherited

Get the parameters of the object.

Returns
The parameters of the object

Definition at line 62 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), assemble_l2(), Moose::assemble_matrix(), PhysicsBase::assertParamDefined(), Action::associateWithParameter(), AuxKernelTempl< Real >::AuxKernelTempl(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), UserObjectInterface::castUserObject(), PostprocessorInterface::checkParam(), PhysicsBase::checkSecondParamSetOnlyIfFirstOneTrue(), OversampleOutput::cloneMesh(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Executor::Executor(), Exodus::Exodus(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainMeshGenerator::generate(), MooseBaseParameterInterface::getCheckedPointerParam(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), MooseObject::MooseObject(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), OverlayMeshGenerator::OverlayMeshGenerator(), PatchMeshGenerator::PatchMeshGenerator(), PenetrationAux::PenetrationAux(), PicardSolve::PicardSolve(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), InputParameterWarehouse::removeInputParameters(), OutputWarehouse::resetFileBase(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), SideSetsGeneratorBase::setup(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SteffensenSolve::SteffensenSolve(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), Transient::Transient(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

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

◆ paramInfo()

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

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

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

Definition at line 254 of file MooseBaseParameterInterface.h.

Referenced by TransientMultiApp::TransientMultiApp().

255 {
256  mooseInfo(paramErrorMsg(param, std::forward<Args>(args)...));
257 }
void mooseInfo(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
Definition: MooseError.h:329
std::string paramErrorMsg(const std::string &param, Args... args) const

◆ paramWarning()

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

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

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

Definition at line 247 of file MooseBaseParameterInterface.h.

Referenced by MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), and MooseMesh::MooseMesh().

248 {
249  mooseWarning(paramErrorMsg(param, std::forward<Args>(args)...));
250 }
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:296
std::string paramErrorMsg(const std::string &param, Args... args) const

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

Referenced by AddMetaDataGenerator::validParams().

77 {
78  params.set<bool>("_has_generate_data") = true;
79 }
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.

◆ setMeshProperty() [1/2]

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

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

Definition at line 485 of file MeshGenerator.h.

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

◆ setMeshProperty() [2/2]

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

Definition at line 221 of file MeshGenerator.h.

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

◆ type()

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

Get the type of this class.

Returns
the name of the type of this class

Definition at line 51 of file MooseBase.h.

Referenced by CreateProblemDefaultAction::act(), SetupDebugAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), FEProblemBase::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addObject(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addTimeIntegrator(), MooseServer::addValuesToList(), DisplacedProblem::addVectorTag(), SubProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), PhysicsBase::assertParamDefined(), AuxKernelTempl< Real >::AuxKernelTempl(), FEProblemBase::backupMultiApps(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildPRefinementAndCoarseningMaps(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PhysicsBase::checkRequiredTasks(), FEProblemBase::computeAuxiliaryKernels(), 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(), InterfaceReaction::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), DGDiffusion::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), HFEMTestJump::computeQpOffDiagJacobian(), HFEMTrialJump::computeQpOffDiagJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), ArrayHFEMDiffusion::computeQpResidual(), DGConvection::computeQpResidual(), HFEMDiffusion::computeQpResidual(), ScalarKernel::computeQpResidual(), InterfaceDiffusion::computeQpResidual(), ADDGAdvection::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), InterfaceReaction::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), ADDGDiffusion::computeQpResidual(), DGDiffusion::computeQpResidual(), HFEMTrialJump::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), HFEMTestJump::computeQpResidual(), EqualValueEmbeddedConstraint::computeQpResidual(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), BatchMaterial< Tuple, Output, Input >::construct(), DisplacedProblem::createQRules(), FEProblemBase::createQRules(), MooseApp::createRecoverablePerfGraph(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MooseBase::errorPrefix(), AB2PredictorCorrector::estimateTimeError(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), SubdomainPerElementGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateInternal(), MultiAppTransfer::getAppInfo(), TransfiniteMeshGenerator::getEdge(), ElementGenerator::getElemType(), MooseServer::getInputLookupDefinitionNodes(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), MaterialOutputAction::getParams(), ReporterData::getReporterInfo(), Transient::getTimeIntegratorName(), FEProblemBase::getTransfers(), DisplacedProblem::getVectorTags(), SubProblem::getVectorTags(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), AdvancedOutput::initAvailableLists(), FunctorPositions::initialize(), FunctorTimes::initialize(), MultiAppConservativeTransfer::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MooseObject::MooseObject(), DisplacedProblem::numVectorTags(), SubProblem::numVectorTags(), Console::output(), AdvancedOutput::output(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), ProjectedStatefulMaterialStorageAction::processProperty(), MooseApp::recursivelyCreateExecutors(), SolutionInvalidInterface::registerInvalidSolutionInternal(), FEProblemBase::restoreMultiApps(), MeshRepairGenerator::separateSubdomainsByElementType(), FEProblemBase::setCoupling(), MooseApp::setupOptions(), MooseBase::typeAndName(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), UserObjectInterface::userObjectType(), and AdvancedOutput::wantOutput().

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

◆ typeAndName()

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

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

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

Definition at line 27 of file MooseBase.C.

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

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

◆ uniqueName()

MooseObjectName MooseBaseParameterInterface::uniqueName ( ) const
inlineinherited

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

Definition at line 67 of file MooseBaseParameterInterface.h.

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

68  {
69  return MooseObjectName(_pars.get<std::string>("_unique_name"));
70  }
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.
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
A class for storing the names of MooseObject by tag and object name.

◆ uniqueParameterName()

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

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

Definition at line 52 of file MooseBaseParameterInterface.h.

53  {
55  _pars.get<std::string>("_moose_base"), _moose_base.name(), parameter_name);
56  }
const MooseBase & _moose_base
The MooseBase object that inherits this class.
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.
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
A class for storing an input parameter name.

◆ validParams()

InputParameters ConcentricCircleMeshGenerator::validParams ( )
static

Definition at line 26 of file ConcentricCircleMeshGenerator.C.

27 {
29  MooseEnum portion(
30  "full top_right top_left bottom_left bottom_right right_half left_half top_half bottom_half",
31  "full");
32  params.addRequiredParam<unsigned int>("num_sectors",
33  "num_sectors % 2 = 0, num_sectors > 0"
34  "Number of azimuthal sectors in each quadrant"
35  "'num_sectors' must be an even number.");
36  params.addRequiredParam<std::vector<Real>>("radii", "Radii of major concentric circles");
37  params.addRequiredParam<std::vector<unsigned int>>(
38  "rings", "Number of rings in each circle or in the enclosing square");
39  params.addRequiredParam<bool>(
40  "has_outer_square",
41  "It determines if meshes for a outer square are added to concentric circle meshes.");
42  params.addRangeCheckedParam<Real>(
43  "pitch",
44  0.0,
45  "pitch>=0.0",
46  "The enclosing square can be added to the completed concentric circle mesh."
47  "Elements are quad meshes.");
48  params.addParam<MooseEnum>("portion", portion, "Control of which part of mesh is created");
49  params.addRequiredParam<bool>(
50  "preserve_volumes", "Volume of concentric circles can be preserved using this function.");
51  params.addParam<unsigned int>("smoothing_max_it", 1, "Number of Laplacian smoothing iterations");
52  params.addClassDescription(
53  "This ConcentricCircleMeshGenerator source code is to generate concentric "
54  "circle meshes.");
55 
56  return params;
57 }
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
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...
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:31
static InputParameters validParams()
Definition: MeshGenerator.C:23
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
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...
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an option parameter and a documentation string to the InputParameters object...
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)

Member Data Documentation

◆ _action_factory

ActionFactory& MooseBaseParameterInterface::_action_factory
protectedinherited

◆ _app

MooseApp& MooseBase::_app
protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

◆ _console

const ConsoleStream ConsoleStreamInterface::_console
inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

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

◆ _enabled

const bool& MooseObject::_enabled
protectedinherited

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

Definition at line 53 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _factory

Factory& MooseBaseParameterInterface::_factory
protectedinherited

◆ _has_outer_square

bool ConcentricCircleMeshGenerator::_has_outer_square
protected

Adding the enclosing square is optional.

Definition at line 38 of file ConcentricCircleMeshGenerator.h.

Referenced by ConcentricCircleMeshGenerator(), and generate().

◆ _mesh

MooseMesh* const MeshGenerator::_mesh
protectedinherited

◆ _name

const std::string MooseBase::_name
protectedinherited

The name of this class.

Definition at line 90 of file MooseBase.h.

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

◆ _num_sectors

unsigned int ConcentricCircleMeshGenerator::_num_sectors
protected

Number of sectors in one quadrant.

Definition at line 29 of file ConcentricCircleMeshGenerator.h.

Referenced by ConcentricCircleMeshGenerator(), and generate().

◆ _pars

const InputParameters& MooseBaseParameterInterface::_pars
protectedinherited

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

Definition at line 162 of file MooseBaseParameterInterface.h.

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

◆ _pitch

Real ConcentricCircleMeshGenerator::_pitch
protected

Definition at line 39 of file ConcentricCircleMeshGenerator.h.

Referenced by ConcentricCircleMeshGenerator(), and generate().

◆ _portion

MooseEnum ConcentricCircleMeshGenerator::_portion
protected

Control of which portion of mesh will be developed.

Definition at line 48 of file ConcentricCircleMeshGenerator.h.

Referenced by generate().

◆ _preserve_volumes

bool ConcentricCircleMeshGenerator::_preserve_volumes
protected

Volume preserving function is optional.

Definition at line 42 of file ConcentricCircleMeshGenerator.h.

Referenced by generate().

◆ _radii

std::vector<Real> ConcentricCircleMeshGenerator::_radii
protected

Radii of concentric circles.

Definition at line 32 of file ConcentricCircleMeshGenerator.h.

Referenced by ConcentricCircleMeshGenerator(), and generate().

◆ _rings

std::vector<unsigned int> ConcentricCircleMeshGenerator::_rings
protected

Number of rings in each circle or in the enclosing square.

Definition at line 35 of file ConcentricCircleMeshGenerator.h.

Referenced by ConcentricCircleMeshGenerator(), and generate().

◆ _smoothing_max_it

unsigned int ConcentricCircleMeshGenerator::_smoothing_max_it
protected

Iteration number for Laplace smoothing.

Definition at line 45 of file ConcentricCircleMeshGenerator.h.

Referenced by generate().

◆ _type

const std::string MooseBase::_type
protectedinherited

◆ data_only_param

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

The name of the private parameter for setting data only.

Definition at line 62 of file MeshGenerator.h.

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

◆ NAME

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

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

Definition at line 33 of file MeshMetaDataInterface.h.

◆ SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"
staticinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().


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