setupEM 0.5.1__tar.gz → 0.6.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.5.1
+Version: 0.6.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
@@ -15,6 +15,7 @@ Requires-Dist: scikit-rf
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: gdspy
+Requires-Dist: meshio
 Dynamic: license-file
 
 # Python GUI for gds2palace 

{setupem-0.5.1 → setupem-0.6.1}/pyproject.toml

@@ -19,7 +19,8 @@ dependencies = [
     "scikit-rf",
     "matplotlib",
     "numpy",
-    "gdspy"
+    "gdspy",
+    "meshio"
 ]
 requires-python = ">=3.9"
 

{setupem-0.5.1 → setupem-0.6.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.1"
+__version__ = "0.6.1"

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

@@ -27,6 +27,7 @@ import csv
 import re
 import math
 import cmath
+import glob
 
 _ITERATION_RE = re.compile(r'^iteration(\d+)$')
 
@@ -47,6 +48,23 @@ def find_output_dir(run_path, model_basename):
     return os.path.normpath(os.path.join(run_path, output_rel))
 
 
+def find_paraview_files(run_path, model_basename):
+    """All ParaView collection files under this run's Palace output directory, found
+    recursively. Palace's own field-dump feature (triggered by fdump/SaveStep) writes
+    its category/excitation folder structure without gds2palace's control - confirmed
+    (on two Palace versions) to only keep the last-solved excitation's Cycle files, so
+    no fixed filename or count can be assumed here. Falls back to loose .vtu if no .pvd
+    exists yet. Empty list if the output directory doesn't exist / has nothing yet.
+    """
+    output_dir = find_output_dir(run_path, model_basename)
+    if not os.path.isdir(output_dir):
+        return []
+    pvd_files = sorted(glob.glob(os.path.join(output_dir, '**', '*.pvd'), recursive=True))
+    if pvd_files:
+        return pvd_files
+    return sorted(glob.glob(os.path.join(output_dir, '**', '*.vtu'), recursive=True))
+
+
 def _read_palace_json(dir_path):
     path = os.path.join(dir_path, 'palace.json')
     if not os.path.isfile(path):

{setupem-0.5.1 → setupem-0.6.1}/src/setupEM/result_viewer.py

@@ -205,6 +205,32 @@ def find_touchstone_files(target_dir):
     return sorted(matches)
 
 
+# AWS Palace adaptive mesh refinement writes one result snapshot per
+# iteration<N>/ subfolder alongside the final, fully-refined result in the
+# parent directory itself (see _ITERATION_RE in palace_results.py, reverse
+# engineered from real Palace output) - same convention, applied per path
+# component so it matches regardless of how deep target_dir's own scan went.
+_AMR_ITERATION_DIR_RE = re.compile(r'^iteration\d+$')
+
+
+def is_amr_iteration_snapshot(path):
+    """True if path sits inside an AMR "iterationN" output folder, i.e. it's
+    a per-iteration snapshot rather than the final result."""
+    parts = os.path.normpath(path).split(os.sep)
+    return any(_AMR_ITERATION_DIR_RE.match(part) for part in parts)
+
+
+def pick_final_result_file(paths):
+    """Given a list of touchstone file paths, prefer the final result (any
+    path with no "iterationN" component) over AMR per-iteration snapshots;
+    break ties (or fall back, if every path is a snapshot) by newest mtime.
+    Returns None for an empty list."""
+    if not paths:
+        return None
+    final_candidates = [p for p in paths if not is_amr_iteration_snapshot(p)] or paths
+    return max(final_candidates, key=os.path.getmtime)
+
+
 # ------------------------------------------------------------------
 # Result Viewer window
 # ------------------------------------------------------------------
@@ -364,13 +390,12 @@ class ResultViewerWindow(QDialog):
                 item.setFlags(Qt.NoItemFlags)
                 self.file_list.addTopLevelItem(item)
             else:
-                # drop checked paths that no longer exist; auto-check the newest
-                # file if nothing is checked (e.g. first open), so the window
-                # isn't blank
+                # drop checked paths that no longer exist; auto-check the final
+                # result (preferring it over any AMR per-iteration snapshot) if
+                # nothing is checked (e.g. first open), so the window isn't blank
                 self._checked_paths &= set(self._master_files)
                 if not self._checked_paths:
-                    newest = max(self._master_files, key=os.path.getmtime)
-                    self._checked_paths = {newest}
+                    self._checked_paths = {pick_final_result_file(self._master_files)}
 
                 # group by each file's immediate parent directory (relative to
                 # target_dir), not a Palace/Elmer-specific convention like

{setupem-0.5.1 → setupem-0.6.1}/src/setupEM/setupEM.py

@@ -17,7 +17,7 @@
 ########################################################################
 
 
-import sys, json, os, pathlib, ast, webbrowser, argparse, shutil, re
+import sys, json, os, pathlib, ast, webbrowser, argparse, shutil, re, glob
 import numpy as np
 import importlib.metadata
 import importlib.util
@@ -55,7 +55,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, find_output_dir
+    from palace_results import build_results_summary, find_output_dir, find_paraview_files
 else:
     from .setup_common import (
         EDIT_STYLE_OPTIONAL, EDIT_STYLE_REQUIRED, COMBO_STYLE_REQUIRED, COMBO_STYLE_OPTIONAL,
@@ -63,7 +63,7 @@ else:
         VectorWidget, PopUpWindow, CreateModelTabBase, MainWindowBase,
         epsilon_to_color, default_stackup_dielectric_label, default_stackup_metal_label,
     )
-    from .palace_results import build_results_summary, find_output_dir
+    from .palace_results import build_results_summary, find_output_dir, find_paraview_files
 
 
 '''
@@ -244,6 +244,8 @@ class FrequenciesTab(QWidget):
             saved_values ["fdump"] = ast.literal_eval('['+text+']')
         else:
             saved_values.pop("fdump",None)
+        # "View fields in Paraview" is only relevant once fdump is set
+        self.MainWindow.create_model_tab._update_paraview_button_visibility()
 
         # if fstart == fstop == fdump or fstart == fstop == fstep, then remove fstart, fstop
         if fstart is not None and fstop is not None and fstart == fstop:
@@ -644,6 +646,130 @@ class PortsTab(QWidget):
 
 
 
+class RefinedCellsizeOverrideDialog(QDialog):
+    """Popup editor for settings['refined_cellsize_override'], opened from
+    MeshTab's "Advanced..." button. Lets the user set a different mesh
+    refinement cell size for specific metal/sheet layers, instead of the
+    single global "Mesh refinement at metal edges" value. The Layer column
+    is restricted to metals_list.getallplanarmetals() (conductor/sheet
+    layers) - vias and dielectrics never produce boundary curves in
+    gds2palace's meshing code, so a name outside that list would silently
+    have no effect if it were allowed to be typed in.
+    """
+
+    def __init__(self, parent, layer_choices, current_overrides):
+        super().__init__(parent)
+        self.setAttribute(Qt.WA_DeleteOnClose)
+        self.setWindowTitle("Mesh Refinement Overrides")
+        self.resize(420, 400)
+        self.setModal(True)
+
+        self._layer_choices = layer_choices
+        self._result = []
+
+        layout = QVBoxLayout()
+
+        info = QLabel("Override the mesh refinement cell size for specific layers\n"
+                      "(all other layers keep using the default set above).")
+        layout.addWidget(info)
+
+        self.table = QTableWidget()
+        self.table.setColumnCount(3)
+        self.table.setHorizontalHeaderLabels(["Layer", "Cell size (µm)", ""])
+        self.table.verticalHeader().setVisible(False)
+        self.table.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        header = self.table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
+        header.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
+        layout.addWidget(self.table)
+
+        for name, value in current_overrides:
+            self._add_row(name, value)
+
+        add_row_layout = QHBoxLayout()
+        add_btn = QPushButton("+ Add Row")
+        add_btn.clicked.connect(lambda: self._add_row())
+        add_row_layout.addWidget(add_btn)
+        add_row_layout.addStretch()
+        layout.addLayout(add_row_layout)
+
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        ok_btn = QPushButton("OK")
+        ok_btn.clicked.connect(self._on_ok)
+        button_layout.addWidget(ok_btn)
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        button_layout.addWidget(cancel_btn)
+        layout.addLayout(button_layout)
+
+        self.setLayout(layout)
+
+    def _add_row(self, name="", value=""):
+        row = self.table.rowCount()
+        self.table.insertRow(row)
+
+        combo = QComboBox()
+        combo.setStyleSheet(COMBO_STYLE_OPTIONAL)
+        combo.addItem("")
+        combo.addItems(self._layer_choices)
+        if name and name not in self._layer_choices:
+            # tolerate a saved override for a layer no longer in the current
+            # stackup, same tolerant style as the Cellname combo box
+            combo.addItem(name)
+        if name:
+            combo.setCurrentText(name)
+        self.table.setCellWidget(row, 0, combo)
+
+        value_text = "" if value == "" else str(value)
+        self.table.setItem(row, 1, QTableWidgetItem(value_text))
+
+        remove_btn = QPushButton("✕")
+        remove_btn.setFixedWidth(28)
+        remove_btn.clicked.connect(lambda: self._remove_row_containing(remove_btn))
+        self.table.setCellWidget(row, 2, remove_btn)
+
+    def _remove_row_containing(self, button):
+        # look up the row by identity rather than a captured index, since
+        # row indices shift whenever an earlier row is removed
+        for row in range(self.table.rowCount()):
+            if self.table.cellWidget(row, 2) is button:
+                self.table.removeRow(row)
+                return
+
+    def _on_ok(self):
+        overrides = []
+        seen_layers = set()
+        for row in range(self.table.rowCount()):
+            combo = self.table.cellWidget(row, 0)
+            layer = combo.currentText().strip() if combo else ""
+            if not layer:
+                continue  # blank row - not yet configured, skip silently
+
+            value_item = self.table.item(row, 1)
+            value_text = value_item.text().strip() if value_item else ""
+            try:
+                value = float(value_text)
+                if value <= 0:
+                    raise ValueError
+            except ValueError:
+                QMessageBox.warning(self, "Error", f"Not a valid cell size for layer '{layer}'")
+                return
+
+            if layer in seen_layers:
+                QMessageBox.warning(self, "Error", f"Layer '{layer}' is selected more than once")
+                return
+            seen_layers.add(layer)
+            overrides.append([layer, value])
+
+        self._result = overrides
+        self.accept()
+
+    def get_overrides(self):
+        return self._result
+
+
 class MeshTab(QWidget):
     def __init__(self, MainWindow):
         super().__init__()
@@ -662,42 +788,44 @@ class MeshTab(QWidget):
         self.mesh_layout = QVBoxLayout()
 
         self.refinement_layout = QHBoxLayout()
-        self.label2 = QLabel("Mesh refinement at metal edges")
+        self.label2 = QLabel("Mesh refinement at metal edges (µm)")
         self.label2.setFixedWidth(label_width)
         self.refinement_layout.addWidget(self.label2)
         self.refinement_edit = QLineEdit("5")
         self.refinement_edit.setFixedWidth(edit_width)
         self.refinement_edit.setStyleSheet(EDIT_STYLE_REQUIRED)
         self.refinement_layout.addWidget(self.refinement_edit)
-        self.label3 = QLabel(" µm ")
-        self.refinement_layout.addWidget(self.label3)
+        self.refined_override_btn = QPushButton("Advanced...")
+        self.refined_override_btn.clicked.connect(self.open_refined_cellsize_override_dialog)
+        self.refinement_layout.addWidget(self.refined_override_btn)
         self.refinement_layout.addStretch()
         self.mesh_layout.addLayout(self.refinement_layout)
 
+        # in-memory copy of settings['refined_cellsize_override'] (list of
+        # [layername, value] pairs), edited via the "Advanced..." dialog;
+        # harvested into saved_values by save_values() like every other field
+        self._refined_cellsize_override = []
+
         self.cells_lambda_layout = QHBoxLayout()
-        self.label4 = QLabel("Mesh cells per wavelength")
+        self.label4 = QLabel("Mesh cells per wavelength (min 10)")
         self.label4.setFixedWidth(label_width)
         self.cells_lambda_layout.addWidget(self.label4)
         self.cells_lambda_edit = QLineEdit("10")
         self.cells_lambda_edit.setFixedWidth(edit_width)
         self.cells_lambda_edit.setStyleSheet(EDIT_STYLE_OPTIONAL)
         self.cells_lambda_layout.addWidget(self.cells_lambda_edit)
-        self.label5 = QLabel(" (min 10)")
-        self.cells_lambda_layout.addWidget(self.label5)
         self.cells_lambda_layout.addStretch()
         self.mesh_layout.addLayout(self.cells_lambda_layout)
 
 
         self.cells_maxsize_layout = QHBoxLayout()
-        self.label6 = QLabel("Mesh cell maximum size absolute")
+        self.label6 = QLabel("Mesh cell maximum size absolute (µm)")
         self.label6.setFixedWidth(label_width)
         self.cells_maxsize_layout.addWidget(self.label6)
         self.cells_maxsize_edit = QLineEdit("100")
         self.cells_maxsize_edit.setFixedWidth(edit_width)
         self.cells_maxsize_edit.setStyleSheet(EDIT_STYLE_OPTIONAL)
         self.cells_maxsize_layout.addWidget(self.cells_maxsize_edit)
-        self.label5 = QLabel(" µm ")
-        self.cells_maxsize_layout.addWidget(self.label5)
         self.cells_maxsize_layout.addStretch()
         self.mesh_layout.addLayout(self.cells_maxsize_layout)
 
@@ -916,6 +1044,22 @@ class MeshTab(QWidget):
         self.setLayout(self.main_layout)
 
 
+    def _update_refined_override_button_label(self):
+        n = len(self._refined_cellsize_override)
+        self.refined_override_btn.setText(f"Advanced... ({n})" if n > 0 else "Advanced...")
+
+    def open_refined_cellsize_override_dialog(self):
+        metals_list = self.MainWindow.metals_list
+        if metals_list is None:
+            QMessageBox.warning(self, "Error", "Load a GDSII file and XML stackup first")
+            return
+
+        layer_choices = [metal.name for metal in metals_list.getallplanarmetals()]
+        dialog = RefinedCellsizeOverrideDialog(self, layer_choices, self._refined_cellsize_override)
+        if dialog.exec() == QDialog.Accepted:
+            self._refined_cellsize_override = dialog.get_overrides()
+            self._update_refined_override_button_label()
+
     def on_meshorder_changed(self, value):
     # callback when mesh order changed, so that we can show/hide edit fields
         try:
@@ -952,6 +1096,7 @@ class MeshTab(QWidget):
             self.refinement_edit.setText("5")
             return False
         saved_values ["refined_cellsize"] = float(value)
+        saved_values ["refined_cellsize_override"] = self._refined_cellsize_override
 
         saved_values ["order"] = self.mesh_order_box.currentIndex()+1
 
@@ -1053,6 +1198,8 @@ class MeshTab(QWidget):
 
     def load_values(self):
         self.refinement_edit.setText(str(saved_values.get("refined_cellsize","5")))
+        self._refined_cellsize_override = list(saved_values.get("refined_cellsize_override", []))
+        self._update_refined_override_button_label()
         self.cells_lambda_edit.setText(str(saved_values.get("cells_per_wavelength","10")))
         self.cells_maxsize_edit.setText(str(saved_values.get("meshsize_max","100")))
         self.AMR_iterations_edit.setText(str(saved_values.get("adaptive_mesh_iterations","0")))
@@ -1080,17 +1227,23 @@ class MeshTab(QWidget):
             self.airaround_edit.setText(saved_values.get("margin","200"))
             self.airaround_box.setCurrentIndex(0)
         else:
-            if "," in str(air):
-                # we have a list of 6 values
-                air_as_list = air.split(',')
-                if len(air_as_list) == 6:
-                    self.airaround_box.setCurrentIndex(1)
-                    self.airxmin_edit.setText(air_as_list[0])
-                    self.airxmax_edit.setText(air_as_list[1])
-                    self.airymin_edit.setText(air_as_list[2])
-                    self.airymax_edit.setText(air_as_list[3])
-                    self.airzmin_edit.setText(air_as_list[4])
-                    self.airzmax_edit.setText(air_as_list[5])
+            # native JSON round-trip stores this as a real list of floats;
+            # .py import stores it as a comma-separated string instead
+            if isinstance(air, list):
+                air_as_list = [str(v) for v in air]
+            elif "," in str(air):
+                air_as_list = [v.strip() for v in str(air).split(',')]
+            else:
+                air_as_list = None
+
+            if air_as_list and len(air_as_list) == 6:
+                self.airaround_box.setCurrentIndex(1)
+                self.airxmin_edit.setText(air_as_list[0])
+                self.airxmax_edit.setText(air_as_list[1])
+                self.airymin_edit.setText(air_as_list[2])
+                self.airymax_edit.setText(air_as_list[3])
+                self.airzmin_edit.setText(air_as_list[4])
+                self.airzmax_edit.setText(air_as_list[5])
             else:
                 # we have air_around defined as a single value
                 self.airaround_box.setCurrentIndex(0)
@@ -1134,13 +1287,26 @@ class CreateModelTab(CreateModelTabBase):
         # up exactly with Preview/Create Mesh/Start Simulation above, in the same
         # Actions group.
         row = self.buttons_grid.rowCount()
-        self.view_results_btn = QPushButton("📈 View Results...")
+        self.view_results_btn = QPushButton("📈 View S-Parameters...")
         self.view_results_btn.clicked.connect(self.MainWindow.open_result_viewer)
         self.buttons_grid.addWidget(self.view_results_btn, row, 0)
         self.model_fit_btn = QPushButton("🧩 Model Fit...")
         self.model_fit_btn.clicked.connect(self.open_model_fit)
         self.buttons_grid.addWidget(self.model_fit_btn, row, 1)
 
+        # "View fields in Paraview" opens field-dump data (Palace fdump / Elmer EM
+        # fields*.vtu), a separate row since it's independent of the S-parameter
+        # viewer/model fit above. Only meaningful when fdump is set (otherwise there's
+        # never any field data to open), so it's hidden rather than shown greyed-out -
+        # kept in sync with saved_values['fdump'] via _update_paraview_button_visibility(),
+        # called from here, from load_values() (project/model import), and from
+        # FrequenciesTab.save_values() (live edits to the fdump field).
+        row = self.buttons_grid.rowCount()
+        self.paraview_btn = QPushButton("🖼️ View fields in Paraview...")
+        self.paraview_btn.clicked.connect(self.launch_paraview)
+        self.buttons_grid.addWidget(self.paraview_btn, row, 0)
+        self._update_paraview_button_visibility()
+
     def open_model_fit(self):
         SNP2LE_URL = "https://github.com/iic-jku/snp2le"
 
@@ -1171,9 +1337,9 @@ class CreateModelTab(CreateModelTabBase):
         # local import: only needed once snp2le is actually launched, same lazy-import
         # style used by open_result_viewer() for its own heavy imports.
         if __package__ in (None, ""):
-            from result_viewer import find_touchstone_files
+            from result_viewer import find_touchstone_files, is_amr_iteration_snapshot
         else:
-            from .result_viewer import find_touchstone_files
+            from .result_viewer import find_touchstone_files, is_amr_iteration_snapshot
 
         if self.MainWindow.PalaceMode:
             run_path = saved_values['sim_path'] + "/palace_model/" + saved_values['model_basename'] + "_data"
@@ -1189,23 +1355,28 @@ class CreateModelTab(CreateModelTabBase):
             QMessageBox.warning(self, "Model Fit",
                                  f"No raw S-parameter result file found in {run_path}.\nRun a simulation first.")
             return
-        if len(raw_files) > 1:
-            self.log_area.appendPlainText("⚠️ Multiple raw S-parameter result files found, using the first one:")
-            for path in raw_files:
+
+        # adaptive mesh refinement leaves one snapshot touchstone file per
+        # iteration<N>/ subfolder alongside the final, fully-refined result
+        # directly in run_path - prefer that final result over the snapshots.
+        final_candidates = [p for p in raw_files if not is_amr_iteration_snapshot(p)] or raw_files
+        if len(final_candidates) > 1:
+            self.log_area.appendPlainText("⚠️ Multiple raw S-parameter result files found, using the newest one:")
+            for path in final_candidates:
                 self.log_area.appendPlainText("  " + path)
-        raw_file = raw_files[0]
+        raw_file = max(final_candidates, key=os.path.getmtime)
 
-        # snp2le's GUI mode takes no filename argument (only its "-b" batch mode does) -
-        # the file has to be loaded by hand via the GUI's own file picker, so point the
-        # user at it explicitly and start snp2le in that file's directory, so its file
-        # picker opens there instead of wherever setupEM happened to be launched from.
+        # naming a .sNp file on the command line opens snp2le's GUI on it directly
+        # (see https://github.com/iic-jku/snp2le/blob/main/doc/architecture.md);
+        # still start it in that file's directory, so any relative paths it uses
+        # (e.g. for exporting a fit) resolve there instead of wherever setupEM
+        # happened to be launched from.
         raw_dir = os.path.dirname(raw_file)
-        self.log_area.appendPlainText("Starting snp2le ...")
+        self.log_area.appendPlainText(f"Starting snp2le on {raw_file} ...")
         self.log_area.appendPlainText(SNP2LE_URL)
-        self.log_area.appendPlainText(f"In the snp2le window, load: {raw_file}")
         self._process_purpose = "model_fit"
         self.process.setWorkingDirectory(raw_dir)
-        self.process.start(sys.executable, ["-m", "snp2le"])
+        self.process.start(sys.executable, ["-m", "snp2le", raw_file])
 
     def _append_results_summary(self):
         # Palace-only: parse palace.json / error-indicators.csv and append a results summary
@@ -1214,6 +1385,43 @@ class CreateModelTab(CreateModelTabBase):
         summary = build_results_summary(run_path, saved_values['model_basename'])
         self.log_area.appendPlainText("\n" + summary + "\n")
 
+    def _update_paraview_button_visibility(self):
+        self.paraview_btn.setVisible(bool(saved_values.get('fdump')))
+
+    def load_values(self):
+        super().load_values()
+        self._update_paraview_button_visibility()
+
+    def launch_paraview(self):
+        if self.MainWindow.PalaceMode:
+            run_path = saved_values['sim_path'] + "/palace_model/" + saved_values['model_basename'] + "_data"
+            file_paths = find_paraview_files(run_path, saved_values['model_basename'])
+            not_found = (
+                f"⚠️ No Palace field-dump output found under "
+                f"{find_output_dir(run_path, saved_values['model_basename'])}\n"
+                "(set fdump to specific frequencies before running the simulation)\n"
+            )
+        else:
+            run_path = saved_values['sim_path'] + "/elmer_model/" + saved_values['model_basename'] + "_data"
+            # Output File Name = File "fields" has no path prefix, so Elmer resolves it
+            # relative to the Mesh DB directory ("mesh" under run_path) rather than
+            # run_path itself - confirmed against a real run (same resolution mechanism
+            # found for thermal_results.vtu). Check run_path too, defensively.
+            search_dirs = [os.path.join(run_path, "mesh"), run_path]
+            file_paths = []
+            for pattern in ("fields*.pvd", "fields*.vtu"):
+                for d in search_dirs:
+                    file_paths = sorted(glob.glob(os.path.join(d, pattern)))
+                    if file_paths:
+                        break
+                if file_paths:
+                    break
+            not_found = (
+                f"⚠️ No Elmer field-dump output found under {run_path}\n"
+                "(set fdump to specific frequencies before running the simulation)\n"
+            )
+        self._open_in_paraview(file_paths, not_found)
+
     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)
@@ -1275,9 +1483,13 @@ class CreateModelTab(CreateModelTabBase):
 
         Palace writes all of its results into one dedicated subdirectory (named in
         config.json's Problem.Output, resolved via find_output_dir()), so that whole
-        subtree is the deletion target. Elmer has no such subdirectory - its solver
-        writes scalar_results.*/fields*.vtu*/*.sNp files directly into run_path
-        alongside the mesh/config - so those are matched and removed individually.
+        subtree is the deletion target. Elmer's SaveScalars/ResultOutputSolver write
+        bare filenames (no path prefix) in their .sif config, so Elmer resolves them
+        relative to the Mesh DB directory ("mesh" under run_path) rather than run_path
+        itself - confirmed against real runs (same resolution mechanism found for
+        thermal_results.vtu, and combine_snp.py itself expects "scalar_results" under
+        a "mesh" parent and writes the resulting .sNp file there too). run_path itself
+        is also checked, defensively, in case some variant writes there directly.
         """
         if self.MainWindow.PalaceMode:
             output_dir = find_output_dir(run_path, saved_values['model_basename'])
@@ -1286,12 +1498,14 @@ class CreateModelTab(CreateModelTabBase):
             targets = [output_dir]
         else:
             targets = []
-            if os.path.isdir(run_path):
-                for fn in os.listdir(run_path):
-                    full_path = os.path.join(run_path, fn)
+            for search_dir in (os.path.join(run_path, "mesh"), run_path):
+                if not os.path.isdir(search_dir):
+                    continue
+                for fn in os.listdir(search_dir):
+                    full_path = os.path.join(search_dir, fn)
                     if not os.path.isfile(full_path):
                         continue
-                    if fn in ("scalar_results.dat", "scalar_results.names") or \
+                    if fn in ("scalar_results", "scalar_results.names") or \
                        fn.startswith("fields") or re.search(r'\.s\d+p$', fn, re.IGNORECASE):
                         targets.append(full_path)
             if not targets:
@@ -1390,17 +1604,27 @@ class CreateModelTab(CreateModelTabBase):
 
                 self.log_area.appendPlainText('Setting work directory ' + run_path)
 
-                # rename file to batch file, but only if that has not already
-                # been done by a previous run (otherwise os.rename() fails on
-                # the second run because run_elmer no longer exists)
-                run_file_orig = os.path.join(run_path, 'run_elmer')
-                run_file = run_file_orig.replace('run_elmer','run_elmer.bat')
-                if os.path.exists(run_file_orig):
-                    os.rename(run_file_orig, run_file)
-
+                # create_elmer_run_script() (util_utilities.py) writes run_elmer.bat
+                # directly on Windows (proper .bat content - no "#!/bin/bash" shebang,
+                # and MS-MPI's "mpiexec -n N" instead of the Linux-only "mpirun -np N"),
+                # so no rename step is needed here any more.
+                if saved_values.get('ELMER_MPI_THREADS', 1) > 1 and shutil.which("mpiexec") is None:
+                    self.log_area.appendPlainText(
+                        "⚠️ This model requests MPI multithreading, but 'mpiexec' was not "
+                        "found on PATH. On Windows, Elmer uses Microsoft MPI - download and "
+                        "install it from "
+                        "https://learn.microsoft.com/en-us/message-passing-interface/microsoft-mpi "
+                        "and restart setupEM, or switch to 1 thread (no multithreading) on the "
+                        "Mesh and Boundaries tab.\n"
+                    )
+                    return
                 self.process.setWorkingDirectory(run_path)
-                # start simulation
-                self.process.start("run_elmer.bat")
+                # start simulation - full path, not just "run_elmer.bat": Windows'
+                # CreateProcess resolves a bare relative program name against the
+                # CALLING process's own cwd/PATH, not the child's setWorkingDirectory(),
+                # so a bare filename here silently fails with FailedToStart even though
+                # setWorkingDirectory() is set correctly.
+                self.process.start(os.path.join(run_path, "run_elmer.bat"))
             else:
                 # Linux
                 self.log_area.appendPlainText('Setting work directory ' + run_path)
@@ -1516,7 +1740,7 @@ class ModelEditorTab(QWidget):
 
         if forExport:
             # these commands are only used within this GUI application to control gmsh
-            ignore_list.append(['preview_only','no_preview'])
+            ignore_list.extend(['preview_only','no_preview'])
 
         for key in saved_values.keys():
             if not key in special_keylist:
@@ -1739,7 +1963,9 @@ class MainWindow(MainWindowBase):
         self.PalaceMode = False
         self.ElmerMode  = True
         self.setWindowTitle(APP_NAME + ' Elmer')
-        self.frequencies_tab.dump_group.setVisible(False)
+        # fdump now also enables Elmer EM field dumps (Exec Solver = Always), not just
+        # Palace's SaveStep - so this group must stay visible/usable in Elmer mode too.
+        self.frequencies_tab.dump_group.setVisible(True)
         self.mesh_tab.AMR_group.setVisible(False)
         self.mesh_tab.Elmer_group.setVisible(True)
 
@@ -1802,20 +2028,37 @@ class MainWindow(MainWindowBase):
     def apply_native_config_data(self, data):
         # update ports, they are separate from the other internal data
         self.ports_tab.update_port_from_import(data.get("ports"))
+        # restore simulator mode (not part of saved_values, see native_config_extra_struct)
+        if data.get("elmer_mode", False):
+            self.setElmerMode()
+        else:
+            self.setPalaceMode()
 
     def apply_python_import_data(self, file_path):
         # read port assignments in workflow syntax for gds2palace Python code
         ports = parse_python_ports_definitions(file_path)
         self.ports_tab.update_port_from_import(ports)
 
-        # set simulator
-        if self.saved_values.get("elmer", False):
+        # Elmer/Palace mode isn't captured by the general settings-dict import
+        # (parse_assignments() skips lines whose value contains "settings", and
+        # 'elmer' isn't in import_mapping anyway), so detect it directly from the
+        # source text instead. Two valid ways a script selects Elmer mode:
+        #  - calling simulation_setup.create_elmer(...) (what create_model_text()
+        #    itself generates, with a space before "(" - a plain "create_elmer("
+        #    substring check never matches that)
+        #  - setting settings['elmer'] = True directly and calling create_model()
+        #    itself (create_elmer() is only a thin wrapper that sets this same flag)
+        with open(file_path) as f:
+            text = f.read()
+        elmer_call = re.search(r'create_elmer\s*\(', text)
+        elmer_flag = re.search(r'settings\s*\[\s*[\'"]elmer[\'"]\s*\]\s*=\s*True\b', text, re.IGNORECASE)
+        if elmer_call or elmer_flag:
             self.setElmerMode()
         else:
             self.setPalaceMode()
 
     def native_config_extra_struct(self):
-        return {"ports": simulation_ports_to_struct(simulation_ports)}
+        return {"ports": simulation_ports_to_struct(simulation_ports), "elmer_mode": self.ElmerMode}
 
     def update_target_layer_choices(self, metals_list):
         self.ports_tab.update_layers(metals_list)

{setupem-0.5.1 → setupem-0.6.1}/src/setupEM/setupThermal.py

@@ -53,12 +53,14 @@ if __package__ in (None, ""):
         FileDropLineEdit, FileInputTab, PythonHighlighter, CodeEditor,
         VectorWidget, PopUpWindow, CreateModelTabBase, MainWindowBase,
     )
+    from thermal_results import build_thermal_summary, format_source_table, find_thermal_vtu
 else:
     from .setup_common import (
         EDIT_STYLE_OPTIONAL, EDIT_STYLE_REQUIRED, COMBO_STYLE_REQUIRED, COMBO_STYLE_OPTIONAL,
         FileDropLineEdit, FileInputTab, PythonHighlighter, CodeEditor,
         VectorWidget, PopUpWindow, CreateModelTabBase, MainWindowBase,
     )
+    from .thermal_results import build_thermal_summary, format_source_table, find_thermal_vtu
 
 
 '''
@@ -486,7 +488,7 @@ class MeshTab(QWidget):
         self.label6 = QLabel("Mesh cell maximum size")
         self.label6.setFixedWidth(label_width)
         self.cells_maxsize_layout.addWidget(self.label6)
-        self.cells_maxsize_edit = QLineEdit("10")
+        self.cells_maxsize_edit = QLineEdit("100")
         self.cells_maxsize_edit.setFixedWidth(edit_width)
         self.cells_maxsize_edit.setStyleSheet(EDIT_STYLE_OPTIONAL)
         self.cells_maxsize_layout.addWidget(self.cells_maxsize_edit)
@@ -507,7 +509,7 @@ class MeshTab(QWidget):
         self.label7 = QLabel("Dielectric stackup: oversize by")
         self.label7.setFixedWidth(label_width)
         self.margins_layout.addWidget(self.label7)
-        self.margins_edit = QLineEdit("200")
+        self.margins_edit = QLineEdit("100")
         self.margins_edit.setFixedWidth(edit_width)
         self.margins_edit.setStyleSheet(EDIT_STYLE_REQUIRED)
         self.margins_layout.addWidget(self.margins_edit)
@@ -545,7 +547,7 @@ class MeshTab(QWidget):
             value = float(self.margins_edit.text())
         except Exception:
             QMessageBox.warning(self, "Error", "Not a valid value for dielectric oversize margin")
-            self.margins_edit.setText("200")
+            self.margins_edit.setText("100")
             return False
         saved_values ["margin"] = float(value)
 
@@ -569,6 +571,56 @@ 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
+
+        # "View in ParaView" is thermal-only (Palace/EM results are S-parameters, not a 3D
+        # field to open directly), added as its own row of the base class's buttons_grid so
+        # it lines up with Preview/Create Mesh/Start Simulation above, in the same Actions group.
+        row = self.buttons_grid.rowCount()
+        self.paraview_btn = QPushButton("🖼️ View in ParaView")
+        self.paraview_btn.clicked.connect(self.launch_paraview)
+        self.buttons_grid.addWidget(self.paraview_btn, row, 0)
+
+    def _append_thermal_results_summary(self):
+        # Parse thermal_results.dat / thermal_results.vtu and append a results summary
+        # to the log. Called from on_finished() after a real simulation run.
+        run_path = saved_values['sim_path'] + "/elmer_model/" + saved_values['model_basename'] + "_data"
+
+        # Heat sources first, then constant-temperature boundaries, regardless of the
+        # order they were added in the GUI.
+        rows = []
+        for thermal_object in thermal_objects.objects:
+            if isinstance(thermal_object, simulation_setup.heatsource):
+                rows.append(["Heat source", str(thermal_object.source_layernum),
+                             str(thermal_object.target_layername), f"{thermal_object.power} W"])
+        for thermal_object in thermal_objects.objects:
+            if isinstance(thermal_object, simulation_setup.constanttemp):
+                rows.append(["Const. temp", str(thermal_object.source_layernum),
+                             str(thermal_object.target_layername), f"{thermal_object.temp} K"])
+        source_lines = format_source_table(rows) if rows else None
+
+        summary = build_thermal_summary(run_path, source_lines=source_lines)
+        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":
+            self._append_thermal_results_summary()
+
+    def launch_paraview(self):
+        run_path = saved_values['sim_path'] + "/elmer_model/" + saved_values['model_basename'] + "_data"
+        vtu_path = find_thermal_vtu(run_path)
+        self._open_in_paraview(
+            [vtu_path] if vtu_path else [],
+            f"⚠️ No thermal results .vtu found yet under {run_path}\n"
+        )
+
     def create_model(self):
         # Request all tabs to save values again,
         # which can do some update to saved_values
@@ -606,6 +658,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])
 
 
@@ -622,6 +675,7 @@ class CreateModelTab(CreateModelTabBase):
 
         # clear log
         self.log_area.clear()
