Namespaces
	DataFileUtils

	FV

	internal

	MFEM

	Mortar

	PetscSupport

	SerialAccessRange

	SlepcSupport

	WebServerControlTypeRegistry

Classes
struct	_enumerate_iterator

struct	_enumerate_range

struct	_enumerate_struct

struct	ADType

struct	ADType< ADRankFourTensor >

struct	ADType< ADRankThreeTensor >

struct	ADType< ADRankTwoTensor >

struct	ADType< ADReal >

struct	ADType< ADSymmetricRankFourTensor >

struct	ADType< ADSymmetricRankTwoTensor >

struct	ADType< ADVariableGradient >

struct	ADType< ADVariableSecond >

struct	ADType< ADVariableValue >

struct	ADType< ChainedADReal >

struct	ADType< ChainedReal >

struct	ADType< DenseMatrix< T > >

struct	ADType< DenseVector< T > >

struct	ADType< Eigen::Matrix< T, M, N, O, M2, N2 > >

struct	ADType< MooseUtils::SemidynamicVector< T, N, value_init > >

struct	ADType< Point >

struct	ADType< RankFourTensor >

struct	ADType< RankThreeTensor >

struct	ADType< RankTwoTensor >

struct	ADType< Real >

struct	ADType< RealEigenVector >

struct	ADType< RealVectorValue >

struct	ADType< std::list< T, std::allocator< T > > >

struct	ADType< std::set< T, std::less< T >, std::allocator< T > > >

struct	ADType< std::vector< T, std::allocator< T > > >

struct	ADType< SymmetricRankFourTensor >

struct	ADType< SymmetricRankTwoTensor >

struct	ADType< VariableGradient >

struct	ADType< VariableSecond >

struct	ADType< VariableValue >

struct	ADType< W< T > >

class	ADWrapperFunctor

class	ArrayComponentFunctor

class	Builder

class	Capabilities

class	ConstantFunctor

struct	DOFType

struct	DOFType< RealVectorValue >

struct	ElemArg

struct	ElemPointArg

struct	ElemQpArg

struct	ElemSideQpArg

struct	FaceArg

class	FunctorAbstract

class	FunctorBase

class	FunctorEnvelope

class	FunctorEnvelopeBase

struct	FunctorGradientEvaluationKind

struct	FunctorGradientEvaluationKind< FunctorEvaluationKind::Dot >

struct	FunctorGradientEvaluationKind< FunctorEvaluationKind::Value >

struct	FunctorReturnType

struct	FunctorReturnType< T, FunctorEvaluationKind::Dot >

struct	FunctorReturnType< T, FunctorEvaluationKind::GradDot >

struct	FunctorReturnType< T, FunctorEvaluationKind::Gradient >

struct	FunctorReturnType< T, FunctorEvaluationKind::Value >

struct	indirect_comparator

struct	IsADType

struct	IsADType< ADPoint >

struct	IsADType< ADReal >

struct	IsADType< MetaPhysicL::DualNumber< T, Args... > >

struct	IsADType< W< T, Args... > >

class	LibtorchArtificialNeuralNet

class	LibtorchArtificialNeuralNetTrainer

class	LibtorchDataset

class	LibtorchNeuralNetBase

struct	LibtorchTrainingOptions

struct	NodeArg

class	NullFunctor

class	PassKey

class	RawValueFunctor

class	ScopedCommSwapper

struct	SerialAccess

class	SerialAccessRange

struct	SerialAccessValueTypeHelper

struct	SerialAccessValueTypeHelper< ADReal >

struct	SerialAccessValueTypeHelper< Real >

struct	ShapeType

struct	ShapeType< Eigen::Matrix< Real, Eigen::Dynamic, 1 > >

struct	StateArg

class	TorchScriptModule

struct	TypeList

class	UnusedWalker

class	VectorComponentFunctor

class	VectorCompositeFunctor

class	WebServerControlTypeRegistry

Typedefs
typedef FunctorEnvelope< T >	Functor

typedef typename std::conditional< is_ad, typename ADType< T >::type, T >::type	GenericType

typedef std::function< void(const InputParameters &, InputParameters &)>	RelationshipManagerInputParameterCallback

Enumerations
enum	FunctorEvaluationKind { FunctorEvaluationKind::Value, FunctorEvaluationKind::Gradient, FunctorEvaluationKind::Dot, FunctorEvaluationKind::GradDot }

enum	SolutionState

enum	SolutionIterationType { SolutionIterationType::Time, SolutionIterationType::Nonlinear, SolutionIterationType::FixedPoint }

enum	GeometryType

enum	MaterialDataType

enum	AuxGroup

enum	VarKindType

enum	VarFieldType

enum	CouplingType

enum	ConstraintSideType

enum	DGResidualType

enum	DGJacobianType

enum	ConstraintType

enum	ElementType { ElementType::Element, ElementType::Neighbor, ElementType::Lower }

enum	MortarType { MortarType::Secondary, MortarType::Primary, MortarType::Lower }

enum	ComputeType { ComputeType::Residual, ComputeType::Jacobian, ComputeType::ResidualAndJacobian }

enum	RESTARTABLE_FILTER { RESTARTABLE_FILTER::RECOVERABLE }

enum	ConstraintJacobianType

enum	CoordinateSystemType

enum	PCSideType

enum	MooseKSPNormType

enum	SolveType

enum	EigenSolveType

enum	EigenProblemType

enum	WhichEigenPairs

enum	TimeIntegratorType

enum	ConstraintFormulationType

enum	LineSearchType

enum	MffdType

enum	PatchUpdateType

enum	RelationshipManagerType { RelationshipManagerType::DEFAULT, RelationshipManagerType::GEOMETRIC, RelationshipManagerType::ALGEBRAIC, RelationshipManagerType::COUPLING }

enum	RMSystemType

enum	VectorTagType

enum	FEBackend { FEBackend::LibMesh, FEBackend::MFEM }

Functions
InputParameters	commonAdaptivityParams ()

bool	colorConsole ()

bool	setColorConsole (bool use_color, bool force=false)

void	registerAll (Factory &f, ActionFactory &af, Syntax &s)

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

void	addActionTypes (Syntax &syntax)

void	registerActions (Syntax &syntax, ActionFactory &action_factory)

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

void	associateSyntax (Syntax &syntax, ActionFactory &action_factory)

void	setSolverDefaults (FEProblemBase &problem)

MPI_Comm	swapLibMeshComm (MPI_Comm new_comm)

std::string	hitMessagePrefix (const hit::Node &node)

StateArg	currentState ()

StateArg	oldState ()

StateArg	previousNonlinearState ()

StateArg	previousFixedPointState ()

std::unique_ptr< MooseApp >	createMooseApp (const std::string &default_app_type, int argc, char *argv[])

int	main (int argc, char *argv[])

void	findContactPoint (PenetrationInfo &p_info, FEBase fe_elem, FEBase fe_side, FEType &, const libMesh::Point &secondary_point, bool start_with_centroid, const Real tangential_tolerance, bool &contact_point_on_side, bool &search_succeeded)

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

void	to_json (nlohmann::json &json, const Moose::LibtorchArtificialNeuralNet *const &network)

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

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

void	derivInsert (SemiDynamicSparseNumberArray< Real, libMesh::dof_id_type, NWrapper< N >> &derivs, libMesh::dof_id_type index, Real value)

bool	globalADIndexing ()

std::size_t	adOffset (unsigned int var_num, std::size_t max_dofs_per_elem, ElementType element_type=ElementType::Element, unsigned int num_vars_in_system=0)

std::size_t	adOffset (unsigned int var_num, std::size_t max_dofs_per_elem, DGJacobianType dg_jacobian_type, unsigned int num_vars_in_system=0)

std::unordered_map< dof_id_type, Real >	globalDofIndexToDerivative (const ADReal &ad_real, const SystemBase &sys, ElementType elem_type=ElementType::Element, THREAD_ID tid=0)

