www.mooseframework.org
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Moose Namespace Reference

Namespaces

 PetscSupport
 
 SlepcSupport
 

Classes

struct  _enumerate_iterator
 
struct  _enumerate_range
 
struct  _enumerate_struct
 
struct  indirect_comparator
 
struct  RealType
 
struct  RealType< JACOBIAN >
 
class  ScopedCommSwapper
 
struct  ValueType
 
struct  ValueType< Real, compute_stage >
 
struct  ValueType< W< Real >, compute_stage >
 

Typedefs

typedef std::function< void(const InputParameters &, InputParameters &)> RelationshipManagerInputParameterCallback
 The type for the callback to set RelationshipManager parameters. More...
 

Enumerations

enum  MaterialDataType { BLOCK_MATERIAL_DATA, BOUNDARY_MATERIAL_DATA, FACE_MATERIAL_DATA, NEIGHBOR_MATERIAL_DATA }
 MaterialData types. More...
 
enum  AuxGroup { PRE_IC = 0, PRE_AUX = 1, POST_AUX = 2, ALL = 3 }
 Flag for AuxKernel related execution type. More...
 
enum  VarKindType { VAR_NONLINEAR, VAR_AUXILIARY, VAR_ANY }
 Framework-wide stuff. More...
 
enum  VarFieldType { VAR_FIELD_STANDARD, VAR_FIELD_SCALAR, VAR_FIELD_VECTOR, VAR_FIELD_ANY }
 
enum  CouplingType { COUPLING_DIAG, COUPLING_FULL, COUPLING_CUSTOM }
 
enum  ConstraintSideType { SIDE_MASTER, SIDE_SLAVE }
 
enum  DGResidualType { Element, Neighbor }
 
enum  DGJacobianType { ElementElement, ElementNeighbor, NeighborElement, NeighborNeighbor }
 
enum  ConstraintType { Slave = Element, Master = Neighbor }
 
enum  ConstraintJacobianType { SlaveSlave = ElementElement, SlaveMaster = ElementNeighbor, MasterSlave = NeighborElement, MasterMaster = NeighborNeighbor }
 
enum  CoordinateSystemType { COORD_XYZ, COORD_RZ, COORD_RSPHERICAL }
 
enum  PCSideType { PCS_LEFT, PCS_RIGHT, PCS_SYMMETRIC, PCS_DEFAULT }
 Preconditioning side. More...
 
enum  MooseKSPNormType {
  KSPN_NONE, KSPN_PRECONDITIONED, KSPN_UNPRECONDITIONED, KSPN_NATURAL,
  KSPN_DEFAULT
}
 Norm type for converge test. More...
 
enum  SolveType {
  ST_PJFNK, ST_JFNK, ST_NEWTON, ST_FD,
  ST_LINEAR
}
 Type of the solve. More...
 
enum  EigenSolveType {
  EST_POWER, EST_ARNOLDI, EST_KRYLOVSCHUR, EST_JACOBI_DAVIDSON,
  EST_NONLINEAR_POWER, EST_MF_NONLINEAR_POWER, EST_MONOLITH_NEWTON, EST_MF_MONOLITH_NEWTON
}
 Type of the eigen solve. More...
 
enum  EigenProblemType {
  EPT_HERMITIAN, EPT_NON_HERMITIAN, EPT_GEN_HERMITIAN, EPT_GEN_INDEFINITE,
  EPT_GEN_NON_HERMITIAN, EPT_POS_GEN_NON_HERMITIAN, EPT_SLEPC_DEFAULT
}
 Type of the eigen problem. More...
 
enum  WhichEigenPairs {
  WEP_LARGEST_MAGNITUDE, WEP_SMALLEST_MAGNITUDE, WEP_LARGEST_REAL, WEP_SMALLEST_REAL,
  WEP_LARGEST_IMAGINARY, WEP_SMALLEST_IMAGINARY, WEP_TARGET_MAGNITUDE, WEP_TARGET_REAL,
  WEP_TARGET_IMAGINARY, WEP_ALL_EIGENVALUES, WEP_SLEPC_DEFAULT
}
 Which eigen pairs. More...
 
enum  TimeIntegratorType {
  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
}
 Time integrators. More...
 
enum  ConstraintFormulationType { Penalty, Kinematic }
 Type of constraint formulation. More...
 
enum  LineSearchType {
  LS_INVALID, LS_DEFAULT, LS_NONE, LS_BASIC,
  LS_CUBIC, LS_QUADRATIC, LS_BASICNONORMS, LS_SHELL,
  LS_CONTACT, LS_L2, LS_BT, LS_CP
}
 Type of the line search. More...
 
enum  MffdType { MFFD_INVALID, MFFD_WP, MFFD_DS }
 Type of the matrix-free finite-differencing parameter. More...
 
enum  PatchUpdateType { Never, Always, Auto, Iteration }
 Type of patch update strategy for modeling node-face constraints or contact. More...
 
enum  RelationshipManagerType : unsigned char { RelationshipManagerType::DEFAULT = 0, RelationshipManagerType::GEOMETRIC = 1 << 0, RelationshipManagerType::ALGEBRAIC = 1 << 1, RelationshipManagerType::COUPLING = 1 << 2 }
 Main types of Relationship Managers. More...
 

Functions

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 registerExecFlags (Factory &factory)
 
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...
 
void findContactPoint (PenetrationInfo &p_info, FEBase *fe_elem, FEBase *fe_side, FEType &fe_side_type, const Point &slave_point, bool start_with_centroid, const Real tangential_tolerance, bool &contact_point_on_side)
 Finds the closest point (called the contact point) on the master_elem on side "side" to the slave_point. More...
 
void restrictPointToFace (Point &p, const Elem *side, std::vector< const Node *> &off_edge_nodes)
 
void initial_condition (EquationSystems &es, const std::string &system_name)
 
template<typename 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 (const SolveType &t)
 Convert solve 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...
 
template<typename T , typename U >
std::string stringify (const std::pair< T, U > &p)
 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...
 
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...
 
std::string stringify (const Moose::RelationshipManagerType &t)
 
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...
 
void associateSyntaxInner (Syntax &syntax, ActionFactory &action_factory)
 
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 initQuadratureType ()
 
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)
 
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)
 
int 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. 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

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() and mooseWarning(), should only be used with MOOSE unit. More...
 
ExecFlagEnum execute_flags
 Storage for the registered execute flags. More...
 
const SubdomainID ANY_BLOCK_ID = libMesh::Elem::invalid_subdomain_id - 1
 
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 std::set< SubdomainIDEMPTY_BLOCK_IDS = {}
 
const std::set< BoundaryIDEMPTY_BOUNDARY_IDS = {}
 
static bool _color_console = isatty(fileno(stdout))
 
std::map< std::string, QuadratureType > quadrature_type_to_enum
 
std::map< std::string, CoordinateSystemTypecoordinate_system_type_to_enum
 
std::map< std::string, SolveTypesolve_type_to_enum
 
std::map< std::string, EigenSolveTypeeigen_solve_type_to_enum
 
std::map< std::string, EigenProblemTypeeigen_problem_type_to_enum
 
std::map< std::string, WhichEigenPairswhich_eigen_pairs_to_enum
 
std::map< std::string, LineSearchTypeline_search_type_to_enum
 
std::map< std::string, TimeIntegratorTypetime_integrator_to_enum
 
std::map< std::string, MffdTypemffd_type_to_enum
 
std::map< std::string, RelationshipManagerTyperm_type_to_enum
 

Typedef Documentation

◆ RelationshipManagerInputParameterCallback

The type for the callback to set RelationshipManager parameters.

Definition at line 710 of file MooseTypes.h.

Enumeration Type Documentation

◆ AuxGroup

Flag for AuxKernel related execution type.

Enumerator
PRE_IC 
PRE_AUX 
POST_AUX 
ALL 

Definition at line 471 of file MooseTypes.h.

472 {
473  PRE_IC = 0,
474  PRE_AUX = 1,
475  POST_AUX = 2,
476  ALL = 3
477 };

◆ ConstraintFormulationType

Type of constraint formulation.

Enumerator
Penalty 
Kinematic 

Definition at line 645 of file MooseTypes.h.

646 {
647  Penalty,
648  Kinematic
649 };

◆ ConstraintJacobianType

◆ ConstraintSideType

Enumerator
SIDE_MASTER 
SIDE_SLAVE 

Definition at line 504 of file MooseTypes.h.

◆ ConstraintType

Enumerator
Slave 
Master 

Definition at line 524 of file MooseTypes.h.

◆ CoordinateSystemType

Enumerator
COORD_XYZ 
COORD_RZ 
COORD_RSPHERICAL 

Definition at line 538 of file MooseTypes.h.

◆ CouplingType

Enumerator
COUPLING_DIAG 
COUPLING_FULL 
COUPLING_CUSTOM 

Definition at line 497 of file MooseTypes.h.

◆ DGJacobianType

Enumerator
ElementElement 
ElementNeighbor 
NeighborElement 
NeighborNeighbor 

Definition at line 516 of file MooseTypes.h.

◆ DGResidualType

Enumerator
Element 
Neighbor 

Definition at line 510 of file MooseTypes.h.

511 {
512  Element,
513  Neighbor
514 };

◆ EigenProblemType

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 598 of file MooseTypes.h.

599 {
600  EPT_HERMITIAN,
607 };
Generalized Non-Hermitian.
Definition: MooseTypes.h:604
Generalized Hermitian indefinite.
Definition: MooseTypes.h:603
use whatever SLPEC has by default
Definition: MooseTypes.h:606
Generalized Non-Hermitian with positive (semi-)definite B.
Definition: MooseTypes.h:605
Non-Hermitian.
Definition: MooseTypes.h:601
Generalized Hermitian.
Definition: MooseTypes.h:602

◆ EigenSolveType

Type of the eigen solve.

Enumerator
EST_POWER 

Power / Inverse / RQI.

EST_ARNOLDI 

Arnoldi.

EST_KRYLOVSCHUR 

Krylov-Schur.

EST_JACOBI_DAVIDSON 

Jacobi-Davidson.

EST_NONLINEAR_POWER 

Nonlinear inverse power.

EST_MF_NONLINEAR_POWER 

Matrix-free nonlinear inverse power.

EST_MONOLITH_NEWTON 

Newton-based eigen solver.

EST_MF_MONOLITH_NEWTON 

Matrix-free Newton-based eigen solver.

Definition at line 583 of file MooseTypes.h.

584 {
585  EST_POWER,
586  EST_ARNOLDI,
593 };
Newton-based eigen solver.
Definition: MooseTypes.h:591
Matrix-free Newton-based eigen solver.
Definition: MooseTypes.h:592
Matrix-free nonlinear inverse power.
Definition: MooseTypes.h:590
Power / Inverse / RQI.
Definition: MooseTypes.h:585
Krylov-Schur.
Definition: MooseTypes.h:587
Nonlinear inverse power.
Definition: MooseTypes.h:589
Jacobi-Davidson.
Definition: MooseTypes.h:588

◆ LineSearchType

Type of the line search.

Enumerator
LS_INVALID 

means not set

LS_DEFAULT 
LS_NONE 
LS_BASIC 
LS_CUBIC 
LS_QUADRATIC 
LS_BASICNONORMS 
LS_SHELL 
LS_CONTACT 
LS_L2 
LS_BT 
LS_CP 

Definition at line 653 of file MooseTypes.h.

654 {
655  LS_INVALID,
656  LS_DEFAULT,
657  LS_NONE,
658  LS_BASIC,
659 #ifdef LIBMESH_HAVE_PETSC
660 #if PETSC_VERSION_LESS_THAN(3, 3, 0)
661  LS_CUBIC,
662  LS_QUADRATIC,
664 #else
665  LS_SHELL,
666  LS_CONTACT,
667  LS_L2,
668  LS_BT,
669  LS_CP
670 #endif
671 #endif
672 };
means not set
Definition: MooseTypes.h:655

◆ MaterialDataType

MaterialData types.

See also
FEProblemBase, MaterialPropertyInterface
Enumerator
BLOCK_MATERIAL_DATA 
BOUNDARY_MATERIAL_DATA 
FACE_MATERIAL_DATA 
NEIGHBOR_MATERIAL_DATA 

Definition at line 460 of file MooseTypes.h.

◆ MffdType

Type of the matrix-free finite-differencing parameter.

