emerge 1.0.3__py3-none-any.whl → 1.0.4__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "1.0.3"
+__version__ = "1.0.4"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -30,8 +30,11 @@ os.environ["EMERGE_FILE_LOGLEVEL"] = os.getenv("EMERGE_FILE_LOGLEVEL", default="
 os.environ["OMP_NUM_THREADS"] = os.getenv("OMP_NUM_THREADS", default="1")
 os.environ["MKL_NUM_THREADS"] = os.getenv("MKL_NUM_THREADS", default="4")
 os.environ["OPENBLAS_NUM_THREADS"] = NTHREADS
+os.environ["VECLIB_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_MAXIMUM_THREADS"] = NTHREADS
 os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
+os.environ["NUMBA_NUM_THREADS"] = "4"
+os.environ.setdefault("NUMBA_THREADING_LAYER", "workqueue")
 
 ############################################################
 #                      IMPORT MODULES                     #
@@ -44,6 +47,7 @@ LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
 LOG_CONTROLLER._set_log_buffer()
 
+import gmsh
 from ._emerge.simmodel import Simulation
 from ._emerge.material import Material, FreqCoordDependent, FreqDependent, CoordDependent
 from ._emerge import bc
@@ -53,12 +57,12 @@ from ._emerge.coord import Line
 from ._emerge import geo
 from ._emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
 from ._emerge.geometry import select
-#from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
+from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
 from ._emerge.periodic import RectCell, HexCell
 from ._emerge.mesher import Algorithm2D, Algorithm3D
 from . import lib
 from ._emerge.howto import _HowtoClass
-
+from ._emerge.emerge_update import update_emerge
 howto = _HowtoClass()
 
 logger.debug('Importing complete!')

emerge/_emerge/elements/femdata.py

@@ -61,7 +61,7 @@ class FEMBasis:
             return matmul(ibasis, np.array(self.interpolate(field, xyzg[0,:], xyzg[1,:], xyzg[2,:], tetids)))
         return func
     
-    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, tetids: np.ndarray | None = None, usenan: bool = True) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         raise NotImplementedError()
     
     def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, constants: np.ndarray, tetids: np.ndarray | None = None, usenan: bool = True) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
