emerge 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

emerge/_emerge/{_cache_check.py → mth/_cache_check.py}

@@ -15,12 +15,12 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-from numba.core import event, types
+from numba.core import event
 from numba import njit
 
 _COMPILE_MESSAGE = """
  [ EMERGE ]
-⚠  Numba is compiling optimized code; this may take a few minutes.
+⚠  Numba will be compiling optimized code in this first run; this may take a few minutes.
    • Additional functions may be compiled on-the-fly.
    • Compilation happens only once-subsequent runs load from cache.
    Please wait…"""

emerge/_emerge/mth/optimized.py

@@ -17,8 +17,7 @@
 
 from numba import njit, f8, i8, types, c16
 import numpy as np
-
-
+from . import _cache_check
 
 ############################################################
 #             TRIANGLE GAUSS QUADRATURE POINTS            #
@@ -446,4 +445,71 @@ def matmul(M: np.ndarray, vecs: np.ndarray):
     out[0,:] = M[0,0]*vecs[0,:] + M[0,1]*vecs[1,:] + M[0,2]*vecs[2,:]
     out[1,:] = M[1,0]*vecs[0,:] + M[1,1]*vecs[1,:] + M[1,2]*vecs[2,:]
     out[2,:] = M[2,0]*vecs[0,:] + M[2,1]*vecs[1,:] + M[2,2]*vecs[2,:]
-    return out
+    return out
+
+@njit(cache=True)
+def _subsample_coordinates(xs: np.ndarray, ys: np.ndarray, tolerance: float, xmin: float) -> tuple[np.ndarray, np.ndarray]:
+    """This function takes a set of x and y coordinates in a finely sampled set and returns a reduced
+    set of numbers that traces the input curve within a provided tolerance.
+
+    Args:
+        xs (np.ndarray): The set of X-coordinates
+        ys (np.ndarray): The set of Y-coordinates
+        tolerance (float): The maximum deviation of the curve in meters
+        xmin (float): The minimal distance to the next point.
+
+    Returns:
+        np.ndarray: The output X-coordinates
+        np.ndarray: The output Y-coordinates
+    """
+    N = xs.shape[0]
+    ids = np.zeros((N,), dtype=np.int32)
+    store_index = 1
+    start_index = 0
+    final_index = 0
+    for iteration in range(N):
+        i1 = start_index
+        done = 0
+        for i2 in range(i1+1,N):
+            x_true = xs[i1:i2+1]
+            y_true = ys[i1:i2+1]
+
+            x_f = np.linspace(xs[i1],xs[i2], i2-i1+1)
+            y_f = np.linspace(ys[i1],ys[i2], i2-i1+1)
+            error = np.max(np.sqrt((x_f-x_true)**2 + (y_f-y_true)**2))
+            ds = np.sqrt((xs[i2]-xs[i1])**2 + (ys[i2]-ys[i1])**2)
+            # If at the end
+            if i2==N-1: 
+                ids[store_index] = i2-1
+                final_index = store_index + 1
+                done = 1
+                break
+            # If not yet past the minimum distance, accumulate more
+            if ds < xmin:
+                continue
+            # If the end is less than a minimum distance
+            if np.sqrt((ys[-1]-ys[i2])**2 + (xs[-1]-xs[i2])**2) < xmin:
+                imid = i1 + (N-1-i1)//2
+                ids[store_index] = imid
+                ids[store_index+1] = N-1
+                final_index = store_index + 2
+                done = 1
+                break
+            if error < tolerance:
+                continue
+            else:
+                ids[store_index] = i2-1
+                start_index = i2
+                store_index = store_index + 1
+                break
+        if done==1:
+            break
+    return xs[ids[0:final_index]], ys[ids[0:final_index]]
+
+
+@njit(f8(f8[:], f8[:], f8[:]), cache=True, nogil=True)
+def area(x1: np.ndarray, x2: np.ndarray, x3: np.ndarray):
+    e1 = x2 - x1
+    e2 = x3 - x1
+    av = np.array([e1[1]*e2[2] - e1[2]*e2[1], e1[2]*e2[0] - e1[0]*e2[2], e1[0]*e2[1] - e1[1]*e2[0]])
+    return np.sqrt(av[0]**2 + av[1]**2 + av[2]**2)/2

