mundy::mesh Namespace Reference

Namespaces
namespace	access
namespace	mundy

Classes
class	AABBFieldComponent
class	Aggregate
	An aggregator of components. More...
class	BulkData
	A extension of STK's BulkData, with streamlined access to Mundy's stk wrappers. More...
struct	BulkDataClassInterface
struct	canonical_component_access
struct	canonical_component_access< AABBType, std::enable_if_t< is_aabb_v< std::remove_cvref_t< AABBType > > > >
struct	canonical_component_access< access::aabb< ScalarType >, void >
struct	canonical_component_access< access::matrix< ScalarType, N, M >, void >
struct	canonical_component_access< access::obb< ScalarType >, void >
struct	canonical_component_access< access::quaternion< ScalarType >, void >
struct	canonical_component_access< access::raw< ValueType >, void >
struct	canonical_component_access< access::scalar< ScalarType >, void >
struct	canonical_component_access< access::vector< ScalarType, N >, void >
struct	canonical_component_access< Matrix3Type, std::enable_if_t< is_matrix3_v< std::remove_cvref_t< Matrix3Type > > > >
struct	canonical_component_access< MatrixType, std::enable_if_t< is_matrix_v< std::remove_cvref_t< MatrixType > > &&!is_matrix3_v< std::remove_cvref_t< MatrixType > > > >
struct	canonical_component_access< OBBType, std::enable_if_t< is_obb_v< std::remove_cvref_t< OBBType > > > >
struct	canonical_component_access< QuaternionType, std::enable_if_t< is_quaternion_v< std::remove_cvref_t< QuaternionType > > > >
struct	canonical_component_access< ScalarType, std::enable_if_t< std::is_arithmetic_v< std::remove_cvref_t< ScalarType > > > >
struct	canonical_component_access< VectorType, std::enable_if_t< is_vector_v< std::remove_cvref_t< VectorType > > > >
class	Class
	Semantic mesh class backed by synchronized data and assembly part hierarchies. More...
class	ClassDeclaration
	Helper class for declaring a class. More...
struct	component_access_shape
struct	component_access_shape< access::aabb< ScalarType > >
struct	component_access_shape< access::matrix< ScalarType, N, M > >
struct	component_access_shape< access::obb< ScalarType > >
struct	component_access_shape< access::quaternion< ScalarType > >
struct	component_access_shape< access::raw< ValueType > >
struct	component_access_shape< access::scalar< ScalarType > >
struct	component_access_shape< access::vector< ScalarType, N > >
class	ComponentDeclaration
	Unified fluent builder for declaring both field-backed and shared-backed components. More...
class	EntityDeclaration
	Helper class for declaring entities. More...
class	FieldComponent
	Raw field-backed component. More...
class	FieldComponentBase
class	FieldDeclaration
class	FieldDeclarationT
struct	FutureConnection
struct	FutureDestroyConnection
struct	FutureDestroyEntity
struct	FutureEntity
class	LinkCOOData
class	LinkCSRBucketConnT
class	LinkCSRDataT
class	LinkCSRPartitionT
class	LinkData
	The main interface for interacting with the link data on the mesh. More...
struct	LinkDataMap
class	LinkMetaData
struct	LinkMetaDataMap
class	MatrixFieldComponent
class	MeshBuilder
	A helper class for building an STK BulkData entity. More...
class	MetaData
	A extension of STK's MetaData, better suited for some of Mundy's requirements. More...
class	NgpAABBFieldComponent
class	NgpAggregate
class	NgpDestroyConnectionsT
class	NgpDestroyEntitiesT
class	NgpEntityPoolT
	NgpEntityPoolT is a Kokkos-compatible pool of stk::mesh::Entity objects. More...
class	NgpFieldComponent
class	NgpFieldComponentBase
class	NgpLinkCOODataT
class	NgpLinkDataT
class	NgpMatrixFieldComponent
class	NgpModRequestsT
	A helper interface for requesting mesh modifications from the device. This is intended to be used in a three-stage command pattern: More...
class	NgpOBBFieldComponent
	Device-side OBB NGP field component. More...
class	NgpQuaternionFieldComponent
class	NgpRequestConnectionsT
class	NgpRequestEntitiesImplT
class	NgpRequestLinkRelationsT
	Request helper for writing COO link relations, supporting FutureEntity linkers. More...
class	NgpScalarFieldComponent
class	NgpSharedComponent
class	NgpSharedScalarComponent
class	NgpTaggedComponent
	A small helper type for tying a Tag to an underlying ngp-compatible component. More...
class	NgpVectorFieldComponent
class	OBBFieldComponent
	Host-side OBB field-backed component. More...
class	PartDeclaration
	Helper class for declaring a part. More...
class	QuaternionFieldComponent
class	ScalarFieldComponent
class	SharedAABBComponent
class	SharedComponent
	A component that returns the same shared value for every entity. More...
class	SharedMatrixComponent
class	SharedQuaternionComponent
class	SharedScalarComponent
class	SharedVectorComponent
class	TaggedComponent
	A small helper type for tying a Tag to an underlying component. More...
class	TaggedFieldDeclarationT
struct	TeamFunctor
class	TicketIssuer
	Issues tickets for modifications in a given memory space. More...
class	TicketRange
	A range of tickets issued by a TicketIssuer. More...
class	VectorFieldComponent

Typedefs
using	ClassVector = std::vector<Class*>
using	ConstClassVector = std::vector<const Class*>
template<typename AccessLike>
using	canonical_component_access_t = typename canonical_component_access<AccessLike>::type
template<typename ScalarType>
using	Vector1FieldComponent = VectorFieldComponent<ScalarType, 1>
template<typename ScalarType>
using	Vector2FieldComponent = VectorFieldComponent<ScalarType, 2>
template<typename ScalarType>
using	Vector3FieldComponent = VectorFieldComponent<ScalarType, 3>
template<typename ScalarType>
using	Vector4FieldComponent = VectorFieldComponent<ScalarType, 4>
template<typename ScalarType>
using	Vector5FieldComponent = VectorFieldComponent<ScalarType, 5>
template<typename ScalarType>
using	Vector6FieldComponent = VectorFieldComponent<ScalarType, 6>
template<typename NgpFieldType>
using	NgpVector1FieldComponent = NgpVectorFieldComponent<NgpFieldType, 1>
template<typename NgpFieldType>
using	NgpVector2FieldComponent = NgpVectorFieldComponent<NgpFieldType, 2>
template<typename NgpFieldType>
using	NgpVector3FieldComponent = NgpVectorFieldComponent<NgpFieldType, 3>
template<typename NgpFieldType>
using	NgpVector4FieldComponent = NgpVectorFieldComponent<NgpFieldType, 4>
template<typename NgpFieldType>
using	NgpVector5FieldComponent = NgpVectorFieldComponent<NgpFieldType, 5>
template<typename NgpFieldType>
using	NgpVector6FieldComponent = NgpVectorFieldComponent<NgpFieldType, 6>
template<typename ScalarType>
using	Matrix1FieldComponent = MatrixFieldComponent<ScalarType, 1, 1>
template<typename ScalarType>
using	Matrix2FieldComponent = MatrixFieldComponent<ScalarType, 2, 2>
template<typename ScalarType>
using	Matrix3FieldComponent = MatrixFieldComponent<ScalarType, 3, 3>
template<typename ScalarType>
using	Matrix4FieldComponent = MatrixFieldComponent<ScalarType, 4, 4>
template<typename ScalarType>
using	Matrix5FieldComponent = MatrixFieldComponent<ScalarType, 5, 5>
template<typename ScalarType>
using	Matrix6FieldComponent = MatrixFieldComponent<ScalarType, 6, 6>
template<typename NgpFieldType>
using	NgpMatrix1FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 1, 1>
template<typename NgpFieldType>
using	NgpMatrix2FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 2, 2>
template<typename NgpFieldType>
using	NgpMatrix3FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 3, 3>
template<typename NgpFieldType>
using	NgpMatrix4FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 4, 4>
template<typename NgpFieldType>
using	NgpMatrix5FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 5, 5>
template<typename NgpFieldType>
using	NgpMatrix6FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 6, 6>
using	NgpLinkCOOData = NgpLinkCOODataT<stk::ngp::MemSpace>
using	LinkCSRBucketConn = LinkCSRBucketConnT<stk::ngp::HostMemSpace>
using	NgpLinkCSRBucketConn = LinkCSRBucketConnT<stk::ngp::MemSpace>
using	LinkCSRData = LinkCSRDataT<stk::ngp::HostMemSpace>
template<typename NgpMemSpace>
using	NgpLinkCSRDataT = LinkCSRDataT<NgpMemSpace>
using	NgpLinkCSRData = LinkCSRDataT<stk::ngp::MemSpace>
using	LinkCSRPartition = LinkCSRPartitionT<stk::ngp::HostMemSpace>
template<typename NgpMemSpace>
using	NgpLinkCSRPartitionT = LinkCSRPartitionT<NgpMemSpace>
using	NgpLinkCSRPartition = LinkCSRPartitionT<stk::ngp::MemSpace>
using	NgpEntityPool = NgpEntityPoolT<typename stk::ngp::ExecSpace::memory_space, long int>
	Our default NgpEntityPool type for use in Mundy.
