Moose Namespace Reference

Namespaces
	PetscSupport
	SlepcSupport

Classes
struct	indirect_comparator
struct	RealType
struct	RealType< JACOBIAN >
class	ScopedCommSwapper
struct	ValueType
struct	ValueType< Real, compute_stage >
struct	ValueType< W< Real >, compute_stage >

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 >
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...
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< SubdomainID >	EMPTY_BLOCK_IDS = {}
const std::set< BoundaryID >	EMPTY_BOUNDARY_IDS = {}
static bool	_color_console = isatty(fileno(stdout))
std::map< std::string, QuadratureType >	quadrature_type_to_enum
std::map< std::string, CoordinateSystemType >	coordinate_system_type_to_enum
std::map< std::string, SolveType >	solve_type_to_enum
std::map< std::string, EigenSolveType >	eigen_solve_type_to_enum
std::map< std::string, EigenProblemType >	eigen_problem_type_to_enum
std::map< std::string, WhichEigenPairs >	which_eigen_pairs_to_enum
std::map< std::string, LineSearchType >	line_search_type_to_enum
std::map< std::string, TimeIntegratorType >	time_integrator_to_enum
std::map< std::string, MffdType >	mffd_type_to_enum
std::map< std::string, RelationshipManagerType >	rm_type_to_enum

Enumeration Type Documentation

AuxGroup

enum Moose::AuxGroup

Flag for AuxKernel related execution type.

Enumerator
PRE_IC
PRE_AUX
POST_AUX
ALL

Definition at line 432 of file MooseTypes.h.

{
  PRE_IC = 0,
  PRE_AUX = 1,
  POST_AUX = 2,
  ALL = 3
};

ConstraintFormulationType

enum Moose::ConstraintFormulationType

Type of constraint formulation.

Enumerator
Penalty
Kinematic

Definition at line 606 of file MooseTypes.h.

{
  Penalty,
  Kinematic
};

ConstraintJacobianType

enum Moose::ConstraintJacobianType

Enumerator
SlaveSlave
SlaveMaster
MasterSlave
MasterMaster

Definition at line 491 of file MooseTypes.h.

{
  SlaveSlave = ElementElement,
  SlaveMaster = ElementNeighbor,
  MasterSlave = NeighborElement,
  MasterMaster = NeighborNeighbor
};

ConstraintSideType

enum Moose::ConstraintSideType

Enumerator
SIDE_MASTER
SIDE_SLAVE

Definition at line 465 of file MooseTypes.h.

{
  SIDE_MASTER,
  SIDE_SLAVE
};

ConstraintType

enum Moose::ConstraintType

Enumerator
Slave
Master

Definition at line 485 of file MooseTypes.h.

{
  Slave = Element,
  Master = Neighbor
};

CoordinateSystemType

enum Moose::CoordinateSystemType

Enumerator
COORD_XYZ
COORD_RZ
COORD_RSPHERICAL

Definition at line 499 of file MooseTypes.h.

{
  COORD_XYZ,
  COORD_RZ,
  COORD_RSPHERICAL
};

CouplingType

enum Moose::CouplingType

Enumerator
COUPLING_DIAG
COUPLING_FULL
COUPLING_CUSTOM

Definition at line 458 of file MooseTypes.h.

{
  COUPLING_DIAG,
  COUPLING_FULL,
  COUPLING_CUSTOM
};

DGJacobianType

enum Moose::DGJacobianType

Enumerator
ElementElement
ElementNeighbor
NeighborElement
NeighborNeighbor

Definition at line 477 of file MooseTypes.h.

{
  ElementElement,
  ElementNeighbor,
  NeighborElement,
  NeighborNeighbor
};

DGResidualType

enum Moose::DGResidualType

Enumerator
Element
Neighbor

Definition at line 471 of file MooseTypes.h.

{
  Element,
  Neighbor
};

EigenProblemType

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

{
  EPT_HERMITIAN,             
  EPT_NON_HERMITIAN,         
  EPT_GEN_HERMITIAN,         
  EPT_GEN_INDEFINITE,        
  EPT_GEN_NON_HERMITIAN,     
  EPT_POS_GEN_NON_HERMITIAN, 
  EPT_SLEPC_DEFAULT          
};

EigenSolveType

enum Moose::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 544 of file MooseTypes.h.

{
  EST_POWER,              
  EST_ARNOLDI,            
  EST_KRYLOVSCHUR,        
  EST_JACOBI_DAVIDSON,    
  EST_NONLINEAR_POWER,    
  EST_MF_NONLINEAR_POWER, 
  EST_MONOLITH_NEWTON,    
  EST_MF_MONOLITH_NEWTON, 
};

LineSearchType

enum Moose::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 614 of file MooseTypes.h.

{
  LS_INVALID, 
  LS_DEFAULT,
  LS_NONE,
  LS_BASIC,
#ifdef LIBMESH_HAVE_PETSC
#if PETSC_VERSION_LESS_THAN(3, 3, 0)
  LS_CUBIC,
  LS_QUADRATIC,
  LS_BASICNONORMS,
#else
  LS_SHELL,
  LS_CONTACT,
  LS_L2,
  LS_BT,
  LS_CP
#endif
#endif
};

MaterialDataType

enum Moose::MaterialDataType

MaterialData types.

See also

FEProblemBase, MaterialPropertyInterface

Enumerator
BLOCK_MATERIAL_DATA
BOUNDARY_MATERIAL_DATA
FACE_MATERIAL_DATA
NEIGHBOR_MATERIAL_DATA

Definition at line 421 of file MooseTypes.h.

{
  BLOCK_MATERIAL_DATA,
  BOUNDARY_MATERIAL_DATA,
  FACE_MATERIAL_DATA,
  NEIGHBOR_MATERIAL_DATA
};

MffdType

enum Moose::MffdType

Type of the matrix-free finite-differencing parameter.

Enumerator
MFFD_INVALID	means not set
MFFD_WP
MFFD_DS

Definition at line 638 of file MooseTypes.h.

{
  MFFD_INVALID, 
  MFFD_WP,
  MFFD_DS
};

MooseKSPNormType

enum Moose::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 520 of file MooseTypes.h.

{
  KSPN_NONE,
  KSPN_PRECONDITIONED,
  KSPN_UNPRECONDITIONED,
  KSPN_NATURAL,
  KSPN_DEFAULT 
};

PatchUpdateType

enum Moose::PatchUpdateType

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

Enumerator
Never
Always
Auto
Iteration

Definition at line 648 of file MooseTypes.h.

{
  Never,
  Always,
  Auto,
  Iteration
};

PCSideType

enum Moose::PCSideType

Preconditioning side.

Enumerator
PCS_LEFT
PCS_RIGHT
PCS_SYMMETRIC
PCS_DEFAULT	Use whatever we have in PETSc.

Definition at line 509 of file MooseTypes.h.

{
  PCS_LEFT,
  PCS_RIGHT,
  PCS_SYMMETRIC,
  PCS_DEFAULT 
};

RelationshipManagerType

enum Moose::RelationshipManagerType : unsigned char

strong

Main types of Relationship Managers.

Enumerator
DEFAULT
GEOMETRIC
ALGEBRAIC
COUPLING

Definition at line 659 of file MooseTypes.h.

                                   : unsigned char
{
  DEFAULT = 0,
  GEOMETRIC = 1 << 0,
  ALGEBRAIC = 1 << 1,
  COUPLING = 1 << 2
};

SolveType

enum Moose::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 532 of file MooseTypes.h.

{
  ST_PJFNK,  
  ST_JFNK,   
  ST_NEWTON, 
  ST_FD,     
  ST_LINEAR  
};

TimeIntegratorType

enum Moose::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 591 of file MooseTypes.h.

{
  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
};

VarFieldType

enum Moose::VarFieldType

Enumerator
VAR_FIELD_STANDARD
VAR_FIELD_SCALAR
VAR_FIELD_VECTOR
VAR_FIELD_ANY

Definition at line 450 of file MooseTypes.h.

{
  VAR_FIELD_STANDARD,
  VAR_FIELD_SCALAR,
  VAR_FIELD_VECTOR,
  VAR_FIELD_ANY
};

VarKindType

enum Moose::VarKindType

Framework-wide stuff.

Enumerator
VAR_NONLINEAR
VAR_AUXILIARY
VAR_ANY

Definition at line 443 of file MooseTypes.h.

{
  VAR_NONLINEAR,
  VAR_AUXILIARY,
  VAR_ANY
};

WhichEigenPairs

enum Moose::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 573 of file MooseTypes.h.

