emerge 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

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

@@ -16,7 +16,7 @@
 # <https://www.gnu.org/licenses/>.
 
 import numpy as np
-from ..microwave_bc import PEC, BoundaryCondition, RectangularWaveguide, RobinBC, PortBC, Periodic
+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
@@ -26,14 +26,7 @@ from scipy.sparse import csr_matrix
 from loguru import logger
 from ..simjob import SimJob
 from .periodicbc import gen_periodic_matrix
-
-
-############################################################
-#                         CONSTANTS                        #
-############################################################
-
-C0 = 299792458
-EPS0 = 8.854187818814e-12
+from ....const import MU0, EPS0, C0
 
 
 ############################################################
@@ -124,7 +117,7 @@ class Assembler:
                         sig: np.ndarray,
                         k0: float,
                         port: PortBC,
-                        bcs: list[BoundaryCondition]) -> tuple[np.ndarray, np.ndarray, np.ndarray, NedelecLegrange2]:
+                        bc_set: MWBoundaryConditionSet) -> tuple[csr_matrix, csr_matrix, np.ndarray, NedelecLegrange2]:
         """Computes the boundary mode analysis matrices
 
         Args:
@@ -134,32 +127,37 @@ class Assembler:
             sig (np.ndarray): The conductivity scalar of shape (N,)
             k0 (float): The simulation phase constant
             port (PortBC): The port boundary condition object
-            bcs (list[BoundaryCondition]): The other boundary conditions
+            bcs (MWBoundaryConditionSet): The other boundary conditions
 
         Returns:
             tuple[np.ndarray, np.ndarray, np.ndarray, NedelecLegrange2]: The E, B, solve ids and Mixed order field object.
         """
         from .generalized_eigen import generelized_eigenvalue_matrix
-        
+        logger.debug('Assembling Boundary Mode Matrices')
+
+        bcs = bc_set.boundary_conditions
         mesh = field.mesh
         tri_ids = mesh.get_triangles(port.tags)
+        logger.trace(f'.boundary face has {len(tri_ids)} triangles.')
 
         origin = tuple([c-n for c,n in zip(port.cs.origin, port.cs.gzhat)])
-        
+        logger.trace(f'.boundary origin {origin}')
+
         boundary_surface = mesh.boundary_surface(port.tags, origin)
         nedlegfield = NedelecLegrange2(boundary_surface, port.cs)
 
         ermesh = er[:,:,tri_ids]
         urmesh = ur[:,:,tri_ids]
         sigmesh = sig[tri_ids]
-
         ermesh = ermesh - 1j * sigmesh/(k0*C0*EPS0)
 
+        logger.trace(f'.assembling matrices for {nedlegfield} at k0={k0:.2f}')
         E, B = generelized_eigenvalue_matrix(nedlegfield, ermesh, urmesh, port.cs._basis, k0)
 
-        pecs: list[PEC] = [bc for bc in bcs if isinstance(bc,PEC)]
+        # TODO: Simplified to all "conductors" loosely defined. Must change to implementing line robin boundary conditions.
+        pecs: list[BoundaryCondition] = bc_set.get_conductors()#[bc for bc in bcs if isinstance(bc,PEC)]
         if len(pecs) > 0:
-            logger.debug('Implementing PEC BCs')
+            logger.debug(f'.total of equiv. {len(pecs)} PEC BCs implemented')
 
         pec_ids = []
 
@@ -172,8 +170,8 @@ class Assembler:
         pec_edges = []
         pec_vertices = []
         for pec in pecs:
+            logger.trace(f'.implementing {pec}')
             face_tags = pec.tags
-
             tri_ids = mesh.get_triangles(face_tags)
             edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
             for ii in edge_ids:
@@ -186,7 +184,6 @@ class Assembler:
                 pec_vertices.append(eids[3]-nedlegfield.n_xy)
                 pec_vertices.append(eids[4]-nedlegfield.n_xy)
             
-
             for ii in tri_ids:
                 i2 = nedlegfield.mesh.from_source_tri(ii)
                 if i2 is None:
@@ -194,12 +191,11 @@ class Assembler:
                 tids = nedlegfield.tri_to_field[:, i2]
                 pec_ids.extend(list(tids))
 
-        port._field = nedlegfield
-        port._pece = pec_edges
-        port._pecv = pec_vertices
         # Process all port boundary Conditions
-        pec_ids = set(pec_ids)
-        solve_ids = [i for i in range(nedlegfield.n_field) if i not in pec_ids]
+        pec_ids_set: set[int] = set(pec_ids)
+
+        logger.trace(f'.total of {len(pec_ids_set)} pec DoF to remove.')
+        solve_ids = [i for i in range(nedlegfield.n_field) if i not in pec_ids_set]
 
         return E, B, np.array(solve_ids), nedlegfield
 
@@ -234,16 +230,16 @@ class Assembler:
 
         mesh = field.mesh
         er = er - 1j*sig/(W0*EPS0)*np.repeat(np.eye(3)[:, :, np.newaxis], er.shape[2], axis=2)
-        is_frequency_dependent: bool = np.any((sig > 0) & (sig < self.conductivity_limit))
+        is_frequency_dependent: bool = np.any((sig > 0) & (sig < self.conductivity_limit)) # type: ignore
         
 
         if cache_matrices and not is_frequency_dependent and self.cached_matrices is not None:
             # IF CACHED AND AVAILABLE PULL E AND B FROM CACHE
-            logger.debug('    Retreiving cached matricies')
+            logger.debug('Using cached matricies.')
             E, B = self.cached_matrices
         else:
             # OTHERWISE, COMPUTE
-            logger.debug('    Assembling matrices')
+            logger.debug('Assembling matrices')
             E, B = tet_mass_stiffness_matrices(field, er, ur)
             self.cached_matrices = (E, B)
 
@@ -254,7 +250,7 @@ class Assembler:
 
         # ISOLATE BOUNDARY CONDITIONS TO ASSEMBLE
         pec_bcs: list[PEC] = [bc for bc in bcs if isinstance(bc,PEC)]
-        robin_bcs: list[RectangularWaveguide] = [bc for bc in bcs if isinstance(bc,RobinBC)]
+        robin_bcs: list[RobinBC] = [bc for bc in bcs if isinstance(bc,RobinBC)]
         port_bcs: list[PortBC] = [bc for bc in bcs if isinstance(bc, PortBC)]
         periodic_bcs: list[Periodic] = [bc for bc in bcs if isinstance(bc, Periodic)]
 
@@ -262,15 +258,24 @@ class Assembler:
         b = np.zeros((E.shape[0],)).astype(np.complex128)
         port_vectors = {port.port_number: np.zeros((E.shape[0],)).astype(np.complex128) for port in port_bcs}
         
-        # Process all PEC Boundary Conditions
-        logger.debug('    Implementing PEC Boundary Conditions.')
-        pec_ids = []
+
+        ############################################################
+        #                      PEC BOUNDARY CONDITIONS             #
+        ############################################################
+
+        logger.debug('Implementing PEC Boundary Conditions.')
+        pec_ids: list[int] = []
         # Conductivity above al imit, consider it all PEC
+        ipec = 0
         for itet in range(field.n_tets):
             if sig[itet] > self.conductivity_limit:
+                ipec+=1
                 pec_ids.extend(field.tet_to_field[:,itet])
-        
+        if ipec>0:
+            logger.trace(f'Extended PEC with {ipec} tets with a conductivity > {self.conductivity_limit}.')
+
         for pec in pec_bcs:
+            logger.trace(f'Implementing: {pec}')
             if len(pec.tags)==0:
                 continue
             face_tags = pec.tags
@@ -285,14 +290,18 @@ class Assembler:
                 tids = field.tri_to_field[:, ii]
                 pec_ids.extend(list(tids))
 
-        # Robin BCs
+
+        ############################################################
+        #                     ROBIN BOUNDARY CONDITIONS            #
+        ############################################################
+
         if len(robin_bcs) > 0:
-            logger.debug('    Implementing Robin Boundary Conditions.')
+            logger.debug('Implementing Robin Boundary Conditions.')
         
             gauss_points = gaus_quad_tri(4)
             Bempty = field.empty_tri_matrix()
             for bc in robin_bcs:
