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

emerge/_emerge/mesher.py

@@ -15,12 +15,12 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-import gmsh
+import gmsh # type: ignore
 from .geometry import GeoVolume, GeoObject, GeoSurface
 from .selection import Selection, FaceSelection
 from .periodic import PeriodicCell
 import numpy as np
-from typing import Iterable, Callable
+from typing import Iterable, Callable, Any, TypeVar
 from loguru import logger
 from enum import Enum
 from .bc import Periodic
@@ -55,7 +55,9 @@ _DOM_TO_STR = {
     2: "face",
     3: "volume",
 }
-def unpack_lists(_list: list[list], collector: list = None) -> list:
+
+T = TypeVar('T')
+def unpack_lists(_list: Any, collector: list | None = None) -> list[Any]:
     '''Unpack a recursive list of lists'''
     if collector is None:
         collector = []
@@ -116,7 +118,7 @@ class Mesher:
             raise MeshError('Either maximum or minimum mesh size is undefined. Make sure \
                             to set the simulation frequency range before calling mesh instructions.')
     
-    def submit_objects(self, objects: list[GeoObject]) -> None:
+    def submit_objects(self, objects: GeoObject | list[GeoObject] | list[list[GeoObject]]) -> None:
         """Takes al ist of GeoObjects and computes the fragment. 
 
         Args:
@@ -126,16 +128,15 @@ class Mesher:
             objects = [objects,]
 
         objects = unpack_lists(objects)
-        embeddings = []
-
+        embeddings: list = []
         gmsh.model.occ.synchronize()
 
-        final_dimtags = unpack_lists([domain.dimtags for domain in objects])
+        final_dimtags = unpack_lists([domain.dimtags for domain in objects]) # type: ignore
 
         dom_mapping = dict()
-        for dom in objects:
-            embeddings.extend(dom._embeddings)
-            for dt in dom.dimtags:
+        for dom in objects: # type: ignore
+            embeddings.extend(dom._embeddings) # type: ignore
+            for dt in dom.dimtags: # type: ignore
                 dom_mapping[dt] = dom
         
 
@@ -145,24 +146,24 @@ class Mesher:
                                         1: dict(),
                                         2: dict(),
                                         3: dict()}
-        if len(objects) > 0:
+        if len(objects) > 0: # type: ignore
             dimtags, output_mapping = gmsh.model.occ.fragment(final_dimtags, embedding_dimtags)
 
             for domain, mapping in zip(final_dimtags + embedding_dimtags, output_mapping):
                 tag_mapping[domain[0]][domain[1]] = [o[1] for o in mapping]
-            for dom in objects:
-                dom.update_tags(tag_mapping)
+            for dom in objects: # type: ignore
+                dom.update_tags(tag_mapping) # type: ignore
         else:
             dimtags = final_dimtags
         
-        self.objects = objects
+        self.objects = objects # type: ignore
         
         gmsh.model.occ.synchronize()
 
     def _set_mesh_periodicity(self, 
-                     face1: FaceSelection,
-                     face2: FaceSelection,
-                     lattice: tuple[float,float,float]):
+                     face1: Selection,
+                     face2: Selection,
+                     lattice: np.ndarray):
         translation = [1,0,0,lattice[0],
                        0,1,0,lattice[1],
                        0,0,1,lattice[2],
@@ -175,7 +176,7 @@ class Mesher:
         for tag in obj.tags:
             gmsh.model.mesh.setAlgorithm(obj.dim, tag, algorithm.value)
             
-    def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: list[FaceSelection] = None):
+    def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: Selection | None = None):
         """Sets the periodic cell information based on the PeriodicCell class object"""
         if excluded_faces is None:
             for f1, f2, lat in cell.cell_data():
@@ -243,10 +244,10 @@ class Mesher:
         for dimtag in dimtags:
             gmsh.model.mesh.setSizeFromBoundary(dimtag[0], dimtag[1], 0)
             
-    def set_boundary_size(self, object: GeoSurface | FaceSelection, 
+    def set_boundary_size(self, boundary: GeoSurface | FaceSelection | Iterable, 
                           size:float,
                           growth_rate: float = 1.4,
-                          max_size: float = None):
+                          max_size: float | None = None) -> None:
         """Refine the mesh size along the boundary of a conducting surface
 
         Args:
