emerge 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

emerge/_emerge/geometry.py

@@ -16,13 +16,15 @@
 # <https://www.gnu.org/licenses/>.
 
 from __future__ import annotations
-import gmsh
+import gmsh # type: ignore
 from .material import Material, AIR
-from .selection import FaceSelection, DomainSelection, EdgeSelection, PointSelection
+from .selection import FaceSelection, DomainSelection, EdgeSelection, PointSelection, Selection
 from loguru import logger
-from typing import Literal, Any
+from typing import Literal, Any, Iterable, TypeVar
 import numpy as np
 
+
+
 def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
     new_tags = []
     for tag in tags:
@@ -48,12 +50,12 @@ class _GeometryManager:
         self.geometry_list: dict[str, list[GeoObject]] = dict()
         self.active: str = ''
 
-    def all_geometries(self, model: str = None) -> list[GeoObject]:
+    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]
 
-    def submit_geometry(self, geo: GeoObject, model: str = None) -> None:
+    def submit_geometry(self, geo: GeoObject, model: str | None = None) -> None:
         if model is None:
             model = self.active
         self.geometry_list[model].append(geo)
@@ -135,7 +137,7 @@ class _FacePointer:
     def translate(self, dx, dy, dz):
         self.o = self.o + np.array([dx, dy, dz])
     
-    def mirror(self, c0: np.ndarray, pln: np.ndarray):
+    def mirror(self, c0: np.ndarray, pln: np.ndarray) -> None:
         """
         Reflect self.o and self.n across the plane passing through c0
         with normal pln.
@@ -205,9 +207,11 @@ class GeoObject:
     """A generalization of any OpenCASCADE entity described by a dimension and a set of tags.
     """
     dim: int = -1
-    def __init__(self):
+    def __init__(self, tags: list[int] | None = None):
+        if tags is None:
+            tags = []
         self.old_tags: list[int] = []
-        self.tags: list[int] = []
+        self.tags: list[int] = tags
         self.material: Material = AIR
         self.mesh_multiplier: float = 1.0
         self.max_meshsize: float = 1e9
@@ -225,7 +229,7 @@ class GeoObject:
         _GEOMANAGER.submit_geometry(self)
 
     @property
-    def color_rgb(self) -> tuple[int,int,int]:
+    def color_rgb(self) -> tuple[float, float, float]:
         return self.material.color_rgb
     
     @property
@@ -233,7 +237,7 @@ class GeoObject:
         return self.material.opacity
     
     @property
-    def select(self) -> FaceSelection | DomainSelection | EdgeSelection | None:
+    def select(self) -> Selection:
         '''Returns a corresponding Face/Domain or Edge Selection object'''
         if self.dim==1:
             return EdgeSelection(self.tags)
@@ -241,11 +245,14 @@ class GeoObject:
             return FaceSelection(self.tags)
         elif self.dim==3:
             return DomainSelection(self.tags)
+        else:
+            return Selection(self.tags)
     
     @staticmethod
-    def merged(objects: list[GeoObject]) -> list[GeoObject]:
+    def merged(objects: list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject]) -> list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject] | GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject:
         dim = objects[0].dim
         tags = []
+        out: GeoObject | None = None
         for obj in objects:
             tags.extend(obj.tags)
         if dim==2:
@@ -260,8 +267,8 @@ class GeoObject:
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({self.dim},{self.tags})'
 
-    def _data(self, *labels) -> tuple[Any]:
-        return tuple([self._aux_data.get(lab, None) for lab in labels])
+    def _data(self, *labels) -> tuple[Any | None, ...]:
+        return tuple([self._aux_data[lab] for lab in labels])
     
     def _add_face_pointer(self, 
                           name: str,
@@ -292,7 +299,7 @@ class GeoObject:
         for tag in self.tags:
             newtags.extend(tagmap.get(tag, [tag,]))
         self.tags = newtags
-        logger.debug(f'Replaced {self.old_tags} with {self.tags}')
+        logger.debug(f'{self} Replaced {self.old_tags} -> {self.tags}')
     
     def update_tags(self, tag_mapping: dict[int,dict]) -> GeoObject:
         ''' Update the tag definition of a GeoObject after fragementation.'''
@@ -325,7 +332,7 @@ class GeoObject:
             self._tools.update(obj._tools)
         return self
     
-    def _face_tags(self, name: FaceNames, tool: GeoObject = None) -> list[int]:
+    def _face_tags(self, name: FaceNames, tool: GeoObject | None = None) -> list[int]:
         names = self._all_pointer_names
         if name not in names:
             raise ValueError(f'The face {name} does not exist in {self}')
@@ -380,7 +387,7 @@ class GeoObject:
         self._priority -= 1
         return self
 
-    def outside(self, *exclude: FaceNames, tags: list[int] = None) -> FaceSelection:
+    def outside(self, *exclude: FaceNames, tags: list[int] | None = None) -> FaceSelection:
         """Returns the complete set of outside faces.
 
         If implemented, it is possible to exclude a set of faces based on their name