+        self._process_purpose = "run_simulation"
 
         # try to start from output directory
         run_path = saved_values['sim_path'] + "/elmer_model/" + saved_values['model_basename'] + "_data"
@@ -737,7 +791,7 @@ class ModelEditorTab(QWidget):
 
         if forExport:
             # these commands are only used within this GUI application to control gmsh
-            ignore_list.append(['preview_only','no_preview'])
+            ignore_list.extend(['preview_only','no_preview'])
 
         for key in saved_values.keys():
             if not key in special_keylist:

{setupem-0.5.1 → setupem-0.6.1}/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, io, contextlib
+import sys, os, json, pathlib, ast, webbrowser, io, contextlib, subprocess, shutil, glob
 import xml.etree.ElementTree as ET
 import numpy as np
 import requests
@@ -324,7 +324,7 @@ class FileInputTab(QWidget):
         self.viamerge_layout = QHBoxLayout()
         self.viamerge_label1 = QLabel("Merge via arrays with spacing ")
         self.viamerge_label1.setFixedWidth(left_label_width)
-        self.viamerge_edit = QLineEdit("0")
+        self.viamerge_edit = QLineEdit("0.5")
         self.viamerge_edit.setStyleSheet(EDIT_STYLE_OPTIONAL)
         self.viamerge_edit.setFixedWidth(70)
         self.viamerge_label2 = QLabel(" micron or more, value 0 disables via array merging")