emerge/_emerge/periodic.py

@@ -16,7 +16,7 @@
 # <https://www.gnu.org/licenses/>.
 
 from .cs import Axis, _parse_axis, GCS, _parse_vector
-from .selection import SELECTOR_OBJ, Selection
+from .selection import SELECTOR_OBJ, Selection, FaceSelection
 from .geo import GeoPrism, XYPolygon, Alignment, XYPlate
 from .bc import BoundaryCondition
 from typing import Generator
@@ -50,8 +50,8 @@ def _pair_selection(f1: Selection,
     for t1, c1 in zip(f1.tags, c1s):
         for t2, c2 in zip(f2.tags, c2s):
             if np.linalg.norm((c1 + ds)-c2) < 1e-8:
-                f1s.append(Selection([t1,]))
-                f2s.append(Selection([t2,]))
+                f1s.append(FaceSelection([t1,]))
+                f2s.append(FaceSelection([t2,]))
     return f1s, f2s
 
 
@@ -69,7 +69,7 @@ class PeriodicCell:
 
         self.origins: list[tuple[float, float, float]] = [_parse_vector(origin) for origin in origins] # type: ignore
         self.vectors: list[Axis] = [_parse_axis(vec) for vec in vectors]
-        self.excluded_faces: Selection | None = None
+        self.included_faces: Selection | None = None
         self._bcs: list[Periodic] = []
         self._ports: list[BoundaryCondition] = []
 
@@ -105,9 +105,11 @@ class PeriodicCell:
         for f1, f2, a in self.cell_data():
             f1_new = f1
             f2_new = f2
-            if self.excluded_faces is not None:
-                f1_new = f1 - self.excluded_faces # type: ignore
-                f2_new = f2 - self.excluded_faces # type: ignore
+            if self.included_faces is not None:
+                f1_new = f1 & self.included_faces # type: ignore
+                f2_new = f2 & self.included_faces # type: ignore
+            if len(f1_new.tags)==0:
+                continue
             bcs.append(Periodic(f1_new, f2_new, tuple(a)))
         self._bcs = bcs
         return bcs
@@ -191,16 +193,16 @@ class RectCell(PeriodicCell):
         return XYPlate(self.width, self.height, position=(0,0,z), alignment=Alignment.CENTER)
         
     def cell_data(self):
-        f1s = SELECTOR_OBJ.inplane(*self.fleft[0], *self.fleft[1])
-        f2s = SELECTOR_OBJ.inplane(*self.fright[0], *self.fright[1])
+        f1s = SELECTOR_OBJ.inplane(*self.fleft[0], self.fleft[1])
+        f2s = SELECTOR_OBJ.inplane(*self.fright[0], self.fright[1])
         vec = (self.fright[0][0]-self.fleft[0][0], 
                self.fright[0][1]-self.fleft[0][1], 
                self.fright[0][2]-self.fleft[0][2])
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
             yield f1, f2, vec
 
-        f1s = SELECTOR_OBJ.inplane(*self.fbot[0], *self.fbot[1])
-        f2s = SELECTOR_OBJ.inplane(*self.ftop[0], *self.ftop[1])
+        f1s = SELECTOR_OBJ.inplane(*self.fbot[0], self.fbot[1])
+        f2s = SELECTOR_OBJ.inplane(*self.ftop[0], self.ftop[1])
         vec = (self.ftop[0][0]-self.fbot[0][0], 
                self.ftop[0][1]-self.fbot[0][1], 
                self.ftop[0][2]-self.fbot[0][2])
@@ -273,9 +275,9 @@ class HexCell(PeriodicCell):
         o = self.o1[:-1]
         n = self.f11[1][:-1]
         w = nrm(self.p2-self.p1)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f11[0], *self.f11[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f11[0], self.f11[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f12[0], *self.f12[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f12[0], self.f12[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p1 + self.p2)
 
@@ -285,9 +287,9 @@ class HexCell(PeriodicCell):
         o = self.o2[:-1]
         n = self.f21[1][:-1]
         w = nrm(self.p3-self.p2)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f21[0], *self.f21[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f21[0], self.f21[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f22[0], *self.f22[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f22[0], self.f22[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p2 + self.p3)
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore
@@ -296,9 +298,9 @@ class HexCell(PeriodicCell):
         o = self.o3[:-1]
         n = self.f31[1][:-1]
         w = nrm(-self.p1-self.p3)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f31[0], *self.f31[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f31[0], self.f31[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f32[0], *self.f32[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f32[0], self.f32[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p3 - self.p1)
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore

emerge/_emerge/physics/microwave/__init__.py

@@ -1 +0,0 @@
-from .sc import stratton_chu

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

@@ -19,14 +19,12 @@ import numpy as np
 from ..microwave_bc import PEC, BoundaryCondition, RectangularWaveguide, RobinBC, PortBC, Periodic, MWBoundaryConditionSet
 from ....elements.nedelec2 import Nedelec2
 from ....elements.nedleg2 import NedelecLegrange2
-from ....mth.optimized import gaus_quad_tri
-from ....mth.pairing import pair_coordinates
 from ....material import Material
 from ....settings import Settings
 from scipy.sparse import csr_matrix
 from loguru import logger
 from ..simjob import SimJob
-from .periodicbc import gen_periodic_matrix
+
 from ....const import MU0, EPS0, C0
 
 
@@ -209,7 +207,11 @@ class Assembler:
 
         from .curlcurl import tet_mass_stiffness_matrices
         from .robinbc import assemble_robin_bc, assemble_robin_bc_excited
-
+        from ....mth.optimized import gaus_quad_tri
+        from ....mth.pairing import pair_coordinates
+        from .periodicbc import gen_periodic_matrix
+        from .robin_abc_order2 import abc_order_2_matrix
+        
         # PREDEFINE CONSTANTS
         W0 = 2*np.pi*frequency
         K0 = W0/C0
@@ -326,6 +328,15 @@ class Assembler:
                         logger.trace(f'..included force vector term with norm {np.linalg.norm(b_p):.3f}')
                     else:
                         Bempty = assemble_robin_bc(field, Bempty, tri_ids, gamma) # type: ignore
+                    
+                    ## Second order absorbing boundary correction
+                    if bc._isabc:
+                        if bc.order==2:
+                            c2 = bc.o2coeffs[bc.abctype][1]
+                            logger.debug('Implementing second order ABC correction.')
+                            mat = abc_order_2_matrix(field, tri_ids, 1j*c2/(K0))
+                            Bempty += mat
+                        
             B_p = field.generate_csr(Bempty)
             K = K + B_p
         
@@ -430,7 +441,10 @@ class Assembler:
         """
         from .curlcurl import tet_mass_stiffness_matrices
         from .robinbc import assemble_robin_bc
-
+        from ....mth.pairing import pair_coordinates
+        from .periodicbc import gen_periodic_matrix
+        from .robin_abc_order2 import abc_order_2_matrix
+        
         mesh = field.mesh
         w0 = 2*np.pi*frequency
         k0 = w0/C0
@@ -507,6 +521,14 @@ class Assembler:
                         ibasis = np.linalg.pinv(basis)
                     
                     Bempty = assemble_robin_bc(field, Bempty, tri_ids, gamma) # type: ignore
+                
+                ## Second order absorbing boundary correction
+                if bc._isabc:
+                    if bc.order==2:
+                        c2 = bc.o2coeffs[bc.abctype][1]
+                        logger.debug('Implementing second order ABC correction.')
+                        mat = abc_order_2_matrix(field, tri_ids, 1j*c2/k0)
+                        Bempty += mat
             B_p = field.generate_csr(Bempty)
             B = B + B_p
         

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

@@ -226,7 +226,6 @@ def tri_coefficients(vxs, vys):
     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)
@@ -444,11 +443,11 @@ def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0):
         ert = er[:,:,itri]
 
         # Construct a local mapping to global triangle orientations
-        local_tri_map = local_tri_to_edgeid(itri, tris, edges, tri_to_edge)
+        local_edge_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)
+        Esub, Bsub = generalized_matrix_GQ(tri_nodes,local_edge_map, matinv(urt), ert, k0)
         
         indices = tri_to_field[:, itri]
         for ii in range(14):

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

@@ -20,7 +20,6 @@ import numpy as np
 from numba import njit, types, i8, c16
 from scipy.sparse import csr_matrix
 
-
 ############################################################
 #                      NUMBA COMPILED                     #
 ############################################################

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