emerge 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.1"
+__version__ = "0.6.3"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #

emerge/_emerge/cs.py

@@ -101,7 +101,7 @@ class Axis:
         """
         return self.pair(other)
     
-    def construct_cs(self) -> CoordinateSystem:
+    def construct_cs(self, origin: tuple[float, float, float] = (0.,0.,0.)) -> CoordinateSystem:
         """Constructs a coordinate system where this vector is the Z-axis
         and the X and Y axis are normal to this axis but with an arbitrary rotation.
 
@@ -114,7 +114,7 @@ class Axis:
             ax = Axis(np.array([0, 1, 0]))
         ax1 = self.cross(ax)
         ax2 = self.cross(ax1).neg
-        return CoordinateSystem(ax2, ax1, self, np.zeros(3))
+        return CoordinateSystem(ax2, ax1, self, np.array(origin))
 
 XAX: Axis = Axis(np.array([1, 0, 0]))
 YAX: Axis = Axis(np.array([0, 1, 0]))
@@ -318,7 +318,8 @@ class CoordinateSystem:
     
     def rotate(self, axis: tuple | list | np.ndarray | Axis, 
                angle: float, 
-               degrees: bool = True) -> CoordinateSystem:
+               degrees: bool = True,
+               origin: bool | np.ndarray = False) -> CoordinateSystem:
         """Return a new CoordinateSystem rotated about the given axis (through the global origin)
         by `angle`. If `degrees` is True, `angle` is interpreted in degrees.
 
@@ -326,6 +327,7 @@ class CoordinateSystem:
             axis (tuple | list | np.ndarray | Axis): The rotation axis
             angle (float): The rotation angle (in degrees if degrees = True)
             degrees (bool, optional): Whether to use degrees. Defaults to True.
+            origin (bool, np.array, optional): Whether to rotate the origin as well. Defaults to False.
 
         Returns:
             CoordinateSystem: The new rotated coordinate system
@@ -354,14 +356,21 @@ class CoordinateSystem:
         new_x = R @ self.xax.vector
         new_y = R @ self.yax.vector
         new_z = R @ self.zax.vector
-        #new_o = R @ self.origin
+        
+        if origin is not False:
+            if isinstance(origin, bool):
+                new_o = R @ self.origin
+            else:
+                new_o = (R @ (self.origin-np.array(origin))) + np.array(origin)
+        else:
+            new_o = self.origin.copy()
 
         return CoordinateSystem(
             xax=new_x,
             yax=new_y,
             zax=new_z,
-            origin=self.origin,
-            _is_global=self._is_global
+            origin=new_o,
+            _is_global=False
         )
     
     def swapxy(self) -> None:

emerge/_emerge/geo/__init__.py

@@ -18,7 +18,7 @@
 from .pcb import PCB
 from .pmlbox import pmlbox
 from .horn import Horn
-from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment
+from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment, Cone
 from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect
-from .polybased import XYPolygon, GeoPrism
+from .polybased import XYPolygon, GeoPrism, Disc, Curve
 from .step import STEPItems

emerge/_emerge/geo/pipes.py

@@ -0,0 +1,62 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+import gmsh
+import numpy as np
+from typing import Literal, Callable
+from ..geometry import GeoEdge, GeoSurface, GeoVolume
+
+
+
+class Curve(GeoEdge):
+    
+    
+    def __init__(self, xpts: np.ndarray, ypts: np.ndarray, zpts: np.ndarray, 
+                 degree: int = 3,
+                 weights: list[float] | None = None,
+                 knots: list[float] | None = None,
+                 ctype: Literal['Spline','BSpline','Bezier'] = 'Bezier'):
+        self.xpts: np.ndarray = xpts
+        self.ypts: np.ndarray = ypts
+        self.zpts: np.ndarray = zpts
+        
+        points = [gmsh.model.occ.add_point(x,y,z) for x,y,z in zip(xpts, ypts, zpts)]
+        
+        if ctype.lower()=='spline':
+            tags = gmsh.model.occ.addSpline(points)
+            
+        elif ctype.lower()=='bspline':
+            if weights is None:
+                weights = []
+            if knots is None:
+                knots = []
+            tags = gmsh.model.occ.addBSpline(points, degree=degree, weights=weights, knots=knots)
+        else:
+            tags = gmsh.model.occ.addBezier(points)
+        
+        tags = gmsh.model.occ.addWire([tags,])
+        gmsh.model.occ.remove([(0,tag) for tag in points])
+        super().__init__(tags)
+    
+
+
+
+class Helix(GeoVolume):
+    
+    
+        

emerge/_emerge/geo/polybased.py

@@ -16,8 +16,8 @@
 # <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 import numpy as np
-from ..cs import CoordinateSystem, GCS
-from ..geometry import GeoVolume, GeoPolygon
+from ..cs import CoordinateSystem, GCS, Axis
+from ..geometry import GeoVolume, GeoPolygon, GeoEdge, GeoSurface
 from .shapes import Alignment
 import gmsh
 from typing import Generator, Callable
@@ -158,6 +158,26 @@ def rotate_point(point: tuple[float, float, float],
     rotated += o
     return tuple(rotated)
 
+
+def orthonormalize(axis: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Generates a set of orthonormal vectors given an input vector X
+
+    Args:
+        axis (np.ndarray): The X-axis
+
+    Returns:
+        tuple[np.ndarray, np.ndarray, np.ndarray]: The X, Y and Z axis (orthonormal)
+    """
+    Xaxis = axis/np.linalg.norm(axis)
+    V = np.array([0,1,0])
+    if 1-np.abs(np.dot(Xaxis, V)) < 1e-12:
+        V = np.array([0,0,1])
+    Yaxis = np.cross(Xaxis, V)
+    Yaxis = np.abs(Yaxis/np.linalg.norm(Yaxis))
+    Zaxis = np.cross(Xaxis, Yaxis)
+    Zaxis = np.abs(Zaxis/np.linalg.norm(Zaxis))
+    return Xaxis, Yaxis, Zaxis
+
 class GeoPrism(GeoVolume):
     """The GepPrism class generalizes the GeoVolume for extruded convex polygons.
     Besides having a volumetric definitions, the class offers a .front_face 
@@ -231,6 +251,10 @@ class XYPolygon:
 
         self.fillets: list[tuple[float, int]] = []
 
+    @property
+    def length(self):
+        return sum([((self.x[i2]-self.x[i1])**2 + (self.y[i2]-self.y[i1])**2)**0.5 for i1, i2 in zip(range(self.N-1),range(1, self.N))])
+        
     @property
     def N(self) -> int:
         """The number of polygon points
