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

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -33,11 +33,10 @@ os.environ["OPENBLAS_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_MAXIMUM_THREADS"] = NTHREADS
 os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
 
-
 ############################################################
 #                      IMPORT MODULES                     #
 ############################################################
-from ._emerge import _cache_check
+
 from ._emerge.logsettings import LOG_CONTROLLER
 from loguru import logger
 
@@ -54,8 +53,7 @@ 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.physics.microwave.sc import stratton_chu
+#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
@@ -65,10 +63,11 @@ howto = _HowtoClass()
 
 logger.debug('Importing complete!')
 
-
 ############################################################
 #                         CONSTANTS                        #
 ############################################################
 
 CENTER = geo.Alignment.CENTER
-CORNER = geo.Alignment.CORNER
+CORNER = geo.Alignment.CORNER
+EISO = lib.EISO
+EOMNI = lib.EOMNI

emerge/_emerge/elements/femdata.py

@@ -19,9 +19,7 @@ from __future__ import annotations
 from ..mesh3d import Mesh3D
 import numpy as np
 from typing import Callable
-from scipy.sparse import csr_matrix # type: ignore
 
-from ..mth.optimized import matmul
 
 class FEMBasis:
 
@@ -48,6 +46,8 @@ class FEMBasis:
     
     def interpolate_Ef(self, field: np.ndarray, basis: np.ndarray | None = None, origin: np.ndarray | None = None, tetids: np.ndarray | None = None) -> Callable:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
+        from ..mth.optimized import matmul
+        
         if basis is None:
             basis = np.eye(3)
 
@@ -124,7 +124,8 @@ class FEMBasis:
         N = self.n_tri_dofs**2
         return slice(itri*N,(itri+1)*N)
     
-    def generate_csr(self, data: np.ndarray) -> csr_matrix:
+    def generate_csr(self, data: np.ndarray):
+        from scipy.sparse import csr_matrix # type: ignore
         ids = np.argwhere(data!=0)[:,0]
         return csr_matrix((data[ids], (self._rows[ids], self._cols[ids])), shape=(self.n_field, self.n_field))
     ### QUANTITIES

emerge/_emerge/elements/nedelec2.py

@@ -19,9 +19,6 @@ from __future__ import annotations
 import numpy as np
 from ..mesh3d import Mesh3D
 from .femdata import FEMBasis
-from .ned2_interp import ned2_tet_interp, ned2_tet_interp_curl
-from ..mth.optimized import local_mapping
-from .index_interp import index_interp
 
 ############### Nedelec2 Class
 
@@ -72,6 +69,7 @@ class Nedelec2(FEMBasis):
         ''' 
         Interpolate the provided field data array at the given xs, ys and zs coordinates
         '''
