emerge 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

emerge/_emerge/geo/shapes.py

@@ -50,14 +50,15 @@ class Box(GeoVolume):
             alignment (Alignment, optional): Which point of the box is placed at the position. 
                 Defaults to Alignment.CORNER.
         """
-
+    _default_name: str = 'Box'
     def __init__(self, 
                  width: float, 
                  depth: float, 
                  height: float, 
                  position: tuple = (0,0,0),
                  alignment: Alignment = Alignment.CORNER,
-                 cs: CoordinateSystem = GCS):
+                 cs: CoordinateSystem = GCS,
+                 name: str | None = None):
         """Creates a box volume object.
         Specify the alignment of the box with the provided position. The options are CORNER (default)
         for the front-left-bottom node of the box or CENTER for the center of the box.
@@ -76,7 +77,7 @@ class Box(GeoVolume):
         x,y,z = position
 
         tag = gmsh.model.occ.addBox(x,y,z,width,depth,height)
-        super().__init__(tag)
+        super().__init__(tag, name=name)
 
         self.center = (x+width/2, y+depth/2, z+height/2)
         self.width = width
@@ -116,6 +117,7 @@ class Sphere(GeoVolume):
         radius (float): The sphere radius
         position (tuple, optional): The center position. Defaults to (0,0,0).
     """
+    _default_name: str = 'Sphere'
     def __init__(self, 
                  radius: float,
                  position: tuple = (0,0,0)):
@@ -142,11 +144,13 @@ class XYPlate(GeoSurface):
             position (tuple, optional): The position of the alignment node. Defaults to (0,0,0).
             alignment (Alignment, optional): Which node to align to. Defaults to Alignment.CORNER.
         """
+    _default_name: str = 'XYPlate'
     def __init__(self, 
                  width: float, 
                  depth: float, 
                  position: tuple = (0,0,0),
-                 alignment: Alignment = Alignment.CORNER):
+                 alignment: Alignment = Alignment.CORNER,
+                 name: str | None = None):
         """Generates and XY-plane oriented plate
         
         Specify the alignment of the plate with the provided position. The options are CORNER (default)
@@ -158,7 +162,7 @@ class XYPlate(GeoSurface):
             position (tuple, optional): The position of the alignment node. Defaults to (0,0,0).
             alignment (Alignment, optional): Which node to align to. Defaults to Alignment.CORNER.
         """
-        super().__init__([])
+        super().__init__([], name=name)
         if alignment is Alignment.CENTER:
             position = (position[0]-width/2, position[1]-depth/2, position[2])
         
@@ -180,10 +184,12 @@ class Plate(GeoSurface):
             u (tuple[float, float, float]): The u-axis of the plate
             v (tuple[float, float, float]): The v-axis of the plate
         """
+    _default_name: str = 'Plate'
     def __init__(self,
                 origin: tuple[float, float, float],
                 u: tuple[float, float, float],
-                v: tuple[float, float, float]):
+                v: tuple[float, float, float],
+                name: str | None = None):
         """A generalized 2D rectangular plate in XYZ-space.
 
         The plate is specified by an origin (o) in meters coordinate plus two vectors (u,v) in meters
@@ -215,7 +221,7 @@ class Plate(GeoSurface):
         tag_wire = gmsh.model.occ.addWire([tagl1,tagl2, tagl3, tagl4])
 
         tags: list[int] = [gmsh.model.occ.addPlaneSurface([tag_wire,]),]
-        super().__init__(tags)
+        super().__init__(tags, name=name)
 
 
 class Cylinder(GeoVolume):
@@ -235,11 +241,13 @@ class Cylinder(GeoVolume):
             cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