@@ -643,7 +643,7 @@ class FileInputTab(QWidget):
             merge_polygon_size = float(self.viamerge_edit.text())
         except Exception:
             QMessageBox.warning(self, "Error", f"Not a valid value for via array merging")
-            self.viamerge_edit.setText("0")
+            self.viamerge_edit.setText("0.5")
             return False
         saved_values["merge_polygon_size"] = float(merge_polygon_size)
 
@@ -1277,6 +1277,7 @@ class CreateModelTabBase(QWidget):
         self.process.readyReadStandardOutput.connect(self.on_stdout)
         self.process.readyReadStandardError.connect(self.on_stderr)
         self.process.finished.connect(self.on_finished)
+        self.process.errorOccurred.connect(self.on_process_error)
 
     def on_modelname_edit_done(self):
         # Model name edit field has changed
@@ -1298,6 +1299,64 @@ class CreateModelTabBase(QWidget):
         """Handle process completion."""
         self.log_area.appendPlainText(f"\n--- Process finished with exit code {exit_code} ---\n")
 
+    def on_process_error(self, error):
+        """Handle QProcess itself failing to launch or run - most importantly
+        FailedToStart (program not found, or not executable, e.g. a .bat with content
+        the current shell can't run). Without this, such failures were silent: none of
+        readyReadStandardOutput/readyReadStandardError/finished ever fire for a process
+        that never actually started, leaving the log blank with no indication anything
+        went wrong.
+        """
+        messages = {
+            QProcess.FailedToStart: "the program could not be started (not found, or not executable)",
+            QProcess.Crashed: "the process crashed",
+            QProcess.Timedout: "the process timed out",
+            QProcess.WriteError: "an error occurred while writing to the process",
+            QProcess.ReadError: "an error occurred while reading from the process",
+            QProcess.UnknownError: "an unknown error occurred",
+        }
+        detail = messages.get(error, f"error code {error}")
+        self.log_area.appendPlainText(f"\n⚠️ Process error: {detail}\n")
+
+    def _open_in_paraview(self, file_paths, not_found_message):
+        """Locate ParaView and open it on file_paths (a list of .pvd/.vtu paths), or
+        log not_found_message if file_paths is empty. Shared by setupEM.py (Palace
+        field dumps / Elmer EM fields) and setupThermal.py (thermal_results.vtu) -
+        each caller is responsible for finding its own result files and wording its
+        own "nothing found" message; this only handles locating/launching ParaView.
+        Detached, non-blocking launch (like klayout_setupEM.py's setupEM launch) -
+        this is a fire-and-forget external GUI viewer, unrelated to self.process's
+        solver-run lifecycle.
+        """
+        if not file_paths:
+            self.log_area.appendPlainText(not_found_message)
+            return
+
+        paraview_exe = shutil.which("paraview")
+        if paraview_exe is None and os.name == "nt":
+            # Not on PATH: fall back to searching the usual install locations, newest first.
+            candidates = (
+                glob.glob(r"C:\Program Files\ParaView*\bin\paraview.exe")
+                + glob.glob(r"C:\Program Files (x86)\ParaView*\bin\paraview.exe")
+            )
+            if candidates:
+                paraview_exe = max(candidates, key=os.path.getmtime)
+
+        if paraview_exe is None:
+            self.log_area.appendPlainText(
+                "⚠️ ParaView not found on PATH. Install it, or add it to PATH, "
+                "then open manually:\n" + "\n".join(file_paths) + "\n"
+            )
+            return
+
+        env = os.environ.copy()
+        env.pop("PYTHONHOME", None)
+        try:
+            subprocess.Popen([paraview_exe, *file_paths], env=env)
+            self.log_area.appendPlainText("Starting ParaView on:\n" + "\n".join(file_paths) + "\n")
+        except OSError as e:
+            self.log_area.appendPlainText(f"⚠️ Failed to launch ParaView: {e}\n")
+
     def browse_directory(self):
         directory = QFileDialog.getExistingDirectory(
             self,
@@ -1328,9 +1387,15 @@ class CreateModelTabBase(QWidget):
                 if "===" in model_basename:
                     model_basename = ""
 
-        # no simulator name prefix
-        model_basename = model_basename.replace('palace_', '')
-        model_basename = model_basename.replace('elmer_', '')
+        # Strip a stale simulator-name prefix left over from a different solver choice
+        # (e.g. "elmer_..." after switching to Palace mode) - but never strip a prefix
+        # that already matches the current choice, otherwise importing an existing
+        # model and reusing its filename would silently rename it to a different file
+        # (setupThermal has no PalaceMode attribute at all; it's always Elmer, so only
+        # a "palace_" prefix would ever be considered stale there).
+        palace_mode = getattr(self.MainWindow, 'PalaceMode', False)
+        mismatched_prefix = 'elmer_' if palace_mode else 'palace_'
+        model_basename = model_basename.replace(mismatched_prefix, '')
 
         self.modelname_edit.setText(model_basename)
 
@@ -1669,6 +1734,8 @@ class MainWindowBase(QMainWindow):
                     "XML_filename": "SubstrateFile",
                     "GdsFile": "GdsFile",
                     "purpose": "purpose",
+                    "cellname": "cellname",
+                    "variable_overrides": "variable_overrides",
                     "SubstrateFile": "SubstrateFile",
                     "merge_polygon_size": "merge_polygon_size",
                     "preprocess_gds": "preprocess_gds",
@@ -1681,12 +1748,12 @@ class MainWindowBase(QMainWindow):
                     "fpoint": "fpoint",
                     "fdump": "fdump",
                     "refined_cellsize": "refined_cellsize",
+                    "refined_cellsize_override": "refined_cellsize_override",
                     "cells_per_wavelength": "cells_per_wavelength",
                     "meshsize_max": "meshsize_max",
                     "adaptive_mesh_iterations": "adaptive_mesh_iterations",
                     "order": "order",
                     "iterative": "iterative",
-                    "elmer": "elmer",
                     "ELMER_MPI_THREADS": "ELMER_MPI_THREADS"
                 }
 
