emsutil 0.2.0__tar.gz → 0.2.2__tar.gz

{emsutil-0.2.0 → emsutil-0.2.2}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.2.0"
+current_version = "0.2.2"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emsutil-0.2.0 → emsutil-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emsutil
-Version: 0.2.0
+Version: 0.2.2
 Summary: Common utilities for Emerge projects EMerge, Optycal and Heavi
 Project-URL: Homepage, https://github.com/FennisRobert/emsutil
 Project-URL: Issues, https://github.com/FennisRobert/emsutil/issues

{emsutil-0.2.0 → emsutil-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ allow-direct-references = true
 
 [project]
 name = "emsutil"
-version = "0.2.0"
+version = "0.2.2"
 description = "Common utilities for Emerge projects EMerge, Optycal and Heavi"
 readme = "README.md"
 requires-python = ">=3.10"

emsutil-0.2.2/src/emsutil/inexport/ffdata.py

@@ -0,0 +1,58 @@
+import numpy as np
+from .strutil import arry_to_line, matrix_to_lines, arry_to_fwl
+from ..emdata import EHFieldFF
+
+def export_ffdata(filename: str, 
+                  thetas: np.ndarray,
+                  phis: np.ndarray,
+                  frequencies: np.ndarray,
+                  fields: list[EHFieldFF],
+                  precision: int = 4) -> None:
+    
+    lines = []
+    lines.append('% Theta (deg)')
+    lines.append(arry_to_line(thetas, precision=precision))
+    lines.append('% Phi (deg)')
+    lines.append(arry_to_line(phis, precision=precision))
+    lines.append('')
+    nF = frequencies.shape[0]
+    
+    actual_frequencies = []
+    blocks = []
+    
+    T, P = np.meshgrid(thetas, phis, indexing='ij')
+    
+    thetal = T.flatten()
+    phil = P.flatten()
+    
+    for iF in range(nF):
+        freq = frequencies[iF]
+        actual_frequencies.append(freq)
+        
+        farfield = fields[iF]._E
+        Fx = farfield[0,:,:].squeeze().flatten()
+        Fy = farfield[1,:,:].squeeze().flatten()
+        Fz = farfield[2,:,:].squeeze().flatten()
+        
+        block_lines = []
+        
+        block_lines.append(f'# {freq} (Hz)')
+        block_lines.append('$ Theta(deg); Phi(deg); E_x[re](V/m); E_x[im](V/m); E_y[re](V/m); E_y[im](V/m); E_z[re](V/m); E_z[im](V/m)')
+        positions = (0, 14, 24, 38, 52, 66, 80, 94)
+        for th, ph, ex, ey, ez in zip(thetal, phil, Fx, Fy, Fz):
+            re_ex = np.real(ex)
+            im_ex = np.imag(ex)
+            re_ey = np.real(ey)
+            im_ey = np.imag(ey)
+            re_ez = np.real(ez)
+            im_ez = np.imag(ez)
+            line_values = np.array([th, ph, re_ex, im_ex, re_ey, im_ey, re_ez, im_ez])
+            line = arry_to_fwl(line_values, positions, precision=precision)
+            block_lines.append(line)
+
+        lines.extend(block_lines)
+        lines.extend('')
+    
+    text = '\n'.join(lines)
+    with open(filename, 'w') as f:
+        f.write(text)

emsutil-0.2.2/src/emsutil/inexport/strutil.py

@@ -0,0 +1,22 @@
+import numpy as np
+
+def arry_to_line(array: np.ndarray, separator: str = ' ', precision: int = 4) -> str:
+    return separator.join([f"{x:.{precision}f}" for x in array.squeeze()])
+
+def arry_to_fwl(array: np.ndarray, start_positions: list[int], precision: int = 4) -> str:
+    # Place the numbers at the starting position indices provided by the start-positions list
+    line_length = max(start_positions) + 10  # Extra space for number
+    line = [' ']*line_length
+    for i, pos in enumerate(start_positions):
+        num_str = f"{array[i]:.{precision}f}"
+        for j, ch in enumerate(num_str):
+            if pos + j < line_length:
+                line[pos + j] = ch
+    return ''.join(line)
+
+def matrix_to_lines(matrix: np.ndarray, separator: str = ',', precision: int = 4) -> str:
+    lines = []
+    for row in matrix:
+        line = arry_to_line(row, separator, precision)
+        lines.append(line)
+    return '\n'.join(lines)

{emsutil-0.2.0 → emsutil-0.2.2}/src/emsutil/pyvista/display.py

@@ -202,6 +202,7 @@ class EMergeDisplay:
         self._isometric: bool = False
         self._bwdrawing: bool = False
 
+        self._bounds: tuple[float, float, float, float, float, float] | None = None
         self._cbar_args: dict = {}
         self._cbar_lim: tuple[float, float] | None = None
         self.camera_position = (1, -1, 1)     # +X, +Z, -Y
@@ -412,6 +413,23 @@ class EMergeDisplay:
             # Turn off directional lighting
             self._plot.remove_all_lights()
         
+        if self.set.theme.draw_pvgrid and not self._bwdrawing:
+            pv.set_plot_theme('dark')
+            bounds = self._bounds
+            extra_factor = 0.1
+            dx = (bounds[1] - bounds[0])*extra_factor
+            dy = (bounds[3] - bounds[2])*extra_factor
+            dz = (bounds[5] - bounds[4])*extra_factor
+            ds = max(dx, dy, dz)
+            bounds = (bounds[0]-ds, bounds[1]+ds, bounds[2]-ds, bounds[3]+ds, bounds[4]-ds, bounds[5]+ds)
+            pv.global_theme.font.fmt = "%.3f"
+            actor = self._plot.show_grid(
+                bounds=bounds,
+                color=self.set.theme.text_color,
+                fmt="%.3f",
+                
+            )
+
         pv.global_theme.font.color = self.set.theme.text_color
         pv.global_theme.colorbar_horizontal.width = 0.4
         pv.global_theme.colorbar_vertical.height = 0.15
@@ -421,6 +439,10 @@ class EMergeDisplay:
         else:
             self._plot.disable_anti_aliasing()
         self._plot.title = 'EMerge'
+        if self._bwdrawing:
+            self._plot.set_background('white', top='white') # type: ignore
+        else:
+            self._plot.set_background(self.set.theme.backgroung_grad_1, top=self.set.theme.backgroung_grad_2) # type: ignore
             
     def _reset(self):
         self._plot.close()
@@ -985,6 +1007,68 @@ class EMergeDisplay:
         pl = self._plot.add_arrows(Coo, Vec, scalars=None, clim=None, cmap=cmap, **kwargs)
         self._data_sets.append(pl.mapper.dataset)
         self._reset_cbar()
+    
+    def add_clip_volume(self,
+                     X: np.ndarray,
+                     Y: np.ndarray,
+                     Z: np.ndarray,
+                     V: np.ndarray,
+                     scale: Literal['lin','log','symlog'] = 'lin',
+                     symmetrize: bool = False,
+                     clim: tuple[float, float] | None = None,
+                     cmap: cmap_names | None = None,
+                     opacity: float = 0.8):
+        """Adds a 3D volumetric contourplot based on a 3D grid of X,Y,Z and field values
+
+        Args:
+            X (np.ndarray): A 3D Grid of X-values
+            Y (np.ndarray): A 3D Grid of Y-values
+            Z (np.ndarray): A 3D Grid of Z-values
+            V (np.ndarray): The scalar quantity to plot ()
+            Nlevels (int, optional): The number of contour levels. Defaults to 5.
+            symmetrize (bool, optional): Wether to symmetrize the countour levels (-V,V). Defaults to True.
+            cmap (str, optional): The color map. Defaults to 'viridis'.
+        """
+        Vf = V.flatten()
+        Vf = np.nan_to_num(Vf)
+        vmin = np.min(np.real(Vf))
+        vmax = np.max(np.real(Vf))
+        
+        default_cmap = self.set.theme.default_amplitude_cmap
+        
+        if scale=='log':
+            T = lambda x: np.log10(np.abs(x+1e-12))
+        elif scale=='symlog':
+            T = lambda x: np.sign(x) * np.log10(1 + np.abs(x*np.log(10)))
+        else:
+            T = lambda x: x
+        
+        if symmetrize:
+            level = np.max(np.abs(Vf))
+            vmin, vmax = (-level, level)
+            default_cmap = self.set.theme.default_wave_cmap
+        
+        if clim is None:
+            if self._cbar_lim is not None:
+                clim = self._cbar_lim
+                vmin, vmax = clim
+            else:
+                clim = (vmin, vmax)
+        
+        if cmap is None:
+            cmap = default_cmap
+        else:
+            cmap = self.set.theme.parse_cmap_name(cmap)
+            
+        grid = pv.StructuredGrid(X,Y,Z)
+        field = V.flatten(order='F')
+        grid['anim'] = T(np.real(field))
+        
+        
+        self._plot.add_mesh_clip_plane(grid, opacity=opacity, cmap=cmap, pickable=False, scalar_bar_args=self._cbar_args)
+        #actor = self._wrap_plot(contour, opacity=opacity, cmap=cmap, clim=clim, pickable=False, scalar_bar_args=self._cbar_args)
+        
+        self._reset_cbar()
         
     def add_contour(self,
                      X: np.ndarray,
@@ -1082,6 +1166,8 @@ class EMergeDisplay:
             
         #self._plot.add_logo_widget('src/_img/logo.jpeg',position=(0.89,0.89), size=(0.1,0.1))    
         bounds = self._plot.bounds
+        self._bounds = bounds
+        
         xmin, xmax, ymin, ymax, zmin, zmax = self._plot.bounds
         
         max_size = max([abs(dim) for dim in [bounds.x_max, bounds.x_min, bounds.y_max, bounds.y_min, bounds.z_max, bounds.z_min]])
@@ -1287,7 +1373,7 @@ class EMergeDisplay:
             light.set_direction_angle(*self.set.light_angle) # type: ignore
             self._plot.add_light(light)
 
-        self._plot.set_background(self.set.theme.backgroung_grad_1, top=self.set.theme.backgroung_grad_2) # type: ignore
+        
         self._plot.add_axes(color=self.set.theme.text_color,
                             x_color=col_x,
                             y_color=col_y,

{emsutil-0.2.0 → emsutil-0.2.2}/src/emsutil/pyvista/display_settings.py

@@ -29,9 +29,10 @@ class EMergeTheme:
     
     def __init__(self):
         
+        
         # Generic Controls
         self.aa_active: bool = True
-        self.aa_mode: str = "msaa"
+        self.aa_mode: Literal['msaa', 'fxaa', 'ssaa'] = "msaa"
         self.aa_samples: int = 8
         
         # Background
@@ -44,10 +45,12 @@ class EMergeTheme:
         self.draw_zplane: bool = False
         self.draw_xgrid: bool = False
         self.draw_ygrid: bool = False
-        self.draw_zgrid: bool = True
-        self.draw_xax: bool = True
-        self.draw_yax: bool = True
-        self.draw_zax: bool = True
+        self.draw_zgrid: bool = False
+        self.draw_xax: bool = False
+        self.draw_yax: bool = False
+        self.draw_zax: bool = False
+        self.draw_pvgrid: bool = True
+        self.draw_pvaxes: bool = True
         
         self.axis_color: str = "#000000"
         self.axis_x_color: str = "#ff007b"

{emsutil-0.2.0 → emsutil-0.2.2}/src/emsutil/themes.py

@@ -106,7 +106,7 @@ class _Tron(EMergeTheme):
         self.axis_x_color = "#FFFF00FF"
         self.axis_y_color = "#00FFFFFF"
         self.axis_z_color = "#FF00FFFF"
-        
+        self.draw_pvaxes = True
         self.aa_active = True
         self.aa_samples = 5
         self.cmap_npts = 32

{emsutil-0.2.0 → emsutil-0.2.2}/uv.lock

@@ -279,7 +279,7 @@ wheels = [
 
 [[package]]
 name = "emsutil"
-version = "0.2.0"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "loguru" },