emerge 0.5.5__py3-none-any.whl → 0.5.6__py3-none-any.whl

emerge/__init__.py

@@ -18,6 +18,7 @@ along with this program; if not, see
 """
 import os
 
+__version__ = "0.5.6"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -57,5 +58,7 @@ from ._emerge.periodic import RectCell, HexCell
 from ._emerge.mesher import Algorithm2D, Algorithm3D
 from . import lib
 from ._emerge.howto import _HowtoClass
+
 howto = _HowtoClass()
+
 logger.debug('Importing complete!')

emerge/_emerge/cs.py

@@ -128,7 +128,7 @@ def _parse_vector(vec: np.ndarray | tuple[float, float, float] | list[float] | A
         return np.array(vec)
     elif isinstance(vec, Axis):
         return vec.vector
-    return None
+    return np.array(vec)
 
 def _parse_axis(vec: np.ndarray | tuple[float, float, float] | list[float] | Axis) -> Axis:
     """Takes an array, tuple, list or Axis and always returns an Axis.
@@ -145,7 +145,7 @@ def _parse_axis(vec: np.ndarray | tuple[float, float, float] | list[float] | Axi
         return Axis(np.array(vec))
     elif isinstance(vec, Axis):
         return vec
-    return None
+    return Axis(np.array(vec))
 
 @dataclass
 class Plane:

emerge/_emerge/elements/ned2_interp.py

@@ -525,7 +525,7 @@ def ned2_tri_interp_full(coords: np.ndarray,
         if inside.sum() == 0:
             continue
         
-        ######### INSIDE THE TETRAHEDRON #########
+        ######### INSIDE THE TRIANGLE #########
         
         x = xs[inside==1]
         y = ys[inside==1]
@@ -533,26 +533,23 @@ def ned2_tri_interp_full(coords: np.ndarray,
         xvs = nodes[0, tris[:,itri]]
         yvs = nodes[1, tris[:,itri]]
 
-        Ds = compute_distances(xvs, yvs, 0*xvs)
-
-        L1 = Ds[0,1]
-        L2 = Ds[1,2]
-        L3 = Ds[0,2]
-
-        mult = np.array([L1,L2,L3,L3,L1,L2,L3,L1,1,1,1,1,1,1])
-
         a_s, b_s, c_s, A = tri_coefficients(xvs, yvs)
         
-        e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 = Etri*mult
+        e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 = Etri
 
         a1, a2, a3 = a_s
         b1, b2, b3 = b_s
         c1, c2, c3 = c_s
 
-        ex =  (e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y))/(8*A**3)
-        ey =  (e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y))/(8*A**3)
-        ez =  (a1 + b1*x + c1*y)*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y))/(2*A**2)
+        # original Nedelec-1 order 2 formulation 
+        # ex =  (e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y))/(8*A**3)
+        # ey =  (e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y))/(8*A**3)
+        # ez =  (a1 + b1*x + c1*y)*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y))/(2*A**2)
         
+        # New Nedelec-1 order 2 formulation
+        ex = (-2*A*(e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y)) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y)) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))) - e4*((b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + (b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a1 + b1*x + c1*y)) - e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) - e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) - e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) + e8*((b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + (b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y)))/(8*A**3)
+        ey = (-2*A*(e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y)) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y)) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))) - e4*((c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + (c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a1 + b1*x + c1*y)) - e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) - e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) - e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) + e8*((c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + (c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y)))/(8*A**3)
+        ez = (-e10*(a2 + b2*x + c2*y)*(A - a2 - b2*x - c2*y)/2 - e11*(a3 + b3*x + c3*y)*(A - a3 - b3*x - c3*y)/2 + e12*(a1 + b1*x + c1*y)*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y)*(a3 + b3*x + c3*y) + e14*(a1 + b1*x + c1*y)*(a3 + b3*x + c3*y) - e9*(a1 + b1*x + c1*y)*(A - a1 - b1*x - c1*y)/2)/A**2
         Ex[inside] = ex
         Ey[inside] = ey
         Ez[inside] = ez