@@ -394,7 +401,7 @@ class GeoObject:
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     
-    def face(self, name: FaceNames, tool: GeoObject = None) -> FaceSelection:
+    def face(self, name: FaceNames, tool: GeoObject | None = None) -> FaceSelection:
         """Returns the FaceSelection for a given face name.
         
         The face name must be defined for the type of geometry.
@@ -422,7 +429,7 @@ class GeoObject:
             return FaceSelection([t[1] for t in tags])
         if self.dim == 2:
             return FaceSelection(self.tags)
-        if self.dim < 2:
+        else:
             raise ValueError('Can only generate faces for objects of dimension 2 or higher.')
 
     @staticmethod
@@ -443,12 +450,13 @@ 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 | list[int]):
+    def __init__(self, tag: int | Iterable[int]):
         super().__init__()
-        if isinstance(tag, list):
-            self.tags: list[int] = tag
+        self.tags: list[int] = []
+        if isinstance(tag, Iterable):
+            self.tags = list(tag)
         else:
-            self.tags: list[int] = [tag,]
+            self.tags = [tag,]
 
     @property
     def select(self) -> DomainSelection:
@@ -463,10 +471,12 @@ class GeoPoint(GeoObject):
     
     def __init__(self, tag: int | list[int]):
         super().__init__()
-        if isinstance(tag, list):
-            self.tags: list[int] = tag
+
+        self.tags: list[int] = []
+        if isinstance(tag, Iterable):
+            self.tags = list(tag)
         else:
-            self.tags: list[int] = [tag,]
+            self.tags = [tag,]
 
 class GeoEdge(GeoObject):
     dim = 1
@@ -477,10 +487,11 @@ class GeoEdge(GeoObject):
     
     def __init__(self, tag: int | list[int]):
         super().__init__()
-        if isinstance(tag, list):
-            self.tags: list[int] = tag
+        self.tags: list[int] = []
+        if isinstance(tag, Iterable):
+            self.tags = list(tag)
         else:
-            self.tags: list[int] = [tag,]
+            self.tags = [tag,]
         
 
 class GeoSurface(GeoObject):
@@ -494,17 +505,20 @@ class GeoSurface(GeoObject):
     
     def __init__(self, tag: int | list[int]):
         super().__init__()
-        if isinstance(tag, list):
-            self.tags: list[int] = tag
+        self.tags: list[int] = []
+        if isinstance(tag, Iterable):
+            self.tags = list(tag)
         else:
-            self.tags: list[int] = [tag,]
+            self.tags = [tag,]
 
 class GeoPolygon(GeoSurface):
     
     def __init__(self,
                  tags: list[int]):
         super().__init__(tags)
-        self.points: list[int] = None
-        self.lines: list[int] = None
+        self.points: list[int] = []
+        self.lines: list[int] = []
 
     
+T = TypeVar('T', GeoVolume, GeoEdge, GeoPoint, GeoSurface)
+    

emerge/_emerge/logsettings.py

@@ -4,31 +4,32 @@ from typing import Literal
 from enum import Enum
 from pathlib import Path
 import os
-
+import gmsh
 
 ############################################################
 #                          FORMATS                         #
 ############################################################
 
 TRACE_FORMAT = (
-    "{time: YY/MM/DD - (ddd) - HH:mm:ss.SSSS} | <green>{elapsed}</green> [ <level>{level}</level> ] "
-    " <level>{message}</level>"
+    "{time:ddd YY/MM/DD HH:mm:ss.SSSS} {level:<7} {thread.id:<15} {line:>4}: "
+    "{message}"
 )
+
 DEBUG_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 INFO_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 WARNING_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 ERROR_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 FORMAT_DICT = {
     'TRACE': TRACE_FORMAT,
@@ -51,8 +52,8 @@ class LogController:
         logger.remove()
         self.std_handlers: list[int] = []
         self.file_handlers: list[int] = []
-        self.level: LLTYPE = 'INFO'
-        self.file_level: LLTYPE = 'INFO'
+        self.level: str = 'INFO'
+        self.file_level: str = 'INFO'
     
     def set_default(self):
         value = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")
@@ -68,13 +69,11 @@ class LogController:
         handler = {"sink": sys.stdout, 
                    "level": loglevel, 
                    "format": FORMAT_DICT.get(loglevel, INFO_FORMAT)}
-        logger.configure(handlers=[handler])
+        logger.configure(handlers=[handler]) # type: ignore
         self.level = loglevel
         os.environ["EMERGE_STD_LOGLEVEL"] = loglevel
-        
 
     def set_write_file(self, path: Path, loglevel: str = 'TRACE'):
-
         handler_id = logger.add(str(path / 'logging.log'), mode='w', level=loglevel, format=FORMAT_DICT.get(loglevel, INFO_FORMAT), colorize=False, backtrace=True, diagnose=True)
         self.file_handlers.append(handler_id)
         self.file_level = loglevel

emerge/_emerge/material.py

@@ -17,7 +17,7 @@
 
 import numpy as np
 from dataclasses import dataclass
-
+from typing import Callable
 @dataclass
 class Material:
     """The Material class generalizes a material in the EMerge FEM environment.
