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

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

@@ -0,0 +1,465 @@
+# 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.nedleg2 import NedelecLegrange2
+from scipy.sparse import csr_matrix
+from numba_progress import ProgressBar, ProgressBarType
+from ....mth.optimized import local_mapping, matinv, compute_distances, gaus_quad_tri
+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)
+
+
+
+############################################################
+#                     PYTHON INTERFACE                     #
+############################################################
+
+def generelized_eigenvalue_matrix(field: NedelecLegrange2,
+                           er: np.ndarray, 
+                           ur: np.ndarray,
+                           basis: np.ndarray,
+                           k0: float,) -> tuple[csr_matrix, csr_matrix]:
+    
+    tris = field.mesh.tris
+    edges = field.mesh.edges
+    nodes = field.mesh.nodes
+    
+    nT = tris.shape[1]
+    tri_to_field = field.tri_to_field
+
+    nodes = field.local_nodes
+    
+    with ProgressBar(total=nT, ncols=100, dynamic_ncols=False) as pgb:
+        dataE, dataB, rows, cols = _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0, pgb)
+    
+    nfield = field.n_field
+
+    E = csr_matrix((dataE, (rows, cols)), shape=(nfield, nfield))
+    B = csr_matrix((dataB, (rows, cols)), shape=(nfield, nfield))
+
+    return E, B
+
+
+############################################################
+#                   MATRIX MULTIPLICATION                  #
+############################################################
+
+@njit(c16[:,:](c16[:,:], c16[:,:]), cache=True, nogil=True)
+def matmul(a, b):
+    out = np.empty((2,b.shape[1]), dtype=np.complex128)
+    out[0,:] = a[0,0]*b[0,:] + a[0,1]*b[1,:]
+    out[1,:] = a[1,0]*b[0,:] + a[1,1]*b[1,:]
+    return out
+
+
+############################################################
+#              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)
+
+@njit(c16(c16[:,:], c16[:,:], types.Array(types.float64, 1, 'A', readonly=True)), cache=True, nogil=True)
+def _gqi2(v1, v2, W):
+    return np.sum(W*np.sum(v1*v2,axis=0))
+
+@njit(c16[:,:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _ne1(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out=np.empty((2,xs.shape[0]), dtype=np.complex128)
+    out[0,:] = (-b1*(a2 + b2*xs + c2*ys) + b2*(a1 + b1*xs + c1*ys))
+    out[1,:] = (-c1*(a2 + b2*xs + c2*ys) + c2*(a1 + b1*xs + c1*ys))
+    return out
+
+@njit(c16[:,:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _ne2(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out=np.empty((2,xs.shape[0]), dtype=np.complex128)
+    out[0,:] = (-b1*(a2 + b2*xs + c2*ys) + b2*(a1 + b1*xs + c1*ys))*(a1 - a2 + b1*xs - b2*xs + c1*ys - c2*ys)
+    out[1,:] = (-c1*(a2 + b2*xs + c2*ys) + c2*(a1 + b1*xs + c1*ys))*(a1 - a2 + b1*xs - b2*xs + c1*ys - c2*ys)
+    return out
+
+@njit(c16[:,:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _nf1(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    a3, b3, c3 = coeff[:,2]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out=np.empty((2,xs.shape[0]), dtype=np.complex128)
+    out[0,:] = -(b1*(a3 + b3*xs + c3*ys) - b3*(a1 + b1*xs + c1*ys))*(a2 + b2*xs + c2*ys) - (b2*(a3 + b3*xs + c3*ys) - b3*(a2 + b2*xs + c2*ys))*(a1 + b1*xs + c1*ys)
+    out[1,:] = -(c1*(a3 + b3*xs + c3*ys) - c3*(a1 + b1*xs + c1*ys))*(a2 + b2*xs + c2*ys) + (-c2*(a3 + b3*xs + c3*ys) + c3*(a2 + b2*xs + c2*ys))*(a1 + b1*xs + c1*ys)
+    return out
+
+@njit(c16[:,:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _nf2(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    a3, b3, c3 = coeff[:,2]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out=np.empty((2,xs.shape[0]), dtype=np.complex128)
+    out[0,:] = (b1*(a2 + b2*xs + c2*ys) - b2*(a1 + b1*xs + c1*ys))*(a3 + b3*xs + c3*ys) + (b1*(a3 + b3*xs + c3*ys) - b3*(a1 + b1*xs + c1*ys))*(a2 + b2*xs + c2*ys)
+    out[1,:] = -(-c1*(a2 + b2*xs + c2*ys) + c2*(a1 + b1*xs + c1*ys))*(a3 + b3*xs + c3*ys) + (c1*(a3 + b3*xs + c3*ys) - c3*(a1 + b1*xs + c1*ys))*(a2 + b2*xs + c2*ys)
+    return out
+
+@njit(c16[:](f8[:], f8[:,:]), cache=True, nogil=True)
+def _lv(coeff, coords):
+    a1, b1, c1 = coeff
+    xs = coords[0,:]
+    ys = coords[1,:]
+    return -a1 - b1*xs - c1*ys + 2*(a1 + b1*xs + c1*ys)**2 + 0*1j
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _le(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    return 4*(a1 + b1*xs + c1*ys)*(a2 + b2*xs + c2*ys)+ 0*1j
+
+@njit(c16[:,:](f8[:], f8[:,:]), cache=True, nogil=True)
+def _lv_grad(coeff, coords):
+    a1, b1, c1 = coeff
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out=np.empty((2,xs.shape[0]), dtype=np.complex128)
+    out[0,:] = b1*(4*a1 + 4*b1*xs + 4*c1*ys - 1)
+    out[1,:] = c1*(4*a1 + 4*b1*xs + 4*c1*ys - 1)
+    return out
+
+@njit(c16[:,:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _le_grad(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    out=np.empty((2,xs.shape[0]), dtype=np.complex128)
+    out[0,:] = 4*b1*(a2 + b2*xs + c2*ys) + 4*b2*(a1 + b1*xs + c1*ys)
+    out[1,:] = 4*c1*(a2 + b2*xs + c2*ys) + 4*c2*(a1 + b1*xs + c1*ys)
+    return out
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _ne1_curl(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    return (2*b1*c2 - 2*b2*c1)*np.ones_like(xs) + 0j#-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
+
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _ne2_curl(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    return (-(b1 - b2)*(c1*(a2 + b2*xs + c2*ys) - c2*(a1 + b1*xs + c1*ys)) + (c1 - c2)*(b1*(a2 + b2*xs + c2*ys) - b2*(a1 + b1*xs + c1*ys)) + 2*(b1*c2 - b2*c1)*(a1 - a2 + b1*xs - b2*xs + c1*ys - c2*ys)) + 0j
+
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _nf1_curl(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    a3, b3, c3 = coeff[:,2]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    return 3*a1*b2*c3 - 3*a1*b3*c2 + 3*a2*b1*c3 - 3*a2*b3*c1 + 6*b1*b2*c3*xs - 3*b1*b3*c2*xs + 3*b1*c2*c3*ys - 3*b2*b3*c1*xs + 3*b2*c1*c3*ys - 6*b3*c1*c2*ys + 0*1j
+           
+@njit(c16[:](f8[:,:], f8[:,:]), cache=True, nogil=True)
+def _nf2_curl(coeff, coords):
+    a1, b1, c1 = coeff[:,0]
+    a2, b2, c2 = coeff[:,1]
+    a3, b3, c3 = coeff[:,2]
+    xs = coords[0,:]
+    ys = coords[1,:]
+    return -3*a2*b1*c3 + 3*a2*b3*c1 - 3*a3*b1*c2 + 3*a3*b2*c1 - 3*b1*b2*c3*xs - 3*b1*b3*c2*xs - 6*b1*c2*c3*ys + 6*b2*b3*c1*xs + 3*b2*c1*c3*ys + 3*b3*c1*c2*ys + 0*1j
+           
+
+############################################################
+#     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
+
+    #A = 0.5*(b1*c2 - b2*c1)
+    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
+
+
+############################################################
+#                    CONSTANT DEFINITION                   #
+############################################################
+
+
+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(types.Tuple((c16[:,:], c16[:,:]))(f8[:,:], i8[:,:], c16[:,:], c16[:,:], f8), cache=True, nogil=True)
+def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
+    '''Nedelec-2 Triangle stiffness and mass submatrix'''
+    Att = np.zeros((8,8), dtype=np.complex128)
+    Btt = np.zeros((8,8), dtype=np.complex128)
+
+    Dtt = np.zeros((8,8), dtype=np.complex128)
+    Dzt = np.zeros((6,8), dtype=np.complex128)
+
+    Dzz1 = np.zeros((6,6), dtype=np.complex128)
+    Dzz2 = np.zeros((6,6), dtype=np.complex128)
+    
+    Ls = np.ones((14,14), dtype=np.float64)
+
+    WEIGHTS = DPTS[0,:]
+    DPTS1 = DPTS[1,:]
+    DPTS2 = DPTS[2,:]
+    DPTS3 = DPTS[3,:]
+
+    txs = tri_vertices[0,:]
+    tys = tri_vertices[1,:]
+
+    Ds = compute_distances(txs, tys, 0*txs)
+
+    xs = txs[0]*DPTS1 + txs[1]*DPTS2 + txs[2]*DPTS3
+    ys = tys[0]*DPTS1 + tys[1]*DPTS2 + tys[2]*DPTS3
+    
+    cs = np.empty((2,xs.shape[0]), dtype=np.float64)
+    cs[0,:] = xs
+    cs[1,:] = ys
+
+    aas, bbs, ccs, Area = tri_coefficients(txs, tys)
+
+    coeff = np.empty((3,3), dtype=np.float64)
+    coeff[0,:] = aas/(2*Area)
+    coeff[1,:] = bbs/(2*Area)
+    coeff[2,:] = ccs/(2*Area)
+
+    Msz = Ms[2,2]
+    Mmz = Mm[2,2]
+    Ms = Ms[:2,:2]
+    Mm = Mm[:2,:2]
+
+    Ls[3,:] *= Ds[0,2]
+    Ls[7,:] *= Ds[0,1]
+    Ls[:,3] *= Ds[0,2]
+    Ls[:,7] *= Ds[0,1]
+    
+    for iv1 in range(3):
+        ie1 = local_edge_map[:, iv1]
+        
+        Le = Ds[ie1[0], ie1[1]]
+        Ls[iv1,:] *= Le
+        Ls[:,iv1] *= Le
+        Ls[iv1+4,:] *= Le
+        Ls[:,iv1+4] *= Le
+        F1 = _ne1_curl(coeff[:,ie1], cs)
+        F2 = _ne2_curl(coeff[:,ie1], cs)
+        F3 = _ne1(coeff[:,ie1], cs)
+        F4 = _ne2(coeff[:,ie1], cs)
+        F5 = _lv_grad(coeff[:,iv1],cs)
+        F6 = _le_grad(coeff[:,ie1],cs)
+        
+        for iv2 in range(3):
+            ei2 = local_edge_map[:, iv2]
+            
+            H1 = matmul(Ms,_ne1(coeff[:,ei2],cs))
+            H2 = matmul(Ms,_ne2(coeff[:,ei2],cs))
+            
+            Att[iv1,iv2]     = _gqi(F1, Msz * _ne1_curl(coeff[:,ei2],cs), WEIGHTS)
+            Att[iv1+4,iv2]   = _gqi(F2, Msz * _ne1_curl(coeff[:,ei2],cs), WEIGHTS)
+            Att[iv1,iv2+4]   = _gqi(F1, Msz * _ne2_curl(coeff[:,ei2],cs), WEIGHTS)
+            Att[iv1+4,iv2+4] = _gqi(F2, Msz * _ne2_curl(coeff[:,ei2],cs), WEIGHTS)
+
+            Btt[iv1,iv2]     = _gqi2(F3, matmul(Mm,_ne1(coeff[:,ei2],cs)), WEIGHTS)
+            Btt[iv1+4,iv2]   = _gqi2(F4, matmul(Mm,_ne1(coeff[:,ei2],cs)), WEIGHTS)
+            Btt[iv1,iv2+4]   = _gqi2(F3, matmul(Mm,_ne2(coeff[:,ei2],cs)), WEIGHTS)
+            Btt[iv1+4,iv2+4] = _gqi2(F4, matmul(Mm,_ne2(coeff[:,ei2],cs)), WEIGHTS)
+
+            Dtt[iv1,iv2]     = _gqi2(F3, H1, WEIGHTS)
+            Dtt[iv1+4,iv2]   = _gqi2(F4, H1, WEIGHTS)
+            Dtt[iv1,iv2+4]   = _gqi2(F3, H2, WEIGHTS)
+            Dtt[iv1+4,iv2+4] = _gqi2(F4, H2, WEIGHTS)
+
+            Dzt[iv1, iv2]     = _gqi2(F5, H1, WEIGHTS)
+            Dzt[iv1+3, iv2]   = _gqi2(F6, H1, WEIGHTS)
+            Dzt[iv1, iv2+4]   = _gqi2(F5, H2, WEIGHTS)
+            Dzt[iv1+3, iv2+4] = _gqi2(F6, H2, WEIGHTS)
+
+            Dzz1[iv1, iv2]     = _gqi2(_lv_grad(coeff[:,iv1], cs), matmul(Ms,_lv_grad(coeff[:,iv2],cs)), WEIGHTS)
+            Dzz1[iv1, iv2+3]   = _gqi2(_lv_grad(coeff[:,iv1], cs), matmul(Ms,_le_grad(coeff[:,ei2],cs)), WEIGHTS)
+            Dzz1[iv1+3, iv2]   = _gqi2(_le_grad(coeff[:,ie1], cs), matmul(Ms,_lv_grad(coeff[:,iv2],cs)), WEIGHTS)
+            Dzz1[iv1+3, iv2+3] = _gqi2(_le_grad(coeff[:,ie1], cs), matmul(Ms,_le_grad(coeff[:,ei2],cs)), WEIGHTS)
+
+            Dzz2[iv1, iv2]     = _gqi(_lv(coeff[:,iv1], cs), Mmz * _lv(coeff[:,iv2],cs), WEIGHTS)
+            Dzz2[iv1, iv2+3]   = _gqi(_lv(coeff[:,iv1], cs), Mmz * _le(coeff[:,ei2],cs), WEIGHTS)
+            Dzz2[iv1+3, iv2]   = _gqi(_le(coeff[:,ie1], cs), Mmz * _lv(coeff[:,iv2],cs), WEIGHTS)
+            Dzz2[iv1+3, iv2+3] = _gqi(_le(coeff[:,ie1], cs), Mmz * _le(coeff[:,ei2],cs), WEIGHTS)
+
+
+        G1 = matmul(Mm,_nf1(coeff,cs))
+        G2 = matmul(Mm,_nf2(coeff,cs))
+        G3 = matmul(Ms,_nf1(coeff,cs))
+        G4 = matmul(Ms,_nf2(coeff,cs))
+        
+        Att[iv1,3]   = _gqi(F1, Msz * _nf1_curl(coeff,cs), WEIGHTS)
+        Att[iv1+4,3] = _gqi(_ne2_curl(coeff[:,ie1], cs), Msz * _nf1_curl(coeff,cs), WEIGHTS)
+        Att[iv1,7]   = _gqi(F1, Msz * _nf2_curl(coeff,cs), WEIGHTS)
+        Att[iv1+4,7] = _gqi(_ne2_curl(coeff[:,ie1], cs), Msz * _nf2_curl(coeff,cs), WEIGHTS)
+        
+        Att[3, iv1]   = Att[iv1,3]
+        Att[7, iv1]   = Att[iv1,7]
+        Att[3, iv1+4] = Att[iv1+4,3]
+        Att[7, iv1+4] = Att[iv1+4,7]
+
+        Btt[iv1,3]   = _gqi2(F3, G1, WEIGHTS)
+        Btt[iv1+4,3] = _gqi2(F4, G1, WEIGHTS)
+        Btt[iv1,7]   = _gqi2(F3, G2, WEIGHTS)
+        Btt[iv1+4,7] = _gqi2(F4, G2, WEIGHTS)
+
+        Btt[3, iv1]   = Btt[iv1,3]
+        Btt[7, iv1]   = Btt[iv1,7]
+        Btt[3, iv1+4] = Btt[iv1+4,3]
+        Btt[7, iv1+4] = Btt[iv1+4,7]
+
+        Dtt[iv1,3]   = _gqi2(F3, G3, WEIGHTS)
+        Dtt[iv1+4,3] = _gqi2(F4, G3, WEIGHTS)
+        Dtt[iv1,7]   = _gqi2(F3, G4, WEIGHTS)
+        Dtt[iv1+4,7] = _gqi2(F4, G4, WEIGHTS)
+
+        Dtt[3, iv1]   = Dtt[iv1,3]
+        Dtt[7, iv1]   = Dtt[iv1,7]
+        Dtt[3, iv1+4] = Dtt[iv1+4,3]
+        Dtt[7, iv1+4] = Dtt[iv1+4,7]
+
+        Dzt[iv1, 3]   = _gqi2(F5, G3, WEIGHTS)
+        Dzt[iv1, 7]   = _gqi2(F5, G4, WEIGHTS)
+        Dzt[iv1+3, 3] = _gqi2(F6, G3, WEIGHTS)
+        Dzt[iv1+3, 7] = _gqi2(F6, G4, WEIGHTS)
+
+    Att[3,3] = _gqi(_nf1_curl(coeff, cs), Msz * _nf1_curl(coeff,cs), WEIGHTS)
+    Att[7,3] = _gqi(_nf2_curl(coeff, cs), Msz * _nf1_curl(coeff,cs), WEIGHTS)
+    Att[3,7] = _gqi(_nf1_curl(coeff, cs), Msz * _nf2_curl(coeff,cs), WEIGHTS)
+    Att[7,7] = _gqi(_nf2_curl(coeff, cs), Msz * _nf2_curl(coeff,cs), WEIGHTS)
+
+    Btt[3,3] = _gqi2(_nf1(coeff, cs), G1, WEIGHTS)
+    Btt[7,3] = _gqi2(_nf2(coeff, cs), G1, WEIGHTS)
+    Btt[3,7] = _gqi2(_nf1(coeff, cs), G2, WEIGHTS)
+    Btt[7,7] = _gqi2(_nf2(coeff, cs), G2, WEIGHTS)
+
+    A = np.zeros((14, 14), dtype = np.complex128)
+    B = np.zeros((14, 14), dtype = np.complex128)
+    
+    A[:8,:8] = (Att - k0**2 * Btt)
+
+    B[:8,:8] = Dtt
+    B[8:,:8] = Dzt
+    B[:8,8:] = Dzt.T
+    B[8:,8:] = Dzz1 - k0**2 * Dzz2
+
+    Ls = np.ones((14,14), dtype=np.float64)
+    
+    B = Ls*B*np.abs(Area)
+    A = Ls*A*np.abs(Area)
+    return A, B
+
+
+@njit(types.Tuple((c16[:], c16[:], i8[:], i8[:]))(f8[:,:],
+                                                      i8[:,:], 
+                                                      i8[:,:], 
+                                                      i8[:,:],
+                                                      c16[:,:,:], 
+                                                      c16[:,:,:], 
+                                                      f8,
+                                                      ProgressBarType), cache=True, nogil=True, parallel=True)
+def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0, pgb: ProgressBar):
+
+    ntritot = tris.shape[1]
+    nnz = ntritot*196
+
+    rows = np.zeros(nnz, dtype=np.int64)
+    cols = np.zeros(nnz, dtype=np.int64)
+    dataE = np.zeros_like(rows, dtype=np.complex128)
+    dataB = np.zeros_like(rows, dtype=np.complex128)
+
+    tri_to_edge = tri_to_field[:3,:]
+    
+    for itri in prange(ntritot): # type: ignore
+        p = itri*196
+        if np.mod(itri,10)==0:
+            pgb.update(10)
+        urt = ur[:,:,itri]
+        ert = er[:,:,itri]
+
+        # 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]]
+        Esub, Bsub = generalized_matrix_GQ(tri_nodes,local_tri_map, matinv(urt), ert, k0)
+        
+        indices = tri_to_field[:, itri]
+        for ii in range(14):
+            rows[p+14*ii:p+14*(ii+1)] = indices[ii]
+            cols[p+ii:p+ii+196:14] = indices[ii]
+
+        dataE[p:p+196] = Esub.ravel()
+        dataB[p:p+196] = Bsub.ravel()
+    return dataE, dataB, rows, cols

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

@@ -18,6 +18,7 @@
 
 import numpy as np
 from numba import njit, f8, c16, i8, types, prange
+from ....mth.optimized import cross, matinv_r
 from ....elements import Nedelec2
 from typing import Callable
 from loguru import logger
@@ -86,6 +87,28 @@ def generate_points(vertices_local, tris, DPTs, surf_triangle_indices):
     yflat = yall.flatten()
     return xflat, yflat
 
+@njit(types.Tuple((f8[:],f8[:], f8[:]))(f8[:,:], i8[:,:], f8[:,:], i8[:]), cache=True, nogil=True)
+def generate_points_3d(vertices, tris, DPTs, surf_triangle_indices):
+    NS = surf_triangle_indices.shape[0]
+    xall = np.zeros((DPTs.shape[1], NS))
+    yall = np.zeros((DPTs.shape[1], NS)) 
+    zall = np.zeros((DPTs.shape[1], NS))
+    for i in range(NS):
+        itri = surf_triangle_indices[i]
+        vertex_ids = tris[:, itri]
+        
+        x1, x2, x3 = vertices[0, vertex_ids]
+        y1, y2, y3 = vertices[1, vertex_ids]
+        z1, z2, z3 = vertices[2, vertex_ids]
+        
+        xall[:,i] = x1*DPTs[1,:] + x2*DPTs[2,:] + x3*DPTs[3,:]
+        yall[:,i] = y1*DPTs[1,:] + y2*DPTs[2,:] + y3*DPTs[3,:]
+        zall[:,i] = z1*DPTs[1,:] + z2*DPTs[2,:] + z3*DPTs[3,:]
+    xflat = xall.flatten()
+    yflat = yall.flatten()
+    zflat = zall.flatten()
+    return xflat, yflat, zflat
+
 @njit(f8[:,:](f8[:], f8[:], f8[:]), cache=True, nogil=True, fastmath=True)
 def compute_distances(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
     N = xs.shape[0]
@@ -96,8 +119,12 @@ def compute_distances(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndar
             Ds[j,i] = Ds[i,j]  
     return Ds
 
+@njit(cache=True, nogil=True)
+def normalize(a: np.ndarray):
+    return a/((a[0]**2 + a[1]**2 + a[2]**2)**0.5)
+    
 @njit(types.Tuple((c16[:,:],c16[:]))(f8[:,:], c16, c16[:,:], f8[:,:]), cache=True, nogil=True, parallel=False)
-def ned2_tri_stiff_force(lcs_vertices, gamma, lcs_Uinc, DPTs):
+def ned2_tri_stiff_force(glob_vertices, gamma, glob_Uinc, DPTs):
     ''' Nedelec-2 Triangle Stiffness matrix and forcing vector (For Boundary Condition of the Third Kind)
 
     '''
@@ -105,9 +132,25 @@ def ned2_tri_stiff_force(lcs_vertices, gamma, lcs_Uinc, DPTs):
     Bmat = np.zeros((8,8), dtype=np.complex128)
     bvec = np.zeros((8,), dtype=np.complex128)
 
+    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,:] = xhat
+    basis[1,:] = yhat
+    basis[2,:] = zhat
+    lcs_vertices = optim_matmul(basis, glob_vertices - orig[:,np.newaxis])
+    lcs_Uinc = optim_matmul(basis, glob_Uinc)
+    
     xs = lcs_vertices[0,:]
     ys = lcs_vertices[1,:]
-
+    
     x1, x2, x3 = xs
     y1, y2, y3 = ys
 
@@ -249,7 +292,7 @@ def ned2_tri_stiff_force(lcs_vertices, gamma, lcs_Uinc, DPTs):
     return Bmat, bvec
 
 @njit(types.Tuple((c16[:], c16[:]))(f8[:,:], i8[:,:], c16[:], c16[:], i8[:], c16, c16[:,:,:], f8[:,:], i8[:,:]), cache=True, nogil=True, parallel=False)
-def compute_bc_entries_excited(vertices_local, tris, Bmat, Bvec, surf_triangle_indices, gamma, Ulocal_all, DPTs, tri_to_field):
+def compute_bc_entries_excited(vertices_global, tris, Bmat, Bvec, surf_triangle_indices, gamma, Uglobal_all, DPTs, tri_to_field):
     N = 64
     Niter = surf_triangle_indices.shape[0]
     for i in prange(Niter): # type: ignore
@@ -257,9 +300,9 @@ def compute_bc_entries_excited(vertices_local, tris, Bmat, Bvec, surf_triangle_i
 
         vertex_ids = tris[:, itri]
 
-        Ulocal = Ulocal_all[:,:, i]
+        Ulocal = Uglobal_all[:,:, i]
 
-        Bsub, bvec = ned2_tri_stiff_force(vertices_local[:,vertex_ids], gamma, Ulocal, DPTs)
+        Bsub, bvec = ned2_tri_stiff_force(vertices_global[:,vertex_ids], gamma, Ulocal, DPTs)
         
         indices = tri_to_field[:, itri]
         
@@ -402,30 +445,28 @@ def compute_bc_entries(vertices, tris, Bmat, all_edge_lengths, surf_triangle_ind
 
 def assemble_robin_bc_excited(field: Nedelec2,
                               Bmat: np.ndarray,
-                surf_triangle_indices: np.ndarray,
-                Ufunc: Callable,
-                gamma: complex,
-                local_basis: np.ndarray,
-                origin: np.ndarray,
-                DPTs: np.ndarray):
+                              surf_triangle_indices: np.ndarray,
+                              Ufunc: Callable,
+                              gamma: complex,
+                              DPTs: np.ndarray):
     
     Bvec = np.zeros((field.n_field,), dtype=np.complex128)
 
-    vertices_local = optim_matmul(local_basis, field.mesh.nodes - origin[:,np.newaxis])
+    vertices = field.mesh.nodes
 
-    xflat, yflat = generate_points(vertices_local, field.mesh.tris, DPTs, surf_triangle_indices)
+    xflat, yflat, zflat = generate_points_3d(vertices, field.mesh.tris, DPTs, surf_triangle_indices)
 
-    Ulocal = Ufunc(xflat, yflat)
+    U_global = Ufunc(xflat, yflat, zflat)
 
-    Ulocal_all = Ulocal.reshape((3, DPTs.shape[1], surf_triangle_indices.shape[0]))
+    U_global_all = U_global.reshape((3, DPTs.shape[1], surf_triangle_indices.shape[0]))
 
-    Bmat, Bvec = compute_bc_entries_excited(vertices_local, field.mesh.tris, Bmat, Bvec, surf_triangle_indices, gamma, Ulocal_all, DPTs, field.tri_to_field)
+    Bmat, Bvec = compute_bc_entries_excited(vertices, field.mesh.tris, Bmat, Bvec, surf_triangle_indices, gamma, U_global_all, DPTs, field.tri_to_field)
     return Bmat, Bvec
 
 def assemble_robin_bc(field: Nedelec2,
                       Bmat: np.ndarray,
-                    surf_triangle_indices: np.ndarray,
-                    gamma: np.ndarray):
+                      surf_triangle_indices: np.ndarray,
+                      gamma: np.ndarray):
     vertices = field.mesh.nodes
     all_edge_lengths = field.mesh.edge_lengths[field.mesh.tri_to_edge]
     Bmat = compute_bc_entries(vertices, field.mesh.tris, Bmat, all_edge_lengths, surf_triangle_indices, gamma)

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -24,6 +24,7 @@ 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 .microwave_bc import MWBoundaryConditionSet, PEC, ModalPort, LumpedPort, PortBC
 from .microwave_data import MWData
 from .assembly.assembler import Assembler
@@ -60,7 +61,7 @@ def run_job_multi(job: SimJob) -> SimJob:
     return job
 
 
-def _dimstring(data: list[float]) -> str:
+def _dimstring(data: list[float] | np.ndarray) -> str:
     """A String formatter for dimensions in millimeters
 
     Args:
@@ -99,6 +100,21 @@ def shortest_path(xyz1: np.ndarray, xyz2: np.ndarray, Npts: int) -> np.ndarray:
 
     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.
 
@@ -302,8 +318,8 @@ class Microwave3D:
         dotprod = xs*field_axis[0] + ys*field_axis[1] + zs*field_axis[2]
 
         start_id = points[np.argwhere(dotprod == np.min(dotprod))]
-
-        start = np.squeeze(np.mean(self.mesh.nodes[:,start_id],axis=1))
+        
+        start = _pick_central(self.mesh.nodes[:,start_id.flatten()])
         logger.info(f'Starting node = {_dimstring(start)}')
         end = start + port.Vdirection.np*port.height
 
@@ -493,6 +509,7 @@ class Microwave3D:
             if TEM:
                 target_kz = ermean*urmean*1.1*k0
             else:
+                
                 target_kz = ermean*urmean*0.7*k0
 
     
@@ -514,7 +531,8 @@ class Microwave3D:
             Emode[solve_ids] = np.squeeze(eigenmode)
             Emode = Emode * np.exp(-1j*np.angle(np.max(Emode)))
 
-            beta = min(k0*np.sqrt(ermax*urmax), np.emath.sqrt(-eigen_values[i]))
+            beta_base = np.emath.sqrt(-eigen_values[i])
+            beta = min(k0*np.sqrt(ermax*urmax), beta_base)
 
             residuals = -1