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

emerge/_emerge/mesh3d.py

@@ -146,6 +146,7 @@ class Mesh3D(Mesh):
         self.ftag_to_node: dict[int, list[int]] = dict()
         self.ftag_to_edge: dict[int, list[int]] = dict()
         self.vtag_to_tet:  dict[int, list[int]] = dict()
+        self.etag_to_edge: dict[int, list[int]] = dict()
         
         self.exterior_face_tags: list[int] = []
     
@@ -176,7 +177,7 @@ class Mesh3D(Mesh):
         search = (min(int(i1),int(i2)), max(int(i1),int(i2)))
         result =  self.inv_edges.get(search, -10)
         if result == -10:
-            ValueError(f'There is no edge with indices {i1}, {i2}')
+            raise ValueError(f'There is no edge with indices {i1}, {i2}')
         return result
     
     def get_edge_sign(self, i1: int, i2: int) -> int:
@@ -240,6 +241,31 @@ class Mesh3D(Mesh):
 
         return np.array(indices)
     
+    def domain_edges(self, dimtags: list[tuple[int,int]]) -> np.ndarray:
+        """Returns a np.ndarray of all edge indices corresponding to a set of dimension tags.
+
+        Args:
+            dimtags (list[tuple[int,int]]): A list of dimtags.
+
+        Returns:
+            np.ndarray: The list of mesh edge element indices.
+        """
+        dimtags_edge = []
+        for (d,t) in dimtags:
+            if d==1:
+                dimtags_edge.append(t)
+            if d==2:
+                dimtags_edge.extend(gmsh.model.getBoundary([(d,t),], False, False))
+            if d==3:
+                dts = gmsh.model.getBoundary([(d,t),], False, False)
+                dimtags_edge.extend(gmsh.model.getBoundary(dts, False, False))
+        
+        edge_ids = []
+        for tag in dimtags_edge:
+            edge_ids.extend(self.etag_to_edge[tag[1]])
+        edge_ids = np.array(edge_ids)
+        return edge_ids
+        
     def get_face_tets(self, *taglist: list[int]) -> np.ndarray:
         ''' Return a list of a tetrahedrons that share a node with any of the nodes in the provided face.'''
         nodes: set = set()
@@ -271,6 +297,8 @@ class Mesh3D(Mesh):
     
     
     def update(self, periodic_bcs: list[Periodic] | None = None):
+        
+        logger.trace('Generating mesh data.')
         if periodic_bcs is None:
             periodic_bcs = []
             
@@ -282,7 +310,7 @@ class Mesh3D(Mesh):
         self.nodes = coords
         self.n_i2t = {i: int(t) for i, t in enumerate(nodes)}
         self.n_t2i = {t: i for i, t in self.n_i2t.items()}
-
+        logger.trace(f'Total of {self.nodes.shape[1]} nodes imported.')
         ## Tetrahedras
 
         _, tet_tags, tet_node_tags = gmsh.model.mesh.get_elements(3)
@@ -297,8 +325,8 @@ class Mesh3D(Mesh):
         self.tets = np.array(tet_node_tags).reshape(-1,4).T
         self.tet_i2t = {i: int(t) for i, t in enumerate(tet_tags)}
         self.tet_t2i = {t: i for i, t in self.tet_i2t.items()}
-
         self.centers = (self.nodes[:,self.tets[0,:]] + self.nodes[:,self.tets[1,:]] + self.nodes[:,self.tets[2,:]] + self.nodes[:,self.tets[3,:]]) / 4
+        logger.trace(f'Total of {self.tets.shape[1]} tetrahedra imported.')
         
         # Resort node indices to be sorted on all periodic conditions
         # This sorting makes sure that each edge and triangle on a source face is 
@@ -307,6 +335,7 @@ class Mesh3D(Mesh):
         # Then this ensures that if i1>i2>i3 then j1>j2>j3
     
         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 = {int(a): int(b) for a,b in nodemap.items()}
             self.nodes[:,ids2] = self.nodes[:,ids1]
@@ -330,25 +359,26 @@ class Mesh3D(Mesh):
             triset.add((i1,i2,i4))
             triset.add((i1,i3,i4))
             triset.add((i2,i3,i4))
-
+        logger.trace(f'Total of {len(edgeset)} unique edges and {len(triset)} unique triangles.')
+        
         # Edges are effectively Randomly sorted
         # It contains index pairs of vertices edge 1 = (ev1, ev2) etc.
-        # Same for traingles
+        # Same for triangles
         self.edges = np.array(sorted(list(edgeset))).T
         self.tris = np.array(sorted(list(triset))).T
-        
         self.tri_centers = (self.nodes[:,self.tris[0,:]] + self.nodes[:,self.tris[1,:]] + self.nodes[:,self.tris[2,:]]) / 3
