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

emerge/_emerge/mth/optimized.py

@@ -358,37 +358,6 @@ def local_mapping(vertex_ids, triangle_ids):
 
     return out
 
-@njit(f8[:,:](f8[:], f8[:], f8[:]), cache=True, nogil=True)
-def orthonormal_basis(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):
-    """
-    Returns an orthonormal basis for the tetrahedron defined by the points
-    xs, ys, zs. The basis is given as a 3x3 matrix with the first column being
-    the normal vector of the face opposite to the first vertex.
-    """
-    x1, x2, x3 = xs
-    y1, y2, y3 = ys
-    z1, z2, z3 = zs
-    e1x, e1y, e1z = x2-x1, y2-y1, z2-z1
-    e2x, e2y, e2z = x3-x1, y3-y1, z3-z1
-
-    nn = np.array([e2y*e1z - e2z*e1y,
-                   e2z*e1x - e2x*e1z,
-                   e2y*e1x - e2x*e1y])
-    
-    nn = nn/np.sqrt(nn[0]**2 + nn[1]**2 + nn[2]**2)
-    n2 = np.array([e1x, e1y, e1z])/np.sqrt(e1x**2 + e1y**2 + e1z**2)
-    n1 = np.array([n2[1]*nn[2] - n2[2]*nn[1],
-                   n2[2]*nn[0] - n2[0]*nn[2],
-                   n2[0]*nn[1] - n2[1]*nn[0]])
-    
-    if dot(n1, cross(n2, nn)) < 0:
-        n1 = -n1
-    
-    B = np.zeros((3,3), dtype=np.float64)
-    B[:,0] = n1
-    B[:,1] = n2
-    B[:,2] = nn
-    return B
 
 @njit(f8[:,:](f8[:], f8[:], f8[:]), cache=True, nogil=True, fastmath=True)
 def compute_distances(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:

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

@@ -18,7 +18,6 @@
 import numpy as np
 from ....elements import Nedelec2
 from scipy.sparse import csr_matrix, coo_matrix
-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
 
@@ -167,8 +166,7 @@ def tet_mass_stiffness_matrices(field: Nedelec2,
     nE = edges.shape[1]
     nTri = tris.shape[1]
 
-    with ProgressBar(total=nT, ncols=100, dynamic_ncols=False) as pgb:
-        dataE, dataB, rows, cols = _matrix_builder(nodes, tets, tris, edges, field.mesh.edge_lengths, tet_to_field, tet_to_edge, ur, er, pgb)
+    dataE, dataB, rows, cols = _matrix_builder(nodes, tets, tris, edges, field.mesh.edge_lengths, tet_to_field, tet_to_edge, ur, er)
         
     E = coo_matrix((dataE, (rows, cols)), shape=(nE*2 + nTri*2, nE*2 + nTri*2)).tocsr()
     B = coo_matrix((dataB, (rows, cols)), shape=(nE*2 + nTri*2, nE*2 + nTri*2)).tocsr()
@@ -426,9 +424,8 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
                                                       i8[:,:], 
                                                       i8[:,:], 
                                                       c16[:,:,:], 
-                                                      c16[:,:,:], 
-                                                      ProgressBarType), cache=True, nogil=True, parallel=True)
-def _matrix_builder(nodes, tets, tris, edges, all_edge_lengths, tet_to_field, tet_to_edge, ur, er, pgb: ProgressBar):
+                                                      c16[:,:,:]), cache=True, nogil=True, parallel=True)
+def _matrix_builder(nodes, tets, tris, edges, all_edge_lengths, tet_to_field, tet_to_edge, ur, er):
     nT = tets.shape[1]
     nedges = edges.shape[1]
 
@@ -442,8 +439,6 @@ def _matrix_builder(nodes, tets, tris, edges, all_edge_lengths, tet_to_field, te
     
     for itet in prange(nT): # ty: ignore
         p = itet*400
-        if np.mod(itet,10)==0:
-            pgb.update(10)
         urt = ur[:,:,itet]
         ert = er[:,:,itet]
 

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

@@ -18,7 +18,6 @@
 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, gaus_quad_tri
 from numba import c16, types, f8, i8, njit, prange
 
@@ -54,8 +53,7 @@ def generelized_eigenvalue_matrix(field: NedelecLegrange2,
 
     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)
+    dataE, dataB, rows, cols = _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0)
     
     nfield = field.n_field
 
@@ -427,9 +425,8 @@ def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
                                                       i8[:,:],
                                                       c16[:,:,:], 
                                                       c16[:,:,:], 
-                                                      f8,
-                                                      ProgressBarType), cache=True, nogil=True, parallel=True)
-def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0, pgb: ProgressBar):
+                                                      f8), cache=True, nogil=True, parallel=True)
+def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0):
 
     ntritot = tris.shape[1]
     nnz = ntritot*196
@@ -443,8 +440,6 @@ def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0, pgb: ProgressB
     
     for itri in prange(ntritot): # type: ignore
         p = itri*196
