setupEM 0.3.14__tar.gz → 0.3.16__tar.gz

{setupem-0.3.14/src/setupEM.egg-info → setupem-0.3.16}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.3.14
+Version: 0.3.16
 Summary: Python tool for configuration of gds2palace workflow with GUI.
 Author-email: Volker Muehlhaus <volker@muehlhaus.com>
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: gds2palace>=0.3.6
+Requires-Dist: gds2palace>=0.4.0
 Requires-Dist: PySide6
 Requires-Dist: scipy
 Requires-Dist: requests
@@ -126,7 +126,7 @@ On this tab, you configure input files:
 
 The fields for GDSII and XML file support drag & drop or you can use the Browse... buttons.
 
-Some pre-processing of the layout is also defined here: You can specify a distance (in micron) which is used for **via array merging**, to speed up simulation by replacing many individual vias with one large via box. If your layout includes **polygons with holes**, you need to set the "Preprocess GDSII file" checkbox, otherwise you will get error messages during meshing.
+Some pre-processing of the layout is also defined here: You can specify a distance (in micron) which is used for **via array merging**, to speed up simulation by replacing many individual vias with one large via box.
 
 <img src="https://raw.githubusercontent.com/VolkerMuehlhaus/setupEM/main/doc/png/inputfiles1.png" alt="input files" width="700">
 