{
  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       
};

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

{
  // clang-format off
  /**************************/
  /**** Register Actions ****/
  /**************************/
  registerMooseObjectTask("create_problem",               Problem,                false);
  registerMooseObjectTask("setup_executioner",            Executioner,            false);

  // This task does not construct an object, but it needs all of the parameters that
  // would normally be used to construct an object.
  registerMooseObjectTask("determine_system_type",        Executioner,            true);

  registerMooseObjectTask("setup_mesh",                   MooseMesh,              false);
  registerMooseObjectTask("set_mesh_base",                MooseMesh,              false);
  registerMooseObjectTask("init_mesh",                    MooseMesh,              false);
  registerMooseObjectTask("add_mesh_modifier",            MeshModifier,           false);
  registerMooseObjectTask("add_mesh_generator",           MeshGenerator,          false);

  registerMooseObjectTask("add_kernel",                   Kernel,                 false);
  appendMooseObjectTask  ("add_kernel",                   EigenKernel);
  appendMooseObjectTask  ("add_kernel",                   VectorKernel);

  registerMooseObjectTask("add_ad_kernel",                ADKernel,               false);
  appendMooseObjectTask  ("add_ad_kernel",                ADVectorKernel);

  registerMooseObjectTask("add_nodal_kernel",             NodalKernel,            false);

  registerMooseObjectTask("add_material",                 Material,               false);
  registerMooseObjectTask("add_ad_material",              ADMaterial,             false);
  registerMooseObjectTask("add_bc",                       BoundaryCondition,      false);
  registerMooseObjectTask("add_ad_bc",                    ADIntegratedBC,         false);
  appendMooseObjectTask  ("add_ad_bc",                    ADVectorIntegratedBC);
  appendMooseObjectTask  ("add_ad_bc",                    ADNodalBC);
  appendMooseObjectTask  ("add_ad_bc",                    ADVectorNodalBC);

  registerMooseObjectTask("add_function",                 Function,               false);
  registerMooseObjectTask("add_distribution",             Distribution,           false);
  registerMooseObjectTask("add_sampler",                  Sampler,                false);

  registerMooseObjectTask("add_aux_kernel",               AuxKernel,              false);
  registerMooseObjectTask("add_elemental_field_variable", AuxKernel,              false);

  registerMooseObjectTask("add_scalar_kernel",            ScalarKernel,           false);
  registerMooseObjectTask("add_aux_scalar_kernel",        AuxScalarKernel,        false);
  registerMooseObjectTask("add_dirac_kernel",             DiracKernel,            false);
  registerMooseObjectTask("add_dg_kernel",                DGKernel,               false);
  registerMooseObjectTask("add_interface_kernel",         InterfaceKernel,        false);
  registerMooseObjectTask("add_constraint",               Constraint,             false);

  registerMooseObjectTask("add_ic",                       InitialCondition,       false);
  appendMooseObjectTask  ("add_ic",                       ScalarInitialCondition);

  registerMooseObjectTask("add_damper",                   Damper,                 false);
  registerMooseObjectTask("setup_predictor",              Predictor,              false);
  registerMooseObjectTask("setup_time_stepper",           TimeStepper,            false);
  registerMooseObjectTask("setup_time_integrator",        TimeIntegrator,         false);

  registerMooseObjectTask("add_preconditioning",          MoosePreconditioner,    false);
  registerMooseObjectTask("add_field_split",              Split,                  false);

  registerMooseObjectTask("add_user_object",              UserObject,             false);
  appendMooseObjectTask  ("add_user_object",              Postprocessor);

  registerMooseObjectTask("add_postprocessor",            Postprocessor,          false);
  registerMooseObjectTask("add_vector_postprocessor",     VectorPostprocessor,    false);

  registerMooseObjectTask("add_indicator",                Indicator,              false);
  registerMooseObjectTask("add_marker",                   Marker,                 false);

  registerMooseObjectTask("add_multi_app",                MultiApp,               false);
  registerMooseObjectTask("add_transfer",                 Transfer,               false);

  registerMooseObjectTask("add_output",                   Output,                 false);

  registerMooseObjectTask("add_control",                  Control,                false);
  registerMooseObjectTask("add_partitioner",              MoosePartitioner,       false);

  // clang-format on

  registerTask("dynamic_object_registration", false);
  registerTask("common_output", true);
  registerTask("setup_recover_file_base", true);

  registerTask("add_bounds_vectors", false);
  registerTask("add_periodic_bc", false);
  registerTask("add_aux_variable", false);
  registerTask("add_external_aux_variables", true);
  registerTask("add_variable", false);

  registerTask("execute_mesh_modifiers", false);
  registerTask("execute_mesh_generators", true);
  registerTask("uniform_refine_mesh", false);
  registerTask("prepare_mesh", false);
  registerTask("add_geometric_rm", true);
  registerTask("setup_mesh_complete", true); // calls prepare

  registerTask("init_displaced_problem", false);

  registerTask("add_algebraic_rm", true);
  registerTask("init_problem", true);
  registerTask("check_copy_nodal_vars", true);
  registerTask("copy_nodal_vars", true);
  registerTask("copy_nodal_aux_vars", true);
  registerTask("setup_postprocessor_data", false);

  registerTask("setup_dampers", true);
  registerTask("check_integrity", true);
  registerTask("check_integrity_early", true);
  registerTask("setup_quadrature", true);

  registerTask("no_action", false); // Used for Empty Action placeholders
  registerTask("set_global_params", false);
  registerTask("setup_adaptivity", false);
  registerTask("meta_action", false);
  registerTask("setup_residual_debug", false);
  registerTask("setup_oversampling", false);
  registerTask("deprecated_block", false);
  registerTask("set_adaptivity_options", false);
  registerTask("add_mortar_interface", false);

  // Dummy Actions (useful for sync points in the dependencies)
  registerTask("setup_function_complete", false);
  registerTask("setup_variable_complete", false);
  registerTask("ready_to_init", true);

  // Output related actions
  registerTask("add_output_aux_variables", true);
  registerTask("check_output", true);

  registerTask("create_problem_default", true);
  registerTask("create_problem_custom", false);
  registerTask("create_problem_complete", false);

  // Deprecated tasks
  registerTask("setup_material_output", false);
  registerTask("setup_debug", false);

  /**************************/
  /****** Dependencies ******/
  /**************************/
  syntax.addDependencySets(
      "(meta_action)"
      "(dynamic_object_registration)"
      "(common_output)"
      "(set_global_params)"
      "(setup_recover_file_base)"
      "(setup_mesh)"
      "(add_mesh_generator)"
      "(execute_mesh_generators)"
      "(set_mesh_base)"
      "(check_copy_nodal_vars)"
      "(add_partitioner)"
      "(add_geometric_rm)"
      "(init_mesh)"
      "(prepare_mesh)"
      "(add_mesh_modifier)"
      "(execute_mesh_modifiers)"
      "(add_mortar_interface)"
      "(uniform_refine_mesh)"
      "(setup_mesh_complete)"
      "(determine_system_type)"
      "(create_problem)"
      "(create_problem_custom)"
      "(create_problem_default)"
      "(create_problem_complete)"
      "(setup_postprocessor_data)"
      "(setup_time_integrator)"
      "(setup_executioner)"
      "(check_integrity_early)"
      "(setup_predictor)"
      "(init_displaced_problem)"
      "(add_aux_variable, add_variable, add_elemental_field_variable,"
      " add_external_aux_variables)"
      "(setup_variable_complete)"
      "(setup_quadrature)"
      "(add_function)"
      "(add_distribution)"
      "(add_sampler)"
      "(add_periodic_bc)"
      "(add_user_object)"
      "(setup_function_complete)"
      "(setup_adaptivity)"
      "(set_adaptivity_options)"
      "(add_ic)"
      "(add_constraint, add_field_split)"
      "(add_preconditioning)"
      "(setup_time_stepper)"
      "(ready_to_init)"
      "(setup_dampers)"
      "(setup_residual_debug)"
      "(add_bounds_vectors)"
      "(add_multi_app)"
      "(add_transfer)"
      "(copy_nodal_vars, copy_nodal_aux_vars)"
      "(add_material, add_ad_material)"
      "(setup_material_output)" // DEPRECATED: Remove by 12/31/2018
      "(add_output_aux_variables)"
      "(add_algebraic_rm)"
      "(init_problem)"
      "(setup_debug)" // DEPRECATED: Remove by 12/31/2018
      "(add_output)"
      "(add_postprocessor)"
      "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
                                   // to be after material objects are created.
      "(add_aux_kernel, add_bc, add_ad_bc, add_damper, add_dirac_kernel, add_kernel,"
      " add_ad_kernel, add_nodal_kernel, add_dg_kernel, add_interface_kernel,"
      " add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker)"
      "(add_control)"
      "(check_output)"
      "(check_integrity)");
}

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

