https://mooseframework.inl.gov
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Moose Namespace Reference

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 }
 
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)
 
StateArg currentState ()
 
StateArg oldState ()
 
StateArg previousNonlinearState ()
 
std::shared_ptr< MooseAppcreateMooseApp (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, RealglobalDofIndexToDerivative (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)
 
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 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, MooseEnumcreateMapFromVectorAndMultiMooseEnum (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)
 
fe_lagrange_1D_shape (const Order order, const unsigned int i, const T &xi)
 
fe_lagrange_1D_shape_deriv (const Order order, const unsigned int i, const T &xi)
 
fe_lagrange_2D_shape (const libMesh::ElemType type, const Order order, const unsigned int i, const VectorType< T > &p)
 
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)
 
std::string getExec ()
 
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< SubdomainIDEMPTY_BLOCK_IDS
 
const std::set< BoundaryIDEMPTY_BOUNDARY_IDS
 
const TagName SOLUTION_TAG
 
const TagName OLD_SOLUTION_TAG
 
const TagName OLDER_SOLUTION_TAG
 
const TagName PREVIOUS_NL_SOLUTION_TAG
 
static bool _color_console
 
std::map< std::string, CoordinateSystemTypecoordinate_system_type_to_enum
 
std::map< std::string, SolveTypesolve_type_to_enum
 
std::map< std::string, EigenSolveTypeeigen_solve_type_to_enum
 
std::map< std::string, EigenProblemTypeeigen_problem_type_to_enum
 
std::map< std::string, WhichEigenPairswhich_eigen_pairs_to_enum
 
std::map< std::string, LineSearchTypeline_search_type_to_enum
 
std::map< std::string, TimeIntegratorTypetime_integrator_to_enum
 
std::map< std::string, MffdTypemffd_type_to_enum
 
std::map< std::string, RelationshipManagerTyperm_type_to_enum
 

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

27 {
29  for (const auto i : make_range(Moose::dim))
30  ret(i) = a * b(i);
31 
32  return ret;
33 }
static constexpr std::size_t dim
IntRange< T > make_range(T beg, T end)

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

38 {
39  return libMesh::outer_product(a, b);
40 }
TypeTensor< typename CompareTypes< T, T2 >::supertype > outer_product(const TypeVector< T > &a, const TypeVector< T2 > &b)