@@ -272,7 +272,7 @@ This project is licensed under the GNU General Public License v3.0 or later (GPL
 
 **Note:** the `setupEM` PyPI package itself requires:
 
-- gds2palace>=0.3.6
+- gds2palace>=0.4.0
 - PySide6
 - scipy
 - requests

{setupem-0.3.14 → setupem-0.3.16}/README.md

@@ -107,7 +107,7 @@ On this tab, you configure input files:
 
 The fields for GDSII and XML file support drag & drop or you can use the Browse... buttons.
 
-Some pre-processing of the layout is also defined here: You can specify a distance (in micron) which is used for **via array merging**, to speed up simulation by replacing many individual vias with one large via box. If your layout includes **polygons with holes**, you need to set the "Preprocess GDSII file" checkbox, otherwise you will get error messages during meshing.
+Some pre-processing of the layout is also defined here: You can specify a distance (in micron) which is used for **via array merging**, to speed up simulation by replacing many individual vias with one large via box.
 
 <img src="./doc/png/inputfiles1.png" alt="input files" width="700">
 

{setupem-0.3.14 → setupem-0.3.16}/README_pypi.md

@@ -107,7 +107,7 @@ On this tab, you configure input files:
 
 The fields for GDSII and XML file support drag & drop or you can use the Browse... buttons.
 
-Some pre-processing of the layout is also defined here: You can specify a distance (in micron) which is used for **via array merging**, to speed up simulation by replacing many individual vias with one large via box. If your layout includes **polygons with holes**, you need to set the "Preprocess GDSII file" checkbox, otherwise you will get error messages during meshing.
+Some pre-processing of the layout is also defined here: You can specify a distance (in micron) which is used for **via array merging**, to speed up simulation by replacing many individual vias with one large via box.
 
 <img src="https://raw.githubusercontent.com/VolkerMuehlhaus/setupEM/main/doc/png/inputfiles1.png" alt="input files" width="700">
 
@@ -253,7 +253,7 @@ This project is licensed under the GNU General Public License v3.0 or later (GPL
 
 **Note:** the `setupEM` PyPI package itself requires:
 
-- gds2palace>=0.3.6
+- gds2palace>=0.4.0
 - PySide6
 - scipy
 - requests

{setupem-0.3.14 → setupem-0.3.16}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
     { name = "Volker Muehlhaus", email = "volker@muehlhaus.com" }
 ]
 dependencies = [
-    "gds2palace>=0.3.6",
+    "gds2palace>=0.4.0",
     "PySide6",
     "scipy",
     "requests",

{setupem-0.3.14 → setupem-0.3.16}/src/setupEM/__init__.py

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

setupem-0.3.16/src/setupEM/palace_results.py

@@ -0,0 +1,199 @@
+########################################################################
+#
+# Copyright 2025 Volker Muehlhaus and IHP PDK Authors
+#
+# Licensed under the GNU General Public License, Version 3.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    https://www.gnu.org/licenses/gpl-3.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+########################################################################
+
+"""Parse AWS Palace solver output (palace.json / error-indicators.csv) into a
+human-readable summary for the setupEM "Create Model" log. No Qt dependency,
+so this can be exercised standalone against real Palace output directories.
+"""
+
+import os
+import json
+import csv
+import re
+
+_ITERATION_RE = re.compile(r'^iteration(\d+)$')
+
+
+def _find_output_dir(run_path, model_basename):
+    # config.json's Problem.Output is a path relative to config.json's own directory
+    config_path = os.path.join(run_path, 'config.json')
+    output_rel = None
+    if os.path.isfile(config_path):
+        try:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+            output_rel = config.get('Problem', {}).get('Output')
+        except (OSError, json.JSONDecodeError):
+            output_rel = None
+    if not output_rel:
+        output_rel = 'output/' + model_basename
+    return os.path.normpath(os.path.join(run_path, output_rel))
+
+
+def _read_palace_json(dir_path):
+    path = os.path.join(dir_path, 'palace.json')
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return None
+    return {
+        'duration_s': data.get('ElapsedTime', {}).get('Durations', {}).get('Total'),
+        'peak_ram_mb': data.get('PeakMemoryMegabytes', {}).get('Total'),
+        'dof': data.get('Problem', {}).get('DegreesOfFreedom'),
+        'mesh_elements': data.get('Problem', {}).get('MeshElements'),
+    }
+
+
+def _read_error_indicators(dir_path):
+    path = os.path.join(dir_path, 'error-indicators.csv')
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, 'r', encoding='utf-8', newline='') as f:
+            rows = [row for row in csv.reader(f, skipinitialspace=True) if row]
+    except OSError:
+        return None
+    if len(rows) < 2:
+        return None
+    headers = [h.strip() for h in rows[0]]
+    values = [v.strip() for v in rows[1]]
+    fields = dict(zip(headers, values))
+    try:
+        return {
+            'norm': float(fields['Norm']),
+            'minimum': float(fields['Minimum']),
+            'maximum': float(fields['Maximum']),
+            'mean': float(fields['Mean']),
+        }
+    except (KeyError, ValueError):
+        return None
+
+
+def _list_iteration_dirs(output_dir):
+    if not os.path.isdir(output_dir):
+        return []
+    found = []
+    for name in os.listdir(output_dir):
+        match = _ITERATION_RE.match(name)
+        full_path = os.path.join(output_dir, name)
+        if match and os.path.isdir(full_path):
+            found.append((int(match.group(1)), full_path))
+    found.sort(key=lambda item: item[0])
+    return [full_path for _, full_path in found]
+
+
+def _format_duration(seconds):
+    if seconds is None:
+        return 'n/a'
+    if seconds < 60:
+        return f"{seconds:.1f} s"
+    minutes, secs = divmod(int(round(seconds)), 60)
+    hours, minutes = divmod(minutes, 60)
+    if hours:
+        return f"{hours}h {minutes}m {secs}s"
+    return f"{minutes}m {secs}s"
+
+
+def _format_ram(mb):
+    if mb is None:
+        return 'n/a'
+    if mb >= 1024:
+        return f"{mb / 1024:.2f} GB"
+    return f"{mb:.1f} MB"
+
+
+def _format_int(n):
+    return 'n/a' if n is None else f"{n:,}"
+
+
+def _format_sci(x):
+    return 'n/a' if x is None else f"{x:.3e}"
+
+
+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.
+    """
+    output_dir = _find_output_dir(run_path, model_basename)
+    if not os.path.isdir(output_dir):
+        return (f"No Palace results found yet (expected output directory: {output_dir}) "
+                 "-- has the simulation finished?")
+
+    iteration_dirs = _list_iteration_dirs(output_dir)
+
+    if not iteration_dirs:
+        summary = _read_palace_json(output_dir)
+        errors = _read_error_indicators(output_dir)
+        if summary is None:
+            return (f"No palace.json found yet in {output_dir} "
+                     "-- has the simulation finished?")
+        lines = [
+            f"=== Simulation results: {model_basename} ===",
+            f"Degrees of freedom : {_format_int(summary['dof'])}",
+            f"Mesh elements      : {_format_int(summary['mesh_elements'])}",
+            f"Simulation time    : {_format_duration(summary['duration_s'])}",
+            f"Peak RAM           : {_format_ram(summary['peak_ram_mb'])}",
+        ]
+        if errors:
+            lines.append(
+                f"Error indicator    : Norm={_format_sci(errors['norm'])}  "
+                f"Max={_format_sci(errors['maximum'])}  Mean={_format_sci(errors['mean'])}"
+            )
+        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)))
+
+    headers = ["Iteration", "DOF", "Mesh elems", "Error Norm", "Error Max", "Error Mean", "Time", "Peak RAM"]
+    table_rows = []
+    for label, summary, errors in rows:
+        summary = summary or {}
+        errors = errors or {}
+        table_rows.append([
+            label,
+            _format_int(summary.get('dof')),
+            _format_int(summary.get('mesh_elements')),
+            _format_sci(errors.get('norm')),
+            _format_sci(errors.get('maximum')),
+            _format_sci(errors.get('mean')),
+            _format_duration(summary.get('duration_s')),
+            _format_ram(summary.get('peak_ram_mb')),
+        ])
+
+    widths = [max(len(headers[i]), *(len(r[i]) for r in table_rows)) for i in range(len(headers))]
+
+    def fmt_row(cells):
+        return " | ".join(
+            cell.ljust(widths[i]) if i == 0 else cell.rjust(widths[i])
+            for i, cell in enumerate(cells)
+        )
+
+    lines = [f"=== Simulation results: {model_basename} (adaptive mesh refinement) ==="]
+    header_line = fmt_row(headers)
+    lines.append(header_line)
+    lines.append("-+-".join("-" * w for w in widths))
+    for row in table_rows:
+        lines.append(fmt_row(row))
+    lines.append("=" * len(header_line))
+    return "\n".join(lines)

{setupem-0.3.14 → setupem-0.3.16}/src/setupEM/setupEM.py

@@ -54,6 +54,7 @@ if __package__ in (None, ""):
         VectorWidget, PopUpWindow, CreateModelTabBase, MainWindowBase,
         epsilon_to_color, default_stackup_dielectric_label, default_stackup_metal_label,
     )
+    from palace_results import build_results_summary
 else:
     from .setup_common import (
         EDIT_STYLE_OPTIONAL, EDIT_STYLE_REQUIRED, COMBO_STYLE_REQUIRED, COMBO_STYLE_OPTIONAL,
@@ -61,6 +62,7 @@ else:
         VectorWidget, PopUpWindow, CreateModelTabBase, MainWindowBase,
         epsilon_to_color, default_stackup_dielectric_label, default_stackup_metal_label,
     )
+    from .palace_results import build_results_summary
 
 
 '''
@@ -179,29 +181,43 @@ class FrequenciesTab(QWidget):
 
 
     def save_values(self):
-        try:
-            fstart = float(self.start_edit.text())
-        except Exception:
-            # the only case when this field can be empty is when fpoint or fdump are defined
-            if self.start_edit.text()=="" and (self.fpoint_edit.text() != "" or self.fdump_edit.text() != ""):
-                return True
+        # fstart/fstop may be left empty only if fpoint or fdump supplies at least
+        # one frequency instead (gds2palace treats fstart/fstop as fully optional)
+        discrete_freqs_given = (self.fpoint_edit.text() != "" or self.fdump_edit.text() != "")
+
+        fstart = None
+        if self.start_edit.text() == "":
+            if discrete_freqs_given:
+                saved_values.pop("fstart", None) # don't leave stale sweep data behind
             else:
                 QMessageBox.warning(self, "Error", "Not a valid value for fstart")
                 self.start_edit.setText("0")
                 return False
-        saved_values ["fstart"] = float(fstart)
+        else:
+            try:
+                fstart = float(self.start_edit.text())
+            except Exception:
+                QMessageBox.warning(self, "Error", "Not a valid value for fstart")
+                self.start_edit.setText("0")
+                return False
+            saved_values ["fstart"] = fstart
 
-        try:
-            fstop = float(self.stop_edit.text())
-        except Exception:
-            # the only case when this field can be empty is when fpoint or fdump are defined
-            if self.stop_edit.text()=="" and (self.fpoint_edit.text() != "" or self.fdump_edit.text() != ""):
-                return True
+        fstop = None
+        if self.stop_edit.text() == "":
+            if discrete_freqs_given:
+                saved_values.pop("fstop", None) # don't leave stale sweep data behind
             else:
                 QMessageBox.warning(self, "Error", "Not a valid value for fstop")
                 self.stop_edit.setText("50")
                 return False
-        saved_values ["fstop"] = float(fstop)
+        else:
+            try:
+                fstop = float(self.stop_edit.text())
+            except Exception:
+                QMessageBox.warning(self, "Error", "Not a valid value for fstop")
+                self.stop_edit.setText("50")
+                return False
+            saved_values ["fstop"] = fstop
 
         if self.step_edit.text() != "":
             try:
@@ -229,10 +245,13 @@ class FrequenciesTab(QWidget):
             saved_values.pop("fdump",None)
 
         # if fstart == fstop == fdump or fstart == fstop == fstep, then remove fstart, fstop
-        if saved_values ["fstart"] == saved_values ["fstop"]:
+        if fstart is not None and fstop is not None and fstart == fstop:
             discrete_list1 = saved_values.get("fpoint", [])
             discrete_list2 = saved_values.get("fdump", [])
-            if saved_values ["fstart"] in discrete_list1 or saved_values ["fstart"] in discrete_list2:
+            if fstart in discrete_list1 or fstart in discrete_list2:
+                saved_values.pop("fstart", None)
+                saved_values.pop("fstop", None)
+                saved_values.pop("fstep", None)
                 self.start_edit.setText("")
                 self.stop_edit.setText("")
                 self.step_edit.setText("")
@@ -241,8 +260,13 @@ class FrequenciesTab(QWidget):
         return True  # Tab change only possible when returning True
 
     def load_values(self):
-        self.start_edit.setText(str(saved_values.get("fstart","0")))
-        self.stop_edit.setText(str(saved_values.get("fstop","50")))
+        # if fstart/fstop were intentionally omitted in favor of fpoint/fdump, keep the
+        # fields blank on reload instead of repopulating the "0"/"50" sweep defaults
+        discrete_freqs_given = ("fpoint" in saved_values) or ("fdump" in saved_values)
+        fstart_default = "" if discrete_freqs_given else "0"
+        fstop_default  = "" if discrete_freqs_given else "50"
+        self.start_edit.setText(str(saved_values.get("fstart",fstart_default)))
+        self.stop_edit.setText(str(saved_values.get("fstop",fstop_default)))
         self.step_edit.setText(str(saved_values.get("fstep","")))
 
         float_list  = saved_values.get("fpoint","")
@@ -629,7 +653,7 @@ class MeshTab(QWidget):
         self.main_layout.setAlignment(Qt.AlignTop)
 
         label_width = 250
-        edit_width = 150
+        edit_width = 170
 
 
         # ---------- MESH GROUP ----------
@@ -685,7 +709,7 @@ class MeshTab(QWidget):
         self.mesh_order_box = QComboBox()
         self.mesh_order_box.setFixedWidth(edit_width)
         self.mesh_order_box.setStyleSheet(COMBO_STYLE_OPTIONAL)
-        self.mesh_order_box.addItems(["faster, less accurate","most accurate"])
+        self.mesh_order_box.addItems(["faster, less accurate (N=1)","recommended (N=2)", "slower, most accurate (N=3)"])
         self.meshorder_layout.addWidget(self.mesh_order_box)
         self.mesh_order_box.setCurrentIndex(0)
         self.meshorder_layout.addStretch()
@@ -902,6 +926,22 @@ class MeshTab(QWidget):
         except:
             pass
 
+        # order=3 (ultra accurate) is Palace-only: Elmer has no cubic-order solver
+        # templates in util_elmer.write_case_and_solver_files(), so it would silently
+        # fall back to first-order there. Disable that option under Elmer mode, and
+        # fall back to the default order if it was selected when switching into Elmer.
+        try:
+            ultra_accurate_index = 2
+            item = self.mesh_order_box.model().item(ultra_accurate_index)
+            if self.MainWindow.ElmerMode:
+                item.setEnabled(False)
+                if self.mesh_order_box.currentIndex() == ultra_accurate_index:
+                    self.mesh_order_box.setCurrentIndex(1)
+            else:
+                item.setEnabled(True)
+        except:
+            pass
+
 
     def save_values(self):
         try:
@@ -1079,6 +1119,26 @@ class CreateModelTab(CreateModelTabBase):
     are specific to this app.
     """
 
+    def __init__(self, MainWindow):
+        super().__init__(MainWindow)
+
+        # Tracks which action self.process is currently running, so on_finished() can tell a
+        # simulation run apart from a mesh-creation run (self.process is reused for both).
+        self._process_purpose = None
+
+    def _append_results_summary(self):
+        # Palace-only: parse palace.json / error-indicators.csv and append a results summary
+        # to the log. Called from on_finished() after a real simulation run.
+        run_path = saved_values['sim_path'] + "/palace_model/" + saved_values['model_basename'] + "_data"
+        summary = build_results_summary(run_path, saved_values['model_basename'])
+        self.log_area.appendPlainText("\n" + summary + "\n")
+
+    def on_finished(self, exit_code, exit_status):
+        super().on_finished(exit_code, exit_status)
+        # Auto-append the results summary after a real simulation run (not after mesh creation)
+        if self._process_purpose == "run_simulation" and self.MainWindow.PalaceMode:
+            self._append_results_summary()
+
     def create_model(self):
         # Request all tabs to save values again,
         # which can do some update to saved_values
@@ -1105,6 +1165,7 @@ class CreateModelTab(CreateModelTabBase):
 
             # Run Python interpreter on that file
             python_exe = sys.executable  # Use the same Python interpreter
+            self._process_purpose = "create_mesh"
             self.process.start(python_exe, [pymodel_filename])
 
 
@@ -1118,6 +1179,7 @@ class CreateModelTab(CreateModelTabBase):
 
         # clear log
         self.log_area.clear()
+        self._process_purpose = "run_simulation"
 
         if self.MainWindow.PalaceMode:
             self.log_area.appendPlainText("Trying to start Palace using script ./run_sim now")
@@ -1143,10 +1205,21 @@ class CreateModelTab(CreateModelTabBase):
 
 
                 wsl_run_path = windows_to_wsl_path(run_path)
-                # tell user what to do, we can open WSL in the right place but not start simulation
-                self.log_area.appendPlainText("Running on Windows with WSL, you need to type ./run_sim in the terminal yourself!")
-                self.log_area.appendPlainText("Note that this works for LOCAL drives only, we can't open WSL on network drive.")
-                self.process.start("cmd.exe", ["/c", "start", "wt.exe", "wsl", "--cd", wsl_run_path])
+                self.log_area.appendPlainText("Running on Windows with WSL: starting ./run_sim ...")
+                self.log_area.appendPlainText("Note that this works for LOCAL drives only, we can't open WSL on network drive.\n")
+                # Run wsl.exe directly as self.process (no terminal emulator in between), so Palace's
+                # stdout/stderr stream into this log via the existing on_stdout/on_stderr handlers, and
+                # on_finished fires with the real exit code when ./run_sim actually completes -- instead
+                # of opening a detached terminal window, whose own quoting/tokenization rules (cmd's
+                # "start", and wt.exe's own use of ";" as a pane/command separator) make embedding a
+                # multi-step shell command fragile, and whose completion can't be tracked anyway.
+                # bash -lc: login shell so ~/.profile (where PATH additions for run_palace/combine_snp
+                # usually live, per gds2palace's scripts/README.md) gets sourced, same as a manually
+                # typed ./run_sim in a fresh WSL login shell would.
+                self.process.start("wsl.exe", [
+                    "--cd", wsl_run_path,
+                    "--", "bash", "-lc", "./run_sim"
+                ])
             else:
                 # Linux
                 self.log_area.appendPlainText('Setting work directory ' + run_path)

{setupem-0.3.14 → setupem-0.3.16}/src/setupEM/setup_common.py

@@ -32,7 +32,7 @@ mesh fields, the Python model code generator bodies) is intentionally left
 in setupEM.py / setupThermal.py, not here.
 """
 
-import sys, os, json, pathlib, ast, webbrowser
+import sys, os, json, pathlib, ast, webbrowser, io, contextlib
 import xml.etree.ElementTree as ET
 import numpy as np
 import requests
@@ -497,7 +497,7 @@ class FileInputTab(QWidget):
         self.MainWindow.saved_values["SubstrateFile"] = filename.replace('\\', '/')
         self.update_XML_description(filename)
         self.update_variable_overrides_grid(filename)
-        self.MainWindow.read_XML()  # safe if invalid filename
+        self.MainWindow.read_XML()  # shows an error dialog and keeps prior data on invalid/unparseable XML
         # file is read when leaving the files tab
 
     def update_XML_description(self, filename):
@@ -1246,6 +1246,16 @@ class CreateModelTabBase(QWidget):
         self.log_group.setLayout(self.log_layout)
         self.log_area = QPlainTextEdit()
         self.log_area.setReadOnly(True)
+        log_font = QFont()
+        # Consolas/Cascadia Mono: Windows. Ubuntu Mono: default on Ubuntu (this app's primary
+        # Linux target, see the Ubuntu 24.04 notice below) and narrower than DejaVu Sans Mono.
+        # Liberation Mono/DejaVu Sans Mono: broader Linux fallbacks. "monospace": generic
+        # fontconfig alias, guaranteed to resolve to an installed monospace font on Linux.
+        log_font.setFamilies(["Consolas", "Cascadia Mono", "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "monospace"])
+        log_font.setStyleHint(QFont.Monospace)
+        log_font.setFixedPitch(True)
+        log_font.setPointSize(9)
+        self.log_area.setFont(log_font)
         self.log_layout.addWidget(self.log_area)
 
         self.main_layout.addWidget(self.file_group)
@@ -1824,8 +1834,22 @@ class MainWindowBase(QMainWindow):
     def read_XML(self):
         filename = self.saved_values["SubstrateFile"]
         if pathlib.Path(filename).exists():
-            self.materials_list, self.dielectrics_list, self.metals_list = stackup_reader.read_substrate(
-                filename, variable_overrides=self.saved_values.get("variable_overrides"))
+            captured_stdout = io.StringIO()
+            try:
+                with contextlib.redirect_stdout(captured_stdout):
+                    materials_list, dielectrics_list, metals_list = stackup_reader.read_substrate(
+                        filename, variable_overrides=self.saved_values.get("variable_overrides"))
+            except (Exception, SystemExit) as e:
+                # SystemExit is caught deliberately (not just Exception): the reader
+                # reports hard validation failures (circular/ambiguous Reference,
+                # Offset+Reference conflict, ...) via print(...); exit(1) instead of
+                # raising - see the same pattern in stackupEditor.py's _refresh_preview().
+                # Capture stdout so that printed ERROR text (otherwise invisible in a
+                # GUI with no attached console) can be shown to the user.
+                details = captured_stdout.getvalue().strip() or str(e)
+                QMessageBox.critical(self, "Error", f"Could not load stackup {filename}:\n\n{details}")
+                return  # keep last-known-good materials_list/dielectrics_list/metals_list
+            self.materials_list, self.dielectrics_list, self.metals_list = materials_list, dielectrics_list, metals_list
             self.update_target_layer_choices(self.metals_list)
             self.file_tab.update_XML_description(filename)
             self.file_tab.update_variable_overrides_grid(filename)

{setupem-0.3.14 → setupem-0.3.16/src/setupEM.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.3.14
+Version: 0.3.16
 Summary: Python tool for configuration of gds2palace workflow with GUI.
 Author-email: Volker Muehlhaus <volker@muehlhaus.com>
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: gds2palace>=0.3.6
+Requires-Dist: gds2palace>=0.4.0
 Requires-Dist: PySide6
 Requires-Dist: scipy
 Requires-Dist: requests
@@ -126,7 +126,7 @@ On this tab, you configure input files:
 
 The fields for GDSII and XML file support drag & drop or you can use the Browse... buttons.
 
-Some pre-processing of the layout is also defined here: You can specify a distance (in micron) which is used for **via array merging**, to speed up simulation by replacing many individual vias with one large via box. If your layout includes **polygons with holes**, you need to set the "Preprocess GDSII file" checkbox, otherwise you will get error messages during meshing.
+Some pre-processing of the layout is also defined here: You can specify a distance (in micron) which is used for **via array merging**, to speed up simulation by replacing many individual vias with one large via box.
 
 <img src="https://raw.githubusercontent.com/VolkerMuehlhaus/setupEM/main/doc/png/inputfiles1.png" alt="input files" width="700">
 
@@ -272,7 +272,7 @@ This project is licensed under the GNU General Public License v3.0 or later (GPL
 
 **Note:** the `setupEM` PyPI package itself requires:
 
-- gds2palace>=0.3.6
+- gds2palace>=0.4.0
 - PySide6
 - scipy
 - requests

{setupem-0.3.14 → setupem-0.3.16}/src/setupEM.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ pyproject.toml
 src/setupEM/__init__.py
 src/setupEM/__main__.py
 src/setupEM/momentum_import.py
+src/setupEM/palace_results.py
 src/setupEM/setupEM.py
 src/setupEM/setupThermal.py
 src/setupEM/setup_common.py

{setupem-0.3.14 → setupem-0.3.16}/src/setupEM.egg-info/requires.txt

@@ -1,4 +1,4 @@
-gds2palace>=0.3.6
+gds2palace>=0.4.0
 PySide6
 scipy
 requests