{
  T tmp;
  tmp.resize(container.size());
  for (size_t i = 0; i < indices.size(); i++)
    tmp[i] = container[indices[i]];
  std::swap(tmp, container);
}

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

{
  EigenProblem * p = es.parameters.get<EigenProblem *>("_eigen_problem");
  EigenSystem & eigen_system = es.get_system<EigenSystem>(system_name);
  NonlinearEigenSystem & eigen_nl = p->getNonlinearEigenSystem();

  // If it is a linear generalized eigenvalue problem,
  // we assemble A and B together
  if (!p->isNonlinearEigenvalueSolver() && eigen_system.generalized())
  {
    p->computeJacobianAB(*eigen_system.current_local_solution.get(),
                         *eigen_system.matrix_A,
                         *eigen_system.matrix_B,
                         eigen_nl.nonEigenMatrixTag(),
                         eigen_nl.eigenMatrixTag());
    return;
  }

  if (!p->isNonlinearEigenvalueSolver())
  {
    p->computeJacobianTag(*eigen_system.current_local_solution.get(),
                          *eigen_system.matrix_A,
                          eigen_nl.nonEigenMatrixTag());
  }
  else
  {
    Mat petsc_mat_A = static_cast<PetscMatrix<Number> &>(*eigen_system.matrix_A).mat();

    PetscObjectComposeFunction((PetscObject)petsc_mat_A,
                               "formJacobian",
                               Moose::SlepcSupport::mooseSlepcEigenFormJacobianA);
    PetscObjectComposeFunction((PetscObject)petsc_mat_A,
                               "formFunction",
                               Moose::SlepcSupport::mooseSlepcEigenFormFunctionA);

    PetscObjectComposeFunction((PetscObject)petsc_mat_A,
                               "formFunctionAB",
                               Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB);

    PetscContainer container;
    PetscContainerCreate(eigen_system.comm().get(), &container);
    PetscContainerSetPointer(container, p);
    PetscObjectCompose((PetscObject)petsc_mat_A, "formJacobianCtx", nullptr);
    PetscObjectCompose((PetscObject)petsc_mat_A, "formJacobianCtx", (PetscObject)container);
    PetscObjectCompose((PetscObject)petsc_mat_A, "formFunctionCtx", nullptr);
    PetscObjectCompose((PetscObject)petsc_mat_A, "formFunctionCtx", (PetscObject)container);
    PetscContainerDestroy(&container);

    // Let libmesh do not close matrices before solve
    eigen_system.eigen_solver->set_close_matrix_before_solve(false);
  }
  if (eigen_system.generalized())
  {
    if (eigen_system.matrix_B)
    {
      if (!p->isNonlinearEigenvalueSolver())
      {
        p->computeJacobianTag(*eigen_system.current_local_solution.get(),
                              *eigen_system.matrix_B,
                              eigen_nl.eigenMatrixTag());
      }
      else
      {
        Mat petsc_mat_B = static_cast<PetscMatrix<Number> &>(*eigen_system.matrix_B).mat();

        PetscObjectComposeFunction((PetscObject)petsc_mat_B,
                                   "formJacobian",
                                   Moose::SlepcSupport::mooseSlepcEigenFormJacobianB);
        PetscObjectComposeFunction((PetscObject)petsc_mat_B,
                                   "formFunction",
                                   Moose::SlepcSupport::mooseSlepcEigenFormFunctionB);

        PetscContainer container;
        PetscContainerCreate(eigen_system.comm().get(), &container);
        PetscContainerSetPointer(container, p);
        PetscObjectCompose((PetscObject)petsc_mat_B, "formFunctionCtx", nullptr);
        PetscObjectCompose((PetscObject)petsc_mat_B, "formFunctionCtx", (PetscObject)container);
        PetscObjectCompose((PetscObject)petsc_mat_B, "formJacobianCtx", nullptr);
        PetscObjectCompose((PetscObject)petsc_mat_B, "formJacobianCtx", (PetscObject)container);
        PetscContainerDestroy(&container);
      }
    }
    else
      mooseError("It is a generalized eigenvalue problem but matrix B is empty\n");
  }
}

associateSyntax()

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

Definition at line 526 of file Moose.C.

{
  associateSyntaxInner(syntax, action_factory);
  registerActions(syntax, action_factory);
}

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

Referenced by associateSyntax(), and registerAll().

{
  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");

  registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
  registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
  registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
  registerSyntaxTask("AddKernelAction", "Bounds/*", "add_aux_kernel");

  registerSyntaxTask("AddADKernelAction", "ADKernels/*", "add_ad_kernel");

  registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
  registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");

  registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
  registerSyntaxTask("AddADBCAction", "ADBCs/*", "add_ad_bc");

  registerSyntax("CreateProblemAction", "Problem");
  registerSyntax("DynamicObjectRegistrationAction", "Problem");
  registerSyntax("SetupMeshAction", "Mesh");
  registerSyntax("SetupMeshCompleteAction", "Mesh");
  //  registerSyntaxTask("SetupMeshCompleteAction", "Mesh", "prepare_mesh");
  //  registerSyntaxTask("SetupMeshCompleteAction", "Mesh", "setup_mesh_complete");
  registerSyntax("CreateDisplacedProblemAction", "Mesh");
  registerSyntax("AddMeshModifierAction", "MeshModifiers/*");
  registerSyntax("AddMeshGeneratorAction", "MeshGenerators/*");
  registerSyntax("AddMortarInterfaceAction", "Mesh/MortarInterfaces/*");

  registerSyntax("AddFunctionAction", "Functions/*");
  syntax.registerSyntaxType("Functions/*", "FunctionName");

  registerSyntax("GlobalParamsAction", "GlobalParams");

  registerSyntax("AddDistributionAction", "Distributions/*");
  registerSyntax("AddSamplerAction", "Samplers/*");

  registerSyntax("SetupDebugAction", "Debug");
  registerSyntax("SetupResidualDebugAction", "Debug");

  registerSyntax("AddVariableAction", "Variables/*");
  syntax.registerSyntaxType("Variables/*", "VariableName");
  syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
  //  syntax.registerActionSyntax("AddVariableAction", "Variables/*", "add_variable");
  //  syntax.registerActionSyntax("AddVariableAction", "Variables/*", "add_ic");

  registerSyntax("AddICAction", "Variables/*/InitialCondition");

  registerSyntax("AddAuxVariableAction", "AuxVariables/*");
  syntax.registerSyntaxType("AuxVariables/*", "VariableName");
  syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
  //  syntax.registerActionSyntax("AddAuxVariableAction", "AuxVariables/*", "add_aux_variable");
  //  syntax.registerActionSyntax("AddAuxVariableAction", "AuxVariables/*", "add_ic");

  registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");

  registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
  registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");

  registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");

  registerSyntax("AddMaterialAction", "Materials/*");
  registerSyntaxTask("AddADMaterialAction", "ADMaterials/*", "add_ad_material");

  registerSyntax("SetupPostprocessorDataAction", "Postprocessors/*");
  registerSyntax("AddPostprocessorAction", "Postprocessors/*");
  syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
  syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");

  registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
  syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");

  registerSyntax("AddDamperAction", "Dampers/*");

  registerSyntax("AddOutputAction", "Outputs/*");
  registerSyntax("CommonOutputAction", "Outputs");
  syntax.registerSyntaxType("Outputs/*", "OutputName");

  // Note: Preconditioner Actions will be built by this setup action
  registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
  registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");

  registerSyntax("CreateExecutionerAction", "Executioner");
  registerSyntax("SetupTimeStepperAction", "Executioner/TimeStepper");
  registerSyntax("SetupTimeIntegratorAction", "Executioner/TimeIntegrator");

  registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
  registerSyntax("SetupPredictorAction", "Executioner/Predictor");
#ifdef LIBMESH_ENABLE_AMR
  registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
#endif

  registerSyntax("PartitionerAction", "Mesh/Partitioner");

  registerSyntax("AddDiracKernelAction", "DiracKernels/*");

  registerSyntax("AddDGKernelAction", "DGKernels/*");

  registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");

  registerSyntax("AddConstraintAction", "Constraints/*");

  registerSyntax("AddUserObjectAction", "UserObjects/*");
  syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
  registerSyntax("AddControlAction", "Controls/*");
  registerSyntax("AddBoundsVectorsAction", "Bounds");

  registerSyntax("AddNodalNormalsAction", "NodalNormals");
  //  registerSyntaxTask("AddNodalNormalsAction", "NodalNormals", "add_aux_variable");
  //  registerSyntaxTask("AddNodalNormalsAction", "NodalNormals", "add_postprocessor");
  //  registerSyntaxTask("AddNodalNormalsAction", "NodalNormals", "add_user_object");

  // Indicator
  registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
  registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
  syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");

  // Marker
  registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
  registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
  syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");

  // New Adaptivity System
  registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");

  // Deprecated Block
  registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");

  // Multi Apps
  registerSyntax("AddMultiAppAction", "MultiApps/*");
  syntax.registerSyntaxType("MultiApps/*", "MultiAppName");

  // Transfers
  registerSyntax("AddTransferAction", "Transfers/*");

  // Material derivative test
  registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder
  registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");

  addActionTypes(syntax);
}

