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

emerge/_emerge/physics/microwave/assembly/robin_abc_order2.py

@@ -0,0 +1,375 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+
+import numpy as np
+from ....elements import Nedelec2
+from scipy.sparse import csr_matrix
+from ....mth.optimized import local_mapping, compute_distances
+from numba import c16, types, f8, i8, njit, prange
+
+
+############################################################
+#                      FIELD MAPPING                      #
+############################################################
+
+@njit(i8[:,:](i8, i8[:,:], i8[:,:], i8[:,:]), cache=True, nogil=True)
+def local_tri_to_edgeid(itri: int, tris, edges, tri_to_edge) -> np.ndarray:
+    global_edge_map = edges[:, tri_to_edge[:,itri]]
+    return local_mapping(tris[:, itri], global_edge_map)
+
+
+@njit(cache=True, fastmath=True, nogil=True)
+def optim_matmul(B: np.ndarray, data: np.ndarray):
+    dnew = np.zeros_like(data)
+    dnew[0,:] = B[0,0]*data[0,:] + B[0,1]*data[1,:] + B[0,2]*data[2,:]
+    dnew[1,:] = B[1,0]*data[0,:] + B[1,1]*data[1,:] + B[1,2]*data[2,:]
+    dnew[2,:] = B[2,0]*data[0,:] + B[2,1]*data[1,:] + B[2,2]*data[2,:]
+    return dnew
+
+@njit(f8[:](f8[:], f8[:]), cache=True, fastmath=True, nogil=True)
+def cross(a: np.ndarray, b: np.ndarray):
+    crossv = np.empty((3,), dtype=np.float64)
+    crossv[0] = a[1]*b[2] - a[2]*b[1]
+    crossv[1] = a[2]*b[0] - a[0]*b[2]
+    crossv[2] = a[0]*b[1] - a[1]*b[0]
+    return crossv
+
+@njit(cache=True, nogil=True)
+def normalize(a: np.ndarray):
+    return a/((a[0]**2 + a[1]**2 + a[2]**2)**0.5)
+
+
+############################################################
+#              GAUSS QUADRATURE IMPLEMENTATION             #
+############################################################
+
+@njit(c16(c16[:], c16[:], types.Array(types.float64, 1, 'A', readonly=True)), cache=True, nogil=True)
+def _gqi(v1, v2, W):
+    return np.sum(v1*v2*W)
+
+
+############################################################
+#                BASIS FUNCTION DERIVATIVES               #
+############################################################
+
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True)
+def _curl_edge_1(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out = -3*a1*b1*c2 + 3*a1*b2*c1 - 3*b1**2*c2*xs + 3*b1*b2*c1*xs - 3*b1*c1*c2*ys + 3*b2*c1**2*ys + 0j
+    return out
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True)
+def _curl_edge_2(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out = -3*a2*b1*c2 + 3*a2*b2*c1 - 3*b1*b2*c2*xs - 3*b1*c2**2*ys + 3*b2**2*c1*xs + 3*b2*c1*c2*ys + 0j
+    return out
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True)
+def _curl_face_1(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    a3, b3, c3 = coeff[:,2]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out = -b2*(c1*(a3 + b3*xs + c3*ys) - c3*(a1 + b1*xs + c1*ys)) + c2*(b1*(a3 + b3*xs + c3*ys) - b3*(a1 + b1*xs + c1*ys)) + 2*(b1*c3 - b3*c1)*(a2 + b2*xs + c2*ys) + 0j
+    return out
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True)
+def _curl_face_2(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    a3, b3, c3 = coeff[:,2]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out = b3*(c1*(a2 + b2*xs + c2*ys) - c2*(a1 + b1*xs + c1*ys)) - c3*(b1*(a2 + b2*xs + c2*ys) - b2*(a1 + b1*xs + c1*ys)) - 2*(b1*c2 - b2*c1)*(a3 + b3*xs + c3*ys) + 0j
+    return out
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True)
+def _divergence_edge_1(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out = b1*(b1*(a2 + b2*xs + c2*ys) - b2*(a1 + b1*xs + c1*ys)) + c1*(c1*(a2 + b2*xs + c2*ys) - c2*(a1 + b1*xs + c1*ys)) + 0j
+    return out
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True)
+def _divergence_edge_2(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out = b2*(b1*(a2 + b2*xs + c2*ys) - b2*(a1 + b1*xs + c1*ys)) + c2*(c1*(a2 + b2*xs + c2*ys) - c2*(a1 + b1*xs + c1*ys)) + 0j
+    return out
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True)
+def _divergence_face_1(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    a3, b3, c3 = coeff[:,2]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out = -b2*(b1*(a3 + b3*xs + c3*ys) - b3*(a1 + b1*xs + c1*ys)) - c2*(c1*(a3 + b3*xs + c3*ys) - c3*(a1 + b1*xs + c1*ys)) + 0j
+    return out
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True)
+def _divergence_face_2(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    a3, b3, c3 = coeff[:,2]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out = b3*(b1*(a2 + b2*xs + c2*ys) - b2*(a1 + b1*xs + c1*ys)) + c3*(c1*(a2 + b2*xs + c2*ys) - c2*(a1 + b1*xs + c1*ys)) + 0j
+    return out
+
+############################################################
+#     TRIANGLE BARYCENTRIC COORDINATE LIN. COEFFICIENTS    #
+############################################################
+
+
+@njit(types.Tuple((f8[:], f8[:], f8[:], f8))(f8[:], f8[:]), cache = True, nogil=True)
+def tri_coefficients(vxs, vys):
+
+    x1, x2, x3 = vxs
+    y1, y2, y3 = vys
+
+    a1 = x2*y3-y2*x3
+    a2 = x3*y1-y3*x1
+    a3 = x1*y2-y1*x2
+    b1 = y2-y3
+    b2 = y3-y1
+    b3 = y1-y2
+    c1 = x3-x2
+    c2 = x1-x3
+    c3 = x2-x1
+
+    sA = 0.5*(((x1-x3)*(y2-y1) - (x1-x2)*(y3-y1)))
+    sign = np.sign(sA)
+    A = np.abs(sA)
+    As = np.array([a1, a2, a3])*sign
+    Bs = np.array([b1, b2, b3])*sign
+    Cs = np.array([c1, c2, c3])*sign
+    return As, Bs, Cs, A
+
+
+############################################################
+#                  GAUSS QUADRATURE POINTS                 #
+############################################################
+
+
+DPTS = np.array([[0.22338159, 0.22338159, 0.22338159, 0.10995174, 0.10995174, 0.10995174],
+                 [0.10810302, 0.44594849, 0.44594849, 0.81684757, 0.09157621, 0.09157621],
+                 [0.44594849, 0.44594849, 0.10810302, 0.09157621, 0.09157621, 0.81684757],
+                 [0.44594849, 0.10810302, 0.44594849, 0.09157621, 0.81684757, 0.09157621]], dtype=np.float64)
+
+
+############################################################
+#                 NUMBA OPTIMIZED ASSEMBLER                #
+############################################################
+
+
+@njit(c16[:,:](f8[:,:], i8[:,:], c16), cache=True, nogil=True)
+def _abc_order_2_terms(tri_vertices, local_edge_map, cf):
+    '''ABC order 2 tangent gradient term'''
+    
+    origin = tri_vertices[:,0]
+    vertex_2 = tri_vertices[:,1]
+    vertex_3 = tri_vertices[:,2]
+    
+    edge_1 = vertex_2-origin
+    edge_2 = vertex_3-origin
+    
+    zhat = normalize(cross(edge_1, edge_2))
+    xhat = normalize(edge_1)
+    yhat = normalize(cross(zhat, xhat))
+    
+    basis = np.zeros((3,3), dtype=np.float64)
+    basis[0,:] = xhat
+    basis[1,:] = yhat
+    basis[2,:] = zhat
+    
+    local_vertices = optim_matmul(basis, tri_vertices - origin[:,np.newaxis])
+    
+    CurlMatrix = np.zeros((8,8), dtype=np.complex128)
+    DivMatrix = np.zeros((8,8), dtype=np.complex128)
+    
+    Lengths = np.ones((8,8), dtype=np.float64)
+
+    WEIGHTS = DPTS[0,:]
+    DPTS1 = DPTS[1,:]
+    DPTS2 = DPTS[2,:]
+    DPTS3 = DPTS[3,:]
+
+    xpts = local_vertices[0,:]
+    ypts = local_vertices[1,:]
+
+    distances = compute_distances(xpts, ypts, 0*xpts)
+
+    xs = xpts[0]*DPTS1 + xpts[1]*DPTS2 + xpts[2]*DPTS3
+    ys = ypts[0]*DPTS1 + ypts[1]*DPTS2 + ypts[2]*DPTS3
+    
+    int_coords = np.empty((2,xs.shape[0]), dtype=np.float64)
+    int_coords[0,:] = xs
+    int_coords[1,:] = ys
+
+    aas, bbs, ccs, Area = tri_coefficients(xpts, ypts)
+    
+    bary_coeff = np.empty((3,3), dtype=np.float64)
+    bary_coeff[0,:] = aas/(2*Area)
+    bary_coeff[1,:] = bbs/(2*Area)
+    bary_coeff[2,:] = ccs/(2*Area)
+
+    Lengths[3,:] *= distances[0,2]
+    Lengths[7,:] *= distances[0,1]
+    Lengths[:,3] *= distances[0,2]
+    Lengths[:,7] *= distances[0,1]
+    
+    FF1C = _curl_face_1(bary_coeff, int_coords)
+    FF2C = _curl_face_2(bary_coeff, int_coords)
+    FF1D = _divergence_face_1(bary_coeff, int_coords)
+    FF2D = _divergence_face_2(bary_coeff, int_coords)
+    
+    for iv1 in range(3):
+        ie1 = local_edge_map[:, iv1]
+        
+        Le = distances[ie1[0], ie1[1]]
+        Lengths[iv1,:] *= Le
+        Lengths[iv1+4,:] *= Le
+        Lengths[:,iv1] *= Le
+        Lengths[:,iv1+4] *= Le
+        
+        FE1C_1 = _curl_edge_1(bary_coeff[:,ie1], int_coords)
+        FE2C_1 = _curl_edge_2(bary_coeff[:,ie1], int_coords)
+        FE1D_1 = _divergence_edge_1(bary_coeff[:,ie1], int_coords)
+        FE2D_1 = _divergence_edge_2(bary_coeff[:,ie1], int_coords)
+        
+        for iv2 in range(3):
+            ie2 = local_edge_map[:, iv2]
+            
+            FE1C_2 = _curl_edge_1(bary_coeff[:,ie2], int_coords)
+            FE2C_2 = _curl_edge_2(bary_coeff[:,ie2], int_coords)
+            FE1D_2 = _divergence_edge_1(bary_coeff[:,ie2], int_coords)
+            FE2D_2 = _divergence_edge_2(bary_coeff[:,ie2], int_coords)
+            
+            CurlMatrix[iv1, iv2]     = _gqi(FE1C_1, FE1C_2, WEIGHTS)
+            CurlMatrix[iv1, iv2+4]   = _gqi(FE1C_1, FE2C_2, WEIGHTS)
+            CurlMatrix[iv1+4, iv2]   = _gqi(FE2C_1, FE1C_2, WEIGHTS)
+            CurlMatrix[iv1+4, iv2+4] = _gqi(FE2C_1, FE2C_2, WEIGHTS)
+            
+            DivMatrix[iv1, iv2]     = _gqi(FE1D_1, FE1D_2, WEIGHTS)
+            DivMatrix[iv1, iv2+4]   = _gqi(FE1D_1, FE2D_2, WEIGHTS)
+            DivMatrix[iv1+4, iv2]   = _gqi(FE2D_1, FE1D_2, WEIGHTS)
+            DivMatrix[iv1+4, iv2+4] = _gqi(FE2D_1, FE2D_2, WEIGHTS)
+        
+        CurlMatrix[iv1,  3]      = _gqi(FE1C_1, FF1C, WEIGHTS)
+        CurlMatrix[iv1+4,3]      = _gqi(FE2C_1, FF1C, WEIGHTS)
+        CurlMatrix[iv1,  7]      = _gqi(FE1C_1, FF2C, WEIGHTS)
+        CurlMatrix[iv1+4,7]      = _gqi(FE2C_1, FF2C, WEIGHTS)
+        
+        CurlMatrix[3, iv1]   = CurlMatrix[iv1, 3]
+        CurlMatrix[3, iv1+4] = CurlMatrix[iv1+4, 3]
+        CurlMatrix[7, iv1]   = CurlMatrix[iv1, 7]
+        CurlMatrix[7, iv1+4] = CurlMatrix[iv1+4, 7]
+        
+        DivMatrix[iv1,  3]      = _gqi(FE1D_1, FF1D, WEIGHTS)
+        DivMatrix[iv1+4,3]      = _gqi(FE2D_1, FF1D, WEIGHTS)
+        DivMatrix[iv1,  7]      = _gqi(FE1D_1, FF2D, WEIGHTS)
+        DivMatrix[iv1+4,7]      = _gqi(FE2D_1, FF2D, WEIGHTS)
+        
+        DivMatrix[3, iv1]   = DivMatrix[iv1, 3]
+        DivMatrix[3, iv1+4] = DivMatrix[iv1+4, 3]
+        DivMatrix[7, iv1]   = DivMatrix[iv1, 7]
+        DivMatrix[7, iv1+4] = DivMatrix[iv1+4, 7]
+    
+    CurlMatrix[3, 3] = _gqi(FF1C, FF1C, WEIGHTS)
+    CurlMatrix[3, 7] = _gqi(FF1C, FF2C, WEIGHTS)
+    CurlMatrix[7, 3] = _gqi(FF2C, FF1C, WEIGHTS)
+    CurlMatrix[7, 7] = _gqi(FF2C, FF2C, WEIGHTS)
+    
+    DivMatrix[3, 3] = _gqi(FF1D, FF1D, WEIGHTS)
+    DivMatrix[3, 7] = _gqi(FF1D, FF2D, WEIGHTS)
+    DivMatrix[7, 3] = _gqi(FF2D, FF1D, WEIGHTS)
+    DivMatrix[7, 7] = _gqi(FF2D, FF2D, WEIGHTS)
+    
+    Mat = cf*Lengths*(CurlMatrix-DivMatrix)*np.abs(Area)
+    return Mat
+
+
+############################################################
+#            NUMBA OPTIMIZED INTEGRAL OVER TETS            #
+############################################################
+
+@njit((c16[:])(f8[:,:],
+            i8[:,:], 
+            i8[:,:], 
+            i8[:,:],
+            i8[:],
+            c16), cache=True, nogil=True, parallel=True)
+def _matrix_builder(nodes, tris, edges, tri_to_field, tri_ids, coeff):
+    """ Numba optimized loop over each face triangle."""
+    ntritot = tris.shape[1]
+    nnz = ntritot*64
+    
+    Mat = np.zeros(nnz, dtype=np.complex128)
+
+    tri_to_edge = tri_to_field[:3,:]
+    
+    Ntris = tri_ids.shape[0]
+    for itri_sub in prange(Ntris): # type: ignore
+        
+        itri = tri_ids[itri_sub]
+        p = itri*64
+
+        # Construct a local mapping to global triangle orientations
+        local_tri_map = local_tri_to_edgeid(itri, tris, edges, tri_to_edge)
+
+        # Construct the local edge map
+        tri_nodes = nodes[:, tris[:,itri]]
+        subMat = _abc_order_2_terms(tri_nodes, local_tri_map, coeff)
+
+        Mat[p:p+64] += subMat.ravel()
+        
+    return Mat
+
+############################################################
+#                     PYTHON INTERFACE                     #
+############################################################
+
+    
+def abc_order_2_matrix(field: Nedelec2,
+                       surf_triangle_indices: np.ndarray,
+                       coeff: complex) -> np.ndarray:
+    """Computes the second order absorbing boundary condition correction terms.
+
+    Args:
+        field (Nedelec2): The Basis function object
+        surf_triangle_indices (np.ndarray): The surface triangle indices to add
+        coeff (complex): The integral coefficient jp2/k0
+
+    Returns:
+        np.ndarray: The resultant matrix items
+    """
+    Mat = _matrix_builder(field.mesh.nodes, field.mesh.tris, field.mesh.edges, field.tri_to_field, surf_triangle_indices, coeff)
+    return Mat

emerge/_emerge/physics/microwave/assembly/robinbc.py

@@ -312,34 +312,31 @@ def compute_bc_entries_excited(vertices_global, tris, Bmat, Bvec, surf_triangle_
 
 
 @njit(c16[:,:](f8[:,:], f8[:], c16), cache=True, nogil=True, parallel=False)
-def ned2_tri_stiff(vertices, edge_lengths, gamma):
+def ned2_tri_stiff(glob_vertices, edge_lengths, gamma):
     ''' Nedelec-2 Triangle Stiffness matrix and forcing vector (For Boundary Condition of the Third Kind)
 
     '''
     local_edge_map = np.array([[0,1,0],[1,2,2]])
     Bmat = np.zeros((8,8), dtype=np.complex128)
 
-    xs = vertices[0,:]
-    ys = vertices[1,:]
-    zs = vertices[2,:]
-
-    ax1 = np.array([xs[1]-xs[0], ys[1]-ys[0], zs[1]-zs[0]])
-    ax2 = np.array([xs[2]-xs[0], ys[2]-ys[0], zs[2]-zs[0]])
-    ax1 = ax1/np.linalg.norm(ax1)
-    ax2 = ax2/np.linalg.norm(ax2)
-
-    axn = cross(ax1, ax2)
-    ax2 = -cross(axn, ax1)
+    orig = glob_vertices[:,0]
+    v2 = glob_vertices[:,1]
+    v3 = glob_vertices[:,2]
+    
+    e1 = v2-orig
+    e2 = v3-orig
+    zhat = normalize(cross(e1, e2))
+    xhat = normalize(e1)
+    yhat = normalize(cross(zhat, xhat))
     basis = np.zeros((3,3), dtype=np.float64)
-    basis[:,0] = ax1
-    basis[:,1] = ax2
-    basis[:,2] = axn
-    basis = np.linalg.pinv(basis)
-    lcs_vertices = basis @ np.ascontiguousarray(vertices)
-
+    basis[0,:] = xhat
+    basis[1,:] = yhat
+    basis[2,:] = zhat
+    lcs_vertices = optim_matmul(basis, glob_vertices - orig[:,np.newaxis])
+    
     xs = lcs_vertices[0,:]
     ys = lcs_vertices[1,:]
-
+    
     x1, x2, x3 = xs
     y1, y2, y3 = ys
 
@@ -359,7 +356,7 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
     GLs = (GL1, GL2, GL3)
 
     Area = 0.5 * np.abs((x1 - x3) * (y2 - y1) - (x1 - x2) * (y3 - y1))
-
+    
     letters = [1,2,3,4,5,6]
 
     tA, tB, tC = letters[0], letters[1], letters[2]
@@ -367,11 +364,12 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
     
     Lt1, Lt2 = Ds[2, 0], Ds[1, 0]
     
+
     COEFF = gamma/(2*Area)**2
     AREA_COEFF = AREA_COEFF_CACHE_BASE * Area
     for ei in range(3):
         ei1, ei2 = local_edge_map[:, ei]
-        Li = edge_lengths[ei]
+        Li = Ds[ei1, ei2]
         
         A = letters[ei1]
         B = letters[ei2]
@@ -381,24 +379,25 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
 
         for ej in range(3):
             ej1, ej2 = local_edge_map[:, ej]
-            Lj = edge_lengths[ej]
+            Lj = Ds[ej1, ej2]
 
             C = letters[ej1]
             D = letters[ej2]
 
             GC = GLs[ej1]
             GD = GLs[ej2]
+
             DAC = dot(GA,GC)
             DAD = dot(GA,GD)
             DBC = dot(GB,GC)
             DBD = dot(GB,GD)
             LL = Li*Lj
-
-            Bmat[ei,ej] += LL*COEFF*(AREA_COEFF[A,B,C,D]*DAC-AREA_COEFF[A,B,C,C]*DAD-AREA_COEFF[A,A,C,D]*DBC+AREA_COEFF[A,A,C,C]*DBD)
-            Bmat[ei,ej+4] += LL*COEFF*(AREA_COEFF[A,B,D,D]*DAC-AREA_COEFF[A,B,C,D]*DAD-AREA_COEFF[A,A,D,D]*DBC+AREA_COEFF[A,A,C,D]*DBD)
-            Bmat[ei+4,ej] += LL*COEFF*(AREA_COEFF[B,B,C,D]*DAC-AREA_COEFF[B,B,C,C]*DAD-AREA_COEFF[A,B,C,D]*DBC+AREA_COEFF[A,B,C,C]*DBD)
-            Bmat[ei+4,ej+4] += LL*COEFF*(AREA_COEFF[B,B,D,D]*DAC-AREA_COEFF[B,B,C,D]*DAD-AREA_COEFF[A,B,D,D]*DBC+AREA_COEFF[A,B,C,D]*DBD)
-        
+            
+            Bmat[ei,ej] += LL*(AREA_COEFF[A,B,C,D]*DAC-AREA_COEFF[A,B,C,C]*DAD-AREA_COEFF[A,A,C,D]*DBC+AREA_COEFF[A,A,C,C]*DBD)
+            Bmat[ei,ej+4] += LL*(AREA_COEFF[A,B,D,D]*DAC-AREA_COEFF[A,B,C,D]*DAD-AREA_COEFF[A,A,D,D]*DBC+AREA_COEFF[A,A,C,D]*DBD)
+            Bmat[ei+4,ej] += LL*(AREA_COEFF[B,B,C,D]*DAC-AREA_COEFF[B,B,C,C]*DAD-AREA_COEFF[A,B,C,D]*DBC+AREA_COEFF[A,B,C,C]*DBD)
+            Bmat[ei+4,ej+4] += LL*(AREA_COEFF[B,B,D,D]*DAC-AREA_COEFF[B,B,C,D]*DAD-AREA_COEFF[A,B,D,D]*DBC+AREA_COEFF[A,B,C,D]*DBD)
+            
         FA = dot(GA,GtC)
         FB = dot(GA,GtA)
         FC = dot(GB,GtC)
@@ -406,15 +405,15 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
         FE = dot(GA,GtB)
         FF = dot(GB,GtB)
 
-        Bmat[ei,3] += Li*Lt1*COEFF*(AREA_COEFF[A,B,tA,tB]*FA-AREA_COEFF[A,B,tB,tC]*FB-AREA_COEFF[A,A,tA,tB]*FC+AREA_COEFF[A,A,tB,tC]*FD)
-        Bmat[ei,7] += Li*Lt2*COEFF*(AREA_COEFF[A,B,tB,tC]*FB-AREA_COEFF[A,B,tC,tA]*FE-AREA_COEFF[A,A,tB,tC]*FD+AREA_COEFF[A,A,tC,tA]*FF)
-        Bmat[3,ei] += Lt1*Li*COEFF*(AREA_COEFF[tA,tB,A,B]*FA-AREA_COEFF[tA,tB,A,A]*FC-AREA_COEFF[tB,tC,A,B]*FB+AREA_COEFF[tB,tC,A,A]*FD)
-        Bmat[7,ei] += Lt2*Li*COEFF*(AREA_COEFF[tB,tC,A,B]*FB-AREA_COEFF[tB,tC,A,A]*FD-AREA_COEFF[tC,tA,A,B]*FE+AREA_COEFF[tC,tA,A,A]*FF)
-        Bmat[ei+4,3] += Li*Lt1*COEFF*(AREA_COEFF[B,B,tA,tB]*FA-AREA_COEFF[B,B,tB,tC]*FB-AREA_COEFF[A,B,tA,tB]*FC+AREA_COEFF[A,B,tB,tC]*FD)
-        Bmat[ei+4,7] += Li*Lt2*COEFF*(AREA_COEFF[B,B,tB,tC]*FB-AREA_COEFF[B,B,tC,tA]*FE-AREA_COEFF[A,B,tB,tC]*FD+AREA_COEFF[A,B,tC,tA]*FF)
-        Bmat[3,ei+4] += Lt1*Li*COEFF*(AREA_COEFF[tA,tB,B,B]*FA-AREA_COEFF[tA,tB,A,B]*FC-AREA_COEFF[tB,tC,B,B]*FB+AREA_COEFF[tB,tC,A,B]*FD)
-        Bmat[7,ei+4] += Lt2*Li*COEFF*(AREA_COEFF[tB,tC,B,B]*FB-AREA_COEFF[tB,tC,A,B]*FD-AREA_COEFF[tC,tA,B,B]*FE+AREA_COEFF[tC,tA,A,B]*FF)
-      
+        Bmat[ei,3] += Li*Lt1*(AREA_COEFF[A,B,tA,tB]*FA-AREA_COEFF[A,B,tB,tC]*FB-AREA_COEFF[A,A,tA,tB]*FC+AREA_COEFF[A,A,tB,tC]*FD)
+        Bmat[ei,7] += Li*Lt2*(AREA_COEFF[A,B,tB,tC]*FB-AREA_COEFF[A,B,tC,tA]*FE-AREA_COEFF[A,A,tB,tC]*FD+AREA_COEFF[A,A,tC,tA]*FF)
+        Bmat[3,ei] += Lt1*Li*(AREA_COEFF[tA,tB,A,B]*FA-AREA_COEFF[tA,tB,A,A]*FC-AREA_COEFF[tB,tC,A,B]*FB+AREA_COEFF[tB,tC,A,A]*FD)
+        Bmat[7,ei] += Lt2*Li*(AREA_COEFF[tB,tC,A,B]*FB-AREA_COEFF[tB,tC,A,A]*FD-AREA_COEFF[tC,tA,A,B]*FE+AREA_COEFF[tC,tA,A,A]*FF)
+        Bmat[ei+4,3] += Li*Lt1*(AREA_COEFF[B,B,tA,tB]*FA-AREA_COEFF[B,B,tB,tC]*FB-AREA_COEFF[A,B,tA,tB]*FC+AREA_COEFF[A,B,tB,tC]*FD)
+        Bmat[ei+4,7] += Li*Lt2*(AREA_COEFF[B,B,tB,tC]*FB-AREA_COEFF[B,B,tC,tA]*FE-AREA_COEFF[A,B,tB,tC]*FD+AREA_COEFF[A,B,tC,tA]*FF)
+        Bmat[3,ei+4] += Lt1*Li*(AREA_COEFF[tA,tB,B,B]*FA-AREA_COEFF[tA,tB,A,B]*FC-AREA_COEFF[tB,tC,B,B]*FB+AREA_COEFF[tB,tC,A,B]*FD)
+        Bmat[7,ei+4] += Lt2*Li*(AREA_COEFF[tB,tC,B,B]*FB-AREA_COEFF[tB,tC,A,B]*FD-AREA_COEFF[tC,tA,B,B]*FE+AREA_COEFF[tC,tA,A,B]*FF)
+    
     H1 = dot(GtA,GtC)
     H2 = dot(GtA,GtA)
     H3 = dot(GtA,GtB)
@@ -423,8 +422,8 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
     Bmat[3,7] += Lt1*Lt2*(AREA_COEFF[tA,tB,tB,tC]*H1-AREA_COEFF[tA,tB,tC,tA]*dot(GtB,GtC)-AREA_COEFF[tB,tC,tB,tC]*H2+AREA_COEFF[tB,tC,tC,tA]*H3)
     Bmat[7,3] += Lt2*Lt1*(AREA_COEFF[tB,tC,tA,tB]*H1-AREA_COEFF[tB,tC,tB,tC]*H2-AREA_COEFF[tC,tA,tA,tB]*dot(GtB,GtC)+AREA_COEFF[tC,tA,tB,tC]*H3)
     Bmat[7,7] += Lt2*Lt2*(AREA_COEFF[tB,tC,tB,tC]*H2-AREA_COEFF[tB,tC,tC,tA]*H3-AREA_COEFF[tC,tA,tB,tC]*H3+AREA_COEFF[tC,tA,tC,tA]*dot(GtB,GtB))
-    
 
+    Bmat = Bmat * COEFF
     return Bmat
 
 @njit(c16[:](f8[:,:], i8[:,:], c16[:], f8[:,:], i8[:], c16), cache=True, nogil=True, parallel=False)

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -25,7 +25,6 @@ from ...elements.nedelec2 import Nedelec2
 from ...solver import DEFAULT_ROUTINE, SolveRoutine
 from ...system import called_from_main_function
 from ...selection import FaceSelection
-from ...mth.optimized import compute_distances
 from ...settings import Settings
 from .microwave_bc import MWBoundaryConditionSet, PEC, ModalPort, LumpedPort, PortBC
 from .microwave_data import MWData
@@ -101,21 +100,6 @@ def shortest_path(xyz1: np.ndarray, xyz2: np.ndarray, Npts: int) -> np.ndarray:
     path = (1 - t) * p1[:, np.newaxis] + t * p2[:, np.newaxis]
 
     return path
-
-def _pick_central(vertices: np.ndarray) -> np.ndarray:
-    """Computes the coordinate in the vertex set that has the shortest square distance to all other points.
-    
-
-    Args:
-        vertices (np.ndarray): The set of coordinates [3,:]
-
-    Returns:
-        np.ndarray: The most central point
-    """
-    Ds = compute_distances(vertices[0,:], vertices[1,:], vertices[2,:])
-    sumDs = np.sum(Ds**2, axis=1)
-    id_central = np.argwhere(sumDs==np.min(sumDs)).flatten()[0]
-    return vertices[:, id_central].squeeze()
     
 class Microwave3D:
     """The Electrodynamics time harmonic physics class.
@@ -248,6 +232,14 @@ class Microwave3D:
         self.set_frequency(np.linspace(fmin, fmax, Npoints))
     
     def fdense(self, Npoints: int) -> np.ndarray:
+        """Return a resampled version of the current frequency range
+
+        Args:
+            Npoints (int): The new number of points
+
+        Returns:
+            np.ndarray: The new frequency axis
+        """
         if len(self.frequencies) == 1:
             raise ValueError('Only 1 frequency point known. At least two need to be defined.')
         fmin = min(self.frequencies)
@@ -497,7 +489,7 @@ class Microwave3D:
         if freq is None:
             freq = self.frequencies[0]
         
-        materials = self.mesh.retreive(self.mesher.volumes)
+        materials = self.mesh._get_material_assignment(self.mesher.volumes)
 
         ertet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
         tandtet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
@@ -655,7 +647,7 @@ class Microwave3D:
         if self.basis is None:
             raise SimulationError('Cannot proceed, the simulation basis class is undefined.')
 
-        materials = self.mesh.retreive(self.mesher.volumes)
+        materials = self.mesh._get_material_assignment(self.mesher.volumes)
 
         ### Does this move
         logger.debug('Initializing frequency domain sweep.')
@@ -853,7 +845,7 @@ class Microwave3D:
         if self.basis is None:
             raise SimulationError('Cannot proceed. The simulation basis class is undefined.')
 
-        materials = self.mesh.retreive(self.mesher.volumes)
+        materials = self.mesh._get_material_assignment(self.mesher.volumes)
         
         # er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
         # ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -19,19 +19,17 @@ from __future__ import annotations
 import numpy as np
 from loguru import logger
 from typing import Callable, Literal
+from dataclasses import dataclass
+from collections import defaultdict
 from ...selection import Selection, FaceSelection
 from ...cs import CoordinateSystem, Axis, GCS, _parse_axis
 from ...coord import Line
 from ...geometry import GeoSurface, GeoObject
-from dataclasses import dataclass
-from collections import defaultdict
 from ...bc import BoundaryCondition, BoundaryConditionSet, Periodic
 from ...periodic import PeriodicCell, HexCell, RectCell
 from ...material import Material
 from ...const import Z0, C0, EPS0, MU0
 
-
-
 ############################################################
 #                     UTILITY FUNCTIONS                    #
 ############################################################
@@ -98,6 +96,15 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         self._cell._ports.append(port)
         return port
 
+    # Checks
+    def _is_excited(self) -> bool:
+        for bc in self.boundary_conditions:
+            if not isinstance(bc, RobinBC):
+                continue
+            if bc._include_force:
+                return True
+            
+        return False
 
 ############################################################
 #                    BOUNDARY CONDITIONS                   #
@@ -125,6 +132,7 @@ class RobinBC(BoundaryCondition):
     _include_stiff: bool = False
     _include_mass: bool = False
     _include_force: bool = False
+    _isabc: bool = False
 
     def __init__(self, selection: GeoSurface | Selection):
         """A Generalization of any boundary condition of the third kind (Robin).
@@ -264,11 +272,13 @@ class AbsorbingBoundary(RobinBC):
     _include_stiff: bool = True
     _include_mass: bool = True
     _include_force: bool = False
-
+    _isabc: bool = True
+    
     def __init__(self,
                  face: FaceSelection | GeoSurface,
-                 order: int = 1,
-                 origin: tuple | None = None):
+                 order: int = 2,
+                 origin: tuple | None = None,
+                 abctype: Literal['A','B','C','D','E'] = 'B'):
         """Creates an AbsorbingBoundary condition.
 
         Currently only a first order boundary condition is possible. Second order will be supported later.
@@ -286,7 +296,15 @@ class AbsorbingBoundary(RobinBC):
         self.order: int = order
         self.origin: tuple = origin
         self.cs: CoordinateSystem = GCS
-
+        
+        self.abctype: Literal['A','B','C','D','E']  = abctype
+        self.o2coeffs: tuple[float, float] = {'A': (1.0, -0.5),
+                                              'B': (1.00023, -0.51555),
+                                              'C': (1.03084, -0.73631),
+                                              'D': (1.06103, -0.84883),
+                                              'E': (1.12500, -1.00000)
+                                              }
+        
     def get_basis(self) -> np.ndarray:
         return np.eye(3)
 
@@ -306,15 +324,10 @@ class AbsorbingBoundary(RobinBC):
         Returns:
             complex: The γ-constant
         """
-        if self.order == 2:
-            
-            p0 = 1.06103
-            p2 = -0.84883
-            ky = k0*0.5
-            return 1j*k0*p0 - 1j*p2*ky**2/k0
-        else:
-            Factor = 1
-            return 1j*self.get_beta(k0)*Factor
+        if self.order==1:
+            return 1j*k0
+        
+        return 1j*k0*self.o2coeffs[self.abctype][0]
     
    
 @dataclass