ids for mixed element grid

Author: mscroggs

src/grid/mixed_grid/builder.rs

@@ -23,8 +23,8 @@ pub struct SerialMixedGridBuilder<const GDIM: usize, T: Float + Scalar<Real = T>
     cell_types: Vec<ReferenceCellType>,
     cell_degrees: Vec<usize>,
     point_indices_to_ids: Vec<usize>,
-    cell_indices_to_ids: Vec<usize>,
     point_ids_to_indices: HashMap<usize, usize>,
+    cell_indices_to_ids: Vec<usize>,
     cell_ids_to_indices: HashMap<usize, usize>,
 }
 
@@ -46,8 +46,8 @@ where
             cell_types: vec![],
             cell_degrees: vec![],
             point_indices_to_ids: vec![],
-            cell_indices_to_ids: vec![],
             point_ids_to_indices: HashMap::new(),
+            cell_indices_to_ids: vec![],
             cell_ids_to_indices: HashMap::new(),
         }
     }
@@ -60,8 +60,8 @@ where
             cell_types: vec![],
             cell_degrees: vec![],
             point_indices_to_ids: Vec::with_capacity(npoints),
-            cell_indices_to_ids: Vec::with_capacity(ncells),
             point_ids_to_indices: HashMap::new(),
+            cell_indices_to_ids: Vec::with_capacity(ncells),
             cell_ids_to_indices: HashMap::new(),
         }
     }
@@ -110,6 +110,14 @@ where
             [npts, 3],
             [1, npts]
         ));
-        SerialMixedGrid::new(points, &self.cells, &self.cell_types, &self.cell_degrees)
+        SerialMixedGrid::new(
+            points,
+            &self.cells,
+            &self.cell_types,
+            &self.cell_degrees,
+            self.point_indices_to_ids,
+            self.point_ids_to_indices,
+            self.cell_indices_to_ids,
+        )
     }
 }

src/grid/mixed_grid/geometry.rs

@@ -14,6 +14,7 @@ use rlst_dense::{
     rlst_array_from_slice2, rlst_dynamic_array4,
     traits::{RandomAccessByRef, Shape, UnsafeRandomAccessByRef},
 };
+use std::collections::HashMap;
 
 /// Geometry of a serial grid
 pub struct SerialMixedGeometry<T: Float + Scalar> {
@@ -26,6 +27,10 @@ pub struct SerialMixedGeometry<T: Float + Scalar> {
     diameters: Vec<Vec<T>>,
     volumes: Vec<Vec<T>>,
     cell_indices: Vec<Vec<(usize, usize)>>,
+    point_indices_to_ids: Vec<usize>,
+    point_ids_to_indices: HashMap<usize, usize>,
+    cell_indices_to_ids: HashMap<(usize, usize), usize>,
+    cell_ids_to_indices: HashMap<usize, (usize, usize)>,
 }
 
 unsafe impl<T: Float + Scalar> Sync for SerialMixedGeometry<T> {}
@@ -36,12 +41,18 @@ impl<T: Float + Scalar> SerialMixedGeometry<T> {
         cells_input: &[usize],
         elements: Vec<CiarletElement<T>>,
         cell_elements: &[usize],
+        point_indices_to_ids: Vec<usize>,
+        point_ids_to_indices: HashMap<usize, usize>,
+        grid_cell_indices_to_ids: &[usize],
     ) -> Self {
         let dim = coordinates.shape()[1];
         let mut index_map = vec![(0, 0); cell_elements.len()];
         let mut cells = vec![];
         let mut cell_indices = vec![];
 
+        let mut cell_indices_to_ids = HashMap::new();
+        let mut cell_ids_to_indices = HashMap::new();
+
         for (element_index, _e) in elements.iter().enumerate() {
             let mut start = 0;
 
@@ -55,6 +66,8 @@ impl<T: Float + Scalar> SerialMixedGeometry<T> {
                     index_map[cell_i] = cell_index;
                     cell_indices[element_index].push(cell_index);
                     cells[element_index].extend_from_slice(&cells_input[start..start + size]);
+                    cell_indices_to_ids.insert(cell_index, grid_cell_indices_to_ids[cell_i]);
+                    cell_ids_to_indices.insert(grid_cell_indices_to_ids[cell_i], cell_index);
                 }
                 start += size;
             }
@@ -106,6 +119,10 @@ impl<T: Float + Scalar> SerialMixedGeometry<T> {
             diameters,
             volumes,
             cell_indices,
+            point_indices_to_ids,
+            point_ids_to_indices,
+            cell_indices_to_ids,
+            cell_ids_to_indices,
         }
     }
 }