@@ -255,8 +256,12 @@ class Mesher:
             growth_rate (float, optional): _description_. Defaults to 1.1.
             max_size (float, optional): _description_. Defaults to None.
         """
+        if isinstance(boundary, Iterable):
+            for bound in boundary:
+                self.set_boundary_size(bound, size, growth_rate, max_size)
+            return
         
-        dimtags = object.dimtags
+        dimtags = boundary.dimtags
 
         if max_size is None:
             self._check_ready()

emerge/_emerge/mth/integrals.py

@@ -60,7 +60,7 @@ def _fast_integral_f(nodes, triangles, constants, DPTs, field_values):
 def surface_integral(nodes: np.ndarray, 
                      triangles: np.ndarray, 
                      function: Callable, 
-                     constants: np.ndarray = None,
+                     constants: np.ndarray | None = None,
                      gq_order: int = 4) -> complex:
     """Computes the surface integral of a scalar-field
 

emerge/_emerge/mth/pairing.py

@@ -27,7 +27,7 @@ ALL PAIRED NODES ARE NO LONGER VISITED
 """
 
 import numpy as np
-from numba import njit, f8, i8
+from numba import njit, f8, i8 # type: ignore
 
 
 ############################################################
@@ -72,7 +72,7 @@ def link_coords(coords: np.ndarray, ids1: np.ndarray, ids2: np.ndarray, disp: np
 #                   MAIN PYTHON INTERFACE                  #
 ############################################################
 
-def pair_coordinates(coords: np.ndarray, ids1: list[int], ids2: list[int], disp: np.ndarray, dsmax: float) -> dict[int, int]:
+def pair_coordinates(coords: np.ndarray, ids1: np.ndarray, ids2: np.ndarray, disp: np.ndarray, dsmax: float) -> dict[int, int]:
     """ This function finds the mapping between a total coordinate set and two lits of indices.
 
     The indices correspond to two faces that are identical but displaced (mesh centroids of periodic boundaries).

emerge/_emerge/periodic.py

@@ -1,5 +1,5 @@
-from .cs import Axis, _parse_axis, GCS
-from .selection import FaceSelection, SELECTOR_OBJ
+from .cs import Axis, _parse_axis, GCS, _parse_vector
+from .selection import FaceSelection, SELECTOR_OBJ, Selection
 from .geo import GeoPrism, XYPolygon, Alignment, XYPlate
 from .bc import BoundaryCondition
 from typing import Generator
@@ -21,7 +21,7 @@ def _rotnorm(v: np.ndarray) -> np.ndarray:
     ax = ax/np.linalg.norm(ax)
     return ax
 