@@ -621,23 +618,21 @@ def ned2_tri_interp_curl(coords: np.ndarray,
 
         a_s, b_s, c_s, A = tri_coefficients(xvs, yvs)
 
-        Ds = compute_distances(xvs, yvs, 0*xvs)
-
-        L1 = Ds[0,1]
-        L2 = Ds[1,2]
-        L3 = Ds[0,2]
-
-        mult = np.array([L1,L2,L3,L3,L1,L2,L3,L1,1,1,1,1,1,1])
-        
-        e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 = Etri*mult
+        e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 = Etri
 
         a1, a2, a3 = a_s
         b1, b2, b3 = b_s
         c1, c2, c3 = c_s
-
-        hx =  (4*A*(c1*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y)) + (a1 + b1*x + c1*y)*(c1*e10 + c1*e11 + c1*e9 + c2*e12 + c2*e13 + c2*e14)) + jB*(e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y)))/(8*A**3)
-        hy =  (4*A*(b1*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y)) + (a1 + b1*x + c1*y)*(b1*e10 + b1*e11 + b1*e9 + b2*e12 + b2*e13 + b2*e14)) - jB*(e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y)))/(8*A**3)
-        hz =  (-3*a1*b1*c2*e1 - 3*a1*b1*c3*e3 + 3*a1*b2*c1*e1 + a1*b2*c3*e4 + a1*b2*c3*e8 + 3*a1*b3*c1*e3 - a1*b3*c2*e4 - a1*b3*c2*e8 - 3*a2*b1*c2*e5 + 2*a2*b1*c3*e4 - a2*b1*c3*e8 + 3*a2*b2*c1*e5 - 3*a2*b2*c3*e2 - 2*a2*b3*c1*e4 + a2*b3*c1*e8 + 3*a2*b3*c2*e2 + a3*b1*c2*e4 - 2*a3*b1*c2*e8 - 3*a3*b1*c3*e7 - a3*b2*c1*e4 + 2*a3*b2*c1*e8 - 3*a3*b2*c3*e6 + 3*a3*b3*c1*e7 + 3*a3*b3*c2*e6 - 3*b1**2*c2*e1*x - 3*b1**2*c3*e3*x + 3*b1*b2*c1*e1*x - 3*b1*b2*c2*e5*x + 3*b1*b2*c3*e4*x + 3*b1*b3*c1*e3*x - 3*b1*b3*c2*e8*x - 3*b1*b3*c3*e7*x - 3*b1*c1*c2*e1*y - 3*b1*c1*c3*e3*y - 3*b1*c2**2*e5*y + 3*b1*c2*c3*e4*y - 3*b1*c2*c3*e8*y - 3*b1*c3**2*e7*y + 3*b2**2*c1*e5*x - 3*b2**2*c3*e2*x - 3*b2*b3*c1*e4*x + 3*b2*b3*c1*e8*x + 3*b2*b3*c2*e2*x - 3*b2*b3*c3*e6*x + 3*b2*c1**2*e1*y + 3*b2*c1*c2*e5*y + 3*b2*c1*c3*e8*y - 3*b2*c2*c3*e2*y - 3*b2*c3**2*e6*y + 3*b3**2*c1*e7*x + 3*b3**2*c2*e6*x + 3*b3*c1**2*e3*y - 3*b3*c1*c2*e4*y + 3*b3*c1*c3*e7*y + 3*b3*c2**2*e2*y + 3*b3*c2*c3*e6*y)/(8*A**3)
+        
+        # original Nedelec-1 order 2 formulation 
+        #hx =  (4*A*(c1*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y)) + (a1 + b1*x + c1*y)*(c1*e10 + c1*e11 + c1*e9 + c2*e12 + c2*e13 + c2*e14)) + jB*(e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y)))/(8*A**3)
+        # hy =  (4*A*(b1*(e10*(-A + a1 + b1*x + c1*y) + e11*(-A + a1 + b1*x + c1*y) + e12*(a2 + b2*x + c2*y) + e13*(a2 + b2*x + c2*y) + e14*(a2 + b2*x + c2*y) + e9*(-A + a1 + b1*x + c1*y)) + (a1 + b1*x + c1*y)*(b1*e10 + b1*e11 + b1*e9 + b2*e12 + b2*e13 + b2*e14)) - jB*(e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 + b2*x + c2*y) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 + b1*x + c1*y) - e4*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a3 + b3*x + c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + e8*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y)))/(8*A**3)
+        # hz =  (-3*a1*b1*c2*e1 - 3*a1*b1*c3*e3 + 3*a1*b2*c1*e1 + a1*b2*c3*e4 + a1*b2*c3*e8 + 3*a1*b3*c1*e3 - a1*b3*c2*e4 - a1*b3*c2*e8 - 3*a2*b1*c2*e5 + 2*a2*b1*c3*e4 - a2*b1*c3*e8 + 3*a2*b2*c1*e5 - 3*a2*b2*c3*e2 - 2*a2*b3*c1*e4 + a2*b3*c1*e8 + 3*a2*b3*c2*e2 + a3*b1*c2*e4 - 2*a3*b1*c2*e8 - 3*a3*b1*c3*e7 - a3*b2*c1*e4 + 2*a3*b2*c1*e8 - 3*a3*b2*c3*e6 + 3*a3*b3*c1*e7 + 3*a3*b3*c2*e6 - 3*b1**2*c2*e1*x - 3*b1**2*c3*e3*x + 3*b1*b2*c1*e1*x - 3*b1*b2*c2*e5*x + 3*b1*b2*c3*e4*x + 3*b1*b3*c1*e3*x - 3*b1*b3*c2*e8*x - 3*b1*b3*c3*e7*x - 3*b1*c1*c2*e1*y - 3*b1*c1*c3*e3*y - 3*b1*c2**2*e5*y + 3*b1*c2*c3*e4*y - 3*b1*c2*c3*e8*y - 3*b1*c3**2*e7*y + 3*b2**2*c1*e5*x - 3*b2**2*c3*e2*x - 3*b2*b3*c1*e4*x + 3*b2*b3*c1*e8*x + 3*b2*b3*c2*e2*x - 3*b2*b3*c3*e6*x + 3*b2*c1**2*e1*y + 3*b2*c1*c2*e5*y + 3*b2*c1*c3*e8*y - 3*b2*c2*c3*e2*y - 3*b2*c3**2*e6*y + 3*b3**2*c1*e7*x + 3*b3**2*c2*e6*x + 3*b3*c1**2*e3*y - 3*b3*c1*c2*e4*y + 3*b3*c1*c3*e7*y + 3*b3*c2**2*e2*y + 3*b3*c2*c3*e6*y)/(8*A**3)
+       
+        # New Nedelec-1 order 2 formulation
+        hx = (4*A*(2*c1*e12*(a2 + b2*x + c2*y) + 2*c1*e14*(a3 + b3*x + c3*y) + c1*e9*(a1 + b1*x + c1*y) - c1*e9*(A - a1 - b1*x - c1*y) + c2*e10*(a2 + b2*x + c2*y) - c2*e10*(A - a2 - b2*x - c2*y) + 2*c2*e12*(a1 + b1*x + c1*y) + 2*c2*e13*(a3 + b3*x + c3*y) + c3*e11*(a3 + b3*x + c3*y) - c3*e11*(A - a3 - b3*x - c3*y) + 2*c3*e13*(a2 + b2*x + c2*y) + 2*c3*e14*(a1 + b1*x + c1*y)) + jB*(2*A*(e1*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y)) + e2*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y)) + e3*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))) + e4*((c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + (c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a1 + b1*x + c1*y)) + e5*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) + e6*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y))*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) + e7*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) - e8*((c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + (c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y))))/(8*A**3)
+        hy = (4*A*(-2*b1*e12*(a2 + b2*x + c2*y) - 2*b1*e14*(a3 + b3*x + c3*y) - b1*e9*(a1 + b1*x + c1*y) + b1*e9*(A - a1 - b1*x - c1*y) - b2*e10*(a2 + b2*x + c2*y) + b2*e10*(A - a2 - b2*x - c2*y) - 2*b2*e12*(a1 + b1*x + c1*y) - 2*b2*e13*(a3 + b3*x + c3*y) - b3*e11*(a3 + b3*x + c3*y) + b3*e11*(A - a3 - b3*x - c3*y) - 2*b3*e13*(a2 + b2*x + c2*y) - 2*b3*e14*(a1 + b1*x + c1*y)) - jB*(2*A*(e1*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y)) + e2*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y)) + e3*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))) + e4*((b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y) + (b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a1 + b1*x + c1*y)) + e5*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) + e6*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y))*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) + e7*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) - e8*((b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y))*(a3 + b3*x + c3*y) + (b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y))*(a2 + b2*x + c2*y))))/(8*A**3)
+        hz = (4*A*(e1*(b1*c2 - b2*c1) + e2*(b2*c3 - b3*c2) + e3*(b1*c3 - b3*c1)) - e4*(b1*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y)) + b2*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y)) - (b1*c3 - b3*c1)*(a2 + b2*x + c2*y) - (b2*c3 - b3*c2)*(a1 + b1*x + c1*y)) + e4*(c1*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y)) + c2*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y)) + (b1*c3 - b3*c1)*(a2 + b2*x + c2*y) + (b2*c3 - b3*c2)*(a1 + b1*x + c1*y)) - e5*(b1 - b2)*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y)) + e5*(c1 - c2)*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y)) + 2*e5*(b1*c2 - b2*c1)*(a1 - a2 + b1*x - b2*x + c1*y - c2*y) - e6*(b2 - b3)*(c2*(a3 + b3*x + c3*y) - c3*(a2 + b2*x + c2*y)) + e6*(c2 - c3)*(b2*(a3 + b3*x + c3*y) - b3*(a2 + b2*x + c2*y)) + 2*e6*(b2*c3 - b3*c2)*(a2 - a3 + b2*x - b3*x + c2*y - c3*y) - e7*(b1 - b3)*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y)) + e7*(c1 - c3)*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y)) + 2*e7*(b1*c3 - b3*c1)*(a1 - a3 + b1*x - b3*x + c1*y - c3*y) + e8*(b2*(c1*(a3 + b3*x + c3*y) - c3*(a1 + b1*x + c1*y)) + b3*(c1*(a2 + b2*x + c2*y) - c2*(a1 + b1*x + c1*y)) - (b1*c2 - b2*c1)*(a3 + b3*x + c3*y) - (b1*c3 - b3*c1)*(a2 + b2*x + c2*y)) - e8*(c2*(b1*(a3 + b3*x + c3*y) - b3*(a1 + b1*x + c1*y)) + c3*(b1*(a2 + b2*x + c2*y) - b2*(a1 + b1*x + c1*y)) + (b1*c2 - b2*c1)*(a3 + b3*x + c3*y) + (b1*c3 - b3*c1)*(a2 + b2*x + c2*y)))/(8*A**3)     
         
         Ex[inside] = hx*dc[0,0]
         Ey[inside] = hy*dc[1,1]

