emsutil 0.2.2__tar.gz → 0.3.0__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emsutil
-Version: 0.2.2
+Version: 0.3.0
 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.3.0/emerge-install-mumps

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -e
+
+# Resolve Python environment
+PYTHON="$(command -v python)"
+
+if [ -z "$PYTHON" ]; then
+  echo "ERROR: No active Python environment found."
+  exit 1
+fi
+
+echo "Using Python:"
+echo "  $PYTHON"
+
+# Location of bundled installer
+INSTALLER_ROOT="$HOME/.emerge/installer"
+
+if [ ! -f "$INSTALLER_ROOT/install.sh" ]; then
+  echo "ERROR: MUMPS installer not found."
+  echo "Expected:"
+  echo "  $INSTALLER_ROOT/install.sh"
+  exit 1
+fi
+
+# Run installer
+bash "$INSTALLER_ROOT/install.sh"
+
+# Install Python package into *this* environment
+"$PYTHON" -m pip install "$HOME/.emerge/mumps_py"
+
+echo
+echo "MUMPS successfully installed for this Python environment."

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

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

{emsutil-0.2.2 → emsutil-0.3.0}/src/emsutil/emdata.py

@@ -7,6 +7,8 @@ from .lib import EISO, EOMNI
 @dataclass
 class FarFieldComponent:
     F: np.ndarray
+    _th: np.ndarray
+    _ph: np.ndarray
 
     @property
     def x(self) -> np.ndarray:
@@ -22,16 +24,16 @@ class FarFieldComponent:
     
     @property
     def theta(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)
+        thx = np.cos(self._th)*np.cos(self._ph)
+        thy = np.cos(self._th)*np.sin(self._ph)
+        thz = -np.sin(self._th)
         return thx*self.F[0,:] + thy*self.F[1,:] + thz*self.F[2,:]
     
     @property
     def phi(self) -> np.ndarray:
-        phx = -np.sin(self.phi)
-        phy = np.cos(self.phi)
-        phz = np.zeros_like(self.theta)
+        phx = -np.sin(self._ph)
+        phy = np.cos(self._ph)
+        phz = np.zeros_like(self._th)
         return phx*self.F[0,:] + phy*self.F[1,:] + phz*self.F[2,:]
     
     @property
@@ -122,6 +124,7 @@ class EHFieldFF:
     phi: np.ndarray
     Ptot: float
     ang: np.ndarray | None = field(default=None)