@@ -238,7 +262,7 @@ class XYPolygon:
         Returns:
             int: The number of points
         """
-        return len(self.xs)
+        return len(self.x)
     
     def _check(self) -> None:
         """Checks if the last point is the same as the first point.
@@ -329,7 +353,7 @@ class XYPolygon:
         poly.lines = lines
         return poly
     
-    def extrude(self, length: float, cs: CoordinateSystem = None) -> GeoPrism:
+    def extrude(self, length: float, cs: CoordinateSystem | None = None) -> GeoPrism:
         """Extrues the polygon along the Z-axis.
         The z-coordinates go from z1 to z2 (in meters). Then the extrusion
         is either provided by a maximum dz distance (in meters) or a number
@@ -351,7 +375,7 @@ class XYPolygon:
         surftags = [t for d,t in volume if d==2]
         return GeoPrism(tags, surftags[0], surftags)
     
-    def geo(self, cs: CoordinateSystem = None) -> GeoPolygon:
+    def geo(self, cs: CoordinateSystem | None = None) -> GeoPolygon:
         """Returns a GeoPolygon object for the current polygon.
 
         Args:
@@ -388,9 +412,9 @@ class XYPolygon:
 
     @staticmethod
     def circle(radius: float, 
-               dsmax: float = None,
-               tolerance: float = None,
-               Nsections: int = None):
+               dsmax: float | None= None,
+               tolerance: float | None = None,
+               Nsections: int | None = None):
         """This method generates a segmented circle.
 
         The number of points along the circumpherence can be specified in 3 ways. By a maximum
@@ -476,54 +500,269 @@ class XYPolygon:
         self.extend(xs, ys)
         return self
     
-    # def discrete_revolve(self, cs: CoordinateSystem, origin: tuple[float, float, float], axis: tuple[float, float,float], angle: float = 360.0, nsteps: int = 12) -> GeoPrism:
-    #     """Applies a revolution to the XYPolygon along the coordinate system Z-axis
-
-    #     Args:
-    #         cs (CoordinateSystem, optional): _description_. Defaults to None.
-    #         angle (float, optional): _description_. Defaults to 360.0.
-
-    #     Returns:
-    #         Prism: The resultant 
-    #     """
-    #     if cs is None:
-    #         cs = GCS
-        
-    #     x,y,z = origin
-    #     ax, ay, az = axis
-    #     loops = []
-    #     loops_edges = []
-
-    #     closed = False
-    #     if angle == 360:
-    #         angs = np.linspace(0, 2*np.pi, nsteps+1)[:-1]
-    #         closed = True
-    #     else:
-    #         angs = np.linspace(0, angle*np.pi/180, nsteps)
-
-    #     for x0, y0 in zip(self.x, self.y):
-    #         #print([rotate_point((x0, y0, 0), axis, ang, origin, degrees=False) for ang in angs])
-    #         points = [gmsh.model.occ.add_point(*rotate_point((x0, y0, 0), axis, ang, origin, degrees=False)) for ang in angs]
-    #         points = points + [points[0],]
-    #         loops.append(points)
-
-    #         edges = [gmsh.model.occ.add_line(p1, p2) for p1, p2 in zip(points[:-1],points[1:])]
-    #         loops_edges.append(edges)
-        
-    #     face1loop = gmsh.model.occ.add_curve_loop(loops_edges[0])
-    #     face_front = gmsh.model.occ.add_plane_surface([face1loop,])
-
-    #     face2loop = gmsh.model.occ.add_curve_loop(loops_edges[-1])
-    #     face_back = gmsh.model.occ.add_plane_surface([face2loop,])
-        
-    #     faces = []
-    #     for loop1, loop2 in zip(loops_edges[:-1], loops_edges[1:]):
-    #         for p1, p2, p3, p4 in zip(loop1[:-1], loop1[1:], loop2[1:], loop2[:0]):
-    #             curve = gmsh.model.occ.add_curve_loop([p1, p2, p3, p4])
-    #             face = gmsh.model.occ.add_plane_surface(curve)
-    #             faces.append(face)
-
-    #     surface_loop = gmsh.model.occ.add_surface_loop(faces + [face_front, face_back])
-    #     vol = gmsh.model.occ.add_volume([surface_loop,])
-
-    #     return GeoVolume(vol)
+
+class Disc(GeoSurface):
+    
+    def __init__(self, origin: tuple[float, float, float],
+                 radius: float,
+                 axis: tuple[float, float, float] = (0,0,1.0)):
+        """Creates a circular Disc surface.
+
+        Args:
+            origin (tuple[float, float, float]): The center of the disc
+            radius (float): The radius of the disc
+            axis (tuple[float, float, float], optional): The disc normal axis. Defaults to (0,0,1.0).
+        """
+        disc = gmsh.model.occ.addDisk(*origin, radius, radius, zAxis=axis)
+        super().__init__(disc)
+    
+    
+class Curve(GeoEdge):
+    def __init__(self, 
+                 xpts: np.ndarray, 
+                 ypts: np.ndarray, 
+                 zpts: np.ndarray, 
+                 degree: int = 3,
+                 weights: list[float] | None = None,
+                 knots: list[float] | None = None,
+                 ctype: Literal['Spline','BSpline','Bezier'] = 'Bezier',
+                 dstart: tuple[float, float, float] | None = None):
+        """Generate a Spline/Bspline or Bezier curve based on a series of points
+
+        This calls the different curve features in OpenCASCADE.
+        
+        The dstart parameter defines the departure direction of the curve. If not provided this is inferred as the
+        discrete derivative from the first to second coordinate. 
+        
+        Args:
+            xpts (np.ndarray): The X-coordinates
+            ypts (np.ndarray): The Y-coordinates
+            zpts (np.ndarray): The Z-coordinates
+            degree (int, optional): The BSpline degree parameter. Defaults to 3.
+            weights (list[float] | None, optional): An optional point weights list. Defaults to None.
+            knots (list[float] | None, optional): A nkots list. Defaults to None.
+            ctype (Literal['Spline','BSpline','Bezier'], optional): The type of curve. Defaults to 'Spline'.
+            dstart (tuple[float, float, float] | None, optional): The departure direction. Defaults to None.
+        """
+        self.xpts: np.ndarray = xpts
+        self.ypts: np.ndarray = ypts
+        self.zpts: np.ndarray = zpts
+        
+        if dstart is None:
+            dstart = (xpts[1]-xpts[0], ypts[1]-ypts[0], zpts[1]-zpts[0])
+        
+        self.dstart: tuple[float, float, float] = dstart
+
+        points = [gmsh.model.occ.add_point(x,y,z) for x,y,z in zip(xpts, ypts, zpts)]
+        
+        if ctype.lower()=='spline':
+            tags = gmsh.model.occ.addSpline(points)
+            
+        elif ctype.lower()=='bspline':
+            if weights is None:
+                weights = []
+            if knots is None:
+                knots = []
+            tags = gmsh.model.occ.addBSpline(points, degree=degree, weights=weights, knots=knots)
+        else:
+            tags = gmsh.model.occ.addBezier(points)
+        
+        tags = gmsh.model.occ.addWire([tags,])
+        gmsh.model.occ.remove([(0,tag) for tag in points])
+        super().__init__(tags)
+    
+    @property
+    def p0(self) -> tuple[float, float, float]:
+        """The start coordinate
+        """
+        return (self.xpts[0], self.ypts[0], self.zpts[0])
+
+    @staticmethod
+    def helix_rh(pstart: tuple[float, float, float],
+              pend: tuple[float, float, float],
+              r_start: float,
+              pitch: float,
+              r_end: float | None = None,
+              _narc: int = 8,
+              startfeed: float = 0.0) -> Curve:
+        """Generates a Helical curve
+
+        Args:
+            pstart (tuple[float, float, float]): The start of the center of rotation (not the start of the curve)
+            pend (tuple[float, float, float]): The end of the center of rotation
+            r_start (float): The (start) radius of the helix
+            pitch (float): The pitch angle of the helix
+            r_end (float | None, optional): The ending radius. If default, the same is used as the start. Defaults to None.
+            _narc (int, optional): The number of Spline arc sections used. Defaults to 8.
+
+        Returns:
+            Curve: The Curve geometry object
+        """
+        if r_end is None:
+            r_end = r_start
+        
+        pitch = pitch*np.pi/180
+        
+        R1, R2, DR = r_start, r_end, r_end-r_start
+        p0 = np.array(pstart)
+        p1 = np.array(pend)
+        dp = (p1-p0)
+        L = (dp[0]**2 + dp[1]**2 + dp[2]**2)**(0.5)
+        dp = dp/L
+        
+        Z, X, Y = orthonormalize(dp)
+        
+        Q = L/np.tan(pitch)
+        #a1 = Q/R1
+        #a2 = Q*((1 - 1/R1 *(R2 + DR))/(2*R2 + DR))
+        C = 0#Q/R1
+
+        wtot = C/R2 + Q/R2
+        nt = int(np.ceil(wtot/(2*np.pi)*_narc))
+        
+        t = np.linspace(0, 1, nt)
+        Rt = R1 + DR*t
+        #wt = (a1*t + a2*t**2)
+        wt = C/Rt + (Q*t)/Rt
+        
+        xs = (R1 + DR*t)*np.cos(wt)
+        ys = (R1 + DR*t)*np.sin(wt)
+        zs = L*t
+
+        xp = xs*X[0] + ys*Y[0] + zs*Z[0] + p0[0]
+        yp = xs*X[1] + ys*Y[1] + zs*Z[1] + p0[1]
+        zp = xs*X[2] + ys*Y[2] + zs*Z[2] + p0[2]
+        
+        dp = tuple(Y)
+        if startfeed > 0:
+            dpx, dpy, dpz = Y
+            dx = Z[0]
+            dy = Z[1]
+            dz = Z[2]
+            d = startfeed
+
+            fx = np.array([xp[0] - dx*d/2 - d*dpx, xp[0] - dx*d*0.8/2 - d*dpx])
+            fy = np.array([yp[0] - dy*d/2 - d*dpy, yp[0] - dy*d*0.8/2 - d*dpy])
+            fz = np.array([zp[0] - dz*d/2 - d*dpz, zp[0] - dz*d*0.8/2 - d*dpz])
+            
+            xp = np.concat([fx ,xp])
+            yp = np.concat([fy, yp])
+            zp = np.concat([fz, zp])
+            xp[2] += d/2*dx
+            yp[2] += d/2*dy
+            zp[2] += d/2*dz
+            dp = tuple(Z)
+        
+        return Curve(xp, yp, zp, ctype='Spline', dstart=dp)
+    
+    @staticmethod
+    def helix_lh(pstart: tuple[float, float, float],
+              pend: tuple[float, float, float],
+              r_start: float,
+              pitch: float,
+              r_end: float | None = None,
+              _narc: int = 8,
+              startfeed: float = 0.0) -> Curve:
+        """Generates a Helical curve
+
+        Args:
+            pstart (tuple[float, float, float]): The start of the center of rotation (not the start of the curve)
+            pend (tuple[float, float, float]): The end of the center of rotation
+            r_start (float): The (start) radius of the helix
+            pitch (float): The pitch angle of the helix
+            r_end (float | None, optional): The ending radius. If default, the same is used as the start. Defaults to None.
+            _narc (int, optional): The number of Spline arc sections used. Defaults to 8.
+
+        Returns:
+            Curve: The Curve geometry object
+        """
+        if r_end is None:
+            r_end = r_start
+        
+        pitch = pitch*np.pi/180
+        
+        R1, R2, DR = r_start, r_end, r_end-r_start
+        p0 = np.array(pstart)
+        p1 = np.array(pend)
+        dp = (p1-p0)
+        L = (dp[0]**2 + dp[1]**2 + dp[2]**2)**(0.5)
+        dp = dp/L
+        
+        Z, X, Y = orthonormalize(dp)
+        
+        Q = L/np.tan(pitch)
+        #a1 = Q/R1
+        #a2 = Q*((1 - 1/R1 *(R2 + DR))/(2*R2 + DR))
+        C = 0#Q/R1
+
+        wtot = C/R2 + Q/R2
+        nt = int(np.ceil(wtot/(2*np.pi)*_narc))
+        
+        t = np.linspace(0, 1, nt)
+        Rt = R1 + DR*t
+        #wt = (a1*t + a2*t**2)
+        wt = C/Rt + (Q*t)/Rt
+        
+        xs = (R1 + DR*t)*np.cos(-wt)
+        ys = (R1 + DR*t)*np.sin(-wt)
+        zs = L*t
+
+        xp = xs*X[0] + ys*Y[0] + zs*Z[0] + p0[0]
+        yp = xs*X[1] + ys*Y[1] + zs*Z[1] + p0[1]
+        zp = xs*X[2] + ys*Y[2] + zs*Z[2] + p0[2]
+        
+        dp = tuple(Y)
+        if startfeed > 0:
+            dpx, dpy, dpz = Y
+            dx = Z[0]
+            dy = Z[1]
+            dz = Z[2]
+            d = startfeed
+
+            fx = np.array([xp[0] - dx*d/2 + d*dpx, xp[0] - dx*d*0.8/2 + d*dpx])
+            fy = np.array([yp[0] - dy*d/2 + d*dpy, yp[0] - dy*d*0.8/2 + d*dpy])
+            fz = np.array([zp[0] - dz*d/2 + d*dpz, zp[0] - dz*d*0.8/2 + d*dpz])
+            
+            xp = np.concat([fx ,xp])
+            yp = np.concat([fy, yp])
+            zp = np.concat([fz, zp])
+            xp[2] += d/2*dx
+            yp[2] += d/2*dy
+            zp[2] += d/2*dz
+            dp = tuple(Z)
+        
+        return Curve(xp, yp, zp, ctype='Spline', dstart=dp)
+        
+    def pipe(self, crossection: GeoSurface | XYPolygon, max_mesh_size: float | None = None) -> GeoVolume:
+        """Extrudes a surface or XYPolygon object along the given curve
+
+        If a GeoSurface object is used, make sure it starts at the center of the curve. This property
+        can be accessed with curve_obj.p0.Alignment
+        If an XYPolygon is used, it will be automatically centered with XY=0 at the start of the curve with
+        the Z-axis align along the initial departure direction curve_obj.dstart.Alignment
+        
+        Args:
+            crossection (GeoSurface | XYPolygon): The cross section definition to be used
+            max_mesh_size (float, optional): The maximum mesh size. Defaults to None
+        Returns:
+            GeoVolume: The resultant volume object
+        """
+        if isinstance(crossection, XYPolygon):
+            zax = self.dstart
+            cs = Axis(np.array(zax)).construct_cs(self.p0)
+            surf = crossection.geo(cs)
+        else:
+            surf = crossection
+        x1, y1, z1, x2, y2, z2 = gmsh.model.occ.getBoundingBox(*surf.dimtags[0])
+        diag = ((x2-x1)**2 + (y2-y1)**2 + (z2-z1)**2)**(0.5)
+        
+        pipetag = gmsh.model.occ.addPipe(surf.dimtags, self.tags[0], 'GuidePlan')
+        
+        self.remove()
+        surf.remove()
+        
+        volume = GeoVolume(pipetag[0][1])
+        
+        volume.max_meshsize = diag/2
+        return volume
+        