Enumerator
MFFD_INVALID 

means not set

MFFD_WP 
MFFD_DS 

Definition at line 677 of file MooseTypes.h.

678 {
679  MFFD_INVALID,
680  MFFD_WP,
681  MFFD_DS
682 };
means not set
Definition: MooseTypes.h:679

◆ MooseKSPNormType

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 559 of file MooseTypes.h.

◆ PatchUpdateType

Type of patch update strategy for modeling node-face constraints or contact.

Enumerator
Never 
Always 
Auto 
Iteration 

Definition at line 687 of file MooseTypes.h.

688 {
689  Never,
690  Always,
691  Auto,
692  Iteration
693 };

◆ PCSideType

Preconditioning side.

Enumerator
PCS_LEFT 
PCS_RIGHT 
PCS_SYMMETRIC 
PCS_DEFAULT 

Use whatever we have in PETSc.

Definition at line 548 of file MooseTypes.h.

549 {
550  PCS_LEFT,
551  PCS_RIGHT,
553  PCS_DEFAULT
554 };
Use whatever we have in PETSc.
Definition: MooseTypes.h:553

◆ RelationshipManagerType

enum Moose::RelationshipManagerType : unsigned char
strong

Main types of Relationship Managers.

Enumerator
DEFAULT 
GEOMETRIC 
ALGEBRAIC 
COUPLING 

Definition at line 698 of file MooseTypes.h.

◆ SolveType

Type of the solve.

Enumerator
ST_PJFNK 

Preconditioned Jacobian-Free Newton Krylov.

ST_JFNK 

Jacobian-Free Newton Krylov.

ST_NEWTON 

Full Newton Solve.

ST_FD 

Use finite differences to compute Jacobian.

ST_LINEAR 

Solving a linear problem.

Definition at line 571 of file MooseTypes.h.

572 {
573  ST_PJFNK,
574  ST_JFNK,
575  ST_NEWTON,
576  ST_FD,
577  ST_LINEAR
578 };
Full Newton Solve.
Definition: MooseTypes.h:575
Solving a linear problem.
Definition: MooseTypes.h:577
Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:574
Use finite differences to compute Jacobian.
Definition: MooseTypes.h:576
Preconditioned Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:573

◆ TimeIntegratorType

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 630 of file MooseTypes.h.

◆ VarFieldType

Enumerator
VAR_FIELD_STANDARD 
VAR_FIELD_SCALAR 
VAR_FIELD_VECTOR 
VAR_FIELD_ANY 

Definition at line 489 of file MooseTypes.h.

◆ VarKindType

Framework-wide stuff.

Enumerator
VAR_NONLINEAR 
VAR_AUXILIARY 
VAR_ANY 

Definition at line 482 of file MooseTypes.h.

◆ WhichEigenPairs

Which eigen pairs.

Enumerator
WEP_LARGEST_MAGNITUDE 

largest magnitude

WEP_SMALLEST_MAGNITUDE 

smallest magnitude

WEP_LARGEST_REAL 

largest real

WEP_SMALLEST_REAL 

smallest real

WEP_LARGEST_IMAGINARY 

largest imaginary

WEP_SMALLEST_IMAGINARY 

smallest imaginary

WEP_TARGET_MAGNITUDE 

target magnitude

WEP_TARGET_REAL 

target real

WEP_TARGET_IMAGINARY 

target imaginary

WEP_ALL_EIGENVALUES 

all eigenvalues

WEP_SLEPC_DEFAULT 

use whatever we have in SLEPC

Definition at line 612 of file MooseTypes.h.

Function Documentation

◆ addActionTypes()

void Moose::addActionTypes ( Syntax syntax)

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 74 of file Moose.C.

Referenced by associateSyntaxInner().

75 {
88  // clang-format off
89  /**************************/
90  /**** Register Actions ****/
91  /**************************/
92  registerMooseObjectTask("create_problem", Problem, false);
93  registerMooseObjectTask("setup_executioner", Executioner, false);
94 
95  // This task does not construct an object, but it needs all of the parameters that
96  // would normally be used to construct an object.
97  registerMooseObjectTask("determine_system_type", Executioner, true);
98 
99  registerMooseObjectTask("setup_mesh", MooseMesh, false);
100  registerMooseObjectTask("set_mesh_base", MooseMesh, false);
101  registerMooseObjectTask("init_mesh", MooseMesh, false);
102  registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
103  registerMooseObjectTask("add_mesh_generator", MeshGenerator, false);
104 
105  registerMooseObjectTask("add_kernel", Kernel, false);
106  appendMooseObjectTask ("add_kernel", EigenKernel);
107  appendMooseObjectTask ("add_kernel", VectorKernel);
108 
109  registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
110 
111  registerMooseObjectTask("add_material", Material, false);
112  registerMooseObjectTask("add_bc", BoundaryCondition, false);
113 
114  registerMooseObjectTask("add_function", Function, false);
115  registerMooseObjectTask("add_distribution", Distribution, false);
116  registerMooseObjectTask("add_sampler", Sampler, false);
117 
118  registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
119  appendMooseObjectTask ("add_aux_kernel", VectorAuxKernel);
120  registerMooseObjectTask("add_elemental_field_variable", AuxKernel, false);
121 
122  registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
123  registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
124  registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
125  registerMooseObjectTask("add_dg_kernel", DGKernel, false);
126  registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
127  registerMooseObjectTask("add_constraint", Constraint, false);
128 
129  registerMooseObjectTask("add_ic", InitialCondition, false);
130  appendMooseObjectTask ("add_ic", ScalarInitialCondition);
131 
132  registerMooseObjectTask("add_damper", Damper, false);
133  registerMooseObjectTask("setup_predictor", Predictor, false);
134  registerMooseObjectTask("setup_time_stepper", TimeStepper, false);
135  registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
136 
137  registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
138  registerMooseObjectTask("add_field_split", Split, false);
139 
140  registerMooseObjectTask("add_user_object", UserObject, false);
141  appendMooseObjectTask ("add_user_object", Postprocessor);
142 
143  registerMooseObjectTask("add_postprocessor", Postprocessor, false);
144  registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
145 
146  registerMooseObjectTask("add_indicator", Indicator, false);
147  registerMooseObjectTask("add_marker", Marker, false);
148 
149  registerMooseObjectTask("add_multi_app", MultiApp, false);
150  registerMooseObjectTask("add_transfer", Transfer, false);
151 
152  registerMooseObjectTask("add_output", Output, false);
153 
154  registerMooseObjectTask("add_control", Control, false);
155  registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
156 
157  // clang-format on
158 
159  registerTask("dynamic_object_registration", false);
160  registerTask("common_output", true);
161  registerTask("setup_recover_file_base", true);
162 
163  registerTask("add_bounds_vectors", false);
164  registerTask("add_periodic_bc", false);
165  registerTask("add_aux_variable", false);
166  registerTask("add_external_aux_variables", true);
167  registerTask("add_variable", false);
168 
169  registerTask("execute_mesh_modifiers", false);
170  registerTask("execute_mesh_generators", true);
171  registerTask("uniform_refine_mesh", false);
172  registerTask("prepare_mesh", false);
173  registerTask("delete_remote_elements_post_equation_systems_init", false);
174  registerTask("setup_mesh_complete", true); // calls prepare
175  registerTask("add_geometric_rm", false);
176  registerTask("attach_geometric_rm", true);
177 
178  registerTask("init_displaced_problem", false);
179 
180  registerTask("add_algebraic_rm", false);
181  registerTask("attach_algebraic_rm", true);
182  registerTask("init_problem", true);
183  registerTask("check_copy_nodal_vars", true);
184  registerTask("copy_nodal_vars", true);
185  registerTask("copy_nodal_aux_vars", true);
186  registerTask("setup_postprocessor_data", false);
187 
188  registerTask("setup_dampers", true);
189  registerTask("check_integrity", true);
190  registerTask("check_integrity_early", true);
191  registerTask("setup_quadrature", true);
192 
194  registerTask("no_action", false); // Used for Empty Action placeholders
195  registerTask("set_global_params", false);
196  registerTask("setup_adaptivity", false);
197  registerTask("meta_action", false);
198  registerTask("setup_residual_debug", false);
199  registerTask("setup_oversampling", false);
200  registerTask("deprecated_block", false);
201  registerTask("set_adaptivity_options", false);
202  registerTask("add_mortar_interface", false);
203 
204  // Dummy Actions (useful for sync points in the dependencies)
205  registerTask("setup_function_complete", false);
206  registerTask("setup_variable_complete", false);
207  registerTask("ready_to_init", true);
208  appendMooseObjectTask("ready_to_init", InterfaceKernel);
209  appendMooseObjectTask("ready_to_init", DGKernel);
210 
211  // Output related actions
212  registerTask("add_output_aux_variables", true);
213  registerTask("check_output", true);
214 
215  registerTask("create_problem_default", true);
216  registerTask("create_problem_custom", false);
217  registerTask("create_problem_complete", false);
218 
219  /**************************/
220  /****** Dependencies ******/
221  /**************************/
231  syntax.addDependencySets("(meta_action)"
232  "(dynamic_object_registration)"
233  "(common_output)"
234  "(set_global_params)"
235  "(setup_recover_file_base)"
236  "(setup_mesh)"
237  "(add_mesh_generator)"
238  "(execute_mesh_generators)"
239  "(set_mesh_base)"
240  "(check_copy_nodal_vars)"
241  "(add_partitioner)"
242  "(add_geometric_rm)"
243  "(attach_geometric_rm)"
244  "(init_mesh)"
245  "(prepare_mesh)"
246  "(add_mesh_modifier)"
247  "(execute_mesh_modifiers)"
248  "(add_mortar_interface)"
249  "(uniform_refine_mesh)"
250  "(setup_mesh_complete)"
251  "(determine_system_type)"
252  "(create_problem)"
253  "(create_problem_custom)"
254  "(create_problem_default)"
255  "(create_problem_complete)"
256  "(setup_postprocessor_data)"
257  "(setup_time_integrator)"
258  "(setup_executioner)"
259  "(check_integrity_early)"
260  "(setup_predictor)"
261  "(init_displaced_problem)"
262  "(add_aux_variable, add_variable, add_elemental_field_variable,"
263  " add_external_aux_variables)"
264  "(setup_variable_complete)"
265  "(setup_quadrature)"
266  "(add_function)"
267  "(add_distribution)"
268  "(add_sampler)"
269  "(add_periodic_bc)"
270  "(add_user_object)"
271  "(setup_function_complete)"
272  "(setup_adaptivity)"
273  "(set_adaptivity_options)"
274  "(add_ic)"
275  "(add_constraint, add_field_split)"
276  "(add_preconditioning)"
277  "(setup_time_stepper)"
278  "(ready_to_init)"
279  "(setup_dampers)"
280  "(setup_residual_debug)"
281  "(add_bounds_vectors)"
282  "(add_multi_app)"
283  "(add_transfer)"
284  "(copy_nodal_vars, copy_nodal_aux_vars)"
285  "(add_material)"
286  "(add_output_aux_variables)"
287  "(add_algebraic_rm)"
288  "(attach_algebraic_rm)"
289  "(init_problem)"
290  "(delete_remote_elements_post_equation_systems_init)"
291  "(add_output)"
292  "(add_postprocessor)"
293  "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
294  // to be after material objects are created.
295  "(add_aux_kernel, add_bc, add_damper, add_dirac_kernel, add_kernel,"
296  " add_nodal_kernel, add_dg_kernel, add_interface_kernel,"
297  " add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker)"
298  "(add_control)"
299  "(check_output)"
300  "(check_integrity)");
301 }
Base class for function objects.
Definition: Function.h:41
Base class for split-based preconditioners.
Definition: Split.h:30
This is the base class for Samplers.
Definition: Sampler.h:41
Base class for predictors.
Definition: Predictor.h:34
This is a template class that implements the workhorse compute and computeNodal methods.
Base class for all Constraint types.
Definition: Constraint.h:39
Class that hold the whole problem being solved.
Definition: Problem.h:25
Definition: Marker.h:40
MeshModifiers are objects that can modify or add to an existing mesh.
Definition: MeshModifier.h:26
Base class for time stepping.
Definition: TimeStepper.h:27
All Distributions should inherit from this class.
Definition: Distribution.h:23
Base class for MOOSE preconditioners.
Based class for output objects.
Definition: Output.h:42
The DGKernel class is responsible for calculating the residuals for various physics on internal sides...
Definition: DGKernel.h:24
Base class for making kernels that work on auxiliary scalar variables.
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:75
Executioners are objects that do the actual work of solving your problem.
Definition: Executioner.h:33
Base class for all Postprocessors.
Definition: Postprocessor.h:30
The behavior of this kernel is controlled by one problem-wise global parameter eigen_on_current - boo...
Definition: EigenKernel.h:29
InterfaceKernel is responsible for interfacing physics across subdomains.
InitialConditions are objects that set the initial value of variables.
void addDependencySets(const std::string &action_sets)
Adds all dependencies in a single call.
Definition: Syntax.C:64
Materials compute MaterialProperties.
Definition: Material.h:47
Base class for creating new types of boundary conditions.
Base class for time integrators.
Base class for Control objects.
Definition: Control.h:38
Base class for MOOSE partitioner.
Base class for deriving dampers.
Definition: Damper.h:30
Definition: Kernel.h:21
Base class for creating new auxiliary kernels and auxiliary boundary conditions.
Definition: AuxKernel.h:34
Base class for creating new types of boundary conditions.
Definition: NodalKernel.h:49
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:58
Base class for Postprocessors that produce a vector of values.
MeshGenerators are objects that can modify or add to an existing mesh.
Definition: MeshGenerator.h:31
A DiracKernel is used when you need to add contributions to the residual by means of multiplying some...
Definition: DiracKernel.h:46
Base class for user-specific data.
Definition: UserObject.h:38
Base class for all Transfer objects.
Definition: Transfer.h:41