-
+                logger.trace(f'.Implementing {bc}')
                 for tag in bc.tags:
                     face_tags = [tag,]
 
@@ -301,6 +310,7 @@ class Assembler:
                     edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
 
                     gamma = bc.get_gamma(K0)
+                    logger.trace(f'..robin bc γ={gamma:.3f}')
 
                     def Ufunc(x,y): 
                         return bc.get_Uinc(x,y,K0)
@@ -309,38 +319,42 @@ class Assembler:
                     if ibasis is None:
                         basis = plane_basis_from_points(mesh.nodes[:,nodes]) + 1e-16
                         ibasis = np.linalg.pinv(basis)
+                        logger.trace(f'..Using computed basis: {ibasis.flatten()}')
                     if bc._include_force:
-
-                        Bempty, b_p = assemble_robin_bc_excited(field, Bempty, tri_ids, Ufunc, gamma, ibasis, bc.cs.origin, gauss_points)
-                        
-                        port_vectors[bc.port_number] += b_p
-                    
+                        Bempty, b_p = assemble_robin_bc_excited(field, Bempty, tri_ids, Ufunc, gamma, ibasis, bc.cs.origin, gauss_points) # type: ignore
+                        port_vectors[bc.port_number] += b_p # type: ignore
+                        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)
+                        Bempty = assemble_robin_bc(field, Bempty, tri_ids, gamma) # type: ignore
             B_p = field.generate_csr(Bempty)
             K = K + B_p
         
         if len(periodic_bcs) > 0:
-            logger.debug('    Implementing Periodic Boundary Conditions.')
+            logger.debug('Implementing Periodic Boundary Conditions.')
+
+
+        ############################################################
+        #                   PERIODIC BOUNDARY CONDITIONS          #
+        ############################################################
 
-        
-        # Periodic BCs
         Pmats = []
-        remove = set()
+        remove: set[int] = set()
         has_periodic = False
 
-        for bc in periodic_bcs:
+        for pbc in periodic_bcs:
+            logger.trace(f'.Implementing {pbc}')
             has_periodic = True
-            tri_ids_1 = mesh.get_triangles(bc.face1.tags)
-            edge_ids_1 = mesh.get_edges(bc.face1.tags)
-            tri_ids_2 = mesh.get_triangles(bc.face2.tags)
-            edge_ids_2 = mesh.get_edges(bc.face2.tags)
-            dv = np.array(bc.dv)
+            tri_ids_1 = mesh.get_triangles(pbc.face1.tags)
+            edge_ids_1 = mesh.get_edges(pbc.face1.tags)
+            tri_ids_2 = mesh.get_triangles(pbc.face2.tags)
+            edge_ids_2 = mesh.get_edges(pbc.face2.tags)
+            dv = np.array(pbc.dv)
+            logger.trace(f'..displacement vector {dv}')
             linked_tris = pair_coordinates(mesh.tri_centers, tri_ids_1, tri_ids_2, dv, 1e-9)
             linked_edges = pair_coordinates(mesh.edge_centers, edge_ids_1, edge_ids_2, dv, 1e-9)
-            dv = np.array(bc.dv)
-            phi = bc.phi(K0)
-            
+            dv = np.array(pbc.dv)
+            phi = pbc.phi(K0)
+            logger.trace(f'..ϕ={phi} rad/m')
             Pmat, rows = gen_periodic_matrix(tri_ids_1,
                                        edge_ids_1,
                                        field.tri_to_field,
@@ -351,20 +365,26 @@ class Assembler:
                                        phi)
             remove.update(rows)
             Pmats.append(Pmat)
-        
+
         if Pmats:
+            logger.trace(f'.periodic bc removes {len(remove)} boundary DoF')
             Pmat = Pmats[0]
             for P2 in Pmats[1:]:
                 Pmat = Pmat @ P2
-            remove = np.array(sorted(list(remove)))
+            remove_array = np.sort(np.unique(list(remove)))
             all_indices = np.arange(NF)