+        from .ned2_interp import ned2_tet_interp
         if tetids is None:
             tetids = self._all_tet_ids
         vals = ned2_tet_interp(np.array([xs, ys, zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, tetids)
@@ -83,8 +81,11 @@ class Nedelec2(FEMBasis):
         """
         Interpolates the curl of the field at the given points.
         """
+        from .ned2_interp import ned2_tet_interp_curl
+        
         if tetids is None:
             tetids = self._all_tet_ids
+        
         vals = ned2_tet_interp_curl(np.array([xs, ys, zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, c, tetids)
         if not usenan:
             vals = np.nan_to_num(vals)
@@ -97,7 +98,7 @@ class Nedelec2(FEMBasis):
                         usenan: bool = True) -> np.ndarray:
         if tetids is None:
             tetids = self._all_tet_ids
-
+        from .index_interp import index_interp
         vals = index_interp(np.array([xs, ys, zs]), self.mesh.tets, self.mesh.nodes, tetids)
         if not usenan:
             vals[vals==-1]==0
@@ -106,15 +107,18 @@ class Nedelec2(FEMBasis):
     ###### INDEX MAPPINGS
 
     def local_tet_to_triid(self, itet: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         tri_ids = self.tet_to_field[6:10, itet] - self.n_edges
         global_tri_map = self.mesh.tris[:, tri_ids]
         return local_mapping(self.mesh.tets[:, itet], global_tri_map)
 
     def local_tet_to_edgeid(self, itet: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         global_edge_map = self.mesh.edges[:, self.tet_to_field[:6,itet]]
         return local_mapping(self.mesh.tets[:, itet], global_edge_map)
 
     def local_tri_to_edgeid(self, itri: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         global_edge_map = self.mesh.edges[:, self.tri_to_field[:3,itri]]
         return local_mapping(self.mesh.tris[:, itri], global_edge_map)
     

emerge/_emerge/elements/nedleg2.py

@@ -19,8 +19,6 @@ from __future__ import annotations
 import numpy as np
 from ..mesh3d import SurfaceMesh
 from .femdata import FEMBasis
-from .ned2_interp import ned2_tri_interp_full, ned2_tri_interp_curl
-from ..mth.optimized import matinv
 from ..cs import CoordinateSystem
 from ..const import MU0, C0
 
@@ -74,6 +72,8 @@ class FieldFunctionClass:
         return np.array([Fx, Fy, Fz])*self.constant
     
     def calcE(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_full
+        
         coordinates = np.array([xs, ys])
         vals = ned2_tri_interp_full(coordinates, 
                                self.field, 
@@ -85,6 +85,7 @@ class FieldFunctionClass:
         return vals
     
     def calcH(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_curl
         coordinates = np.array([xs, ys])
         
         vals = ned2_tri_interp_curl(coordinates, 
@@ -176,6 +177,7 @@ class NedelecLegrange2(FEMBasis):
 
     def interpolate_Hf(self, field: np.ndarray, k0: float, ur: np.ndarray, beta: float) -> FieldFunctionClass:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
+        from ..mth.optimized import matinv
         constant = 1j / ((k0*C0)*MU0)
         urinv = np.zeros_like(ur)
         
@@ -185,6 +187,7 @@ class NedelecLegrange2(FEMBasis):
         return FieldFunctionClass(field, self.cs, self.local_nodes, self.mesh.tris, self.tri_to_field, 'H', urinv, beta, constant)
     
     def tri_interpolate(self, field, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_full
         coordinates = np.array([xs, ys])
         vals = ned2_tri_interp_full(coordinates, 
                                field, 
@@ -196,6 +199,7 @@ class NedelecLegrange2(FEMBasis):
         return vals
     
     def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray | None = None, beta: float = 0.0, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_curl
         coordinates = np.array([xs, ys])
         if diadic is None:
             diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.mesh.n_tris)) # type: ignore

emerge/_emerge/geo/pcb.py

@@ -958,6 +958,7 @@ class PCB:
                  stack: list[PCBLayer] = None,
                  name: str | None = None,
                  trace_thickness: float | None = None,
+                 zs: np.ndarray | None = None
                  ):
         """Creates a new PCB layout class instance
 
@@ -975,8 +976,11 @@ class PCB:
 
         self.thickness: float = thickness
         self._stack: list[PCBLayer] = []
-        
-        if stack is not None:
+        if zs is not None:
+            self._zs = zs
+            self.thickness = np.max(zs)-np.min(zs)
+            self._stack = [PCBLayer(th, material) for th in np.diff(self._zs)]
+        elif stack is not None:
             self._stack = stack
             ths = [ly.th for ly in stack]
             zbot = -sum(ths)

emerge/_emerge/geo/pcb_tools/dxf.py

@@ -325,8 +325,9 @@ def import_dxf(filename: str,
                unit: float | None = None,
                cs: CoordinateSystem | None = GCS,
                trace_material: Material = PEC) -> PCB:
+    
     polies = extract_polygons_with_meta(filename)
-    prop = inspect_pcb_from_dxf('LP5G_Chb3.dxf')
+    prop = inspect_pcb_from_dxf(filename)
     
     if prop['units']['name'] == 'unitless':
         if unit is None:
@@ -335,7 +336,7 @@ def import_dxf(filename: str,
     else:
         pcb_unit = 0.001 * prop['units']['to_mm']
     
-    if prop['thickness']==0.0:
+    if prop['thickness'] == 0.0:
         if thickness is None:
             raise RouteException(f'Cannot generate PCB because no thickness is found int he DXF file and none is provided in the import_dxf function.')
         pcb_thickness = thickness
@@ -346,7 +347,7 @@ def import_dxf(filename: str,
         cs = GCS
     
     zs = sorted(list(set([pol['z'] for pol in polies])))
-    pcb = PCB(pcb_thickness, pcb_unit, cs, material=material, trace_material=trace_material, _zs=zs)
+    pcb = PCB(pcb_thickness, pcb_unit, cs, material=material, trace_material=trace_material)
     
     for poly in polies:
         xs, ys = zip(*poly['ring'])

emerge/_emerge/geo/polybased.py

@@ -24,66 +24,7 @@ from typing import Generator, Callable
 from ..selection import FaceSelection
 from typing import Literal
 from functools import reduce
-from numba import njit
 
-@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]]
 
 def _discretize_curve(xfunc: Callable, yfunc: Callable, 
                       t0: float, t1: float, xmin: float, tol: float=1e-4) -> tuple[np.ndarray, np.ndarray]:
@@ -100,6 +41,8 @@ def _discretize_curve(xfunc: Callable, yfunc: Callable,
     Returns:
         tuple[np.ndarray, np.ndarray]: _description_
     """
+    from ..mth.optimized import _subsample_coordinates
+    
     td = np.linspace(t0, t1, 10001)
     xs = xfunc(td)
     ys = yfunc(td)

emerge/_emerge/mesh3d.py

@@ -18,25 +18,14 @@
 from __future__ import annotations
 import gmsh # type: ignore
 import numpy as np
-from numba import njit, f8 # type: ignore
 from .mesher import Mesher
 from typing import Union, List, Tuple, Callable, Any
 from collections import defaultdict
 from .geometry import GeoVolume
-from .mth.optimized import outward_normal
 from loguru import logger
-from functools import cache
 from .bc import Periodic
-from .mth.pairing import pair_coordinates
 from .material import Material
 
-@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
-
 def shortest_distance(point_cloud):
     """
     Compute the shortest distance between any two points in a 3D point cloud.
@@ -172,7 +161,7 @@ class Mesh3D(Mesh):
     def n_nodes(self) -> int:
         '''Return the number of nodes'''
         return self.nodes.shape[1]
-
+    
     def get_edge(self, i1: int, i2: int, skip: bool = False) -> int:
         '''Return the edge index given the two node indices'''
         if i1==i2:
@@ -204,21 +193,6 @@ class Mesh3D(Mesh):
         if output is None:
             raise ValueError(f'There is no tetrahedron with indices {i1}, {i2}, {i3}, {i4}')
         return output
-    
-    def boundary_triangles(self, dimtags: list[tuple[int, int]] | None = None) -> np.ndarray:
-        if dimtags is None:
-            outputtags = []
-            for tags in self.ftag_to_tri.values():
-                outputtags.extend(tags)
-            return np.array(outputtags)
-        else:
-            dts = []
-            for dimtag in dimtags:
-                if dimtag[0]==2:
-                    dts.append(dimtag)
-                elif dimtag[0]==3:
-                    dts.extend(gmsh.model.get_boundary(dimtags))
-            return self.get_triangles([tag[1] for tag in dts])
         
 
     def get_tetrahedra(self, vol_tags: Union[int, list[int]]) -> np.ndarray:
@@ -317,7 +291,16 @@ class Mesh3D(Mesh):
         return np.array(sorted(list(set(edges))))
     
     
-    def update(self, periodic_bcs: list[Periodic] | None = None):
+    def _pre_update(self, periodic_bcs: list[Periodic] | None = None):
+        """Builds the mesh data properties
+
+        Args:
+            periodic_bcs (list[Periodic] | None, optional): A list of periodic boundary conditions. Defaults to None.
+
+        Returns:
+            None: None
+        """
+        from .mth.optimized import area
         
         logger.trace('Generating mesh data.')
         if periodic_bcs is None:
@@ -357,7 +340,7 @@ class Mesh3D(Mesh):
     
         for bc in periodic_bcs:
             logger.trace(f'reassigning ordered node numbers for periodic boundary {bc}')
-            nodemap, ids1, ids2 = self._derive_node_map(bc)
+            nodemap, ids1, ids2 = self._pre_derive_node_map(bc)
             nodemap = {int(a): int(b) for a,b in nodemap.items()}
             self.nodes[:,ids2] = self.nodes[:,ids1]
             for itet in range(self.tets.shape[1]):
@@ -508,6 +491,11 @@ class Mesh3D(Mesh):
 
         self.defined = True
         
+
+        ############################################################
+        #                            GMSH CACHE                   #
+        ############################################################
+
         for dim in (0,1,2,3):
             dts= gmsh.model.get_entities(dim)
             for dt in dts:
@@ -519,7 +507,7 @@ class Mesh3D(Mesh):
 
     ## Higher order functions
 
-    def _derive_node_map(self, bc: Periodic) -> tuple[dict[int, int], np.ndarray, np.ndarray]:
+    def _pre_derive_node_map(self, bc: Periodic) -> tuple[dict[int, int], np.ndarray, np.ndarray]:
         """Computes an old to new node index mapping that preserves global sorting
 
         Since basis function field direction is based on the order of indices in tetrahedron
@@ -534,6 +522,8 @@ class Mesh3D(Mesh):
             tuple[dict[int, int], np.ndarray, np.ndarray]: The node index mapping and the node index arrays
         """
 
+        from .mth.pairing import pair_coordinates
+        
         node_ids_1 = []
         node_ids_2 = []
 
@@ -566,7 +556,7 @@ class Mesh3D(Mesh):
         return conv_map, np.array(node_ids_2_unsorted), np.array(node_ids_2_sorted)
 
 
-    def retreive(self, volumes: list[GeoVolume]) -> list[Material]:
+    def _get_material_assignment(self, volumes: list[GeoVolume]) -> list[Material]:
         '''Retrieve the material properties of the geometry'''
         #arry = np.zeros((3,3,self.n_tets,), dtype=np.complex128)
         for vol in volumes:
@@ -818,6 +808,8 @@ class SurfaceMesh(Mesh):
     def update(self) -> None:
         ## First Edges
 
+        from .mth.optimized import outward_normal, area
+        
         edges = set()
         for i in range(self.n_tris):
             i1, i2, i3 = self.tris[:,i]

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/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                     #
 ############################################################