auto	globalDofIndexToDerivative (const T &ad_real_container, const SystemBase &sys, ElementType elem_type=ElementType::Element, THREAD_ID tid=0) -> std::vector< std::unordered_map< dof_id_type, typename std::enable_if< std::is_same< ADReal, typename T::value_type >::value, Real >::type >>

bool	doDerivatives (const SubProblem &subproblem, const SystemBase &sys)

T	stringToEnum (const std::string &s)
	Converts a string to an enum. More...

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

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

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

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

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

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

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

std::vector< T >	vectorStringsToEnum (const MultiMooseEnum &v)

std::string	stringify (const T &t)

std::string	stringify (bool v)

std::string	stringify (int v)

std::string	stringify (long v)

std::string	stringify (long long v)

std::string	stringify (unsigned int v)

std::string	stringify (unsigned long v)

std::string	stringify (unsigned long long v)

std::string	stringify (std::variant< T... > v)

std::string	stringify (const SolveType &t)

std::string	stringify (const EigenSolveType &t)

std::string	stringify (const VarFieldType &t)

std::string	stringify (const std::string &s)

std::string	stringify (libMesh::FEFamily f)

std::string	stringify (SolutionIterationType t)

std::string	stringify (ElementType t)

std::string	stringify (libMesh::ElemType t)

std::string	stringify (const std::pair< T, U > &p, const std::string &delim=":")

std::string	stringify (const T< U... > &c, const std::string &delim=", ", const std::string &elem_encl="", bool enclose_list_in_curly_braces=false)

std::string	stringifyExact (Real)

void	elementsIntersectedByPlane (const libMesh::Point &p0, const libMesh::Point &normal, const libMesh::MeshBase &mesh, std::vector< const libMesh::Elem * > &intersected_elems)

void	elementsIntersectedByPlane (const libMesh::Point &p0, const libMesh::Point &p1, const libMesh::Point &p2, const libMesh::MeshBase &mesh, std::vector< const libMesh::Elem * > &intersected_elems)

_enumerate_range< Iterator >	enumerate (Iterator first, Iterator last, typename std::iterator_traits< Iterator >::difference_type initial)

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

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

std::string	getExec ()

std::string	getExecutablePath ()

std::string	getExecutableName ()

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

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

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

void	applyIndices (T &container, const std::vector< size_t > &indices)

std::map< T, C >	createMapFromVectors (const std::vector< T > &keys, const std::vector< C > &values)

std::map< T, MooseEnum >	createMapFromVectorAndMultiMooseEnum (const std::vector< T > &keys, const MultiMooseEnum &values)

void	hash_combine (std::size_t &)

void	hash_combine (std::size_t &seed, const T &v, Rest &&... rest)

void	hash_combine (std::size_t &seed, const std::vector< T > &v, Rest &&... rest)

void	hash_combine (std::size_t &seed, const std::set< T > &v, Rest &&... rest)

T	fe_lagrange_1D_shape (const Order order, const unsigned int i, const T &xi)

T	fe_lagrange_1D_shape_deriv (const Order order, const unsigned int i, const T &xi)

T	fe_lagrange_2D_shape (const libMesh::ElemType type, const Order order, const unsigned int i, const VectorType< T > &p)

T	fe_lagrange_2D_shape_deriv (const libMesh::ElemType type, const Order order, const unsigned int i, const unsigned int j, const VectorType< T > &p)

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

std::string	stringify (const Moose::TimeIntegratorType &t)

void	derivInsert (NumberArray< N, Real > &derivs, dof_id_type index, Real value)

void	elementsIntersectedByLine (const Point &p0, const Point &p1, const MeshBase &mesh, const libMesh::PointLocatorBase &point_locator, std::vector< Elem * > &intersected_elems, std::vector< LineSegment > &segments)

	SERIAL_ACCESS_SCALAR (Real)

	SERIAL_ACCESS_SCALAR (ADReal)

	SERIAL_ACCESS_CONST_SIZE (libMesh::VectorValue, &obj(0u), Moose::dim)

	SERIAL_ACCESS_CONST_SIZE (RankTwoTensorTempl, &obj(0u, 0u), RankTwoTensorTempl< T >::N2)

	SERIAL_ACCESS_CONST_SIZE (RankFourTensorTempl, &obj(0u, 0u, 0u, 0u), RankFourTensorTempl< T >::N4)

	SERIAL_ACCESS_DYNAMIC_SIZE (DenseVector, &obj(0u), obj.size())

SerialAccessRange< T >	serialAccess (T &obj)

void	typeLoopInternal (TypeList< T, Ts... >, As... args)

void	typeLoop (TypeList< Ts... >, As... args)

void	initDofIndices (T &data, const Elem &elem)

void	associateSyntaxInner (Syntax &syntax, ActionFactory &action_factory)

bool	isSectionActive (std::string path, hit::Node *root)

std::vector< std::string >	findSimilar (std::string param, std::vector< std::string > options)

void	Builder::setScalarParameter< ReporterName, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< ReporterName > param, bool in_global, GlobalParamsAction global_block)

void	Builder::setVectorParameter< ReporterName, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< ReporterName >> param, bool in_global, GlobalParamsAction global_block)

void	Builder::setVectorParameter< CLIArgString, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< CLIArgString >> param, bool in_global, GlobalParamsAction global_block)

bool	toBool (const std::string &, T &)

bool	toBool< bool > (const std::string &s, bool &val)

void	compute_linear_system (libMesh::EquationSystems &es, const std::string &system_name)

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

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

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

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

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

void	compute_postcheck (const NumericVector< Number > &old_soln, NumericVector< Number > &search_direction, NumericVector< Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln, NonlinearImplicitSystem &sys)

void	initCoordinateSystemType ()

void	initSolveType ()

void	initEigenSolveType ()

void	initEigenProlemType ()

void	initWhichEigenPairs ()

void	initLineSearchType ()

void	initTimeIntegratorsType ()

void	initMffdType ()

void	initRMType ()

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

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

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

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

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

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

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

void	findElementsIntersectedByPlane (const libMesh::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)

int	sideNeighborIsOn (const Elem elem, const Elem neighbor)

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)

void	elementsIntersectedByLine (const Point &p0, const Point &p1, const MeshBase &, const PointLocatorBase &point_locator, std::vector< Elem * > &intersected_elems, std::vector< LineSegment > &segments)

template<typename T , typename T2 , typename std::enable_if< ScalarTraits< T >::value, int >::type = 0>
TypeVector< typename CompareTypes< T, T2 >::supertype >	outer_product (const T &a, const TypeVector< T2 > &b)

template<typename T , typename T2 >
TypeTensor< typename CompareTypes< T, T2 >::supertype >	outer_product (const TypeVector< T > &a, const TypeVector< T2 > &b)