emerge/_emerge/elements/nedleg2.py

@@ -103,6 +103,8 @@ class NedelecLegrange2(FEMBasis):
 
         self.cs: CoordinateSystem = cs
 
+        LGORDER = 2
+        
         ## 
         nodes = self.mesh.nodes
         self.local_nodes: np.ndarray = np.array(self.cs.in_local_cs(nodes[0,:], nodes[1,:], nodes[2,:]))
@@ -113,15 +115,23 @@ class NedelecLegrange2(FEMBasis):
         self.n_tris: int = self.mesh.n_tris
         self.n_tri_dofs: int = None
 
-        self.n_field: int = 2*self.n_edges + 2*self.n_tris + self.n_nodes + self.n_edges
+        if LGORDER == 2:
+            self.n_field: int = 2*self.n_edges + 2*self.n_tris + self.n_nodes + self.n_edges
+        else:
+            self.n_field: int = 2*self.n_edges + 2*self.n_tris + self.n_nodes + self.n_edges*2 + self.n_tris
+        
         self.n_xy: int = 2*self.n_edges + 2*self.n_tris
-
         ######## MESH Derived
         Nn = self.mesh.n_nodes
         Ne = self.mesh.n_edges
         Nt = self.mesh.n_tris
 
-        self.tri_to_field: np.ndarray = np.zeros((8 + 6, self.n_tris), dtype=int)
+        
+        
+        if LGORDER==3:
+            self.tri_to_field: np.ndarray = np.zeros((8 + 10, self.n_tris), dtype=int)
+        else:
+            self.tri_to_field: np.ndarray = np.zeros((8 + 6, self.n_tris), dtype=int)
 
         self.tri_to_field[:3,:] = self.mesh.tri_to_edge
         self.tri_to_field[3,:] = np.arange(Nt) + Ne
@@ -129,13 +139,21 @@ class NedelecLegrange2(FEMBasis):
         self.tri_to_field[7,:] = np.arange(Nt) + 2*Ne + Nt
         self.tri_to_field[8:11,:] = self.mesh.tris + (2*Ne + 2*Nt) # + E + T + E + T
         self.tri_to_field[11:14,:] = self.mesh.tri_to_edge + (2*Ne + 2*Nt + Nn)
-    
+        
+        if LGORDER==3:
+            # Legrange 3
+            self.tri_to_field[14:17,:] = self.mesh.tri_to_edge + (2*Ne + 2*Nt + Nn + Ne)
+            self.tri_to_field[17,:] = np.arange(Nt) + (2*Ne + 2*Nt + Nn + Ne + Ne)
+        
         self.edge_to_field: np.ndarray = np.zeros((5,Ne), dtype=int) #edge mode 1, edge mode 2, edge legrande mode, edge vertex mode 1, edge vertex mode 2
 
         self.edge_to_field[0,:] = np.arange(Ne)
         self.edge_to_field[1,:] = np.arange(Ne) + Nt + Ne
-        self.edge_to_field[2,:] = np.arange(Ne) + Ne*2 + Nt*2 + Nn
-        self.edge_to_field[3:,:] = self.mesh.edges + Ne*2 + Nt*2
+        self.edge_to_field[2:4,:] = self.mesh.edges + Ne*2 + Nt*2
+        self.edge_to_field[4,:] = np.arange(Ne) + Ne*2 + Nt*2 + Nn
+        
+        if LGORDER==3:
+            self.edge_to_field[5:,:] = np.arange(Ne)  + Ne*2 + Nt*2 + Nn + Ne
 
         ##
         self._field: np.ndarray = None   
@@ -148,12 +166,6 @@ class NedelecLegrange2(FEMBasis):
     
     def interpolate_Ef(self, field: np.ndarray) -> FieldFunctionClass:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
-        
-        # def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
-        #     xl, yl, zl = self.cs.in_local_cs(xs, ys, zs)
-        #     Exl, Eyl, Ezl = self.tri_interpolate(field, xl, yl)
-        #     Ex, Ey, Ez = self.cs.in_global_basis(Exl, Eyl, Ezl)
-        #     return np.array([Ex, Ey, Ez])
         return FieldFunctionClass(field, self.cs, self.local_nodes, self.mesh.tris, self.tri_to_field, 'E')
 
     def interpolate_Hf(self, field: np.ndarray, k0: float, ur: np.ndarray, beta: float) -> FieldFunctionClass:
@@ -164,11 +176,6 @@ class NedelecLegrange2(FEMBasis):
         for i in range(ur.shape[2]):
             urinv[:,:,i] = matinv(ur[:,:,i])
 
-        # def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
-        #     xl, yl, _ = self.cs.in_local_cs(xs, ys, zs)
-        #     Exl, Eyl, Ezl = self.tri_interpolate_curl(field, xl, yl, urinv, beta)
-        #     Ex, Ey, Ez = self.cs.in_global_basis(Exl, Eyl, Ezl)
-        #     return np.array([Ex, Ey, Ez])*constant
         return FieldFunctionClass(field, self.cs, self.local_nodes, self.mesh.tris, self.tri_to_field, 'H', urinv, beta, constant)
     
     def tri_interpolate(self, field, xs: np.ndarray, ys: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
@@ -189,29 +196,4 @@ class NedelecLegrange2(FEMBasis):
                                self.local_nodes, 
                                self.tri_to_field,
                                diadic,
-                               beta)
-    
-    
-    # def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    #     """
-    #     Interpolates the curl of the field at the given points.
-    #     """
-    #     return ned2_tet_interp_curl(np.array([xs, ys,zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, c)
-    
-    # def fieldf(self, field: np.ndarray, basis: np.ndarray = None, origin: np.ndarray = None) -> Callable:
-    #     if basis is None:
-    #         basis = np.eye(3)
-
-    #     if origin is None:
-    #         origin = np.zeros(3)
-        
-    #     ibasis = np.linalg.pinv(basis)
-    #     def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
-    #         xyz = np.array([xs, ys, zs]) + origin[:, np.newaxis]
-    #         xyzg = basis @ xyz
-    #         return ibasis @ np.array(self.interpolate(field, xyzg[0,:], xyzg[1,:], xyzg[2,:]))
-    #     return func
-    
-    ###### INDEX MAPPINGS
-
-    
+                               beta)

emerge/_emerge/geo/shapes.py

@@ -210,6 +210,10 @@ class Cyllinder(GeoVolume):
             super().__init__(cyl)
         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)
+        self._add_face_pointer('top', cs.origin+height*cs.zax.np, cs.zax.np)
+        self._add_face_pointer('left', cs.origin, -cs.zax.np)
+        self._add_face_pointer('right', cs.origin+height*cs.zax.np, cs.zax.np)
             
         self.cs: CoordinateSystem = cs
         self.radius = radius
@@ -273,6 +277,10 @@ class CoaxCyllinder(GeoVolume):
 
         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)
+        self._add_face_pointer('top', cs.origin+height*cs.zax.np, cs.zax.np)
+        self._add_face_pointer('left', cs.origin, -cs.zax.np)
+        self._add_face_pointer('right', cs.origin+height*cs.zax.np, cs.zax.np)
 
         self.cs = cs
 
@@ -297,13 +305,28 @@ class HalfSphere(GeoVolume):
                  radius: float,
                  position: tuple = (0,0,0),
                  direction: tuple = (1,0,0)):
-        super().__init__([])
+        
         sphere = Sphere(radius, position=position)
         cx, cy, cz = position
 
-        box = Box(1.1*radius, 2.2*radius, 2.2*radius, position=(cx-radius*1.1,cy-radius*1.1, cz-radius*1.1))
+        dx, dy, dz = direction
+        fx = 0.5**dx
+        fy = 0.5**dy
+        fz = 0.5**dz
+        box = Box(2.2*radius*fx, 2.2*radius*fy, 2.2*radius*fz, position=(cx-radius*1.1*dx*0.5,cy-radius*1.1*dy*0.5, cz-radius*1.1*dz*0.5), alignment=Alignment.CENTER)
+        
+        dimtags, _ = gmsh.model.occ.cut(sphere.dimtags, box.dimtags)
+        
+        sphere._exists = False
+        box._exists = False
 
-        self.tag = subtract(sphere, box)[0].tag
+        super().__init__([dt[1] for dt in dimtags])
+        
+        self._add_face_pointer('front',np.array(position), np.array(direction))
+        self._add_face_pointer('back',np.array(position), np.array(direction))
+        self._add_face_pointer('bottom',np.array(position), np.array(direction))
+        self._add_face_pointer('face',np.array(position), np.array(direction))
+        
 
 
 

emerge/_emerge/geometry.py

@@ -67,7 +67,13 @@ class _GeometryManager:
 
     def reset(self, modelname: str) -> None:
         self.geometry_list[modelname] = []
-        
+    
+    def lowest_priority(self) -> int:
+        return min([geo._priority for geo in self.all_geometries()])
+    
+    def highest_priority(self) -> int:
+        return min([geo._priority for geo in self.all_geometries()])
+    
 class _FacePointer:
     """The FacePointer class defines a face to be selectable as a
     face normal vector plus an origin. All faces of an object
@@ -387,6 +393,24 @@ class GeoObject:
         self._priority -= 1
         return self
 
+    def background(self) -> GeoObject:
+        """Set the priority to be on the background.
+
+        Returns:
+            GeoObject: _description_
+        """
+        self._priority = _GEOMANAGER.lowest_priority()-10
+        return self
+
+    def foreground(self) -> GeoObject:
+        """Set the priority to be on top.
+
+        Returns:
+            GeoObject: _description_
+        """
+        self._priority = _GEOMANAGER.highest_priority()+10
+        return self
+    
     def outside(self, *exclude: FaceNames, tags: list[int] | None = None) -> FaceSelection:
         """Returns the complete set of outside faces.
 
@@ -398,6 +422,8 @@ class GeoObject:
         """
         if tags is None:
             tags = []
+        for name in exclude:
+            tags.extend(self.face(name).tags)
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     

emerge/_emerge/material.py

@@ -18,6 +18,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.

emerge/_emerge/mesh3d.py

@@ -146,6 +146,7 @@ class Mesh3D(Mesh):
         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.etag_to_edge: dict[int, list[int]] = dict()
         
         self.exterior_face_tags: list[int] = []
     
@@ -176,7 +177,7 @@ class Mesh3D(Mesh):
         search = (min(int(i1),int(i2)), max(int(i1),int(i2)))
         result =  self.inv_edges.get(search, -10)
         if result == -10:
-            ValueError(f'There is no edge with indices {i1}, {i2}')
+            raise ValueError(f'There is no edge with indices {i1}, {i2}')
         return result
     
     def get_edge_sign(self, i1: int, i2: int) -> int:
@@ -240,6 +241,31 @@ class Mesh3D(Mesh):
 
         return np.array(indices)
     
+    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.
+        """
+        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))
+        
+        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 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()
@@ -271,6 +297,8 @@ class Mesh3D(Mesh):
     
     
     def update(self, periodic_bcs: list[Periodic] | None = None):
+        
+        logger.trace('Generating mesh data.')
         if periodic_bcs is None:
             periodic_bcs = []
             
@@ -282,7 +310,7 @@ class Mesh3D(Mesh):
         self.nodes = coords
         self.n_i2t = {i: int(t) for i, t in enumerate(nodes)}
         self.n_t2i = {t: i for i, t in self.n_i2t.items()}
-
+        logger.trace(f'Total of {self.nodes.shape[1]} nodes imported.')
         ## Tetrahedras
 
         _, tet_tags, tet_node_tags = gmsh.model.mesh.get_elements(3)
@@ -297,8 +325,8 @@ class Mesh3D(Mesh):
         self.tets = np.array(tet_node_tags).reshape(-1,4).T
         self.tet_i2t = {i: int(t) for i, t in enumerate(tet_tags)}
         self.tet_t2i = {t: i for i, t in self.tet_i2t.items()}
-
         self.centers = (self.nodes[:,self.tets[0,:]] + self.nodes[:,self.tets[1,:]] + self.nodes[:,self.tets[2,:]] + self.nodes[:,self.tets[3,:]]) / 4
+        logger.trace(f'Total of {self.tets.shape[1]} tetrahedra imported.')
         
         # Resort node indices to be sorted on all periodic conditions
         # This sorting makes sure that each edge and triangle on a source face is 
@@ -307,6 +335,7 @@ class Mesh3D(Mesh):
         # Then this ensures that if i1>i2>i3 then j1>j2>j3
     
         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 = {int(a): int(b) for a,b in nodemap.items()}
             self.nodes[:,ids2] = self.nodes[:,ids1]
@@ -330,25 +359,26 @@ class Mesh3D(Mesh):
             triset.add((i1,i2,i4))
             triset.add((i1,i3,i4))
             triset.add((i2,i3,i4))
-
+        logger.trace(f'Total of {len(edgeset)} unique edges and {len(triset)} unique triangles.')
+        
         # Edges are effectively Randomly sorted
         # It contains index pairs of vertices edge 1 = (ev1, ev2) etc.
-        # Same for traingles
+        # Same for triangles
         self.edges = np.array(sorted(list(edgeset))).T
         self.tris = np.array(sorted(list(triset))).T
-        
         self.tri_centers = (self.nodes[:,self.tris[0,:]] + self.nodes[:,self.tris[1,:]] + self.nodes[:,self.tris[2,:]]) / 3
+        
         def _hash(ints):
             return tuple(sorted([int(x) for x in ints]))
         
         # Map edge index tuples to edge indices
         # This mapping tells which characteristic index pair (4,3) maps to which edge
+        logger.trace('Constructing tet/tri/edge and node mappings.')
         self.inv_edges = {(int(self.edges[0,i]), int(self.edges[1,i])): i for i in range(self.edges.shape[1])}
         self.inv_tris = {_hash((self.tris[0,i], self.tris[1,i], self.tris[2,i])): i for i in range(self.tris.shape[1])}
         self.inv_tets = {_hash((self.tets[0,i], self.tets[1,i], self.tets[2,i], self.tets[3,i])): i for i in range(self.tets.shape[1])}
         
         # Tet links
-
         self.tet_to_edge = np.zeros((6, self.tets.shape[1]), dtype=int)-99999
         self.tet_to_edge_sign = np.zeros((6, self.tets.shape[1]), dtype=int)-999999
         self.tet_to_tri = np.zeros((4, self.tets.shape[1]), dtype=int)-99999
@@ -414,14 +444,32 @@ class Mesh3D(Mesh):
         self.node_to_edge = {key: sorted(list(set(val))) for key, val in self.node_to_edge.items()}
 
         ## Quantities
-
+        logger.trace('Computing derived quantaties (centres, areas and lengths).')
         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])])
         
+        ## Edge tag pairings
+        _, edge_tags, edge_node_tags = gmsh.model.mesh.get_elements(1)
+        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_i2t = {i: t for t, i in self.edge_t2i.items()}
+        
+        edge_dimtags = gmsh.model.get_entities(1)
+        for _d, t in edge_dimtags:
+            _, edge_tags, node_tags = gmsh.model.mesh.get_elements(1, t)
+            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]]
+        
+        
         ## Tag bindings
+        logger.trace('Constructing geometry to mesh mappings.')
         face_dimtags = gmsh.model.get_entities(2)
-        for d,t in face_dimtags:
+        for _d,t in face_dimtags:
             domain_tag, f_tags, node_tags = gmsh.model.mesh.get_elements(2, t)
             node_tags = [self.n_t2i[int(t)] for t in node_tags[0]]
             self.ftag_to_node[t] = node_tags
@@ -430,13 +478,14 @@ class Mesh3D(Mesh):
             self.ftag_to_edge[t] = sorted(list(np.unique(self.tri_to_edge[:,self.ftag_to_tri[t]].flatten())))
         
         vol_dimtags = gmsh.model.get_entities(3)
-        for d,t in vol_dimtags:
+        for _d,t in vol_dimtags:
             domain_tag, v_tags, node_tags = gmsh.model.mesh.get_elements(3, t)
             node_tags = [self.n_t2i[int(t)] for t in node_tags[0]]
             node_tags = np.squeeze(np.array(node_tags)).reshape(-1,4).T
             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
+        logger.trace('Done analyzing mesh.')
 
 
     ## Higher order functions
