setupEM 0.5.0__tar.gz → 0.5.1__tar.gz

{setupem-0.5.0/src/setupEM.egg-info → setupem-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.5.0
+Version: 0.5.1
 Summary: Python tool for configuration of gds2palace workflow with GUI.
 Author-email: Volker Muehlhaus <volker@muehlhaus.com>
 License-Expression: GPL-3.0-or-later

{setupem-0.5.0 → setupem-0.5.1}/src/setupEM/__init__.py

@@ -24,4 +24,4 @@ A Python tool for EM setup using gds2palace.
 from .setupEM import main
 
 __all__ = ["main"]
-__version__ = "0.5.0"
+__version__ = "0.5.1"

{setupem-0.5.0 → setupem-0.5.1}/src/setupEM/palace_results.py

@@ -25,6 +25,8 @@ import os
 import json
 import csv
 import re
+import math
+import cmath
 
 _ITERATION_RE = re.compile(r'^iteration(\d+)$')
 
@@ -79,14 +81,121 @@ def _read_error_indicators(dir_path):
     try:
         return {
             'norm': float(fields['Norm']),
-            'minimum': float(fields['Minimum']),
             'maximum': float(fields['Maximum']),
-            'mean': float(fields['Mean']),
         }
     except (KeyError, ValueError):
         return None
 
 
+def _parse_palace_port_s_csv(path):
+    """Parse a Palace port-S.csv file into (freq_list, S_dB_list, S_arg_list,
+    num_ports), where S_dB_list/S_arg_list are one dict-per-frequency mapping
+    'i j' port-pair strings to their |S| (dB) / phase (deg) string values.
+    """
+    freq = []
+    S_dB = []
+    S_arg = []
+    params = []
+    num_ports = 0
+
+    with open(path, 'r', encoding='utf-8') as f:
+        for line in f:
+            aline = line.rstrip()
+            aline = aline.replace(",", "")
+            aline = aline.replace("(dB)", "")
+            aline = aline.replace("(deg.)", "")
+
+            if 'Hz)' in aline:
+                # header line: items are like |S[1][1]| arg(S[1][1])
+                items = aline.split()
+                for item in items:
+                    if '|' in item:
+                        Sxx = item.replace('|S', '').replace('|', '')
+                        Sxx = Sxx.replace('][', ' ').replace('[', '').replace(']', '')
+                        params.append(Sxx)
+                        a, b = (int(x) for x in Sxx.split())
+                        num_ports = max(num_ports, a, b)
+                continue
+
+            items = aline.split()
+            if not items:
+                continue
+            dB = {}
+            arg = {}
+            for param in params:
+                dB_index = 2 * params.index(param) + 1
+                arg_index = dB_index + 1
+                dB[param] = items[dB_index]
+                arg[param] = items[arg_index]
+            freq.append(items[0])
+            S_dB.append(dB)
+            S_arg.append(arg)
+
+    return freq, S_dB, S_arg, num_ports
+
+
+def _read_port_s_data(dir_path):
+    """Parse dir_path/port-S.csv (if present), or None if the file is
+    missing, unfinished, or malformed (e.g. a still-running pass).
+    """
+    path = os.path.join(dir_path, 'port-S.csv')
+    if not os.path.isfile(path):
+        return None
+    try:
+        freq, S_dB, S_arg, num_ports = _parse_palace_port_s_csv(path)
+    except (OSError, ValueError, IndexError):
+        return None
+    if not freq:
+        return None
+    return freq, S_dB, S_arg, num_ports
+
+
+def _max_delta_s(prev_data, curr_data):
+    """Max |S_curr - S_prev| across all ports and frequencies common to both
+    passes, mirroring HFSS's per-pass Max Delta S. Returns None if either
+    pass has no port-S data, or the two use different port counts.
+    """
+    if prev_data is None or curr_data is None:
+        return None
+    freq_p, dB_p, arg_p, ports_p = prev_data
+    freq_c, dB_c, arg_c, ports_c = curr_data
+    if ports_p != ports_c:
+        return None
+
+    max_delta = 0.0
+    found_any = False
+    for idx in range(min(len(freq_p), len(freq_c))):
+        for key in set(dB_p[idx]) & set(dB_c[idx]):
+            try:
+                Sp = cmath.rect(10 ** (float(dB_p[idx][key]) / 20.0), math.radians(float(arg_p[idx][key])))
+                Sc = cmath.rect(10 ** (float(dB_c[idx][key]) / 20.0), math.radians(float(arg_c[idx][key])))
+            except ValueError:
+                continue
+            found_any = True
+            max_delta = max(max_delta, abs(Sc - Sp))
+    return max_delta if found_any else None
+
+
+def _collect_amr_rows(output_dir, iteration_dirs):
+    """One row per AMR iteration subfolder, plus the root output_dir as
+    'Final': (label, palace_json_dict_or_None, error_indicators_dict_or_None,
+    max_delta_s_vs_previous_row_or_None).
+    """
+    dirs_in_order = list(iteration_dirs) + [output_dir]
+    labels = [os.path.basename(d) for d in iteration_dirs] + ["Final"]
+
+    rows = []
+    prev_port_s = None
+    for label, d in zip(labels, dirs_in_order):
+        summary = _read_palace_json(d)
+        errors = _read_error_indicators(d)
+        port_s = _read_port_s_data(d)
+        delta_s = _max_delta_s(prev_port_s, port_s)
+        rows.append((label, summary, errors, delta_s))
+        prev_port_s = port_s
+    return rows
+
+
 def _list_iteration_dirs(output_dir):
     if not os.path.isdir(output_dir):
         return []
@@ -128,6 +237,22 @@ def _format_sci(x):
     return 'n/a' if x is None else f"{x:.3e}"
 
 
+def _format_delta(x):
+    return 'n/a' if x is None else f"{x:.4f}"
+
+
+def _save_convergence_summary(run_path, summary_text):
+    """Save the AMR summary table alongside the run's config.json /
+    port_information.json, so it's available on disk without re-running the
+    simulation or digging through the setupEM log.
+    """
+    try:
+        with open(os.path.join(run_path, "mesh_convergence_summary.txt"), "w", encoding="utf-8") as f:
+            f.write(summary_text + "\n")
+    except OSError:
+        pass
+
+
 def build_results_summary(run_path, model_basename):
     """Return a formatted multi-line summary of Palace results found under run_path,
     or an explanatory message if nothing is there yet.
@@ -155,19 +280,18 @@ def build_results_summary(run_path, model_basename):
         if errors:
             lines.append(
                 f"Error indicator    : Norm={_format_sci(errors['norm'])}  "
-                f"Max={_format_sci(errors['maximum'])}  Mean={_format_sci(errors['mean'])}"
+                f"Max={_format_sci(errors['maximum'])}"
             )
         lines.append("=" * 40)
         return "\n".join(lines)
 
     # Adaptive mesh refinement: one row per iteration subfolder, plus the root as "Final"
-    rows = [(os.path.basename(it_dir), _read_palace_json(it_dir), _read_error_indicators(it_dir))
-            for it_dir in iteration_dirs]
-    rows.append(("Final", _read_palace_json(output_dir), _read_error_indicators(output_dir)))
+    rows = _collect_amr_rows(output_dir, iteration_dirs)
 
-    headers = ["Iteration", "DOF", "Mesh elems", "Error Norm", "Error Max", "Error Mean", "Time", "Peak RAM"]
+    headers = ["Iteration", "DOF", "Mesh elems", "Error Norm", "Error Max",
+               "Max dS", "Time", "Peak RAM"]
     table_rows = []
-    for label, summary, errors in rows:
+    for label, summary, errors, delta_s in rows:
         summary = summary or {}
         errors = errors or {}
         table_rows.append([
@@ -176,7 +300,7 @@ def build_results_summary(run_path, model_basename):
             _format_int(summary.get('mesh_elements')),
             _format_sci(errors.get('norm')),
             _format_sci(errors.get('maximum')),
-            _format_sci(errors.get('mean')),
+            _format_delta(delta_s),
             _format_duration(summary.get('duration_s')),
             _format_ram(summary.get('peak_ram_mb')),
         ])
@@ -196,4 +320,6 @@ def build_results_summary(run_path, model_basename):
     for row in table_rows:
         lines.append(fmt_row(row))
     lines.append("=" * len(header_line))
-    return "\n".join(lines)
+    summary_text = "\n".join(lines)
+    _save_convergence_summary(run_path, summary_text)
+    return summary_text

{setupem-0.5.0 → setupem-0.5.1}/src/setupEM/setup_common.py

@@ -1411,6 +1411,42 @@ class MainWindowBase(QMainWindow):
 
     TAB_HEADER_COLORS = ["#FFCDD2", "#C8E6C9", "#BBDEFB", "#FFF9C4", "#D1C4E9"]
 
+    def __init__(self):
+        super().__init__()
+        # let the whole window accept a dropped *.simcfg / *.tsimcfg file,
+        # not just the individual file-path fields (see FileDropLineEdit)
+        self.setAcceptDrops(True)
+
+    # ---------- Drag & drop native config file onto the window ----------
+    def _config_file_from_drop(self, event):
+        if not event.mimeData().hasUrls():
+            return None
+        for url in event.mimeData().urls():
+            path = url.toLocalFile()
+            if path and pathlib.Path(path).suffix.upper() == "." + self.CONFIG_SUFFIX.upper():
+                return path
+        return None
+
+    def dragEnterEvent(self, event):
+        if self._config_file_from_drop(event):
+            event.acceptProposedAction()
+        else:
+            event.ignore()
+
+    def dragMoveEvent(self, event):
+        if self._config_file_from_drop(event):
+            event.acceptProposedAction()
+        else:
+            event.ignore()
+
+    def dropEvent(self, event):
+        file_path = self._config_file_from_drop(event)
+        if file_path:
+            event.acceptProposedAction()
+            self.load_configuration_from_file(file_path)
+        else:
+            event.ignore()
+
     # ---------- Menu Bar ----------
     def create_menu_bar(self):
         menu_bar = self.menuBar()

{setupem-0.5.0 → setupem-0.5.1/src/setupEM.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.5.0
+Version: 0.5.1
 Summary: Python tool for configuration of gds2palace workflow with GUI.
 Author-email: Volker Muehlhaus <volker@muehlhaus.com>
 License-Expression: GPL-3.0-or-later