+    _default_name: str = 'Cylinder'
     def __init__(self, 
                  radius: float,
                  height: float,
                  cs: CoordinateSystem = GCS,
-                 Nsections: int | None = None):
+                 Nsections: int | None = None,
+                 name: str | None = None):
         """Generates a Cylinder object in 3D space.
         The cylinder will always be placed in the origin of the provided CoordinateSystem.
         The bottom cylinder plane is always placed in the XY-plane. The length of the cylinder is
@@ -263,12 +271,12 @@ class Cylinder(GeoVolume):
             cyl = XYPolygon.circle(radius, Nsections=Nsections).extrude(height, cs)
             cyl._exists = False
             self._face_pointers = cyl._face_pointers
-            super().__init__(cyl.tags)
+            super().__init__(cyl.tags, name=name)
         else:
             cyl = gmsh.model.occ.addCylinder(cs.origin[0], cs.origin[1], cs.origin[2],
                                          height*ax[0], height*ax[1], height*ax[2],
                                          radius)
-            super().__init__(cyl)
+            super().__init__(cyl, name=name)
         self._add_face_pointer('front', cs.origin, -cs.zax.np)
         self._add_face_pointer('back', cs.origin+height*cs.zax.np, cs.zax.np)
         self._add_face_pointer('bottom', cs.origin, -cs.zax.np)
@@ -312,12 +320,14 @@ class CoaxCylinder(GeoVolume):
             cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
+    _default_name: str = 'CoaxCylinder'
     def __init__(self, 
                  rout: float,
                  rin: float,
                  height: float,
                  cs: CoordinateSystem = GCS,
-                 Nsections: int | None = None):
+                 Nsections: int | None = None,
+                 name: str | None = None):
         """Generates a Coaxial cylinder object in 3D space.
         The coaxial cylinder will always be placed in the origin of the provided CoordinateSystem.
         The bottom coax plane is always placed in the XY-plane. The lenth of the coax is
@@ -347,7 +357,7 @@ class CoaxCylinder(GeoVolume):
         self.cyl_out._exists = False
         cyltags, _ = gmsh.model.occ.cut(self.cyl_out.dimtags, self.cyl_in.dimtags)
         
-        super().__init__([dt[1] for dt in cyltags])
+        super().__init__([dt[1] for dt in cyltags], name=name)
 
         self._add_face_pointer('front', cs.origin, -cs.zax.np)
         self._add_face_pointer('back', cs.origin+height*cs.zax.np, cs.zax.np)
@@ -374,10 +384,12 @@ class CoaxCylinder(GeoVolume):
     
 class HalfSphere(GeoVolume):
     """A half sphere volume."""
+    _default_name: str = 'HalfSphere'
     def __init__(self,
                  radius: float,
                  position: tuple = (0,0,0),
-                 direction: tuple = (1,0,0)):
+                 direction: tuple = (1,0,0),
+                 name: str | None = None):
         
         sphere = Sphere(radius, position=position)
         cx, cy, cz = position
@@ -393,7 +405,7 @@ class HalfSphere(GeoVolume):
         sphere._exists = False
         box._exists = False
 
-        super().__init__([dt[1] for dt in dimtags])
+        super().__init__([dt[1] for dt in dimtags], name=name)
         
         self._add_face_pointer('front',np.array(position), np.array(direction))
         self._add_face_pointer('back',np.array(position), np.array(direction))
@@ -528,10 +540,13 @@ class Cone(GeoVolume):
             r1 (float): _description_
             r2 (float): _description_
         """
+    _default_name: str = 'Cone'
+    
     def __init__(self, p0: tuple[float, float, float],
                  direction: tuple[float, float, float],
                  r1: float,
-                 r2: float):
+                 r2: float,
+                 name: str | None = None):
         """Constructis a cone that starts at position p0 and is aimed in the given direction.
         r1 is the start radius and r2 the end radius. The magnitude of direction determines its length.
 
