Struct TetMeshExt

pub struct TetMeshExt<T: Real> {
    pub tetmesh: TetMesh<T>,
    pub cell_indices: Vec<usize>,
    pub cell_offsets: Vec<usize>,
    pub vertex_cell_attributes: AttribDict<VertexCellIndex>,
}

Mesh composed of tetrahedra, extended with its dual voronoi topology.

Fields

tetmesh: TetMesh<T>

cell_indices: Vec<usize>

Lists of cell indices for each vertex. Since each vertex can have a variable number of cell neighbours, the cell_offsets field keeps track of where each subarray of indices begins.

cell_offsets: Vec<usize>

Offsets into the cell_indices array, one for each vertex. The last offset is always equal to the size of cell_indices for convenience.

vertex_cell_attributes: AttribDict<VertexCellIndex>

Vertex cell Attributes.

Implementations

impl<T: Real> TetMeshExt<T>

pub fn vertex_connectivity(&self) -> (Vec<usize>, usize)

impl<T: Real> TetMeshExt<T>

pub fn merge_with_vertex_source<'a, I>( meshes: I, source_attrib: &str, ) -> Result<Self, Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: Clone,

Merge a iterator of meshes into a single distinct mesh.

This version of merge accepts an attribute name for the source index on vertices.

The mesh vertices will be merged in the order given by the source attribute. This is useful when merging previously split up meshes. The source attribute needs to have type usize.

If the source attribute does not exist in at least one of the given meshes, then None is returned and the merge is aborted.

This is a non-destructive merge — both original meshes remain intact. This also means that this way of merging is somewhat more expensive than a merge without any source indices.

impl<T: Real> TetMeshExt<T>

pub const TET_FACES: [[usize; 3]; 4]

This constant defines the triangle faces of each tet. The rule is that ith face of the tet is the one opposite to the ith vertex. The triangle starts with the smallest index.

pub fn new(verts: Vec<[T; 3]>, indices: Vec<[usize; 4]>) -> TetMeshExt<T>

pub fn cell_iter(&self) -> Iter<'_, [usize; 4]>

pub fn cell_iter_mut(&mut self) -> IterMut<'_, [usize; 4]>

pub fn cell<CI: Into<CellIndex>>(&self, cidx: CI) -> &[usize; 4]

Cell accessor. These are vertex indices.

pub fn cells(&self) -> &[[usize; 4]]

Return a slice of individual cells.

pub fn tet_iter(&self) -> impl Iterator<Item = Tetrahedron<T>> + '_

Tetrahedron iterator.

pub fn tet_from_indices(&self, indices: &[usize; 4]) -> Tetrahedron<T>

Get a tetrahedron primitive corresponding to the given vertex indices.

pub fn tet<CI: Into<CellIndex>>(&self, cidx: CI) -> Tetrahedron<T>

Get a tetrahedron primitive corresponding to the given cell index.

pub fn inverted(self) -> TetMeshExt<T>

Consumes the current mesh to produce a mesh with inverted tetrahedra.

pub fn invert(&mut self)

Non consuming verion of the inverted function which simply modifies the given mesh.

pub fn canonicalized(self) -> TetMeshExt<T>

Convert this mesh into canonical form. This function inverts any inverted tetrahedron such that all tetrahedra are in canonical (non-inverted) form. The canonical form is determined by the shape matrix determinant of each tetrahedron. Canonical tetrahedra have a positive shape matrix determinant (see the meshx::ops::ShapeMatrix trait and the meshx::prim::tetrahedron module).

pub fn canonicalize(&mut self)

Convert this mesh into canonical form. This function inverts any inverted tetrahedron such that all tetrahedra are in canonical (non-inverted) form. This is a non-consuming version of canonicalized.

Trait Implementations

impl<T: Real> Attrib for TetMeshExt<T>

fn attrib_size<I: AttribIndex<Self>>(&self) -> usize

Get the size of the attribute at the appropriate mesh location determined by I.

fn attrib_dict<I: AttribIndex<Self>>(&self) -> &AttribDict<I>

Read only access to the attribute dictionary.

fn attrib_dict_mut<I: AttribIndex<Self>>(&mut self) -> &mut AttribDict<I>

Read and write access to the attribute dictionary.

fn attrib_dict_and_cache_mut<I: AttribIndex<Self>>( &mut self, ) -> (&mut AttribDict<I>, Option<&mut AttribValueCache>)

Read and write access to the attribute dictionary along with a cache for indirect attribute values.

fn insert_attrib_with_default<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, def: T, ) -> Result<&mut Attribute<I>, Error>

where T: AttributeValue,

Insert an attribute at the appropriate location with a given default.