+    freq: float | None = field(default=None)
     
     def total_radiated_power_integral(
         self,
@@ -183,11 +186,11 @@ class EHFieldFF:
     
     @property
     def E(self) -> np.ndarray:
-        return FarFieldComponent(self._E)
+        return FarFieldComponent(self._E, self.theta, self.phi)
     
     @property
     def H(self) -> np.ndarray:
-        return FarFieldComponent(self._H)
+        return FarFieldComponent(self._H, self.theta, self.phi)
     
     @property
     def Ex(self) -> np.ndarray:
@@ -244,16 +247,16 @@ class EHFieldFF:
     @property
     def gain(self, kind: Literal['iso','omni'] = 'iso') -> FarFieldComponent:
         if kind=='iso':
-            return FarFieldComponent(self._E/EISO)
+            return FarFieldComponent(self._E/EISO, self.theta, self.phi)
         else:
-            return FarFieldComponent(self._E/EOMNI)
+            return FarFieldComponent(self._E/EOMNI, self.theta, self.phi)
         
     @property
     def dir(self, kind: Literal['iso','omni'] = 'iso') -> FarFieldComponent:
         if kind=='iso':
-            return FarFieldComponent(self._E/(EISO*(self.Ptot)**0.5))
+            return FarFieldComponent(self._E/(EISO*(self.Ptot)**0.5), self.theta, self.phi)
         else:
-            return FarFieldComponent(self._E/(EOMNI*(self.Ptot)**0.5))
+            return FarFieldComponent(self._E/(EOMNI*(self.Ptot)**0.5), self.theta, self.phi)
     
     @property
     def normE(self) -> np.ndarray:

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

@@ -0,0 +1,304 @@
+import numpy as np
+from .strutil import arry_to_line, matrix_to_lines, arry_to_fwl
+from ..emdata import EHFieldFF
+from dataclasses import dataclass
+from typing import List
+from loguru import logger
+import os
+
+@dataclass
+class Column:
+    name: str
+    values: np.ndarray
+
+    @staticmethod
+    def from_array(name: str, data: np.ndarray) -> List["Column"]:
+        """
+        Returns:
+        - [Column] if data is real
+        - [Column(real), Column(imag)] if data is complex
+        """
+        data = np.asarray(data)
+
+        if np.iscomplexobj(data):
+            return [
+                Column(f"{name}[re]", data.real),
+                Column(f"{name}[im]", data.imag),
+            ]
+        else:
+            return [Column(name, data)]
+
+
+def to_lines(
+    columns: List[Column],
+    header_prefix: str = "$ ",
+    separator: str = "  ",
+    fmt: str = "{:g}",
+) -> List[str]:
+    """
+    Convert columns to equally spaced text lines.
+    """
+
+    # Convert all values to strings first
+    str_cols = [[fmt.format(v) for v in col.values] for col in columns]
+    headers = [col.name for col in columns]
+    headers[0] = header_prefix + headers[0]
+    for i in range(len(headers)-1):
+        headers[i] = headers[i] + ';'
+    # Compute column widths (including separator!)
+    widths = []
+    for h, col in zip(headers, str_cols):
+        widths.append(max(len(h), max(len(v) for v in col)))
+
+    def format_row(items, sep: str):
+        return sep.join(item.ljust(w) for item, w in zip(items, widths))
+
+    lines = []
+
+    # Header
+    lines.append(format_row(headers, separator))
+
+    # Data rows
+    nrows = len(columns[0].values)
+    for i in range(nrows):
+        row = [col[i] for col in str_cols]
+        lines.append(format_row(row, separator))
+
+    return lines
+
+class _fieldGetter:
+    
+    def __init__(self, fields: list[EHFieldFF]):
+        self.names: list[str] = []
+        self.data: list = fields
+    
+    @property
+    def name(self) -> str:
+        return '.'.join([n.capitalize() for n in self.names])
+        
+    def __getattr__(self, name: str) -> EHFieldFF:
+        self.names.append(name)
+        self.data = [getattr(item, name) for item in self.data]
+        return self
+    
+class FarFieldExporter:
+    """A class to export far-field data to a text file.
+    
+    """
+    def __init__(self, filename: str, fields: list[EHFieldFF], precision: int = 4, todeg: bool = True):
+        self.filename: str = filename
+        self.fields: list[EHFieldFF] = fields
+        self.precision: int = precision
+        self.columns: list[_fieldGetter] = []
+        self.todeg: bool = todeg
+    
+    def addcol(self) -> EHFieldFF:
+        """Returns a field getter to specify which field component to export.
+        
+        Example:
+        >>> exporter = FarFieldExporter('data.txt', field_data)
+        >>> exporter.addcol().Ex
+        >>> exporter.addcol().gain.theta
+        >>> exporter.write()
+
+        Returns:
+            EHFieldFF(_fieldGetter): Field getter to specify field component.
+        """
+        getter = _fieldGetter(self.fields)
+        self.columns.append(getter)
+        return getter
+    
+    def write(self) -> None:
+        """Saves the far-field data to a text file.
+        """
+        base = self.fields[0]
+        
+        thetas = base.theta
+        phis = base.phi
+        
+        theta_lin = thetas[0,:].flatten()
+        phi_lin = phis[:,0].flatten()
+        p = self.precision
+        mult = 1.0
+        unit = 'rad'
+        if self.todeg:
+            mult = 180.0 / np.pi
+            theta_lin = theta_lin * mult
+            phi_lin = phi_lin * mult
+            thetas = thetas * mult
+            phis = phis * mult
+            unit = 'deg'
+        
+        datalines = []
+        datalines.append(f'% Theta({unit})')
+        datalines.append(' '.join([f'{x:.{p}g}' for x in theta_lin]))
+        datalines.append(f'% Phi({unit})')
+        datalines.append(' '.join([f'{x:.{p}g}' for x in phi_lin]))
+        datalines.append('% Frequencies(Hz)')
+        datalines.append(' '.join([f'{field.freq:.{p}g}' for field in self.fields]))
+        datalines.append('')
+        thcol = Column(f'Theta({unit})', thetas.flatten())
+        phcol = Column(f'Phi({unit})', phis.flatten())
+        
+        for i, field in enumerate(self.fields):
+            freq = field.freq
+            cols = []
+            datalines.append(f'# {freq:.{p}g} Hz')
+            for col in self.columns:
+                cols.extend(Column.from_array(col.name, col.data[i].flatten()))
+            
+            datalines.extend(to_lines([thcol, phcol] + cols, fmt=f"{{:.{p}g}}"))
+            datalines.append('')
+        
+        #replace any extension of filename with.emff
+        filename = os.path.splitext(self.filename)[0] + '.emff'
+        self.filename = filename
+        with open(self.filename, 'w') as f:
+            f.write('\n'.join(datalines))
+        logger.info(f'Wrote far-field data to {self.filename}')
+        
+def import_farfield(filename: str, degrees: bool = True) -> dict[str, np.ndarray]:
+    """Reads emerge farfiel datafiles created by FarFieldExporter.
+    They can be recognized by the .emff extension.
+
+    Args:
+        filename (str): The path to the far-field data file.
+        degrees (bool): If True, theta and phi angles are converted to degrees.
+
+    Returns:
+        dict[str, np.ndarray]: The imported far-field data structured as:
+            {
+                "theta": np.ndarray,  # Theta grid (nTheta, nPhi)
+                "phi": np.ndarray,    # Phi grid (nTheta, nPhi)
+                "freq": np.ndarray,   # Frequencies (nF,)
+                "Ex": np.ndarray,     # Electric field component Ex (nF, nTheta, nPhi)
+                "Ey": np.ndarray,     # Electric field component Ey (nF, nTheta, nPhi)
+                ...
+    """
+    with open(filename, "r") as f:
+        lines = f.readlines()
+
+    # ---------------- helpers ----------------
+    def parse_vector(header):
+        i = lines.index(header) + 1
+        return np.array(lines[i].split(), float)
+
+    def strip_unit(name):
+        if "(" in name and ")" in name:
+            base, unit = name.split("(")
+            return base.strip(), unit.rstrip(")")
+        return name.strip(), None
+
+    def to_rad(values, unit):
+        if unit == "deg":
+            return np.deg2rad(values)
+        return values
+
+    # ---------------- global grids ----------------
+    theta_name, theta_unit = strip_unit("% Theta(deg)")
+    phi_name,   phi_unit   = strip_unit("% Phi(deg)")
+
+    # Find actual headers (deg or rad)
+    theta_header = next(l for l in lines if l.startswith("% Theta"))
+    phi_header   = next(l for l in lines if l.startswith("% Phi"))
+
+    theta_vals = parse_vector(theta_header)
+    phi_vals   = parse_vector(phi_header)
+    freqs      = parse_vector("% Frequencies(Hz)\n")
+
+    theta_unit = theta_header.split("(")[1].split(")")[0]
+    phi_unit   = phi_header.split("(")[1].split(")")[0]
+
+    theta_vals = to_rad(theta_vals, theta_unit)
+    phi_vals   = to_rad(phi_vals, phi_unit)
+
+    nTheta = len(theta_vals)
+    nPhi   = len(phi_vals)
+    nF     = len(freqs)
+
+    theta_grid, phi_grid = np.meshgrid(theta_vals, phi_vals, indexing="ij")
+
+    result = {
+        "theta": theta_grid,
+        "phi": phi_grid,
+        "freq": freqs,
+    }
+
+    # ---------------- frequency blocks ----------------
+    field_buffers = {}
+    column_map = {}
+    header_info = {}
+    fidx = -1
+    header_cols = None
+    data_rows = []
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        # Frequency block
+        if line.startswith("#"):
+            fidx += 1
+            data_rows = []
+            continue
+
+        # Header line
+        if line.startswith("$"):
+            header_cols = []
+            column_map.clear()
+            header_info.clear()
+
+            raw_cols = line[1:].split(";")
+            for i, raw in enumerate(raw_cols):
+                name, unit = strip_unit(raw)
+                header_cols.append(name)
+                header_info[name] = unit
+
+                if "[" in name and "]" in name:
+                    base, comp = name.split("[")
+                    comp = comp.rstrip("]")
+                    column_map.setdefault(base, {})[comp] = i
+                else:
+                    column_map[name] = i
+            continue
+
+        if line.startswith("%"):
+            continue
+
+        parts = line.split()
+        if header_cols is None or len(parts) < len(header_cols):
+            continue
+
+        data_rows.append([float(p) for p in parts])
+
+        if len(data_rows) == nTheta * nPhi:
+            data = np.array(data_rows)
+
+            for field, comps in column_map.items():
+                unit = header_info.get(field)
+
+                if isinstance(comps, dict):  # complex
+                    re = data[:, comps["re"]]
+                    im = data[:, comps["im"]]
+                    arr = re + 1j * im
+                else:  # real
+                    arr = data[:, comps]
+
+                if unit in ("deg", "rad"):
+                    arr = to_rad(arr, unit)
+
+                arr = arr.reshape(nTheta, nPhi)
+                field_buffers.setdefault(field, []).append(arr)
+
+    
+    # Stack frequencies
+    for field, blocks in field_buffers.items():
+        result[field] = np.stack(blocks, axis=0)
+    
+    if degrees:
+        result["theta"] = np.rad2deg(result["theta"])
+        result["phi"] = np.rad2deg(result["phi"])
+        result["Theta"] = np.rad2deg(result["Theta"])
+        result["Phi"] = np.rad2deg(result["Phi"])
+    return result

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

@@ -184,8 +184,66 @@ class _Document(EMergeTheme):
             "#4DBEEEFF",
         ]
 