@@ -70,6 +70,10 @@ class FEMBasis:
         """
         raise NotImplementedError()
     
+    def interpolate_error(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, tetids: np.ndarray | None = None, cs: tuple[float, float] = (1.0, 1.0)) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        raise NotImplementedError()
+    
+    
     def empty_tet_matrix(self) -> np.ndarray:
         nnz = self.n_tets*self.n_tet_dofs**2
         matrix = np.empty((nnz,), dtype=np.complex128)

emerge/_emerge/elements/ned2_interp.py

@@ -192,6 +192,7 @@ def ned2_tet_interp(coords: np.ndarray,
         Exl = np.zeros(x.shape, dtype=np.complex128)
         Eyl = np.zeros(x.shape, dtype=np.complex128)
         Ezl = np.zeros(x.shape, dtype=np.complex128)
+        V1 = (216*V**3)
         for ie in range(6):
             Em1, Em2 = Em1s[ie], Em2s[ie]
             edgeids = l_edge_ids[:, ie]
@@ -202,11 +203,12 @@ def ned2_tet_interp(coords: np.ndarray,
             x1, x2 = xvs[edgeids]
             y1, y2 = yvs[edgeids]
             z1, z2 = zvs[edgeids]
-
+            F1 = (a1 + b1*x + c1*y + d1*z)
+            F2 = (a2 + b2*x + c2*y + d2*z)
             L = np.sqrt((x1 - x2)**2 + (y1 - y2)**2 + (z1 - z2)**2)
-            ex =  L*(Em1*(a1 + b1*x + c1*y + d1*z) + Em2*(a2 + b2*x + c2*y + d2*z))*(b1*(a2 + b2*x + c2*y + d2*z) - b2*(a1 + b1*x + c1*y + d1*z))/(216*V**3)
-            ey =  L*(Em1*(a1 + b1*x + c1*y + d1*z) + Em2*(a2 + b2*x + c2*y + d2*z))*(c1*(a2 + b2*x + c2*y + d2*z) - c2*(a1 + b1*x + c1*y + d1*z))/(216*V**3)
-            ez =  L*(Em1*(a1 + b1*x + c1*y + d1*z) + Em2*(a2 + b2*x + c2*y + d2*z))*(d1*(a2 + b2*x + c2*y + d2*z) - d2*(a1 + b1*x + c1*y + d1*z))/(216*V**3)
+            ex =  L*(Em1*F1 + Em2*F2)*(b1*F2 - b2*F1)/V1
+            ey =  L*(Em1*F1 + Em2*F2)*(c1*F2 - c2*F1)/V1
+            ez =  L*(Em1*F1 + Em2*F2)*(d1*F2 - d2*F1)/V1
 
             Exl += ex
             Eyl += ey
@@ -226,10 +228,16 @@ def ned2_tet_interp(coords: np.ndarray,
 
             L1 = np.sqrt((x1-x3)**2 + (y1-y3)**2 + (z1-z3)**2)
             L2 = np.sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2)
-
-            ex =  (-Em1*L1*(b1*(a3 + b3*x + c3*y + d3*z) - b3*(a1 + b1*x + c1*y + d1*z))*(a2 + b2*x + c2*y + d2*z) + Em2*L2*(b1*(a2 + b2*x + c2*y + d2*z) - b2*(a1 + b1*x + c1*y + d1*z))*(a3 + b3*x + c3*y + d3*z))/(216*V**3)
-            ey =  (-Em1*L1*(c1*(a3 + b3*x + c3*y + d3*z) - c3*(a1 + b1*x + c1*y + d1*z))*(a2 + b2*x + c2*y + d2*z) + Em2*L2*(c1*(a2 + b2*x + c2*y + d2*z) - c2*(a1 + b1*x + c1*y + d1*z))*(a3 + b3*x + c3*y + d3*z))/(216*V**3)
-            ez =  (-Em1*L1*(d1*(a3 + b3*x + c3*y + d3*z) - d3*(a1 + b1*x + c1*y + d1*z))*(a2 + b2*x + c2*y + d2*z) + Em2*L2*(d1*(a2 + b2*x + c2*y + d2*z) - d2*(a1 + b1*x + c1*y + d1*z))*(a3 + b3*x + c3*y + d3*z))/(216*V**3)
+            
+            F1 = (a1 + b1*x + c1*y + d1*z)
+            F2 = (a2 + b2*x + c2*y + d2*z)
+            F3 = (a3 + b3*x + c3*y + d3*z)
+            
+            Q1 = Em1*L1*F2
+            Q2 = Em2*L2*F3
+            ex =  (-Q1*(b1*F3 - b3*F1) + Q2*(b1*F2 - b2*F1))/V1
+            ey =  (-Q1*(c1*F3 - c3*F1) + Q2*(c1*F2 - c2*F1))/V1
+            ez =  (-Q1*(d1*F3 - d3*F1) + Q2*(d1*F2 - d2*F1))/V1
             
             Exl += ex
             Eyl += ey
@@ -322,6 +330,10 @@ def ned2_tet_interp_curl(coords: np.ndarray,
         Exl = np.zeros(x.shape, dtype=np.complex128)
         Eyl = np.zeros(x.shape, dtype=np.complex128)
         Ezl = np.zeros(x.shape, dtype=np.complex128)
+        
+        V1 = (216*V**3)
+        V2 = (72*V**3)
+        
         for ie in range(6):
             Em1, Em2 = Em1s[ie], Em2s[ie]
             edgeids = l_edge_ids[:, ie]
@@ -334,9 +346,35 @@ def ned2_tet_interp_curl(coords: np.ndarray,
             z1, z2 = zvs[edgeids]
 
             L = np.sqrt((x1 - x2)**2 + (y1 - y2)**2 + (z1 - z2)**2)
-            ex =  L*(-Em1*a1*c1*d2 + Em1*a1*c2*d1 - Em1*b1*c1*d2*x + Em1*b1*c2*d1*x - Em1*c1**2*d2*y + Em1*c1*c2*d1*y - Em1*c1*d1*d2*z + Em1*c2*d1**2*z - Em2*a2*c1*d2 + Em2*a2*c2*d1 - Em2*b2*c1*d2*x + Em2*b2*c2*d1*x - Em2*c1*c2*d2*y - Em2*c1*d2**2*z + Em2*c2**2*d1*y + Em2*c2*d1*d2*z)/(72*V**3)
-            ey =  L*(Em1*a1*b1*d2 - Em1*a1*b2*d1 + Em1*b1**2*d2*x - Em1*b1*b2*d1*x + Em1*b1*c1*d2*y + Em1*b1*d1*d2*z - Em1*b2*c1*d1*y - Em1*b2*d1**2*z + Em2*a2*b1*d2 - Em2*a2*b2*d1 + Em2*b1*b2*d2*x + Em2*b1*c2*d2*y + Em2*b1*d2**2*z - Em2*b2**2*d1*x - Em2*b2*c2*d1*y - Em2*b2*d1*d2*z)/(72*V**3)
-            ez =  L*(-Em1*a1*b1*c2 + Em1*a1*b2*c1 - Em1*b1**2*c2*x + Em1*b1*b2*c1*x - Em1*b1*c1*c2*y - Em1*b1*c2*d1*z + Em1*b2*c1**2*y + Em1*b2*c1*d1*z - Em2*a2*b1*c2 + Em2*a2*b2*c1 - Em2*b1*b2*c2*x - Em2*b1*c2**2*y - Em2*b1*c2*d2*z + Em2*b2**2*c1*x + Em2*b2*c1*c2*y + Em2*b2*c1*d2*z)/(72*V**3)
+            C1 = Em1*a1
+            C2 = Em1*b1
+            C3 = Em1*c1
+            C4 = Em1*c2
+            C5 = Em2*a2
+            C6 = Em2*b2
+            C7 = Em2*c1
+            C8 = Em2*c2
+            C9 = Em1*b2
+            C10 = Em2*b1
+            D1 = c1*d2
+            D2 = c2*d1
+            D3 = d1*d2
+            D4 = d1*d1
+            D5 = c2*d2
+            D6 = d2*d2
+            D7 = b1*d2
+            D8 = b2*d1
+            D9 = c1*d1
+            D10 = b2*d2
+            D11 = b1*c2
+            D12 = b2*c1
+            D13 = c1*c2
+            D14 = c1*c1
+            D15 = b2*c2
+            
+            ex =  L*(-C1*D1 + C1*D2 - C2*D1*x + C2*D2*x - C3*D1*y + C3*D2*y - C3*D3*z + C4*D4*z - C5*D1 + C5*D2 - C6*D1*x + C6*D2*x - C7*D5*y - C7*D6*z + C8*D2*y + C8*D3*z)/V2
+            ey =  L*(C1*D7 - C1*D8 + C2*D7*x - C2*D8*x + C2*D1*y + C2*D3*z - C9*D9*y - C9*D4*z + C5*D7 - C5*D8 + C10*D10*x + C10*D5*y + C10*D6*z - C6*D8*x - C6*D2*y - C6*D3*z)/V2
+            ez =  L*(-C1*D11 + C1*D12 - C2*D11*x + C2*D12*x - C2*D13*y - C2*D2*z + C9*D14*y + C9*D9*z - C5*D11 + C5*D12 - C10*D15*x - C10*c2*c2*y - C10*D5*z + C6*D12*x + C6*D13*y + C6*D1*z)/V2
             Exl += ex
             Eyl += ey
             Ezl += ez
@@ -355,10 +393,28 @@ def ned2_tet_interp_curl(coords: np.ndarray,
 
             L1 = np.sqrt((x1-x3)**2 + (y1-y3)**2 + (z1-z3)**2)
             L2 = np.sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2)
-
-            ex =  (Em1*L1*(-c2*(d1*(a3 + b3*x + c3*y + d3*z) - d3*(a1 + b1*x + c1*y + d1*z)) + d2*(c1*(a3 + b3*x + c3*y + d3*z) - c3*(a1 + b1*x + c1*y + d1*z)) + 2*(c1*d3 - c3*d1)*(a2 + b2*x + c2*y + d2*z)) - Em2*L2*(-c3*(d1*(a2 + b2*x + c2*y + d2*z) - d2*(a1 + b1*x + c1*y + d1*z)) + d3*(c1*(a2 + b2*x + c2*y + d2*z) - c2*(a1 + b1*x + c1*y + d1*z)) + 2*(c1*d2 - c2*d1)*(a3 + b3*x + c3*y + d3*z)))/(216*V**3)
-            ey =  (-Em1*L1*(-b2*(d1*(a3 + b3*x + c3*y + d3*z) - d3*(a1 + b1*x + c1*y + d1*z)) + d2*(b1*(a3 + b3*x + c3*y + d3*z) - b3*(a1 + b1*x + c1*y + d1*z)) + 2*(b1*d3 - b3*d1)*(a2 + b2*x + c2*y + d2*z)) + Em2*L2*(-b3*(d1*(a2 + b2*x + c2*y + d2*z) - d2*(a1 + b1*x + c1*y + d1*z)) + d3*(b1*(a2 + b2*x + c2*y + d2*z) - b2*(a1 + b1*x + c1*y + d1*z)) + 2*(b1*d2 - b2*d1)*(a3 + b3*x + c3*y + d3*z)))/(216*V**3)
-            ez =  (Em1*L1*(-b2*(c1*(a3 + b3*x + c3*y + d3*z) - c3*(a1 + b1*x + c1*y + d1*z)) + c2*(b1*(a3 + b3*x + c3*y + d3*z) - b3*(a1 + b1*x + c1*y + d1*z)) + 2*(b1*c3 - b3*c1)*(a2 + b2*x + c2*y + d2*z)) - Em2*L2*(-b3*(c1*(a2 + b2*x + c2*y + d2*z) - c2*(a1 + b1*x + c1*y + d1*z)) + c3*(b1*(a2 + b2*x + c2*y + d2*z) - b2*(a1 + b1*x + c1*y + d1*z)) + 2*(b1*c2 - b2*c1)*(a3 + b3*x + c3*y + d3*z)))/(216*V**3)
+            F1 = (a3 + b3*x + c3*y + d3*z)
+            F2 = (a1 + b1*x + c1*y + d1*z)
+            F3 = (a2 + b2*x + c2*y + d2*z)
+            N1 = (d1*F1 - d3*F2)
+            N2 = (c1*F1 - c3*F2)
+            N3 = (c1*d3 - c3*d1)
+            N4 = (d1*F3 - d2*F2)
+            N5 = (c1*F3 - c2*F2)
+            D1 = c1*d2
+            D2 = c2*d1
+            N6 = (D1 - D2)
+            N7 = (b1*F1 - b3*F2)
+            N8 = (b1*d3 - b3*d1)
+            N9 = (b1*F3 - b2*F2)
+            D7 = b1*d2
+            D8 = b2*d1
+            N10 = (D7 - D8)
+            D11 = b1*c2
+            D12 = b2*c1
+            ex =  (Em1*L1*(-c2*N1 + d2*N2 + 2*N3*F3) - Em2*L2*(-c3*N4 + d3*N5 + 2*N6*F1))/V1
+            ey =  (-Em1*L1*(-b2*N1 + d2*N7 + 2*N8*F3) + Em2*L2*(-b3*N4 + d3*N9 + 2*N10*F1))/V1
+            ez =  (Em1*L1*(-b2*N2 + c2*N7 + 2*(b1*c3 - b3*c1)*F3) - Em2*L2*(-b3*N5 + c3*N9 + 2*(D11 - D12)*F1))/V1
             
             Exl += ex
             Eyl += ey
@@ -445,8 +501,7 @@ def ned2_tri_interp(coords: np.ndarray,
         
         Exl = np.zeros(x.shape, dtype=np.complex128)
         Eyl = np.zeros(x.shape, dtype=np.complex128)
-
-
+        
         for ie in range(3):
             Em1, Em2 = Em1s[ie], Em2s[ie]
             edgeids = l_edge_ids[:, ie]
@@ -534,17 +589,11 @@ def ned2_tri_interp_full(coords: np.ndarray,
         yvs = nodes[1, tris[:,itri]]
 
         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
 
         a1, a2, a3 = a_s
         b1, b2, b3 = b_s
         c1, c2, c3 = c_s
-
-        # 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)
@@ -617,18 +666,12 @@ def ned2_tri_interp_curl(coords: np.ndarray,
         yvs = nodes[1, tris[:,itri]]
 
         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
 
         a1, a2, a3 = a_s
         b1, b2, b3 = b_s
         c1, c2, c3 = c_s
         
-        # 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)
@@ -637,4 +680,4 @@ def ned2_tri_interp_curl(coords: np.ndarray,
         Ex[inside] = hx*dc[0,0]
         Ey[inside] = hy*dc[1,1]
         Ez[inside] = hz*dc[2,2]
-    return Ex, Ey, Ez
+    return Ex, Ey, Ez

emerge/_emerge/elements/nedelec2.py

@@ -91,6 +91,7 @@ class Nedelec2(FEMBasis):
             vals = np.nan_to_num(vals)
         return vals
     
+    
     def interpolate_index(self, xs: np.ndarray,
                         ys: np.ndarray,
                         zs: np.ndarray,

emerge/_emerge/emerge_update.py

@@ -0,0 +1,63 @@
+import subprocess
+import sys
+from importlib import import_module
+
+try:
+    from loguru import logger
+except ImportError:
+    # Fallback if loguru isn't installed
+    class _Logger:
+        def info(self, msg): print(f"[INFO] {msg}")
+        def warning(self, msg): print(f"[WARN] {msg}")
+        def error(self, msg): print(f"[ERROR] {msg}")
+    logger = _Logger()
+
+
+def update_emerge(branch: str = "main", confirm: bool = True, _dryrun: bool = False) -> str | None:
+    """
+    Update the EMerge library directly from GitHub.
+
+    Parameters
+    ----------
+    branch : str, optional
+        The git branch or tag to install from. Default is "main".
+    confirm : bool, optional
+        If True, asks the user for confirmation before updating.
+
+    Returns
+    -------
+    str | None
+        The updated version string if successful, otherwise None.
+    """
+    logger.warning(
+        "You are about to update EMerge from GitHub. "
+        "This is an experimental feature and may overwrite your installed version."
+    )
+
+    if confirm:
+        ans = input("Do you wish to proceed? [y/N] ").strip().lower()
+        if ans != "y":
+            logger.info("Update aborted by user.")
+            return None
+
+    url = f"git+https://github.com/FennisRobert/EMerge.git@{branch}"
+    logger.info(f"Updating EMerge from branch/tag '{branch}'...")
+
+    if not _dryrun:
+        try:
+            subprocess.check_call(
+                [sys.executable, "-m", "pip", "install", "--upgrade", "--force-reinstall", url]
+            )
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Update failed: {e}")
+            return None
+    else:
+        logger.info('Dry run... No update executed!')
+    try:
+        emerge = import_module("emerge")
+        version = getattr(emerge, "__version__", "unknown")
+        logger.info(f"Successfully updated to EMerge version {version}.")
+        return version
+    except Exception as e:
+        logger.error(f"Update installed but could not retrieve version: {e}")
+        return None

emerge/_emerge/geo/operations.py

@@ -300,14 +300,15 @@ def unite(*objects: GeoObject) -> GeoObject:
         GeoObject: The resultant object
     """
     main, *rest = objects