using	NgpLinkData = NgpLinkDataT<stk::ngp::MemSpace>
template<typename NgpMemSpace>
using	NgpRequestEntitiesKnownIdsT = NgpRequestEntitiesImplT<NgpMemSpace, true>
template<typename NgpMemSpace>
using	NgpRequestEntitiesNewIdsT = NgpRequestEntitiesImplT<NgpMemSpace, false>
using	NgpModRequests = NgpModRequestsT<stk::ngp::MemSpace>
using	NgpRequestEntitiesKnownIds = NgpRequestEntitiesKnownIdsT<stk::ngp::MemSpace>
using	NgpRequestEntitiesNewIds = NgpRequestEntitiesNewIdsT<stk::ngp::MemSpace>
using	NgpRequestConnections = NgpRequestConnectionsT<stk::ngp::MemSpace>
using	NgpRequestLinkRelations = NgpRequestLinkRelationsT<stk::ngp::MemSpace>
using	NgpDestroyEntities = NgpDestroyEntitiesT<stk::ngp::MemSpace>
using	NgpDestroyConnections = NgpDestroyConnectionsT<stk::ngp::MemSpace>
template<typename ScalarType>
using	SharedVector1Component = SharedVectorComponent<ScalarType, 1>
template<typename ScalarType>
using	SharedVector2Component = SharedVectorComponent<ScalarType, 2>
template<typename ScalarType>
using	SharedVector3Component = SharedVectorComponent<ScalarType, 3>
template<typename ScalarType>
using	SharedVector4Component = SharedVectorComponent<ScalarType, 4>
template<typename ScalarType>
using	SharedVector5Component = SharedVectorComponent<ScalarType, 5>
template<typename ScalarType>
using	SharedVector6Component = SharedVectorComponent<ScalarType, 6>
template<typename ScalarType>
using	SharedMatrix1Component = SharedMatrixComponent<ScalarType, 1, 1>
template<typename ScalarType>
using	SharedMatrix2Component = SharedMatrixComponent<ScalarType, 2, 2>
template<typename ScalarType>
using	SharedMatrix3Component = SharedMatrixComponent<ScalarType, 3, 3>
template<typename ScalarType>
using	SharedMatrix4Component = SharedMatrixComponent<ScalarType, 4, 4>
template<typename ScalarType>
using	SharedMatrix5Component = SharedMatrixComponent<ScalarType, 5, 5>
template<typename ScalarType>
using	SharedMatrix6Component = SharedMatrixComponent<ScalarType, 6, 6>
template<typename SharedType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpRawSharedComponent = NgpSharedComponent<SharedType, NgpMemSpace>
template<typename ScalarType, size_t N, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedVectorComponent = NgpSharedComponent<Vector<ScalarType, N>, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedVector1Component = NgpSharedVectorComponent<ScalarType, 1, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedVector2Component = NgpSharedVectorComponent<ScalarType, 2, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedVector3Component = NgpSharedVectorComponent<ScalarType, 3, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedVector4Component = NgpSharedVectorComponent<ScalarType, 4, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedVector5Component = NgpSharedVectorComponent<ScalarType, 5, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedVector6Component = NgpSharedVectorComponent<ScalarType, 6, NgpMemSpace>
template<typename ScalarType, size_t N, size_t M, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedMatrixComponent = NgpSharedComponent<Matrix<ScalarType, N, M>, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedMatrix1Component = NgpSharedMatrixComponent<ScalarType, 1, 1, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedMatrix2Component = NgpSharedMatrixComponent<ScalarType, 2, 2, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedMatrix3Component = NgpSharedMatrixComponent<ScalarType, 3, 3, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedMatrix4Component = NgpSharedMatrixComponent<ScalarType, 4, 4, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedMatrix5Component = NgpSharedMatrixComponent<ScalarType, 5, 5, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedMatrix6Component = NgpSharedMatrixComponent<ScalarType, 6, 6, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedQuaternionComponent = NgpSharedComponent<Quaternion<ScalarType>, NgpMemSpace>
template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>
using	NgpSharedAABBComponent = NgpSharedComponent<AABB<ScalarType>, NgpMemSpace>

Enumerations
enum class	IOPartRole { NONE , IO , ASSEMBLY , EDGE_BLOCK }
enum	NgpDataAccessTag : uint8_t {   ReadWrite = 0 , ReadOnly = 1 , OverwriteAll = 2 , Unsynchronized ,   ConstUnsynchronized , InvalidAccess }

Functions
template<typename Tag, typename... Components>
const auto &	get_component (const Aggregate< Components... > &aggregate)
	Get a component of the given aggregate (const) This simply calls the get_component method of the given aggregate and solely exists so you don't need to write "aggregate. template get_component<Tag>()" every time you want to fetch a component. Instead, you use "get_component<Tag>(aggregate)". Same concept as std::get<N>(tuple).
template<typename Tag, typename... Components>
auto &	get_component (Aggregate< Components... > &aggregate)
	Get a component of the given aggregate.
template<typename Tag, typename... Components>
decltype(auto)	get (const Aggregate< Components... > &aggregate, stk::mesh::Entity entity)
	Get the data tagged by the given tag from the given aggregate and entity (const).
template<typename Tag, typename... Components>
decltype(auto)	get (Aggregate< Components... > &aggregate, stk::mesh::Entity entity)
	Get the data tagged by the given tag from the given aggregate and entity.
template<typename Tag, typename... Components>
constexpr bool	has (const Aggregate< Components... > &)
	Check if an aggregate has a component with the given tag.
template<typename Tag, typename... Components>
decltype(auto)	get (const NgpAggregate< Components... > &aggregate, stk::mesh::FastMeshIndex entity_index)
	Get the data tagged by the given tag from the given aggregate and entity index (const).
template<typename Tag, typename... Components>
decltype(auto)	get (NgpAggregate< Components... > &aggregate, stk::mesh::FastMeshIndex entity_index)
	Get the data tagged by the given tag from the given aggregate and entity index.
template<typename Tag, typename... Components>
decltype(auto)	get (const NgpAggregate< Components... > &aggregate, stk::mesh::Entity entity)
	Get the data tagged by the given tag from the given aggregate and entity (const).
template<typename Tag, typename... Components>
decltype(auto)	get (NgpAggregate< Components... > &aggregate, stk::mesh::Entity entity)
	Get the data tagged by the given tag from the given aggregate and entity.
template<typename Tag, typename... Components>
constexpr bool	has (const NgpAggregate< Components... > &)
	Check if an NGP aggregate has a component with the given tag.
template<typename... TaggedComponents>
auto	get_updated_ngp_aggregate (const Aggregate< TaggedComponents... > &aggregate)
	A helper function for getting the NGP aggregate from a regular aggregate.
Class &	declare_class (stk::mesh::MetaData &meta_data, const std::string &class_name)
	Declare (or fetch) a named class on the given MetaData.
Class &	declare_class (stk::mesh::MetaData &meta_data, const std::string &class_name, stk::mesh::EntityRank class_rank, bool disable_io_support)
	Declare (or fetch) a ranked class-set on the given MetaData.
Class &	declare_class (stk::mesh::MetaData &meta_data, const std::string &class_name, stk::topology::topology_t class_topology, bool disable_io_support)
	Declare (or fetch) a topological primary class on the given MetaData.
const ClassVector &	get_classes (stk::mesh::MetaData &meta_data)
	Fetch all declared classes from MetaData in class-ordinal order.
const ConstClassVector &	get_classes (const stk::mesh::MetaData &meta_data)
	Fetch all declared classes from MetaData in class-ordinal order.
template<typename OurExecSpace>
NgpViewT< stk::mesh::FastMeshIndex *, OurExecSpace >	get_local_entity_indices (const stk::mesh::BulkData &bulk_data, stk::mesh::EntityRank rank, const stk::mesh::Selector &selector, const OurExecSpace &)
	Get the local fast mesh indices for the entities of a (rank, selector) chunk as an NgpView (memoized).
template<typename OurExecSpace>
NgpViewT< stk::mesh::Entity *, OurExecSpace >	get_local_entities (const stk::mesh::BulkData &bulk_data, stk::mesh::EntityRank rank, const stk::mesh::Selector &selector, const OurExecSpace &)
	Get the entities of a (rank, selector) chunk as an NgpView, in the same order as get_local_entity_indices (memoized).
template<typename ComponentType>
auto	get_updated_ngp_component (const ComponentType &component)
	A helper function for getting the NGP component from a regular component.
template<typename Mesh, typename AlgorithmPerEntity>
void	for_each_entity_run (Mesh &mesh, stk::topology::rank_t rank, const stk::mesh::Selector &selector, const AlgorithmPerEntity &functor)
template<typename Mesh, typename AlgorithmPerEntity, typename EXEC_SPACE>
void	for_each_entity_run (Mesh &mesh, stk::topology::rank_t rank, const stk::mesh::Selector &selector, const AlgorithmPerEntity &functor, const EXEC_SPACE &exec_space)
template<typename Mesh, typename AlgorithmPerEntity>
void	for_each_entity_run (const Mesh &mesh, stk::topology::rank_t rank, const stk::mesh::Selector &selector, const AlgorithmPerEntity &functor)
template<typename Mesh, typename AlgorithmPerEntity>
void	for_each_entity_run (const Mesh &mesh, stk::topology::rank_t rank, const AlgorithmPerEntity &functor)
template<typename NgpMemSpace = stk::ngp::MemSpace>
NgpLinkDataT< NgpMemSpace > &	get_updated_ngp_link_data (const LinkData &link_data)
	Get an updated ngp link data object.