emerge/_emerge/geo/shapes.py

@@ -448,3 +448,28 @@ class OldBox(GeoVolume):
         
         tags = list(reduce(lambda a,b: a+b, tagslist))
         return FaceSelection(tags)
+
+class Cone(GeoVolume):
+    
+    def __init__(self, p0: tuple[float, float, float],
+                 direction: tuple[float, float, float],
+                 r1: float,
+                 r2: float):
+        """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.
+
+        Args:
+            p0 (tuple[float, float, float]): _description_
+            direction (tuple[float, float, float]): _description_
+            r1 (float): _description_
+            r2 (float): _description_
+        """
+        tag = gmsh.model.occ.add_cone(*p0, *direction, r1, r2)
+        super().__init__(tag)
+        
+        p0 = np.array(p0)
+        ds = np.array(direction)
+        
+        self._add_face_pointer('front', p0, ds)
+        if r2>0:
+            self._add_face_pointer('back', p0+ds, ds)

emerge/_emerge/geometry.py

@@ -472,6 +472,10 @@ class GeoObject:
             return GeoVolume(tags)
         return GeoObject(tags)
     
+    def remove(self) -> None:
+        self._exists = False
+        gmsh.model.occ.remove(self.dimtags, True)
+        
 class GeoVolume(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not represent EMerge
     specific geometry data.'''

emerge/_emerge/mesh3d.py

@@ -170,13 +170,13 @@ class Mesh3D(Mesh):
         '''Return the number of nodes'''
         return self.nodes.shape[1]
 
-    def get_edge(self, i1: int, i2: int) -> int:
+    def get_edge(self, i1: int, i2: int, skip: bool = False) -> int:
         '''Return the edge index given the two node indices'''
         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, -10)
-        if result == -10:
+        if result == -10 and not skip:
             raise ValueError(f'There is no edge with indices {i1}, {i2}')
         return result
     
@@ -454,7 +454,8 @@ class Mesh3D(Mesh):
         edge_tags = np.array(edge_tags).flatten()
         ent = np.array(edge_node_tags).reshape(-1,2).T
         nET = ent.shape[1]
-        self.edge_t2i = {int(edge_tags[i]): self.get_edge(self.n_t2i[ent[0,i]], self.n_t2i[ent[1,i]]) for i in range(nET)}
+        self.edge_t2i = {int(edge_tags[i]): self.get_edge(self.n_t2i[ent[0,i]], self.n_t2i[ent[1,i]], skip=True) for i in range(nET)}
+        self.edge_t2i = {key: value for key,value in self.edge_t2i.items() if value!=-10}
         self.edge_i2t = {i: t for t, i in self.edge_t2i.items()}
         
         edge_dimtags = gmsh.model.get_entities(1)
@@ -463,7 +464,7 @@ class Mesh3D(Mesh):
             if not edge_tags:
                 self.etag_to_edge[t] = []
                 continue
-            self.etag_to_edge[t] = [int(self.edge_t2i[tag]) for tag in edge_tags[0]]
+            self.etag_to_edge[t] = [int(self.edge_t2i.get(tag,None)) for tag in edge_tags[0] if tag in self.edge_t2i]
         
         
         ## Tag bindings

emerge/_emerge/mth/optimized.py

@@ -358,37 +358,6 @@ def local_mapping(vertex_ids, triangle_ids):
 
     return out
 
-@njit(f8[:,:](f8[:], f8[:], f8[:]), cache=True, nogil=True)
-def orthonormal_basis(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):
-    """
-    Returns an orthonormal basis for the tetrahedron defined by the points
-    xs, ys, zs. The basis is given as a 3x3 matrix with the first column being
-    the normal vector of the face opposite to the first vertex.
-    """
-    x1, x2, x3 = xs
-    y1, y2, y3 = ys
-    z1, z2, z3 = zs
-    e1x, e1y, e1z = x2-x1, y2-y1, z2-z1
-    e2x, e2y, e2z = x3-x1, y3-y1, z3-z1
-
-    nn = np.array([e2y*e1z - e2z*e1y,
-                   e2z*e1x - e2x*e1z,
-                   e2y*e1x - e2x*e1y])
-    
-    nn = nn/np.sqrt(nn[0]**2 + nn[1]**2 + nn[2]**2)
-    n2 = np.array([e1x, e1y, e1z])/np.sqrt(e1x**2 + e1y**2 + e1z**2)
-    n1 = np.array([n2[1]*nn[2] - n2[2]*nn[1],
-                   n2[2]*nn[0] - n2[0]*nn[2],
-                   n2[0]*nn[1] - n2[1]*nn[0]])
-    
-    if dot(n1, cross(n2, nn)) < 0:
-        n1 = -n1
-    
-    B = np.zeros((3,3), dtype=np.float64)
-    B[:,0] = n1
-    B[:,1] = n2
-    B[:,2] = nn
-    return B
 
 @njit(f8[:,:](f8[:], f8[:], f8[:]), cache=True, nogil=True, fastmath=True)
 def compute_distances(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray: