Namespaces
	DataFileUtils

	FV

	internal

	Kokkos

	MFEM

	Mortar

	ParameterRegistration

	PetscSupport

	SerialAccessRange

	SlepcSupport

	UnitUtils

	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	DerivativeStringClass

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	ParameterRegistry

class	PassKey

class	RawValueFunctor

class	ScopedCommSwapper

class	ScopedThrowOnError

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 (const hit::Node &node)

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

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

const TagName	SOLUTION_DOT_TAG

const TagName	SOLUTION_DOTDOT_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]