colorConsole()

bool Moose::colorConsole

(

)

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

Definition at line 554 of file Moose.C.

{
  return _color_console;
}

compute_bounds()

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

Definition at line 37 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeBounds(sys, lower, upper);
}

compute_jacobian()

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

Definition at line 27 of file NonlinearSystem.C.

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

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeJacobianSys(sys, soln, jacobian);
}

compute_nearnullspace()

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

Definition at line 64 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeNearNullSpace(sys, sp);
}

compute_nullspace()

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

Definition at line 47 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeNullSpace(sys, sp);
}

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

Referenced by NonlinearSystem::solve().

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computePostCheck(
      sys, old_soln, search_direction, new_soln, changed_search_direction, changed_new_soln);
}

compute_transpose_nullspace()

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

Definition at line 55 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeTransposeNullSpace(sys, 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

p0	The beginning of the line
p1	The end of the line
intersected_elems	The elements intersected by the line. Will be empty if there are no intersections.
segments	The line segments across each element

Definition at line 192 of file RayTracing.C.

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

{
  // Make sure our list is clear
  intersected_elems.clear();

  // Find the starting element
  const Elem * first_elem = point_locator(p0);

  // Quick return if can't even locate the first element.
  if (!first_elem)
    return;

  intersected_elems.push_back(const_cast<Elem *>(first_elem));

  // Make a LineSegment object out of our two points for ease:
  LineSegment line_segment = LineSegment(p0, p1);

  // Find 'em!
  recursivelyFindElementsIntersectedByLine(
      line_segment, first_elem, -1, p0, intersected_elems, segments);
}

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

p0	Point in plane.
normal	Normal vector to plane.
intersected_elems	The elements intersected by the plane. Will be empty if there are no intersections.

Definition at line 53 of file ElementsIntersectedByPlane.C.

Referenced by ElementsAlongPlane::execute().

{
  // Make sure our list is clear
  intersected_elems.clear();

  // Create plane from point and normal:
  Plane plane(p0, normal);

  // Find 'em!
  findElementsIntersectedByPlane(plane, mesh, 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

p0	Point in plane.
p1	Point in plane.
p2	Point in plane.
intersected_elems	The elements intersected by the plane. Will be empty if there are no intersections.

Definition at line 69 of file ElementsIntersectedByPlane.C.

{
  // Make sure our list is clear
  intersected_elems.clear();

  // Create plane from three points:
  Plane plane(p0, p1, p2);

  // Find 'em!
  findElementsIntersectedByPlane(plane, mesh, intersected_elems);
}

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_info	The penetration info object, contains master_elem, side, various other information
fe_elem	FE object for the element
fe_side	FE object for the side
fe_side_type	The type of fe_side, needed for inverse_map routines
start_with_centroid	if true, start inverse mapping procedure from element centroid
tangential_tolerance	'tangential' tolerance for determining whether a contact point on a side
slave_point	The physical space coordinates of the slave node
contact_point_on_side	whether or not the contact_point actually lies on that side of the element.

Definition at line 45 of file FindContactPoint.C.

Referenced by PenetrationThread::createInfoForElem(), and PenetrationThread::operator()().

{
  const Elem * master_elem = p_info._elem;

  unsigned int dim = master_elem->dim();

  const Elem * side = p_info._side;

  const std::vector<Point> & phys_point = fe_side->get_xyz();

  const std::vector<RealGradient> & dxyz_dxi = fe_side->get_dxyzdxi();
  const std::vector<RealGradient> & d2xyz_dxi2 = fe_side->get_d2xyzdxi2();
  const std::vector<RealGradient> & d2xyz_dxieta = fe_side->get_d2xyzdxideta();

  const std::vector<RealGradient> & dxyz_deta = fe_side->get_dxyzdeta();
  const std::vector<RealGradient> & d2xyz_deta2 = fe_side->get_d2xyzdeta2();
  const std::vector<RealGradient> & d2xyz_detaxi = fe_side->get_d2xyzdxideta();

  if (dim == 1)
  {
    const Node * nearest_node = side->node_ptr(0);
    p_info._closest_point = *nearest_node;
    p_info._closest_point_ref =
        master_elem->master_point(master_elem->get_node_index(nearest_node));
    std::vector<Point> elem_points = {p_info._closest_point_ref};
    fe_elem->reinit(master_elem, &elem_points);

    const std::vector<RealGradient> & elem_dxyz_dxi = fe_elem->get_dxyzdxi();
    p_info._normal = elem_dxyz_dxi[0];
    if (nearest_node->id() == master_elem->node_id(0))
      p_info._normal *= -1.0;
    p_info._normal /= p_info._normal.norm();

    Point from_slave_to_closest = p_info._closest_point - slave_point;
    p_info._distance = from_slave_to_closest * p_info._normal;
    Point tangential = from_slave_to_closest - p_info._distance * p_info._normal;
    p_info._tangential_distance = tangential.norm();
    p_info._dxyzdxi = dxyz_dxi;
    p_info._dxyzdeta = dxyz_deta;
    p_info._d2xyzdxideta = d2xyz_dxieta;
    p_info._side_phi = fe_side->get_phi();
    p_info._side_grad_phi = fe_side->get_dphi();
    contact_point_on_side = true;
    return;
  }

  Point ref_point;

  if (start_with_centroid)
    ref_point =
        FEInterface::inverse_map(dim - 1, fe_side_type, side, side->centroid(), TOLERANCE, false);
  else
    ref_point = p_info._closest_point_ref;

  std::vector<Point> points = {ref_point};
  fe_side->reinit(side, &points);
  RealGradient d = slave_point - phys_point[0];

  Real update_size = std::numeric_limits<Real>::max();

  // Least squares
  for (unsigned int it = 0; it < 3 && update_size > TOLERANCE * 1e3; ++it)
  {
    DenseMatrix<Real> jac(dim - 1, dim - 1);

    jac(0, 0) = -(dxyz_dxi[0] * dxyz_dxi[0]);

    if (dim - 1 == 2)
    {
      jac(1, 0) = -(dxyz_dxi[0] * dxyz_deta[0]);
      jac(0, 1) = -(dxyz_deta[0] * dxyz_dxi[0]);
      jac(1, 1) = -(dxyz_deta[0] * dxyz_deta[0]);
    }

    DenseVector<Real> rhs(dim - 1);

    rhs(0) = dxyz_dxi[0] * d;

    if (dim - 1 == 2)
      rhs(1) = dxyz_deta[0] * d;

    DenseVector<Real> update(dim - 1);

    jac.lu_solve(rhs, update);

    ref_point(0) -= update(0);

    if (dim - 1 == 2)
      ref_point(1) -= update(1);

    points[0] = ref_point;
    fe_side->reinit(side, &points);
    d = slave_point - phys_point[0];

    update_size = update.l2_norm();
  }

  update_size = std::numeric_limits<Real>::max();

  unsigned nit = 0;

  // Newton Loop
  for (; nit < 12 && update_size > TOLERANCE * TOLERANCE; nit++)
  {
    d = slave_point - phys_point[0];

    DenseMatrix<Real> jac(dim - 1, dim - 1);

    jac(0, 0) = (d2xyz_dxi2[0] * d) - (dxyz_dxi[0] * dxyz_dxi[0]);

    if (dim - 1 == 2)
    {
      jac(1, 0) = (d2xyz_dxieta[0] * d) - (dxyz_dxi[0] * dxyz_deta[0]);

      jac(0, 1) = (d2xyz_detaxi[0] * d) - (dxyz_deta[0] * dxyz_dxi[0]);
      jac(1, 1) = (d2xyz_deta2[0] * d) - (dxyz_deta[0] * dxyz_deta[0]);
    }

    DenseVector<Real> rhs(dim - 1);

    rhs(0) = -dxyz_dxi[0] * d;

    if (dim - 1 == 2)
      rhs(1) = -dxyz_deta[0] * d;

    DenseVector<Real> update(dim - 1);

    jac.lu_solve(rhs, update);

    ref_point(0) += update(0);

    if (dim - 1 == 2)
      ref_point(1) += update(1);

    points[0] = ref_point;
    fe_side->reinit(side, &points);
    d = slave_point - phys_point[0];

    update_size = update.l2_norm();
  }

  /*
    if (nit == 12 && update_size > TOLERANCE*TOLERANCE)
      Moose::err<<"Warning!  Newton solve for contact point failed to converge!"<<std::endl;
  */

  p_info._closest_point_ref = ref_point;
  p_info._closest_point = phys_point[0];
  p_info._distance = d.norm();

  if (dim - 1 == 2)
  {
    p_info._normal = dxyz_dxi[0].cross(dxyz_deta[0]);
    p_info._normal /= p_info._normal.norm();
  }
  else
  {
    const Node * const * elem_nodes = master_elem->get_nodes();
    const Point in_plane_vector1 = *elem_nodes[1] - *elem_nodes[0];
    const Point in_plane_vector2 = *elem_nodes[2] - *elem_nodes[0];

    Point out_of_plane_normal = in_plane_vector1.cross(in_plane_vector2);
    out_of_plane_normal /= out_of_plane_normal.norm();

    p_info._normal = dxyz_dxi[0].cross(out_of_plane_normal);
    if (std::fabs(p_info._normal.norm()) > 1e-15)
      p_info._normal /= p_info._normal.norm();
  }

  // If the point has not penetrated the face, make the distance negative
  const Real dot(d * p_info._normal);
  if (dot > 0.0)
    p_info._distance = -p_info._distance;

  contact_point_on_side = FEInterface::on_reference_element(ref_point, side->type());

  p_info._tangential_distance = 0.0;

  if (!contact_point_on_side)
  {
    p_info._closest_point_on_face_ref = ref_point;
    restrictPointToFace(p_info._closest_point_on_face_ref, side, p_info._off_edge_nodes);

    points[0] = p_info._closest_point_on_face_ref;
    fe_side->reinit(side, &points);
    Point closest_point_on_face(phys_point[0]);

    RealGradient off_face = closest_point_on_face - p_info._closest_point;
    Real tangential_distance = off_face.norm();
    p_info._tangential_distance = tangential_distance;
    if (tangential_distance <= tangential_tolerance)
    {
      contact_point_on_side = true;
    }
  }

  const std::vector<std::vector<Real>> & phi = fe_side->get_phi();
  const std::vector<std::vector<RealGradient>> & grad_phi = fe_side->get_dphi();

  points[0] = p_info._closest_point_ref;
  fe_side->reinit(side, &points);

  p_info._side_phi = phi;
  p_info._side_grad_phi = grad_phi;
  p_info._dxyzdxi = dxyz_dxi;
  p_info._dxyzdeta = dxyz_deta;
  p_info._d2xyzdxideta = d2xyz_dxieta;
}

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

{
  // Loop over all elements to find elements intersected by the plane
  for (const auto & elem : mesh.element_ptr_range())
  {
    bool intersected = false;

    // Check whether the first node of this element is below or above the plane
    const Node & node0 = elem->node_ref(0);
    bool node0_above_plane = plane.above_surface(node0);

    // Loop over the rest of the nodes and check if any node is on the other side of the plane
    for (unsigned int i = 1; i < elem->n_nodes(); ++i)
    {
      const Node & node = elem->node_ref(i);

      bool node_above_plane = plane.above_surface(node);
      if (node0_above_plane != node_above_plane)
        intersected = true;
    }

    if (intersected)
      intersected_elems.push_back(elem);
  }
}

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

{
  std::string exec_path;
  char path[1024];

#ifdef __APPLE__
  uint32_t size = sizeof(path);
  if (_NSGetExecutablePath(path, &size) == 0)
    exec_path = path;
  else
    mooseError("Unable to retrieve executable path");
#else // Linux with Proc
  std::ostringstream oss;
  oss << "/proc/" << getpid() << "/exe";
  int ch = readlink(oss.str().c_str(), path, 1024);
  if (ch != -1)
  {
    path[ch] = 0;
    exec_path = path;
  }
#endif

  // Now strip off the exeuctable to get the PATH
  std::string::size_type t = exec_path.find_last_of("/");
  exec_path = exec_path.substr(0, t) + "/";

  return exec_path;
}

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

{
  // Space in b
  initialize_indirect_sort(beg, end, b);

  // Typedef for less typing.  Note: use of std::iterator_traits means this should work with
  // naked pointers too...
  typedef std::less<typename std::iterator_traits<RandomAccessIterator>::value_type>
      LessThanComparator;

  // Construct comparator object
  indirect_comparator<RandomAccessIterator, LessThanComparator> ic(beg, LessThanComparator());

  // Sort the indices, based on the data
  std::sort(b.begin(), b.end(), ic);
}

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.

{
  // Space in b
  initialize_indirect_sort(beg, end, b);

  // Construct comparator object
  indirect_comparator<RandomAccessIterator, UserComparisonFunctor> ic(beg, user_comp);

  // Sort the indices, based on the data
  std::sort(b.begin(), b.end(), ic);
}

initCoordinateSystemType()

void Moose::initCoordinateSystemType

(

)

Definition at line 52 of file Conversion.C.

Referenced by stringToEnum< CoordinateSystemType >().

{
  if (coordinate_system_type_to_enum.empty())
  {
    coordinate_system_type_to_enum["XYZ"] = COORD_XYZ;
    coordinate_system_type_to_enum["RZ"] = COORD_RZ;
    coordinate_system_type_to_enum["RSPHERICAL"] = COORD_RSPHERICAL;
  }
}

initEigenProlemType()

void Moose::initEigenProlemType

(

)

Definition at line 92 of file Conversion.C.

Referenced by stringToEnum< EigenProblemType >().

{
  if (eigen_problem_type_to_enum.empty())
  {
    eigen_problem_type_to_enum["HERMITIAN"] = EPT_HERMITIAN;
    eigen_problem_type_to_enum["NON_HERMITIAN"] = EPT_NON_HERMITIAN;
    eigen_problem_type_to_enum["GEN_HERMITIAN"] = EPT_GEN_HERMITIAN;
    eigen_problem_type_to_enum["GEN_NON_HERMITIAN"] = EPT_GEN_NON_HERMITIAN;
    eigen_problem_type_to_enum["GEN_INDEFINITE"] = EPT_GEN_INDEFINITE;
    eigen_problem_type_to_enum["POS_GEN_NON_HERMITIAN"] = EPT_POS_GEN_NON_HERMITIAN;
    eigen_problem_type_to_enum["SLEPC_DEFAULT"] = EPT_SLEPC_DEFAULT;
  }
}

initEigenSolveType()

void Moose::initEigenSolveType

(

)

Definition at line 76 of file Conversion.C.

Referenced by stringToEnum< EigenSolveType >().

{
  if (eigen_solve_type_to_enum.empty())
  {
    eigen_solve_type_to_enum["POWER"] = EST_POWER;
    eigen_solve_type_to_enum["ARNOLDI"] = EST_ARNOLDI;
    eigen_solve_type_to_enum["KRYLOVSCHUR"] = EST_KRYLOVSCHUR;
    eigen_solve_type_to_enum["JACOBI_DAVIDSON"] = EST_JACOBI_DAVIDSON;
    eigen_solve_type_to_enum["NONLINEAR_POWER"] = EST_NONLINEAR_POWER;
    eigen_solve_type_to_enum["MF_NONLINEAR_POWER"] = EST_MF_NONLINEAR_POWER;
    eigen_solve_type_to_enum["MONOLITH_NEWTON"] = EST_MONOLITH_NEWTON;
    eigen_solve_type_to_enum["MF_MONOLITH_NEWTON"] = EST_MF_MONOLITH_NEWTON;
  }
}

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

{
  // enough storage for all the indices
  b.resize(std::distance(beg, end));

  // iota
  for (size_t i = 0; i < b.size(); ++i)
    b[i] = i;
}

initLineSearchType()

void Moose::initLineSearchType

(

)

Definition at line 126 of file Conversion.C.

Referenced by stringToEnum< LineSearchType >().

{
  if (line_search_type_to_enum.empty())
  {
    line_search_type_to_enum["DEFAULT"] = LS_DEFAULT;
    line_search_type_to_enum["NONE"] = LS_NONE;
    line_search_type_to_enum["BASIC"] = LS_BASIC;
#ifdef LIBMESH_HAVE_PETSC
#if PETSC_VERSION_LESS_THAN(3, 3, 0)
    line_search_type_to_enum["CUBIC"] = LS_CUBIC;
    line_search_type_to_enum["QUADRATIC"] = LS_QUADRATIC;
    line_search_type_to_enum["BASICNONORMS"] = LS_BASICNONORMS;
#else
    line_search_type_to_enum["SHELL"] = LS_SHELL;
    line_search_type_to_enum["L2"] = LS_L2;
    line_search_type_to_enum["BT"] = LS_BT;
    line_search_type_to_enum["CP"] = LS_CP;
    line_search_type_to_enum["CONTACT"] = LS_CONTACT;
#endif
#endif
  }
}

initMffdType()

void Moose::initMffdType

(

)

Definition at line 165 of file Conversion.C.

Referenced by stringToEnum< MffdType >().

{
  if (mffd_type_to_enum.empty())
  {
    mffd_type_to_enum["DS"] = MFFD_DS;
    mffd_type_to_enum["WP"] = MFFD_WP;
  }
}

initQuadratureType()

void Moose::initQuadratureType

(

)

Definition at line 36 of file Conversion.C.

Referenced by stringToEnum< QuadratureType >().

{
  if (quadrature_type_to_enum.empty())
  {
    quadrature_type_to_enum["CLOUGH"] = QCLOUGH;
    quadrature_type_to_enum["CONICAL"] = QCONICAL;
    quadrature_type_to_enum["GAUSS"] = QGAUSS;
    quadrature_type_to_enum["GRID"] = QGRID;
    quadrature_type_to_enum["MONOMIAL"] = QMONOMIAL;
    quadrature_type_to_enum["SIMPSON"] = QSIMPSON;
    quadrature_type_to_enum["TRAP"] = QTRAP;
    quadrature_type_to_enum["GAUSS_LOBATTO"] = QGAUSS_LOBATTO;
  }
}

initRMType()

void Moose::initRMType

(

)

Definition at line 175 of file Conversion.C.

Referenced by stringToEnum< RelationshipManagerType >().

{
  if (rm_type_to_enum.empty())
  {
    rm_type_to_enum["DEFAULT"] = RelationshipManagerType::DEFAULT;
    rm_type_to_enum["GEOMETRIC"] = RelationshipManagerType::GEOMETRIC;
    rm_type_to_enum["ALGEBRAIC"] = RelationshipManagerType::ALGEBRAIC;
    rm_type_to_enum["COUPLING"] = RelationshipManagerType::COUPLING;
  }
}

initSolveType()

void Moose::initSolveType

(

)

Definition at line 63 of file Conversion.C.

Referenced by stringToEnum< SolveType >().

{
  if (solve_type_to_enum.empty())
  {
    solve_type_to_enum["PJFNK"] = ST_PJFNK;
    solve_type_to_enum["JFNK"] = ST_JFNK;
    solve_type_to_enum["NEWTON"] = ST_NEWTON;
    solve_type_to_enum["FD"] = ST_FD;
    solve_type_to_enum["LINEAR"] = ST_LINEAR;
  }
}

initTimeIntegratorsType()

void Moose::initTimeIntegratorsType

(

)

Definition at line 150 of file Conversion.C.

Referenced by stringToEnum< TimeIntegratorType >().

{
  if (time_integrator_to_enum.empty())
  {
    time_integrator_to_enum["IMPLICIT_EULER"] = TI_IMPLICIT_EULER;
    time_integrator_to_enum["EXPLICIT_EULER"] = TI_EXPLICIT_EULER;
    time_integrator_to_enum["CRANK_NICOLSON"] = TI_CRANK_NICOLSON;
    time_integrator_to_enum["BDF2"] = TI_BDF2;
    time_integrator_to_enum["EXPLICIT_MIDPOINT"] = TI_EXPLICIT_MIDPOINT;
    time_integrator_to_enum["LSTABLE_DIRK2"] = TI_LSTABLE_DIRK2;
    time_integrator_to_enum["EXPLICIT_TVDRK2"] = TI_EXPLICIT_TVD_RK_2;
  }
}

initWhichEigenPairs()

void Moose::initWhichEigenPairs

(

)

Definition at line 107 of file Conversion.C.

Referenced by stringToEnum< WhichEigenPairs >().

{
  if (which_eigen_pairs_to_enum.empty())
  {
    which_eigen_pairs_to_enum["LARGEST_MAGNITUDE"] = WEP_LARGEST_MAGNITUDE;
    which_eigen_pairs_to_enum["SMALLEST_MAGNITUDE"] = WEP_SMALLEST_MAGNITUDE;
    which_eigen_pairs_to_enum["LARGEST_REAL"] = WEP_LARGEST_REAL;
    which_eigen_pairs_to_enum["SMALLEST_REAL"] = WEP_SMALLEST_REAL;
    which_eigen_pairs_to_enum["LARGEST_IMAGINARY"] = WEP_LARGEST_IMAGINARY;
    which_eigen_pairs_to_enum["SMALLEST_IMAGINARY"] = WEP_SMALLEST_IMAGINARY;
    which_eigen_pairs_to_enum["TARGET_MAGNITUDE"] = WEP_TARGET_MAGNITUDE;
    which_eigen_pairs_to_enum["TARGET_REAL"] = WEP_TARGET_REAL;
    which_eigen_pairs_to_enum["TARGET_IMAGINARY"] = WEP_TARGET_IMAGINARY;
    which_eigen_pairs_to_enum["ALL_EIGENVALUES"] = WEP_ALL_EIGENVALUES;
    which_eigen_pairs_to_enum["SLEPC_DEFAULT"] = WEP_SLEPC_DEFAULT;
  }
}

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_segment	the LineSegment to intersect
current_elem	The current element that needs to be searched
incoming_side	The side of the current element that was intersected by the LineSegment that brought us here
intersected_elems	The output
segments	Line segments for the path across each element

Definition at line 144 of file RayTracing.C.

Referenced by elementsIntersectedByLine().

{
  Point intersection_point;

  std::vector<int> not_side(1, incoming_side);

  // Find the side of this element that the LineSegment intersects... while ignoring the incoming
  // side (we don't want to move backward!)
  int intersected_side =
      sideIntersectedByLine(current_elem, not_side, line_segment, intersection_point);

  if (intersected_side != -1) // -1 means that we didn't find any side
  {
    // Get the neighbor on that side
    const Elem * neighbor = current_elem->neighbor_ptr(intersected_side);

    if (neighbor)
    {
      // Add it to the list
      intersected_elems.push_back(const_cast<Elem *>(neighbor));

      // Add the line segment across the element to the segments list
      segments.push_back(LineSegment(incoming_point, intersection_point));

      // Note: This is finding the side the current_elem is on for the neighbor.  That's the
      // "incoming_side" for the neighbor
      int incoming_side = sideNeighborIsOn(neighbor, current_elem);

      // Recurse
      recursivelyFindElementsIntersectedByLine(
          line_segment, neighbor, incoming_side, intersection_point, intersected_elems, segments);
    }
    else // Add the final segment
      segments.push_back(LineSegment(incoming_point, line_segment.end()));
  }
  else // Add the final segment
    segments.push_back(LineSegment(incoming_point, line_segment.end()));

  // Finished... return out!
  return;
}

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.

• Example: "setup_mesh" <--------—> SetupMeshAction <------— \ [Mesh] / "setup_mesh_complete" <—> SetupMeshCompleteAction <-

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

Referenced by associateSyntax(), and registerAll().

{
  mooseDeprecated("use registerAll instead of registerActions");
  registerActions(syntax, action_factory, {"MooseApp"});
}

registerActions() [2/2]

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

Definition at line 345 of file Moose.C.

{
  Registry::registerActionsTo(action_factory, obj_labels);

  // TODO: Why is this here?
  registerTask("finish_input_file_output", false);
}

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

{
  registerObjects(f, {"MooseApp"});
  associateSyntaxInner(s, af);
  registerActions(s, af, {"MooseApp"});
  registerExecFlags(f);
}

registerExecFlags()

void Moose::registerExecFlags

(

Factory &

factory

)

Definition at line 356 of file Moose.C.

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

{
  registerExecFlag(EXEC_NONE);
  registerExecFlag(EXEC_INITIAL);
  registerExecFlag(EXEC_LINEAR);
  registerExecFlag(EXEC_NONLINEAR);
  registerExecFlag(EXEC_TIMESTEP_END);
  registerExecFlag(EXEC_TIMESTEP_BEGIN);
  registerExecFlag(EXEC_FINAL);
  registerExecFlag(EXEC_FORCED);
  registerExecFlag(EXEC_FAILED);
  registerExecFlag(EXEC_CUSTOM);
  registerExecFlag(EXEC_SUBDOMAIN);
  registerExecFlag(EXEC_PRE_DISPLACE);
  registerExecFlag(EXEC_SAME_AS_MULTIAPP);
  registerExecFlag(EXEC_PRE_MULTIAPP_SETUP);
}

registerObjects() [1/2]

void Moose::registerObjects

(

Factory &

factory

)

Definition at line 61 of file Moose.C.

Referenced by registerAll().

{
  mooseDeprecated("use registerAll instead of registerObjects");
  registerObjects(factory, {"MooseApp"});
}

registerObjects() [2/2]

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

Definition at line 68 of file Moose.C.

{
  Registry::registerObjectsTo(factory, obj_labels);
}

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

{
  const ElemType t(side->type());
  off_edge_nodes.clear();
  Real & xi = p(0);
  Real & eta = p(1);

  switch (t)
  {
    case EDGE2:
    case EDGE3:
    case EDGE4:
    {
      // The reference 1D element is [-1,1].
      if (xi < -1.0)
      {
        xi = -1.0;
        off_edge_nodes.push_back(side->node_ptr(0));
      }
      else if (xi > 1.0)
      {
        xi = 1.0;
        off_edge_nodes.push_back(side->node_ptr(1));
      }
      break;
    }

    case TRI3:
    case TRI6:
    {
      // The reference triangle is isosceles
      // and is bound by xi=0, eta=0, and xi+eta=1.

      if (xi <= 0.0 && eta <= 0.0)
      {
        xi = 0.0;
        eta = 0.0;
        off_edge_nodes.push_back(side->node_ptr(0));
      }
      else if (xi > 0.0 && xi < 1.0 && eta < 0.0)
      {
        eta = 0.0;
        off_edge_nodes.push_back(side->node_ptr(0));
        off_edge_nodes.push_back(side->node_ptr(1));
      }
      else if (eta > 0.0 && eta < 1.0 && xi < 0.0)
      {
        xi = 0.0;
        off_edge_nodes.push_back(side->node_ptr(2));
        off_edge_nodes.push_back(side->node_ptr(0));
      }
      else if (xi >= 1.0 && (eta - xi) <= -1.0)
      {
        xi = 1.0;
        eta = 0.0;
        off_edge_nodes.push_back(side->node_ptr(1));
      }
      else if (eta >= 1.0 && (eta - xi) >= 1.0)
      {
        xi = 0.0;
        eta = 1.0;
        off_edge_nodes.push_back(side->node_ptr(2));
      }
      else if ((xi + eta) > 1.0)
      {
        Real delta = (xi + eta - 1.0) / 2.0;
        xi -= delta;
        eta -= delta;
        off_edge_nodes.push_back(side->node_ptr(1));
        off_edge_nodes.push_back(side->node_ptr(2));
      }
      break;
    }

    case QUAD4:
    case QUAD8:
    case QUAD9:
    {
      // The reference quadrilateral element is [-1,1]^2.
      if (xi < -1.0)
      {
        xi = -1.0;
        if (eta < -1.0)
        {
          eta = -1.0;
          off_edge_nodes.push_back(side->node_ptr(0));
        }
        else if (eta > 1.0)
        {
          eta = 1.0;
          off_edge_nodes.push_back(side->node_ptr(3));
        }
        else
        {
          off_edge_nodes.push_back(side->node_ptr(3));
          off_edge_nodes.push_back(side->node_ptr(0));
        }
      }
      else if (xi > 1.0)
      {
        xi = 1.0;
        if (eta < -1.0)
        {
          eta = -1.0;
          off_edge_nodes.push_back(side->node_ptr(1));
        }
        else if (eta > 1.0)
        {
          eta = 1.0;
          off_edge_nodes.push_back(side->node_ptr(2));
        }
        else
        {
          off_edge_nodes.push_back(side->node_ptr(1));
          off_edge_nodes.push_back(side->node_ptr(2));
        }
      }
      else
      {
        if (eta < -1.0)
        {
          eta = -1.0;
          off_edge_nodes.push_back(side->node_ptr(0));
          off_edge_nodes.push_back(side->node_ptr(1));
        }
        else if (eta > 1.0)
        {
          eta = 1.0;
          off_edge_nodes.push_back(side->node_ptr(2));
          off_edge_nodes.push_back(side->node_ptr(3));
        }
      }
      break;
    }

    default:
    {
      mooseError("Unsupported face type: ", t);
      break;
    }
  }
}

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

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

{
  _color_console = (isatty(fileno(stdout)) || force) && use_color;
  return _color_console;
}

setSolverDefaults()

void Moose::setSolverDefaults

(

FEProblemBase &

problem

)

Definition at line 533 of file Moose.C.

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

{
#ifdef LIBMESH_HAVE_PETSC
  // May be a touch expensive to create a new DM every time, but probably safer to do it this way
  Moose::PetscSupport::petscSetDefaults(problem);
#endif // LIBMESH_HAVE_PETSC
}

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

elem	The elem to search
not_side	Sides to not search (Use -1 if you want to search all sides)
intersection_point	If an intersection is found this will be filled with the x,y,z position of that intersection

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

{
  unsigned int n_sides = elem->n_sides();

  // Whether or not they intersect
  bool intersect = false;

  unsigned int dim = elem->dim();

  for (unsigned int i = 0; i < n_sides; i++)
  {
    // Don't search the "not_side"
    // Note: A linear search is fine here because this vector is going to be < n_sides
    if (std::find(not_side.begin(), not_side.end(), static_cast<int>(i)) != not_side.end())
      continue;

    // Get a simplified side element
    std::unique_ptr<const Elem> side_elem = elem->side_ptr(i);

    if (dim == 3)
    {
      // Make a plane out of the first three nodes on the side
      Plane plane(side_elem->point(0), side_elem->point(1), side_elem->point(2));

      // See if they intersect
      intersect = line_segment.intersect(plane, intersection_point);
    }
    else if (dim == 2)
    {
      // Make a Line Segment out of the first two nodes on the side
      LineSegment side_segment(side_elem->point(0), side_elem->point(1));

      // See if they intersect
      intersect = line_segment.intersect(side_segment, intersection_point);
    }
    else // 1D
    {
      // See if the line segment contains the point
      intersect = line_segment.contains_point(side_elem->point(0));

      // If it does then save off that one point as the intersection point
      if (intersect)
        intersection_point = side_elem->point(0);
    }

    if (intersect)
    {
      if (side_elem->contains_point(intersection_point))
      {
        const Elem * neighbor = elem->neighbor_ptr(i);

        // If this side is on a boundary, let's do another search and see if we can find a better
        // candidate
        if (!neighbor)
        {
          not_side.push_back(i); // Make sure we don't find this side again

          int better_side = sideIntersectedByLine(elem, not_side, line_segment, intersection_point);

          if (better_side != -1)
            return better_side;
        }

        return i;
      }
    }
  }

  // Didn't find one
  return -1;
}

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

{
  unsigned int n_sides = elem->n_sides();

  for (unsigned int i = 0; i < n_sides; i++)
  {
    if (elem->neighbor_ptr(i) == neighbor)
      return i;
  }

  return -1;
}

stringify() [1/6]

template<typename T >

std::string Moose::stringify

(

const T &

t

)

conversion to string

Definition at line 61 of file Conversion.h.

Referenced by SetupResidualDebugAction::act(), MaterialDerivativeTestAction::act(), DerivativeParsedMaterialHelper::assembleDerivatives(), FEProblemBase::checkCoordinateSystems(), Damper::checkMinDamping(), BlockRestrictable::checkVariable(), FEProblemBase::computeUserObjects(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), DOFMapOutput::filename(), ElementQualityChecker::finalize(), ExecFlagEnum::getDocString(), MooseEnumBase::getRawNames(), MooseApp::getRelationshipManagerInfo(), SystemBase::getScalarVariable(), SystemBase::getVariable(), MatrixTools::inverse(), LeastSquaresFitHistory::LeastSquaresFitHistory(), MultiApp::localApp(), operator<<(), MooseEnum::operator=(), ConsoleUtils::outputExecutionInformation(), libMesh::print_helper(), TopResidualDebugOutput::printTopResiduals(), FEProblemBase::setCoordSystem(), Moose::SlepcSupport::setEigenSolverOptions(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), Split::setup(), stringify(), RankTwoTensorTempl< Real >::syev(), and validParams< Executioner >().

{
  std::ostringstream os;
  os << t;
  return os.str();
}

stringify() [2/6]

std::string Moose::stringify

(

const SolveType &

t

)

Convert solve type into human readable string.

Definition at line 369 of file Conversion.C.

{
  switch (t)
  {
    case ST_NEWTON:
      return "NEWTON";
    case ST_JFNK:
      return "JFNK";
    case ST_PJFNK:
      return "Preconditioned JFNK";
    case ST_FD:
      return "FD";
    case ST_LINEAR:
      return "Linear";
  }
  return "";
}

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

{
  return s;
}

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.

{
  return stringify(p.first) + ':' + stringify(p.second);
}

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]	c	Container to stringify
[in]	delim	String to print between elements
[in]	elem_encl	String to use at the beginning and end of each element, typically quotation marks
[in]	enclose_list_in_curly_braces	Enclose the list string in curly braces?

Definition at line 97 of file Conversion.h.

{
  std::string str;
  if (enclose_list_in_curly_braces)
    str += "{";
  const auto begin = c.begin();
  const auto end = c.end();
  for (auto i = begin; i != end; ++i)
    str += (i != begin ? delim : "") + elem_encl + stringify(*i) + elem_encl;
  if (enclose_list_in_curly_braces)
    str += "}";
  return str;
}

stringify() [6/6]

std::string Moose::stringify

(

const Moose::RelationshipManagerType &

t

)

Definition at line 351 of file Conversion.C.

{
  switch (t)
  {
    case RelationshipManagerType::DEFAULT:
      return "DEFAULT";
    case RelationshipManagerType::GEOMETRIC:
      return "GEOMETRIC";
    case RelationshipManagerType::ALGEBRAIC:
      return "ALGEBRAIC";
    case RelationshipManagerType::COUPLING:
      return "COUPLING";
    default:
      return "ERROR";
  }
}

stringifyExact()

std::string Moose::stringifyExact

(

Real

t

)

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

Definition at line 394 of file Conversion.C.

{
  // this or std::numeric_limits<T>::max_digits10
  const unsigned int max_digits10 =
      std::floor(std::numeric_limits<Real>::digits * std::log10(2) + 2);

  std::ostringstream os;
  os << std::setprecision(max_digits10) << t;
  return os.str();
}

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.

{
  initCoordinateSystemType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!coordinate_system_type_to_enum.count(upper))
    mooseError("Unknown coordinate system type: ", upper);

  return coordinate_system_type_to_enum[upper];
}

stringToEnum< EigenProblemType >()

template<>

EigenProblemType Moose::stringToEnum< EigenProblemType >

(

const std::string &

s

)

Definition at line 261 of file Conversion.C.

{
  initEigenProlemType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!eigen_problem_type_to_enum.count(upper))
    mooseError("Unknown eigen problem type: ", upper);

  return eigen_problem_type_to_enum[upper];
}