@@ -34,17 +34,21 @@ class Material:
     ur: float = 1
     tand: float = 0
     cond: float = 0
-    _neff: float = None
-    _fer: callable = None
-    _fur: callable = None
+    _neff: float | None = None
+    _fer: Callable | None= None
+    _fur: Callable | None = None
     color: str = "#BEBEBE"
-    _color_rgb: tuple[int,int,int] = None
+    _color_rgb: tuple[float,float,float] = (0.5, 0.5, 0.5)
     opacity: float = 1.0
 
     def __post_init__(self):
         hex_str = self.color.lstrip('#')
         self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
 
+    @property
+    def sigma(self) -> float:
+        return self.cond
+        
     @property
     def color_rgb(self) -> tuple[float,float,float]:
         return self._color_rgb
@@ -73,34 +77,34 @@ class Material:
         return np.abs(np.sqrt(er*(1-1j*self.tand)*ur))
     
     @property
-    def fer2d(self) -> callable:
+    def fer2d(self) -> Callable:
         if self._fer is None:
             return lambda x,y: self.er*(1-1j*self.tand)*np.ones_like(x)
         else:
             return self._fer
         
     @property
-    def fur2d(self) -> callable:
+    def fur2d(self) -> Callable:
         if self._fur is None:
 
             return lambda x,y: self.ur*np.ones_like(x)
         else:
             return self._fur
     @property
-    def fer3d(self) -> callable:
+    def fer3d(self) -> Callable:
         if self._fer is None:
             return lambda x,y,z: self.er*(1-1j*self.tand)*np.ones_like(x)
         else:
             return self._fer
     
     @property
-    def fur3d(self) -> callable:
+    def fur3d(self) -> Callable:
         if self._fur is None:
             return lambda x,y,z: self.ur*np.ones_like(x)
         else:
             return self._fur
     @property
-    def fer3d_mat(self) -> callable:
+    def fer3d_mat(self) -> Callable:
         if self._fer is None:
             
             return lambda x,y,z: np.repeat(self.ermat[:, :, np.newaxis], x.shape[0], axis=2)
@@ -108,7 +112,7 @@ class Material:
             return self._fer
     
     @property
-    def fur3d_mat(self) -> callable:
+    def fur3d_mat(self) -> Callable:
         if self._fur is None:
             return lambda x,y,z: np.repeat(self.urmat[:, :, np.newaxis], x.shape[0], axis=2)
         else:

emerge/_emerge/mesh3d.py

@@ -16,11 +16,11 @@
 # <https://www.gnu.org/licenses/>.
 
 from __future__ import annotations
-import gmsh
+import gmsh # type: ignore
 import numpy as np