Variables
	Current

	Old

	Older

	PreviousNL

	Volume

	Face

	BLOCK_MATERIAL_DATA

	BOUNDARY_MATERIAL_DATA

	FACE_MATERIAL_DATA

	NEIGHBOR_MATERIAL_DATA

	INTERFACE_MATERIAL_DATA

	PRE_IC

	PRE_AUX

	POST_AUX

	ALL

	VAR_SOLVER

	VAR_AUXILIARY

	VAR_ANY

	VAR_FIELD_STANDARD

	VAR_FIELD_SCALAR

	VAR_FIELD_VECTOR

	VAR_FIELD_ARRAY

	VAR_FIELD_ANY

	COUPLING_DIAG

	COUPLING_FULL

	COUPLING_CUSTOM

	SIDE_PRIMARY

	SIDE_SECONDARY

	Element

	Neighbor

	ElementElement

	ElementNeighbor

	NeighborElement

	NeighborNeighbor

	Secondary

	Primary

	SecondarySecondary

	SecondaryPrimary

	PrimarySecondary

	PrimaryPrimary

	LowerLower

	LowerSecondary

	LowerPrimary

	SecondaryLower

	PrimaryLower

	COORD_XYZ

	COORD_RZ

	COORD_RSPHERICAL

	PCS_LEFT

	PCS_RIGHT

	PCS_SYMMETRIC

	PCS_DEFAULT

	KSPN_NONE

	KSPN_PRECONDITIONED

	KSPN_UNPRECONDITIONED

	KSPN_NATURAL

	KSPN_DEFAULT

	ST_PJFNK

	ST_JFNK

	ST_NEWTON

	ST_FD

	ST_LINEAR

	EST_POWER

	EST_ARNOLDI

	EST_KRYLOVSCHUR

	EST_JACOBI_DAVIDSON

	EST_NONLINEAR_POWER

	EST_NEWTON

	EST_PJFNK

	EST_PJFNKMO

	EST_JFNK

	EPT_HERMITIAN

	EPT_NON_HERMITIAN

	EPT_GEN_HERMITIAN

	EPT_GEN_INDEFINITE

	EPT_GEN_NON_HERMITIAN

	EPT_POS_GEN_NON_HERMITIAN

	EPT_SLEPC_DEFAULT

	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

	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

	Penalty

	Kinematic

	LS_INVALID

	LS_DEFAULT

	LS_NONE

	LS_BASIC

	LS_SHELL

	LS_CONTACT

	LS_PROJECT

	LS_L2

	LS_BT

	LS_CP

	MFFD_INVALID

	MFFD_WP

	MFFD_DS

	Never

	Always

	Auto

	Iteration

	NONLINEAR

	AUXILIARY

	NONE

	VECTOR_TAG_RESIDUAL

	VECTOR_TAG_SOLUTION

	VECTOR_TAG_ANY

static constexpr std::size_t	dim

int	interrupt_signal_number

bool	show_trace

bool	show_multiple

libMesh::PerfLog	perf_log

bool	_trap_fpe

bool	_warnings_are_errors

bool	_deprecated_is_error

bool	_throw_on_error

bool	_throw_on_warning

ExecFlagEnum	execute_flags

constexpr std::size_t	constMaxQpsPerElem

constexpr std::false_type	always_false

const processor_id_type	INVALID_PROCESSOR_ID

const SubdomainID	ANY_BLOCK_ID

const SubdomainID	INVALID_BLOCK_ID

const BoundaryID	ANY_BOUNDARY_ID

const BoundaryID	INVALID_BOUNDARY_ID

const TagID	INVALID_TAG_ID

const TagTypeID	INVALID_TAG_TYPE_ID

const std::set< SubdomainID >	EMPTY_BLOCK_IDS

const std::set< BoundaryID >	EMPTY_BOUNDARY_IDS

const TagName	SOLUTION_TAG

const TagName	OLD_SOLUTION_TAG

const TagName	OLDER_SOLUTION_TAG

const TagName	PREVIOUS_NL_SOLUTION_TAG

const TagName	PREVIOUS_FP_SOLUTION_TAG

static bool	_color_console

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

Function Documentation

◆ outer_product() [1/2]

template<typename T , typename T2 , typename std::enable_if< ScalarTraits< T >::value, int >::type = 0>

TypeVector<typename CompareTypes<T, T2>::supertype> Moose::outer_product	(	const T &	a,
		const TypeVector< T2 > &	b
	)

inline

Definition at line 26 of file FaceCenteredMapFunctor.C.

Referenced by INSFVSymmetryVelocityBC::computeSegregatedContribution(), and FaceCenteredMapFunctor< Real, std::unordered_map< dof_id_type, Real > >::evaluate().

 {
   TypeVector<typename CompareTypes<T, T2>::supertype> ret;
   for (const auto i : make_range(Moose::dim))
     ret(i) = a * b(i);
 
   return ret;
 }

◆ outer_product() [2/2]

template<typename T , typename T2 >

TypeTensor<typename CompareTypes<T, T2>::supertype> Moose::outer_product	(	const TypeVector< T > &	a,
		const TypeVector< T2 > &	b
	)

inline

Definition at line 37 of file FaceCenteredMapFunctor.C.

 {
   return libMesh::outer_product(a, b);
 }

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Function Documentation

◆ outer_product() [1/2]

◆ outer_product() [2/2]