@@ -455,7 +504,7 @@ class Mesh3D(Mesh):
         Returns:
             tuple[dict[int, int], np.ndarray, np.ndarray]: The node index mapping and the node index arrays
         """
-        
+
         node_ids_1 = []
         node_ids_2 = []
 
@@ -597,9 +646,9 @@ class Mesh3D(Mesh):
         tri_ids = self.get_triangles(face_tags)
         if origin is None:
             nodes = self.nodes[:,self.get_nodes(face_tags)]
-            x0 = np.mean(nodes[0,:])
-            y0 = np.mean(nodes[1,:])
-            z0 = np.mean(nodes[2,:])
+            x0 = float(np.mean(nodes[0,:]))
+            y0 = float(np.mean(nodes[1,:]))
+            z0 = float(np.mean(nodes[2,:]))
             origin = (x0, y0, z0)
 
         return SurfaceMesh(self, tri_ids, origin)

emerge/_emerge/mesher.py

@@ -79,6 +79,7 @@ class Mesher:
         self.max_size: float = None
         self.periodic_cell: PeriodicCell = None
 
+        
     @property
     def edge_tags(self) -> list[int]:
         return [tag[1] for tag in gmsh.model.getEntities(1)]
@@ -244,7 +245,7 @@ class Mesher:
         for dimtag in dimtags:
             gmsh.model.mesh.setSizeFromBoundary(dimtag[0], dimtag[1], 0)
             
-    def set_boundary_size(self, boundary: GeoSurface | FaceSelection | Iterable, 
+    def set_boundary_size(self, boundary: GeoObject | Selection | Iterable, 
                           size:float,
                           growth_rate: float = 1.4,
                           max_size: float | None = None) -> None:
@@ -272,8 +273,10 @@ class Mesher:
         nodes = gmsh.model.getBoundary(dimtags, combined=False, oriented=False, recursive=False)
 
         disttag = gmsh.model.mesh.field.add("Distance")
-
-        gmsh.model.mesh.field.setNumbers(disttag, "CurvesList", [n[1] for n in nodes])
+        if boundary.dim==2:
+            gmsh.model.mesh.field.setNumbers(disttag, "CurvesList", [n[1] for n in nodes])
+        if boundary.dim==3:
+            gmsh.model.mesh.field.setNumbers(disttag,'SurfacesList', [n[1] for n in nodes])
         gmsh.model.mesh.field.setNumber(disttag, "Sampling", 100)
 
         thtag = gmsh.model.mesh.field.add("Threshold")
@@ -285,7 +288,7 @@ class Mesher:
     
         self.mesh_fields.append(thtag)
 
-    def set_domain_size(self, obj: GeoVolume | Selection, size: float):
+    def set_domain_size(self, obj: GeoObject | Selection, size: float):
         """Manually set the maximum element size inside a domain
 
         Args:

emerge/_emerge/mth/optimized.py

@@ -432,6 +432,36 @@ def matinv(M: np.ndarray) -> np.ndarray:
         out = out*det
     return out
 
+@njit(f8[:,:](f8[:,:]), cache=True, nogil=True)
+def matinv_r(M: np.ndarray) -> np.ndarray:
+    """Optimized matrix inverse of 3x3 matrix
+
+    Args:
+        M (np.ndarray): Input matrix M of shape (3,3)
+
+    Returns:
+        np.ndarray: The matrix inverse inv(M)
+    """
+    out = np.zeros((3,3), dtype=np.float64)
+   
+    if M[0,1]==0 and M[0,2]==0 and M[1,0]==0 and M[1,2]==0 and M[2,0]==0 and M[2,1]==0:
+        out[0,0] = 1/M[0,0]
+        out[1,1] = 1/M[1,1]
+        out[2,2] = 1/M[2,2]
+    else:
+        det = M[0,0]*M[1,1]*M[2,2] - M[0,0]*M[1,2]*M[2,1] - M[0,1]*M[1,0]*M[2,2] + M[0,1]*M[1,2]*M[2,0] + M[0,2]*M[1,0]*M[2,1] - M[0,2]*M[1,1]*M[2,0]
+        out[0,0] = M[1,1]*M[2,2] - M[1,2]*M[2,1]
+        out[0,1] = -M[0,1]*M[2,2] + M[0,2]*M[2,1]
+        out[0,2] = M[0,1]*M[1,2] - M[0,2]*M[1,1]
+        out[1,0] = -M[1,0]*M[2,2] + M[1,2]*M[2,0]
+        out[1,1] = M[0,0]*M[2,2] - M[0,2]*M[2,0]
+        out[1,2] = -M[0,0]*M[1,2] + M[0,2]*M[1,0]
+        out[2,0] = M[1,0]*M[2,1] - M[1,1]*M[2,0]
+        out[2,1] = -M[0,0]*M[2,1] + M[0,1]*M[2,0]
+        out[2,2] = M[0,0]*M[1,1] - M[0,1]*M[1,0]
+        out = out*det
+    return out
+
 @njit(cache=True, nogil=True)
 def matmul(M: np.ndarray, vecs: np.ndarray):
     """Executes a basis transformation of vectors (3,N) with a basis matrix M