stringToEnum< EigenSolveType >()

template<>

EigenSolveType Moose::stringToEnum< EigenSolveType >

(

const std::string &

s

)

Definition at line 246 of file Conversion.C.

{
  initEigenSolveType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!eigen_solve_type_to_enum.count(upper))
    mooseError("Unknown eigen solve type: ", upper);

  return eigen_solve_type_to_enum[upper];
}

stringToEnum< LineSearchType >()

template<>

LineSearchType Moose::stringToEnum< LineSearchType >

(

const std::string &

s

)

Definition at line 291 of file Conversion.C.

{
  initLineSearchType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!line_search_type_to_enum.count(upper))
    mooseError("Unknown line search type: ", upper);

  return line_search_type_to_enum[upper];
}

stringToEnum< MffdType >()

template<>

MffdType Moose::stringToEnum< MffdType >

(

const std::string &

s

)

Definition at line 321 of file Conversion.C.

{
  initMffdType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!mffd_type_to_enum.count(upper))
    mooseError("Unknown mffd type: ", upper);

  return mffd_type_to_enum[upper];
}

stringToEnum< Order >()

template<>

Order Moose::stringToEnum< Order >

(

const std::string &

s

)

Definition at line 203 of file Conversion.C.

{
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (upper.compare("AUTO") == 0)
    return INVALID_ORDER;
  else
    return Utility::string_to_enum<Order>(upper);
}

stringToEnum< QuadratureType >()

template<>

QuadratureType Moose::stringToEnum< QuadratureType >

(

const std::string &

s

)

Definition at line 188 of file Conversion.C.

{
  initQuadratureType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!quadrature_type_to_enum.count(upper))
    mooseError("Unknown quadrature type: ", upper);

  return quadrature_type_to_enum[upper];
}

stringToEnum< RelationshipManagerType >()

template<>

RelationshipManagerType Moose::stringToEnum< RelationshipManagerType >

(

const std::string &

s

)

Definition at line 336 of file Conversion.C.

{
  initRMType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!rm_type_to_enum.count(upper))
    mooseError("Unknown RelationshipManager type: ", upper);

  return rm_type_to_enum[upper];
}

stringToEnum< SolveType >()

template<>

SolveType Moose::stringToEnum< SolveType >

(

const std::string &

s

)

Definition at line 231 of file Conversion.C.

{
  initSolveType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!solve_type_to_enum.count(upper))
    mooseError("Unknown solve type: ", upper);

  return solve_type_to_enum[upper];
}

stringToEnum< TimeIntegratorType >()

template<>

TimeIntegratorType Moose::stringToEnum< TimeIntegratorType >

(

const std::string &

s

)

Definition at line 306 of file Conversion.C.

{
  initTimeIntegratorsType();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!time_integrator_to_enum.count(upper))
    mooseError("Unknown time integrator: ", upper);

  return time_integrator_to_enum[upper];
}

stringToEnum< WhichEigenPairs >()

template<>

WhichEigenPairs Moose::stringToEnum< WhichEigenPairs >

(

const std::string &

s

)

Definition at line 276 of file Conversion.C.

{
  initWhichEigenPairs();

  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

  if (!which_eigen_pairs_to_enum.count(upper))
    mooseError("Unknown type of WhichEigenPairs: ", upper);

  return which_eigen_pairs_to_enum[upper];
}

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

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

{
#ifdef LIBMESH_HAVE_PETSC
  MPI_Comm old_comm = PETSC_COMM_WORLD;
  PETSC_COMM_WORLD = new_comm;
  return old_comm;
#endif // LIBMESH_HAVE_PETSC
}

toPoint()

Point Moose::toPoint

(

const std::vector< Real > &

pos

)

Convert point represented as std::vector into Point.

Parameters

pos	Point represented as a vector

Returns

Converted point

Definition at line 406 of file Conversion.C.

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

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 551 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 568 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 570 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 566 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

Definition at line 15 of file MooseTypes.C.

Referenced by InitialConditionWarehouse::addObject(), BlockRestrictable::blockRestricted(), SubProblem::checkBlockMatProps(), FEProblemBase::checkDependMaterialsHelper(), NonlinearSystemBase::checkKernelCoverage(), FEProblemBase::checkUserObjects(), SubProblem::getMaterialPropertyBlockNames(), BlockRestrictable::hasBlocks(), AttribSubdomains::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), BlockRestrictable::isBlockSubset(), and AttribSubdomains::isMatch().

ANY_BOUNDARY_ID

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

Definition at line 17 of file MooseTypes.C.

Referenced by SubProblem::checkBoundaryMatProps(), SubProblem::getMaterialPropertyBoundaryNames(), hasBoundary(), BoundaryRestrictable::hasBoundary(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), AttribBoundaries::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), BoundaryRestrictable::isBoundarySubset(), AttribBoundaries::isMatch(), and BoundaryRestrictable::restricted().

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

EMPTY_BOUNDARY_IDS

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

Definition at line 414 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

Definition at line 16 of file MooseTypes.C.

Referenced by MooseMesh::getSubdomainID(), MooseMeshUtils::getSubdomainIDs(), MooseMesh::getSubdomainIDs(), and ThreadedElementLoopBase< ConstElemPointerRange >::operator()().

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