emerge 1.0.3__py3-none-any.whl → 1.0.5__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.5"
 
 ############################################################
 #               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

@@ -51,11 +51,13 @@ def add(main: T, tool: T,
     GeoSurface | GeoVolume
         A new object that is the union of the main and tool objects.
     '''
+    
     out_dim_tags, out_dim_tags_map = gmsh.model.occ.fuse(main.dimtags, tool.dimtags, removeObject=remove_object, removeTool=remove_tool)
     if out_dim_tags[0][0] == 3:
         output = GeoVolume([dt[1] for dt in out_dim_tags])._take_tools(tool,main)
     elif out_dim_tags[0][0] == 2:
         output = GeoSurface([dt[1] for dt in out_dim_tags])._take_tools(tool,main)
+    
     if remove_object:
         main._exists = False
     if remove_tool:
@@ -300,15 +302,16 @@ 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:
+    for other in objects:
         dts.extend(other.dimtags)
         other._exists = False
-    
-    new_dimtags, mapping = gmsh.model.occ.fuse(main.dimtags, dts)
+    new_dimtags, mapping = gmsh.model.occ.fuse(dts, main.dimtags)
     
     new_obj = GeoObject.from_dimtags(new_dimtags)._take_tools(*objects)
     new_obj.set_material(main.material)

emerge/_emerge/geo/polybased.py

@@ -24,6 +24,7 @@ from typing import Generator, Callable
 from ..selection import FaceSelection
 from typing import Literal
 from functools import reduce
+from loguru import logger
 
 
 def _discretize_curve(xfunc: Callable, yfunc: Callable, 
@@ -238,7 +239,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 +258,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 +282,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 +332,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.
 
@@ -343,10 +363,23 @@ class XYPolygon:
         self._check()
 
         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))
+            reuse = False
+            for key, (px, py, pz) in points.items():
+                if ((x-px)**2 + (y-py)**2 + (z-pz)**2)**0.5 < 1e-12:
+                    ptags.append(key)
+                    reuse = True
+                    break
+            if reuse:
+                logger.warning(f'Reusing {ptags[-1]}')
+                continue
+            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 +408,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 +669,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