@@ -542,7 +557,7 @@ class Cone(GeoVolume):
             r2 (float): _description_
         """
         tag = gmsh.model.occ.add_cone(*p0, *direction, r1, r2)
-        super().__init__(tag)
+        super().__init__(tag, name=name)
         
         p0 = np.array(p0)
         ds = np.array(direction)

emerge/_emerge/geometry.py

@@ -33,6 +33,7 @@ def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
 
 def _bbcenter(x1, y1, z1, x2, y2, z2):
     return np.array([(x1+x2)/2, (y1+y2)/2, (z1+z2)/2])
+
 FaceNames = Literal['back','front','left','right','top','bottom']
 
 class _KEY_GENERATOR:
@@ -47,8 +48,9 @@ class _KEY_GENERATOR:
 class _GeometryManager:
 
     def __init__(self):
-        self.geometry_list: dict[str, list[GeoObject]] = dict()
+        self.geometry_list: dict[str, dict[str, GeoObject]] = dict()
         self.active: str = ''
+        self.geometry_names: dict[str, set[str]] = dict()
 
     def get_surfaces(self) -> list[GeoSurface]:
         return [geo for geo in self.all_geometries() if geo.dim==2]
@@ -56,23 +58,40 @@ class _GeometryManager:
     def all_geometries(self, model: str | None = None) -> list[GeoObject]:
         if model is None:
             model = self.active
-        return [geo for geo in self.geometry_list[model] if geo._exists]
+        return [geo for geo in self.geometry_list[model].values() if geo._exists]
 
+    def all_names(self, model: str | None = None) -> set[str]:
+        if model is None:
+            model = self.active
+        return self.geometry_names[model]
+    
+    def get_name(self, suggestion: str, model: str | None = None) -> str:
+        names = self.all_names(model)
+        if suggestion not in names:
+            return suggestion
+        for i in range(1_000_000):
+            if f'{suggestion}_{i}' not in names:
+                return f'{suggestion}_{i}'
+        raise RuntimeError('Cannot generate a unique name.')
+        
     def submit_geometry(self, geo: GeoObject, model: str | None = None) -> None:
         if model is None:
             model = self.active
-        self.geometry_list[model].append(geo)
+        self.geometry_list[model][geo.name] = geo
+        self.geometry_names[model].add(geo.name)
 
     def sign_in(self, modelname: str) -> None:
         # if modelname not in self.geometry_list:
         #     self.geometry_list[modelname] = []
         if modelname is self.geometry_list:
             logger.warning(f'{modelname} already exist, Geometries will be reset.')
-        self.geometry_list[modelname] = []
+        self.geometry_list[modelname] = dict()
+        self.geometry_names[modelname] = set()
         self.active = modelname
 
     def reset(self, modelname: str) -> None:
-        self.geometry_list[modelname] = []
+        self.geometry_list[modelname] = dict()
+        self.geometry_names[modelname] = set()
     
     def lowest_priority(self) -> int:
         return min([geo._priority for geo in self.all_geometries()])
@@ -219,7 +238,8 @@ class GeoObject:
     """A generalization of any OpenCASCADE entity described by a dimension and a set of tags.
     """
     dim: int = -1
-    def __init__(self, tags: list[int] | None = None):
+    _default_name: str = 'GeoObject'
+    def __init__(self, tags: list[int] | None = None, name: str | None = None):
         if tags is None:
             tags = []
         self.old_tags: list[int] = []
@@ -238,18 +258,63 @@ class GeoObject:
         self._priority: int = 10
 
         self._exists: bool = True
+        
+        self.give_name(name)
         _GEOMANAGER.submit_geometry(self)
 
+    def _store(self, name: str, data: Any) -> None:
+        """Store a property as auxilliary data under a given name
+
+        Args:
+            name (str): Name field
+            data (Any): Data to store
+        """
+        self._aux_data[name] = data
+
+    def _load(self, name: str) -> Any | None:
+        """Load data with a given name. If it doesn't exist, it returns None
+
+        Args:
+            name (str): The property to retreive
+
+        Returns:
+            Any | None: The property
+        """
+        return self._aux_data.get(name, None)
+    
+    def give_name(self, name: str | None = None) -> GeoObject:
+        """Assign a name to this object
+
+        Args:
+            name (str | None, optional): The name for the object. Defaults to None.
+        """
+        if name is None:
+            name = self._default_name
+        self.name: str = _GEOMANAGER.get_name(name)
+        return self
+    
     @property
     def color_rgb(self) -> tuple[float, float, float]:
+        """The color of the object in RGB float tuple
+
+        Returns:
+            tuple[float, float, float]: The color
+        """
         return self.material.color_rgb
     
     @property
     def opacity(self) -> float:
+        """The opacity of the object
+
+        Returns:
+            float: The opacity
+        """
         return self.material.opacity
     
     @property
     def _metal(self) -> bool:
+        """If the material should be rendered as metal
+        """
         return self.material._metal
     
     @property
@@ -266,6 +331,14 @@ class GeoObject:
     
     @staticmethod
     def merged(objects: list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject]) -> list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject] | GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject:
+        """Create a GeoObject by merging an iterable of GeoObjects
+
+        Args:
+            objects (list[GeoPoint  |  GeoEdge  |  GeoSurface  |  GeoVolume  |  GeoObject]): A list of geo objects
+
+        Returns:
+            GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject: The resultant object
+        """
         dim = objects[0].dim
         tags = []
         out: GeoObject | None = None
@@ -291,6 +364,17 @@ class GeoObject:
                           origin: np.ndarray | None = None,
                           normal: np.ndarray | None = None,
                           tag: int | None = None):
+        """Adds a face identifier (face pointer) to this object
+
+        Args:
+            name (str): The name for the face
+            origin (np.ndarray | None, optional): A point on the object. Defaults to None.
+            normal (np.ndarray | None, optional): The normal of the face. Defaults to None.
+            tag (int | None, optional): The tace tag used to extract the origin and normal. Defaults to None.
+
+        Raises:
+            ValueError: _description_
+        """
         if tag is not None:
             o = gmsh.model.occ.get_center_of_mass(2, tag)
             n = gmsh.model.get_normal(tag, (0,0))
@@ -302,6 +386,7 @@ class GeoObject:
         raise ValueError('Eitehr a tag or an origin + normal must be provided!')
     
     def make_copy(self) -> GeoObject:
+        """ Copies this object and returns a new object (also in GMSH)"""
         new_dimtags = gmsh.model.occ.copy(self.dimtags)
         new_obj = GeoObject.from_dimtags(new_dimtags)
         new_obj.material = self.material
@@ -319,6 +404,11 @@ class GeoObject:
         return new_obj
 
     def replace_tags(self, tagmap: dict[int, list[int]]):
+        """Replaces the GMSH tags assigned to this objects
+
+        Args:
+            tagmap (dict[int, list[int]]): A map that shows which tag is mapped to which set of new tags.
+        """
         self.old_tags = self.tags
         newtags = []
         for tag in self.tags:
@@ -454,7 +544,9 @@ class GeoObject:
         self._priority = _GEOMANAGER.highest_priority()+10
         return self
     
-    def boundary(self, exclude: tuple[FaceNames,...] | None = None, tags: list[int] | None = None) -> FaceSelection:
+    def boundary(self, exclude: tuple[FaceNames,...] | None = None, 
+                 tags: list[int] | None = None,
+                 tool: GeoObject | None = None) -> FaceSelection:
         """Returns the complete set of boundary faces.
 
         If implemented, it is possible to exclude a set of faces based on their name