+        
         def _hash(ints):
             return tuple(sorted([int(x) for x in ints]))
         
         # Map edge index tuples to edge indices
         # This mapping tells which characteristic index pair (4,3) maps to which edge
+        logger.trace('Constructing tet/tri/edge and node mappings.')
         self.inv_edges = {(int(self.edges[0,i]), int(self.edges[1,i])): i for i in range(self.edges.shape[1])}
         self.inv_tris = {_hash((self.tris[0,i], self.tris[1,i], self.tris[2,i])): i for i in range(self.tris.shape[1])}
         self.inv_tets = {_hash((self.tets[0,i], self.tets[1,i], self.tets[2,i], self.tets[3,i])): i for i in range(self.tets.shape[1])}
         
         # Tet links
-
         self.tet_to_edge = np.zeros((6, self.tets.shape[1]), dtype=int)-99999
         self.tet_to_edge_sign = np.zeros((6, self.tets.shape[1]), dtype=int)-999999
         self.tet_to_tri = np.zeros((4, self.tets.shape[1]), dtype=int)-99999
@@ -414,14 +444,32 @@ class Mesh3D(Mesh):
         self.node_to_edge = {key: sorted(list(set(val))) for key, val in self.node_to_edge.items()}
 
         ## Quantities
-
+        logger.trace('Computing derived quantaties (centres, areas and lengths).')
         self.edge_centers = (self.nodes[:,self.edges[0,:]] + self.nodes[:,self.edges[1,:]]) / 2
         self.edge_lengths = np.sqrt(np.sum((self.nodes[:,self.edges[0,:]] - self.nodes[:,self.edges[1,:]])**2, axis=0))
         self.areas = np.array([area(self.nodes[:,self.tris[0,i]], self.nodes[:,self.tris[1,i]], self.nodes[:,self.tris[2,i]]) for i in range(self.tris.shape[1])])
         
+        ## Edge tag pairings
+        _, edge_tags, edge_node_tags = gmsh.model.mesh.get_elements(1)
+        edge_tags = np.array(edge_tags).flatten()
+        ent = np.array(edge_node_tags).reshape(-1,2).T
+        nET = ent.shape[1]
+        self.edge_t2i = {int(edge_tags[i]): self.get_edge(self.n_t2i[ent[0,i]], self.n_t2i[ent[1,i]]) for i in range(nET)}
+        self.edge_i2t = {i: t for t, i in self.edge_t2i.items()}
+        
+        edge_dimtags = gmsh.model.get_entities(1)
+        for _d, t in edge_dimtags:
+            _, edge_tags, node_tags = gmsh.model.mesh.get_elements(1, t)
+            if not edge_tags:
+                self.etag_to_edge[t] = []
+                continue
+            self.etag_to_edge[t] = [int(self.edge_t2i[tag]) for tag in edge_tags[0]]
+        
+        
         ## Tag bindings
+        logger.trace('Constructing geometry to mesh mappings.')
         face_dimtags = gmsh.model.get_entities(2)
-        for d,t in face_dimtags:
+        for _d,t in face_dimtags:
             domain_tag, f_tags, node_tags = gmsh.model.mesh.get_elements(2, t)
             node_tags = [self.n_t2i[int(t)] for t in node_tags[0]]
             self.ftag_to_node[t] = node_tags
@@ -430,13 +478,14 @@ class Mesh3D(Mesh):
             self.ftag_to_edge[t] = sorted(list(np.unique(self.tri_to_edge[:,self.ftag_to_tri[t]].flatten())))
         
         vol_dimtags = gmsh.model.get_entities(3)
-        for d,t in vol_dimtags:
+        for _d,t in vol_dimtags:
             domain_tag, v_tags, node_tags = gmsh.model.mesh.get_elements(3, t)
             node_tags = [self.n_t2i[int(t)] for t in node_tags[0]]
             node_tags = np.squeeze(np.array(node_tags)).reshape(-1,4).T
             self.vtag_to_tet[t] = [self.get_tet(node_tags[0,i], node_tags[1,i], node_tags[2,i], node_tags[3,i]) for i in range(node_tags.shape[1])]
 
         self.defined = True
+        logger.trace('Done analyzing mesh.')
 
 
     ## Higher order functions