fn insert_attrib_data<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, data: Vec<T>, ) -> Result<&mut Attribute<I>, Error>

where T: AttributeValue + Default,

Construct an attribute from a given data Vec<T>. data must have exactly the right size for the attribute to be inserted successfully.

fn reset_attrib_to_default<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, def: T, ) -> Result<&mut Attribute<I>, Error>

where T: AttributeValue,

Resets the attribute to the specified default value whether or not it already exists.

fn set_attrib_data<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, data: Vec<T>, ) -> Result<&mut Attribute<I>, Error>

where T: AttributeValue + Default,

Set an attribute to the given data vector. data must have exactly the right size for the attribute to be set successfully.

fn insert_indirect_attrib<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, def: T, ) -> Result<(&mut Attribute<I>, &mut AttribValueCache), Error>

where T: AttributeValueHash,

Insert an indirect attribute at the appropriate location with a given default.

fn set_indirect_attrib<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, def: T, ) -> Result<(&mut Attribute<I>, &mut AttribValueCache), Error>

where T: AttributeValueHash,

Sets the indirect attribute to the specified default value whether or not it already exists.

fn insert_indirect_attrib_data<'a, I: AttribIndex<Self>>( &mut self, name: &'a str, data: IndirectData, ) -> Result<(&mut Attribute<I>, &mut AttribValueCache), Error>

Construct an indirect attribute from a given IndirectData. data must have exactly the right size for the attribute to be inserted successfully.

fn set_indirect_attrib_data<'a, I: AttribIndex<Self>>( &mut self, name: &'a str, data: IndirectData, ) -> Result<(&mut Attribute<I>, &mut AttribValueCache), Error>

Set an indirect attribute to the given IndirectData instance. data must have exactly the right size for the attribute to be set successfully.

fn duplicate_attrib<'a, 'b, T, I: AttribIndex<Self>>( &mut self, name: &'a str, new_name: &'b str, ) -> Result<&mut Attribute<I>, Error>

where T: Any + Clone,

Makes a copy of an existing attribute.

fn remove_attrib<I: AttribIndex<Self>>( &mut self, name: &str, ) -> Result<Attribute<I>, Error>

Remove an attribute from the attribute dictionary.

fn insert_attrib<I: AttribIndex<Self>>( &mut self, name: &str, attrib: Attribute<I>, ) -> Result<Option<Attribute<I>>, Error>

Inserts an attribute into the dictionary with the usual HashMap semantics.

fn attrib_or_insert_with_default<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, def: T, ) -> Result<&mut Attribute<I>, Error>

where T: AttributeValue,

Retrieve the attribute with the given name and if it doesn’t exist, insert a new one and set it to a given default value. In either case the mutable reference to the attribute is returned.

fn attrib_or_insert_data<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, data: &[T], ) -> Result<&mut Attribute<I>, Error>

where T: AttributeValue + Default,

Retrieve the attribute with the given name and if it doesn’t exist, set its data to what’s in the given slice. In either case the mutable reference to the attribute is returned.

fn attrib_or_insert_indirect<'a, T, I: AttribIndex<Self>>( &mut self, name: &'a str, def: T, ) -> Result<(&mut Attribute<I>, &mut AttribValueCache), Error>

where T: AttributeValueHash,

Retrieve the indirect attribute with the given name and if it doesn’t exist, insert a new one and set it to a given default value. In either case the mutable reference to the attribute is returned.

fn direct_attrib_iter<'a, 'b, T, I: 'b + AttribIndex<Self>>( &'b self, name: &'a str, ) -> Result<Iter<'b, T>, Error>

where T: Any + Clone,

Get the attribute iterator for a direct attribute.

fn attrib_iter_mut<'a, 'b, T, I: 'b + AttribIndex<Self>>( &'b mut self, name: &'a str, ) -> Result<IterMut<'b, T>, Error>

where T: Any + Clone,

Get the attribute mutable iterator for a direct attribute.

fn attrib_iter<'b, T, I: 'b + AttribIndex<Self>>( &'b self, name: &str, ) -> Result<Box<dyn Iterator<Item = &'b T> + 'b>, Error>

where T: Any + Clone,

Get the iterator for an attribute no matter what kind.

fn indirect_attrib_update_with<'a, 'b, T, I, F>( &'b mut self, name: &'a str, f: F, ) -> Result<(&'b mut Attribute<I>, &'b mut AttribValueCache), Error>

where T: AttributeValueHash, I: 'b + AttribIndex<Self>, F: FnMut(usize, &Irc<T>) -> Option<Irc<T>>,

Update indirect attribute entries with the given closure.

fn attrib_exists<I: AttribIndex<Self>>(&self, name: &str) -> bool

Return true if the given attribute exists at the given location, and false otherwise, even if the specified attribute location is invalid for the mesh.

fn attrib_check<'a, T: Any, I: AttribIndex<Self>>( &self, name: &'a str, ) -> Result<&Attribute<I>, Error>