+    
     if not rest:
         return main
+    
     main._exists = False
     dts = []
     for other in rest:
         dts.extend(other.dimtags)
         other._exists = False
-    
     new_dimtags, mapping = gmsh.model.occ.fuse(main.dimtags, dts)
     
     new_obj = GeoObject.from_dimtags(new_dimtags)._take_tools(*objects)

emerge/_emerge/geo/polybased.py

@@ -238,7 +238,8 @@ class XYPolygon:
     def __init__(self, 
                  xs: np.ndarray | list | tuple | None = None,
                  ys: np.ndarray | list | tuple | None = None,
-                 cs: CoordinateSystem | None = None):
+                 cs: CoordinateSystem | None = None,
+                 resolution: float = 1e-6):
         """Constructs an XY-plane placed polygon.
 
         Args:
@@ -256,6 +257,7 @@ class XYPolygon:
         self.fillets: list[tuple[float, int]] = []
         
         self._cs: CoordinateSystem = cs
+        self.resolution: float = resolution
 
     @property
     def center(self) -> tuple[float, float]:
@@ -279,7 +281,7 @@ class XYPolygon:
         The XYPolygon does not store redundant points p[0]==p[N] so if these are
         the same, this function will remove the last point.
         """
-        if np.sqrt((self.x[-1]-self.x[0])**2 + (self.y[-1]-self.y[0])**2) < 1e-6:
+        if np.sqrt((self.x[-1]-self.x[0])**2 + (self.y[-1]-self.y[0])**2) < 1e-9:
             self.x = self.x[:-1]
             self.y = self.y[:-1]
         
