Struct gut::mesh::tetmesh::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.

Methods

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>) -> 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<'a>(&'a self) -> impl Iterator<Item = Tetrahedron<T>> + 'a

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 gut::ops::ShapeMatrix trait and the gut::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 add_attrib<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    def: T
) -> Result<&mut Attribute<I>, Error> where
    T: Any + Clone, 

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

fn add_attrib_data<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    data: Vec<T>
) -> Result<&mut Attribute<I>, Error> where
    T: Any + Clone + Default, 

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

fn set_attrib<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    def: T
) -> Result<&mut Attribute<I>, Error> where
    T: Any + Clone, 

Sets 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: &[T]
) -> Result<&mut Attribute<I>, Error> where
    T: Any + Clone + Default, 

Set an attribute to the given data slice. 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. Return a mutable reference to the new attribute if successful.

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

Remove an attribute from the attribute dictionary. From there you can use methods defined on the returned attribute, and if desired return it back to the dictionary with insert_attrib.

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

Inserts an attribute into the dictionary with the usual HashMap semantics. This means that if an attribute with the same name exists, it will be returned and the current table entry is updated with the new value. If it doesn't already exist, None is returned.

fn attrib_or_add<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    def: T
) -> Result<&mut Attribute<I>, Error> where
    T: Any + Clone, 

Retrieve the attribute with the given name and if it doesn't exist, add 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_add_data<'a, T, I: AttribIndex<Self>>(
    &mut self,
    name: &'a str,
    data: &[T]
) -> Result<&mut Attribute<I>, Error> where
    T: Any + Clone + 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_iter<'a, 'b, T, I: 'b + AttribIndex<Self>>(
    &'b self,
    name: &'a str
) -> Result<Iter<T>, Error> where
    T: 'static + Clone, 

Get the attribute iterator. This is essentially a safe version of attrib(loc, name).unwrap().iter::<T>().

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

Get the attribute mutable iterator. This is essentially a safe version of attrib_mut(name).unwrap().iter_mut::<T>().

fn attrib_exists<'a, I: AttribIndex<Self>>(&self, name: &'a 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 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 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: 'static + Clone, 

Clone 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. From there you can use methods defined on the attribute itself.

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. From there you can use methods defined on the attribute itself.

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

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary 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 impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary 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 impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary mutable getter.

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

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

Returns a copy 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>

Performs the conversion.

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

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

Performs the conversion.

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_vec(vec: Vec<Self>) -> Self where
    Self: Default, 

Merge a Vec of objecs 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<TetMeshExt<T>> for TetMeshExt<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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

fn split_into_connected_components(self) -> Vec<Self>

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

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

fn impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary 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 impl_attrib_size(&self) -> usize

Mesh implementation of the attribute size getter.

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

Mesh implementation of the attribute dictionary getter.

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

Mesh implementation of the attribute dictionary 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>, 

Vertex accessor.