@@ -195,18 +212,16 @@ impl<T: Float + Scalar> Geometry for SerialMixedGeometry<T> {
     }
 
     fn point_index_to_id(&self, index: usize) -> usize {
-        panic!();
+        self.point_indices_to_ids[index]
     }
-
     fn cell_index_to_id(&self, index: (usize, usize)) -> usize {
-        panic!();
+        self.cell_indices_to_ids[&index]
     }
-
     fn point_id_to_index(&self, id: usize) -> usize {
-        panic!();
+        self.point_ids_to_indices[&id]
     }
     fn cell_id_to_index(&self, id: usize) -> (usize, usize) {
-        panic!();
+        self.cell_ids_to_indices[&id]
     }
 }
 
@@ -304,7 +319,15 @@ mod test {
         *points.get_mut([2, 1]).unwrap() = 1.0;
         *points.get_mut([3, 0]).unwrap() = 0.0;
         *points.get_mut([3, 1]).unwrap() = 1.0;
-        SerialMixedGeometry::new(points, &[0, 1, 2, 0, 2, 3], vec![p1triangle], &[0, 0])
+        SerialMixedGeometry::new(
+            points,
+            &[0, 1, 2, 0, 2, 3],
+            vec![p1triangle],
+            &[0, 0],
+            vec![0, 1, 2, 3],
+            HashMap::from([(0, 0), (1, 1), (2, 2), (3, 3)]),
+            &[0, 1],
+        )
     }
 
     fn example_geometry_mixed() -> SerialMixedGeometry<f64> {
@@ -336,6 +359,9 @@ mod test {
             &[0, 1, 2, 3, 1, 4, 3],
             vec![p1quad, p1triangle],
             &[0, 1],
+            vec![0, 1, 2, 3, 4],
+            HashMap::from([(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]),
+            &[0, 1],
         )
     }
 

src/grid/mixed_grid/grid.rs

@@ -15,6 +15,7 @@ use rlst_dense::{
     data_container::VectorContainer,
     traits::MatrixInverse,
 };
+use std::collections::HashMap;
 
 /// A serial grid
 pub struct SerialMixedGrid<T: Float + Scalar> {
@@ -31,6 +32,9 @@ where
         cells: &[usize],
         cell_types: &[ReferenceCellType],
         cell_degrees: &[usize],
+        point_indices_to_ids: Vec<usize>,
+        point_ids_to_indices: HashMap<usize, usize>,
+        cell_indices_to_ids: Vec<usize>,
     ) -> Self {
         let mut element_info = vec![];
         let mut element_numbers = vec![];
@@ -64,8 +68,21 @@ where
             start += npoints;
         }
 
-        let topology = SerialMixedTopology::new(&cell_vertices, cell_types);
-        let geometry = SerialMixedGeometry::<T>::new(points, cells, elements, &element_numbers);
+        let topology = SerialMixedTopology::new(
+            &cell_vertices,
+            cell_types,
+            &point_indices_to_ids,
+            &cell_indices_to_ids,
+        );
+        let geometry = SerialMixedGeometry::<T>::new(
+            points,
+            cells,
+            elements,
+            &element_numbers,
+            point_indices_to_ids,
+            point_ids_to_indices,
+            &cell_indices_to_ids,
+        );
 
         Self { topology, geometry }
     }

src/grid/mixed_grid/topology.rs