◆ applyIndices()

template<typename T >
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 109 of file IndirectSort.h.

Referenced by MaterialVectorPostprocessor::sortVecs().

110 {
111  T tmp;
112  tmp.resize(container.size());
113  for (size_t i = 0; i < indices.size(); i++)
114  tmp[i] = container[indices[i]];
115  std::swap(tmp, container);
116 }
X_global swap(X_sys)

◆ assemble_matrix()

void Moose::assemble_matrix ( EquationSystems &  es,
const std::string &  system_name 
)

Definition at line 33 of file NonlinearEigenSystem.C.

Referenced by NonlinearEigenSystem::NonlinearEigenSystem().

34 {
35  EigenProblem * p = es.parameters.get<EigenProblem *>("_eigen_problem");
36  EigenSystem & eigen_system = es.get_system<EigenSystem>(system_name);
38 
39  // If it is a linear generalized eigenvalue problem,
40  // we assemble A and B together
41  if (!p->isNonlinearEigenvalueSolver() && eigen_system.generalized())
42  {
43  p->computeJacobianAB(*eigen_system.current_local_solution.get(),
44  *eigen_system.matrix_A,
45  *eigen_system.matrix_B,
46  eigen_nl.nonEigenMatrixTag(),
47  eigen_nl.eigenMatrixTag());
48  return;
49  }
50 
52  {
53  p->computeJacobianTag(*eigen_system.current_local_solution.get(),
54  *eigen_system.matrix_A,
55  eigen_nl.nonEigenMatrixTag());
56  }
57  else
58  {
59  Mat petsc_mat_A = static_cast<PetscMatrix<Number> &>(*eigen_system.matrix_A).mat();
60 
61  PetscObjectComposeFunction((PetscObject)petsc_mat_A,
62  "formJacobian",
64  PetscObjectComposeFunction((PetscObject)petsc_mat_A,
65  "formFunction",
67 
68  PetscObjectComposeFunction((PetscObject)petsc_mat_A,
69  "formFunctionAB",
71 
72  PetscContainer container;
73  PetscContainerCreate(eigen_system.comm().get(), &container);
74  PetscContainerSetPointer(container, p);
75  PetscObjectCompose((PetscObject)petsc_mat_A, "formJacobianCtx", nullptr);
76  PetscObjectCompose((PetscObject)petsc_mat_A, "formJacobianCtx", (PetscObject)container);
77  PetscObjectCompose((PetscObject)petsc_mat_A, "formFunctionCtx", nullptr);
78  PetscObjectCompose((PetscObject)petsc_mat_A, "formFunctionCtx", (PetscObject)container);
79  PetscContainerDestroy(&container);
80 
81  // Let libmesh do not close matrices before solve
82  eigen_system.eigen_solver->set_close_matrix_before_solve(false);
83  }
84  if (eigen_system.generalized())
85  {
86  if (eigen_system.matrix_B)
87  {
89  {
90  p->computeJacobianTag(*eigen_system.current_local_solution.get(),
91  *eigen_system.matrix_B,
92  eigen_nl.eigenMatrixTag());
93  }
94  else
95  {
96  Mat petsc_mat_B = static_cast<PetscMatrix<Number> &>(*eigen_system.matrix_B).mat();
97 
98  PetscObjectComposeFunction((PetscObject)petsc_mat_B,
99  "formJacobian",
101  PetscObjectComposeFunction((PetscObject)petsc_mat_B,
102  "formFunction",
104 
105  PetscContainer container;
106  PetscContainerCreate(eigen_system.comm().get(), &container);
107  PetscContainerSetPointer(container, p);
108  PetscObjectCompose((PetscObject)petsc_mat_B, "formFunctionCtx", nullptr);
109  PetscObjectCompose((PetscObject)petsc_mat_B, "formFunctionCtx", (PetscObject)container);
110  PetscObjectCompose((PetscObject)petsc_mat_B, "formJacobianCtx", nullptr);
111  PetscObjectCompose((PetscObject)petsc_mat_B, "formJacobianCtx", (PetscObject)container);
112  PetscContainerDestroy(&container);
113  }
114  }
115  else
116  mooseError("It is a generalized eigenvalue problem but matrix B is empty\n");
117  }
118 }
Nonlinear eigenvalue system to be solved.
virtual bool isNonlinearEigenvalueSolver()
Definition: EigenProblem.C:243
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
PetscErrorCode mooseSlepcEigenFormJacobianB(SNES snes, Vec x, Mat jac, Mat pc, void *ctx)
Definition: SlepcSupport.C:483
PetscErrorCode mooseSlepcEigenFormFunctionAB(SNES snes, Vec x, Vec Ax, Vec Bx, void *ctx)
Definition: SlepcSupport.C:538
PetscErrorCode mooseSlepcEigenFormFunctionA(SNES snes, Vec x, Vec r, void *ctx)
Definition: SlepcSupport.C:514
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62
PetscErrorCode mooseSlepcEigenFormJacobianA(SNES snes, Vec x, Mat jac, Mat pc, void *ctx)
Definition: SlepcSupport.C:471
PetscErrorCode mooseSlepcEigenFormFunctionB(SNES snes, Vec x, Vec r, void *ctx)
Definition: SlepcSupport.C:526
Problem for solving eigenvalue problems.
Definition: EigenProblem.h:26
NonlinearEigenSystem & getNonlinearEigenSystem()
Definition: EigenProblem.h:45
virtual void computeJacobianAB(const NumericVector< Number > &soln, SparseMatrix< Number > &jacobianA, SparseMatrix< Number > &jacobianB, TagID tagA, TagID tagB)
Form two Jacobian matrices, whre each is associateed with one tag, through one element-loop.
Definition: EigenProblem.C:134
virtual void computeJacobianTag(const NumericVector< Number > &soln, SparseMatrix< Number > &jacobian, TagID tag) override
Form a Jacobian matrix for all kernels and BCs with a given tag.
Definition: EigenProblem.C:112

◆ associateSyntax()

void Moose::associateSyntax ( Syntax syntax,
ActionFactory action_factory 
)

Definition at line 510 of file Moose.C.

511 {
512  associateSyntaxInner(syntax, action_factory);
513  registerActions(syntax, action_factory);
514 }
void registerActions(Syntax &syntax, ActionFactory &action_factory)
Multiple Action class can be associated with a single input file section, in which case all associate...
Definition: Moose.C:332
void associateSyntaxInner(Syntax &syntax, ActionFactory &action_factory)
Definition: Moose.C:369

◆ associateSyntaxInner()

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 369 of file Moose.C.

Referenced by associateSyntax(), and registerAll().

370 {
376  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
377  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
378  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
379  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
380 
381  registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
382  registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
383  registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
384  registerSyntaxTask("AddKernelAction", "Bounds/*", "add_aux_kernel");
385 
386  registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
387  registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
388 
389  registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
390 
391  registerSyntax("CreateProblemAction", "Problem");
392  registerSyntax("DynamicObjectRegistrationAction", "Problem");
393 
394  registerSyntax("SetupMeshAction", "Mesh");
395  registerSyntax("SetupMeshCompleteAction", "Mesh");
396  registerSyntax("CreateDisplacedProblemAction", "Mesh");
397  registerSyntax("DisplayGhostingAction", "Mesh");
398 
399  registerSyntax("AddMeshModifierAction", "MeshModifiers/*");
400  registerSyntax("AddMeshGeneratorAction", "MeshGenerators/*");
401  registerSyntax("AddMortarInterfaceAction", "Mesh/MortarInterfaces/*");
402 
403  registerSyntax("AddFunctionAction", "Functions/*");
404  syntax.registerSyntaxType("Functions/*", "FunctionName");
405 
406  registerSyntax("GlobalParamsAction", "GlobalParams");
407 
408  registerSyntax("AddDistributionAction", "Distributions/*");
409  registerSyntax("AddSamplerAction", "Samplers/*");
410 
411  registerSyntax("SetupDebugAction", "Debug");
412  registerSyntax("SetupResidualDebugAction", "Debug");
413 
415  registerSyntax("AddVariableAction", "Variables/*");
416  syntax.registerSyntaxType("Variables/*", "VariableName");
417  syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
418 
419  registerSyntax("AddICAction", "Variables/*/InitialCondition");
420 
421  registerSyntax("AddAuxVariableAction", "AuxVariables/*");
422  syntax.registerSyntaxType("AuxVariables/*", "VariableName");
423  syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
424 
425  registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
426 
427  registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
428  registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
429 
430  registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
431 
432  registerSyntax("AddMaterialAction", "Materials/*");
433 
434  registerSyntax("SetupPostprocessorDataAction", "Postprocessors/*");
435  registerSyntax("AddPostprocessorAction", "Postprocessors/*");
436  syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
437  syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
438 
439  registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
440  syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
441 
442  registerSyntax("AddDamperAction", "Dampers/*");
443 
444  registerSyntax("AddOutputAction", "Outputs/*");
445  registerSyntax("CommonOutputAction", "Outputs");
446  syntax.registerSyntaxType("Outputs/*", "OutputName");
447 
448  // Note: Preconditioner Actions will be built by this setup action
449  registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
450  registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
451 
452  registerSyntax("CreateExecutionerAction", "Executioner");
453  registerSyntax("SetupTimeStepperAction", "Executioner/TimeStepper");
454  registerSyntax("SetupTimeIntegratorAction", "Executioner/TimeIntegrator");
455 
456  registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
457  registerSyntax("SetupPredictorAction", "Executioner/Predictor");
458 #ifdef LIBMESH_ENABLE_AMR
459  registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
460 #endif
461 
462  registerSyntax("PartitionerAction", "Mesh/Partitioner");
463 
464  registerSyntax("AddDiracKernelAction", "DiracKernels/*");
465 
466  registerSyntax("AddDGKernelAction", "DGKernels/*");
467 
468  registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
469 
470  registerSyntax("AddConstraintAction", "Constraints/*");
471 
472  registerSyntax("AddUserObjectAction", "UserObjects/*");
473  syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
474  registerSyntax("AddControlAction", "Controls/*");
475  registerSyntax("AddBoundsVectorsAction", "Bounds");
476 
477  registerSyntax("AddNodalNormalsAction", "NodalNormals");
478 
479  // Indicator
480  registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
481  registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
482  syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
483 
484  // Marker
485  registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
486  registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
487  syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
488 
489  // New Adaptivity System
490  registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
491 
492  // Deprecated Block
493  registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
494 
495  // Multi Apps
496  registerSyntax("AddMultiAppAction", "MultiApps/*");
497  syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
498 
499  // Transfers
500  registerSyntax("AddTransferAction", "Transfers/*");
501 
502  // Material derivative test
503  registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
504  registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");
505 
506  addActionTypes(syntax);
507 }
void registerSyntaxType(const std::string &syntax, const std::string &type)
Register a type with a block.
Definition: Syntax.C:298
void addActionTypes(Syntax &syntax)
Definition: Moose.C:74

◆ colorConsole()

bool Moose::colorConsole ( )

Returns whether Console coloring is turned on (default: true).

Definition at line 538 of file Moose.C.

539 {
540  return _color_console;
541 }
static bool _color_console
Definition: Moose.C:535

◆ compute_bounds()

void Moose::compute_bounds ( NumericVector< Number > &  lower,
NumericVector< Number > &  upper,
NonlinearImplicitSystem &  sys 
)

Definition at line 38 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

41 {
42  FEProblemBase * p =
43  sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
44  p->computeBounds(sys, lower, upper);
45 }
virtual void computeBounds(NonlinearImplicitSystem &sys, NumericVector< Number > &lower, NumericVector< Number > &upper)
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62

◆ compute_jacobian()

void Moose::compute_jacobian ( const NumericVector< Number > &  soln,
SparseMatrix< Number > &  jacobian,
NonlinearImplicitSystem &  sys 
)

Definition at line 28 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem(), and NonlinearSystem::setupColoringFiniteDifferencedPreconditioner().

31 {
32  FEProblemBase * p =
33  sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
34  p->computeJacobianSys(sys, soln, jacobian);
35 }
virtual void computeJacobianSys(NonlinearImplicitSystem &sys, const NumericVector< Number > &soln, SparseMatrix< Number > &jacobian)
Form a Jacobian matrix.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62

◆ compute_nearnullspace()

void Moose::compute_nearnullspace ( std::vector< NumericVector< Number > *> &  sp,
NonlinearImplicitSystem &  sys 
)

Definition at line 65 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

66 {
67  FEProblemBase * p =
68  sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
69  p->computeNearNullSpace(sys, sp);
70 }
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62
virtual void computeNearNullSpace(NonlinearImplicitSystem &sys, std::vector< NumericVector< Number > *> &sp)

◆ compute_nullspace()

void Moose::compute_nullspace ( std::vector< NumericVector< Number > *> &  sp,
NonlinearImplicitSystem &  sys 
)

Definition at line 48 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

49 {
50  FEProblemBase * p =
51  sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
52  p->computeNullSpace(sys, sp);
53 }
virtual void computeNullSpace(NonlinearImplicitSystem &sys, std::vector< NumericVector< Number > *> &sp)
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62

◆ compute_postcheck()

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 73 of file NonlinearSystem.C.

Referenced by NonlinearSystem::solve().

79 {
80  FEProblemBase * p =
81  sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
83  sys, old_soln, search_direction, new_soln, changed_search_direction, changed_new_soln);
84 }
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62
virtual void computePostCheck(NonlinearImplicitSystem &sys, const NumericVector< Number > &old_soln, NumericVector< Number > &search_direction, NumericVector< Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln)

◆ compute_transpose_nullspace()

void Moose::compute_transpose_nullspace ( std::vector< NumericVector< Number > *> &  sp,
NonlinearImplicitSystem &  sys 
)

Definition at line 56 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

58 {
59  FEProblemBase * p =
60  sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
61  p->computeTransposeNullSpace(sys, sp);
62 }
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62
virtual void computeTransposeNullSpace(NonlinearImplicitSystem &sys, std::vector< NumericVector< Number > *> &sp)

◆ elementsIntersectedByLine()

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

Parameters
p0The beginning of the line
p1The end of the line
intersected_elemsThe elements intersected by the line. Will be empty if there are no intersections.
segmentsThe line segments across each element

Definition at line 192 of file RayTracing.C.

Referenced by ElementsAlongLine::execute(), IntersectionPointsAlongLine::execute(), and LineMaterialSamplerBase< Real >::execute().

198 {
199  // Make sure our list is clear
200  intersected_elems.clear();
201 
202  // Find the starting element
203  const Elem * first_elem = point_locator(p0);
204 
205  // Quick return if can't even locate the first element.
206  if (!first_elem)
207  return;
208 
209  intersected_elems.push_back(const_cast<Elem *>(first_elem));
210 
211  // Make a LineSegment object out of our two points for ease:
212  LineSegment line_segment = LineSegment(p0, p1);
213 
214  // Find 'em!
216  line_segment, first_elem, -1, p0, intersected_elems, segments);
217 }
The LineSegment class is used by the LineMaterialSamplerBase class and for some ray tracing stuff...
Definition: LineSegment.h:28
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.
Definition: RayTracing.C:144

◆ elementsIntersectedByPlane() [1/2]

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.

Parameters
p0Point in plane.
normalNormal vector to plane.
intersected_elemsThe 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().

57 {
58  // Make sure our list is clear
59  intersected_elems.clear();
60 
61  // Create plane from point and normal:
62  Plane plane(p0, normal);
63 
64  // Find 'em!
65  findElementsIntersectedByPlane(plane, mesh, intersected_elems);
66 }
void findElementsIntersectedByPlane(const Plane &plane, const MeshBase &mesh, std::vector< const Elem *> &intersected_elems)

◆ elementsIntersectedByPlane() [2/2]

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.

Parameters
p0Point in plane.
p1Point in plane.
p2Point in plane.
intersected_elemsThe elements intersected by the plane. Will be empty if there are no intersections.

Definition at line 69 of file ElementsIntersectedByPlane.C.

74 {
75  // Make sure our list is clear
76  intersected_elems.clear();
77 
78  // Create plane from three points:
79  Plane plane(p0, p1, p2);
80 
81  // Find 'em!
82  findElementsIntersectedByPlane(plane, mesh, intersected_elems);
83 }
void findElementsIntersectedByPlane(const Plane &plane, const MeshBase &mesh, std::vector< const Elem *> &intersected_elems)

◆ enumerate() [1/3]

template<class Iterator >
_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 53 of file Enumerate.h.

Referenced by JvarMapInterfaceBase< Kernel >::JvarMapInterfaceBase(), and NearestPointBase< LayeredAverage >::nearestUserObject().

56 {
57  return _enumerate_range<Iterator>(first, last, initial);
58 }

◆ enumerate() [2/3]

template<class Container >
_enumerate_range<typename Container::iterator> Moose::enumerate ( Container &  content)

Definition at line 62 of file Enumerate.h.

63 {
64  return _enumerate_range<typename Container::iterator>(std::begin(content), std::end(content), 0);
65 }

◆ enumerate() [3/3]

template<class Container >
_enumerate_range<typename Container::const_iterator> Moose::enumerate ( const Container &  content)

Definition at line 69 of file Enumerate.h.

70 {
71  return _enumerate_range<typename Container::const_iterator>(
72  std::begin(content), std::end(content), 0);
73 }

◆ findContactPoint()

void Moose::findContactPoint ( PenetrationInfo p_info,
FEBase *  fe_elem,
FEBase *  fe_side,
FEType &  fe_side_type,
const Point &  slave_point,
bool  start_with_centroid,
const Real  tangential_tolerance,
bool &  contact_point_on_side 
)

Finds the closest point (called the contact point) on the master_elem on side "side" to the slave_point.

Parameters
p_infoThe penetration info object, contains master_elem, side, various other information
fe_elemFE object for the element
fe_sideFE object for the side
fe_side_typeThe type of fe_side, needed for inverse_map routines
start_with_centroidif true, start inverse mapping procedure from element centroid
tangential_tolerance'tangential' tolerance for determining whether a contact point on a side
slave_pointThe physical space coordinates of the slave node
contact_point_on_sidewhether 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()().

53 {
54  const Elem * master_elem = p_info._elem;
55 
56  unsigned int dim = master_elem->dim();
57 
58  const Elem * side = p_info._side;
59 
60  const std::vector<Point> & phys_point = fe_side->get_xyz();
61 
62  const std::vector<RealGradient> & dxyz_dxi = fe_side->get_dxyzdxi();
63  const std::vector<RealGradient> & d2xyz_dxi2 = fe_side->get_d2xyzdxi2();
64  const std::vector<RealGradient> & d2xyz_dxieta = fe_side->get_d2xyzdxideta();
65 
66  const std::vector<RealGradient> & dxyz_deta = fe_side->get_dxyzdeta();
67  const std::vector<RealGradient> & d2xyz_deta2 = fe_side->get_d2xyzdeta2();
68  const std::vector<RealGradient> & d2xyz_detaxi = fe_side->get_d2xyzdxideta();
69 
70  if (dim == 1)
71  {
72  const Node * nearest_node = side->node_ptr(0);
73  p_info._closest_point = *nearest_node;
74  p_info._closest_point_ref =
75  master_elem->master_point(master_elem->get_node_index(nearest_node));
76  std::vector<Point> elem_points = {p_info._closest_point_ref};
77  fe_elem->reinit(master_elem, &elem_points);
78 
79  const std::vector<RealGradient> & elem_dxyz_dxi = fe_elem->get_dxyzdxi();
80  p_info._normal = elem_dxyz_dxi[0];
81  if (nearest_node->id() == master_elem->node_id(0))
82  p_info._normal *= -1.0;
83  p_info._normal /= p_info._normal.norm();
84 
85  Point from_slave_to_closest = p_info._closest_point - slave_point;
86  p_info._distance = from_slave_to_closest * p_info._normal;
87  Point tangential = from_slave_to_closest - p_info._distance * p_info._normal;
88  p_info._tangential_distance = tangential.norm();
89  p_info._dxyzdxi = dxyz_dxi;
90  p_info._dxyzdeta = dxyz_deta;
91  p_info._d2xyzdxideta = d2xyz_dxieta;
92  p_info._side_phi = fe_side->get_phi();
93  p_info._side_grad_phi = fe_side->get_dphi();
94  contact_point_on_side = true;
95  return;
96  }
97 
98  Point ref_point;
99 
100  if (start_with_centroid)
101  ref_point =
102  FEInterface::inverse_map(dim - 1, fe_side_type, side, side->centroid(), TOLERANCE, false);
103  else
104  ref_point = p_info._closest_point_ref;
105 
106  std::vector<Point> points = {ref_point};
107  fe_side->reinit(side, &points);
108  RealGradient d = slave_point - phys_point[0];
109 
110  Real update_size = std::numeric_limits<Real>::max();
111 
112  // Least squares
113  for (unsigned int it = 0; it < 3 && update_size > TOLERANCE * 1e3; ++it)
114  {
115  DenseMatrix<Real> jac(dim - 1, dim - 1);
116 
117  jac(0, 0) = -(dxyz_dxi[0] * dxyz_dxi[0]);
118 
119  if (dim - 1 == 2)
120  {
121  jac(1, 0) = -(dxyz_dxi[0] * dxyz_deta[0]);
122  jac(0, 1) = -(dxyz_deta[0] * dxyz_dxi[0]);
123  jac(1, 1) = -(dxyz_deta[0] * dxyz_deta[0]);
124  }
125 
126  DenseVector<Real> rhs(dim - 1);
127 
128  rhs(0) = dxyz_dxi[0] * d;
129 
130  if (dim - 1 == 2)
131  rhs(1) = dxyz_deta[0] * d;
132 
133  DenseVector<Real> update(dim - 1);
134 
135  jac.lu_solve(rhs, update);
136 
137  ref_point(0) -= update(0);
138 
139  if (dim - 1 == 2)
140  ref_point(1) -= update(1);
141 
142  points[0] = ref_point;
143  fe_side->reinit(side, &points);
144  d = slave_point - phys_point[0];
145 
146  update_size = update.l2_norm();
147  }
148 
149  update_size = std::numeric_limits<Real>::max();
150 
151  unsigned nit = 0;
152 
153  // Newton Loop
154  for (; nit < 12 && update_size > TOLERANCE * TOLERANCE; nit++)
155  {
156  d = slave_point - phys_point[0];
157 
158  DenseMatrix<Real> jac(dim - 1, dim - 1);
159 
160  jac(0, 0) = (d2xyz_dxi2[0] * d) - (dxyz_dxi[0] * dxyz_dxi[0]);
161 
162  if (dim - 1 == 2)
163  {
164  jac(1, 0) = (d2xyz_dxieta[0] * d) - (dxyz_dxi[0] * dxyz_deta[0]);
165 
166  jac(0, 1) = (d2xyz_detaxi[0] * d) - (dxyz_deta[0] * dxyz_dxi[0]);
167  jac(1, 1) = (d2xyz_deta2[0] * d) - (dxyz_deta[0] * dxyz_deta[0]);
168  }
169 
170  DenseVector<Real> rhs(dim - 1);
171 
172  rhs(0) = -dxyz_dxi[0] * d;
173 
174  if (dim - 1 == 2)
175  rhs(1) = -dxyz_deta[0] * d;
176 
177  DenseVector<Real> update(dim - 1);
178 
179  jac.lu_solve(rhs, update);
180 
181  ref_point(0) += update(0);
182 
183  if (dim - 1 == 2)
184  ref_point(1) += update(1);
185 
186  points[0] = ref_point;
187  fe_side->reinit(side, &points);
188  d = slave_point - phys_point[0];
189 
190  update_size = update.l2_norm();
191  }
192 
193  /*
194  if (nit == 12 && update_size > TOLERANCE*TOLERANCE)
195  Moose::err<<"Warning! Newton solve for contact point failed to converge!"<<std::endl;
196  */
197 
198  p_info._closest_point_ref = ref_point;
199  p_info._closest_point = phys_point[0];
200  p_info._distance = d.norm();
201 
202  if (dim - 1 == 2)
203  {
204  p_info._normal = dxyz_dxi[0].cross(dxyz_deta[0]);
205  p_info._normal /= p_info._normal.norm();
206  }
207  else
208  {
209  const Node * const * elem_nodes = master_elem->get_nodes();
210  const Point in_plane_vector1 = *elem_nodes[1] - *elem_nodes[0];
211  const Point in_plane_vector2 = *elem_nodes[2] - *elem_nodes[0];
212 
213  Point out_of_plane_normal = in_plane_vector1.cross(in_plane_vector2);
214  out_of_plane_normal /= out_of_plane_normal.norm();
215 
216  p_info._normal = dxyz_dxi[0].cross(out_of_plane_normal);
217  if (std::fabs(p_info._normal.norm()) > 1e-15)
218  p_info._normal /= p_info._normal.norm();
219  }
220 
221  // If the point has not penetrated the face, make the distance negative
222  const Real dot(d * p_info._normal);
223  if (dot > 0.0)
224  p_info._distance = -p_info._distance;
225 
226  contact_point_on_side = FEInterface::on_reference_element(ref_point, side->type());
227 
228  p_info._tangential_distance = 0.0;
229 
230  if (!contact_point_on_side)
231  {
232  p_info._closest_point_on_face_ref = ref_point;
234 
235  points[0] = p_info._closest_point_on_face_ref;
236  fe_side->reinit(side, &points);
237  Point closest_point_on_face(phys_point[0]);
238 
239  RealGradient off_face = closest_point_on_face - p_info._closest_point;
240  Real tangential_distance = off_face.norm();
241  p_info._tangential_distance = tangential_distance;
242  if (tangential_distance <= tangential_tolerance)
243  {
244  contact_point_on_side = true;
245  }
246  }
247 
248  const std::vector<std::vector<Real>> & phi = fe_side->get_phi();
249  const std::vector<std::vector<RealGradient>> & grad_phi = fe_side->get_dphi();
250 
251  points[0] = p_info._closest_point_ref;
252  fe_side->reinit(side, &points);
253 
254  p_info._side_phi = phi;
255  p_info._side_grad_phi = grad_phi;
256  p_info._dxyzdxi = dxyz_dxi;
257  p_info._dxyzdeta = dxyz_deta;
258  p_info._d2xyzdxideta = d2xyz_dxieta;
259 }
std::vector< RealGradient > _d2xyzdxideta
static PetscErrorCode Vec Mat jac
RealVectorValue _normal
Point _closest_point_on_face_ref
void restrictPointToFace(Point &p, const Elem *side, std::vector< const Node *> &off_edge_nodes)
std::vector< std::vector< RealGradient > > _side_grad_phi
std::vector< std::vector< Real > > _side_phi
const Elem * _elem
std::vector< RealGradient > _dxyzdxi
const Elem * _side
std::vector< const Node * > _off_edge_nodes
std::vector< RealGradient > _dxyzdeta

◆ findElementsIntersectedByPlane()

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

27 {
28  // Loop over all elements to find elements intersected by the plane
29  for (const auto & elem : mesh.element_ptr_range())
30  {
31  bool intersected = false;
32 
33  // Check whether the first node of this element is below or above the plane
34  const Node & node0 = elem->node_ref(0);
35  bool node0_above_plane = plane.above_surface(node0);
36 
37  // Loop over the rest of the nodes and check if any node is on the other side of the plane
38  for (unsigned int i = 1; i < elem->n_nodes(); ++i)
39  {
40  const Node & node = elem->node_ref(i);
41 
42  bool node_above_plane = plane.above_surface(node);
43  if (node0_above_plane != node_above_plane)
44  intersected = true;
45  }
46 
47  if (intersected)
48  intersected_elems.push_back(elem);
49  }
50 }

◆ getExecutablePath()

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 24 of file ExecutablePath.C.

Referenced by SystemInfo::getInfo().

25 {
26  std::string exec_path;
27  char path[1024];
28 
29 #ifdef __APPLE__
30  uint32_t size = sizeof(path);
31  if (_NSGetExecutablePath(path, &size) == 0)
32  exec_path = path;
33  else
34  mooseError("Unable to retrieve executable path");
35 #else // Linux with Proc
36  std::ostringstream oss;
37  oss << "/proc/" << getpid() << "/exe";
38  int ch = readlink(oss.str().c_str(), path, 1024);
39  if (ch != -1)
40  {
41  path[ch] = 0;
42  exec_path = path;
43  }
44 #endif
45 
46  // Now strip off the exeuctable to get the PATH
47  std::string::size_type t = exec_path.find_last_of("/");
48  exec_path = exec_path.substr(0, t) + "/";
49 
50  return exec_path;
51 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208

◆ indirectSort() [1/2]

template<class RandomAccessIterator >
void Moose::indirectSort ( RandomAccessIterator  beg,
RandomAccessIterator  end,
std::vector< size_t > &  b 
)

Definition at line 69 of file IndirectSort.h.

Referenced by SamplerBase::finalize(), and PerfGraph::printHeaviestSections().

70 {
71  // Space in b
72  initialize_indirect_sort(beg, end, b);
73 
74  // Typedef for less typing. Note: use of std::iterator_traits means this should work with
75  // naked pointers too...
76  typedef std::less<typename std::iterator_traits<RandomAccessIterator>::value_type>
77  LessThanComparator;
78 
79  // Construct comparator object
80  indirect_comparator<RandomAccessIterator, LessThanComparator> ic(beg, LessThanComparator());
81 
82  // Sort the indices, based on the data
83  std::sort(b.begin(), b.end(), ic);
84 }
void initialize_indirect_sort(RandomAccessIterator beg, RandomAccessIterator end, std::vector< size_t > &b)
Definition: IndirectSort.h:53

◆ indirectSort() [2/2]

template<class RandomAccessIterator , class UserComparisonFunctor >
void Moose::indirectSort ( RandomAccessIterator  beg,
RandomAccessIterator  end,
std::vector< size_t > &  b,
UserComparisonFunctor  user_comp 
)

Definition at line 90 of file IndirectSort.h.

94 {
95  // Space in b
96  initialize_indirect_sort(beg, end, b);
97 
98  // Construct comparator object
99  indirect_comparator<RandomAccessIterator, UserComparisonFunctor> ic(beg, user_comp);
100 
101  // Sort the indices, based on the data
102  std::sort(b.begin(), b.end(), ic);
103 }
void initialize_indirect_sort(RandomAccessIterator beg, RandomAccessIterator end, std::vector< size_t > &b)
Definition: IndirectSort.h:53

◆ initCoordinateSystemType()

void Moose::initCoordinateSystemType ( )

Definition at line 52 of file Conversion.C.

Referenced by stringToEnum< CoordinateSystemType >().

53 {
55  {
59  }
60 }
std::map< std::string, CoordinateSystemType > coordinate_system_type_to_enum
Definition: Conversion.C:25

◆ initEigenProlemType()

void Moose::initEigenProlemType ( )

Definition at line 92 of file Conversion.C.

Referenced by stringToEnum< EigenProblemType >().

93 {
94  if (eigen_problem_type_to_enum.empty())
95  {
101  eigen_problem_type_to_enum["POS_GEN_NON_HERMITIAN"] = EPT_POS_GEN_NON_HERMITIAN;
103  }
104 }
Generalized Non-Hermitian.
Definition: MooseTypes.h:604
Generalized Hermitian indefinite.
Definition: MooseTypes.h:603
std::map< std::string, EigenProblemType > eigen_problem_type_to_enum
Definition: Conversion.C:28
use whatever SLPEC has by default
Definition: MooseTypes.h:606
Generalized Non-Hermitian with positive (semi-)definite B.
Definition: MooseTypes.h:605
Non-Hermitian.
Definition: MooseTypes.h:601
Generalized Hermitian.
Definition: MooseTypes.h:602

◆ initEigenSolveType()

void Moose::initEigenSolveType ( )

Definition at line 76 of file Conversion.C.

Referenced by stringToEnum< EigenSolveType >().

77 {
78  if (eigen_solve_type_to_enum.empty())
79  {
83  eigen_solve_type_to_enum["JACOBI_DAVIDSON"] = EST_JACOBI_DAVIDSON;
84  eigen_solve_type_to_enum["NONLINEAR_POWER"] = EST_NONLINEAR_POWER;
85  eigen_solve_type_to_enum["MF_NONLINEAR_POWER"] = EST_MF_NONLINEAR_POWER;
86  eigen_solve_type_to_enum["MONOLITH_NEWTON"] = EST_MONOLITH_NEWTON;
87  eigen_solve_type_to_enum["MF_MONOLITH_NEWTON"] = EST_MF_MONOLITH_NEWTON;
88  }
89 }
Newton-based eigen solver.
Definition: MooseTypes.h:591
std::map< std::string, EigenSolveType > eigen_solve_type_to_enum
Definition: Conversion.C:27
Matrix-free Newton-based eigen solver.
Definition: MooseTypes.h:592
Matrix-free nonlinear inverse power.
Definition: MooseTypes.h:590
Power / Inverse / RQI.
Definition: MooseTypes.h:585
Krylov-Schur.
Definition: MooseTypes.h:587
Nonlinear inverse power.
Definition: MooseTypes.h:589
Jacobi-Davidson.
Definition: MooseTypes.h:588

◆ initial_condition()

void Moose::initial_condition ( EquationSystems &  es,
const std::string &  system_name 
)

◆ initialize_indirect_sort()

template<class RandomAccessIterator >
void Moose::initialize_indirect_sort ( RandomAccessIterator  beg,
RandomAccessIterator  end,
std::vector< size_t > &  b 
)

Definition at line 53 of file IndirectSort.h.

Referenced by indirectSort().

56 {
57  // enough storage for all the indices
58  b.resize(std::distance(beg, end));
59 
60  // iota
61  for (size_t i = 0; i < b.size(); ++i)
62  b[i] = i;
63 }

◆ initLineSearchType()

void Moose::initLineSearchType ( )

Definition at line 126 of file Conversion.C.

Referenced by stringToEnum< LineSearchType >().

127 {
128  if (line_search_type_to_enum.empty())
129  {
133 #ifdef LIBMESH_HAVE_PETSC
134 #if PETSC_VERSION_LESS_THAN(3, 3, 0)
136  line_search_type_to_enum["QUADRATIC"] = LS_QUADRATIC;
137  line_search_type_to_enum["BASICNONORMS"] = LS_BASICNONORMS;
138 #else
144 #endif
145 #endif
146  }
147 }
std::map< std::string, LineSearchType > line_search_type_to_enum
Definition: Conversion.C:30

◆ initMffdType()

void Moose::initMffdType ( )

Definition at line 165 of file Conversion.C.

Referenced by stringToEnum< MffdType >().

166 {
167  if (mffd_type_to_enum.empty())
168  {
169  mffd_type_to_enum["DS"] = MFFD_DS;
170  mffd_type_to_enum["WP"] = MFFD_WP;
171  }
172 }
std::map< std::string, MffdType > mffd_type_to_enum
Definition: Conversion.C:32

◆ initQuadratureType()

void Moose::initQuadratureType ( )

Definition at line 36 of file Conversion.C.

Referenced by stringToEnum< QuadratureType >().

37 {
38  if (quadrature_type_to_enum.empty())
39  {
40  quadrature_type_to_enum["CLOUGH"] = QCLOUGH;
41  quadrature_type_to_enum["CONICAL"] = QCONICAL;
42  quadrature_type_to_enum["GAUSS"] = QGAUSS;
43  quadrature_type_to_enum["GRID"] = QGRID;
44  quadrature_type_to_enum["MONOMIAL"] = QMONOMIAL;
45  quadrature_type_to_enum["SIMPSON"] = QSIMPSON;
46  quadrature_type_to_enum["TRAP"] = QTRAP;
47  quadrature_type_to_enum["GAUSS_LOBATTO"] = QGAUSS_LOBATTO;
48  }
49 }
std::map< std::string, QuadratureType > quadrature_type_to_enum
Definition: Conversion.C:24

◆ initRMType()

void Moose::initRMType ( )

Definition at line 175 of file Conversion.C.

Referenced by stringToEnum< RelationshipManagerType >().

176 {
177  if (rm_type_to_enum.empty())
178  {
179  rm_type_to_enum["DEFAULT"] = RelationshipManagerType::DEFAULT;
180  rm_type_to_enum["GEOMETRIC"] = RelationshipManagerType::GEOMETRIC;
181  rm_type_to_enum["ALGEBRAIC"] = RelationshipManagerType::ALGEBRAIC;
182  rm_type_to_enum["COUPLING"] = RelationshipManagerType::COUPLING;
183  }
184 }
std::map< std::string, RelationshipManagerType > rm_type_to_enum
Definition: Conversion.C:33

◆ initSolveType()

void Moose::initSolveType ( )

Definition at line 63 of file Conversion.C.

Referenced by stringToEnum< SolveType >().

64 {
65  if (solve_type_to_enum.empty())
66  {
67  solve_type_to_enum["PJFNK"] = ST_PJFNK;
68  solve_type_to_enum["JFNK"] = ST_JFNK;
69  solve_type_to_enum["NEWTON"] = ST_NEWTON;
70  solve_type_to_enum["FD"] = ST_FD;
71  solve_type_to_enum["LINEAR"] = ST_LINEAR;
72  }
73 }
Full Newton Solve.
Definition: MooseTypes.h:575
Solving a linear problem.
Definition: MooseTypes.h:577
Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:574
Use finite differences to compute Jacobian.
Definition: MooseTypes.h:576
Preconditioned Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:573
std::map< std::string, SolveType > solve_type_to_enum
Definition: Conversion.C:26

◆ initTimeIntegratorsType()

void Moose::initTimeIntegratorsType ( )

Definition at line 150 of file Conversion.C.

Referenced by stringToEnum< TimeIntegratorType >().

151 {
152  if (time_integrator_to_enum.empty())
153  {
154  time_integrator_to_enum["IMPLICIT_EULER"] = TI_IMPLICIT_EULER;
155  time_integrator_to_enum["EXPLICIT_EULER"] = TI_EXPLICIT_EULER;
156  time_integrator_to_enum["CRANK_NICOLSON"] = TI_CRANK_NICOLSON;
158  time_integrator_to_enum["EXPLICIT_MIDPOINT"] = TI_EXPLICIT_MIDPOINT;
159  time_integrator_to_enum["LSTABLE_DIRK2"] = TI_LSTABLE_DIRK2;
160  time_integrator_to_enum["EXPLICIT_TVDRK2"] = TI_EXPLICIT_TVD_RK_2;
161  }
162 }
std::map< std::string, TimeIntegratorType > time_integrator_to_enum
Definition: Conversion.C:31

◆ initWhichEigenPairs()

void Moose::initWhichEigenPairs ( )

Definition at line 107 of file Conversion.C.

Referenced by stringToEnum< WhichEigenPairs >().

108 {
109  if (which_eigen_pairs_to_enum.empty())
110  {
111  which_eigen_pairs_to_enum["LARGEST_MAGNITUDE"] = WEP_LARGEST_MAGNITUDE;
112  which_eigen_pairs_to_enum["SMALLEST_MAGNITUDE"] = WEP_SMALLEST_MAGNITUDE;
114  which_eigen_pairs_to_enum["SMALLEST_REAL"] = WEP_SMALLEST_REAL;
115  which_eigen_pairs_to_enum["LARGEST_IMAGINARY"] = WEP_LARGEST_IMAGINARY;
116  which_eigen_pairs_to_enum["SMALLEST_IMAGINARY"] = WEP_SMALLEST_IMAGINARY;
117  which_eigen_pairs_to_enum["TARGET_MAGNITUDE"] = WEP_TARGET_MAGNITUDE;
119  which_eigen_pairs_to_enum["TARGET_IMAGINARY"] = WEP_TARGET_IMAGINARY;
120  which_eigen_pairs_to_enum["ALL_EIGENVALUES"] = WEP_ALL_EIGENVALUES;
121  which_eigen_pairs_to_enum["SLEPC_DEFAULT"] = WEP_SLEPC_DEFAULT;
122  }
123 }
smallest magnitude
Definition: MooseTypes.h:615
std::map< std::string, WhichEigenPairs > which_eigen_pairs_to_enum
Definition: Conversion.C:29
target magnitude
Definition: MooseTypes.h:620
target imaginary
Definition: MooseTypes.h:622
smallest imaginary
Definition: MooseTypes.h:619
largest imaginary
Definition: MooseTypes.h:618
all eigenvalues
Definition: MooseTypes.h:623
use whatever we have in SLEPC
Definition: MooseTypes.h:624
largest magnitude
Definition: MooseTypes.h:614

◆ recursivelyFindElementsIntersectedByLine()

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

Parameters
line_segmentthe LineSegment to intersect
current_elemThe current element that needs to be searched
incoming_sideThe side of the current element that was intersected by the LineSegment that brought us here
intersected_elemsThe output
segmentsLine segments for the path across each element

Definition at line 144 of file RayTracing.C.

Referenced by elementsIntersectedByLine().

150 {
151  Point intersection_point;
152 
153  std::vector<int> not_side(1, incoming_side);
154 
155  // Find the side of this element that the LineSegment intersects... while ignoring the incoming
156  // side (we don't want to move backward!)
157  int intersected_side =
158  sideIntersectedByLine(current_elem, not_side, line_segment, intersection_point);
159 
160  if (intersected_side != -1) // -1 means that we didn't find any side
161  {
162  // Get the neighbor on that side
163  const Elem * neighbor = current_elem->neighbor_ptr(intersected_side);
164 
165  if (neighbor)
166  {
167  // Add it to the list
168  intersected_elems.push_back(const_cast<Elem *>(neighbor));
169 
170  // Add the line segment across the element to the segments list
171  segments.push_back(LineSegment(incoming_point, intersection_point));
172 
173  // Note: This is finding the side the current_elem is on for the neighbor. That's the
174  // "incoming_side" for the neighbor
175  int incoming_side = sideNeighborIsOn(neighbor, current_elem);
176 
177  // Recurse
179  line_segment, neighbor, incoming_side, intersection_point, intersected_elems, segments);
180  }
181  else // Add the final segment
182  segments.push_back(LineSegment(incoming_point, line_segment.end()));
183  }
184  else // Add the final segment
185  segments.push_back(LineSegment(incoming_point, line_segment.end()));
186 
187  // Finished... return out!
188  return;
189 }
const Point & end() const
Ending of the line segment.
Definition: LineSegment.h:66
int sideNeighborIsOn(const Elem *elem, const Elem *neighbor)
Returns the side number for elem that neighbor is on.
Definition: RayTracing.C:115
The LineSegment class is used by the LineMaterialSamplerBase class and for some ray tracing stuff...
Definition: LineSegment.h:28
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.
Definition: RayTracing.C:144
int 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.
Definition: RayTracing.C:34

◆ registerActions() [1/2]

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 332 of file Moose.C.

Referenced by associateSyntax(), and registerAll().

333 {
334  mooseDeprecated("use registerAll instead of registerActions");
335  registerActions(syntax, action_factory, {"MooseApp"});
336 }
void registerActions(Syntax &syntax, ActionFactory &action_factory)
Multiple Action class can be associated with a single input file section, in which case all associate...
Definition: Moose.C:332
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:237

◆ registerActions() [2/2]

void Moose::registerActions ( Syntax syntax,
ActionFactory action_factory,
const std::set< std::string > &  obj_labels 
)

Definition at line 339 of file Moose.C.

342 {
343  Registry::registerActionsTo(action_factory, obj_labels);
344 
345  // TODO: Why is this here?
346  registerTask("finish_input_file_output", false);
347 }
static void registerActionsTo(ActionFactory &f, const std::set< std::string > &labels)
This registers all Actions known to the registry that have the given label(s) with the factory f...
Definition: Registry.C:120

◆ registerAll()

void Moose::registerAll ( Factory f,
ActionFactory af,
Syntax s 
)

Register objects that are in MOOSE.

Definition at line 52 of file Moose.C.

Referenced by MooseApp::MooseApp().

53 {
54  registerObjects(f, {"MooseApp"});
55  associateSyntaxInner(s, af);
56  registerActions(s, af, {"MooseApp"});
58 }
void registerActions(Syntax &syntax, ActionFactory &action_factory)
Multiple Action class can be associated with a single input file section, in which case all associate...
Definition: Moose.C:332
void registerObjects(Factory &factory)
Definition: Moose.C:61
void registerExecFlags(Factory &factory)
Definition: Moose.C:350
void associateSyntaxInner(Syntax &syntax, ActionFactory &action_factory)
Definition: Moose.C:369

◆ registerExecFlags()

void Moose::registerExecFlags ( Factory factory)

Definition at line 350 of file Moose.C.

Referenced by registerAll(), and MooseApp::setupOptions().

351 {
352  registerExecFlag(EXEC_NONE);
353  registerExecFlag(EXEC_INITIAL);
354  registerExecFlag(EXEC_LINEAR);
355  registerExecFlag(EXEC_NONLINEAR);
356  registerExecFlag(EXEC_TIMESTEP_END);
357  registerExecFlag(EXEC_TIMESTEP_BEGIN);
358  registerExecFlag(EXEC_FINAL);
359  registerExecFlag(EXEC_FORCED);
360  registerExecFlag(EXEC_FAILED);
361  registerExecFlag(EXEC_CUSTOM);
362  registerExecFlag(EXEC_SUBDOMAIN);
363  registerExecFlag(EXEC_PRE_DISPLACE);
364  registerExecFlag(EXEC_SAME_AS_MULTIAPP);
365  registerExecFlag(EXEC_PRE_MULTIAPP_SETUP);
366 }
const ExecFlagType EXEC_CUSTOM("CUSTOM", 0x100)
const ExecFlagType EXEC_LINEAR("LINEAR", 0x02)
const ExecFlagType EXEC_SUBDOMAIN("SUBDOMAIN", 0x200)
const ExecFlagType EXEC_NONE("NONE", 0x00)
const ExecFlagType EXEC_TIMESTEP_END("TIMESTEP_END", 0x08)
const ExecFlagType EXEC_PRE_MULTIAPP_SETUP("PRE_MULTIAPP_SETUP")
const ExecFlagType EXEC_INITIAL("INITIAL", 0x01)
const ExecFlagType EXEC_FINAL("FINAL", 0x20)
const ExecFlagType EXEC_TIMESTEP_BEGIN("TIMESTEP_BEGIN", 0x10)
const ExecFlagType EXEC_FORCED("FORCED", 0x40)
const ExecFlagType EXEC_PRE_DISPLACE("PRE_DISPLACE")
const ExecFlagType EXEC_NONLINEAR("NONLINEAR", 0x04)
const ExecFlagType EXEC_SAME_AS_MULTIAPP("SAME_AS_MULTIAPP")
const ExecFlagType EXEC_FAILED("FAILED", 0x80)

◆ registerObjects() [1/2]

void Moose::registerObjects ( Factory factory)

Definition at line 61 of file Moose.C.

Referenced by registerAll().

62 {
63  mooseDeprecated("use registerAll instead of registerObjects");
64  registerObjects(factory, {"MooseApp"});
65 }
void registerObjects(Factory &factory)
Definition: Moose.C:61
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:237

◆ registerObjects() [2/2]

void Moose::registerObjects ( Factory factory,
const std::set< std::string > &  obj_labels 
)

Definition at line 68 of file Moose.C.

69 {
70  Registry::registerObjectsTo(factory, obj_labels);
71 }
static void registerObjectsTo(Factory &f, const std::set< std::string > &labels)
This registers all MooseObjects known to the registry that have the given label(s) with the factory f...
Definition: Registry.C:52

◆ restrictPointToFace()

void Moose::restrictPointToFace ( Point &  p,
const Elem *  side,
std::vector< const Node *> &  off_edge_nodes 
)

Definition at line 262 of file FindContactPoint.C.

Referenced by findContactPoint().

263 {
264  const ElemType t(side->type());
265  off_edge_nodes.clear();
266  Real & xi = p(0);
267  Real & eta = p(1);
268 
269  switch (t)
270  {
271  case EDGE2:
272  case EDGE3:
273  case EDGE4:
274  {
275  // The reference 1D element is [-1,1].
276  if (xi < -1.0)
277  {
278  xi = -1.0;
279  off_edge_nodes.push_back(side->node_ptr(0));
280  }
281  else if (xi > 1.0)
282  {
283  xi = 1.0;
284  off_edge_nodes.push_back(side->node_ptr(1));
285  }
286  break;
287  }
288 
289  case TRI3:
290  case TRI6:
291  {
292  // The reference triangle is isosceles
293  // and is bound by xi=0, eta=0, and xi+eta=1.
294 
295  if (xi <= 0.0 && eta <= 0.0)
296  {
297  xi = 0.0;
298  eta = 0.0;
299  off_edge_nodes.push_back(side->node_ptr(0));
300  }
301  else if (xi > 0.0 && xi < 1.0 && eta < 0.0)
302  {
303  eta = 0.0;
304  off_edge_nodes.push_back(side->node_ptr(0));
305  off_edge_nodes.push_back(side->node_ptr(1));
306  }
307  else if (eta > 0.0 && eta < 1.0 && xi < 0.0)
308  {
309  xi = 0.0;
310  off_edge_nodes.push_back(side->node_ptr(2));
311  off_edge_nodes.push_back(side->node_ptr(0));
312  }
313  else if (xi >= 1.0 && (eta - xi) <= -1.0)
314  {
315  xi = 1.0;
316  eta = 0.0;
317  off_edge_nodes.push_back(side->node_ptr(1));
318  }
319  else if (eta >= 1.0 && (eta - xi) >= 1.0)
320  {
321  xi = 0.0;
322  eta = 1.0;
323  off_edge_nodes.push_back(side->node_ptr(2));
324  }
325  else if ((xi + eta) > 1.0)
326  {
327  Real delta = (xi + eta - 1.0) / 2.0;
328  xi -= delta;
329  eta -= delta;
330  off_edge_nodes.push_back(side->node_ptr(1));
331  off_edge_nodes.push_back(side->node_ptr(2));
332  }
333  break;
334  }
335 
336  case QUAD4:
337  case QUAD8:
338  case QUAD9:
339  {
340  // The reference quadrilateral element is [-1,1]^2.
341  if (xi < -1.0)
342  {
343  xi = -1.0;
344  if (eta < -1.0)
345  {
346  eta = -1.0;
347  off_edge_nodes.push_back(side->node_ptr(0));
348  }
349  else if (eta > 1.0)
350  {
351  eta = 1.0;
352  off_edge_nodes.push_back(side->node_ptr(3));
353  }
354  else
355  {
356  off_edge_nodes.push_back(side->node_ptr(3));
357  off_edge_nodes.push_back(side->node_ptr(0));
358  }
359  }
360  else if (xi > 1.0)
361  {
362  xi = 1.0;
363  if (eta < -1.0)
364  {
365  eta = -1.0;
366  off_edge_nodes.push_back(side->node_ptr(1));
367  }
368  else if (eta > 1.0)
369  {
370  eta = 1.0;
371  off_edge_nodes.push_back(side->node_ptr(2));
372  }
373  else
374  {
375  off_edge_nodes.push_back(side->node_ptr(1));
376  off_edge_nodes.push_back(side->node_ptr(2));
377  }
378  }
379  else
380  {
381  if (eta < -1.0)
382  {
383  eta = -1.0;
384  off_edge_nodes.push_back(side->node_ptr(0));
385  off_edge_nodes.push_back(side->node_ptr(1));
386  }
387  else if (eta > 1.0)
388  {
389  eta = 1.0;
390  off_edge_nodes.push_back(side->node_ptr(2));
391  off_edge_nodes.push_back(side->node_ptr(3));
392  }
393  }
394  break;
395  }
396 
397  default:
398  {
399  mooseError("Unsupported face type: ", t);
400  break;
401  }
402  }
403 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208

◆ setColorConsole()

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 544 of file Moose.C.

Referenced by CommonOutputAction::act(), and MooseApp::setupOptions().

545 {
546  _color_console = (isatty(fileno(stdout)) || force) && use_color;
547  return _color_console;
548 }
static bool _color_console
Definition: Moose.C:535

◆ setSolverDefaults()

void Moose::setSolverDefaults ( FEProblemBase problem)

Definition at line 517 of file Moose.C.

Referenced by FEProblemBase::solve(), and DT2::step().

518 {
519 #ifdef LIBMESH_HAVE_PETSC
520  // May be a touch expensive to create a new DM every time, but probably safer to do it this way
522 #endif // LIBMESH_HAVE_PETSC
523 }
void petscSetDefaults(FEProblemBase &problem)
Sets the default options for PETSc.
Definition: PetscSupport.C:601

◆ sideIntersectedByLine()

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.

Parameters
elemThe elem to search
not_sideSides to not search (Use -1 if you want to search all sides)
intersection_pointIf an intersection is found this will be filled with the x,y,z position of that intersection
Returns
The side that is intersected by the line. Will return -1 if it doesn't intersect any side

Definition at line 34 of file RayTracing.C.

Referenced by recursivelyFindElementsIntersectedByLine().

38 {
39  unsigned int n_sides = elem->n_sides();
40 
41  // Whether or not they intersect
42  bool intersect = false;
43 
44  unsigned int dim = elem->dim();
45 
46  for (unsigned int i = 0; i < n_sides; i++)
47  {
48  // Don't search the "not_side"
49  // Note: A linear search is fine here because this vector is going to be < n_sides
50  if (std::find(not_side.begin(), not_side.end(), static_cast<int>(i)) != not_side.end())
51  continue;
52 
53  // Get a simplified side element
54  std::unique_ptr<const Elem> side_elem = elem->side_ptr(i);
55 
56  if (dim == 3)
57  {
58  // Make a plane out of the first three nodes on the side
59  Plane plane(side_elem->point(0), side_elem->point(1), side_elem->point(2));
60 
61  // See if they intersect
62  intersect = line_segment.intersect(plane, intersection_point);
63  }
64  else if (dim == 2)
65  {
66  // Make a Line Segment out of the first two nodes on the side
67  LineSegment side_segment(side_elem->point(0), side_elem->point(1));
68 
69  // See if they intersect
70  intersect = line_segment.intersect(side_segment, intersection_point);
71  }
72  else // 1D
73  {
74  // See if the line segment contains the point
75  intersect = line_segment.contains_point(side_elem->point(0));
76 
77  // If it does then save off that one point as the intersection point
78  if (intersect)
79  intersection_point = side_elem->point(0);
80  }
81 
82  if (intersect)
83  {
84  if (side_elem->contains_point(intersection_point))
85  {
86  const Elem * neighbor = elem->neighbor_ptr(i);
87 
88  // If this side is on a boundary, let's do another search and see if we can find a better
89  // candidate
90  if (!neighbor)
91  {
92  not_side.push_back(i); // Make sure we don't find this side again
93 
94  int better_side = sideIntersectedByLine(elem, not_side, line_segment, intersection_point);
95 
96  if (better_side != -1)
97  return better_side;
98  }
99 
100  return i;
101  }
102  }
103  }
104 
105  // Didn't find one
106  return -1;
107 }
The LineSegment class is used by the LineMaterialSamplerBase class and for some ray tracing stuff...
Definition: LineSegment.h:28
bool intersect(const Plane &pl, Point &intersect_p) const
Definition: LineSegment.C:64
bool contains_point(const Point &p) const
Determines whether a point is in a line segment or not.
Definition: LineSegment.C:57
int 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.
Definition: RayTracing.C:34

◆ sideNeighborIsOn()

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

116 {
117  unsigned int n_sides = elem->n_sides();
118 
119  for (unsigned int i = 0; i < n_sides; i++)
120  {
121  if (elem->neighbor_ptr(i) == neighbor)
122  return i;
123  }
124 
125  return -1;
126 }

◆ stringify() [1/6]

template<typename T >
std::string Moose::stringify ( const T &  t)

◆ stringify() [2/6]

std::string Moose::stringify ( const SolveType t)

Convert solve type into human readable string.

Definition at line 376 of file Conversion.C.

377 {
378  switch (t)
379  {
380  case ST_NEWTON:
381  return "NEWTON";
382  case ST_JFNK:
383  return "JFNK";
384  case ST_PJFNK:
385  return "Preconditioned JFNK";
386  case ST_FD:
387  return "FD";
388  case ST_LINEAR:
389  return "Linear";
390  }
391  return "";
392 }
Full Newton Solve.
Definition: MooseTypes.h:575
Solving a linear problem.
Definition: MooseTypes.h:577
Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:574
Use finite differences to compute Jacobian.
Definition: MooseTypes.h:576
Preconditioned Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:573

◆ stringify() [3/6]

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 395 of file Conversion.C.

396 {
397  return s;
398 }

◆ stringify() [4/6]

template<typename T , typename U >
std::string Moose::stringify ( const std::pair< T, U > &  p)

Add pair stringify to support maps.

Definition at line 77 of file Conversion.h.

78 {
79  return stringify(p.first) + ':' + stringify(p.second);
80 }
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&#39;s choice.
Definition: Conversion.h:97

◆ stringify() [5/6]

template<template< typename... > class T, typename... U>
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.

Parameters
[in]cContainer to stringify
[in]delimString to print between elements
[in]elem_enclString to use at the beginning and end of each element, typically quotation marks
[in]enclose_list_in_curly_bracesEnclose the list string in curly braces?

Definition at line 97 of file Conversion.h.

101 {
102  std::string str;
103  if (enclose_list_in_curly_braces)
104  str += "{";
105  const auto begin = c.begin();
106  const auto end = c.end();
107  for (auto i = begin; i != end; ++i)
108  str += (i != begin ? delim : "") + elem_encl + stringify(*i) + elem_encl;
109  if (enclose_list_in_curly_braces)
110  str += "}";
111  return str;
112 }
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&#39;s choice.
Definition: Conversion.h:97

◆ stringify() [6/6]

std::string Moose::stringify ( const Moose::RelationshipManagerType t)

Definition at line 354 of file Conversion.C.

355 {
356  // Cannot make a switch statement because the boolean logic doesn't work well with the class type
357  // enumeration and because Cody says so.
358  if (t == RelationshipManagerType::DEFAULT)
359  return "DEFAULT";
360  if (t == RelationshipManagerType::GEOMETRIC)
361  return "GEOMETRIC";
362  if (t == RelationshipManagerType::ALGEBRAIC)
363  return "ALGEBRAIC";
364  if (t == (RelationshipManagerType::GEOMETRIC | RelationshipManagerType::ALGEBRAIC))
365  return "GEOMETRIC and ALGEBRAIC";
366  if (t == RelationshipManagerType::COUPLING)
367  return "COUPLING";
368 
369  mooseError("Unknown RelationshipManagerType");
370 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208

◆ stringifyExact()

std::string Moose::stringifyExact ( Real  t)

Stringify Reals with enough precision to guarantee lossless Real -> string -> Real roundtrips.

Definition at line 401 of file Conversion.C.

402 {
403  // this or std::numeric_limits<T>::max_digits10
404  const unsigned int max_digits10 =
405  std::floor(std::numeric_limits<Real>::digits * std::log10(2) + 2);
406 
407  std::ostringstream os;
408  os << std::setprecision(max_digits10) << t;
409  return os.str();
410 }

◆ stringToEnum()

template<typename T >
T Moose::stringToEnum ( const std::string &  s)

◆ stringToEnum< CoordinateSystemType >()

template<>
CoordinateSystemType Moose::stringToEnum< CoordinateSystemType > ( const std::string &  s)

Definition at line 216 of file Conversion.C.

217 {
219 
220  std::string upper(s);
221  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
222 
223  if (!coordinate_system_type_to_enum.count(upper))
224  mooseError("Unknown coordinate system type: ", upper);
225 
226  return coordinate_system_type_to_enum[upper];
227 }
std::map< std::string, CoordinateSystemType > coordinate_system_type_to_enum
Definition: Conversion.C:25
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
void initCoordinateSystemType()
Definition: Conversion.C:52

◆ stringToEnum< EigenProblemType >()

template<>
EigenProblemType Moose::stringToEnum< EigenProblemType > ( const std::string &  s)

Definition at line 261 of file Conversion.C.

262 {
264 
265  std::string upper(s);
266  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
267 
268  if (!eigen_problem_type_to_enum.count(upper))
269  mooseError("Unknown eigen problem type: ", upper);
270 
271  return eigen_problem_type_to_enum[upper];
272 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
std::map< std::string, EigenProblemType > eigen_problem_type_to_enum
Definition: Conversion.C:28
void initEigenProlemType()
Definition: Conversion.C:92

◆ stringToEnum< EigenSolveType >()

template<>
EigenSolveType Moose::stringToEnum< EigenSolveType > ( const std::string &  s)

Definition at line 246 of file Conversion.C.

247 {
249 
250  std::string upper(s);
251  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
252 
253  if (!eigen_solve_type_to_enum.count(upper))
254  mooseError("Unknown eigen solve type: ", upper);
255 
256  return eigen_solve_type_to_enum[upper];
257 }
std::map< std::string, EigenSolveType > eigen_solve_type_to_enum
Definition: Conversion.C:27
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
void initEigenSolveType()
Definition: Conversion.C:76

◆ stringToEnum< LineSearchType >()

template<>
LineSearchType Moose::stringToEnum< LineSearchType > ( const std::string &  s)

Definition at line 291 of file Conversion.C.

292 {
294 
295  std::string upper(s);
296  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
297 
298  if (!line_search_type_to_enum.count(upper))
299  mooseError("Unknown line search type: ", upper);
300 
301  return line_search_type_to_enum[upper];
302 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
void initLineSearchType()
Definition: Conversion.C:126
std::map< std::string, LineSearchType > line_search_type_to_enum
Definition: Conversion.C:30

◆ stringToEnum< MffdType >()

template<>
MffdType Moose::stringToEnum< MffdType > ( const std::string &  s)

Definition at line 321 of file Conversion.C.

322 {
323  initMffdType();
324 
325  std::string upper(s);
326  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
327 
328  if (!mffd_type_to_enum.count(upper))
329  mooseError("Unknown mffd type: ", upper);
330 
331  return mffd_type_to_enum[upper];
332 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
void initMffdType()
Definition: Conversion.C:165
std::map< std::string, MffdType > mffd_type_to_enum
Definition: Conversion.C:32

◆ stringToEnum< Order >()

template<>
Order Moose::stringToEnum< Order > ( const std::string &  s)

Definition at line 203 of file Conversion.C.

204 {
205  std::string upper(s);
206  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
207 
208  if (upper.compare("AUTO") == 0)
209  return INVALID_ORDER;
210  else
211  return Utility::string_to_enum<Order>(upper);
212 }

◆ stringToEnum< QuadratureType >()

template<>
QuadratureType Moose::stringToEnum< QuadratureType > ( const std::string &  s)

Definition at line 188 of file Conversion.C.

189 {
191 
192  std::string upper(s);
193  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
194 
195  if (!quadrature_type_to_enum.count(upper))
196  mooseError("Unknown quadrature type: ", upper);
197 
198  return quadrature_type_to_enum[upper];
199 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
void initQuadratureType()
Definition: Conversion.C:36
std::map< std::string, QuadratureType > quadrature_type_to_enum
Definition: Conversion.C:24

◆ stringToEnum< RelationshipManagerType >()

template<>
RelationshipManagerType Moose::stringToEnum< RelationshipManagerType > ( const std::string &  s)

Definition at line 336 of file Conversion.C.

337 {
338  initRMType();
339 
340  std::string upper(s);
341  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
342 
343  if (!rm_type_to_enum.count(upper))
344  mooseError("Unknown RelationshipManager type: ", upper);
345 
346  return rm_type_to_enum[upper];
347 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
std::map< std::string, RelationshipManagerType > rm_type_to_enum
Definition: Conversion.C:33
void initRMType()
Definition: Conversion.C:175

◆ stringToEnum< SolveType >()

template<>
SolveType Moose::stringToEnum< SolveType > ( const std::string &  s)

Definition at line 231 of file Conversion.C.

232 {
233  initSolveType();
234 
235  std::string upper(s);
236  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
237 
238  if (!solve_type_to_enum.count(upper))
239  mooseError("Unknown solve type: ", upper);
240 
241  return solve_type_to_enum[upper];
242 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
void initSolveType()
Definition: Conversion.C:63
std::map< std::string, SolveType > solve_type_to_enum
Definition: Conversion.C:26

◆ stringToEnum< TimeIntegratorType >()

template<>
TimeIntegratorType Moose::stringToEnum< TimeIntegratorType > ( const std::string &  s)

Definition at line 306 of file Conversion.C.

307 {
309 
310  std::string upper(s);
311  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
312 
313  if (!time_integrator_to_enum.count(upper))
314  mooseError("Unknown time integrator: ", upper);
315 
316  return time_integrator_to_enum[upper];
317 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
std::map< std::string, TimeIntegratorType > time_integrator_to_enum
Definition: Conversion.C:31
void initTimeIntegratorsType()
Definition: Conversion.C:150

◆ stringToEnum< WhichEigenPairs >()

template<>
WhichEigenPairs Moose::stringToEnum< WhichEigenPairs > ( const std::string &  s)

Definition at line 276 of file Conversion.C.

277 {
279 
280  std::string upper(s);
281  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
282 
283  if (!which_eigen_pairs_to_enum.count(upper))
284  mooseError("Unknown type of WhichEigenPairs: ", upper);
285 
286  return which_eigen_pairs_to_enum[upper];
287 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
std::map< std::string, WhichEigenPairs > which_eigen_pairs_to_enum
Definition: Conversion.C:29
void initWhichEigenPairs()
Definition: Conversion.C:107

◆ swapLibMeshComm()

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 526 of file Moose.C.

Referenced by Moose::ScopedCommSwapper::forceSwap(), and Moose::ScopedCommSwapper::~ScopedCommSwapper().

527 {
528 #ifdef LIBMESH_HAVE_PETSC
529  MPI_Comm old_comm = PETSC_COMM_WORLD;
530  PETSC_COMM_WORLD = new_comm;
531  return old_comm;
532 #endif // LIBMESH_HAVE_PETSC
533 }

◆ toPoint()

Point Moose::toPoint ( const std::vector< Real > &  pos)

Convert point represented as std::vector into Point.

Parameters
posPoint represented as a vector
Returns
Converted point

Definition at line 413 of file Conversion.C.

414 {
415  mooseAssert(pos.size() == LIBMESH_DIM, "Wrong array size while converting into a point");
416  return Point(pos[0], pos[1], pos[2]);
417 }

◆ vectorStringsToEnum()

template<typename T >
std::vector<T> Moose::vectorStringsToEnum ( const MultiMooseEnum v)

Variable Documentation

◆ _color_console

bool Moose::_color_console = isatty(fileno(stdout))
static

Definition at line 535 of file Moose.C.

Referenced by colorConsole(), and setColorConsole().

◆ _deprecated_is_error

bool Moose::_deprecated_is_error = false

Variable to toggle only deprecated warnings as errors.

Definition at line 552 of file Moose.C.

Referenced by moose::internal::mooseDeprecatedStream(), and MooseApp::setupOptions().

◆ _throw_on_error

bool Moose::_throw_on_error = false

Variable to turn on exceptions during mooseError() and mooseWarning(), should only be used with MOOSE unit.

Definition at line 554 of file Moose.C.

Referenced by moose::internal::mooseErrorRaw(), moose::internal::mooseUnusedStream(), and moose::internal::mooseWarningStream().

◆ _trap_fpe

bool Moose::_trap_fpe

Variable indicating whether we will enable FPE trapping for this run.

◆ _warnings_are_errors

bool Moose::_warnings_are_errors = false

Variable to toggle any warning into an error (includes deprecated code warnings)

Definition at line 550 of file Moose.C.

Referenced by moose::internal::mooseWarningStream(), and MooseApp::setupOptions().

◆ ANY_BLOCK_ID

const SubdomainID Moose::ANY_BLOCK_ID = libMesh::Elem::invalid_subdomain_id - 1

◆ ANY_BOUNDARY_ID

const BoundaryID Moose::ANY_BOUNDARY_ID = static_cast<BoundaryID>(-1)

◆ coordinate_system_type_to_enum

std::map<std::string, CoordinateSystemType> Moose::coordinate_system_type_to_enum

Definition at line 25 of file Conversion.C.

Referenced by initCoordinateSystemType(), and stringToEnum< CoordinateSystemType >().

◆ eigen_problem_type_to_enum

std::map<std::string, EigenProblemType> Moose::eigen_problem_type_to_enum

Definition at line 28 of file Conversion.C.

Referenced by initEigenProlemType(), and stringToEnum< EigenProblemType >().

◆ eigen_solve_type_to_enum

std::map<std::string, EigenSolveType> Moose::eigen_solve_type_to_enum

Definition at line 27 of file Conversion.C.

Referenced by initEigenSolveType(), and stringToEnum< EigenSolveType >().

◆ EMPTY_BLOCK_IDS

const std::set<SubdomainID> Moose::EMPTY_BLOCK_IDS = {}

Definition at line 452 of file MooseTypes.h.

◆ EMPTY_BOUNDARY_IDS

const std::set<BoundaryID> Moose::EMPTY_BOUNDARY_IDS = {}

Definition at line 453 of file MooseTypes.h.

◆ execute_flags

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

◆ INVALID_BLOCK_ID

const SubdomainID Moose::INVALID_BLOCK_ID = libMesh::Elem::invalid_subdomain_id

◆ INVALID_BOUNDARY_ID

const BoundaryID Moose::INVALID_BOUNDARY_ID = libMesh::BoundaryInfo::invalid_id

Definition at line 18 of file MooseTypes.C.

Referenced by MooseMesh::getBoundaryID().

◆ line_search_type_to_enum

std::map<std::string, LineSearchType> Moose::line_search_type_to_enum

Definition at line 30 of file Conversion.C.

Referenced by initLineSearchType(), and stringToEnum< LineSearchType >().

◆ mffd_type_to_enum

std::map<std::string, MffdType> Moose::mffd_type_to_enum

Definition at line 32 of file Conversion.C.

Referenced by initMffdType(), and stringToEnum< MffdType >().

◆ perf_log

PerfLog Moose::perf_log

Perflog to be used by applications.

If the application prints this in the end they will get performance info.

Referenced by CheckOutputAction::checkPerfLogOutput(), PerformanceData::getValue(), NonlinearSystemBase::init(), Console::output(), MooseApp::setupOptions(), and Console::~Console().

◆ quadrature_type_to_enum

std::map<std::string, QuadratureType> Moose::quadrature_type_to_enum

Definition at line 24 of file Conversion.C.

Referenced by initQuadratureType(), and stringToEnum< QuadratureType >().

◆ rm_type_to_enum

std::map<std::string, RelationshipManagerType> Moose::rm_type_to_enum

Definition at line 33 of file Conversion.C.

Referenced by initRMType(), and stringToEnum< RelationshipManagerType >().

◆ solve_type_to_enum

std::map<std::string, SolveType> Moose::solve_type_to_enum

Definition at line 26 of file Conversion.C.

Referenced by initSolveType(), and stringToEnum< SolveType >().

◆ time_integrator_to_enum

std::map<std::string, TimeIntegratorType> Moose::time_integrator_to_enum

Definition at line 31 of file Conversion.C.

Referenced by initTimeIntegratorsType(), and stringToEnum< TimeIntegratorType >().

◆ which_eigen_pairs_to_enum

std::map<std::string, WhichEigenPairs> Moose::which_eigen_pairs_to_enum

Definition at line 29 of file Conversion.C.

Referenced by initWhichEigenPairs(), and stringToEnum< WhichEigenPairs >().