Determine if the given attribute is valid and exists at the given location.

fn attrib_as_slice<'a, 'b, T: 'static, I: 'b + AttribIndex<Self>>( &'b self, name: &'a str, ) -> Result<&'b [T], Error>

Expose the underlying direct attribute as a slice.

fn attrib_as_mut_slice<'a, 'b, T: 'static, I: 'b + AttribIndex<Self>>( &'b mut self, name: &'a str, ) -> Result<&'b mut [T], Error>

Expose the underlying direct attribute as a mutable slice.

fn attrib_clone_into_vec<'a, 'b, T, I: 'b + AttribIndex<Self>>( &'b self, name: &'a str, ) -> Result<Vec<T>, Error>

where T: AttributeValueHash,

Clone attribute data into a Vec<T>.

fn direct_attrib_clone_into_vec<'a, 'b, T, I: 'b + AttribIndex<Self>>( &'b self, name: &'a str, ) -> Result<Vec<T>, Error>

where T: AttributeValue,

Clone direct attribute data into a Vec<T>.

fn attrib<'a, I: AttribIndex<Self>>( &self, name: &'a str, ) -> Result<&Attribute<I>, Error>

Borrow the raw attribute from the attribute dictionary.

fn attrib_mut<'a, I: AttribIndex<Self>>( &mut self, name: &'a str, ) -> Result<&mut Attribute<I>, Error>

Get the raw mutable attribute from the attribute dictionary.

impl<T: Real> CellAttrib for TetMeshExt<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<CellIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<CellIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut( &mut self, ) -> (&mut AttribDict<CellIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Real> CellFace for TetMeshExt<T>

fn face<CFI>(&self, cf_idx: CFI) -> FaceIndex

where CFI: Copy + Into<CellFaceIndex>,

Index of the destination element given the topology index.

fn cell_face<CI>(&self, cidx: CI, which: usize) -> Option<CellFaceIndex>

where CI: Copy + Into<CellIndex>,

Toplogy index: where the data lives in an attribute array.

fn num_cell_faces(&self) -> usize

Topology quantifier. Number of connectors in total.

fn num_faces_at_cell<CI>(&self, cidx: CI) -> usize

where CI: Copy + Into<CellIndex>,

Topology quantifier. Number of connectors at a particular element.

fn cell_to_face<I>(&self, i: I, k: usize) -> Option<FaceIndex>

where I: Copy + Into<CellIndex>,

Index of the destination element from the source index.

impl<T: Real> CellFaceAttrib for TetMeshExt<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<CellFaceIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<CellFaceIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut( &mut self, ) -> (&mut AttribDict<CellFaceIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Real> CellVertex for TetMeshExt<T>

fn vertex<CVI>(&self, cv_idx: CVI) -> VertexIndex

where CVI: Copy + Into<CellVertexIndex>,

Index of the destination element given the topology index.

fn cell_vertex<CI>(&self, cidx: CI, which: usize) -> Option<CellVertexIndex>

where CI: Copy + Into<CellIndex>,

Toplogy index: where the data lives in an attribute array.

fn num_cell_vertices(&self) -> usize

Topology quantifier. Number of connectors in total.

fn num_vertices_at_cell<CI>(&self, cidx: CI) -> usize

where CI: Copy + Into<CellIndex>,

Topology quantifier. Number of connectors at a particular element.

fn cell_to_vertex<I>(&self, i: I, k: usize) -> Option<VertexIndex>

where I: Copy + Into<CellIndex>,

Index of the destination element from the source index.

fn reverse_topo(&self) -> (Vec<usize>, Vec<usize>)

where Self: NumCells + NumVertices,

Generate the reverse topology structure.

fn reverse_source_topo(&self) -> (Vec<usize>, Vec<usize>)

where Self: NumVertices,

Generate the reverse topology structure from the destination element to the source topology element.

impl<T: Real> CellVertexAttrib for TetMeshExt<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<CellVertexIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<CellVertexIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut( &mut self, ) -> (&mut AttribDict<CellVertexIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Clone + Real> Clone for TetMeshExt<T>

fn clone(&self) -> TetMeshExt<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Real> Debug for TetMeshExt<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Real> Default for TetMeshExt<T>

fn default() -> Self

Produce an empty TetMeshExt. This is not particularly useful on its own, however it can be used as a null case for various mesh algorithms.

impl<T: Real> From<TetMesh<T>> for TetMeshExt<T>

fn from(tetmesh: TetMesh<T>) -> TetMeshExt<T>

Converts to this type from the input type.

impl<T: Real> From<TetMeshExt<T>> for TetMesh<T>

fn from(ext: TetMeshExt<T>) -> TetMesh<T>

Converts to this type from the input type.

impl<T: Real> Merge for TetMeshExt<T>

fn merge(&mut self, other: Self) -> &mut Self

Attributes with the same name but different types won’t be merged.

fn merge_iter(iterable: impl IntoIterator<Item = Self>) -> Self

where Self: Default,

Merge an iterator of objects into one of the same type.

fn merge_vec(vec: Vec<Self>) -> Self

where Self: Default,

Merge a Vec of objects into one of the same type.

fn merge_slice(slice: &[Self]) -> Self

where Self: Clone + Default,

In contrast to merge_vec, this function takes an immutable reference to a collection of meshes, and creates a brand new mesh that is a union of all the given meshes.

impl<T: Real> NumCells for TetMeshExt<T>

fn num_cells(&self) -> usize

impl<T: Real> NumVertices for TetMeshExt<T>

Define TetMeshExt topology

fn num_vertices(&self) -> usize

impl<T: PartialEq + Real> PartialEq for TetMeshExt<T>

fn eq(&self, other: &TetMeshExt<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Real> Split<VertexIndex> for TetMeshExt<T>

fn split(self, vertex_partition: &[usize], num_parts: usize) -> Vec<Self>

fn split_by_attrib<T: AttributeValueHash>(self, attrib: &str) -> Vec<Self>

where Self: Attrib, Src: AttribIndex<Self>,

Split the mesh using a given attribute whose type implements Hash and Eq.

fn split_by_attrib_ord<T: PartialOrd + AttributeValue>( self, attrib: &str, ) -> Vec<Self>

where Self: Attrib, Src: AttribIndex<Self>,

Split the mesh using a given attribute whose type implements PartialOrd.

impl<T: Real> SplitIntoConnectedComponents<VertexIndex, CellIndex> for TetMeshExt<T>

fn split_into_connected_components(self) -> Vec<Self>

impl<T: Real> VertexAttrib for TetMeshExt<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<VertexIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<VertexIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut( &mut self, ) -> (&mut AttribDict<VertexIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Real> VertexCell for TetMeshExt<T>

fn cell<VCI>(&self, vc_idx: VCI) -> CellIndex

where VCI: Copy + Into<VertexCellIndex>,

Index of the destination element given the topology index.

fn vertex_cell<VI>(&self, vidx: VI, which: usize) -> Option<VertexCellIndex>

where VI: Copy + Into<VertexIndex>,

Toplogy index: where the data lives in an attribute array.

fn num_vertex_cells(&self) -> usize

Topology quantifier. Number of connectors in total.

fn num_cells_at_vertex<VI>(&self, vidx: VI) -> usize

where VI: Copy + Into<VertexIndex>,

Topology quantifier. Number of connectors at a particular element.

fn vertex_to_cell<I>(&self, i: I, k: usize) -> Option<CellIndex>

where I: Copy + Into<VertexIndex>,

Index of the destination element from the source index.

impl<T: Real> VertexCellAttrib for TetMeshExt<T>

fn topo_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

fn topo_attrib_dict(&self) -> &AttribDict<VertexCellIndex>

Mesh implementation of the attribute dictionary getter.

fn topo_attrib_dict_mut(&mut self) -> &mut AttribDict<VertexCellIndex>

Mesh implementation of the attribute dictionary mutable getter.

fn topo_attrib_dict_and_cache_mut( &mut self, ) -> (&mut AttribDict<VertexCellIndex>, Option<&mut AttribValueCache>)

Mesh implementation of the attribute dictionary and cache mutable getter.

impl<T: Real> VertexPositions for TetMeshExt<T>

type Element = <TetMesh<T> as VertexPositions>::Element

fn vertex_positions(&self) -> &[Self::Element]

Vertex positions as a slice of triplets.

fn vertex_positions_mut(&mut self) -> &mut [Self::Element]

Vertex positions as a mutable slice of triplets.

fn vertex_position_iter(&self) -> Iter<'_, Self::Element>

Vertex iterator.

fn vertex_position_iter_mut(&mut self) -> IterMut<'_, Self::Element>

Mutable vertex iterator.

fn vertex_position<VI>(&self, vidx: VI) -> Self::Element

where VI: Into<VertexIndex>, Self::Element: Clone,

Vertex accessor.

impl<T: Real> StructuralPartialEq for TetMeshExt<T>