template<typename MemSpace1, typename MemSpace2>
void	deep_copy (LinkCSRBucketConnT< MemSpace1 > &dest, const LinkCSRBucketConnT< MemSpace2 > &src)
template<typename MemSpace1, typename MemSpace2>
void	deep_copy (LinkCSRPartitionT< MemSpace1 > &dest, const LinkCSRPartitionT< MemSpace2 > &src)
LinkData &	declare_link_data (stk::mesh::BulkData &bulk_data, LinkMetaData &link_meta_data)
	Declare or fetch a MetaData-owned LinkData object.
LinkData *	get_link_data (const stk::mesh::BulkData &bulk_data, const std::string &our_name, stk::mesh::EntityRank link_rank)
	Get an existing LinkData object.
LinkData *	get_link_data (const stk::mesh::BulkData &bulk_data, const LinkMetaData &link_meta_data)
template<typename Scalar, typename ExecSpace>
void	field_fill (const Scalar alpha, stk::mesh::FieldBase &field, int component, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Fill a component of a field with a scalar value.
template<typename Scalar, typename ExecSpace>
void	field_fill (const Scalar alpha, stk::mesh::FieldBase &field, int component, const ExecSpace &exec_space)
	Fill a component of a field with a scalar value.
template<typename Scalar, typename ExecSpace>
void	field_fill (const Scalar alpha, stk::mesh::FieldBase &field, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Fill all components of a field with a scalar value.
template<typename Scalar, typename ExecSpace>
void	field_fill (const Scalar alpha, stk::mesh::FieldBase &field, const ExecSpace &exec_space)
	Fill all components of a field with a scalar value.
template<typename Scalar, typename ExecSpace>
void	field_randomize (size_t seed, stk::mesh::FieldBase &counter_field, stk::mesh::FieldBase &field, int component, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Randomize a component of a field (uniform between 0 and 1).
template<typename Scalar, typename ExecSpace>
void	field_randomize (size_t seed, stk::mesh::FieldBase &counter_field, stk::mesh::FieldBase &field, int component, const ExecSpace &exec_space)
	Randomize a component of a field (uniform between 0 and 1).
template<typename Scalar, typename ExecSpace>
void	field_randomize (size_t seed, stk::mesh::FieldBase &counter_field, stk::mesh::FieldBase &field, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Randomize all components of a field (uniform between 0 and 1).
template<typename Scalar, typename ExecSpace>
void	field_randomize (size_t seed, stk::mesh::FieldBase &counter_field, stk::mesh::FieldBase &field, const ExecSpace &exec_space)
	Randomize all components of a field (uniform between 0 and 1).
template<typename Scalar, typename ExecSpace>
void	field_randomize (size_t seed, Scalar min, Scalar max, stk::mesh::FieldBase &counter_field, stk::mesh::FieldBase &field, int component, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Randomize a component of a field (between given min and max).
template<typename Scalar, typename ExecSpace>
void	field_randomize (size_t seed, Scalar min, Scalar max, stk::mesh::FieldBase &counter_field, stk::mesh::FieldBase &field, int component, const ExecSpace &exec_space)
	Randomize a component of a field (between given min and max).
template<typename Scalar, typename ExecSpace>
void	field_randomize (size_t seed, Scalar min, Scalar max, stk::mesh::FieldBase &counter_field, stk::mesh::FieldBase &field, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Randomize all components of a field (between given min and max).
template<typename Scalar, typename ExecSpace>
void	field_randomize (size_t seed, Scalar min, Scalar max, stk::mesh::FieldBase &counter_field, stk::mesh::FieldBase &field, const ExecSpace &exec_space)
	Randomize all components of a field (between given min and max).
template<typename Scalar, typename ExecSpace>
void	field_copy (stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Deep copy y = x.
template<typename Scalar, typename ExecSpace>
void	field_copy (stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, const ExecSpace &exec_space)
	Deep copy y = x.
template<typename Scalar, typename ExecSpace>
void	field_swap (stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Swap the contents of two fields.
template<typename Scalar, typename ExecSpace>
void	field_swap (stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, const ExecSpace &exec_space)
	Swap the contents of two fields.
template<typename Scalar, typename ExecSpace>
void	field_scale (const Scalar alpha, stk::mesh::FieldBase &x, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Scale a field by a scalar x = alpha x.
template<typename Scalar, typename ExecSpace>
void	field_scale (const Scalar alpha, stk::mesh::FieldBase &x, const ExecSpace &exec_space)
	Scale a field by a scalar x = alpha x.
template<typename Scalar, typename ExecSpace>
void	field_product (stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, stk::mesh::FieldBase &z, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the element-wise product of two fields z = x * y.
template<typename Scalar, typename ExecSpace>
void	field_product (stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, stk::mesh::FieldBase &z, const ExecSpace &exec_space)
	Compute the element-wise product of two fields z = x * y.
template<typename Scalar, typename ExecSpace>
void	field_axpy (const Scalar alpha, stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the element-wise sum of two fields y += alpha x.
template<typename Scalar, typename ExecSpace>
void	field_axpy (const Scalar alpha, stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, const ExecSpace &exec_space)
	Compute the element-wise sum of two fields y += alpha x.
template<typename Scalar, typename ExecSpace>
void	field_axpby (const Scalar alpha, stk::mesh::FieldBase &x, const Scalar beta, stk::mesh::FieldBase &y, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the element-wise sum of two fields y = alpha x + beta y.
template<typename Scalar, typename ExecSpace>
void	field_axpby (const Scalar alpha, stk::mesh::FieldBase &x, const Scalar beta, stk::mesh::FieldBase &y, const ExecSpace &exec_space)
	Compute the element-wise sum of two fields y = alpha x + beta y.
template<typename Scalar, typename ExecSpace>
void	field_axpbyz (const Scalar alpha, stk::mesh::FieldBase &x, const Scalar beta, stk::mesh::FieldBase &y, stk::mesh::FieldBase &z, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the element-wise sum of three fields z = alpha x + beta y.
template<typename Scalar, typename ExecSpace>
void	field_axpbyz (const Scalar alpha, stk::mesh::FieldBase &x, const Scalar beta, stk::mesh::FieldBase &y, stk::mesh::FieldBase &z, const ExecSpace &exec_space)
	Compute the element-wise sum of three fields z = alpha x + beta y.
template<typename Scalar, typename ExecSpace>
void	field_axpbygz (const Scalar alpha, stk::mesh::FieldBase &x, const Scalar beta, stk::mesh::FieldBase &y, const Scalar gamma, stk::mesh::FieldBase &z, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the element-wise sum of three fields z = alpha x + beta y + gamma z.
template<typename Scalar, typename ExecSpace>
void	field_axpbygz (const Scalar alpha, stk::mesh::FieldBase &x, const Scalar beta, stk::mesh::FieldBase &y, const Scalar gamma, stk::mesh::FieldBase &z, const ExecSpace &exec_space)
	Compute the element-wise sum of three fields z = alpha x + beta y + gamma z.
template<typename Scalar, typename ExecSpace>
Scalar	field_dot (stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the dot product of two fields.
template<typename Scalar, typename ExecSpace>
Scalar	field_dot (stk::mesh::FieldBase &x, stk::mesh::FieldBase &y, const ExecSpace &exec_space)
	Compute the dot product of two fields.
template<typename Scalar, typename ExecSpace>
Scalar	field_nrm2 (stk::mesh::FieldBase &x, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the 2-norm of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_nrm2 (stk::mesh::FieldBase &x, const ExecSpace &exec_space)
	Compute the 2-norm of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_sum (stk::mesh::FieldBase &x, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the sum of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_sum (stk::mesh::FieldBase &x, const ExecSpace &exec_space)
	Compute the sum of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_asum (stk::mesh::FieldBase &x, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the 1-norm of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_asum (stk::mesh::FieldBase &x, const ExecSpace &exec_space)
	Compute the 1-norm of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_max (stk::mesh::FieldBase &x, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the maximum value of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_max (stk::mesh::FieldBase &x, const ExecSpace &exec_space)
	Compute the maximum value of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_amax (stk::mesh::FieldBase &x, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the maximum absolute value of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_amax (stk::mesh::FieldBase &x, const ExecSpace &exec_space)
	Compute the maximum absolute value of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_min (stk::mesh::FieldBase &x, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the minimum value of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_min (stk::mesh::FieldBase &x, const ExecSpace &exec_space)
	Compute the minimum value of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_amin (stk::mesh::FieldBase &x, const stk::mesh::Selector &selector, const ExecSpace &exec_space)
	Compute the minimum absolute value of a field.
template<typename Scalar, typename ExecSpace>
Scalar	field_amin (stk::mesh::FieldBase &x, const ExecSpace &exec_space)
	Compute the minimum absolute value of a field.
template<typename Field>
void	sync_field_to_owning_space (Field &field)
template<typename ExecSpace>
void	sync_field_to_space (const stk::mesh::FieldBase &field, const ExecSpace &exec_space)
template<typename Field>
void	mark_field_modified_on_owning_space (Field &field)
template<typename ExecSpace>
void	mark_field_modified_on_space (const stk::mesh::FieldBase &field, const ExecSpace &exec_space)
template<typename NgpMemSpace = stk::ngp::MemSpace, typename SharedType>
NgpSharedComponent< SharedType, NgpMemSpace > &	get_updated_ngp_component (const SharedComponent< SharedType > &component)
template<typename NgpMemSpace = stk::ngp::MemSpace, typename ScalarType>
auto	get_updated_ngp_component (const SharedScalarComponent< ScalarType > &component)
stk::topology::rank_t	string_to_rank (const std::string &rank_string)
	Map a string with a valid rank name to the corresponding rank.
stk::mesh::Selector	string_to_selector (const BulkData &bulk_data, const std::string &selector_string)
	Map a string with a valid set of selector math to the corresponding selector.
stk::topology	string_to_topology (const std::string &topology_string)
	Map a string with a valid topology name to the corresponding topology.
Query helpers
Class &	get_class (stk::mesh::MetaData &meta_data, Class::class_ordinal_t class_ordinal)
	Fetch an existing class by ordinal from MetaData.
const Class &	get_class (const stk::mesh::MetaData &meta_data, Class::class_ordinal_t class_ordinal)
	Fetch an existing class by ordinal from MetaData.
Class &	get_class (stk::mesh::MetaData &meta_data, const std::string &class_name)
	Fetch an existing class by name from MetaData.
const Class &	get_class (const stk::mesh::MetaData &meta_data, const std::string &class_name)
	Fetch an existing class by name from MetaData.
Class &	get_class (stk::mesh::BulkData &bulk_data, Class::class_ordinal_t class_ordinal)
	Fetch an existing class by ordinal through the given BulkData's MetaData.
const Class &	get_class (const stk::mesh::BulkData &bulk_data, Class::class_ordinal_t class_ordinal)
	Fetch an existing class by ordinal through the given BulkData's MetaData.
Class &	get_class (stk::mesh::BulkData &bulk_data, const std::string &class_name)
	Fetch an existing class by name through the given BulkData's MetaData.
const Class &	get_class (const stk::mesh::BulkData &bulk_data, const std::string &class_name)
	Fetch an existing class by name through the given BulkData's MetaData.
const ClassVector &	get_classes (stk::mesh::BulkData &bulk_data)
	Fetch all classes visible from BulkData in class-ordinal order.
const ConstClassVector &	get_classes (const stk::mesh::BulkData &bulk_data)
	Fetch all classes visible from BulkData in class-ordinal order.
Non-member actions
void	declare_subset (Class &parent_class, Class &sub_class)
	Declare sub_class as a subclass of parent_class in both hierarchy channels.
stk::mesh::Selector	operator& (const Class &lhs, const Class &rhs)
	Intersection of a class assembly selector and another class assembly selector.
stk::mesh::Selector	operator& (const Class &lhs, const stk::mesh::Selector &rhs)
	Intersection of a class assembly selector and an STK selector.
stk::mesh::Selector	operator& (const stk::mesh::Selector &lhs, const Class &rhs)
	Intersection of an STK selector and a class assembly selector.
stk::mesh::Selector	operator| (const Class &lhs, const Class &rhs)
	Union of a class assembly selector and another class assembly selector.
stk::mesh::Selector	operator| (const Class &lhs, const stk::mesh::Selector &rhs)
	Union of a class assembly selector and an STK selector.
stk::mesh::Selector	operator| (const stk::mesh::Selector &lhs, const Class &rhs)
	Union of an STK selector and a class assembly selector.
stk::mesh::Selector	operator- (const Class &lhs, const Class &rhs)
	Difference of a class assembly selector and another class assembly selector.
stk::mesh::Selector	operator- (const Class &lhs, const stk::mesh::Selector &rhs)
	Difference of a class assembly selector and an STK selector.
stk::mesh::Selector	operator- (const stk::mesh::Selector &lhs, const Class &rhs)
	Difference of an STK selector and a class assembly selector.
stk::mesh::Selector	operator! (const Class &class_instance)
	Complement of a class assembly selector.
void	add_class_field (stk::io::StkMeshIoBroker &io_broker, size_t output_file_index, stk::mesh::FieldBase &field, const ClassVector &classes, const std::string &db_name)
	Register a field for output using Class-aware IO rules over an explicit class set.
void	add_class_field (stk::io::StkMeshIoBroker &io_broker, size_t output_file_index, stk::mesh::FieldBase &field, const ClassVector &classes)
	Register a field for output using Class-aware IO rules over an explicit class set.
void	add_class_field (stk::io::StkMeshIoBroker &io_broker, size_t output_file_index, stk::mesh::FieldBase &field, const std::string &db_name)
	Register a field for output using Class-aware IO rules.
void	add_class_field (stk::io::StkMeshIoBroker &io_broker, size_t output_file_index, stk::mesh::FieldBase &field)
	Register a field for output using Class-aware IO rules.
template<typename ComponentType>
void	add_class_component (stk::io::StkMeshIoBroker &io_broker, size_t output_file_index, ComponentType &component, const ClassVector &classes, const std::string &db_name)
	Register a component for output using Class-aware IO rules over an explicit class set.
template<typename ComponentType>
void	add_class_component (stk::io::StkMeshIoBroker &io_broker, size_t output_file_index, ComponentType &component, const ClassVector &classes)
	Register a component for output using Class-aware IO rules over an explicit class set.
template<typename ComponentType>
void	add_class_component (stk::io::StkMeshIoBroker &io_broker, size_t output_file_index, ComponentType &component, const std::string &db_name)
	Register a component for output using Class-aware IO rules.
template<typename ComponentType>
void	add_class_component (stk::io::StkMeshIoBroker &io_broker, size_t output_file_index, ComponentType &component)
	Register a component for output using Class-aware IO rules.
template<typename FieldType>
void	put_field_on_mesh (FieldType &field, Class &class_instance, const typename FieldType::value_type *init_value)
	Put a rank-0/1 field restriction on a class data part.
template<typename FieldType>
void	put_field_on_mesh (FieldType &field, Class &class_instance, unsigned n1, const typename FieldType::value_type *init_value)
	Put a rank-1 field restriction on a class data part.
template<typename FieldType>
void	put_field_on_mesh (FieldType &field, Class &class_instance, unsigned n1, unsigned n2, const typename FieldType::value_type *init_value)
	Put a rank-2 field restriction on a class data part.
Entity declaration interface
BulkDataClassInterface	class_interface (stk::mesh::BulkData &bulk_data)
Our Tags (types never need to be complete)
template<typename Tag, typename ComponentType>
auto	make_tagged_component (ComponentType component)
template<typename Tag, typename ComponentType>
decltype(auto)	get_updated_ngp_component (const TaggedComponent< Tag, ComponentType > &tagged_component)
Forward declarations
void	add_link_restart_fields (stk::io::StkMeshIoBroker &io_broker, size_t output_index, LinkMetaData &link_meta_data)
std::shared_ptr< LinkMetaData >	declare_link_meta_data_ptr (stk::mesh::MetaData &meta_data, const std::string &our_name, stk::mesh::EntityRank link_rank)
	Construct a new LinkMetaData object.
LinkMetaData &	declare_link_meta_data (stk::mesh::MetaData &meta_data, const std::string &our_name, stk::mesh::EntityRank link_rank)
	Construct a new LinkMetaData object.
std::shared_ptr< LinkMetaData >	get_link_meta_data (const stk::mesh::MetaData &meta_data, const std::string &our_name, stk::mesh::EntityRank link_rank)
Entity expression factories
template<typename ExecSpace = stk::ngp::ExecSpace>
auto	make_entity_expr (stk::mesh::BulkData &bulk_data, const stk::mesh::Selector &selector, const stk::mesh::EntityRank &rank, const ExecSpace &exec_space=ExecSpace())
	Create an entity expression for iterating over entities of a given rank in a selector.
template<typename PairView, typename FMIExtractor, typename ExecSpace = stk::ngp::ExecSpace>
auto	make_pairwise_entity_expr (stk::mesh::BulkData &bulk_data, const stk::mesh::EntityRank &left_rank, const stk::mesh::EntityRank &right_rank, const PairView &pair_view, const FMIExtractor &fmi_extractor, const ExecSpace &exec_space=ExecSpace())
	Create a pairwise entity expression for iterating over entity pairs defined by a pair view.
Value expressions
template<typename Func, typename... Args>
auto	apply_expr (Func func, const Args &... args)
	Build a read-only value expression by applying a function object to expression arguments.
Sink expressions
template<typename Arg>
auto	read_only (const Arg &arg)
	Wrap an argument as read-only for use with sink_expr().
template<typename Arg>
auto	read_write (const Arg &arg)
	Wrap an argument as read-write for use with sink_expr().
template<typename Arg>
auto	overwrite_all (const Arg &arg)
	Wrap an argument as overwrite-all for use with sink_expr().
template<typename Func, typename... Args>
void	sink_expr (Func func, const Args &... args)
	Apply a mutating function object to expression arguments, executing immediately. Builds the sink expression, drives it to completion, and returns void.
template<typename... Args>
auto	atomic_add (const Args &... args)
	Atomically add rhs to each element of the target expression.
template<typename... Args>
auto	atomic_sub (const Args &... args)
	Atomically subtract rhs from each element of the target expression.
template<typename... Args>
auto	atomic_mul (const Args &... args)
	Atomically multiply each element of the target expression by rhs.
template<typename... Args>
auto	atomic_div (const Args &... args)
	Atomically divide each element of the target expression by rhs.
RNG factory functions
template<typename SeedExpr, typename CounterExpr, typename RNGType = openrand::Philox, RNGType(*)(size_t, size_t) make_counter_based_rng = make_philox>
auto	rng (const SeedExpr &seed_expr, const CounterExpr &counter_expr)
	Create a counter-based random number generator using the given seed and counter. At least one of seed or counter must be an expression for this code to compile.
Fused assignment
template<typename... TrgSrcExprPairs>
void	fused_assign (const TrgSrcExprPairs &... exprs)
	Evaluate all RHS expressions before writing any LHS—simultaneous multi-target assignment in one kernel.
Reduction operations
template<typename Expr, typename ReductionOp>
void	reduce_local (Expr &&expr, ReductionOp &reduction)
	Reduces value of a given expression over all entities in the driver on this process.
template<typename Scalar, typename Expr>
auto	reduce_local_sum (Expr &&expr)
	Reduce sum (process local).
template<typename Scalar, typename Expr>
auto	reduce_local_max (Expr &&expr)
	Reduce max (process local).
template<typename Scalar, typename Expr>
auto	reduce_local_min (Expr &&expr)
	Reduce min (process local).
template<typename Scalar, typename Expr>
auto	all_reduce_sum (Expr &&expr)
	Reduces sum (all processes).
template<typename Scalar, typename Expr>
auto	all_reduce_max (Expr &&expr)
	Reduces max (all processes).
template<typename Scalar, typename Expr>
auto	all_reduce_min (Expr &&expr)
	Reduces min (all processes).
Link iteration
template<typename FunctionToRunPerLink>
void	for_each_link_run (const NgpLinkData &ngp_link_data, const stk::mesh::Selector &linker_subset_selector, const FunctionToRunPerLink &functor)
	Run an ngp-compatible function over each link in the ngp_link_data that falls in the given selector in parallel.
template<typename FunctionToRunPerLink>
void	for_each_link_run (const NgpLinkData &ngp_link_data, const FunctionToRunPerLink &functor)
	Run an ngp-compatible function over each link in the ngp_link_data in parallel.
template<typename FunctionToRunPerLink>
void	for_each_link_run (const LinkData &link_data, const stk::mesh::Selector &linker_subset_selector, const FunctionToRunPerLink &functor)
template<typename FunctionToRunPerLink>
void	for_each_link_run (const LinkData &link_data, const FunctionToRunPerLink &functor)

Variables
template<typename Field>
constexpr bool	is_device_field = false
template<typename Field>
constexpr bool	is_host_field = false
template<typename T, template< typename > class NgpDebugger>
constexpr bool	is_device_field< stk::mesh::DeviceField< T, NgpDebugger > > = true
template<typename T, template< typename > class NgpDebugger>
constexpr bool	is_device_field< const stk::mesh::DeviceField< T, NgpDebugger > > = true
template<typename T, template< typename > class NgpDebugger>
constexpr bool	is_host_field< stk::mesh::HostField< T, NgpDebugger > > = true
template<typename T, template< typename > class NgpDebugger>
constexpr bool	is_host_field< const stk::mesh::HostField< T, NgpDebugger > > = true
template<typename Field>
constexpr bool	is_ngp_field = is_device_field<Field> || is_host_field<Field>
template<typename Mesh>
constexpr bool	is_device_mesh = std::is_base_of_v<stk::mesh::DeviceMesh, Mesh>
template<typename Mesh>
constexpr bool	is_host_mesh = std::is_base_of_v<stk::mesh::HostMesh, Mesh>
template<typename Mesh>
constexpr bool	is_ngp_mesh = is_device_mesh<Mesh> || is_host_mesh<Mesh>
template<typename Mesh, typename Field>
constexpr bool	ngp_field_and_mesh_compatible

stk::mesh::Field data views
size_t	M
typename	StkDebugger
const stk::mesh::FastMeshIndex &	i
template<class FieldType, typename StkDebugger = stk::mesh::DefaultStkFieldSyncDebugger>
auto	scalar_field_data (const FieldType &f, stk::mesh::Entity e, stk::mesh::DummyOverload dummyArg=stk::mesh::DummyOverload(), const char *fileName=HOST_DEBUG_FILE_NAME, int lineNumber=HOST_DEBUG_LINE_NUMBER)
	Get a view of a field's data as a scalar. 1 scalar per entity.
template<size_t N, class FieldType, typename StkDebugger = stk::mesh::DefaultStkFieldSyncDebugger>
auto	vector_field_data (const FieldType &f, stk::mesh::Entity e, stk::mesh::DummyOverload dummyArg=stk::mesh::DummyOverload(), const char *fileName=HOST_DEBUG_FILE_NAME, int lineNumber=HOST_DEBUG_LINE_NUMBER)
	Get a view of a field's data as a Vector<N>. N scalars per entity.
	MUNDY_IMPL_VECTOR_FIELD_DATA_N (1) MUNDY_IMPL_VECTOR_FIELD_DATA_N(2) MUNDY_IMPL_VECTOR_FIELD_DATA_N(3) MUNDY_IMPL_VECTOR_FIELD_DATA_N(4) MUNDY_IMPL_VECTOR_FIELD_DATA_N(5) MUNDY_IMPL_VECTOR_FIELD_DATA_N(6) template< size_t N
	Get a view of a field's data as a Matrix<N, M>. N * M scalars per entity.
typename class FieldType auto	vector_field_data (FieldType &f, const stk::mesh::FastMeshIndex &i)
size_t class FieldType auto	matrix_field_data (FieldType &f, const stk::mesh::FastMeshIndex &i)
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (1, 1) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(1
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (1, 3) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(1
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (1, 5) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(1
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (2, 1) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(2
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (2, 3) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(2
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (2, 5) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(2
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (3, 1) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(3
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (3, 3) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(3
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (3, 5) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(3
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (4, 1) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(4
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (4, 3) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(4
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (4, 5) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(4
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (5, 1) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(5
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (5, 3) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(5
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (5, 5) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(5
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (6, 1) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(6
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (6, 3) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(6
	MUNDY_IMPL_MATRIX_FIELD_DATA_NM (6, 5) MUNDY_IMPL_MATRIX_FIELD_DATA_NM(6
	MUNDY_IMPL_MATRIX_FIELD_DATA_NN (1) MUNDY_IMPL_MATRIX_FIELD_DATA_NN(2) MUNDY_IMPL_MATRIX_FIELD_DATA_NN(3) MUNDY_IMPL_MATRIX_FIELD_DATA_NN(4) MUNDY_IMPL_MATRIX_FIELD_DATA_NN(5) MUNDY_IMPL_MATRIX_FIELD_DATA_NN(6) template< class FieldType > auto quaternion_field_data(FieldType &f
	Get a view of a field's data as a Quaternion.
template<class FieldType>
auto	aabb_field_data (FieldType &f, const stk::mesh::FastMeshIndex &i)
	Get a view of a field's data as an AABB. 6 scalars per entity. Layout: min corner xyz (0-2), max corner xyz (3-5).
template<class FieldType>
auto	obb_field_data (FieldType &f, const stk::mesh::FastMeshIndex &i)
	Get a view of a field's NGP data as an OBB. 10 scalars per entity. Layout: center xyz (0-2), orientation quaternion wxyz (3-6), half-extents xyz (7-9).

Typedef Documentation

canonical_component_access_t

template<typename AccessLike>

using mundy::mesh::canonical_component_access_t = typename canonical_component_access<AccessLike>::type

Vector1FieldComponent

template<typename ScalarType>

using mundy::mesh::Vector1FieldComponent = VectorFieldComponent<ScalarType, 1>

Vector2FieldComponent

template<typename ScalarType>

using mundy::mesh::Vector2FieldComponent = VectorFieldComponent<ScalarType, 2>

Vector3FieldComponent

template<typename ScalarType>

using mundy::mesh::Vector3FieldComponent = VectorFieldComponent<ScalarType, 3>

Vector4FieldComponent

template<typename ScalarType>

using mundy::mesh::Vector4FieldComponent = VectorFieldComponent<ScalarType, 4>

Vector5FieldComponent

template<typename ScalarType>

using mundy::mesh::Vector5FieldComponent = VectorFieldComponent<ScalarType, 5>

Vector6FieldComponent

template<typename ScalarType>

using mundy::mesh::Vector6FieldComponent = VectorFieldComponent<ScalarType, 6>

NgpVector1FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpVector1FieldComponent = NgpVectorFieldComponent<NgpFieldType, 1>

NgpVector2FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpVector2FieldComponent = NgpVectorFieldComponent<NgpFieldType, 2>

NgpVector3FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpVector3FieldComponent = NgpVectorFieldComponent<NgpFieldType, 3>

NgpVector4FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpVector4FieldComponent = NgpVectorFieldComponent<NgpFieldType, 4>

NgpVector5FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpVector5FieldComponent = NgpVectorFieldComponent<NgpFieldType, 5>

NgpVector6FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpVector6FieldComponent = NgpVectorFieldComponent<NgpFieldType, 6>

Matrix1FieldComponent

template<typename ScalarType>

using mundy::mesh::Matrix1FieldComponent = MatrixFieldComponent<ScalarType, 1, 1>

Matrix2FieldComponent

template<typename ScalarType>

using mundy::mesh::Matrix2FieldComponent = MatrixFieldComponent<ScalarType, 2, 2>

Matrix3FieldComponent

template<typename ScalarType>

using mundy::mesh::Matrix3FieldComponent = MatrixFieldComponent<ScalarType, 3, 3>

Matrix4FieldComponent

template<typename ScalarType>

using mundy::mesh::Matrix4FieldComponent = MatrixFieldComponent<ScalarType, 4, 4>

Matrix5FieldComponent

template<typename ScalarType>

using mundy::mesh::Matrix5FieldComponent = MatrixFieldComponent<ScalarType, 5, 5>

Matrix6FieldComponent

template<typename ScalarType>

using mundy::mesh::Matrix6FieldComponent = MatrixFieldComponent<ScalarType, 6, 6>

NgpMatrix1FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpMatrix1FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 1, 1>

NgpMatrix2FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpMatrix2FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 2, 2>

NgpMatrix3FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpMatrix3FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 3, 3>

NgpMatrix4FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpMatrix4FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 4, 4>

NgpMatrix5FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpMatrix5FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 5, 5>

NgpMatrix6FieldComponent

template<typename NgpFieldType>

using mundy::mesh::NgpMatrix6FieldComponent = NgpMatrixFieldComponent<NgpFieldType, 6, 6>

NgpLinkCOOData

using mundy::mesh::NgpLinkCOOData = NgpLinkCOODataT<stk::ngp::MemSpace>

LinkCSRBucketConn

using mundy::mesh::LinkCSRBucketConn = LinkCSRBucketConnT<stk::ngp::HostMemSpace>

NgpLinkCSRBucketConn

using mundy::mesh::NgpLinkCSRBucketConn = LinkCSRBucketConnT<stk::ngp::MemSpace>

LinkCSRData

using mundy::mesh::LinkCSRData = LinkCSRDataT<stk::ngp::HostMemSpace>

NgpLinkCSRDataT

template<typename NgpMemSpace>

using mundy::mesh::NgpLinkCSRDataT = LinkCSRDataT<NgpMemSpace>

NgpLinkCSRData

using mundy::mesh::NgpLinkCSRData = LinkCSRDataT<stk::ngp::MemSpace>

LinkCSRPartition

using mundy::mesh::LinkCSRPartition = LinkCSRPartitionT<stk::ngp::HostMemSpace>

NgpLinkCSRPartitionT

template<typename NgpMemSpace>

using mundy::mesh::NgpLinkCSRPartitionT = LinkCSRPartitionT<NgpMemSpace>

NgpLinkCSRPartition

using mundy::mesh::NgpLinkCSRPartition = LinkCSRPartitionT<stk::ngp::MemSpace>

NgpEntityPool

using mundy::mesh::NgpEntityPool = NgpEntityPoolT<typename stk::ngp::ExecSpace::memory_space, long int>

Unlike NgpNgpEntityPoolT, we follow stk::ngp conventions by using stk::ngp::ExecSpace as our chosen device space.

We chose to hard-code the default size type here to avoid users writing NgpEntityPool<>.

NgpLinkData

using mundy::mesh::NgpLinkData = NgpLinkDataT<stk::ngp::MemSpace>

NgpRequestEntitiesKnownIdsT

template<typename NgpMemSpace>

using mundy::mesh::NgpRequestEntitiesKnownIdsT = NgpRequestEntitiesImplT<NgpMemSpace, true>

NgpRequestEntitiesNewIdsT

template<typename NgpMemSpace>

using mundy::mesh::NgpRequestEntitiesNewIdsT = NgpRequestEntitiesImplT<NgpMemSpace, false>

NgpModRequests

using mundy::mesh::NgpModRequests = NgpModRequestsT<stk::ngp::MemSpace>

NgpRequestEntitiesKnownIds

using mundy::mesh::NgpRequestEntitiesKnownIds = NgpRequestEntitiesKnownIdsT<stk::ngp::MemSpace>

NgpRequestEntitiesNewIds

using mundy::mesh::NgpRequestEntitiesNewIds = NgpRequestEntitiesNewIdsT<stk::ngp::MemSpace>

NgpRequestConnections

using mundy::mesh::NgpRequestConnections = NgpRequestConnectionsT<stk::ngp::MemSpace>

NgpRequestLinkRelations

using mundy::mesh::NgpRequestLinkRelations = NgpRequestLinkRelationsT<stk::ngp::MemSpace>

NgpDestroyEntities

using mundy::mesh::NgpDestroyEntities = NgpDestroyEntitiesT<stk::ngp::MemSpace>

NgpDestroyConnections

using mundy::mesh::NgpDestroyConnections = NgpDestroyConnectionsT<stk::ngp::MemSpace>

SharedVector1Component

template<typename ScalarType>

using mundy::mesh::SharedVector1Component = SharedVectorComponent<ScalarType, 1>

SharedVector2Component

template<typename ScalarType>

using mundy::mesh::SharedVector2Component = SharedVectorComponent<ScalarType, 2>

SharedVector3Component

template<typename ScalarType>

using mundy::mesh::SharedVector3Component = SharedVectorComponent<ScalarType, 3>

SharedVector4Component

template<typename ScalarType>

using mundy::mesh::SharedVector4Component = SharedVectorComponent<ScalarType, 4>

SharedVector5Component

template<typename ScalarType>

using mundy::mesh::SharedVector5Component = SharedVectorComponent<ScalarType, 5>

SharedVector6Component

template<typename ScalarType>

using mundy::mesh::SharedVector6Component = SharedVectorComponent<ScalarType, 6>

SharedMatrix1Component

template<typename ScalarType>

using mundy::mesh::SharedMatrix1Component = SharedMatrixComponent<ScalarType, 1, 1>

SharedMatrix2Component

template<typename ScalarType>

using mundy::mesh::SharedMatrix2Component = SharedMatrixComponent<ScalarType, 2, 2>

SharedMatrix3Component

template<typename ScalarType>

using mundy::mesh::SharedMatrix3Component = SharedMatrixComponent<ScalarType, 3, 3>

SharedMatrix4Component

template<typename ScalarType>

using mundy::mesh::SharedMatrix4Component = SharedMatrixComponent<ScalarType, 4, 4>

SharedMatrix5Component

template<typename ScalarType>

using mundy::mesh::SharedMatrix5Component = SharedMatrixComponent<ScalarType, 5, 5>

SharedMatrix6Component

template<typename ScalarType>

using mundy::mesh::SharedMatrix6Component = SharedMatrixComponent<ScalarType, 6, 6>

NgpRawSharedComponent

template<typename SharedType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpRawSharedComponent = NgpSharedComponent<SharedType, NgpMemSpace>

NgpSharedVectorComponent

template<typename ScalarType, size_t N, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedVectorComponent = NgpSharedComponent<Vector<ScalarType, N>, NgpMemSpace>

NgpSharedVector1Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedVector1Component = NgpSharedVectorComponent<ScalarType, 1, NgpMemSpace>

NgpSharedVector2Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedVector2Component = NgpSharedVectorComponent<ScalarType, 2, NgpMemSpace>

NgpSharedVector3Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedVector3Component = NgpSharedVectorComponent<ScalarType, 3, NgpMemSpace>

NgpSharedVector4Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedVector4Component = NgpSharedVectorComponent<ScalarType, 4, NgpMemSpace>

NgpSharedVector5Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedVector5Component = NgpSharedVectorComponent<ScalarType, 5, NgpMemSpace>

NgpSharedVector6Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedVector6Component = NgpSharedVectorComponent<ScalarType, 6, NgpMemSpace>

NgpSharedMatrixComponent

template<typename ScalarType, size_t N, size_t M, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedMatrixComponent = NgpSharedComponent<Matrix<ScalarType, N, M>, NgpMemSpace>

NgpSharedMatrix1Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedMatrix1Component = NgpSharedMatrixComponent<ScalarType, 1, 1, NgpMemSpace>

NgpSharedMatrix2Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedMatrix2Component = NgpSharedMatrixComponent<ScalarType, 2, 2, NgpMemSpace>

NgpSharedMatrix3Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedMatrix3Component = NgpSharedMatrixComponent<ScalarType, 3, 3, NgpMemSpace>

NgpSharedMatrix4Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedMatrix4Component = NgpSharedMatrixComponent<ScalarType, 4, 4, NgpMemSpace>

NgpSharedMatrix5Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedMatrix5Component = NgpSharedMatrixComponent<ScalarType, 5, 5, NgpMemSpace>

NgpSharedMatrix6Component

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedMatrix6Component = NgpSharedMatrixComponent<ScalarType, 6, 6, NgpMemSpace>

NgpSharedQuaternionComponent

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedQuaternionComponent = NgpSharedComponent<Quaternion<ScalarType>, NgpMemSpace>

NgpSharedAABBComponent

template<typename ScalarType, typename NgpMemSpace = stk::ngp::MemSpace>

using mundy::mesh::NgpSharedAABBComponent = NgpSharedComponent<AABB<ScalarType>, NgpMemSpace>

Enumeration Type Documentation

IOPartRole

enum class mundy::mesh::IOPartRole

strong

Enumerator
NONE
IO
ASSEMBLY
EDGE_BLOCK

NgpDataAccessTag

enum mundy::mesh::NgpDataAccessTag : uint8_t

Enumerator
ReadWrite
ReadOnly
OverwriteAll
Unsynchronized
ConstUnsynchronized
InvalidAccess

Function Documentation

get_component() [1/2]

template<typename Tag, typename... Components>

const auto & mundy::mesh::get_component

(

const Aggregate< Components... > &

aggregate

)

get_component() [2/2]

template<typename Tag, typename... Components>

auto & mundy::mesh::get_component

(

Aggregate< Components... > &

aggregate

)

get() [1/6]

template<typename Tag, typename... Components>

decltype(auto) mundy::mesh::get	(	const Aggregate< Components... > &	aggregate,
		stk::mesh::Entity	entity )

get() [2/6]

template<typename Tag, typename... Components>

decltype(auto) mundy::mesh::get	(	Aggregate< Components... > &	aggregate,
		stk::mesh::Entity	entity )

has() [1/2]

template<typename Tag, typename... Components>

bool mundy::mesh::has ( const Aggregate< Components... > & )

constexpr

get() [3/6]

template<typename Tag, typename... Components>

decltype(auto) mundy::mesh::get	(	const NgpAggregate< Components... > &	aggregate,
		stk::mesh::FastMeshIndex	entity_index )

get() [4/6]

template<typename Tag, typename... Components>

decltype(auto) mundy::mesh::get	(	NgpAggregate< Components... > &	aggregate,
		stk::mesh::FastMeshIndex	entity_index )

get() [5/6]

template<typename Tag, typename... Components>

decltype(auto) mundy::mesh::get	(	const NgpAggregate< Components... > &	aggregate,
		stk::mesh::Entity	entity )

get() [6/6]

template<typename Tag, typename... Components>

decltype(auto) mundy::mesh::get	(	NgpAggregate< Components... > &	aggregate,
		stk::mesh::Entity	entity )

has() [2/2]

template<typename Tag, typename... Components>

bool mundy::mesh::has ( const NgpAggregate< Components... > & )

constexpr

get_updated_ngp_aggregate()

template<typename... TaggedComponents>

auto mundy::mesh::get_updated_ngp_aggregate

(

const Aggregate< TaggedComponents... > &

aggregate

)

make_tagged_component()

template<typename Tag, typename ComponentType>

auto mundy::mesh::make_tagged_component

(

ComponentType

component

)

get_updated_ngp_component() [1/4]

template<typename Tag, typename ComponentType>

decltype(auto) mundy::mesh::get_updated_ngp_component

(

const TaggedComponent< Tag, ComponentType > &

tagged_component

)

get_local_entity_indices()

template<typename OurExecSpace>

NgpViewT< stk::mesh::FastMeshIndex *, OurExecSpace > mundy::mesh::get_local_entity_indices	(	const stk::mesh::BulkData &	bulk_data,
		stk::mesh::EntityRank	rank,
		const stk::mesh::Selector &	selector,
		const OurExecSpace &	)

The returned view is ordered by stk::mesh::get_entities and is host-modified (call .sync_to_device() or pass through an NGP path before device use). The result is cached per the file note on memoization, so repeated calls within one mesh-modification epoch reuse the same view.

get_local_entities()

template<typename OurExecSpace>

NgpViewT< stk::mesh::Entity *, OurExecSpace > mundy::mesh::get_local_entities	(	const stk::mesh::BulkData &	bulk_data,
		stk::mesh::EntityRank	rank,
		const stk::mesh::Selector &	selector,
		const OurExecSpace &	)

The i-th entry of this view and the i-th entry of get_local_entity_indices(...) refer to the same entity, so the two can be used together: the index view to read NGP component/field data, the entity view to form EntityKeys (for STK coarse search, ghosting, etc.). The result is cached per the file note on memoization.

get_updated_ngp_component() [2/4]

template<typename ComponentType>

auto mundy::mesh::get_updated_ngp_component

(

const ComponentType &

component

)

Field-backed components simply wrap STK's updated ngp field and return the wrapper by value. The host component chooses the wrapper type through ngp_component_t, which keeps access policies intact (for example, AABBFieldComponent<T> returns NgpAABBFieldComponent<...>). SharedComponent follows the LinkData pattern instead, lazily materializing and caching a memspace-specific NgpSharedComponent in a std::any owned by the host component state.

for_each_entity_run() [1/4]

template<typename Mesh, typename AlgorithmPerEntity>

void mundy::mesh::for_each_entity_run ( Mesh & mesh, stk::topology::rank_t rank, const stk::mesh::Selector & selector, const AlgorithmPerEntity & functor )

inline

for_each_entity_run() [2/4]

template<typename Mesh, typename AlgorithmPerEntity, typename EXEC_SPACE>

void mundy::mesh::for_each_entity_run ( Mesh & mesh, stk::topology::rank_t rank, const stk::mesh::Selector & selector, const AlgorithmPerEntity & functor, const EXEC_SPACE & exec_space )

inline

for_each_entity_run() [3/4]

template<typename Mesh, typename AlgorithmPerEntity>

void mundy::mesh::for_each_entity_run ( const Mesh & mesh, stk::topology::rank_t rank, const stk::mesh::Selector & selector, const AlgorithmPerEntity & functor )

inline

for_each_entity_run() [4/4]

template<typename Mesh, typename AlgorithmPerEntity>

void mundy::mesh::for_each_entity_run ( const Mesh & mesh, stk::topology::rank_t rank, const AlgorithmPerEntity & functor )

inline

get_updated_ngp_link_data()

template<typename NgpMemSpace = stk::ngp::MemSpace>

NgpLinkDataT< NgpMemSpace > & mundy::mesh::get_updated_ngp_link_data

(

const LinkData &

link_data

)

Note

I believe this is the best place to explain what I have perceived as STK's intent for NgpMemSpace. Currently, you may have one and only one NGP memory space per bulk data object. Effectively, this works like a deconstructed Kokkos::DualView<NgpMemSpace> design where the host never knows about the device memory space and only learns about the device view when get_updated_ngp_* is called. The device memory space is then "locked in" for the lifetime of the bulk data. Consequently, you must use the same NgpMemSpace for ALL get_updated_ngp_* calls for a given bulk data. We follow the same design here with the NgpLinkDataT.

deep_copy() [1/2]

template<typename MemSpace1, typename MemSpace2>

void mundy::mesh::deep_copy	(	LinkCSRBucketConnT< MemSpace1 > &	dest,
		const LinkCSRBucketConnT< MemSpace2 > &	src )

deep_copy() [2/2]

template<typename MemSpace1, typename MemSpace2>

void mundy::mesh::deep_copy	(	LinkCSRPartitionT< MemSpace1 > &	dest,
		const LinkCSRPartitionT< MemSpace2 > &	src )

declare_link_data()

LinkData & mundy::mesh::declare_link_data ( stk::mesh::BulkData & bulk_data, LinkMetaData & link_meta_data )

inline

Parameters

bulk_data	[in] The bulk data manager we extend.
link_meta_data	[in] Our meta data manager.

Returns

A reference to the MetaData-owned LinkData object.

get_link_data() [1/2]

LinkData * mundy::mesh::get_link_data ( const stk::mesh::BulkData & bulk_data, const std::string & our_name, stk::mesh::EntityRank link_rank )

inline

get_link_data() [2/2]

LinkData * mundy::mesh::get_link_data ( const stk::mesh::BulkData & bulk_data, const LinkMetaData & link_meta_data )

inline

add_link_restart_fields()

void mundy::mesh::add_link_restart_fields ( stk::io::StkMeshIoBroker & io_broker, size_t output_index, LinkMetaData & link_meta_data )

inline

declare_link_meta_data_ptr()

std::shared_ptr< LinkMetaData > mundy::mesh::declare_link_meta_data_ptr ( stk::mesh::MetaData & meta_data, const std::string & our_name, stk::mesh::EntityRank link_rank )

inline

Parameters

meta_data	[in] The mesh meta data manager. (pre-commit)
our_name	[in] The name of this link data.
link_rank	[in] The rank of the link entities.

declare_link_meta_data()

LinkMetaData & mundy::mesh::declare_link_meta_data ( stk::mesh::MetaData & meta_data, const std::string & our_name, stk::mesh::EntityRank link_rank )

inline

Parameters

meta_data	[in] The mesh meta data manager. (pre-commit)
our_name	[in] The name of this link data.
link_rank	[in] The rank of the link entities.

get_link_meta_data()

std::shared_ptr< LinkMetaData > mundy::mesh::get_link_meta_data ( const stk::mesh::MetaData & meta_data, const std::string & our_name, stk::mesh::EntityRank link_rank )

inline

for_each_link_run() [1/4]

template<typename FunctionToRunPerLink>

void mundy::mesh::for_each_link_run	(	const NgpLinkData &	ngp_link_data,
		const stk::mesh::Selector &	linker_subset_selector,
		const FunctionToRunPerLink &	functor )

Thread parallel over each link.

The functor must have the following signature: operator()(const FastMeshIndex &) -> void

for_each_link_run() [2/4]

template<typename FunctionToRunPerLink>

void mundy::mesh::for_each_link_run	(	const NgpLinkData &	ngp_link_data,
		const FunctionToRunPerLink &	functor )

for_each_link_run() [3/4]

template<typename FunctionToRunPerLink>

void mundy::mesh::for_each_link_run	(	const LinkData &	link_data,
		const stk::mesh::Selector &	linker_subset_selector,
		const FunctionToRunPerLink &	functor )

for_each_link_run() [4/4]

template<typename FunctionToRunPerLink>

void mundy::mesh::for_each_link_run	(	const LinkData &	link_data,
		const FunctionToRunPerLink &	functor )

sync_field_to_owning_space()

template<typename Field>

void mundy::mesh::sync_field_to_owning_space

(

Field &

field

)

sync_field_to_space()

template<typename ExecSpace>

void mundy::mesh::sync_field_to_space	(	const stk::mesh::FieldBase &	field,
		const ExecSpace &	exec_space )

mark_field_modified_on_owning_space()

template<typename Field>

void mundy::mesh::mark_field_modified_on_owning_space

(

Field &

field

)

mark_field_modified_on_space()

template<typename ExecSpace>

void mundy::mesh::mark_field_modified_on_space	(	const stk::mesh::FieldBase &	field,
		const ExecSpace &	exec_space )

get_updated_ngp_component() [3/4]

template<typename NgpMemSpace = stk::ngp::MemSpace, typename SharedType>

NgpSharedComponent< SharedType, NgpMemSpace > & mundy::mesh::get_updated_ngp_component

(

const SharedComponent< SharedType > &

component

)

get_updated_ngp_component() [4/4]

template<typename NgpMemSpace = stk::ngp::MemSpace, typename ScalarType>

auto mundy::mesh::get_updated_ngp_component

(

const SharedScalarComponent< ScalarType > &

component

)

string_to_rank()

stk::topology::rank_t mundy::mesh::string_to_rank

(

const std::string &

rank_string

)

The set of valid rank names and their corresponding type is

• NODE_RANK -> stk::topology::NODE_RANK
• EDGE_RANK -> stk::topology::EDGE_RANK
• FACE_RANK -> stk::topology::FACE_RANK
• ELEMENT_RANK -> stk::topology::ELEMENT_RANK
• CONSTRAINT_RANK -> stk::topology::CONSTRAINT_RANK
• INVALID_RANK -> stk::topology::INVALID_RANK

Parameters

rank_string

[in] String containing a valid rank name.

string_to_selector()

stk::mesh::Selector mundy::mesh::string_to_selector	(	const BulkData &	bulk_data,
		const std::string &	selector_string )

Selectors are allowed to be combined using the following operators:

• Subtraction: -
• Arythmetic and: &
• Arythmetic or: |
• Unary not: !
• Parentheses: ( )

For example, to select all elements of parts A and B that are not in part C, the selector string would be: "(partA | partB) & !partC" To instead, get all elements in both parts A and B that are not in part C, the selector string would be: "(partA & partB) & !partC"

Spaces are allowed in the selector string, but are not required. Names may contain any combination of letters, numbers, underscores, and periods, so long as they start with a letter.

The names of the parts are fetched from the BulkData object. If a part name is not found, an exception is thrown. We offer the following special part names:

• "UNIVERSAL" -> The universal part, which contains all entities.
• "LOCALLY_OWNED" -> The locally owned part, which contains all entities owned by the current process.
• "GLOBALLY_SHARED" -> The globally shared part, which contains all entities shared from another processes.
• "AURA" -> The automatically generated auto part, which contains all entities ghosted from another process.

Parameters

bulk_data	[in] BulkData object used to fetch the part names.
selector_string	[in] String containing valid selector math.

string_to_topology()

stk::topology mundy::mesh::string_to_topology

(

const std::string &

topology_string

)

The set of valid topology names and their corresponding return type is

• No rank topologies
  • INVALID_TOPOLOGY -> stk::topology::INVALID_TOPOLOGY
• Node rank topologies
  • NODE -> stk::topology::NODE
• Edge rank topologies
  • LINE_2 -> stk::topology::LINE_2
  • LINE_3 -> stk::topology::LINE_3
• Face rank topologies
  • TRI_3 or TRIANGLE_3 -> stk::topology::TRI_3
  • TRI_4 or TRIANGLE_4 -> stk::topology::TRI_4
  • TRI_6 or TRIANGLE_6 -> stk::topology::TRI_6
  • QUAD_4 or QUADRILATERAL_4 -> stk::topology::QUAD_4
  • QUAD_6 or QUADRILATERAL_6 -> stk::topology::QUAD_6
  • QUAD_8 or QUADRILATERAL_8 -> stk::topology::QUAD_8
  • QUAD_9 or QUADRILATERAL_9 -> stk::topology::QUAD_9

Element rank topologies

• PARTICLE -> stk::topology::PARTICLE
• LINE_2_1D -> stk::topology::LINE_2_1D
• LINE_3_1D -> stk::topology::LINE_3_1D
• BEAM_2 -> stk::topology::BEAM_2
• BEAM_3 -> stk::topology::BEAM_3
• SHELL_LINE_2 -> stk::topology::SHELL_LINE_2
• SHELL_LINE_3 -> stk::topology::SHELL_LINE_3
• SPRING_2 -> stk::topology::SPRING_2
• SPRING_3 -> stk::topology::SPRING_3
• TRI_3_2D or TRIANGLE_3_2D -> stk::topology::TRI_3_2D
• TRI_4_2D or TRIANGLE_4_2D -> stk::topology::TRI_4_2D
• TRI_6_2D or TRIANGLE_6_2D -> stk::topology::TRI_6_2D
• QUAD_4_2D or QUADRILATERAL_4_2D -> stk::topology::QUAD_4_2D
• QUAD_8_2D or QUADRILATERAL_8_2D -> stk::topology::QUAD_8_2D
• QUAD_9_2D or QUADRILATERAL_9_2D -> stk::topology::QUAD_9_2D
• SHELL_TRI_3 or SHELL_TRIANGLE_3 -> stk::topology::SHELL_TRI_3
• SHELL_TRI_4 or SHELL_TRIANGLE_4 -> stk::topology::SHELL_TRI_4
• SHELL_TRI_6 or SHELL_TRIANGLE_6 -> stk::topology::SHELL_TRI_6
• SHELL_QUAD_4 or SHELL_QUADRILATERAL_4 -> stk::topology::SHELL_QUAD_4
• SHELL_QUAD_8 or SHELL_QUADRILATERAL_8 -> stk::topology::SHELL_QUAD_8
• SHELL_QUAD_9 or SHELL_QUADRILATERAL_9 -> stk::topology::SHELL_QUAD_9
• TET_4 or TETRAHEDRON_4 -> stk::topology::TET_4
• TET_8 or TETRAHEDRON_8 -> stk::topology::TET_8
• TET_10 or TETRAHEDRON_10 -> stk::topology::TET_10
• TET_11 or TETRAHEDRON_11 -> stk::topology::TET_11
• PYRAMID_5 -> stk::topology::PYRAMID_5
• PYRAMID_13 -> stk::topology::PYRAMID_13
• PYRAMID_14 -> stk::topology::PYRAMID_14
• WEDGE_6 -> stk::topology::WEDGE_6
• WEDGE_12 -> stk::topology::WEDGE_12
• WEDGE_15 -> stk::topology::WEDGE_15
• WEDGE_18 -> stk::topology::WEDGE_18
• HEX_8 or HEXAHEDRON_8 -> stk::topology::HEX_8
• HEX_20 or HEXAHEDRON_20 -> stk::topology::HEX_20
• HEX_27 or HEXAHEDRON_27 -> stk::topology::HEX_27

Super topologies

• SUPEREDGE<N> -> create_superedge_topology(N)
• SUPERFACE<N> -> create_superface_topology(N)
• SUPERELEMENT<N> -> create_superelement_topology(N)

  Parameters

  topology_string

  [in] String containing a valid topology name.

Variable Documentation

is_device_field

template<typename Field>

bool mundy::mesh::is_device_field = false

constexpr

is_host_field

template<typename Field>

bool mundy::mesh::is_host_field = false

constexpr

is_device_field< stk::mesh::DeviceField< T, NgpDebugger > >

template<typename T, template< typename > class NgpDebugger>

bool mundy::mesh::is_device_field< stk::mesh::DeviceField< T, NgpDebugger > > = true

constexpr

is_device_field< const stk::mesh::DeviceField< T, NgpDebugger > >

template<typename T, template< typename > class NgpDebugger>

bool mundy::mesh::is_device_field< const stk::mesh::DeviceField< T, NgpDebugger > > = true

constexpr

is_host_field< stk::mesh::HostField< T, NgpDebugger > >

template<typename T, template< typename > class NgpDebugger>

bool mundy::mesh::is_host_field< stk::mesh::HostField< T, NgpDebugger > > = true

constexpr

is_host_field< const stk::mesh::HostField< T, NgpDebugger > >

template<typename T, template< typename > class NgpDebugger>

bool mundy::mesh::is_host_field< const stk::mesh::HostField< T, NgpDebugger > > = true

constexpr

is_ngp_field

template<typename Field>

bool mundy::mesh::is_ngp_field = is_device_field<Field> || is_host_field<Field>

constexpr

is_device_mesh

template<typename Mesh>

bool mundy::mesh::is_device_mesh = std::is_base_of_v<stk::mesh::DeviceMesh, Mesh>

constexpr

is_host_mesh

template<typename Mesh>

bool mundy::mesh::is_host_mesh = std::is_base_of_v<stk::mesh::HostMesh, Mesh>

constexpr

is_ngp_mesh

template<typename Mesh>

bool mundy::mesh::is_ngp_mesh = is_device_mesh<Mesh> || is_host_mesh<Mesh>

constexpr

ngp_field_and_mesh_compatible

template<typename Mesh, typename Field>

bool mundy::mesh::ngp_field_and_mesh_compatible

constexpr

Initial value:

                                         =
(is_host_field<Field> == is_host_mesh<Mesh>) && (is_device_field<Field> == is_device_mesh<Mesh>)