-        if np.mod(itri,10)==0:
-            pgb.update(10)
         urt = ur[:,:,itri]
         ert = er[:,:,itri]
 

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

@@ -18,7 +18,6 @@
 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, gaus_quad_tri
 from numba import c16, types, f8, i8, njit, prange
 
@@ -54,8 +53,7 @@ def generelized_eigenvalue_matrix(field: NedelecLegrange2,
 
     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)
+    dataE, dataB, rows, cols = _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0)
     
     nfield = field.n_field
 
@@ -427,9 +425,8 @@ def generalized_matrix_GQ(tri_vertices, local_edge_map, Ms, Mm, k0):
                                                       i8[:,:],
                                                       c16[:,:,:], 
                                                       c16[:,:,:], 
-                                                      f8,
-                                                      ProgressBarType), cache=True, nogil=True, parallel=True)
-def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0, pgb: ProgressBar):
+                                                      f8), cache=True, nogil=True, parallel=True)
+def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0):
 
     ntritot = tris.shape[1]
     nnz = ntritot*196
@@ -443,8 +440,6 @@ def _matrix_builder(nodes, tris, edges, tri_to_field, ur, er, k0, pgb: ProgressB
     
     for itri in prange(ntritot): # type: ignore
         p = itri*196
-        if np.mod(itri,10)==0:
-            pgb.update(10)
         urt = ur[:,:,itri]
         ert = er[:,:,itri]
 

emerge/_emerge/physics/microwave/microwave_data.py

@@ -254,9 +254,72 @@ class FarfieldData:
     H: np.ndarray
     theta: np.ndarray
     phi: np.ndarray
+    ang: np.ndarray | None = None
 
+    @property
+    def Ex(self) -> np.ndarray:
+        return self.E[0,:]
+    
+    @property
+    def Ey(self) -> np.ndarray:
+        return self.E[1,:]
+    
+    @property
+    def Ez(self) -> np.ndarray:
+        return self.E[2,:]
+    
+    @property
+    def Hx(self) -> np.ndarray:
+        return self.H[0,:]
+    
+    @property
+    def Hy(self) -> np.ndarray:
+        return self.H[1,:]
+    
+    @property
+    def Hz(self) -> np.ndarray:
+        return self.H[2,:]
+    
+    @property
+    def Etheta(self) -> np.ndarray:
+        thx = -np.cos(self.theta)*np.cos(self.phi)
+        thy = -np.cos(self.theta)*np.sin(self.phi)
+        thz = np.sin(self.theta)
+        return thx*self.E[0,:] + thy*self.E[1,:] + thz*self.E[2,:]
+    
+    @property
+    def Ephi(self) -> np.ndarray:
+        phx = -np.sin(self.phi)
+        phy = np.cos(self.phi)
+        phz = np.zeros_like(self.theta)
+        return phx*self.E[0,:] + phy*self.E[1,:] + phz*self.E[2,:]
+    
+    @property
+    def Erhcp(self) -> np.ndarray:
+        return (self.Etheta - 1j*self.Ephi)/np.sqrt(2)
+    
+    @property
+    def Elhcp(self) -> np.ndarray:
+        return (self.Etheta + 1j*self.Ephi)/np.sqrt(2)
+    
+    @property
+    def AR(self) -> np.ndarray:
+        R = np.abs(self.Erhcp)
+        L = np.abs(self.Elhcp)
+        return (R+L)/(R-L)
+    
+    @property
+    def normE(self) -> np.ndarray:
+        return np.sqrt(np.abs(self.E[0,:])**2 + np.abs(self.E[1,:])**2 + np.abs(self.E[2,:])**2)
+    
+    @property
+    def normH(self) -> np.ndarray:
+        return np.sqrt(np.abs(self.H[0,:])**2 + np.abs(self.H[1,:])**2 + np.abs(self.H[2,:])**2)
+    
+    
     def surfplot(self, 
-             polarization: Literal['Ex','Ey','Ez','Etheta','Ephi','normE'], 
+             polarization: Literal['Ex','Ey','Ez','Etheta','Ephi','normE','Erhcp','Elhcp','AR'],
+             quantity: Literal['abs','real','imag','angle'] = 'abs',
              isotropic: bool = True, dB: bool = False, dBfloor: float = -30, rmax: float | None = None,
              offset: tuple[float, float, float] = (0,0,0)) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """Returns the parameters to be used as positional arguments for the display.add_surf() function.
@@ -273,27 +336,16 @@ class FarfieldData:
         Returns:
             tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: The X, Y, Z, F values
         """
-        if polarization == "Ex":
-            F = self.E[0,:]
-        elif polarization == "Ey":
-            F = self.E[1,:]
-        elif polarization == "Ez":
-            F = self.E[2,:]
-        elif polarization == "normE":
-            F = np.sqrt(np.abs(self.E[0,:])**2 + np.abs(self.E[1,:])**2 + np.abs(self.E[2,:])**2)
-        elif polarization == "Etheta":
-            thx = -np.cos(self.theta)*np.cos(self.phi)
-            thy = -np.cos(self.theta)*np.sin(self.phi)
-            thz = np.sin(self.theta)
-            F = np.abs(thx*self.E[0,:] + thy*self.E[1,:] + thz*self.E[2,:])
-        elif polarization == "Ephi":
-            phx = -np.sin(self.phi)
-            phy = np.cos(self.phi)
-            phz = np.zeros_like(self.theta)
-            F = np.abs(phx*self.E[0,:] + phy*self.E[1,:] + phz*self.E[2,:])
-        else:
-            logger.warning('Defaulting to normE')
-            F = np.sqrt(np.abs(self.E[0,:])**2 + np.abs(self.E[1,:])**2 + np.abs(self.E[2,:])**2)
+        fmap = {
+            'abs': np.abs,
+            'real': np.real,
+            'imag': np.imag,
+            'angle': np.angle,
+        }
+        mapping = fmap.get(quantity.lower(),np.abs)
+        
+        F = mapping(self.__dict__.get(polarization, self.normE))
+        
         if isotropic:
             F = F/np.sqrt(Z0/(2*np.pi))
         if dB:
@@ -764,7 +816,7 @@ class MWField:
                          ang_range: tuple[float, float] = (-180, 180),
                          Npoints: int = 201,
                          origin: tuple[float, float, float] | None = None,
-                         syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+                         syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> FarfieldData:#tuple[np.ndarray, np.ndarray, np.ndarray]:
         """Compute the farfield electric and magnetic field defined by a circle.
 
         Args:
@@ -784,7 +836,7 @@ class MWField:
         theta, phi = arc_on_plane(refdir, plane_normal_parsed, ang_range, Npoints)
         E,H = self.farfield(theta, phi, faces, origin, syms = syms)
         angs = np.linspace(*ang_range, Npoints)*np.pi/180
-        return angs, E ,H
+        return FarfieldData(E, H, theta, phi, ang=angs)
 
     def farfield_3d(self, 
                     faces: FaceSelection | GeoSurface,

emerge/_emerge/physics/microwave/sc.py

@@ -15,13 +15,11 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-from numba_progress import ProgressBar
 from ...mesh3d import SurfaceMesh
 import numpy as np
 from loguru import logger
 from numba import c16, njit, prange, f8
 from numba.types import Tuple as TupleType  # ty: ignore
-from numba_progress.progress import ProgressBarType
 from ...const import Z0
 
 LR = 0.001
@@ -34,14 +32,13 @@ LR = 0.001
         f8[:, :],
         f8[:, :],
         f8,
-        ProgressBarType,
     ),
     parallel=True,
     fastmath=True,
     cache=True,
     nogil=True,
 )
-def stratton_chu_ff(Ein, Hin, vis, wns, tpout, k0, pgb):
+def stratton_chu_ff(Ein, Hin, vis, wns, tpout, k0):
     
     Ex = Ein[0, :].flatten()
     Ey = Ein[1, :].flatten()
@@ -125,7 +122,6 @@ def stratton_chu_ff(Ein, Hin, vis, wns, tpout, k0, pgb):
         Eoutz += Q * (rx * ie1y - ry * ie1x)
 
         # ii += iadd
-        pgb.update(1)
     Eout[0, :] = Eoutx
     Eout[1, :] = Eouty
     Eout[2, :] = Eoutz
@@ -162,14 +158,13 @@ def stratton_chu(Ein, Hin, mesh: SurfaceMesh, theta: np.ndarray, phi: np.ndarray
     Eout = None
     Hout = None
     tpout = np.array([theta, phi])
-    with ProgressBar(total=Ntot, ncols=100, dynamic_ncols=False) as pgb:
-        Eout, Hout = stratton_chu_ff(
-            Ein.astype(np.complex128),
-            Hin.astype(np.complex128),
-            vis.astype(np.float64),
-            wns.astype(np.float64),
-            tpout.astype(np.float64),
-            np.float64(k0),
-            pgb,
-        )
+
+    Eout, Hout = stratton_chu_ff(
+        Ein.astype(np.complex128),
+        Hin.astype(np.complex128),
+        vis.astype(np.float64),
+        wns.astype(np.float64),
+        tpout.astype(np.float64),
+        np.float64(k0),
+    )
     return Eout.astype(np.complex128), Hout.astype(np.complex128)

emerge/_emerge/plot/simple_plots.py

@@ -342,8 +342,6 @@ and sparse frequency annotations (e.g., labeled by frequency).
     fdiv = units[key]
 
     # --- figure/axes ---
-    fig: Figure
-    ax: Axes
     fig, ax = plt.subplots(figsize=(6, 6))
 
     # --- smith grid (kept out of legend) ---

emerge/_emerge/simmodel.py

@@ -62,7 +62,7 @@ class Simulation:
 
     def __init__(self, 
                  modelname: str, 
-                 loglevel: Literal['DEBUG','INFO','WARNING','ERROR'] = 'INFO',
+                 loglevel: Literal['TRACE','DEBUG','INFO','WARNING','ERROR'] = 'INFO',
                  load_file: bool = False,
                  save_file: bool = False,
                  logfile: bool = False,