+class Stylish(EMergeTheme):
+    """ A custom EMerge theme. """
+    def define(self):
+        self.backgroung_grad_1 = "#FFFFFF"
+        self.backgroung_grad_2 = "#FFFFFF"
+        self.grid_color = "#676767FF"
+        self.brightness = 1.0
+        
+        self.label_color = "#FFFFFF"
+        self.text_color = "#000000FF"
+        self.render_metal = True
+        self.line_width = 3.0
+        
+        self.geo_edge_width = 3.0
+        self.geo_edge_color = "#000000ff"
+        
+
+        self.draw_xax = False
+        self.draw_yax = False
+        self.draw_zax = False
+        self.draw_xplane = False
+        self.draw_yplane = False
+        self.draw_zplane = False
+        self.draw_xgrid = False
+        self.draw_ygrid = False
+        self.draw_zgrid = False
+        
+        self.axis_x_color = "#FF0000FF"
+        self.axis_y_color = "#00FF00FF"
+        self.axis_z_color = "#0000FFFF"
 
+        self.aa_active = True
+        self.aa_samples = 5
+        self.cmap_npts = 64
+        
+        self.draw_pvgrid = False
+        self.render_shadows = True
+        # Basic clear academic scales
+        # Amplitude is Jet
+        # Wave is blue to transparent to red
+        
+        self.colormaps = {
+            'amplitude': (("#0000FF", "#00FFFF", "#00FF00", "#FFFF00", "#FF0000"),(0.0, 0.25, 0.5, 0.75, 1.0)),
+            'wave': (("#FF0000", "#FFAAAA00","#0000FF00", "#0000FF"), (0.0, 0.49, 0.51, 1.0)),
+        }
+        
+        self.render_style = 'surface'
+        
+        # Clear high contrast matlab colors for paper
+        self.line_color_cycle = [
+            "#0072BDFF",
+            "#D95319FF",
+            "#EDB120FF",
+            "#7E2F8EFF",
+            "#77AC30FF",
+            "#4DBEEEFF",
+        ]
+        
 VaporWave = _VaporWave()
 Vintage = _Vintage()
 Tron = _Tron()
 Document = _Document()
+Stylish = Stylish()

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

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

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

@@ -1,58 +0,0 @@
-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)