@@ -34,16 +34,30 @@ pub struct SerialMixedTopology {
     cells_to_entities: Vec<HashMap<ReferenceCellType, Vec<Vec<IndexType>>>>,
     entities_to_cells: Vec<HashMap<ReferenceCellType, Vec<Vec<CellLocalIndexPair<IndexType>>>>>,
     entity_types: Vec<Vec<ReferenceCellType>>,
+    vertex_indices_to_ids: HashMap<IndexType, usize>,
+    vertex_ids_to_indices: HashMap<usize, IndexType>,
+    cell_indices_to_ids: HashMap<IndexType, usize>,
+    cell_ids_to_indices: HashMap<usize, IndexType>,
 }
 
 unsafe impl Sync for SerialMixedTopology {}
 
 impl SerialMixedTopology {
-    pub fn new(cells_input: &[usize], cell_types: &[ReferenceCellType]) -> Self {
+    pub fn new(
+        cells_input: &[usize],
+        cell_types: &[ReferenceCellType],
+        point_indices_to_ids: &[usize],
+        grid_cell_indices_to_ids: &[usize],
+    ) -> Self {
         let mut index_map = vec![(ReferenceCellType::Point, 0); cell_types.len()];
         let mut vertices = vec![];
         let dim = reference_cell::dim(cell_types[0]);
 
+        let mut vertex_indices_to_ids = HashMap::new();
+        let mut vertex_ids_to_indices = HashMap::new();
+        let mut cell_indices_to_ids = HashMap::new();
+        let mut cell_ids_to_indices = HashMap::new();
+
         let mut entity_types = vec![vec![]; 4];
 
         let mut entities_to_vertices = vec![HashMap::new(); dim];
@@ -81,13 +95,21 @@ impl SerialMixedTopology {
                     let cell = &cells_input[start..start + n];
                     let cell_i = (*c, cells_to_entities[0][c].len());
                     index_map[i] = cell_i;
+
+                    cell_indices_to_ids.insert(cell_i, grid_cell_indices_to_ids[i]);
+                    cell_ids_to_indices.insert(grid_cell_indices_to_ids[i], cell_i);
+
                     let mut row = vec![];
                     for v in cell {
                         if !vertices.contains(v) {
                             for (_, ec) in entities_to_cells[0].iter_mut() {
                                 ec.push(vec![]);
                             }
                             vertices.push(*v);
+                            vertex_indices_to_ids
+                                .insert((ReferenceCellType::Point, *v), point_indices_to_ids[*v]);
+                            vertex_ids_to_indices
+                                .insert(point_indices_to_ids[*v], (ReferenceCellType::Point, *v));
                         }
                         row.push((
                             ReferenceCellType::Point,
@@ -171,6 +193,10 @@ impl SerialMixedTopology {
             cells_to_entities,
             entities_to_cells,
             entity_types,
+            vertex_indices_to_ids,
+            vertex_ids_to_indices,
+            cell_indices_to_ids,
+            cell_ids_to_indices,
         }
     }
 }
@@ -263,17 +289,17 @@ impl Topology for SerialMixedTopology {
         }
     }
 
-    fn vertex_index_to_id(&self, index: Self::IndexType) -> usize {
-        panic!();
+    fn vertex_index_to_id(&self, index: IndexType) -> usize {
+        self.vertex_indices_to_ids[&index]
     }
-    fn cell_index_to_id(&self, index: Self::IndexType) -> usize {
-        panic!();
+    fn cell_index_to_id(&self, index: IndexType) -> usize {
+        self.cell_indices_to_ids[&index]
     }
-    fn vertex_id_to_index(&self, id: usize) -> Self::IndexType {
-        panic!();
+    fn vertex_id_to_index(&self, id: usize) -> IndexType {
+        self.vertex_ids_to_indices[&id]
     }
-    fn cell_id_to_index(&self, id: usize) -> Self::IndexType {
-        panic!();
+    fn cell_id_to_index(&self, id: usize) -> IndexType {
+        self.cell_ids_to_indices[&id]
     }
 }
 
@@ -282,7 +308,24 @@ mod test {
     use super::*;
 
     fn example_topology() -> SerialMixedTopology {
-        SerialMixedTopology::new(&[0, 1, 2, 2, 1, 3], &[ReferenceCellType::Triangle; 2])
+        SerialMixedTopology::new(
+            &[0, 1, 2, 2, 1, 3],
+            &[ReferenceCellType::Triangle; 2],
+            &[0, 1, 2, 3],
+            &[0, 1],
+        )
+    }
+
+    fn example_topology_mixed() -> SerialMixedTopology {
+        SerialMixedTopology::new(
+            &[0, 1, 2, 3, 1, 4, 3],
+            &[
+                ReferenceCellType::Quadrilateral,
+                ReferenceCellType::Triangle,
+            ],
+            &[0, 1, 2, 3, 4],
+            &[0, 1],
+        )
     }
 
     #[test]
@@ -339,16 +382,6 @@ mod test {
         }
     }
 
-    fn example_topology_mixed() -> SerialMixedTopology {
-        SerialMixedTopology::new(
-            &[0, 1, 2, 3, 1, 4, 3],
-            &[
-                ReferenceCellType::Quadrilateral,
-                ReferenceCellType::Triangle,
-            ],
-        )
-    }
-
     #[test]
     fn test_mixed_counts() {
         let t = example_topology_mixed();

src/grid/single_element_grid/grid.rs

@@ -29,7 +29,6 @@ impl<T: Float + Scalar> SerialSingleElementGrid<T>
 where
     for<'a> Array<T, ArrayViewMut<'a, T, BaseArray<T, VectorContainer<T>, 2>, 2>, 2>: MatrixInverse,
 {
-
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         points: Array<T, BaseArray<T, VectorContainer<T>, 2>, 2>,