-from numba import njit, f8
+from numba import njit, f8 # type: ignore
 from .mesher import Mesher
-from typing import Union, List, Tuple, Callable
+from typing import Union, List, Tuple, Callable, Any
 from collections import defaultdict
 from .geometry import GeoVolume
 from .mth.optimized import outward_normal
@@ -75,8 +75,10 @@ def tri_ordering(i1: int, i2: int, i3: int) -> int:
     '''
     return np.sign(np.sign(i2-1) + np.sign(i3-i2) + np.sign(i1-i3))
 
+class Mesh:
+    pass
 
-class Mesh3D:
+class Mesh3D(Mesh):
     """A Mesh managing all 3D mesh related properties.
 
     Relevant mesh data such as mappings between nodes(vertices), edges, triangles and tetrahedra
@@ -89,54 +91,54 @@ class Mesh3D:
         self.geometry: Mesher = mesher
 
         # All spatial objects
-        self.nodes: np.ndarray = None
-        self.n_i2t: dict = None
-        self.n_t2i: dict = None
+        self.nodes: np.ndarray = np.array([])
+        self.n_i2t: dict = dict()
+        self.n_t2i: dict = dict()
 
         # tets colletions
-        self.tets: np.ndarray = None
-        self.tet_i2t: dict = None
-        self.tet_t2i: dict = None
-        self.centers: np.ndarray = None
+        self.tets: np.ndarray = np.array([])
+        self.tet_i2t: dict = dict()
+        self.tet_t2i: dict = dict()
+        self.centers: np.ndarray = np.array([])
 
         # triangles
-        self.tris: np.ndarray = None
-        self.tri_i2t: dict = None
-        self.tri_t2i: dict = None
-        self.areas: np.ndarray = None
-        self.tri_centers: np.ndarray = None
+        self.tris: np.ndarray = np.array([])
+        self.tri_i2t: dict = dict()
+        self.tri_t2i: dict = dict()
+        self.areas: np.ndarray = np.array([])
+        self.tri_centers: np.ndarray = np.array([])
 
         # edges
-        self.edges: np.ndarray = None
-        self.edge_i2t: dict = None
-        self.edge_t2i: dict = None
-        self.edge_centers: np.ndarray = None
-        self.edge_lengths: np.ndarray = None
+        self.edges: np.ndarray = np.array([])
+        self.edge_i2t: dict = dict()
+        self.edge_t2i: dict = dict()
+        self.edge_centers: np.ndarray = np.array([])
+        self.edge_lengths: np.ndarray = np.array([])
         
         # Inverse mappings
-        self.inv_edges: dict = None
-        self.inv_tris: dict = None
-        self.inv_tets: dict = None
+        self.inv_edges: dict = dict()
+        self.inv_tris: dict = dict()
+        self.inv_tets: dict = dict()
 
         # Mappings
 
-        self.tet_to_edge: np.ndarray = None
-        self.tet_to_edge_sign: np.ndarray = None
-        self.tet_to_tri: np.ndarray = None
-        self.tri_to_tet: np.ndarray = None
-        self.tri_to_edge: np.ndarray = None
-        self.tri_to_edge_sign: np.ndarray = None
-        self.edge_to_tri: defaultdict = None
-        self.node_to_edge: defaultdict = None
+        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([])
+        self.tri_to_tet: np.ndarray = np.array([])
+        self.tri_to_edge: np.ndarray = np.array([])
+        self.tri_to_edge_sign: np.ndarray = np.array([])
+        self.edge_to_tri: defaultdict | dict = defaultdict()
+        self.node_to_edge: defaultdict | dict = defaultdict()
 
         # Physics mappings
 
-        self.tet_to_field: np.ndarray = None
-        self.edge_to_field: np.ndarray = None
-        self.tri_to_field: np.ndarray = None
+        self.tet_to_field: np.ndarray = np.array([])
+        self.edge_to_field: np.ndarray = np.array([])
+        self.tri_to_field: np.ndarray = np.array([])
 
         ## States
-        self.defined = False
+        self.defined: bool = False
 
 
         ## Memory
@@ -144,6 +146,8 @@ class Mesh3D:
         self.ftag_to_node: dict[int, list[int]] = dict()
         self.ftag_to_edge: dict[int, list[int]] = dict()
         self.vtag_to_tet:  dict[int, list[int]] = dict()
+        
+        self.exterior_face_tags: list[int] = []
     
     @property
     def n_edges(self) -> int:
@@ -170,7 +174,9 @@ class Mesh3D:
         if i1==i2:
             raise ValueError("Edge cannot be formed by the same node.")
         search = (min(int(i1),int(i2)), max(int(i1),int(i2)))
-        result =  self.inv_edges.get(search, None)
+        result =  self.inv_edges.get(search, -10)
+        if result == -10:
+            ValueError(f'There is no edge with indices {i1}, {i2}')
         return result
     
     def get_edge_sign(self, i1: int, i2: int) -> int:
@@ -183,13 +189,19 @@ class Mesh3D:
         
     def get_tri(self, i1, i2, i3) -> int:
         '''Return the triangle index given the three node indices'''
-        return self.inv_tris.get(tuple(sorted((int(i1), int(i2), int(i3)))), None)
+        output = self.inv_tris.get(tuple(sorted((int(i1), int(i2), int(i3)))), None)
+        if output is None:
+            raise ValueError(f'There is no triangle with indices {i1}, {i2}, {i3}')
+        return output
     
     def get_tet(self, i1, i2, i3, i4) -> int:
         '''Return the tetrahedron index given the four node indices'''
-        return self.inv_tets.get(tuple(sorted((int(i1), int(i2), int(i3), int(i4)))), None)
+        output = self.inv_tets.get(tuple(sorted((int(i1), int(i2), int(i3), int(i4)))), None)
+        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) -> np.ndarray:
+    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():
@@ -230,7 +242,7 @@ class Mesh3D:
     
     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()
+        nodes: set = set()
         for tags in taglist:
             nodes.update(self.get_nodes(tags))
         return np.array([i for i, tet in enumerate(self.tets.T) if not set(tet).isdisjoint(nodes)])
@@ -258,7 +270,7 @@ class Mesh3D:
         return np.array(sorted(list(set(edges))))
     
     
-    def update(self, periodic_bcs: list[Periodic] = None):
+    def update(self, periodic_bcs: list[Periodic] | None = None):
         if periodic_bcs is None:
             periodic_bcs = []
             
@@ -406,8 +418,7 @@ class Mesh3D:
         self.edge_centers = (self.nodes[:,self.edges[0,:]] + self.nodes[:,self.edges[1,:]]) / 2
         self.edge_lengths = np.sqrt(np.sum((self.nodes[:,self.edges[0,:]] - self.nodes[:,self.edges[1,:]])**2, axis=0))
         self.areas = np.array([area(self.nodes[:,self.tris[0,i]], self.nodes[:,self.tris[1,i]], self.nodes[:,self.tris[2,i]]) for i in range(self.tris.shape[1])])
-
-
+        
         ## Tag bindings
         face_dimtags = gmsh.model.get_entities(2)
         for d,t in face_dimtags:
@@ -466,11 +477,11 @@ class Mesh3D:
         all_node_ids = np.unique(np.array(node_ids_1 + node_ids_2))
         dsmin = shortest_distance(self.nodes[:,all_node_ids])
 
-        node_ids_1 = sorted(list(set(node_ids_1)))
-        node_ids_2 = sorted(list(set(node_ids_2)))
+        node_ids_1_arry = np.sort(np.unique(np.array(node_ids_1)))
+        node_ids_2_arry = np.sort(np.unique(np.array(node_ids_2)))
         dv = np.array(bc.dv)
         
-        nodemap = pair_coordinates(self.nodes, node_ids_1, node_ids_2, dv, dsmin/2)
+        nodemap = pair_coordinates(self.nodes, node_ids_1_arry, node_ids_2_arry, dv, dsmin/2)
         node_ids_2_unsorted = [nodemap[i] for i in sorted(node_ids_1)]
         node_ids_2_sorted = sorted(node_ids_2_unsorted)
         conv_map = {i1: i2 for i1, i2 in zip(node_ids_2_unsorted, node_ids_2_sorted)}
@@ -499,7 +510,7 @@ class Mesh3D:
     def plot_gmsh(self) -> None:
         gmsh.fltk.run()
 
-    def find_edge_groups(self, edge_ids: np.ndarray) -> dict:
+    def find_edge_groups(self, edge_ids: np.ndarray) -> list[tuple[Any,...]]:
         """
         Find the groups of edges in the mesh.
 
@@ -568,7 +579,7 @@ class Mesh3D:
 
     def boundary_surface(self, 
                          face_tags: Union[int, list[int]], 
-                         origin: tuple[float, float, float] = None) -> SurfaceMesh:
+                         origin: tuple[float, float, float] | None = None) -> SurfaceMesh:
         """Returns a SurfaceMesh class that is a 2D mesh isolated from the 3D mesh
 
         The mesh will be based on the given set of face tags.
@@ -593,7 +604,7 @@ class Mesh3D:
 
         return SurfaceMesh(self, tri_ids, origin)
     
-class SurfaceMesh:
+class SurfaceMesh(Mesh):
 
     def __init__(self,
                  original: Mesh3D,
@@ -614,21 +625,22 @@ class SurfaceMesh:
 
         self.original_tris: np.ndarray = original.tris
 
-        self.old_new_node_map: dict[int,int] = old_to_new_node_id_map
+        self.old_new_node_map: dict = old_to_new_node_id_map
         self.original: Mesh3D = original
         self._alignment_origin: np.ndarray = np.array(origin).astype(np.float64)
         self.nodes: np.ndarray = original.nodes[:, unique_nodes]
         self.tris: np.ndarray = new_tris
 
         ## initialize derived
-        self.edge_centers: np.ndarray = None
-        self.edge_tris: np.ndarray = None
+        self.edge_centers: np.ndarray = np.array([])
+        self.edge_tris: np.ndarray = np.array([])
         self.n_nodes = self.nodes.shape[1]
         self.n_tris = self.tris.shape[1]
-        self.n_edges = None
-        self.areas: np.ndarray = None
-        self.normals: np.ndarray = None
-
+        self.n_edges: float = -1
+        self.areas: np.ndarray = np.array([])
+        self.normals: np.ndarray = np.array([])
+        self.tri_to_edge: np.ndarray = np.array([])
+        self.edge_to_tri: dict | defaultdict = dict()
         # Generate derived
         self.update()
 
@@ -642,22 +654,26 @@ class SurfaceMesh:
             self.flipY()
         if ax.lower()=='z':
             self.flipZ()
+        return self
         #self.tris[(0,1),:] = self.tris[(1,0),:]
 
     def flipX(self) -> SurfaceMesh:
         self.nodes[0,:] = -self.nodes[0,:]
         self.normals[0,:] = -self.normals[0,:]
         self.edge_centers[0,:] = -self.edge_centers[0,:]
-    
+        return self
+
     def flipY(self) -> SurfaceMesh:
         self.nodes[1,:] = -self.nodes[1,:]
         self.normals[1,:] = -self.normals[1,:]
         self.edge_centers[1,:] = -self.edge_centers[1,:]
+        return self
     
     def flipZ(self) -> SurfaceMesh:
         self.nodes[2,:] = -self.nodes[2,:]
         self.normals[2,:] = -self.normals[2,:]
         self.edge_centers[2,:] = -self.edge_centers[2,:]
+        return self
 
     def from_source_tri(self, triid: int) -> int | None:
         ''' Returns a triangle index from the old mesh to the new mesh.'''
@@ -685,6 +701,8 @@ class SurfaceMesh:
             raise ValueError("Edge cannot be formed by the same node.")
         search = (min(int(i1),int(i2)), max(int(i1),int(i2)))
         result =  self.inv_edges.get(search, None)
+        if result is None:
+            raise ValueError(f'There is no edge with indices {i1}, {i2}')
         return result
     
     def get_edge_sign(self, i1: int, i2: int) -> int:
@@ -697,7 +715,11 @@ class SurfaceMesh:
         
     def get_tri(self, i1, i2, i3) -> int:
         '''Return the triangle index given the three node indices'''
-        return self.inv_tris.get(tuple(sorted((int(i1), int(i2), int(i3)))), None)
+        result = self.inv_tris.get(tuple(sorted((int(i1), int(i2), int(i3)))), None)
+        if result is None:
+            raise ValueError(f'There is no triangle with indices {i1}, {i2}, {i3}')
+        return result
+
     
     def update(self) -> None:
         ## First Edges