-            keep_indices = np.setdiff1d(all_indices, remove)
+            keep_indices = np.setdiff1d(all_indices, remove_array)
             Pmat = Pmat[:,keep_indices]
         else:
             Pmat = None
         
-        pec_ids = set(pec_ids)
-        solve_ids = np.array([i for i in range(E.shape[0]) if i not in pec_ids])
+
+        ############################################################
+        #                             FINALIZE                     #
+        ############################################################
+
+        pec_ids_set = set(pec_ids)
+        solve_ids = np.array([i for i in range(E.shape[0]) if i not in pec_ids_set])
         
         if has_periodic:
             mask = np.zeros((NF,))
@@ -419,20 +439,20 @@ class Assembler:
 
         er = er - 1j*sig/(w0*EPS0)*np.repeat(np.eye(3)[:, :, np.newaxis], er.shape[2], axis=2)
         
-        logger.debug('    Assembling matrices')
+        logger.debug('Assembling matrices')
         E, B = tet_mass_stiffness_matrices(field, er, ur)
         self.cached_matrices = (E, B)
 
         NF = E.shape[0]
 
         pecs: list[PEC] = [bc for bc in bcs if isinstance(bc,PEC)]
-        robin_bcs: list[RectangularWaveguide] = [bc for bc in bcs if isinstance(bc,RobinBC)]
+        robin_bcs: list[RectangularWaveguide] = [bc for bc in bcs if isinstance(bc,RobinBC)] # type: ignore
         periodic: list[Periodic] = [bc for bc in bcs if isinstance(bc, Periodic)]
 
         # Process all PEC Boundary Conditions
-        pec_ids = []
+        pec_ids: list = []
         
-        logger.debug('    Implementing PEC Boundary Conditions.')
+        logger.debug('Implementing PEC Boundary Conditions.')
         
         # Conductivity above a limit, consider it all PEC
         for itet in range(field.n_tets):
@@ -457,45 +477,52 @@ class Assembler:
 
         # Robin BCs
         if len(robin_bcs) > 0:
-            logger.debug('    Implementing Robin Boundary Conditions.')
+            logger.debug('Implementing Robin Boundary Conditions.')
+        
+        if len(robin_bcs) > 0:
+            logger.debug('Implementing Robin Boundary Conditions.')
         
-        for bc in robin_bcs:
-            for tag in bc.tags:
-                face_tags = [tag,]#bc.tags
-
-                tri_ids = mesh.get_triangles(face_tags)
-                nodes = mesh.get_nodes(face_tags)
-                edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
-
-                gamma = bc.get_gamma(k0)
-                
-                ibasis = bc.get_inv_basis()
-                if ibasis is None:
-                    basis = plane_basis_from_points(mesh.nodes[:,nodes]) + 1e-16
-                    ibasis = np.linalg.pinv(basis)
-                B_p = assemble_robin_bc(field, tri_ids, gamma)
-                if bc._include_stiff:
-                    B = B + B_p
+            gauss_points = gaus_quad_tri(4)
+            Bempty = field.empty_tri_matrix()
+            for bc in robin_bcs:
+
+                for tag in bc.tags:
+                    face_tags = [tag,]
+
+                    tri_ids = mesh.get_triangles(face_tags)
+                    nodes = mesh.get_nodes(face_tags)
+                    edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
+
+                    gamma = bc.get_gamma(k0)
+                    
+                    ibasis = bc.get_inv_basis()
+                    if ibasis is None:
+                        basis = plane_basis_from_points(mesh.nodes[:,nodes]) + 1e-16
+                        ibasis = np.linalg.pinv(basis)
+                    
+                    Bempty = assemble_robin_bc(field, Bempty, tri_ids, gamma) # type: ignore
+            B_p = field.generate_csr(Bempty)
+            B = B + B_p
         
         if len(periodic) > 0:
-            logger.debug('    Implementing Periodic Boundary Conditions.')
+            logger.debug('Implementing Periodic Boundary Conditions.')
 
         # Periodic BCs
         Pmats = []
         remove = set()
         has_periodic = False
 
-        for bc in periodic:
+        for bcp in periodic:
             has_periodic = True