@@ -455,7 +504,7 @@ class Mesh3D(Mesh):
         Returns:
             tuple[dict[int, int], np.ndarray, np.ndarray]: The node index mapping and the node index arrays
         """
-        
+
         node_ids_1 = []
         node_ids_2 = []
 
@@ -597,9 +646,9 @@ class Mesh3D(Mesh):
         tri_ids = self.get_triangles(face_tags)
         if origin is None:
             nodes = self.nodes[:,self.get_nodes(face_tags)]
-            x0 = np.mean(nodes[0,:])
-            y0 = np.mean(nodes[1,:])
-            z0 = np.mean(nodes[2,:])
+            x0 = float(np.mean(nodes[0,:]))
+            y0 = float(np.mean(nodes[1,:]))
+            z0 = float(np.mean(nodes[2,:]))
             origin = (x0, y0, z0)
 
         return SurfaceMesh(self, tri_ids, origin)

emerge/_emerge/mesher.py

@@ -79,6 +79,7 @@ class Mesher:
         self.max_size: float = None
         self.periodic_cell: PeriodicCell = None
 
+        
     @property
     def edge_tags(self) -> list[int]:
         return [tag[1] for tag in gmsh.model.getEntities(1)]
@@ -244,7 +245,7 @@ class Mesher:
         for dimtag in dimtags:
             gmsh.model.mesh.setSizeFromBoundary(dimtag[0], dimtag[1], 0)
             
-    def set_boundary_size(self, boundary: GeoSurface | FaceSelection | Iterable, 
+    def set_boundary_size(self, boundary: GeoObject | Selection | Iterable, 
                           size:float,
                           growth_rate: float = 1.4,
                           max_size: float | None = None) -> None:
@@ -272,8 +273,10 @@ class Mesher:
         nodes = gmsh.model.getBoundary(dimtags, combined=False, oriented=False, recursive=False)
 
         disttag = gmsh.model.mesh.field.add("Distance")
-
-        gmsh.model.mesh.field.setNumbers(disttag, "CurvesList", [n[1] for n in nodes])
+        if boundary.dim==2:
+            gmsh.model.mesh.field.setNumbers(disttag, "CurvesList", [n[1] for n in nodes])
+        if boundary.dim==3:
+            gmsh.model.mesh.field.setNumbers(disttag,'SurfacesList', [n[1] for n in nodes])
         gmsh.model.mesh.field.setNumber(disttag, "Sampling", 100)
 
         thtag = gmsh.model.mesh.field.add("Threshold")
@@ -285,7 +288,7 @@ class Mesher:
     
         self.mesh_fields.append(thtag)
 
-    def set_domain_size(self, obj: GeoVolume | Selection, size: float):
+    def set_domain_size(self, obj: GeoObject | Selection, size: float):
         """Manually set the maximum element size inside a domain
 
         Args:

emerge/_emerge/mth/optimized.py

@@ -432,6 +432,36 @@ def matinv(M: np.ndarray) -> np.ndarray:
         out = out*det
     return out
 
+@njit(f8[:,:](f8[:,:]), cache=True, nogil=True)
+def matinv_r(M: np.ndarray) -> np.ndarray:
+    """Optimized matrix inverse of 3x3 matrix
+
+    Args:
+        M (np.ndarray): Input matrix M of shape (3,3)
+
+    Returns:
+        np.ndarray: The matrix inverse inv(M)
+    """
+    out = np.zeros((3,3), dtype=np.float64)
+   
+    if M[0,1]==0 and M[0,2]==0 and M[1,0]==0 and M[1,2]==0 and M[2,0]==0 and M[2,1]==0:
+        out[0,0] = 1/M[0,0]
+        out[1,1] = 1/M[1,1]
+        out[2,2] = 1/M[2,2]
+    else:
+        det = M[0,0]*M[1,1]*M[2,2] - M[0,0]*M[1,2]*M[2,1] - M[0,1]*M[1,0]*M[2,2] + M[0,1]*M[1,2]*M[2,0] + M[0,2]*M[1,0]*M[2,1] - M[0,2]*M[1,1]*M[2,0]
+        out[0,0] = M[1,1]*M[2,2] - M[1,2]*M[2,1]
+        out[0,1] = -M[0,1]*M[2,2] + M[0,2]*M[2,1]
+        out[0,2] = M[0,1]*M[1,2] - M[0,2]*M[1,1]
+        out[1,0] = -M[1,0]*M[2,2] + M[1,2]*M[2,0]
+        out[1,1] = M[0,0]*M[2,2] - M[0,2]*M[2,0]
+        out[1,2] = -M[0,0]*M[1,2] + M[0,2]*M[1,0]
+        out[2,0] = M[1,0]*M[2,1] - M[1,1]*M[2,0]
+        out[2,1] = -M[0,0]*M[2,1] + M[0,1]*M[2,0]
+        out[2,2] = M[0,0]*M[1,1] - M[0,1]*M[1,0]
+        out = out*det
+    return out
+
 @njit(cache=True, nogil=True)
 def matmul(M: np.ndarray, vecs: np.ndarray):
     """Executes a basis transformation of vectors (3,N) with a basis matrix M

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