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

emerge/_emerge/periodic.py

@@ -1,5 +1,22 @@
+# 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/>.
+
 from .cs import Axis, _parse_axis, GCS, _parse_vector
-from .selection import FaceSelection, SELECTOR_OBJ, Selection
+from .selection import SELECTOR_OBJ, Selection
 from .geo import GeoPrism, XYPolygon, Alignment, XYPlate
 from .bc import BoundaryCondition
 from typing import Generator
@@ -7,7 +24,6 @@ from .bc import Periodic
 import numpy as np
 
 
-
 ############################################################
 #                         FUNCTIONS                        #
 ############################################################
@@ -21,7 +37,9 @@ def _rotnorm(v: np.ndarray) -> np.ndarray:
     ax = ax/np.linalg.norm(ax)
     return ax
 
-def _pair_selection(f1: Selection, f2: Selection, translation: tuple[float, float, float]):
+def _pair_selection(f1: Selection, 
+                    f2: Selection, 
+                    translation: tuple[float, float, float]):
     if len(f1.tags) == 1:
         return [f1,], [f2,]
     c1s = [np.array(c) for c in f1.centers]
@@ -175,13 +193,17 @@ class RectCell(PeriodicCell):
     def cell_data(self):
         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])
+        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])
-        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])
+        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])
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
             yield f1, f2, vec
 
@@ -206,13 +228,15 @@ class HexCell(PeriodicCell):
                  point1: tuple[float, float, float],
                  point2: tuple[float, float, float],
                  point3: tuple[float, float, float]):
-        """Generates a Hexagonal periodic tiling by providing 4 coordinates. The layout of the tiling is as following
-        Assuming a hexagon with a single vertext at the top and bottom and two vertices on the left and right faces ⬢
+        """
+        Generates a Hexagonal periodic tiling by providing three coordinates.
+        The layout of the tiling assumes a hexagon with a single vertex at the top and bottom,
+        and one vertex on the bottom and right faces (⬢).
 
         Args:
-            p1 (tuple[float, float, float]): left face top vertex
-            p2 (tuple[float, float, float]): left face bottom vertex
-            p3 (tuple[float, float, float]): bottom vertex
+            point1 (tuple[float, float, float]): left face top vertex
+            point2 (tuple[float, float, float]): left face bottom vertex
+            point3 (tuple[float, float, float]): bottom vertex
         """
         p1, p2, p3 = np.array(point1), np.array(point2), np.array(point3)
         p4 = -p1
@@ -249,8 +273,10 @@ 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]).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]).exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
+        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])\
+            .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)
 
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore
@@ -259,8 +285,10 @@ 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]).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]).exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
+        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])\
+            .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
             yield f1, f2, vec
@@ -268,8 +296,10 @@ 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]).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]).exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
+        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])\
+            .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
             yield f1, f2, vec

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

@@ -132,7 +132,7 @@ class Assembler:
         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
+        from .generalized_eigen_hb import generelized_eigenvalue_matrix
         logger.debug('Assembling Boundary Mode Matrices')
 
         bcs = bc_set.boundary_conditions
@@ -167,8 +167,6 @@ class Assembler:
                 pec_ids.extend(list(nedlegfield.tri_to_field[:,it]))
 
         # Process all PEC Boundary Conditions
-        pec_edges = []
-        pec_vertices = []
         for pec in pecs:
             logger.trace(f'.implementing {pec}')
             face_tags = pec.tags
@@ -180,16 +178,6 @@ class Assembler:
                     continue
                 eids = nedlegfield.edge_to_field[:, i2]
                 pec_ids.extend(list(eids))
-                pec_edges.append(eids[0])
-                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:
-                    continue
-                tids = nedlegfield.tri_to_field[:, i2]
-                pec_ids.extend(list(tids))
 
         # Process all port boundary Conditions
         pec_ids_set: set[int] = set(pec_ids)
@@ -312,16 +300,11 @@ class Assembler:
                     gamma = bc.get_gamma(K0)
                     logger.trace(f'..robin bc γ={gamma:.3f}')
 
-                    def Ufunc(x,y): 
-                        return bc.get_Uinc(x,y,K0)
+                    def Ufunc(x,y,z): 
+                        return bc.get_Uinc(x,y,z,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)
-                        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) # type: ignore
+                        Bempty, b_p = assemble_robin_bc_excited(field, Bempty, tri_ids, Ufunc, gamma, 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:

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

@@ -19,7 +19,7 @@ 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
+from ....mth.optimized import local_mapping, matinv, compute_distances, gaus_quad_tri
 from numba import c16, types, f8, i8, njit, prange
 
 
@@ -52,7 +52,7 @@ def generelized_eigenvalue_matrix(field: NedelecLegrange2,
     nT = tris.shape[1]
     tri_to_field = field.tri_to_field
 
-    nodes = np.linalg.pinv(basis) @ nodes
+    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)
@@ -179,6 +179,7 @@ def _ne1_curl(coeff, coords):
     ys = coords[1,:]
     return -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]
@@ -195,7 +196,7 @@ def _nf1_curl(coeff, coords):
     xs = coords[0,:]
     ys = coords[1,:]
     return -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) + 0*1j
-
+           
 @njit(c16[:](f8[:,:], f8[:,:]), cache=True, nogil=True)
 def _nf2_curl(coeff, coords):
     a1, b1, c1 = coeff[:,0]
@@ -204,7 +205,7 @@ def _nf2_curl(coeff, coords):
     xs = coords[0,:]
     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    #
@@ -243,9 +244,9 @@ def tri_coefficients(vxs, vys):
 
 
 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)
+                 [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)
 
 
 ############################################################
@@ -266,7 +267,6 @@ def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
     Dzz2 = np.zeros((6,6), dtype=np.complex128)
     
     Ls = np.ones((14,14), dtype=np.float64)
-    #Ls2 = np.ones((14,14), dtype=np.float64)
 
     WEIGHTS = DPTS[0,:]
     DPTS1 = DPTS[1,:]
@@ -297,13 +297,11 @@ def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
     Ms = Ms[:2,:2]
     Mm = Mm[:2,:2]
 
-    fid = np.array([0,1,2], dtype=np.int64)
-
     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]
         
@@ -318,9 +316,12 @@ def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
         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)
@@ -332,15 +333,15 @@ def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
             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, matmul(Ms,_ne1(coeff[:,ei2],cs)), WEIGHTS)
-            Dtt[iv1+4,iv2]   = _gqi2(F4, matmul(Ms,_ne1(coeff[:,ei2],cs)), WEIGHTS)
-            Dtt[iv1,iv2+4]   = _gqi2(F3, matmul(Ms,_ne2(coeff[:,ei2],cs)), WEIGHTS)
-            Dtt[iv1+4,iv2+4] = _gqi2(F4, matmul(Ms,_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, matmul(Ms,_ne1(coeff[:,ei2],cs)), WEIGHTS)
-            Dzt[iv1+3, iv2]   = _gqi2(F6, matmul(Ms,_ne1(coeff[:,ei2],cs)), WEIGHTS)
-            Dzt[iv1, iv2+4]   = _gqi2(F5, matmul(Ms,_ne2(coeff[:,ei2],cs)), WEIGHTS)
-            Dzt[iv1+3, iv2+4] = _gqi2(F6, matmul(Ms,_ne2(coeff[:,ei2],cs)), 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)
@@ -357,6 +358,7 @@ def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
         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)
@@ -412,6 +414,8 @@ def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
     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