MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to address this in their environment if C++17 compatibility isn't found. More...
Namespaces | |
FV | |
Mortar | |
PetscSupport | |
SlepcSupport | |
Classes | |
struct | _enumerate_iterator |
struct | _enumerate_range |
struct | _enumerate_struct |
struct | ADType |
struct | ADType< ADRankFourTensor > |
struct | ADType< ADRankThreeTensor > |
struct | ADType< ADRankTwoTensor > |
struct | ADType< ADReal > |
struct | ADType< ADSymmetricRankFourTensor > |
struct | ADType< ADSymmetricRankTwoTensor > |
struct | ADType< ADVariableGradient > |
struct | ADType< ADVariableSecond > |
struct | ADType< ADVariableValue > |
struct | ADType< ChainedADReal > |
struct | ADType< ChainedReal > |
struct | ADType< RankFourTensor > |
struct | ADType< RankThreeTensor > |
struct | ADType< RankTwoTensor > |
struct | ADType< Real > |
struct | ADType< RealEigenVector > |
struct | ADType< SymmetricRankFourTensor > |
struct | ADType< SymmetricRankTwoTensor > |
struct | ADType< VariableGradient > |
struct | ADType< VariableSecond > |
struct | ADType< VariableValue > |
struct | ADType< W< ADReal > > |
struct | ADType< W< Real > > |
class | ADWrapperFunctor |
Wraps non-AD functors such that they can be used in objects that have requested the functor as AD. More... | |
class | ArrayComponentFunctor |
This is essentially a forwarding functor that forwards the spatial and temporal evaluation arguments to the parent array functor and then returns the result indexed at a given component. More... | |
class | Builder |
Parses MOOSE input using HIT/WASP. More... | |
class | ConstantFunctor |
Class template for creating constant functors. More... | |
struct | DOFType |
struct | DOFType< RealVectorValue > |
struct | ElemArg |
A structure that is used to evaluate Moose functors logically at an element/cell center. More... | |
struct | ElemPointArg |
A structure that is used to evaluate Moose functors at an arbitrary physical point contained within an element. More... | |
struct | ElemQpArg |
Argument for requesting functor evaluation at a quadrature point location in an element. More... | |
struct | ElemSideQpArg |
Argument for requesting functor evaluation at quadrature point locations on an element side. More... | |
struct | FaceArg |
A structure defining a "face" evaluation calling argument for Moose functors. More... | |
class | FunctorAbstract |
Abstract base class that can be used to hold collections of functors. More... | |
class | FunctorBase |
Base class template for functor objects. More... | |
class | FunctorEnvelope |
This is a wrapper that forwards calls to the implementation, which can be switched out at any time without disturbing references to FunctorBase. More... | |
class | FunctorEnvelopeBase |
A non-templated base class for functors that allow an owner object to hold different class template instantiations of Functor in a single container. More... | |
struct | FunctorGradientEvaluationKind |
This structure takes an evaluation kind as a template argument and defines a constant expression indicating the associated gradient kind. More... | |
struct | FunctorGradientEvaluationKind< FunctorEvaluationKind::Dot > |
The gradient kind associated with a time derivative is the gradient of the time derivative. More... | |
struct | FunctorGradientEvaluationKind< FunctorEvaluationKind::Value > |
The gradient kind associated with a value is simply the gradient. More... | |
struct | FunctorReturnType |
A structure that defines the return type of a functor based on the type of the functor and the requested evaluation kind, e.g. More... | |
struct | FunctorReturnType< T, FunctorEvaluationKind::Dot > |
The return type of a time derivative evaluation is the same as the value type. More... | |
struct | FunctorReturnType< T, FunctorEvaluationKind::GradDot > |
The return type of a gradient of time derivative evaluation is the same as the gradient type. More... | |
struct | FunctorReturnType< T, FunctorEvaluationKind::Gradient > |
The return type of a gradient evaluation is the rank increment of a value return type. More... | |
struct | FunctorReturnType< T, FunctorEvaluationKind::Value > |
The return type for a value evaluation is just the type of the functor. More... | |
struct | indirect_comparator |
class | LibtorchArtificialNeuralNet |
class | LibtorchArtificialNeuralNetTrainer |
Templated class which is responsible for training LibtorchArtificialNeuralNets. More... | |
class | LibtorchDataset |
This class is a wrapper around a libtorch dataset which can be used by the data loaders in the neural net training process. More... | |
class | LibtorchNeuralNetBase |
This base class is meant to gather the functions and members common in every neural network based on Libtorch. More... | |
class | LibtorchTorchScriptNeuralNet |
struct | LibtorchTrainingOptions |
A struct containing necessary information for training neural networks. More... | |
struct | NodeArg |
class | NullFunctor |
A functor that serves as a placeholder during the simulation setup phase if a functor consumer requests a functor that has not yet been constructed. More... | |
class | PassKey |
class | RawValueFunctor |
class | ScopedCommSwapper |
struct | SerialAccess |
Serial access requires object data to be stored contiguously. More... | |
class | SerialAccessRange |
struct | SerialAccessValueTypeHelper |
Value type helper (necessary for any type that does not have a value_type member or where value_type doesn't have a suitable meaning (ADReal)). More... | |
struct | SerialAccessValueTypeHelper< ADReal > |
struct | SerialAccessValueTypeHelper< Real > |
struct | ShapeType |
struct | ShapeType< Eigen::Matrix< Real, Eigen::Dynamic, 1 > > |
struct | StateArg |
State argument for evaluating functors. More... | |
struct | TypeList |
Helper structure to hold a list of types. More... | |
class | UnusedWalker |
class | VectorComponentFunctor |
This is essentially a forwarding functor that forwards the spatial and temporal evaluation arguments to the parent vector functor and then returns the result indexed at a given component. More... | |
class | VectorCompositeFunctor |
A functor that returns a vector composed of its component functor evaluations. More... | |
class | WebServerControlTypeRegistry |
A static registry used to register and build values of different types for the WebServerControl. More... | |
Typedefs | |
template<typename T > | |
using | Functor = FunctorEnvelope< T > |
template<typename T , bool is_ad> | |
using | GenericType = typename std::conditional< is_ad, typename ADType< T >::type, T >::type |
typedef std::function< void(const InputParameters &, InputParameters &)> | RelationshipManagerInputParameterCallback |
The type for the callback to set RelationshipManager parameters. More... | |
Functions | |
InputParameters | commonAdaptivityParams () |
bool | colorConsole () |
Returns whether Console coloring is turned on (default: true). More... | |
bool | setColorConsole (bool use_color, bool force=false) |
Turns color escape sequences on/off for info written to stdout. More... | |
void | registerAll (Factory &f, ActionFactory &af, Syntax &s) |
Register objects that are in MOOSE. More... | |
void | registerObjects (Factory &factory) |
void | registerObjects (Factory &factory, const std::set< std::string > &obj_labels) |
void | addActionTypes (Syntax &syntax) |
void | registerActions (Syntax &syntax, ActionFactory &action_factory) |
Multiple Action class can be associated with a single input file section, in which case all associated Actions will be created and "acted" on when the associated input file section is seen. More... | |
void | registerActions (Syntax &syntax, ActionFactory &action_factory, const std::set< std::string > &obj_labels) |
void | associateSyntax (Syntax &syntax, ActionFactory &action_factory) |
void | setSolverDefaults (FEProblemBase &problem) |
MPI_Comm | swapLibMeshComm (MPI_Comm new_comm) |
Swap the libMesh MPI communicator out for ours. More... | |
StateArg | currentState () |
StateArg | oldState () |
StateArg | previousNonlinearState () |
std::shared_ptr< MooseApp > | createMooseApp (const std::string &default_app_name, int argc, char *argv[]) |
Create a MooseApp from command-line arguments. More... | |
void | addMainCommandLineParams (InputParameters ¶ms) |
Adds the command line parameters needed from within main , which will also need to be added to MooseApp so that they show up in –help. More... | |
template<typename DefaultAppType > | |
void | main (int argc, char *argv[]) |
Initialize, create and run a MooseApp. More... | |
void | findContactPoint (PenetrationInfo &p_info, FEBase *fe_elem, FEBase *fe_side, FEType &fe_side_type, const Point &secondary_point, bool start_with_centroid, const Real tangential_tolerance, bool &contact_point_on_side) |
Finds the closest point (called the contact point) on the primary_elem on side "side" to the secondary_point. More... | |
void | restrictPointToFace (Point &p, const Elem *side, std::vector< const Node *> &off_edge_nodes) |
void | to_json (nlohmann::json &json, const Moose::LibtorchArtificialNeuralNet *const &network) |
void | initial_condition (EquationSystems &es, const std::string &system_name) |
bool | globalADIndexing () |
Whether we are using global AD indexing. More... | |
std::size_t | adOffset (unsigned int var_num, std::size_t max_dofs_per_elem, ElementType element_type=ElementType::Element, unsigned int num_vars_in_system=0) |
Helper function for computing automatic differentiation offset. More... | |
std::size_t | adOffset (unsigned int var_num, std::size_t max_dofs_per_elem, DGJacobianType dg_jacobian_type, unsigned int num_vars_in_system=0) |
std::unordered_map< dof_id_type, Real > | globalDofIndexToDerivative (const ADReal &ad_real, const SystemBase &sys, ElementType elem_type=ElementType::Element, THREAD_ID tid=0) |
Generate a map from global dof index to derivative value. More... | |
template<typename T > | |
auto | globalDofIndexToDerivative (const T &ad_real_container, const SystemBase &sys, ElementType elem_type=ElementType::Element, THREAD_ID tid=0) -> std::vector< std::unordered_map< dof_id_type, typename std::enable_if< std::is_same< ADReal, typename T::value_type >::value, Real >::type >> |
Generate a map from global dof index to derivative value for a (probably quadrature-point-based) container like a material property or a variable value. More... | |
bool | doDerivatives (const SubProblem &subproblem, const SystemBase &sys) |
template<typename T > | |
T | stringToEnum (const std::string &s) |
template<> | |
QuadratureType | stringToEnum< QuadratureType > (const std::string &s) |
template<> | |
Order | stringToEnum< Order > (const std::string &s) |
template<> | |
CoordinateSystemType | stringToEnum< CoordinateSystemType > (const std::string &s) |
template<> | |
SolveType | stringToEnum< SolveType > (const std::string &s) |
template<> | |
LineSearchType | stringToEnum< LineSearchType > (const std::string &s) |
template<> | |
TimeIntegratorType | stringToEnum< TimeIntegratorType > (const std::string &s) |
template<> | |
RelationshipManagerType | stringToEnum< RelationshipManagerType > (const std::string &s) |
template<typename T > | |
std::vector< T > | vectorStringsToEnum (const MultiMooseEnum &v) |
template<typename T > | |
std::string | stringify (const T &t) |
conversion to string More... | |
std::string | stringify (bool v) |
std::string | stringify (int v) |
std::string | stringify (long v) |
std::string | stringify (long long v) |
std::string | stringify (unsigned int v) |
std::string | stringify (unsigned long v) |
std::string | stringify (unsigned long long v) |
std::string | stringify (const SolveType &t) |
Convert solve type into human readable string. More... | |
std::string | stringify (const EigenSolveType &t) |
Convert eigen solve type into human readable string. More... | |
std::string | stringify (const VarFieldType &t) |
Convert variable field type into human readable string. More... | |
std::string | stringify (const std::string &s) |
Add no-op stringify if the argument already is a string (must use overloading) More... | |
std::string | stringify (FEFamily f) |
Convert FEType from libMesh into string. More... | |
std::string | stringify (SolutionIterationType t) |
Convert SolutionIterationType into string. More... | |
std::string | stringify (ElementType t) |
Convert ElementType into string. More... | |
std::string | stringify (libMesh::ElemType t) |
Convert the libmesh ElemType into string. More... | |
template<typename T , typename U > | |
std::string | stringify (const std::pair< T, U > &p, const std::string &delim=":") |
Add pair stringify to support maps. More... | |
template<template< typename... > class T, typename... U> | |
std::string | stringify (const T< U... > &c, const std::string &delim=", ", const std::string &elem_encl="", bool enclose_list_in_curly_braces=false) |
Convert a container to a string with elements separated by delimiter of user's choice. More... | |
std::string | stringifyExact (Real) |
Stringify Reals with enough precision to guarantee lossless Real -> string -> Real roundtrips. More... | |
void | elementsIntersectedByPlane (const Point &p0, const Point &normal, const MeshBase &mesh, std::vector< const Elem *> &intersected_elems) |
Find all of the elements intersected by a plane. More... | |
void | elementsIntersectedByPlane (const Point &p0, const Point &p1, const Point &p2, const MeshBase &mesh, std::vector< const Elem *> &intersected_elems) |
Find all of the elements intersected by a plane. More... | |
template<class Iterator > | |
_enumerate_range< Iterator > | enumerate (Iterator first, Iterator last, typename std::iterator_traits< Iterator >::difference_type initial) |
Enumerate function for iterating over a range and obtaining both a reference to the underlying type and an index simultaneously. More... | |
template<class Container > | |
_enumerate_range< typename Container::iterator > | enumerate (Container &content) |
template<class Container > | |
_enumerate_range< typename Container::const_iterator > | enumerate (const Container &content) |
std::string | getExecutablePath () |
This function returns the PATH of the running executable. More... | |
std::string | getExecutableName () |
This function returns the name of the running executable. More... | |
template<class RandomAccessIterator > | |
void | initialize_indirect_sort (RandomAccessIterator beg, RandomAccessIterator end, std::vector< size_t > &b) |
template<class RandomAccessIterator > | |
void | indirectSort (RandomAccessIterator beg, RandomAccessIterator end, std::vector< size_t > &b) |
template<class RandomAccessIterator , class UserComparisonFunctor > | |
void | indirectSort (RandomAccessIterator beg, RandomAccessIterator end, std::vector< size_t > &b, UserComparisonFunctor user_comp) |
template<typename T > | |
void | applyIndices (T &container, const std::vector< size_t > &indices) |
Uses indices created by the indirectSort function to sort the given container (which must support random access, resizing, and std::swap. More... | |
void | hash_combine (std::size_t &) |
Used for hash function specialization for Attribute objects. More... | |
template<typename T , typename... Rest> | |
void | hash_combine (std::size_t &seed, const T &v, Rest &&... rest) |
Used to combine an existing hash value with the hash of one or more other values (v and rest). More... | |
template<typename T , typename... Rest> | |
void | hash_combine (std::size_t &seed, const std::vector< T > &v, Rest &&... rest) |
Used for hash function specialization for Attribute objects. More... | |
template<typename T , typename... Rest> | |
void | hash_combine (std::size_t &seed, const std::set< T > &v, Rest &&... rest) |
Used for hash function specialization for Attribute objects. More... | |
template<typename T > | |
T | fe_lagrange_1D_shape (const Order order, const unsigned int i, const T &xi) |
template<typename T > | |
T | fe_lagrange_1D_shape_deriv (const Order order, const unsigned int i, const T &xi) |
template<typename T , template< typename > class VectorType> | |
T | fe_lagrange_2D_shape (const ElemType type, const Order order, const unsigned int i, const VectorType< T > &p) |
template<typename T , template< typename > class VectorType> | |
T | fe_lagrange_2D_shape_deriv (const ElemType type, const Order order, const unsigned int i, const unsigned int j, const VectorType< T > &p) |
std::string | stringify (const Moose::RelationshipManagerType &t) |
std::string | stringify (const Moose::TimeIntegratorType &t) |
template<std::size_t N> | |
void | derivInsert (NumberArray< N, Real > &derivs, dof_id_type index, Real value) |
void | elementsIntersectedByLine (const Point &p0, const Point &p1, const MeshBase &mesh, const PointLocatorBase &point_locator, std::vector< Elem *> &intersected_elems, std::vector< LineSegment > &segments) |
Find all of the elements intersected by a line. More... | |
SERIAL_ACCESS_SCALAR (Real) | |
SERIAL_ACCESS_SCALAR (ADReal) | |
SERIAL_ACCESS_CONST_SIZE (VectorValue, &obj(0u), Moose::dim) | |
SERIAL_ACCESS_CONST_SIZE (RankTwoTensorTempl, &obj(0u, 0u), RankTwoTensorTempl< T >::N2) | |
SERIAL_ACCESS_CONST_SIZE (RankFourTensorTempl, &obj(0u, 0u, 0u, 0u), RankFourTensorTempl< T >::N4) | |
SERIAL_ACCESS_DYNAMIC_SIZE (DenseVector, &obj(0u), obj.size()) | |
template<typename T > | |
SerialAccessRange< T > | serialAccess (T &obj) |
template<template< typename, int > class L, int I, typename T , typename... Ts, typename... As> | |
void | typeLoopInternal (TypeList< T, Ts... >, As... args) |
Type loop. More... | |
template<template< typename, int > class L, typename... Ts, typename... As> | |
void | typeLoop (TypeList< Ts... >, As... args) |
Type loop. More... | |
template<std::size_t N> | |
void | derivInsert (SemiDynamicSparseNumberArray< Real, libMesh::dof_id_type, NWrapper< N >> &derivs, libMesh::dof_id_type index, Real value) |
template<typename T > | |
void | initDofIndices (T &data, const Elem &elem) |
void | associateSyntaxInner (Syntax &syntax, ActionFactory &action_factory) |
void | registerAll (Factory &f, ActionFactory &af, Syntax &s) |
void | registerObjects (Factory &factory) |
void | registerObjects (Factory &factory, const std::set< std::string > &obj_labels) |
bool | isSectionActive (std::string path, hit::Node *root) |
std::vector< std::string > | findSimilar (std::string param, std::vector< std::string > options) |
template<> | |
void | Builder::setScalarParameter< ReporterName, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< ReporterName > *param, bool in_global, GlobalParamsAction *global_block) |
template<> | |
void | Builder::setVectorParameter< ReporterName, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< ReporterName >> *param, bool in_global, GlobalParamsAction *global_block) |
template<> | |
void | Builder::setVectorParameter< CLIArgString, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< CLIArgString >> *param, bool in_global, GlobalParamsAction *global_block) |
template<typename T > | |
bool | toBool (const std::string &, T &) |
template<> | |
bool | toBool< bool > (const std::string &s, bool &val) |
void | compute_linear_system (libMesh::EquationSystems &es, const std::string &system_name) |
void | assemble_matrix (EquationSystems &es, const std::string &system_name) |
void | compute_jacobian (const NumericVector< Number > &soln, SparseMatrix< Number > &jacobian, NonlinearImplicitSystem &sys) |
void | compute_bounds (NumericVector< Number > &lower, NumericVector< Number > &upper, NonlinearImplicitSystem &sys) |
void | compute_nullspace (std::vector< NumericVector< Number > *> &sp, NonlinearImplicitSystem &sys) |
void | compute_transpose_nullspace (std::vector< NumericVector< Number > *> &sp, NonlinearImplicitSystem &sys) |
void | compute_nearnullspace (std::vector< NumericVector< Number > *> &sp, NonlinearImplicitSystem &sys) |
void | compute_postcheck (const NumericVector< Number > &old_soln, NumericVector< Number > &search_direction, NumericVector< Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln, NonlinearImplicitSystem &sys) |
void | initCoordinateSystemType () |
void | initSolveType () |
void | initEigenSolveType () |
void | initEigenProlemType () |
void | initWhichEigenPairs () |
void | initLineSearchType () |
void | initTimeIntegratorsType () |
void | initMffdType () |
void | initRMType () |
template<> | |
EigenSolveType | stringToEnum< EigenSolveType > (const std::string &s) |
template<> | |
EigenProblemType | stringToEnum< EigenProblemType > (const std::string &s) |
template<> | |
WhichEigenPairs | stringToEnum< WhichEigenPairs > (const std::string &s) |
template<> | |
MffdType | stringToEnum< MffdType > (const std::string &s) |
std::string | stringify (libMesh::FEFamily f) |
Point | toPoint (const std::vector< Real > &pos) |
Convert point represented as std::vector into Point. More... | |
void | findElementsIntersectedByPlane (const Plane &plane, const MeshBase &mesh, std::vector< const Elem *> &intersected_elems) |
std::string | getExec () |
int | sideIntersectedByLine (const Elem *elem, std::vector< int > ¬_side, const LineSegment &line_segment, Point &intersection_point) |
Figure out which (if any) side of an Elem is intersected by a line. More... | |
int | sideNeighborIsOn (const Elem *elem, const Elem *neighbor) |
Returns the side number for elem that neighbor is on. More... | |
void | recursivelyFindElementsIntersectedByLine (const LineSegment &line_segment, const Elem *current_elem, int incoming_side, const Point &incoming_point, std::vector< Elem *> &intersected_elems, std::vector< LineSegment > &segments) |
Recursively find all elements intersected by a line segment. More... | |
Variables | |
static constexpr std::size_t | dim = LIBMESH_DIM |
This is the dimension of all vector and tensor datastructures used in MOOSE. More... | |
int | interrupt_signal_number = 0 |
Used by the signal handler to determine if we should write a checkpoint file out at any point during operation. More... | |
bool | show_trace = true |
Set to true (the default) to print the stack trace with error and warning messages - false to omit it. More... | |
bool | show_multiple = false |
Set to false (the default) to display an error message only once for each error call code location (as opposed to every time the code is executed). More... | |
PerfLog | perf_log |
Perflog to be used by applications. More... | |
bool | _trap_fpe |
Variable indicating whether we will enable FPE trapping for this run. More... | |
bool | _warnings_are_errors = false |
Variable to toggle any warning into an error (includes deprecated code warnings) More... | |
bool | _deprecated_is_error = false |
Variable to toggle only deprecated warnings as errors. More... | |
bool | _throw_on_error = false |
Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or when about to perform threaded operations because exception throwing in threaded regions is safe while aborting is inherently not when singletons are involved (e.g. More... | |
bool | _throw_on_warning = false |
Variable to turn on exceptions during mooseWarning(), should only be used in MOOSE unit tests. More... | |
ExecFlagEnum | execute_flags |
Storage for the registered execute flags. More... | |
constexpr std::size_t | constMaxQpsPerElem = 216 |
This is used for places where we initialize some qp-sized data structures that would end up being sized too small after the quadrature order gets bumped (dynamically in-sim). More... | |
template<class T > | |
constexpr std::false_type | always_false {} |
This is a helper variable template for cases when we want to use a default compile-time error with constexpr-based if conditions. More... | |
const processor_id_type | INVALID_PROCESSOR_ID = libMesh::DofObject::invalid_processor_id |
const SubdomainID | ANY_BLOCK_ID = libMesh::Elem::invalid_subdomain_id - 1 |
const SubdomainID | INTERNAL_SIDE_LOWERD_ID = libMesh::Elem::invalid_subdomain_id - 2 |
const SubdomainID | BOUNDARY_SIDE_LOWERD_ID = libMesh::Elem::invalid_subdomain_id - 3 |
const SubdomainID | INVALID_BLOCK_ID = libMesh::Elem::invalid_subdomain_id |
const BoundaryID | ANY_BOUNDARY_ID = static_cast<BoundaryID>(-1) |
const BoundaryID | INVALID_BOUNDARY_ID = libMesh::BoundaryInfo::invalid_id |
const TagID | INVALID_TAG_ID = static_cast<TagID>(-1) |
const TagTypeID | INVALID_TAG_TYPE_ID = static_cast<TagTypeID>(-1) |
const std::set< SubdomainID > | EMPTY_BLOCK_IDS = {} |
const std::set< BoundaryID > | EMPTY_BOUNDARY_IDS = {} |
const TagName | SOLUTION_TAG = "SOLUTION" |
const TagName | OLD_SOLUTION_TAG = "SOLUTION_STATE_1" |
const TagName | OLDER_SOLUTION_TAG = "SOLUTION_STATE_2" |
const TagName | PREVIOUS_NL_SOLUTION_TAG = "U_PREVIOUS_NL_NEWTON" |
static bool | _color_console = isatty(fileno(stdout)) |
std::map< std::string, CoordinateSystemType > | coordinate_system_type_to_enum |
std::map< std::string, SolveType > | solve_type_to_enum |
std::map< std::string, EigenSolveType > | eigen_solve_type_to_enum |
std::map< std::string, EigenProblemType > | eigen_problem_type_to_enum |
std::map< std::string, WhichEigenPairs > | which_eigen_pairs_to_enum |
std::map< std::string, LineSearchType > | line_search_type_to_enum |
std::map< std::string, TimeIntegratorType > | time_integrator_to_enum |
std::map< std::string, MffdType > | mffd_type_to_enum |
std::map< std::string, RelationshipManagerType > | rm_type_to_enum |
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to address this in their environment if C++17 compatibility isn't found.
using Moose::Functor = typedef FunctorEnvelope<T> |
Definition at line 33 of file MooseFunctorForward.h.
using Moose::GenericType = typedef typename std::conditional<is_ad, typename ADType<T>::type, T>::type |
Definition at line 555 of file MooseTypes.h.
typedef std::function<void(const InputParameters &, InputParameters &)> Moose::RelationshipManagerInputParameterCallback |
The type for the callback to set RelationshipManager parameters.
Definition at line 902 of file MooseTypes.h.
enum Moose::AuxGroup |
Flag for AuxKernel related execution type.
Enumerator | |
---|---|
PRE_IC | |
PRE_AUX | |
POST_AUX | |
ALL |
Definition at line 616 of file MooseTypes.h.
|
strong |
The type of nonlinear computation being performed.
Enumerator | |
---|---|
Residual | |
Jacobian | |
ResidualAndJacobian |
Definition at line 693 of file MooseTypes.h.
Type of constraint formulation.
Enumerator | |
---|---|
Penalty | |
Kinematic |
Definition at line 830 of file MooseTypes.h.
Enumerator | |
---|---|
SecondarySecondary | |
SecondaryPrimary | |
PrimarySecondary | |
PrimaryPrimary | |
LowerLower | |
LowerSecondary | |
LowerPrimary | |
SecondaryLower | |
PrimaryLower |
Definition at line 709 of file MooseTypes.h.
Enumerator | |
---|---|
SIDE_PRIMARY | |
SIDE_SECONDARY |
Definition at line 650 of file MooseTypes.h.
Enumerator | |
---|---|
Secondary | |
Primary |
Definition at line 670 of file MooseTypes.h.
enum Moose::CoordinateSystemType : int |
Enumerator | |
---|---|
COORD_XYZ | |
COORD_RZ | |
COORD_RSPHERICAL |
Definition at line 722 of file MooseTypes.h.
enum Moose::CouplingType |
Enumerator | |
---|---|
COUPLING_DIAG | |
COUPLING_FULL | |
COUPLING_CUSTOM |
Definition at line 643 of file MooseTypes.h.
Enumerator | |
---|---|
ElementElement | |
ElementNeighbor | |
NeighborElement | |
NeighborNeighbor |
Definition at line 662 of file MooseTypes.h.
Enumerator | |
---|---|
Element | |
Neighbor |
Definition at line 656 of file MooseTypes.h.
Type of the eigen problem.
Enumerator | |
---|---|
EPT_HERMITIAN | Hermitian. |
EPT_NON_HERMITIAN | Non-Hermitian. |
EPT_GEN_HERMITIAN | Generalized Hermitian. |
EPT_GEN_INDEFINITE | Generalized Hermitian indefinite. |
EPT_GEN_NON_HERMITIAN | Generalized Non-Hermitian. |
EPT_POS_GEN_NON_HERMITIAN | Generalized Non-Hermitian with positive (semi-)definite B. |
EPT_SLEPC_DEFAULT | use whatever SLPEC has by default |
Definition at line 783 of file MooseTypes.h.
Type of the eigen solve.
Definition at line 767 of file MooseTypes.h.
|
strong |
Enumerator | |
---|---|
Element | |
Neighbor | |
Lower |
Definition at line 676 of file MooseTypes.h.
|
strong |
An enumeration of possible functor evaluation kinds.
The available options are value, gradient, time derivative (dot), and gradient of time derivative (gradDot)
Enumerator | |
---|---|
Value | |
Gradient | |
Dot | |
GradDot |
Definition at line 36 of file MooseFunctor.h.
enum Moose::GeometryType |
Enumerator | |
---|---|
Volume | |
Face |
Definition at line 236 of file MooseTypes.h.
Type of the line search.
Enumerator | |
---|---|
LS_INVALID | means not set |
LS_DEFAULT | |
LS_NONE | |
LS_BASIC | |
LS_SHELL | |
LS_CONTACT | |
LS_PROJECT | |
LS_L2 | |
LS_BT | |
LS_CP |
Definition at line 838 of file MooseTypes.h.
MaterialData types.
Enumerator | |
---|---|
BLOCK_MATERIAL_DATA | |
BOUNDARY_MATERIAL_DATA | |
FACE_MATERIAL_DATA | |
NEIGHBOR_MATERIAL_DATA | |
INTERFACE_MATERIAL_DATA |
Definition at line 604 of file MooseTypes.h.
enum Moose::MffdType |
Type of the matrix-free finite-differencing parameter.
Enumerator | |
---|---|
MFFD_INVALID | means not set |
MFFD_WP | |
MFFD_DS |
Definition at line 855 of file MooseTypes.h.
Norm type for converge test.
Enumerator | |
---|---|
KSPN_NONE | |
KSPN_PRECONDITIONED | |
KSPN_UNPRECONDITIONED | |
KSPN_NATURAL | |
KSPN_DEFAULT | Use whatever we have in PETSc. |
Definition at line 743 of file MooseTypes.h.
|
strong |
Enumerator | |
---|---|
Secondary | |
Primary | |
Lower |
Definition at line 683 of file MooseTypes.h.
Type of patch update strategy for modeling node-face constraints or contact.
Enumerator | |
---|---|
Never | |
Always | |
Auto | |
Iteration |
Definition at line 865 of file MooseTypes.h.
enum Moose::PCSideType |
Preconditioning side.
Enumerator | |
---|---|
PCS_LEFT | |
PCS_RIGHT | |
PCS_SYMMETRIC | |
PCS_DEFAULT | Use whatever we have in PETSc. |
Definition at line 732 of file MooseTypes.h.
|
strong |
Main types of Relationship Managers.
Enumerator | |
---|---|
DEFAULT | |
GEOMETRIC | |
ALGEBRAIC | |
COUPLING |
Definition at line 876 of file MooseTypes.h.
|
strong |
The filter type applied to a particular piece of "restartable" data.
These filters will be applied during deserialization to include or exclude data as appropriate.
Enumerator | |
---|---|
RECOVERABLE |
Definition at line 704 of file MooseTypes.h.
enum Moose::RMSystemType |
Enumerator | |
---|---|
NONLINEAR | |
AUXILIARY | |
NONE |
Definition at line 884 of file MooseTypes.h.
|
strong |
enum Moose::SolutionState : int |
Enumerator | |
---|---|
Current | |
Old | |
Older | |
PreviousNL |
Definition at line 221 of file MooseTypes.h.
enum Moose::SolveType |
Type of the solve.
Definition at line 755 of file MooseTypes.h.
Time integrators.
Enumerator | |
---|---|
TI_IMPLICIT_EULER | |
TI_EXPLICIT_EULER | |
TI_CRANK_NICOLSON | |
TI_BDF2 | |
TI_EXPLICIT_MIDPOINT | |
TI_LSTABLE_DIRK2 | |
TI_EXPLICIT_TVD_RK_2 | |
TI_NEWMARK_BETA |
Definition at line 815 of file MooseTypes.h.
enum Moose::VarFieldType |
Enumerator | |
---|---|
VAR_FIELD_STANDARD | |
VAR_FIELD_SCALAR | |
VAR_FIELD_VECTOR | |
VAR_FIELD_ARRAY | |
VAR_FIELD_ANY |
Definition at line 634 of file MooseTypes.h.
enum Moose::VarKindType |
Framework-wide stuff.
Enumerator | |
---|---|
VAR_SOLVER | |
VAR_AUXILIARY | |
VAR_ANY |
Definition at line 627 of file MooseTypes.h.
enum Moose::VectorTagType |
Enumerator | |
---|---|
VECTOR_TAG_RESIDUAL | |
VECTOR_TAG_SOLUTION | |
VECTOR_TAG_ANY |
Definition at line 891 of file MooseTypes.h.
Which eigen pairs.
Definition at line 797 of file MooseTypes.h.
The (optional) last param here indicates whether the task should trigger an Action auto-build. If a task is marked as "true". Then MOOSE will attempt to build the associated Action if one is not supplied by some other means (usually through the input file or custom Action). Only Actions that do not have required parameters and have defaults for all optional parameters can be built automatically (See ActionWarehouse.C).
Note: Many of the actions in the "Minimal Problem" section are marked as false. However, we can generally force creation of these "Action"s as needed by registering them to syntax that we expect to see even if those "Action"s don't normally pick up parameters from the input file.
Additional Actions
The following is the default set of action dependencies for a basic MOOSE problem. The formatting of this string is important. Each line represents a set of dependencies that depend on the previous line. Items on the same line have equal weight and can be executed in any order.
Additional dependencies can be inserted later inside of user applications with calls to ActionWarehouse::addDependency("task", "pre_req")
The (optional) last param here indicates whether the task should trigger an Action auto-build. If a task is marked as "true". Then MOOSE will attempt to build the associated Action if one is not supplied by some other means (usually through the input file or custom Action). Only Actions that do not have required parameters and have defaults for all optional parameters can be built automatically (See ActionWarehouse.C).
Note: Many of the actions in the "Minimal Problem" section are marked as false. However, we can generally force creation of these "Action"s as needed by registering them to syntax that we expect to see even if those "Action"s don't normally pick up parameters from the input file.
Additional Actions
The following is the default set of action dependencies for a basic MOOSE problem. The formatting of this string is important. Each line represents a set of dependencies that depend on the previous line. Items on the same line have equal weight and can be executed in any order.
Additional dependencies can be inserted later inside of user applications with calls to ActionWarehouse::addDependency("task", "pre_req")
Definition at line 79 of file Moose.C.
Referenced by associateSyntaxInner().
void Moose::addMainCommandLineParams | ( | InputParameters & | params | ) |
Adds the command line parameters needed from within main
, which will also need to be added to MooseApp so that they show up in –help.
Definition at line 26 of file MooseMain.C.
Referenced by createMooseApp(), and MooseApp::validParams().
|
inline |
Helper function for computing automatic differentiation offset.
Let's explain how our derivative index numbering scheme works:
Let's just think about continuous finite elements for a second. We use a variable major numbering scheme, such that each variables indices are in a contiguous block. Let's imagine we have two variables, u and v, and we're on a QUAD4
. The AD indices will be ordered like this:
u0, u1, u2, u3, v0, v1, v2, v3
max_dofs_per_elem
should be for a QUAD4:
4. For a QUAD9
, 9. HEX27
, 27. Etc. For CFEM the offset will be simply be the max_dofs_per_elem
number times the var_num
. So for u on a QUAD4:
4 * 0 = 0. For v: 4 * 1. So u indices start at index 0, v indices start at index 4.
With DFEM or interface kernels it's a little more complicated. We essentially already have an indices block that is num_vars_in_system
* max_dofs_per_elem
long, so in our two var, QUAD4
example: 4 * 2 = 8. So what we do is that if we are on a neighbor element, we do an additional offset by num_vars_in_system
* max_dofs_per_elem
. So now our derivative indices are ordered like this:
u0, u1, u2, u3, v0, v1, v2, v3, u0_neighbor, u1_neighbor, u2_neighbor, u3_neighbor, v0_neighbor, v1_neighbor, v2_neighbor, v3_neighbor
Finally if a lower-dimensional element is involved, then we another offset of num_vars_in_system
* max_dofs_per_elem:
u0, u1, u2, u3, v0, v1, v2, v3, u0_neighbor, u1_neighbor, u2_neighbor, u3_neighbor, v0_neighbor, v1_neighbor, v2_neighbor, v3_neighbor, u0_lower, u1_lower, u2_lower, u3_lower, v0_lower, v1_lower, v2_lower, v3_lower
Note that a lower dimensional block will have less indices than a higher dimensional one, but we do not optimize for that consideration at this time
var_num | The variable number we are calculating the offset for |
max_dofs_per_elem | The maximum number of degrees of freedom for any one variable on an element |
element_type | The "type" of element that we are on. Current options are ElementType::Element , ElementType::Neighbor , and ElementType::Lower |
num_vars_in_system | The number of vars in the system. This is used in offset calculation unless element_type is ElementType::Element |
Definition at line 79 of file ADUtils.h.
Referenced by adOffset(), and globalDofIndexToDerivative().
|
inline |
Definition at line 109 of file ADUtils.h.
void Moose::applyIndices | ( | T & | container, |
const std::vector< size_t > & | indices | ||
) |
Uses indices created by the indirectSort function to sort the given container (which must support random access, resizing, and std::swap.
Definition at line 108 of file IndirectSort.h.
Referenced by MaterialVectorPostprocessor::sortVecs().
void Moose::assemble_matrix | ( | EquationSystems & | es, |
const std::string & | system_name | ||
) |
Definition at line 40 of file NonlinearEigenSystem.C.
Referenced by NonlinearEigenSystem::NonlinearEigenSystem().
void Moose::associateSyntax | ( | Syntax & | syntax, |
ActionFactory & | action_factory | ||
) |
Definition at line 608 of file Moose.C.
void Moose::associateSyntaxInner | ( | Syntax & | syntax, |
ActionFactory & | action_factory | ||
) |
Note: the optional third parameter is used to differentiate which task is satisfied based on the syntax encountered for classes which are registered to satisfy more than one task
Variable/AuxVariable Actions
Note: the optional third parameter is used to differentiate which task is satisfied based on the syntax encountered for classes which are registered to satisfy more than one task
Variable/AuxVariable Actions
Definition at line 424 of file Moose.C.
Referenced by associateSyntax(), and registerAll().
void Moose::Builder::setScalarParameter< ReporterName, std::string > | ( | const std::string & | full_name, |
const std::string & | short_name, | ||
InputParameters::Parameter< ReporterName > * | param, | ||
bool | in_global, | ||
GlobalParamsAction * | global_block | ||
) |
Definition at line 2080 of file Builder.C.
void Moose::Builder::setVectorParameter< CLIArgString, std::string > | ( | const std::string & | full_name, |
const std::string & | short_name, | ||
InputParameters::Parameter< std::vector< CLIArgString >> * | param, | ||
bool | in_global, | ||
GlobalParamsAction * | global_block | ||
) |
Definition at line 2269 of file Builder.C.
void Moose::Builder::setVectorParameter< ReporterName, std::string > | ( | const std::string & | full_name, |
const std::string & | short_name, | ||
InputParameters::Parameter< std::vector< ReporterName >> * | param, | ||
bool | in_global, | ||
GlobalParamsAction * | global_block | ||
) |
Definition at line 2244 of file Builder.C.
bool Moose::colorConsole | ( | ) |
InputParameters Moose::commonAdaptivityParams | ( | ) |
Definition at line 24 of file SetAdaptivityOptionsAction.C.
Referenced by AdaptivityAction::validParams(), and SetAdaptivityOptionsAction::validParams().
void Moose::compute_bounds | ( | NumericVector< Number > & | lower, |
NumericVector< Number > & | upper, | ||
NonlinearImplicitSystem & | sys | ||
) |
Definition at line 43 of file NonlinearSystem.C.
Referenced by NonlinearSystem::NonlinearSystem().
void Moose::compute_jacobian | ( | const NumericVector< Number > & | soln, |
SparseMatrix< Number > & | jacobian, | ||
NonlinearImplicitSystem & | sys | ||
) |
Definition at line 33 of file NonlinearSystem.C.
Referenced by NonlinearSystem::NonlinearSystem(), and NonlinearSystem::setupColoringFiniteDifferencedPreconditioner().
void Moose::compute_linear_system | ( | libMesh::EquationSystems & | es, |
const std::string & | system_name | ||
) |
Definition at line 60 of file LinearSystem.C.
Referenced by LinearSystem::LinearSystem().
void Moose::compute_nearnullspace | ( | std::vector< NumericVector< Number > *> & | sp, |
NonlinearImplicitSystem & | sys | ||
) |
Definition at line 70 of file NonlinearSystem.C.
Referenced by NonlinearSystem::NonlinearSystem().
void Moose::compute_nullspace | ( | std::vector< NumericVector< Number > *> & | sp, |
NonlinearImplicitSystem & | sys | ||
) |
Definition at line 53 of file NonlinearSystem.C.
Referenced by NonlinearSystem::NonlinearSystem().
void Moose::compute_postcheck | ( | const NumericVector< Number > & | old_soln, |
NumericVector< Number > & | search_direction, | ||
NumericVector< Number > & | new_soln, | ||
bool & | changed_search_direction, | ||
bool & | changed_new_soln, | ||
NonlinearImplicitSystem & | sys | ||
) |
Definition at line 78 of file NonlinearSystem.C.
Referenced by NonlinearSystem::solve().
void Moose::compute_transpose_nullspace | ( | std::vector< NumericVector< Number > *> & | sp, |
NonlinearImplicitSystem & | sys | ||
) |
Definition at line 61 of file NonlinearSystem.C.
Referenced by NonlinearSystem::NonlinearSystem().
std::shared_ptr< MooseApp > Moose::createMooseApp | ( | const std::string & | default_app_name, |
int | argc, | ||
char * | argv[] | ||
) |
Create a MooseApp from command-line arguments.
Definition at line 39 of file MooseMain.C.
Referenced by main().
|
inline |
Definition at line 244 of file MooseFunctorArguments.h.
Referenced by MooseVariableDataFV< OutputType >::computeAD(), GradientJumpIndicator::computeQpIntegral(), MaterialFunctorConverterTempl< T >::computeQpProperties(), FunctorNeumannBC::computeQpResidual(), FunctorDirichletBC::computeQpValue(), TransientInterface::determineState(), ComputeLinearFVGreenGaussGradientFaceThread::onBoundaryFace(), ComputeLinearFVGreenGaussGradientVolumeThread::operator()(), and Moose::FunctorBase< libMesh::VectorValue >::queryFVArgCache().
|
inline |
Definition at line 20 of file NumberArrayOps.h.
Referenced by MooseVariableData< OutputType >::computeAD(), MooseVariableDataFV< OutputType >::computeAD(), MooseVariableScalar::computeAD(), Assembly::computeFaceMap(), ADPeriodicSegmentalConstraint::computeQpResidual(), ADPenaltyPeriodicSegmentalConstraint::computeQpResidual(), ADPenaltyPeriodicSegmentalConstraint::computeScalarQpResidual(), Assembly::computeSinglePointMapAD(), MooseVariableFE< Real >::computeSolution(), MooseVariableFE< Real >::evaluate(), MooseVariableDataFV< OutputType >::fetchADDoFValues(), MooseVariableData< OutputType >::fetchADDoFValues(), and MooseVariableFV< Real >::getElemValue().
|
inline |
Definition at line 20 of file SparseOps.h.
bool Moose::doDerivatives | ( | const SubProblem & | subproblem, |
const SystemBase & | sys | ||
) |
Definition at line 79 of file ADUtils.C.
Referenced by MooseVariableData< OutputType >::computeAD(), MooseVariableFE< Real >::computeSolution(), and MooseVariableFE< Real >::evaluate().
void Moose::elementsIntersectedByLine | ( | const Point & | p0, |
const Point & | p1, | ||
const MeshBase & | mesh, | ||
const PointLocatorBase & | point_locator, | ||
std::vector< Elem *> & | intersected_elems, | ||
std::vector< LineSegment > & | segments | ||
) |
Find all of the elements intersected by a line.
The line is given as the beginning and ending points
p0 | The beginning of the line |
p1 | The end of the line |
intersected_elems | The elements intersected by the line. Will be empty if there are no intersections. |
segments | The line segments across each element |
Definition at line 192 of file RayTracing.C.
Referenced by ElementsAlongLine::execute(), IntersectionPointsAlongLine::execute(), and LineMaterialSamplerBase< Real >::execute().
void Moose::elementsIntersectedByPlane | ( | const Point & | p0, |
const Point & | normal, | ||
const MeshBase & | mesh, | ||
std::vector< const Elem *> & | intersected_elems | ||
) |
Find all of the elements intersected by a plane.
The plane is given as a point and a normal vector.
p0 | Point in plane. |
normal | Normal vector to plane. |
intersected_elems | The elements intersected by the plane. Will be empty if there are no intersections. |
Definition at line 53 of file ElementsIntersectedByPlane.C.
Referenced by ElementsAlongPlane::execute().
void Moose::elementsIntersectedByPlane | ( | const Point & | p0, |
const Point & | p1, | ||
const Point & | p2, | ||
const MeshBase & | mesh, | ||
std::vector< const Elem *> & | intersected_elems | ||
) |
Find all of the elements intersected by a plane.
The plane is given as three points in the plane.
p0 | Point in plane. |
p1 | Point in plane. |
p2 | Point in plane. |
intersected_elems | The elements intersected by the plane. Will be empty if there are no intersections. |
Definition at line 69 of file ElementsIntersectedByPlane.C.
_enumerate_range<Iterator> Moose::enumerate | ( | Iterator | first, |
Iterator | last, | ||
typename std::iterator_traits< Iterator >::difference_type | initial | ||
) |
Enumerate function for iterating over a range and obtaining both a reference to the underlying type and an index simultaneously.
This method is forward-compatible with the C++17 structured bindings capability.
C++11 compatible usage:
for (auto it : Moose::enumerate(values)) _console << it.index() << ": " << it.value() << '
';
// Here the third argument is the starting index value for (auto it : Moose::enumerate(values.begin(), values.end(), 0)) _console << it.index() << ": " << it.value() << '
';
C++17 usage (DO NOT USE IN MOOSE):
for (auto [index, value] : Moose::enumerate(values)) _console << index << ": " << value << '
';
// Here the third argument is the starting index value for (auto [index, value] : Moose::enumerate(values.begin(), values.end(), 0)) _console << index << ": " << value << '
';
Definition at line 52 of file Enumerate.h.
Referenced by JvarMapInterfaceBase< Kernel >::JvarMapInterfaceBase(), NearestPointIntegralVariablePostprocessor::nearestPointIndex(), NearestPointAverage::nearestPointIndex(), and NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::nearestUserObject().
_enumerate_range<typename Container::iterator> Moose::enumerate | ( | Container & | content | ) |
Definition at line 61 of file Enumerate.h.
_enumerate_range<typename Container::const_iterator> Moose::enumerate | ( | const Container & | content | ) |
Definition at line 68 of file Enumerate.h.
T Moose::fe_lagrange_1D_shape | ( | const Order | order, |
const unsigned int | i, | ||
const T & | xi | ||
) |
Definition at line 22 of file MooseLagrangeHelpers.h.
Referenced by AutomaticMortarGeneration::buildMortarSegmentMesh(), fe_lagrange_2D_shape(), fe_lagrange_2D_shape_deriv(), AutomaticMortarGeneration::getNormals(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), and AutomaticMortarGeneration::projectSecondaryNodesSinglePair().
T Moose::fe_lagrange_1D_shape_deriv | ( | const Order | order, |
const unsigned int | i, | ||
const T & | xi | ||
) |
Definition at line 96 of file MooseLagrangeHelpers.h.
Referenced by fe_lagrange_2D_shape_deriv().
T Moose::fe_lagrange_2D_shape | ( | const ElemType | type, |
const Order | order, | ||
const unsigned int | i, | ||
const VectorType< T > & | p | ||
) |
Definition at line 171 of file MooseLagrangeHelpers.h.
Referenced by AutomaticMortarGeneration::getNormals(), and Moose::Mortar::projectQPoints3d().
T Moose::fe_lagrange_2D_shape_deriv | ( | const ElemType | type, |
const Order | order, | ||
const unsigned int | i, | ||
const unsigned int | j, | ||
const VectorType< T > & | p | ||
) |
Definition at line 378 of file MooseLagrangeHelpers.h.
void Moose::findContactPoint | ( | PenetrationInfo & | p_info, |
FEBase * | fe_elem, | ||
FEBase * | fe_side, | ||
FEType & | fe_side_type, | ||
const Point & | secondary_point, | ||
bool | start_with_centroid, | ||
const Real | tangential_tolerance, | ||
bool & | contact_point_on_side | ||
) |
Finds the closest point (called the contact point) on the primary_elem on side "side" to the secondary_point.
p_info | The penetration info object, contains primary_elem, side, various other information |
fe_elem | FE object for the element |
fe_side | FE object for the side |
fe_side_type | The type of fe_side, needed for inverse_map routines |
start_with_centroid | if true, start inverse mapping procedure from element centroid |
tangential_tolerance | 'tangential' tolerance for determining whether a contact point on a side |
secondary_point | The physical space coordinates of the secondary node |
contact_point_on_side | whether or not the contact_point actually lies on that side of the element. |
Definition at line 45 of file FindContactPoint.C.
Referenced by PenetrationThread::createInfoForElem(), and PenetrationThread::operator()().
void Moose::findElementsIntersectedByPlane | ( | const Plane & | plane, |
const MeshBase & | mesh, | ||
std::vector< const Elem *> & | intersected_elems | ||
) |
Definition at line 24 of file ElementsIntersectedByPlane.C.
Referenced by elementsIntersectedByPlane().
std::vector<std::string> Moose::findSimilar | ( | std::string | param, |
std::vector< std::string > | options | ||
) |
Definition at line 95 of file Builder.C.
Referenced by Moose::UnusedWalker::walk().
std::string Moose::getExec | ( | ) |
Definition at line 24 of file ExecutablePath.C.
Referenced by getExecutableName(), and getExecutablePath().
std::string Moose::getExecutableName | ( | ) |
This function returns the name of the running executable.
There is not a portable way to do this function implements this function for Mac OS X and Linux boxes containing a normal /proc tree
Definition at line 60 of file ExecutablePath.C.
Referenced by MooseApp::appBinaryName(), and MooseApp::runInputs().
std::string Moose::getExecutablePath | ( | ) |
This function returns the PATH of the running executable.
There is not a portable way to do this function implements this function for Mac OS X and Linux boxes containing a normal /proc tree
Definition at line 51 of file ExecutablePath.C.
Referenced by MooseUtils::docsDir(), DataFileInterface< Action >::getDataFileNameByName(), SystemInfo::getExecutable(), MooseUtils::installedInputsDir(), ADFParser::JITCompile(), and MooseUtils::runTestsExecutable().
|
inline |
Whether we are using global AD indexing.
Definition at line 29 of file ADUtils.h.
Referenced by FEProblemBase::init().
std::unordered_map< dof_id_type, Real > Moose::globalDofIndexToDerivative | ( | const ADReal & | ad_real, |
const SystemBase & | sys, | ||
ElementType | elem_type = ElementType::Element , |
||
THREAD_ID | tid = 0 |
||
) |
Generate a map from global dof index to derivative value.
Definition at line 23 of file ADUtils.C.
Referenced by globalDofIndexToDerivative().
auto Moose::globalDofIndexToDerivative | ( | const T & | ad_real_container, |
const SystemBase & | sys, | ||
ElementType | elem_type = ElementType::Element , |
||
THREAD_ID | tid = 0 |
||
) | -> std::vector<std::unordered_map< dof_id_type, typename std::enable_if<std::is_same<ADReal, typename T::value_type>::value, Real>::type>> |
Generate a map from global dof index to derivative value for a (probably quadrature-point-based) container like a material property or a variable value.
Definition at line 136 of file ADUtils.h.
|
inline |
Used for hash function specialization for Attribute objects.
Definition at line 22 of file MooseHashing.h.
Referenced by hash_combine(), PointIndexedMap::hash_point::operator()(), moose::internal::SoltionInvalidityNameHash::operator()(), std::hash< std::pair< S, T > >::operator()(), std::hash< Attribute >::operator()(), and std::hash< std::vector< std::unique_ptr< Attribute > > >::operator()().
|
inline |
Used to combine an existing hash value with the hash of one or more other values (v and rest).
For example "auto h = std::hash("hello"); hash_combine(h, my_int_val, my_float_val, etc.);"
Definition at line 30 of file MooseHashing.h.
|
inline |
Used for hash function specialization for Attribute objects.
Definition at line 40 of file MooseHashing.h.
|
inline |
Used for hash function specialization for Attribute objects.
Definition at line 50 of file MooseHashing.h.
void Moose::indirectSort | ( | RandomAccessIterator | beg, |
RandomAccessIterator | end, | ||
std::vector< size_t > & | b | ||
) |
Definition at line 68 of file IndirectSort.h.
Referenced by SamplerBase::finalize(), and PerfGraph::printHeaviestSections().
void Moose::indirectSort | ( | RandomAccessIterator | beg, |
RandomAccessIterator | end, | ||
std::vector< size_t > & | b, | ||
UserComparisonFunctor | user_comp | ||
) |
Definition at line 89 of file IndirectSort.h.
void Moose::initCoordinateSystemType | ( | ) |
Definition at line 35 of file Conversion.C.
Referenced by stringToEnum< CoordinateSystemType >().
void Moose::initDofIndices | ( | T & | data, |
const Elem & | elem | ||
) |
Definition at line 48 of file MooseVariableDataFV.h.
Referenced by MooseVariableDataLinearFV< OutputType >::computeValues(), MooseVariableDataFV< OutputType >::computeValues(), MooseVariableDataLinearFV< OutputType >::dofIndices(), MooseVariableDataFV< OutputType >::dofIndices(), MooseVariableFV< Real >::getElemValue(), MooseVariableFV< Real >::getValue(), MooseVariableDataLinearFV< OutputType >::initDofIndices(), MooseVariableDataFV< OutputType >::initDofIndices(), and MooseVariableDataFV< OutputType >::prepareIC().
void Moose::initEigenProlemType | ( | ) |
Definition at line 76 of file Conversion.C.
Referenced by stringToEnum< EigenProblemType >().
void Moose::initEigenSolveType | ( | ) |
Definition at line 59 of file Conversion.C.
Referenced by stringToEnum< EigenSolveType >().
void Moose::initial_condition | ( | EquationSystems & | es, |
const std::string & | system_name | ||
) |
void Moose::initialize_indirect_sort | ( | RandomAccessIterator | beg, |
RandomAccessIterator | end, | ||
std::vector< size_t > & | b | ||
) |
Definition at line 52 of file IndirectSort.h.
Referenced by indirectSort().
void Moose::initLineSearchType | ( | ) |
Definition at line 110 of file Conversion.C.
Referenced by stringToEnum< LineSearchType >().
void Moose::initMffdType | ( | ) |
Definition at line 143 of file Conversion.C.
Referenced by stringToEnum< MffdType >().
void Moose::initRMType | ( | ) |
Definition at line 153 of file Conversion.C.
Referenced by stringToEnum< RelationshipManagerType >().
void Moose::initSolveType | ( | ) |
Definition at line 46 of file Conversion.C.
Referenced by stringToEnum< SolveType >().
void Moose::initTimeIntegratorsType | ( | ) |
Definition at line 128 of file Conversion.C.
Referenced by stringToEnum< TimeIntegratorType >().
void Moose::initWhichEigenPairs | ( | ) |
Definition at line 91 of file Conversion.C.
Referenced by stringToEnum< WhichEigenPairs >().
bool Moose::isSectionActive | ( | std::string | path, |
hit::Node * | root | ||
) |
Definition at line 58 of file Builder.C.
Referenced by Moose::UnusedWalker::walk(), and Moose::Builder::walkRaw().
Initialize, create and run a MooseApp.
Definition at line 37 of file MooseMain.h.
Referenced by removeSubstring().
|
inline |
Definition at line 250 of file MooseFunctorArguments.h.
Referenced by TransientInterface::determineState().
|
inline |
Definition at line 256 of file MooseFunctorArguments.h.
void Moose::recursivelyFindElementsIntersectedByLine | ( | const LineSegment & | line_segment, |
const Elem * | current_elem, | ||
int | incoming_side, | ||
const Point & | incoming_point, | ||
std::vector< Elem *> & | intersected_elems, | ||
std::vector< LineSegment > & | segments | ||
) |
Recursively find all elements intersected by a line segment.
Works by moving from one element to the next through the side of the current element. This means that (other than for the first element) there is always an incoming_side that is the reason we ended up in this element in the first place. Search all the other sides to see if there is a next element...
line_segment | the LineSegment to intersect |
current_elem | The current element that needs to be searched |
incoming_side | The side of the current element that was intersected by the LineSegment that brought us here |
intersected_elems | The output |
segments | Line segments for the path across each element |
Definition at line 144 of file RayTracing.C.
Referenced by elementsIntersectedByLine().
void Moose::registerActions | ( | Syntax & | syntax, |
ActionFactory & | action_factory | ||
) |
Multiple Action class can be associated with a single input file section, in which case all associated Actions will be created and "acted" on when the associated input file section is seen.
Action classes can also be registered to act on more than one input file section for a different task if similar logic can work in multiple cases
Example: "add_variable" <--— -> [Variables/ *] \ / CopyNodalVarsAction / \ "add_aux_variable" <- -> [AuxVariables/ *]
Note: Placeholder "no_action" actions must be put in places where it is possible to match an object with a star or a more specific parent later on. (i.e. where one needs to negate the '*' matching prematurely).
Definition at line 406 of file Moose.C.
Referenced by associateSyntax(), and registerAll().
void Moose::registerActions | ( | Syntax & | syntax, |
ActionFactory & | action_factory, | ||
const std::set< std::string > & | obj_labels | ||
) |
Definition at line 413 of file Moose.C.
void Moose::registerAll | ( | Factory & | f, |
ActionFactory & | af, | ||
Syntax & | s | ||
) |
Definition at line 56 of file Moose.C.
void Moose::registerAll | ( | Factory & | f, |
ActionFactory & | af, | ||
Syntax & | s | ||
) |
Register objects that are in MOOSE.
Referenced by MooseApp::MooseApp().
Definition at line 66 of file Moose.C.
Definition at line 73 of file Moose.C.
Referenced by registerAll(), and registerObjects().
void Moose::restrictPointToFace | ( | Point & | p, |
const Elem * | side, | ||
std::vector< const Node *> & | off_edge_nodes | ||
) |
Definition at line 265 of file FindContactPoint.C.
Referenced by findContactPoint().
Moose::SERIAL_ACCESS_CONST_SIZE | ( | VectorValue | , |
& | obj0u, | ||
Moose::dim | |||
) |
Moose::SERIAL_ACCESS_CONST_SIZE | ( | RankTwoTensorTempl | , |
& | obj0u, 0u, | ||
RankTwoTensorTempl< T >::N2 | |||
) |
Moose::SERIAL_ACCESS_CONST_SIZE | ( | RankFourTensorTempl | , |
& | obj0u, 0u, 0u, 0u, | ||
RankFourTensorTempl< T >::N4 | |||
) |
Moose::SERIAL_ACCESS_DYNAMIC_SIZE | ( | DenseVector | , |
& | obj0u, | ||
obj. | size() | ||
) |
Moose::SERIAL_ACCESS_SCALAR | ( | Real | ) |
Moose::SERIAL_ACCESS_SCALAR | ( | ADReal | ) |
SerialAccessRange<T> Moose::serialAccess | ( | T & | obj | ) |
Definition at line 151 of file SerialAccess.h.
Referenced by InterpolatedStatefulMaterialTempl< T >::computeQpProperties(), ProjectedStatefulMaterialAuxTempl< T, is_ad >::computeValue(), and ProjectedStatefulMaterialNodalPatchRecoveryTempl< T, is_ad >::execute().
bool Moose::setColorConsole | ( | bool | use_color, |
bool | force = false |
||
) |
Turns color escape sequences on/off for info written to stdout.
Returns the the set value which may be different than use_color.
Definition at line 638 of file Moose.C.
Referenced by CommonOutputAction::act(), and MooseApp::setupOptions().
void Moose::setSolverDefaults | ( | FEProblemBase & | problem | ) |
Definition at line 615 of file Moose.C.
int Moose::sideIntersectedByLine | ( | const Elem * | elem, |
std::vector< int > & | not_side, | ||
const LineSegment & | line_segment, | ||
Point & | intersection_point | ||
) |
Figure out which (if any) side of an Elem is intersected by a line.
elem | The elem to search |
not_side | Sides to not search (Use -1 if you want to search all sides) |
intersection_point | If an intersection is found this will be filled with the x,y,z position of that intersection |
Definition at line 34 of file RayTracing.C.
Referenced by recursivelyFindElementsIntersectedByLine().
int Moose::sideNeighborIsOn | ( | const Elem * | elem, |
const Elem * | neighbor | ||
) |
Returns the side number for elem that neighbor is on.
Returns -1 if the neighbor can't be found to be a neighbor
Definition at line 115 of file RayTracing.C.
Referenced by recursivelyFindElementsIntersectedByLine().
std::string Moose::stringify | ( | const T & | t | ) |
conversion to string
Definition at line 62 of file Conversion.h.
Referenced by SetupResidualDebugAction::act(), MaterialDerivativeTestAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), DiracKernelBase::addPoint(), Action::addRelationshipManager(), MooseVariableData< OutputType >::adGradPhi(), MooseVariableData< OutputType >::adGradPhiFace(), MooseEnum::assign(), AuxKernelTempl< Real >::AuxKernelTempl(), ParsedFunctorMaterialTempl< is_ad >::buildParsedFunction(), MooseMesh::checkCoordinateSystems(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), FEProblemBase::checkExceptionAndStopSolve(), Moose::FunctorBase< libMesh::VectorValue >::checkFace(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonPlanarSides(), PhysicsBase::checkRequiredTasks(), BlockRestrictable::checkVariable(), PhysicsBase::checkVectorParamsNoOverlap(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), Moose::SlepcSupport::clearFreeNonlinearPowerIterations(), FEProblemBase::computeUserObjectsInternal(), CopyValueAux::CopyValueAux(), DGKernelBase::DGKernelBase(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), MonotoneCubicInterpolation::errorCheck(), UnitsConversionEvaler::eval(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), DOFMapOutput::filename(), ElementQualityChecker::finalize(), ParsedMaterialHelper< is_ad >::functionParse(), ExtraNodesetGenerator::generate(), CoarsenBlockGenerator::generate(), ActionWarehouse::getAction(), FunctorBinnedValuesDivision::getBinIndex(), ComputeFVFluxThread< RangeType, AttribMatrixTags >::getBlockNames(), ExecFlagEnum::getDocString(), MooseLinearVariableFV< Real >::getElemValue(), MooseVariableFV< Real >::getElemValue(), MeshCoarseningUtils::getFineElementsFromInteriorNode(), SolutionUserObject::getLocalVarIndex(), Positions::getNearestPositionIndex(), MooseEnumBase::getRawNames(), MooseApp::getRelationshipManagerInfo(), SystemBase::getScalarVariable(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), SystemBase::getVariable(), SubProblem::getVariableHelper(), Moose::FV::harmonicInterpolation(), MultiAppGeneralFieldTransfer::initialSetup(), MatrixTools::inverse(), LeastSquaresFitHistory::LeastSquaresFitHistory(), MultiApp::localApp(), MeshDivisionAux::MeshDivisionAux(), SystemBase::oldSolutionStateVectorName(), operator<<(), Parser::parse(), PatternedMeshGenerator::PatternedMeshGenerator(), CompileTimeDerivatives::CTValue< tag, T >::print(), CompileTimeDerivatives::CTArrayRef< tag, T, I >::print(), CompileTimeDerivatives::CTIPow< B, E >::print(), libMesh::print_helper(), CompileTimeDerivatives::printTag(), TopResidualDebugOutput::printTopResiduals(), ProjectedStatefulMaterialStorageAction::processProperty(), DerivativeParsedMaterialHelperTempl< is_ad >::recurseMatProps(), CoarsenBlockGenerator::recursiveCoarsen(), MeshRepairGenerator::separateSubdomainsByElementType(), MooseMesh::setCoordSystem(), Moose::SlepcSupport::setFreeNonlinearPowerIterations(), Moose::SlepcSupport::setNewtonPetscOptions(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), Split::setup(), SystemBase::solutionState(), EigenProblem::solverTypeString(), FEProblemBase::solverTypeString(), NonlinearSystem::stopSolve(), stringify(), and FEProblemSolve::validParams().
|
inline |
Definition at line 71 of file Conversion.h.
|
inline |
Definition at line 78 of file Conversion.h.
|
inline |
Definition at line 83 of file Conversion.h.
|
inline |
Definition at line 88 of file Conversion.h.
|
inline |
Definition at line 93 of file Conversion.h.
|
inline |
Definition at line 98 of file Conversion.h.
|
inline |
Definition at line 103 of file Conversion.h.
std::string Moose::stringify | ( | const SolveType & | t | ) |
std::string Moose::stringify | ( | const EigenSolveType & | t | ) |
Convert eigen solve type into human readable string.
Definition at line 376 of file Conversion.C.
std::string Moose::stringify | ( | const VarFieldType & | t | ) |
Convert variable field type into human readable string.
Definition at line 403 of file Conversion.C.
std::string Moose::stringify | ( | const std::string & | s | ) |
Add no-op stringify if the argument already is a string (must use overloading)
Definition at line 458 of file Conversion.C.
std::string Moose::stringify | ( | SolutionIterationType | t | ) |
Convert SolutionIterationType into string.
Definition at line 422 of file Conversion.C.
std::string Moose::stringify | ( | ElementType | t | ) |
Convert ElementType into string.
Definition at line 436 of file Conversion.C.
std::string Moose::stringify | ( | libMesh::ElemType | t | ) |
Convert the libmesh ElemType into string.
Definition at line 452 of file Conversion.C.
std::string Moose::stringify | ( | const std::pair< T, U > & | p, |
const std::string & | delim = ":" |
||
) |
Add pair stringify to support maps.
Definition at line 135 of file Conversion.h.
std::string Moose::stringify | ( | const T< U... > & | c, |
const std::string & | delim = ", " , |
||
const std::string & | elem_encl = "" , |
||
bool | enclose_list_in_curly_braces = false |
||
) |
Convert a container to a string with elements separated by delimiter of user's choice.
Optionally, the container elements can be enclosed by curly braces and can enclose elements in quotations (or other characters) to make the separation of elements more clear.
[in] | c | Container to stringify |
[in] | delim | String to print between elements |
[in] | elem_encl | String to use at the beginning and end of each element, typically quotation marks |
[in] | enclose_list_in_curly_braces | Enclose the list string in curly braces? |
Definition at line 155 of file Conversion.h.
std::string Moose::stringify | ( | libMesh::FEFamily | f | ) |
Definition at line 348 of file Conversion.C.
std::string Moose::stringify | ( | const Moose::RelationshipManagerType & | t | ) |
Definition at line 324 of file Conversion.C.
std::string Moose::stringify | ( | const Moose::TimeIntegratorType & | t | ) |
std::string Moose::stringifyExact | ( | Real | t | ) |
Stringify Reals with enough precision to guarantee lossless Real -> string -> Real roundtrips.
Definition at line 464 of file Conversion.C.
T Moose::stringToEnum | ( | const std::string & | s | ) |
CoordinateSystemType Moose::stringToEnum< CoordinateSystemType > | ( | const std::string & | s | ) |
Definition at line 186 of file Conversion.C.
EigenProblemType Moose::stringToEnum< EigenProblemType > | ( | const std::string & | s | ) |
Definition at line 231 of file Conversion.C.
EigenSolveType Moose::stringToEnum< EigenSolveType > | ( | const std::string & | s | ) |
Definition at line 216 of file Conversion.C.
LineSearchType Moose::stringToEnum< LineSearchType > | ( | const std::string & | s | ) |
Definition at line 261 of file Conversion.C.
MffdType Moose::stringToEnum< MffdType > | ( | const std::string & | s | ) |
Definition at line 291 of file Conversion.C.
Order Moose::stringToEnum< Order > | ( | const std::string & | s | ) |
Definition at line 173 of file Conversion.C.
Referenced by SetupQuadratureAction::act().
QuadratureType Moose::stringToEnum< QuadratureType > | ( | const std::string & | s | ) |
Definition at line 166 of file Conversion.C.
RelationshipManagerType Moose::stringToEnum< RelationshipManagerType > | ( | const std::string & | s | ) |
Definition at line 306 of file Conversion.C.
SolveType Moose::stringToEnum< SolveType > | ( | const std::string & | s | ) |
Definition at line 201 of file Conversion.C.
TimeIntegratorType Moose::stringToEnum< TimeIntegratorType > | ( | const std::string & | s | ) |
Definition at line 276 of file Conversion.C.
WhichEigenPairs Moose::stringToEnum< WhichEigenPairs > | ( | const std::string & | s | ) |
Definition at line 246 of file Conversion.C.
MPI_Comm Moose::swapLibMeshComm | ( | MPI_Comm | new_comm | ) |
Swap the libMesh MPI communicator out for ours.
Note that you should usually use the Moose::ScopedCommSwapper class instead of calling this function.
Definition at line 622 of file Moose.C.
Referenced by Moose::ScopedCommSwapper::forceSwap(), and Moose::ScopedCommSwapper::~ScopedCommSwapper().
void Moose::to_json | ( | nlohmann::json & | json, |
const Moose::LibtorchArtificialNeuralNet *const & | network | ||
) |
Definition at line 140 of file LibtorchArtificialNeuralNet.C.
Referenced by JSONOutput::outputSystemInformation(), ReporterContext< std::vector< T > >::store(), and RestartableData< std::list< T > >::storeJSONValue().
bool Moose::toBool | ( | const std::string & | , |
T & | |||
) |
Definition at line 1343 of file Builder.C.
Referenced by Moose::Builder::setScalarParameter(), and toBool< bool >().
bool Moose::toBool< bool > | ( | const std::string & | s, |
bool & | val | ||
) |
Point Moose::toPoint | ( | const std::vector< Real > & | pos | ) |
Convert point represented as std::vector into Point.
pos | Point represented as a vector |
Definition at line 476 of file Conversion.C.
void Moose::typeLoop | ( | TypeList< Ts... > | , |
As... | args | ||
) |
Type loop.
Definition at line 178 of file SerialAccess.h.
void Moose::typeLoopInternal | ( | TypeList< T, Ts... > | , |
As... | args | ||
) |
Type loop.
Definition at line 168 of file SerialAccess.h.
std::vector<T> Moose::vectorStringsToEnum | ( | const MultiMooseEnum & | v | ) |
|
static |
Definition at line 629 of file Moose.C.
Referenced by colorConsole(), and setColorConsole().
bool Moose::_deprecated_is_error = false |
Variable to toggle only deprecated warnings as errors.
Definition at line 645 of file Moose.C.
Referenced by moose::internal::mooseDeprecatedStream(), and MooseApp::setupOptions().
bool Moose::_throw_on_error = false |
Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or when about to perform threaded operations because exception throwing in threaded regions is safe while aborting is inherently not when singletons are involved (e.g.
what thread is responsible for destruction, or what do you do about mutexes?)
Definition at line 646 of file Moose.C.
Referenced by moose::internal::mooseErrorRaw(), MooseServer::parseDocumentForDiagnostics(), CommandLine::setArgument(), ThreadedFaceLoop< RangeType >::ThreadedFaceLoop(), and ThreadedFaceLoop< RangeType >::~ThreadedFaceLoop().
bool Moose::_throw_on_warning = false |
Variable to turn on exceptions during mooseWarning(), should only be used in MOOSE unit tests.
Definition at line 647 of file Moose.C.
Referenced by moose::internal::mooseUnusedStream(), and moose::internal::mooseWarningStream().
bool Moose::_trap_fpe |
Variable indicating whether we will enable FPE trapping for this run.
bool Moose::_warnings_are_errors = false |
Variable to toggle any warning into an error (includes deprecated code warnings)
Definition at line 644 of file Moose.C.
Referenced by moose::internal::mooseWarningStream(), and MooseApp::setupOptions().
constexpr std::false_type Moose::always_false {} |
This is a helper variable template for cases when we want to use a default compile-time error with constexpr-based if conditions.
The templating delays the triggering of the static assertion until the template is instantiated.
Definition at line 503 of file MooseTypes.h.
const SubdomainID Moose::ANY_BLOCK_ID = libMesh::Elem::invalid_subdomain_id - 1 |
Definition at line 19 of file MooseTypes.C.
Referenced by SetupQuadratureAction::act(), InitialConditionWarehouse::addObject(), FVInitialConditionWarehouse::addObject(), BlockRestrictable::blockIDs(), BlockRestrictable::blockRestricted(), Assembly::bumpAllQRuleOrder(), Assembly::bumpVolumeQRuleOrder(), BlockRestrictable::hasBlocks(), AttribSubdomains::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), BlockRestrictable::isBlockSubset(), AttribSubdomains::isMatch(), and Assembly::qrules().
const BoundaryID Moose::ANY_BOUNDARY_ID = static_cast<BoundaryID>(-1) |
Definition at line 23 of file MooseTypes.C.
Referenced by SubProblem::checkBoundaryMatProps(), SubProblem::getMaterialPropertyBoundaryNames(), hasBoundary(), BoundaryRestrictable::hasBoundary(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), AttribBoundaries::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), BoundaryRestrictable::isBoundarySubset(), AttribBoundaries::isMatch(), ComputeUserObjectsThread::printBlockExecutionInformation(), and BoundaryRestrictable::restricted().
const SubdomainID Moose::BOUNDARY_SIDE_LOWERD_ID = libMesh::Elem::invalid_subdomain_id - 3 |
Definition at line 21 of file MooseTypes.C.
Referenced by SetupMeshCompleteAction::act(), FEProblemBase::adaptMesh(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), MooseMesh::buildLowerDMesh(), NonlinearSystemBase::checkKernelCoverage(), HFEMDirichletBC::HFEMDirichletBC(), FEProblemBase::initialAdaptMesh(), LowerDIntegratedBC::LowerDIntegratedBC(), and ThreadedElementLoopBase< ConstElemPointerRange >::operator()().
constexpr std::size_t Moose::constMaxQpsPerElem = 216 |
This is used for places where we initialize some qp-sized data structures that would end up being sized too small after the quadrature order gets bumped (dynamically in-sim).
So for these cases, we just use this constant to size those data structures overly large to accomodate rather than come up with some overkill complex mechanism for dynamically resizing them. Eventually, we may need or implement that more sophisticated mechanism and will no longer need this.
Definition at line 218 of file MooseTypes.h.
Referenced by MaterialPropertyInterface::defaultGenericMaterialProperty(), and FEProblemBase::updateMaxQps().
std::map<std::string, CoordinateSystemType> Moose::coordinate_system_type_to_enum |
Definition at line 24 of file Conversion.C.
Referenced by initCoordinateSystemType(), and stringToEnum< CoordinateSystemType >().
|
static |
This is the dimension of all vector and tensor datastructures used in MOOSE.
We enforce LIBMESH_DIM == 3 through a static assertion above. Note that lower dimensional simulations embedded in 3D space can always be requested at runtime.
Definition at line 148 of file Moose.h.
Referenced by HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), Assembly::Assembly(), Assembly::attachQRuleElem(), Assembly::attachQRuleFace(), MeshGenerator::buildDistributedMesh(), Assembly::buildFaceFE(), Assembly::buildFaceNeighborFE(), Assembly::buildFE(), Assembly::buildLowerDDualFE(), Assembly::buildLowerDFE(), MooseMesh::buildMeshBaseObject(), MeshGenerator::buildMeshBaseObject(), Assembly::buildNeighborFE(), ParsedFunctorMaterialTempl< is_ad >::buildParsedFunction(), MooseMesh::buildPRefinementAndCoarseningMaps(), MeshGenerator::buildReplicatedMesh(), MooseMesh::buildTypedMesh(), Assembly::buildVectorDualLowerDFE(), Assembly::buildVectorFaceFE(), Assembly::buildVectorFaceNeighborFE(), Assembly::buildVectorFE(), Assembly::buildVectorLowerDFE(), Assembly::buildVectorNeighborFE(), ColumnMajorMatrixTempl< Real >::ColumnMajorMatrixTempl(), Assembly::computeADFace(), Assembly::computeFaceMap(), Assembly::computeGradPhiAD(), GenericFunctionVectorMaterialTempl< is_ad >::computeQpFunctions(), ElementW1pError::computeQpIntegral(), GenericConstantVectorMaterialTempl< is_ad >::computeQpProperties(), FVAnisotropicDiffusion::computeQpResidual(), Assembly::computeSinglePointMapAD(), ParsedVectorAux::computeValue(), ArrayParsedAux::computeValue(), ElementH1ErrorFunctionAux::computeValue(), MooseVariableData< OutputType >::computeValues(), StackGenerator::computeWidth(), Assembly::createQRules(), dataLoad(), dataStore(), MooseMesh::detectOrthogonalDimRanges(), MooseMesh::detectPairedSidesets(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::diffusivityGradientProduct(), InitialConditionTempl< T >::dotHelper(), MooseMesh::effectiveSpatialDimension(), MooseVariableFE< Real >::evaluate(), IntersectionPointsAlongLine::execute(), FaceInfo::FaceInfo(), ColumnMajorMatrixTempl< Real >::fill(), MooseMesh::findAdaptivityQpMaps(), findContactPoint(), MaterialOutputAction::functorMaterialOutputHelper(), ExtraNodesetGenerator::generate(), StackGenerator::generate(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), MooseMesh::getBlocksMaxDimension(), Coupleable::getDefaultVectorValue(), Assembly::getFE(), Assembly::getFEFace(), Assembly::getFEFaceNeighbor(), Assembly::getFENeighbor(), MultiAppTransfer::getFromBoundingBoxes(), PenetrationThread::getInfoForFacesWithCommonNodes(), MultiAppGeneralFieldTransfer::getMaxToProblemsBBoxDimensions(), Assembly::getVectorFE(), Assembly::getVectorFEFace(), Assembly::getVectorFEFaceNeighbor(), Assembly::getVectorFENeighbor(), ArrayFunctionIC::gradient(), Moose::FV::greenGaussGradient(), Moose::FV::harmonicInterpolation(), MooseAppCoordTransform::hasScalingOrRotationTransformation(), Assembly::havePRefinement(), Assembly::helpersRequestData(), PropertyReadFile::initVoronoiCenterPoints(), PenetrationThread::isFaceReasonableCandidate(), MultiAppCoordTransform::isIdentity(), MooseUtils::isZero(), PointListAdaptor< Point >::kdtree_distance(), ValueCache< T >::kdtree_get_pt(), PointListAdaptor< Point >::kdtree_get_pt(), NanoflannMeshAdaptor< Dim >::kdtree_get_pt(), NanoflannMeshSubdomainAdaptor< Dim >::kdtree_get_pt(), MaterialOutputAction::materialOutputHelper(), NodalPatchRecovery::multiIndex(), MathUtils::multiIndex(), ResetDisplacedMeshThread::onNode(), SecondaryNeighborhoodThread::operator()(), ColumnMajorMatrixTempl< Real >::operator*(), ColumnMajorMatrixTempl< Real >::operator+=(), ColumnMajorMatrixTempl< Real >::operator=(), GriddedData::parse(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PenetrationLocator::PenetrationLocator(), PropertyReadFile::PropertyReadFile(), Assembly::qruleFaceHelper(), Assembly::qrules(), Assembly::reinitFE(), Assembly::reinitFEFace(), Assembly::reinitFVFace(), Assembly::reinitNeighbor(), MooseUtils::relativeFuzzyEqual(), Assembly::resizeADMappingObjects(), PiecewiseMultilinear::sampleInternal(), Assembly::setFaceQRule(), Assembly::setLowerQRule(), Assembly::setMortarQRule(), Assembly::setNeighborQRule(), SideSetsGeneratorBase::setup(), Assembly::setVolumeQRule(), sideIntersectedByLine(), MultiIndex< Real >::slice(), MultiApp::transformBoundingBox(), MortarData::update(), BoundingBoxIC::value(), MeshBaseImageSampler::vtkFlip(), Assembly::~Assembly(), and PenetrationLocator::~PenetrationLocator().
std::map<std::string, EigenProblemType> Moose::eigen_problem_type_to_enum |
Definition at line 27 of file Conversion.C.
Referenced by initEigenProlemType(), and stringToEnum< EigenProblemType >().
std::map<std::string, EigenSolveType> Moose::eigen_solve_type_to_enum |
Definition at line 26 of file Conversion.C.
Referenced by initEigenSolveType(), and stringToEnum< EigenSolveType >().
const std::set<SubdomainID> Moose::EMPTY_BLOCK_IDS = {} |
Definition at line 596 of file MooseTypes.h.
const std::set<BoundaryID> Moose::EMPTY_BOUNDARY_IDS = {} |
Definition at line 597 of file MooseTypes.h.
ExecFlagEnum Moose::execute_flags |
Storage for the registered execute flags.
This is needed for the ExecuteMooseObjectWarehouse to create the necessary storage containers on a per flag basis. This isn't something that should be used by application developers.
Referenced by InputParameters::declareControllable(), and groupUserObjects().
const SubdomainID Moose::INTERNAL_SIDE_LOWERD_ID = libMesh::Elem::invalid_subdomain_id - 2 |
Definition at line 20 of file MooseTypes.C.
Referenced by SetupMeshCompleteAction::act(), FEProblemBase::adaptMesh(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), MooseMesh::buildLowerDMesh(), NonlinearSystemBase::checkKernelCoverage(), BlockRestrictable::checkVariable(), ComputeFullJacobianThread::computeOnInternalFace(), DGLowerDKernel::DGLowerDKernel(), FEProblemBase::initialAdaptMesh(), ThreadedElementLoopBase< ConstElemPointerRange >::operator()(), DisplacedProblem::reinitElemNeighborAndLowerD(), and FEProblemBase::reinitElemNeighborAndLowerD().
int Moose::interrupt_signal_number = 0 |
Used by the signal handler to determine if we should write a checkpoint file out at any point during operation.
Definition at line 648 of file Moose.C.
Referenced by Output::outputStep(), Checkpoint::shouldOutput(), and SigHandler().
const SubdomainID Moose::INVALID_BLOCK_ID = libMesh::Elem::invalid_subdomain_id |
Definition at line 22 of file MooseTypes.C.
Referenced by FunctorDirichletBC::computeQpValue(), MultiAppGeometricInterpolationTransfer::computeTransformation(), FunctorAux::computeValue(), SubdomainsDivision::divisionIndex(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), BlockToMeshConverterGenerator::generate(), RenameBlockGenerator::generate(), XYMeshLineCutter::generate(), XYDelaunayGenerator::generate(), MooseMeshUtils::getSubdomainID(), MooseMeshUtils::hasSubdomainID(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), AttribSubdomains::isMatch(), FaceInfo::neighborSubdomainID(), ComputeJacobianForScalingThread::operator()(), ThreadedElementLoopBase< ConstElemPointerRange >::operator()(), ComputeLinearFVElementalThread::operator()(), ComputeLinearFVFaceThread::operator()(), ThreadedFaceLoop< RangeType >::operator()(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttribMatrixTags >::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttribMatrixTags >::printBoundaryExecutionInformation(), MooseMeshXYCuttingUtils::quadToTriOnLine(), and MooseMeshXYCuttingUtils::quasiTriElementsFixer().
const BoundaryID Moose::INVALID_BOUNDARY_ID = libMesh::BoundaryInfo::invalid_id |
Definition at line 24 of file MooseTypes.C.
Referenced by BreakMeshByBlockGenerator::addInterfaceBoundary(), MultiAppNearestNodeTransfer::execute(), RenameBoundaryGenerator::generate(), BreakMeshByBlockGenerator::generate(), RefineSidesetGenerator::generate(), BreakMeshByElementGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), PatternedMeshGenerator::generate(), MooseMeshUtils::getBoundaryID(), MooseMeshUtils::hasBoundaryID(), SideSetsGeneratorBase::setup(), and XYMeshLineCutter::XYMeshLineCutter().
const processor_id_type Moose::INVALID_PROCESSOR_ID = libMesh::DofObject::invalid_processor_id |
Definition at line 18 of file MooseTypes.C.
Definition at line 25 of file MooseTypes.C.
Referenced by MooseVariableDataBase< OutputType >::assignNodalValue().
Definition at line 26 of file MooseTypes.C.
std::map<std::string, LineSearchType> Moose::line_search_type_to_enum |
Definition at line 29 of file Conversion.C.
Referenced by initLineSearchType(), and stringToEnum< LineSearchType >().
std::map<std::string, MffdType> Moose::mffd_type_to_enum |
Definition at line 31 of file Conversion.C.
Referenced by initMffdType(), and stringToEnum< MffdType >().
const TagName Moose::OLD_SOLUTION_TAG = "SOLUTION_STATE_1" |
Definition at line 28 of file MooseTypes.C.
Referenced by SystemBase::oldSolutionStateVectorName(), Coupleable::requestStates(), and MooseVariableDataBase< OutputType >::stateToTagHelper().
const TagName Moose::OLDER_SOLUTION_TAG = "SOLUTION_STATE_2" |
Definition at line 29 of file MooseTypes.C.
Referenced by SystemBase::oldSolutionStateVectorName(), Coupleable::requestStates(), and MooseVariableDataBase< OutputType >::stateToTagHelper().
PerfLog Moose::perf_log |
Perflog to be used by applications.
If the application prints this in the end they will get performance info.
This is no longer instantiated in the framework and will be removed in the future.
const TagName Moose::PREVIOUS_NL_SOLUTION_TAG = "U_PREVIOUS_NL_NEWTON" |
Definition at line 30 of file MooseTypes.C.
Referenced by FEProblemBase::computePostCheck(), FEProblemBase::needsPreviousNewtonIteration(), SystemBase::oldSolutionStateVectorName(), NonlinearSystemBase::setPreviousNewtonSolution(), SystemBase::solutionPreviousNewton(), and MooseVariableDataBase< OutputType >::stateToTagHelper().
std::map<std::string, RelationshipManagerType> Moose::rm_type_to_enum |
Definition at line 32 of file Conversion.C.
Referenced by initRMType(), and stringToEnum< RelationshipManagerType >().
bool Moose::show_multiple = false |
bool Moose::show_trace = true |
Set to true (the default) to print the stack trace with error and warning messages - false to omit it.
Definition at line 649 of file Moose.C.
Referenced by InputParameters::attemptPrintDeprecated(), Factory::deprecatedMessage(), moose::internal::mooseDeprecatedStream(), moose::internal::mooseErrorRaw(), and MooseBaseParameterInterface::paramError().
const TagName Moose::SOLUTION_TAG = "SOLUTION" |
Definition at line 27 of file MooseTypes.C.
Referenced by FEProblemBase::createTagSolutions(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MooseVariableDataBase< OutputType >::MooseVariableDataBase(), SolverSystem::setSolution(), and MooseVariableDataBase< OutputType >::stateToTagHelper().
std::map<std::string, SolveType> Moose::solve_type_to_enum |
Definition at line 25 of file Conversion.C.
Referenced by initSolveType(), and stringToEnum< SolveType >().
std::map<std::string, TimeIntegratorType> Moose::time_integrator_to_enum |
Definition at line 30 of file Conversion.C.
Referenced by initTimeIntegratorsType(), and stringToEnum< TimeIntegratorType >().
std::map<std::string, WhichEigenPairs> Moose::which_eigen_pairs_to_enum |
Definition at line 28 of file Conversion.C.
Referenced by initWhichEigenPairs(), and stringToEnum< WhichEigenPairs >().