Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

Nmundy
Nmesh
Naccess
Craw	Raw access: exposes entity field data as a flat array / EntityFieldData view
Cscalar	Scalar access: one arithmetic value per entity
Cvector	Fixed-size vector access: N scalars per entity
Cmatrix	Fixed-size matrix access: N * M scalars per entity
Cquaternion	Quaternion access: 4 scalars per entity
Caabb	Axis-aligned bounding box access: 6 scalars per entity
Cobb
CAABBFieldComponent
CAggregate	An aggregator of components
CBulkData	A extension of STK's BulkData, with streamlined access to Mundy's stk wrappers
CBulkDataClassInterface
Ccanonical_component_access
Ccanonical_component_access< AABBType, std::enable_if_t< is_aabb_v< std::remove_cvref_t< AABBType > > > >
Ccanonical_component_access< access::aabb< ScalarType >, void >
Ccanonical_component_access< access::matrix< ScalarType, N, M >, void >
Ccanonical_component_access< access::obb< ScalarType >, void >
Ccanonical_component_access< access::quaternion< ScalarType >, void >
Ccanonical_component_access< access::raw< ValueType >, void >
Ccanonical_component_access< access::scalar< ScalarType >, void >
Ccanonical_component_access< access::vector< ScalarType, N >, void >
Ccanonical_component_access< Matrix3Type, std::enable_if_t< is_matrix3_v< std::remove_cvref_t< Matrix3Type > > > >
Ccanonical_component_access< MatrixType, std::enable_if_t< is_matrix_v< std::remove_cvref_t< MatrixType > > &&!is_matrix3_v< std::remove_cvref_t< MatrixType > > > >
Ccanonical_component_access< OBBType, std::enable_if_t< is_obb_v< std::remove_cvref_t< OBBType > > > >
Ccanonical_component_access< QuaternionType, std::enable_if_t< is_quaternion_v< std::remove_cvref_t< QuaternionType > > > >
Ccanonical_component_access< ScalarType, std::enable_if_t< std::is_arithmetic_v< std::remove_cvref_t< ScalarType > > > >
Ccanonical_component_access< VectorType, std::enable_if_t< is_vector_v< std::remove_cvref_t< VectorType > > > >
CClass	Semantic mesh class backed by synchronized data and assembly part hierarchies
CDeclarationSignature	Canonical declaration signature used to validate repeated declarations by name
CClassDeclaration	Helper class for declaring a class
Ccomponent_access_shape
Ccomponent_access_shape< access::aabb< ScalarType > >
Ccomponent_access_shape< access::matrix< ScalarType, N, M > >
Ccomponent_access_shape< access::obb< ScalarType > >
Ccomponent_access_shape< access::quaternion< ScalarType > >
Ccomponent_access_shape< access::raw< ValueType > >
Ccomponent_access_shape< access::scalar< ScalarType > >
Ccomponent_access_shape< access::vector< ScalarType, N > >
CComponentDeclaration	Unified fluent builder for declaring both field-backed and shared-backed components
CEntityDeclaration	Helper class for declaring entities
CNodeBuilder	Nested builder for nodes
CElementBuilder
CFieldComponent	Raw field-backed component
CFieldComponentBase
CFieldDeclaration
CFieldDeclarationT
CFutureConnection
CFutureDestroyConnection
CFutureDestroyEntity
CFutureEntity
CLinkCOOData
CLinkCSRBucketConnT
CLinkCSRDataT
CLinkCSRPartitionT
CLinkData	The main interface for interacting with the link data on the mesh
CLinkDataMap
CLinkMetaData
CLinkMetaDataMap
CMatrixFieldComponent
CMeshBuilder	A helper class for building an STK BulkData entity
CMetaData	A extension of STK's MetaData, better suited for some of Mundy's requirements
CNgpAABBFieldComponent
CNgpAggregate
CNgpDestroyConnectionsT
CNgpDestroyEntitiesT
CNgpEntityPoolT	NgpEntityPoolT is a Kokkos-compatible pool of stk::mesh::Entity objects
CNgpFieldComponent
CNgpFieldComponentBase
CNgpLinkCOODataT
CNgpLinkDataT
CNgpMatrixFieldComponent
CNgpModRequestsT	A helper interface for requesting mesh modifications from the device. This is intended to be used in a three-stage command pattern:
CNgpOBBFieldComponent	Device-side OBB NGP field component
CNgpQuaternionFieldComponent
CNgpRequestConnectionsT
CNgpRequestLinkRelationsT	Request helper for writing COO link relations, supporting FutureEntity linkers
CNgpScalarFieldComponent
CNgpSharedComponent
CNgpSharedScalarComponent
CNgpTaggedComponent	A small helper type for tying a Tag to an underlying ngp-compatible component
CNgpVectorFieldComponent
COBBFieldComponent	Host-side OBB field-backed component
CPartDeclaration	Helper class for declaring a part
CQuaternionFieldComponent
CScalarFieldComponent
CSharedAABBComponent
CSharedComponent	A component that returns the same shared value for every entity
CSharedMatrixComponent
CSharedQuaternionComponent
CSharedScalarComponent
CSharedVectorComponent
CTaggedComponent	A small helper type for tying a Tag to an underlying component
CTaggedFieldDeclarationT
CTeamFunctor
CTicketIssuer	Issues tickets for modifications in a given memory space
CTicketRange	A range of tickets issued by a TicketIssuer
CVectorFieldComponent
NOwnership	Literal class enums! These are clearer and easier to work with than bools or explicit enums
COwns
CViews
CMixed
CInvalid
Nscalar_binary_op	Operation tags selecting which binary operation a ScalarBinaryOpTraits describes
Csum
Cdifference
Cproduct
Cquotient
Cunary_minus
Cmin
Cmax
Nsearch
CAlwaysRebuild	Rebuilder that unconditionally triggers a rebuild on every update
CArborX1dNeighborList	ArborX neighbor list with Cabana-style compressed 1D storage
CArborX2dNeighborList	ArborX neighbor list with Cabana-style dense 2D per-target storage
CExcludeConnectedEntities	Exclude candidate pairs that share a connected entity at a given rank
CExcludeNonIntersectingOBBs	Narrow-phase excluder that keeps only candidates whose OBBs intersect
CExcluderChain	Type-level chain of Kokkos-callable excluders
CExcludeSelfInteraction	Exclude degenerate (self) interactions
CExcludeSymmetricDuplicates	Builder-prepared excluder that suppresses one orientation of symmetric target/source pairs
CManagedNeighborList	A neighbor list cache driven by a stateful rebuilder policy
CUpdateResult	Return type for update() carrying both the list and a rebuild indicator
CNeighborListBuilder	Type-state fluent neighbor-list builder
CNeighborListBuildTraits	Traits that couple a concrete neighbor-list type to its build logic and type-specific parameters
Cargs_type	Default empty args; specializations override this with build-specific parameters
CNeighborListBuildTraits< ArborX1dNeighborList< MemorySpace > >
Cargs_type	Build-specific parameters for ArborX1dNeighborList
CNeighborListBuildTraits< ArborX2dNeighborList< MemorySpace > >
Cargs_type	Build-specific parameters for ArborX2dNeighborList
CNeighborListBuildTraits< PeriodicArborX1dNeighborList< MemorySpace, ImageShiftScalar > >
Cargs_type	Build-specific parameters for PeriodicArborX1dNeighborList
CNeighborListBuildTraits< PeriodicArborX2dNeighborList< MemorySpace, ImageShiftScalar > >
Cargs_type	Build-specific parameters for PeriodicArborX2dNeighborList
CNeighborListBuildTraits< PeriodicSTKSearchNeighborList< MemorySpace, ImageShiftScalar > >
Cargs_type	Build-specific parameters for PeriodicSTKSearchNeighborList (none required)
CNeighborListBuildTraits< STKSearchNeighborList< MemorySpace > >
Cargs_type	Build-specific parameters for STKSearchNeighborList (none required)
CNeighborListIterationTraits	Traits class coupling a concrete neighbor-list type to its parallel dispatch strategy
CNeighborPair	Lightweight neighbor-pair view
CNeighbors	Lightweight neighbor-range view for one target
CNeighborSearchCandidate	Non-periodic target/source candidate produced during neighbor-list construction
CNeverRebuild	Rebuilder that suppresses all rebuilds after the first
CNoExcluder	Empty excluder used as the starting point for neighbor-list builders
CPeriodicArborX1dNeighborList	ArborX compressed 1D neighbor list whose stored pairs carry per-object periodic image shifts
CPeriodicArborX2dNeighborList	ArborX dense 2D neighbor list whose stored entries carry per-object periodic image shifts
CPeriodicNeighborSearchCandidate	Periodic owner-pair candidate produced during neighbor-list construction
CPeriodicSearchInput	A SearchInput augmented with a periodicity metric for periodic neighbor-list builds
CPeriodicSTKSearchNeighborList	STK coarse-search neighbor list with compressed owner-pair storage and per-object periodic image shifts
CRebuilderChain	Type-level OR chain of two rebuilders
CRebuildOnAABBDisplacement	Rebuilder that triggers when any box corner moves beyond a displacement threshold
CRebuildOnEntityChange	Rebuilder that triggers when the target or source entity sequence changes
CRebuildOnOBBDisplacement	Rebuilder that triggers when any OBB escapes its inflated snapshot
CSearchInput	A selector paired with a geometry-yielding component for a non-periodic neighbor-list build
CSTKBuildPhaseTimings	Per-phase wall-time breakdown for one STKSearchNeighborList build call
CSTKSearchNeighborList	STK coarse-search neighbor list mapped into Mundy's common access surface
CAABB
Caggregate	An aggregate: A bag of compile-time tagged types In other words, a compile-time unordered map of arbitrary types indexed by tag type
Caggregate_has	Check if an aggregate type has a value with the given Tag usage aggregate_has_v<Tag, AggType>
Caggregate_tag	The I'th aggregate tag
Caggregate_tag< I, aggregate< Ts... > >
Call_have_tags	Check if all types in a pack define an alias named tag_type
Call_tags_unique	Check if all tag_type values in a tagged value pack are unique
CAMatrix	Class for an NxM (num rows x num columns) matrix with arithmetic entries
CAQuaternion	AQuaternion class with floating point entries (an integer-valued quaternion doesn't make much sense)
CArray	A simplistic array type with a fixed size and type
CAScalar	Class for an owning or viewing scalar-like value (an arithmetic type, or a custom scalar such as an autodiff dual)
CAutoDiffScalar	A forward-mode autodiff scalar over passive real type T with N tracked derivatives
CAVector	Class for an Nx1 vector with scalar-like entries
CBallJoint	A ball-and-socket joint between two points
CBBStepStrategy	Barzilai-Borwein step-size policy for projected-gradient descent
CBoundedSpace	Proj(x) = min(max(x, lower_bound), upper_bound) for all x in R
CCGConfig
CCGInvOp	Wraps an SPD operator as its inverse: apply(rhs, out) solves op * out = rhs via matrix-free CG
CCGResult	Result of a linear-system solve: iteration count, final residual, and whether it converged
CCGState	The CG solve state: the x/r/p/Ap vectors and the iteration scalars
CCGStrategy	The CG strategy: initialize/iterate/done/result over (Problem, State)
CCircle3D
CConcatDomainOp	The domain concatenation Op := [op1 | op2]
CWorkspace
CConcatRangeOp	The range concatenation Op := [op1T; op2T], the transpose of ConcatDomainOp
CWorkspace
CCongruentMCQPP
CCongruentMixedReducedOp	The congruent reduced operator Op := D^T M (D - L M D)
CWorkspace
Ccontains_tag	Check if a tagged value pack contains a value with the given Tag
Ccontains_tag< Tag, First, Rest... >
Ccontains_type	Check if a type is in a variadic list of types
Ccount_type	Count how many times a type appears in a variadic list of types
CCQPP	Constrained quadratic programming problem (CQPP) formulation
CDiagonalOp	The diagonal operator y := diag .* x
CEllipsoid
CEuclidean	The distance types
CFeneSpring	A hookean spring between two points with a max length and spring constant
CFreeSpaceMetric	Non-periodic (open-boundary) metric. All operations are identities
CGenericNumTraits	Numeric traits for an arithmetic scalar type; the reusable base NumTraits forwards to
Chas_tag_type	Check if a type defines an alias named tag_type
Chas_tag_type< T, std::void_t< typename T::tag_type > >
CHookeanSpring	A hookean spring between two points with a rest length and spring constant
Chost_ptr	A reference-counted shared handle to a host-resident T whose handle is trivially copyable onto a device
Cindex_finder	Find the index in the variadic list of types that matches the given type
Cindex_finder< T >
Cindex_finder< T, First, Rest... >
Cindex_of_tag	Find the index of Tag inside a pack of tagged components
Cis_ball_joint	Type trait to determine if a type is a BallJoint
Cis_ball_joint< BallJoint< Scalar, LineSegmentType, OwnershipType > >
Cis_ball_joint< const BallJoint< Scalar, LineSegmentType, OwnershipType > >
Cis_char_array
Cis_char_array< char[N]>
Cis_char_array< const char[N]>
Cis_fene_spring	Type trait to determine if a type is a FeneSpring
Cis_fene_spring< const FeneSpring< Scalar, LineSegmentType, OwnershipType > >
Cis_fene_spring< FeneSpring< Scalar, LineSegmentType, OwnershipType > >
Cis_finite	Trait: does a primitive type have finite spatial extent?
Cis_finite< APoint< Scalar, Accessor > >	APoint (and therefore Point) represents a finite position in space
Cis_finite< const APoint< Scalar, Accessor > >
Cis_finite< T, std::void_t< decltype(std::remove_cv_t< T >::is_finite)> >
Cis_free_space_metric	True when T is any instantiation of FreeSpaceMetric
Cis_free_space_metric< FreeSpaceMetric< Scalar > >
Cis_hookean_spring	Type trait to determine if a type is a HookeanSpring
Cis_hookean_spring< const HookeanSpring< Scalar, LineSegmentType, OwnershipType > >
Cis_hookean_spring< HookeanSpring< Scalar, LineSegmentType, OwnershipType > >
Cis_obb
Cis_orthorhombic_metric	True when T is any instantiation of OrthorhombicMetric
Cis_orthorhombic_metric< OrthorhombicMetric< PeriodicAxes, Scalar > >
Cis_our_string_literal
Cis_our_string_literal< StringLiteral< N > >
Cis_periodic_metric	True when T is any periodic metric (orthorhombic or triclinic)
Cis_scalar	Type trait to determine if a type is an AScalar
Cis_string_literal
Cis_string_literal_sink
Cis_string_literal_sink< StringLiteralSink< N > >
Cis_string_sink
Cis_string_sink< StringSink< Chunks... > >
Cis_torsional_spring	Type trait to determine if a type is a TorsionalSpring
Cis_torsional_spring< const TorsionalSpring< Scalar, VSegmentType, OwnershipType > >
Cis_torsional_spring< TorsionalSpring< Scalar, VSegmentType, OwnershipType > >
Cis_triclinic_metric	True when T is any instantiation of TriclinicMetric
Cis_triclinic_metric< TriclinicMetric< PeriodicAxes, Scalar > >
CKokkosBackend	Backend for Kokkos single process execution
CL2Residual	Res = ||r||_2 (absolute). The classic linear-solve convergence measure
CLCP	Linear complementarity problem (LCP) formulation
CLine
CLinearSystem	The linear system A x = b for a square operator A
CLineSegment
CLinfNormProjectedDiffResidual	Res = ||x - proj(x - h grad)||_inf / h for a small step h (line 17 / Eq 25 of Mazhar 2015). Works for any ValidConvexSpace
CLinfNormProjectedGradientResidual	Res = ||proj_grad(x)||_inf, the max absolute projected gradient entry (Eq 2.2 of Dai & Fletcher 2005). Only defined for a non-negativity lower bound
CLinfResidual	Res = ||r||_inf (max absolute residual entry), via Backend::reduce_max
CLowerBoundSpace	Proj(x) = max(x, lower_bound) for all x in R
CMaskedView	Get a masked accessor into a contiguous accessor
CMCQPP	Mixed constrained quadratic programming problem (MCQPP) formulation
Cmetric	Runtime-polymorphic metric (stk::topology-style value class)
CMixedReducedOp	The reduced operator Op := A (I - L A)
CWorkspace
CMundyMathBackend	Backend for Mundy math within a kernel
CNgpPoolT	NgpPoolT is a Kokkos-compatible pool of default constructible objects
CNgpViewT	NgpViewT is an enhanced DualView with a slightly expanded interface
CNumTraits	Numeric traits for a scalar-like type T
CNumTraits< AutoDiffScalar< T, N > >	Numeric traits for AutoDiffScalar. Numeric values come from the passive type; the related types remain differentiable
CNumTraits< double >	Double traits; nonzero fuzzy-comparison precision
CNumTraits< float >	Float traits; nonzero fuzzy-comparison precision
CNumTraits< long double >	Long double traits; nonzero fuzzy-comparison precision
COBB	Oriented Bounding Box: a center, a unit-quaternion orientation, and per-axis half-extents
COrthorhombicMetric	Axis-aligned periodic metric parameterised by a compile-time axis bitmask
Cpassive_scalar	Trait: underlying passive (non-AD) type of T. For arithmetic T: passive_scalar_t<T> == T. For AD types exposing T::value_type: passive_scalar_t<T> == typename T::value_type
Cpassive_scalar< T >
CPGDConfig
CPGDResult	Result of a projected-gradient solve: iteration count, final residual, and whether it converged
CPGDState
CPGDStrategy
CQuadraticFormOp	The quadratic form Op := D^T M D
CWorkspace
Creference_wrapper	A Kokkos-compatible wrapper around a reference
CRelativeL2Residual	Res = ||r||_2 / ||b||_2 (relative to the right-hand side). Scale-independent, unlike L2Residual
CRing
Cruntime_aggregate	A runtime_aggregate: A bag of runtime tagged variants or, In other words, an unordered map of variants indexed by tag string
CScalarBinaryOpTraits	Determines whether a binary operation between scalar types A and B is allowed, and its result
CScalarBinaryOpTraits< A, B, Op >	Two arithmetic primitives (same or mixed) yield their promoted common type
CScalarBinaryOpTraits< AutoDiffScalar< T, N >, T, Op >	An AutoDiffScalar combined with its passive type yields an AutoDiffScalar (either order)
CScalarBinaryOpTraits< T, AutoDiffScalar< T, N >, Op >
CScalarBinaryOpTraits< T, T, Op >	Same non-arithmetic type on both sides yields that type (e.g. autodiff dual op dual)
CScaledOp	The scalar multiple Op := alpha * op
CSharedNormalSigned
CSharedNormalSignedFiniteDiff	Tag selecting the finite-difference-gradient variant of the shared-normal signed distance
CShiftedView	Get a shifted accessor into a contiguous accessor
CSinkStart
CSphere
CSpherocylinder
CSpherocylinderSegment
Cstorage	Own or view a value using a simple normalized storage policy
CStridedView	Get a strided accessor into a contiguous accessor
CStringLiteral	Literal class type that wraps a constant expression string
CStringLiteralSink	Sink that still represents a compile-time string
CStringSink	Sink that stores streamed chunks until a string is actually needed
CSumOp	The sum Op := op1 + op2 of two operators sharing a domain and range
CWorkspace
Ctagged	A small helper type for tying a Tag to an underlying value
CTorsionalSpring	A hookean spring between two points with a rest angle and spring constant
CTransposedView	An accessor that represents the transpose of a row-major (NxM) matrix represented by a contiguous accessor
CTriclinicMetric	General periodic metric for a tilted unit cell
Ctuple	A simple std::tuple-like class that can be used in device code with similar semantics to std::tuple (e.g., get<N>(), get<T>(), tuple_cat, etc.). Constructing a tuple from a set of values moves each one that supports moving and copies the rest; the tuple itself is copyable, movable, and default constructible if all of its elements are (respectively)
Ctuple_element	An element of a tuple
Ctuple_element< I, tuple< Es... > >
Ctuple_size	The size of a tuple
Ctuple_size< tuple< Es... > >
Ctype_at_index	Get the I'th type in a variadic list of types
Ctype_at_index< 0, Head, Tail... >
Ctype_at_index< I, Head, Tail... >
CUnconstrainedSpace	Proj(x) = x for all x in R
CUpperBoundSpace	Proj(x) = min(x, upper_bound) for all x in R
Cvariant
Cvariant_aggregate	A variant_aggregate: A bag of compile-time tagged variants. In other words, a compile-time map of variants indexed by tag type
Cvariant_aggregate_has	Check whether a variant_aggregate type has a value with the given Tag. Usage: variant_aggregate_has_v<Tag, VarAggType>
Cvariant_aggregate_tag	The I'th variant_aggregate tag
Cvariant_aggregate_tag< I, variant_aggregate< VariantType, Tags... > >
Cvariant_size
Cvariant_size< variant< Alts... > >
CVSegment
Nstd
Chash< mundy::host_ptr< T > >	Hash a host_ptr by its pointed-to address, like std::hash<std::shared_ptr<T>>
Nzorder_knn
Ndetail
Csignificand
Csignificand< float >
Csignificand< double >
CLess
CNeighborListBuildTraits< ArborX1dNeighborList< MemorySpace >	Build traits for ArborX1dNeighborList: non-periodic ArborX compressed 1D storage
CNeighborListBuildTraits< ArborX2dNeighborList< MemorySpace >	Build traits for ArborX2dNeighborList: non-periodic ArborX dense 2D storage
CNeighborListBuildTraits< PeriodicArborX1dNeighborList< MemorySpace, ImageShiftScalar >	Build traits for PeriodicArborX1dNeighborList: periodic ArborX compressed 1D storage
CNeighborListBuildTraits< PeriodicArborX2dNeighborList< MemorySpace, ImageShiftScalar >	Build traits for PeriodicArborX2dNeighborList: periodic ArborX dense 2D storage
CNeighborListBuildTraits< PeriodicSTKSearchNeighborList< MemorySpace, ImageShiftScalar >	Build traits for PeriodicSTKSearchNeighborList: periodic STK coarse-search compressed storage
CNeighborListBuildTraits< STKSearchNeighborList< MemorySpace >	Build traits for STKSearchNeighborList: non-periodic STK coarse-search compressed storage