-            tri_ids_1 = mesh.get_triangles(bc.face1.tags)
-            edge_ids_1 = mesh.get_edges(bc.face1.tags)
-            tri_ids_2 = mesh.get_triangles(bc.face2.tags)
-            edge_ids_2 = mesh.get_edges(bc.face2.tags)
-            dv = np.array(bc.dv)
+            tri_ids_1 = mesh.get_triangles(bcp.face1.tags)
+            edge_ids_1 = mesh.get_edges(bcp.face1.tags)
+            tri_ids_2 = mesh.get_triangles(bcp.face2.tags)
+            edge_ids_2 = mesh.get_edges(bcp.face2.tags)
+            dv = np.array(bcp.dv)
             linked_tris = pair_coordinates(mesh.tri_centers, tri_ids_1, tri_ids_2, dv, 1e-9)
             linked_edges = pair_coordinates(mesh.edge_centers, edge_ids_1, edge_ids_2, dv, 1e-9)
-            dv = np.array(bc.dv)
-            phi = bc.phi(k0)
+            dv = np.array(bcp.dv)
+            phi = bcp.phi(k0)
             
             Pmat, rows = gen_periodic_matrix(tri_ids_1,
                                        edge_ids_1,
@@ -513,15 +540,15 @@ class Assembler:
             for P2 in Pmats[1:]:
                 Pmat = Pmat @ P2
             Pmat = Pmat.tocsr()
-            remove = np.array(sorted(list(remove)))
+            remove_array = np.sort(np.array(list(remove)))
             all_indices = np.arange(NF)
-            keep_indices = np.setdiff1d(all_indices, remove)
+            keep_indices = np.setdiff1d(all_indices, remove_array)
             Pmat = Pmat[:,keep_indices]
         else:
             Pmat = None
         
-        pec_ids = set(pec_ids)
-        solve_ids = np.array([i for i in range(E.shape[0]) if i not in pec_ids])
+        pec_ids_set = set(pec_ids)
+        solve_ids = np.array([i for i in range(E.shape[0]) if i not in pec_ids_set])
         
         if has_periodic:
             mask = np.zeros((NF,))

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

@@ -22,16 +22,12 @@ from numba_progress import ProgressBar, ProgressBarType
 from ....mth.optimized import local_mapping, matinv, dot_c, cross_c, compute_distances
 from numba import c16, types, f8, i8, njit, prange
 
-
 ############################################################
 #                  CACHED FACTORIAL VALUES                 #
 ############################################################
 
-
 _FACTORIALS = np.array([1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880], dtype=np.int64)
 
-
-
 ############################################################
 #                  INDEX MAPPING FUNCTIONS                 #
 ############################################################
@@ -264,7 +260,6 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             Dmat[ei+0,ej+10] = Q*VAD
             Dmat[ei+10,ej+0] = Q*VBC
             Dmat[ei+10,ej+10] = Q*VBD
-
             
             Fmat[ei+0,ej+0] = Q2*(VABCD*BD1-VABCC*BE1-VAACD*BF1+VAACC*BG1)
             Fmat[ei+0,ej+10] = Q2*(VABDD*BD1-VABCD*BE1-VAADD*BF1+VAACD*BG1)
@@ -313,7 +308,6 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             BH1 = dot_c(GB,BC1)
             BI1 = dot_c(GA,BD1)
             BJ1 = dot_c(GB,BD1)
-
             
             Dmat[ei+0,ej+6] = L1*Lac2*(-6*VAD*AI1-3*VAC*AJ1-3*VAF*AK1)
             Dmat[ei+0,ej+16] = L1*Lab2*(6*VAF*AK1+3*VAD*AI1-3*VAC*AJ1)
@@ -372,7 +366,6 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             VBCEF = VOLUME_COEFF_CACHE[B,E,F,C]
             VADEF = VOLUME_COEFF_CACHE[E,A,D,F]
 
-            
             Lac2 = Ds[ej1, fj]
             Lab2 = Ds[ej1, ej2]
 
@@ -447,7 +440,7 @@ def _matrix_builder(nodes, tets, tris, edges, all_edge_lengths, tet_to_field, te
     dataB = np.empty_like(rows, dtype=np.complex128)
 
     
-    for itet in prange(nT):
+    for itet in prange(nT): # ty: ignore
         p = itet*400
         if np.mod(itet,10)==0:
             pgb.update(10)

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

@@ -17,21 +17,33 @@
 
 import numpy as np
 from ....elements.nedleg2 import NedelecLegrange2
-from scipy.sparse import coo_matrix
+from scipy.sparse import csr_matrix
 from numba_progress import ProgressBar, ProgressBarType
 from ....mth.optimized import local_mapping, matinv, 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)
 
+
+
+############################################################
+#                     PYTHON INTERFACE                     #
+############################################################
+
 def generelized_eigenvalue_matrix(field: NedelecLegrange2,
                            er: np.ndarray, 
                            ur: np.ndarray,
                            basis: np.ndarray,
-                           k0: float,) -> tuple[coo_matrix, coo_matrix]:
+                           k0: float,) -> tuple[csr_matrix, csr_matrix]:
     
     tris = field.mesh.tris
     edges = field.mesh.edges