@@ -471,7 +563,7 @@ class GeoObject:
         
         
         for name in exclude:
-            tags.extend(self.face(name).tags)
+            tags.extend(self.face(name, tool=tool).tags)
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     
@@ -535,8 +627,10 @@ class GeoVolume(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not represent EMerge
     specific geometry data.'''
     dim = 3
-    def __init__(self, tag: int | Iterable[int]):
-        super().__init__()
+    _default_name: str = 'GeoVolume'
+    def __init__(self, tag: int | Iterable[int], name: str | None = None):
+        super().__init__(name=name)
+        
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -549,13 +643,14 @@ class GeoVolume(GeoObject):
     
 class GeoPoint(GeoObject):
     dim = 0
-
+    _default_name: str = 'GeoPoint'
+    
     @property
     def selection(self) -> PointSelection:
         return PointSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
 
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
@@ -565,13 +660,14 @@ class GeoPoint(GeoObject):
 
 class GeoEdge(GeoObject):
     dim = 1
-
+    _default_name: str = 'GeoEdge'
+    
     @property
     def selection(self) -> EdgeSelection:
         return EdgeSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -583,13 +679,14 @@ class GeoSurface(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not reprsent Emerge
     specific geometry data.'''
     dim = 2
-
+    _default_name: str = 'GeoSurface'
+    
     @property
     def selection(self) -> FaceSelection:
         return FaceSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -597,10 +694,12 @@ class GeoSurface(GeoObject):
             self.tags = [tag,]
 
 class GeoPolygon(GeoSurface):
+    _default_name: str = 'GeoPolygon'
     
     def __init__(self,
-                 tags: list[int]):
-        super().__init__(tags)
+                 tags: list[int],
+                 name: str | None = None):
+        super().__init__(tags, name=name)
         self.points: list[int] = []
         self.lines: list[int] = []
 

emerge/_emerge/mesh3d.py

@@ -18,25 +18,14 @@
 from __future__ import annotations
 import gmsh # type: ignore
 import numpy as np
-from numba import njit, f8 # type: ignore
 from .mesher import Mesher
 from typing import Union, List, Tuple, Callable, Any
 from collections import defaultdict
 from .geometry import GeoVolume
-from .mth.optimized import outward_normal
 from loguru import logger
-from functools import cache
 from .bc import Periodic
-from .mth.pairing import pair_coordinates
 from .material import Material
 