-def _pair_selection(f1: FaceSelection, f2: FaceSelection, 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]
@@ -32,8 +32,8 @@ def _pair_selection(f1: FaceSelection, f2: FaceSelection, translation: tuple[flo
     for t1, c1 in zip(f1.tags, c1s):
         for t2, c2 in zip(f2.tags, c2s):
             if np.linalg.norm((c1 + ds)-c2) < 1e-6:
-                f1s.append(FaceSelection([t1,]))
-                f2s.append(FaceSelection([t2,]))
+                f1s.append(Selection([t1,]))
+                f2s.append(Selection([t2,]))
     return f1s, f2s
 
 
@@ -42,15 +42,16 @@ def _pair_selection(f1: FaceSelection, f2: FaceSelection, translation: tuple[flo
 #                 BASE PERIODIC CELL CLASS                #
 ############################################################
 
-
+# TODO: This must be moved to mw physics if possible
 class PeriodicCell:
 
     def __init__(self, 
-                 origins: list[tuple[float, float, float]],
-                 vectors: list[tuple[float, float, float] | Axis]):
-        self.origins: list[tuple[float, float, float]] = origins
+                 origins: list[tuple[float, float, float] | list[float] | np.ndarray | Axis],
+                 vectors: list[tuple[float, float, float] | list[float] | np.ndarray | Axis]):
+
+        self.origins: list[tuple[float, float, float]] = [_parse_vector(origin) for origin in origins] # type: ignore
         self.vectors: list[Axis] = [_parse_axis(vec) for vec in vectors]
-        self.excluded_faces: FaceSelection = None
+        self.excluded_faces: Selection | None = None
         self._bcs: list[Periodic] = []
         self._ports: list[BoundaryCondition] = []
 
@@ -71,7 +72,7 @@ class PeriodicCell:
         """
         raise NotImplementedError('This method is not implemented for this subclass.')
     
-    def cell_data(self) -> Generator[tuple[FaceSelection,FaceSelection,tuple[float, float, float]], None, None]:
+    def cell_data(self) -> Generator[tuple[Selection, Selection, np.ndarray], None, None]:
         """An iterator that yields the two faces of the hex cell plus a cell periodicity vector
 
         Yields:
@@ -84,15 +85,17 @@ class PeriodicCell:
         """
         bcs = []
         for f1, f2, a in self.cell_data():
+            f1_new = f1
+            f2_new = f2
             if self.excluded_faces is not None:
-                f1 = f1 - self.excluded_faces
-                f2 = f2 - self.excluded_faces
-            bcs.append(Periodic(f1, f2, a))
+                f1_new = f1 - self.excluded_faces # type: ignore
+                f2_new = f2 - self.excluded_faces # type: ignore
+            bcs.append(Periodic(f1_new, f2_new, tuple(a)))
         self._bcs = bcs
         return bcs
     
     @property
-    def bcs(self) -> list[Periodic]:
+    def bcs(self) -> list[BoundaryCondition]:
         """Returns a list of Periodic boundary conditions for the given PeriodicCell
 
         Args:
@@ -103,7 +106,7 @@ class PeriodicCell:
         """
         if not self._bcs:
             raise ValueError('Periodic Boundary conditions not generated')
-        return self._bcs + self._ports
+        return self._bcs + self._ports # type: ignore
     
     def set_scanangle(self, theta: float, phi: float, degree: bool = True) -> None:
         """Sets the scanangle for the periodic condition. (0,0) is defined along the Z-axis
@@ -126,8 +129,8 @@ class PeriodicCell:
             bc.uy = uy
             bc.uz = uz
         for port in self._ports:
-            port.scan_theta = theta
-            port.scan_phi = phi
+            port.scan_theta = theta # type: ignore
+            port.scan_phi = phi # type: ignore
 
     def port_face(self, z: float):
         raise NotImplementedError('')
@@ -200,9 +203,9 @@ class RectCell(PeriodicCell):
 class HexCell(PeriodicCell):
 
     def __init__(self,
-                 p1: tuple[float, float, float],
-                 p2: tuple[float, float, float],
-                 p3: tuple[float, float, float]):
+                 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 ⬢
 
@@ -211,7 +214,7 @@ class HexCell(PeriodicCell):
             p2 (tuple[float, float, float]): left face bottom vertex
             p3 (tuple[float, float, float]): bottom vertex
         """
-        p1, p2, p3 = [np.array(p) for p in [p1, p2, p3]]
+        p1, p2, p3 = np.array(point1), np.array(point2), np.array(point3)
         p4 = -p1
         self.p1: np.ndarray = p1
         self.p2: np.ndarray = p2
@@ -240,7 +243,7 @@ class HexCell(PeriodicCell):
         poly = XYPolygon(xs, ys).geo(GCS.displace(0,0,zs[0]))
         return poly
     
-    def cell_data(self) -> Generator[FaceSelection, FaceSelection, np.ndarray]:
+    def cell_data(self) -> Generator[tuple[Selection, Selection, np.ndarray], None, None]:
         nrm = np.linalg.norm
 
         o = self.o1[:-1]
@@ -250,7 +253,7 @@ class HexCell(PeriodicCell):
         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)):
+        for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore
             yield f1, f2, vec
 
         o = self.o2[:-1]
@@ -259,7 +262,7 @@ class HexCell(PeriodicCell):
         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)):
+        for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore
             yield f1, f2, vec
         
         o = self.o3[:-1]
@@ -268,18 +271,18 @@ class HexCell(PeriodicCell):
         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)):
+        for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore
             yield f1, f2, vec
 
     def volume(self, 
                z1: float,
                z2: float) -> GeoPrism:
         xs, ys, zs = zip(self.p1, self.p2, self.p3)
-        xs = np.array(xs)
-        ys = np.array(ys)
-        xs = np.concatenate([xs, -xs])
-        ys = np.concatenate([ys, -ys])
-        poly = XYPolygon(xs, ys)
+        xs2 = np.array(xs) # type: ignore
+        ys2 = np.array(ys) # type: ignore
+        xs3 = np.concatenate([xs2, -xs2]) # type: ignore
+        ys3 = np.concatenate([ys2, -ys2]) # type: ignore
+        poly = XYPolygon(xs3, ys3)
         length = z2-z1
         return poly.extrude(length, cs=GCS.displace(0,0,z1))
     

emerge/_emerge/physics/microwave/adaptive_freq.py

@@ -49,14 +49,17 @@ Modification history
 
 """
 
+# ty: ignore
+
 import numpy as np
 from typing import Literal
 from loguru import logger
+
 def cc(z):
     return z.conjugate()
 
 def model(s, poles, residues, d, h):
-    return np.sum(r/(s-p) for p, r in zip(poles, residues)) + d + s*h
+    return sum([r/(s-p) for p, r in zip(poles, residues)]) + d + s*h
 
 def vectfit_step(f: np.ndarray, s: np.ndarray, poles: np.ndarray) -> np.ndarray:
     """
@@ -105,10 +108,6 @@ def vectfit_step(f: np.ndarray, s: np.ndarray, poles: np.ndarray) -> np.ndarray:
     b = np.concatenate((b.real, b.imag))
     x, residuals, rnk, s = np.linalg.lstsq(A, b, rcond=-1)
 
-    residues = x[:N]
-    d = x[N]
-    h = x[N+1]
-
     # We only want the "tilde" part in (A.4)
     x = x[-N:]
 
@@ -166,12 +165,12 @@ def calculate_residues(f: np.ndarray, s: np.ndarray, poles: np.ndarray, rcond=-1
     b = np.concatenate((b.real, b.imag))
     cA = np.linalg.cond(A)
     if cA > 1e13:
-        print('Warning!: Ill Conditioned Matrix. Consider scaling the problem down')
-        print('Cond(A)', cA)
+        logger.warning('Warning!: Ill Conditioned Matrix. Consider scaling the problem down')
+        logger.warning('Cond(A)', cA)
     x, residuals, rnk, s = np.linalg.lstsq(A, b, rcond=rcond)
 
     # Recover complex values
-    x = np.complex128(x)
+    x = x.astype(np.complex128)
     for i, ci in enumerate(cindex):
        if ci == 1:
            r1, r2 = x[i:i+2]
@@ -190,11 +189,11 @@ def vectfit_auto(f: np.ndarray,
                  inc_real: bool = False, 
                  loss_ratio: float = 1e-2, 
                  rcond: int = -1, 
-                 track_poles: bool = False) -> tuple[np.ndarray, np.ndarray, float, float]:
+                 track_poles: bool = False) -> tuple[np.ndarray, np.ndarray, float, float, np.ndarray]:
     w = s.imag
     pole_locs = np.linspace(w[0], w[-1], n_poles+2)[1:-1]
     lr = loss_ratio
-    init_poles = poles = np.concatenate([[p*(-lr + 1j), p*(-lr - 1j)] for p in pole_locs])
+    poles = np.concatenate([[p*(-lr + 1j), p*(-lr - 1j)] for p in pole_locs])
 
     if inc_real:
         poles = np.concatenate((poles, [1]))
@@ -208,7 +207,7 @@ def vectfit_auto(f: np.ndarray,
 
     if track_poles:
         return poles, residues, d, h, np.array(poles_list)
-    return poles, residues, d, h
+    return poles, residues, d, h, np.array([])
 
 def vectfit_auto_rescale(f: np.ndarray, s: np.ndarray, 
                          n_poles: int = 10, 
@@ -216,10 +215,10 @@ def vectfit_auto_rescale(f: np.ndarray, s: np.ndarray,
                          inc_real: bool = False, 
                          loss_ratio: float = 1e-2, 
                          rcond: int = -1, 
-                         track_poles: bool = False) -> tuple[np.ndarray, np.ndarray, float, float]:
+                         track_poles: bool = False) -> tuple[np.ndarray, np.ndarray, float, float, np.ndarray]:
     s_scale = abs(s[-1])
     f_scale = abs(f[-1])
-    poles_s, residues_s, d_s, h_s = vectfit_auto(f / f_scale, 
+    poles_s, residues_s, d_s, h_s, tracked_poles = vectfit_auto(f / f_scale, 
                                                  s / s_scale,
                                                   n_poles=n_poles,
                                                   n_iter = n_iter,
@@ -231,7 +230,7 @@ def vectfit_auto_rescale(f: np.ndarray, s: np.ndarray,
     residues = residues_s * f_scale * s_scale
     d = d_s * f_scale
     h = h_s * f_scale / s_scale
-    return poles, residues, d, h
+    return poles, residues, d, h, tracked_poles
 
 
 class SparamModel:
@@ -251,7 +250,7 @@ class SparamModel:
             fdense = np.linspace(min(self.f), max(self.f), max(201, 10*self.f.shape[0]))
             success = False
             for nps in range(1,maxpoles):
-                poles, residues, d, h = vectfit_auto_rescale(Sparam, s, n_poles=nps, inc_real=inc_real)
+                poles, residues, d, h, _ = vectfit_auto_rescale(Sparam, s, n_poles=nps, inc_real=inc_real)
                 self.poles: np.ndarray = poles
                 self.residues: np.ndarray = residues
                 self.d = d
@@ -268,7 +267,7 @@ class SparamModel:
                 logger.warning('Could not model S-parameters. Try a denser grid')
 
         else:
-            poles, residues, d, h = vectfit_auto_rescale(Sparam, s, n_poles=n_poles, inc_real=inc_real)
+            poles, residues, d, h, _ = vectfit_auto_rescale(Sparam, s, n_poles=n_poles, inc_real=inc_real)
             self.poles: np.ndarray = poles
             self.residues: np.ndarray = residues
             self.d = d