@@ -1706,7 +1773,11 @@ class MainWindowBase(QMainWindow):
                             if import_key not in import_value:  # skip the section where key might appear in different context
                                 # get the internal name for this variable
                                 varname = import_mapping.get(import_key, '')
-                                if varname == "fpoint" or varname == "fdump":
+                                if varname in ("fpoint", "fdump"):
+                                    # same Hz-in-code / GHz-in-GUI unit split as fstart/fstop/fstep below,
+                                    # just per-element since these are lists
+                                    saved_values[varname] = [f / 1e9 for f in ast.literal_eval(import_value)]
+                                elif varname in ("variable_overrides", "refined_cellsize_override"):
                                     saved_values[varname] = ast.literal_eval(import_value)
                                 elif varname in ["gds_filename", "XML_filename", "GdsFile", "SubstrateFile"]:
                                     # check if we have full path for files in imported Python script,
@@ -1727,6 +1798,19 @@ class MainWindowBase(QMainWindow):
                                     else:
                                         saved_values[varname] = raw
 
+                # ask whether future "Create Model" output should overwrite this same
+                # file, or start a fresh model (today's GDS-derived default)
+                reuse = QMessageBox.question(
+                    self, "Import Model",
+                    f"Use '{os.path.basename(file_path)}' as the output file for this model too?\n\n"
+                    "Yes: Create Model / Start Simulation will overwrite this file.\n"
+                    "No: pick a model name and target directory on the Create Model(s) tab.",
+                    QMessageBox.Yes | QMessageBox.No, QMessageBox.No
+                ) == QMessageBox.Yes
+                if reuse:
+                    saved_values['sim_path'] = os.path.dirname(file_path).replace('\\', '/')
+                    saved_values['model_basename'] = pathlib.Path(file_path).stem
+
                 # read port/thermal assignments in workflow syntax for gds2palace Python code, and
                 # apply any app-specific post-import state (e.g. setupEM's simulator mode)
                 self.apply_python_import_data(file_path)