@@ -47,11 +59,16 @@ def generelized_eigenvalue_matrix(field: NedelecLegrange2,
     
     nfield = field.n_field
 
-    E = coo_matrix((dataE, (rows, cols)), shape=(nfield, nfield)).tocsr()
-    B = coo_matrix((dataB, (rows, cols)), shape=(nfield, nfield)).tocsr()
+    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)
@@ -59,7 +76,10 @@ def matmul(a, b):
     out[1,:] = a[1,0]*b[0,:] + a[1,1]*b[1,:]
     return out
 
-### GAUSS QUADRATURE IMPLEMENTATION
+
+############################################################
+#              GAUSS QUADRATURE IMPLEMENTATION             #
+############################################################
 
 @njit(c16(c16[:], c16[:], types.Array(types.float64, 1, 'A', readonly=True)), cache=True, nogil=True)
 def _gqi(v1, v2, W):
@@ -185,7 +205,12 @@ def _nf2_curl(coeff, coords):
     ys = coords[1,:]
     return 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) + 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):
 
@@ -211,13 +236,23 @@ def tri_coefficients(vxs, vys):
     Cs = np.array([c1, c2, c3])*sign
     return As, Bs, Cs, A
 
-#DPTS = gaus_quad_tri(4).astype(np.float64)
+
+############################################################
+#                    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'''
@@ -402,7 +437,7 @@ def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0, pgb: ProgressB
 
     tri_to_edge = tri_to_field[:3,:]
     
-    for itri in prange(ntritot):
+    for itri in prange(ntritot): # type: ignore
         p = itri*196
         if np.mod(itri,10)==0:
             pgb.update(10)

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

@@ -252,7 +252,7 @@ def ned2_tri_stiff_force(lcs_vertices, gamma, lcs_Uinc, DPTs):
 def compute_bc_entries_excited(vertices_local, tris, Bmat, Bvec, surf_triangle_indices, gamma, Ulocal_all, DPTs, tri_to_field):
     N = 64
     Niter = surf_triangle_indices.shape[0]
-    for i in prange(Niter):
+    for i in prange(Niter): # type: ignore
         itri = surf_triangle_indices[i]
 
         vertex_ids = tris[:, itri]
@@ -388,7 +388,7 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
 def compute_bc_entries(vertices, tris, Bmat, all_edge_lengths, surf_triangle_indices, gamma):
     N = 64
     Niter = surf_triangle_indices.shape[0]
-    for i in prange(Niter):
+    for i in prange(Niter): # type: ignore
         itri = surf_triangle_indices[i]
 
         vertex_ids = tris[:, itri]
@@ -404,7 +404,7 @@ def assemble_robin_bc_excited(field: Nedelec2,
                               Bmat: np.ndarray,
                 surf_triangle_indices: np.ndarray,
                 Ufunc: Callable,
-                gamma: np.ndarray,
+                gamma: complex,
                 local_basis: np.ndarray,
                 origin: np.ndarray,
                 DPTs: np.ndarray):
@@ -424,8 +424,8 @@ def assemble_robin_bc_excited(field: Nedelec2,
 
 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)