-@njit(f8(f8[:], f8[:], f8[:]), cache=True, nogil=True)
-def area(x1: np.ndarray, x2: np.ndarray, x3: np.ndarray):
-    e1 = x2 - x1
-    e2 = x3 - x1
-    av = np.array([e1[1]*e2[2] - e1[2]*e2[1], e1[2]*e2[0] - e1[0]*e2[2], e1[0]*e2[1] - e1[1]*e2[0]])
-    return np.sqrt(av[0]**2 + av[1]**2 + av[2]**2)/2
-
 def shortest_distance(point_cloud):
     """
     Compute the shortest distance between any two points in a 3D point cloud.
@@ -122,7 +111,6 @@ class Mesh3D(Mesh):
         self.inv_tets: dict = dict()
 
         # Mappings
-
         self.tet_to_edge: np.ndarray = np.array([])
         self.tet_to_edge_sign: np.ndarray = np.array([])
         self.tet_to_tri: np.ndarray = np.array([])
@@ -133,7 +121,6 @@ class Mesh3D(Mesh):
         self.node_to_edge: defaultdict | dict = defaultdict()
 
         # Physics mappings
-
         self.tet_to_field: np.ndarray = np.array([])
         self.edge_to_field: np.ndarray = np.array([])
         self.tri_to_field: np.ndarray = np.array([])
@@ -149,6 +136,10 @@ class Mesh3D(Mesh):
         self.vtag_to_tet:  dict[int, list[int]] = dict()
         self.etag_to_edge: dict[int, list[int]] = dict()
         
+        ## Dervied
+        self.dimtag_to_center: dict[tuple[int, int], tuple[float, float, float]] = dict()
+        self.dimtag_to_edges: dict[tuple[int, int], np.ndarray] = dict()
+        
         self.exterior_face_tags: list[int] = []
     
     @property
@@ -170,7 +161,7 @@ class Mesh3D(Mesh):
     def n_nodes(self) -> int:
         '''Return the number of nodes'''
         return self.nodes.shape[1]
-
+    
     def get_edge(self, i1: int, i2: int, skip: bool = False) -> int:
         '''Return the edge index given the two node indices'''
         if i1==i2:
@@ -202,21 +193,6 @@ class Mesh3D(Mesh):
         if output is None:
             raise ValueError(f'There is no tetrahedron with indices {i1}, {i2}, {i3}, {i4}')
         return output
-    
-    def boundary_triangles(self, dimtags: list[tuple[int, int]] | None = None) -> np.ndarray:
-        if dimtags is None:
-            outputtags = []
-            for tags in self.ftag_to_tri.values():
-                outputtags.extend(tags)
-            return np.array(outputtags)
-        else:
-            dts = []
-            for dimtag in dimtags:
-                if dimtag[0]==2:
-                    dts.append(dimtag)
-                elif dimtag[0]==3:
-                    dts.extend(gmsh.model.get_boundary(dimtags))
-            return self.get_triangles([tag[1] for tag in dts])
         
 
     def get_tetrahedra(self, vol_tags: Union[int, list[int]]) -> np.ndarray:
@@ -242,7 +218,7 @@ class Mesh3D(Mesh):
 
         return np.array(indices)
     
-    def domain_edges(self, dimtags: list[tuple[int,int]]) -> np.ndarray:
+    def _domain_edge(self, dimtag: tuple[int,int]) -> np.ndarray:
         """Returns a np.ndarray of all edge indices corresponding to a set of dimension tags.
 
         Args:
@@ -252,21 +228,39 @@ class Mesh3D(Mesh):
             np.ndarray: The list of mesh edge element indices.
         """
         dimtags_edge = []
-        for (d,t) in dimtags:
-            if d==1:
-                dimtags_edge.append(t)
-            if d==2:
-                dimtags_edge.extend(gmsh.model.getBoundary([(d,t),], False, False))
-            if d==3:
-                dts = gmsh.model.getBoundary([(d,t),], False, False)
-                dimtags_edge.extend(gmsh.model.getBoundary(dts, False, False))
-        
+        d,t = dimtag
+        if d==0:
+            return np.ndarray([], dtype=np.int64)
+        if d==1:
+            dimtags_edge.append((1,t))
+        if d==2:
+            dimtags_edge.extend(gmsh.model.getBoundary([(d,t),], False, False))
+        if d==3:
+            dts = gmsh.model.getBoundary([(d,t),], False, False)
+            dimtags_edge.extend(gmsh.model.getBoundary(dts, False, False))
+    
         edge_ids = []
         for tag in dimtags_edge:
             edge_ids.extend(self.etag_to_edge[tag[1]])
         edge_ids = np.array(edge_ids)
         return edge_ids
+    
+    def domain_edges(self, dimtags: list[tuple[int,int]]) -> np.ndarray:
+        """Returns a np.ndarray of all edge indices corresponding to a set of dimension tags.
+
+        Args:
+            dimtags (list[tuple[int,int]]): A list of dimtags.
+
+        Returns:
+            np.ndarray: The list of mesh edge element indices.
+        """
         
+        edge_ids = []
+        for dt in dimtags:
+            edge_ids.extend(self.dimtag_to_edges[dt])
+        edge_ids = np.array(edge_ids)
+        return edge_ids
+    
     def get_face_tets(self, *taglist: list[int]) -> np.ndarray:
         ''' Return a list of a tetrahedrons that share a node with any of the nodes in the provided face.'''
         nodes: set = set()
@@ -297,7 +291,16 @@ class Mesh3D(Mesh):
         return np.array(sorted(list(set(edges))))
     
     
-    def update(self, periodic_bcs: list[Periodic] | None = None):
+    def _pre_update(self, periodic_bcs: list[Periodic] | None = None):
+        """Builds the mesh data properties
+
+        Args:
+            periodic_bcs (list[Periodic] | None, optional): A list of periodic boundary conditions. Defaults to None.
+
+        Returns:
+            None: None
+        """
+        from .mth.optimized import area
         
         logger.trace('Generating mesh data.')
         if periodic_bcs is None:
@@ -337,7 +340,7 @@ class Mesh3D(Mesh):
     
         for bc in periodic_bcs:
             logger.trace(f'reassigning ordered node numbers for periodic boundary {bc}')
-            nodemap, ids1, ids2 = self._derive_node_map(bc)
+            nodemap, ids1, ids2 = self._pre_derive_node_map(bc)
             nodemap = {int(a): int(b) for a,b in nodemap.items()}
             self.nodes[:,ids2] = self.nodes[:,ids1]
             for itet in range(self.tets.shape[1]):
@@ -487,12 +490,24 @@ class Mesh3D(Mesh):
             self.vtag_to_tet[t] = [self.get_tet(node_tags[0,i], node_tags[1,i], node_tags[2,i], node_tags[3,i]) for i in range(node_tags.shape[1])]
 
         self.defined = True
+        
+
+        ############################################################
+        #                            GMSH CACHE                   #
+        ############################################################
+
+        for dim in (0,1,2,3):
+            dts= gmsh.model.get_entities(dim)
+            for dt in dts:
+                self.dimtag_to_center[dt] = gmsh.model.occ.get_center_of_mass(*dt)
+                self.dimtag_to_edges[dt] = self._domain_edge(dt)
+                
         logger.trace('Done analyzing mesh.')
 
 
     ## Higher order functions
 
-    def _derive_node_map(self, bc: Periodic) -> tuple[dict[int, int], np.ndarray, np.ndarray]:
+    def _pre_derive_node_map(self, bc: Periodic) -> tuple[dict[int, int], np.ndarray, np.ndarray]:
         """Computes an old to new node index mapping that preserves global sorting
 
         Since basis function field direction is based on the order of indices in tetrahedron
@@ -507,6 +522,8 @@ class Mesh3D(Mesh):
             tuple[dict[int, int], np.ndarray, np.ndarray]: The node index mapping and the node index arrays
         """
 
+        from .mth.pairing import pair_coordinates
+        
         node_ids_1 = []
         node_ids_2 = []
 
@@ -539,7 +556,7 @@ class Mesh3D(Mesh):
         return conv_map, np.array(node_ids_2_unsorted), np.array(node_ids_2_sorted)
 
 
-    def retreive(self, volumes: list[GeoVolume]) -> list[Material]:
+    def _get_material_assignment(self, volumes: list[GeoVolume]) -> list[Material]:
         '''Retrieve the material properties of the geometry'''
         #arry = np.zeros((3,3,self.n_tets,), dtype=np.complex128)
         for vol in volumes:
@@ -791,6 +808,8 @@ class SurfaceMesh(Mesh):
     def update(self) -> None:
         ## First Edges
 
+        from .mth.optimized import outward_normal, area
+        
         edges = set()
         for i in range(self.n_tris):
             i1, i2, i3 = self.tris[:,i]