setupem-0.6.1/src/setupEM/thermal_results.py

@@ -0,0 +1,175 @@
+########################################################################
+#
+# Copyright 2025-2026 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 Elmer thermal solver output (thermal_results.dat / thermal_results.vtu)
+into a human-readable summary for the setupThermal "Create Model" log. No Qt
+dependency, so this can be exercised standalone against real Elmer output
+directories.
+"""
+
+import os
+import glob
+
+import meshio
+
+# Elmer's Post File in util_elmer.py is written with "Coordinate Scaling = Real 1e-6"
+# applied on read-in (mesh coordinates in um are scaled down to meters for the solve),
+# so node coordinates recovered from the .vtu are in meters and need to be scaled back
+# up to um to match the layout's native units.
+_METERS_TO_UM = 1e6
+
+
+def _candidate_dirs(run_path):
+    # util_elmer.py writes "Filename = ../thermal_results.dat" and
+    # "Post File = ../thermal_results.vtu", which reads as "one level above run_path"
+    # -- but Elmer actually resolves both relative to the Mesh DB directory ("mesh"
+    # under run_path, per "Mesh DB \"mesh\" \".\"" in the .sif), so "../" cancels back
+    # out to run_path itself (confirmed via thermal_results.dat.names: "Metadata for
+    # SaveScalars file: mesh/../thermal_results.dat"). run_path is therefore the real
+    # location; its parent is kept as a defensive fallback for other Elmer builds/versions.
+    run_path = os.path.normpath(run_path)
+    return [run_path, os.path.dirname(run_path)]
+
+
+def find_thermal_dat(run_path):
+    """Return the path to thermal_results.dat, or None if it doesn't exist yet."""
+    for d in _candidate_dirs(run_path):
+        path = os.path.join(d, "thermal_results.dat")
+        if os.path.isfile(path):
+            return path
+    return None
+
+
+def find_thermal_vtu(run_path):
+    """Return the path to the thermal results .vtu file, or None if it doesn't exist yet.
+
+    Elmer's Post File writer appends a timestep suffix (e.g. thermal_results_t0001.vtu)
+    even for a single steady-state solve, so this globs rather than matching a fixed name;
+    if more than one is found (re-run, or a multi-iteration solve), the most recently
+    written one wins.
+    """
+    matches = []
+    for d in _candidate_dirs(run_path):
+        matches += glob.glob(os.path.join(d, "thermal_results*.vtu"))
+    if not matches:
+        return None
+    return max(matches, key=os.path.getmtime)
+
+
+def read_minmax_temperature(run_path):
+    """Return (t_min, t_max) from thermal_results.dat, or None if missing/unparsable."""
+    path = find_thermal_dat(run_path)
+    if path is None:
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            lines = [line.strip() for line in f if line.strip()]
+        if not lines:
+            return None
+        # SaveScalars writes one row per solver call; steady-state thermal is a single
+        # solve, but take the last line defensively in case Elmer ever appends more.
+        values = [float(v) for v in lines[-1].split()]
+        if len(values) < 2:
+            return None
+        # Column order is fixed by our own .sif generation: Operator 1 = min, Operator 2 = max.
+        return values[0], values[1]
+    except (OSError, ValueError):
+        return None
+
+
+def find_max_temperature_location(run_path):
+    """Return (x, y, z) in um of the mesh node with the highest temperature, or None
+    if the thermal results .vtu doesn't exist yet or can't be read/parsed.
+    """
+    path = find_thermal_vtu(run_path)
+    if path is None:
+        return None
+    try:
+        mesh = meshio.read(path)
+        temp_key = next(
+            (key for key in mesh.point_data if "temp" in key.lower()),
+            None,
+        )
+        if temp_key is None:
+            return None
+        temperature = mesh.point_data[temp_key]
+        max_index = temperature.argmax()
+        x, y, z = mesh.points[max_index]
+        return x * _METERS_TO_UM, y * _METERS_TO_UM, z * _METERS_TO_UM
+    except Exception:
+        # Any read/parse failure (unsupported VTU variant, half-written file while a
+        # simulation is still running, etc.) should never block the min/max summary.
+        return None
+
+
+_SOURCE_TABLE_HEADERS = ["Type", "GDS Layer", "Target Layer", "Value"]
+
+
+def format_source_table(rows):
+    """Format (type, gds_layer, target_layer, value) string rows into an aligned table,
+    same layout style as palace_results.py's AMR results table. The caller decides row
+    order (heat sources first, then constant-temperature boundaries, per setupThermal.py).
+    """
+    headers = _SOURCE_TABLE_HEADERS
+    widths = [max(len(headers[i]), *(len(r[i]) for r in rows)) for i in range(len(headers))]
+
+    def fmt_row(cells):
+        return " | ".join(
+            cell.rjust(widths[i]) if i == len(cells) - 1 else cell.ljust(widths[i])
+            for i, cell in enumerate(cells)
+        )
+
+    lines = [fmt_row(headers), "-+-".join("-" * w for w in widths)]
+    lines += [fmt_row(row) for row in rows]
+    return lines
+
+
+def build_thermal_summary(run_path, source_lines=None):
+    """Return a formatted multi-line summary of Elmer thermal results found relative
+    to run_path (the case.sif working directory), or an explanatory message if
+    nothing is there yet.
+
+    source_lines, if given, is a list of pre-formatted strings describing the model's
+    heat sources / constant-temperature boundaries (e.g. str(heatsource_instance)) --
+    this module only knows about Elmer's output files, not the GUI's in-memory model,
+    so the caller supplies these rather than this module importing simulation_setup.
+    """
+    minmax = read_minmax_temperature(run_path)
+    if minmax is None:
+        return (f"No thermal results found yet (expected thermal_results.dat under {run_path}) "
+                 "-- has the simulation finished?")
+    t_min, t_max = minmax
+
+    location = find_max_temperature_location(run_path)
+    if location is not None:
+        x, y, z = location
+        location_line = f"Hotspot location  : x={x:.3f} um  y={y:.3f} um  z={z:.3f} um"
+    else:
+        location_line = "Hotspot location  : n/a (see thermal_results.vtu)"
+
+    lines = ["=== Thermal results ==="]
+    if source_lines:
+        lines.extend(source_lines)
+        lines.append("-" * 40)
+    lines += [
+        f"Min temperature   : {t_min:.2f} K",
+        f"Max temperature   : {t_max:.2f} K",
+        location_line,
+        "=" * 40,
+    ]
+    return "\n".join(lines)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.5.1
+Version: 0.6.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
@@ -15,6 +15,7 @@ Requires-Dist: scikit-rf
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: gdspy
+Requires-Dist: meshio
 Dynamic: license-file
 
 # Python GUI for gds2palace 

{setupem-0.5.1 → setupem-0.6.1}/src/setupEM.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/setupEM/setupThermal.py
 src/setupEM/setup_common.py
 src/setupEM/stackupEditor.py
 src/setupEM/stackup_writer.py
+src/setupEM/thermal_results.py
 src/setupEM.egg-info/PKG-INFO
 src/setupEM.egg-info/SOURCES.txt
 src/setupEM.egg-info/dependency_links.txt

{setupem-0.5.1 → setupem-0.6.1}/src/setupEM.egg-info/requires.txt

@@ -6,3 +6,4 @@ scikit-rf
 matplotlib
 numpy
 gdspy
+meshio