@@ -329,6 +331,23 @@ class XYPolygon:
             self.fillets.append((radius, i))
         return self
 
+    def _cleanup(self, resolution: float | None = None) -> None:
+        # Compute differences between consecutive points
+        if resolution is None:
+            resolution = self.resolution
+        dx = np.diff(self.x)
+        dy = np.diff(self.y)
+
+        # Distances between consecutive points
+        dist = np.sqrt(dx**2 + dy**2)
+
+        # Keep the first point, then points where distance >= threshold
+        keep = np.insert(dist >= resolution, 1, True)
+
+        # Apply mask
+        self.x = self.x[keep]
+        self.y = self.y[keep]
+        
     def _make_wire(self, cs: CoordinateSystem) -> tuple[list[int], list[int], int]:
         """Turns the XYPolygon object into a GeoPolygon that is embedded in 3D space.
 
@@ -345,8 +364,11 @@ class XYPolygon:
         ptags = []
         xg, yg, zg = cs.in_global_cs(self.x, self.y, 0*self.x)
 
+        points = dict()
         for x,y,z in zip(xg, yg, zg):
-            ptags.append(gmsh.model.occ.add_point(x,y,z))
+            ptag = gmsh.model.occ.add_point(x,y,z)
+            points[ptag] = (x,y,z)
+            ptags.append(ptag)
         
         lines = []
         for i1, p1 in enumerate(ptags):
@@ -375,6 +397,7 @@ class XYPolygon:
         Returns:
             GeoPolygon: The resultant 3D GeoPolygon object.
         """
+        self._cleanup()
         ptags, lines, wiretag = self._make_wire(cs)
         surftag = gmsh.model.occ.add_plane_surface([wiretag,])
         poly = GeoPolygon([surftag,], name=name)
@@ -635,8 +658,6 @@ class Curve(GeoEdge):
         self.dstart: tuple[float, float, float] = (p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
     
         
-        
-    
     @property
     def p0(self) -> tuple[float, float, float]:
         """The start coordinate

emerge/_emerge/geometry.py

@@ -60,6 +60,11 @@ class _GeometryManager:
             model = self.active
         return [geo for geo in self.geometry_list[model].values() if geo._exists]
 
+    def set_geometries(self, geos: list[GeoObject], model: str | None = None):
+        if model is None:
+            model = self.active
+        self.geometry_list[model] = geos
+        
     def all_names(self, model: str | None = None) -> set[str]:
         if model is None:
             model = self.active

emerge/_emerge/logsettings.py

@@ -21,11 +21,25 @@ from typing import Literal
 from pathlib import Path
 import os
 from collections import deque
-
+import platform
+import importlib
+import multiprocessing
+
+packages = ["numba", "numpy", "scipy", "gmsh", "joblib","matplotlib","pyvista","mkl","cloudpickle","scikit-umfpack","nvidia-cudss-cu12","nvmath-python[cu12]","cupy-cuda12x","ezdxf"]
+
+def get_version(pkg_name):
+    try:
+        module = importlib.import_module(pkg_name)
+        return getattr(module, "__version__", "unknown")
+    except ImportError:
+        return "not installed"
+    
 _LOG_BUFFER = deque()
 
 def _log_sink(message):
     _LOG_BUFFER.append(message)
+    
+
 ############################################################
 #                          FORMATS                         #
 ############################################################
@@ -93,6 +107,17 @@ class LogController:
             logger.opt(depth=6).log(msg.record["level"].name, msg.record["message"])
         _LOG_BUFFER.clear()
         
+    def _sys_info(self) -> None:
+        for pkg in packages:
+            logger.trace(f" (!) {pkg} version: {get_version(pkg)}")
+
+        logger.trace(f" (!) OS: {platform.system()} {platform.release()} ({platform.version()})")
+        logger.trace(f" (!) Architecture: {platform.machine()} ({platform.architecture()[0]})")
+        logger.trace(f" (!) Processor: {platform.processor()}")
+        logger.trace(f" (!) Python build: {platform.python_build()}")
+        logger.trace(f" (!) Python version: {platform.python_version()} [{sys.version}]")
+        logger.trace(f" (!) CPU cores: {multiprocessing.cpu_count()}")
+        
     def set_std_loglevel(self, loglevel: str):
         handler = {"sink": sys.stdout, 
                    "level": loglevel, 

emerge/_emerge/material.py

@@ -45,9 +45,10 @@ def _to_mat(value: float | complex | int | np.ndarray) -> np.ndarray:
 class MatProperty:
     _freq_dependent: bool = False
     _coord_dependent: bool = False
+    _pickle_exclude = {"_func","_fmax"}
     """The MatProperty class is an interface for EMerge to deal with frequency and coordinate dependent material properties
     """
-
+    
     def __init__(self, value: float | complex | int | np.ndarray):
         self.value: np.ndarray = _to_mat(value)
         
@@ -76,7 +77,19 @@ class MatProperty:
         self._x: np.ndarray = np.array([], dtype=np.float64)
         self._y: np.ndarray = np.array([], dtype=np.float64)
         self._z: np.ndarray = np.array([], dtype=np.float64)
+    
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        for k in self._pickle_exclude:
+            state.pop(k, None)
         
+        return state
+    
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        for k in self._pickle_exclude:
+            setattr(self, k, None)
+    
 class FreqDependent(MatProperty):
     _freq_dependent: bool = True
     _coord_dependent: bool = False
@@ -165,6 +178,7 @@ class CoordDependent(MatProperty):
         if scalar is not None:
             def _func(x, y, z) -> np.ndarray:
                 return np.eye(3)[:, :, None] * scalar(x,y,z)[None, None, :]
+        
         if vector is not None:
             def _func(x, y, z) -> np.ndarray:
                 N = x.shape[0]
@@ -261,13 +275,6 @@ class FreqCoordDependent(MatProperty):
     def scalar(self, f: float):
         return self._func(f, 0,0,0)[0,0]
 
-# To be finished once its clear how to deal with default values for functions
-
-# def parse_material_property(value: complex | float | Callable):
-#     if not isinstance(value, Callable):
-#         return MatProperty(value)
-#     pass
-
 class Material:
     """The Material class generalizes a material in the EMerge FEM environment.
 
@@ -282,6 +289,8 @@ class Material:
     to supply a frequency and coordinate dependent property use: emerge.FreqCoordDependent()
     
     """
+    _pickle_exclude = {"_neff"}
+    
     def __init__(self,
                  er: float | complex | np.ndarray | MatProperty = 1.0,
                  ur: float | complex | np.ndarray | MatProperty = 1.0,
@@ -319,6 +328,18 @@ class Material:
         hex_str = self.color.lstrip('#')
         self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
         self._metal: bool = _metal
+        
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        for k in self._pickle_exclude:
+            state.pop(k, None)
+        
+        return state
+    
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        for k in self._pickle_exclude:
+            setattr(self, k, None)
 
     def __hash__(self):
         return self._hash_key

emerge/_emerge/mesh3d.py

@@ -26,6 +26,8 @@ from loguru import logger
 from .bc import Periodic
 from .material import Material
 
+_MISSING_ID: int = -1234
+
 def shortest_distance(point_cloud):
     """
     Compute the shortest distance between any two points in a 3D point cloud.
@@ -128,7 +130,6 @@ class Mesh3D(Mesh):
         ## States
         self.defined: bool = False
 
-
         ## Memory
         self.ftag_to_tri: dict[int, list[int]] = dict()
         self.ftag_to_node: dict[int, list[int]] = dict()
@@ -167,8 +168,8 @@ class Mesh3D(Mesh):
         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 and not skip:
+        result =  self.inv_edges.get(search, _MISSING_ID)
+        if result == _MISSING_ID and not skip:
             raise ValueError(f'There is no edge with indices {i1}, {i2}')
         return result
     
@@ -182,9 +183,10 @@ class Mesh3D(Mesh):
         
     def get_tri(self, i1, i2, i3) -> int:
         '''Return the triangle index given the three node indices'''
+        i11, i21, i31 = tuple(sorted((int(i1), int(i2), int(i3))))
         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}')
+            raise ValueError(f'There is no triangle with indices {i11}, {i21}, {i31}')
         return output
     
     def get_tet(self, i1, i2, i3, i4) -> int:
@@ -302,7 +304,7 @@ class Mesh3D(Mesh):
         """
         from .mth.optimized import area
         
-        logger.trace('Generating mesh data.')
+        logger.trace('Generating internal mesh data.')
         if periodic_bcs is None:
             periodic_bcs = []
             
@@ -383,10 +385,10 @@ class Mesh3D(Mesh):
         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
-        self.tet_to_tri_sign = np.zeros((4, self.tets.shape[1]), dtype=int)-999999
+        self.tet_to_edge = np.zeros((6, self.tets.shape[1]), dtype=int) + _MISSING_ID
+        self.tet_to_edge_sign = np.zeros((6, self.tets.shape[1]), dtype=int) + _MISSING_ID
+        self.tet_to_tri = np.zeros((4, self.tets.shape[1]), dtype=int) + _MISSING_ID
+        self.tet_to_tri_sign = np.zeros((4, self.tets.shape[1]), dtype=int) + _MISSING_ID
 
         tri_to_tet = defaultdict(list)
         for itet in range(self.tets.shape[1]):
@@ -408,7 +410,7 @@ class Mesh3D(Mesh):
             tri_to_tet[self.tet_to_tri[3, itet]].append(itet)
         
         # Tri links
-        self.tri_to_tet = np.zeros((2, self.tris.shape[1]), dtype=int)-1
+        self.tri_to_tet = np.zeros((2, self.tris.shape[1]), dtype=int)+_MISSING_ID
         for itri in range(self.tris.shape[1]):
             tets = tri_to_tet[itri]
             self.tri_to_tet[:len(tets), itri] = tets
@@ -459,7 +461,7 @@ class Mesh3D(Mesh):
         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]], 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_t2i = {key: value for key,value in self.edge_t2i.items() if value!=-_MISSING_ID}
         self.edge_i2t = {i: t for t, i in self.edge_t2i.items()}
         
         edge_dimtags = gmsh.model.get_entities(1)
@@ -479,6 +481,7 @@ class Mesh3D(Mesh):
             node_tags = [self.n_t2i[int(t)] for t in node_tags[0]]
             self.ftag_to_node[t] = node_tags
             node_tags = np.squeeze(np.array(node_tags)).reshape(-1,3).T
+            
             self.ftag_to_tri[t] = [self.get_tri(node_tags[0,i], node_tags[1,i], node_tags[2,i]) for i in range(node_tags.shape[1])]
             self.ftag_to_edge[t] = sorted(list(np.unique(self.tri_to_edge[:,self.ftag_to_tri[t]].flatten())))
         
@@ -502,7 +505,7 @@ class Mesh3D(Mesh):
                 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.')
+        logger.trace('Finalized mesh data generation!')
 
 
     ## Higher order functions
@@ -548,7 +551,7 @@ class Mesh3D(Mesh):
         node_ids_2_arry = np.array(node_ids_2)
         dv = np.array(bc.dv)
         
-        nodemap = pair_coordinates(self.nodes, node_ids_1_arry, node_ids_2_arry, dv, dsmin/2)
+        nodemap = pair_coordinates(self.nodes, node_ids_1_arry, node_ids_2_arry, dv, dsmin/4)
         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)}