setupEM 0.14.2__tar.gz → 0.15.0__tar.gz

{setupem-0.14.2/src/setupEM.egg-info → setupem-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.14.2
+Version: 0.15.0
 Summary: Python tool for configuration of gds2palace workflow with GUI.
 Author-email: Volker Muehlhaus <volker@muehlhaus.com>
 License-Expression: GPL-3.0-or-later
@@ -23,6 +23,8 @@ Requires-Dist: gdspy
 Requires-Dist: meshio
 Requires-Dist: pyvista
 Requires-Dist: pyvistaqt
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
 Dynamic: license-file
 
 # Python GUI for gds2palace 
@@ -38,6 +40,16 @@ https://github.com/VolkerMuehlhaus/setupEM
 
 ## Recent changes
 
+# What's New - October 29, 2026
+
+**File > Edit \*.py model in place** (new, setupEM and setupThermal): edits a gds2palace model script directly, e.g. one from the gds2palace MCP server, an example or your own code. Create Model and **File > Save** write only the values you change; the script's loops, comments and custom code stay. Settings the script computes itself are greyed out. A script that builds several models (a parameter sweep) lists them on the Create Model tab, and Start Simulation runs the ticked ones. After importing a script that setupEM didn't write, a bar below the menu offers **Edit in place instead**.
+
+**File > Import from \*.py model** now runs a gds2palace script to read it, without reading the GDSII file and without meshing. The run stops where the script builds the model, so its solver start never runs. The import now gets exactly what gds2palace would get, also values and ports the script computes. Before, ports made in a loop (as in many gds2palace MCP scripts) were left out, and the imported model was missing them. The script's own code before building the model does run, e.g. a script that generates its GDSII file writes it. If the run fails, the import reads the script text as before, and the bar below the menu says why.
+
+**File menu:** the three Recent submenus are now one **Open Recent** submenu, with sections for configs, imported \*.py models and \*.py models edited in place. A file reopens the way it was opened. The menu is grouped as open, recent, save, preferences. **Load Default Config** and **Save as Default Config** are removed: defaults for new models are set in **File > Preferences**. An existing `default.simcfg` / `default.tsimcfg` in your home directory still opens with **Load Config**, and **Save Config** can write it.
+
+Import and edit in place now read a stackup given as `utilities.get_stackup_path("SG13G2_FEM_200um.xml")`, the way the gds2palace MCP server writes it (needs gds2palace 0.9.1 or later). Before, an imported model using that syntax had no stackup file.
+
 # What's New - October 21, 2026
 
 **Tools > Simplify GDS:** the simplification code moved to gds_prepare_for_EM (module `gds_simplify_for_em`), where the gds2palace MCP server uses it too. setupEM now requires gds_prepare_for_EM 1.6.0 or later; `pip install --upgrade setupEM` updates it.
@@ -48,10 +60,6 @@ Fix: with **Merge via arrays** (and no fill removal or merging per layer), the s
 
 **Stackup Editor, ADS Momentum (*.ltd) import:** metals with an EXPAND thickness operation now make the dielectric next to them thicker, as in ADS, instead of reaching into the dielectric below. Before, a thick EXPAND DOWN metal (e.g. MET1/MET2 in a GaAs stackup) overlapped the layers underneath it, and a via could end up with zero height. Files where long lines are wrapped or END_... markers follow the last entry on the same line now import too; before, they failed with "No usable dielectric slabs".
 
-# What's New - October 18, 2026
-
-**Touchstone files with different port impedances:** the option line of the combined `.sNp` file now has one Z0 per port, in port order. Before, ports with the same Z0 as port 1 were left out.
-
 Full history: [CHANGES.md](https://github.com/VolkerMuehlhaus/setupEM/blob/main/doc/CHANGES.md)
 
 ---

{setupem-0.14.2 → setupem-0.15.0}/README.md

@@ -269,9 +269,11 @@ Behind the scenes, the setupEM user interface created Python model code for gds2
 <img src="./doc/png/code1.png" alt="code" width="700">
 
 ## File menu
-In the setupEM File menu, you can save and load simulation configurations, and you can also save and load a user defined "Default Config" configuration. This includes the choice of simulation target directory and all other settings. Configurations are stored in a JSON file with file extension ".simcfg". The "Default Config" will be stored to the user home diretory.
+In the setupEM File menu, you can save and load simulation configurations. This includes the choice of simulation target directory and all other settings. Configurations are stored in a JSON file with file extension ".simcfg". Default values for new models are set in File > Preferences.
 
-Using "File > Import from *.py model", you can load settings from existing simulation model code, e.g. the examples included in the gds2palace repository. This import is based on detecting known keywords, with or without the settings[] syntax, and also works for openEMS Python models. Note that openEMS substrates model the MIM differently, and parameter "refined_cellsize" will usually be smaller in openEMS simulation, so you need to adjust these settings.
+Using "File > Import from *.py model", you can load settings from existing simulation model code, e.g. the examples included in the gds2palace repository. A gds2palace script is run to read it, without reading the GDSII file and without meshing, so also values and ports the script computes are imported. If that fails, and for openEMS Python models, the import detects known keywords in the script text, with or without the settings[] syntax. Note that openEMS substrates model the MIM differently, and parameter "refined_cellsize" will usually be smaller in openEMS simulation, so you need to adjust these settings.
+
+Using "File > Edit *.py model in place", setupEM edits a gds2palace model script directly, e.g. one created by the gds2palace MCP server or written by hand: it writes only the values you change back into the script, its loops, comments and custom code stay.
 
 If you are on the "Code" tab, you can also export the Python model code using "File > Export to *.py model". This option is only required if you want to save the model code **without** running it. Buttons "Create mesh and model file" and "Run Palace" on the "Create Model" tab will also save the model code to the target directory, and run it from there.
 

setupem-0.15.0/README_pypi.md

@@ -0,0 +1,54 @@
+# Python GUI for gds2palace 
+
+![Intro](https://raw.githubusercontent.com/VolkerMuehlhaus/setupEM/main/doc/png/setupEM_banner.png)
+
+## Install
+
+    pip install setupEM
+
+**Full documentation, installation guide, and usage walkthrough:**
+https://github.com/VolkerMuehlhaus/setupEM
+
+## Recent changes
+
+# What's New - October 29, 2026
+
+**File > Edit \*.py model in place** (new, setupEM and setupThermal): edits a gds2palace model script directly, e.g. one from the gds2palace MCP server, an example or your own code. Create Model and **File > Save** write only the values you change; the script's loops, comments and custom code stay. Settings the script computes itself are greyed out. A script that builds several models (a parameter sweep) lists them on the Create Model tab, and Start Simulation runs the ticked ones. After importing a script that setupEM didn't write, a bar below the menu offers **Edit in place instead**.
+
+**File > Import from \*.py model** now runs a gds2palace script to read it, without reading the GDSII file and without meshing. The run stops where the script builds the model, so its solver start never runs. The import now gets exactly what gds2palace would get, also values and ports the script computes. Before, ports made in a loop (as in many gds2palace MCP scripts) were left out, and the imported model was missing them. The script's own code before building the model does run, e.g. a script that generates its GDSII file writes it. If the run fails, the import reads the script text as before, and the bar below the menu says why.
+
+**File menu:** the three Recent submenus are now one **Open Recent** submenu, with sections for configs, imported \*.py models and \*.py models edited in place. A file reopens the way it was opened. The menu is grouped as open, recent, save, preferences. **Load Default Config** and **Save as Default Config** are removed: defaults for new models are set in **File > Preferences**. An existing `default.simcfg` / `default.tsimcfg` in your home directory still opens with **Load Config**, and **Save Config** can write it.
+
+Import and edit in place now read a stackup given as `utilities.get_stackup_path("SG13G2_FEM_200um.xml")`, the way the gds2palace MCP server writes it (needs gds2palace 0.9.1 or later). Before, an imported model using that syntax had no stackup file.
+
+# What's New - October 21, 2026
+
+**Tools > Simplify GDS:** the simplification code moved to gds_prepare_for_EM (module `gds_simplify_for_em`), where the gds2palace MCP server uses it too. setupEM now requires gds_prepare_for_EM 1.6.0 or later; `pip install --upgrade setupEM` updates it.
+
+Fix: with **Merge via arrays** (and no fill removal or merging per layer), the simplified file still contained the original subcells as extra top-level cells. Without a cell name, gds2palace reads the first top-level cell, which could be one of them, e.g. a pad cell instead of the design. These left-over cells are now removed.
+
+# What's New - October 19, 2026
+
+**Stackup Editor, ADS Momentum (*.ltd) import:** metals with an EXPAND thickness operation now make the dielectric next to them thicker, as in ADS, instead of reaching into the dielectric below. Before, a thick EXPAND DOWN metal (e.g. MET1/MET2 in a GaAs stackup) overlapped the layers underneath it, and a via could end up with zero height. Files where long lines are wrapped or END_... markers follow the last entry on the same line now import too; before, they failed with "No usable dielectric slabs".
+
+Full history: [CHANGES.md](https://github.com/VolkerMuehlhaus/setupEM/blob/main/doc/CHANGES.md)
+
+---
+
+**Note:** the `setupEM` PyPI package itself requires:
+
+- gds2palace>=0.9.0
+- gds_prepare_for_EM>=1.6.0
+- PySide6
+- shiboken6
+- scipy
+- requests
+- scikit-rf
+- matplotlib
+- numpy
+- gdspy
+- meshio
+- pyvista
+- pyvistaqt
+
+(Other Python modules mentioned above are only needed to run standalone helper scripts in this repository, not to use the installed package.)

{setupem-0.14.2 → setupem-0.15.0}/pyproject.toml

@@ -28,6 +28,9 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 
+[project.optional-dependencies]
+test = ["pytest"]
+
 [project.urls]
 Homepage = "https://github.com/VolkerMuehlhaus/setupEM"
 Repository = "https://github.com/VolkerMuehlhaus/setupEM"

{setupem-0.14.2 → setupem-0.15.0}/src/setupEM/__init__.py

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

{setupem-0.14.2 → setupem-0.15.0}/src/setupEM/result_viewer.py

@@ -636,7 +636,12 @@ class ResultViewerWindow(QDialog):
         # regardless of which solver produced it.
         saved_values = self.MainWindow.saved_values
         model_basename = saved_values.get('model_basename', '') if isinstance(saved_values, dict) else ''
-        current_model_dir = f"{model_basename}_data" if model_basename else None
+        current_model_dirs = {f"{model_basename}_data"} if model_basename else set()
+        # a script edited in place may create several models (e.g. a parameter
+        # sweep), each with its own run folder name: all of them are "this model"
+        script_runs = getattr(self.MainWindow, "script_runs", None) or []
+        if getattr(self.MainWindow, "script_model", None) is not None and script_runs:
+            current_model_dirs = {os.path.basename(os.path.normpath(run["sim_path"])) for run in script_runs}
 
         result = []
         for path in files:
@@ -645,8 +650,8 @@ class ResultViewerWindow(QDialog):
                 continue
             if not include_deembedded and '_deembedded' in name:
                 continue
-            if not include_all_models and current_model_dir:
-                if current_model_dir not in os.path.normpath(path).split(os.sep):
+            if not include_all_models and current_model_dirs:
+                if not current_model_dirs & set(os.path.normpath(path).split(os.sep)):
                     continue
             result.append(path)
         return result

setupem-0.15.0/src/setupEM/run_with_overrides.py

@@ -0,0 +1,287 @@
+########################################################################
+#
+# 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.
+#
+########################################################################
+
+"""Run a gds2palace model script with some settings[] values overridden.
+
+    python run_with_overrides.py model.py --set preview_only=True --set no_preview=False
+    python run_with_overrides.py model.py --source unsaved.py --set preview_only=True
+    python run_with_overrides.py model.py --record models.json --set no_preview=True
+
+Used by setupEM's edit-in-place mode, so Preview / Create Mesh don't have to
+write their control flags into the user's script. The script runs unchanged,
+as __main__ with its own __file__ and its own folder first on sys.path,
+exactly like "python model.py". The overrides are applied to the settings dict
+when the script calls the workflow's create_model() (also through
+create_palace(), create_elmer() or create_elmer_thermal()). That function is
+patched when the workflow module is imported, from wherever the script
+imports it (installed package or a local copy put on sys.path by the script).
+
+A script may build several models, e.g. a parameter sweep calling
+create_palace() in a loop. --record writes every model it creates (run folder,
+name, solver, stackup variable overrides, plain settings values) to a JSON
+file, so setupEM knows which models to run. --first-only stops the script
+right after its first model is built (a preview only needs one). --no-solver
+keeps a script with start_simulation = True from starting the solver itself
+(setupEM's Start Simulation does that).
+"""
+
+import argparse
+import ast
+import importlib.abc
+import importlib.machinery
+import json
+import os
+import runpy
+import sys
+
+WORKFLOW_MODULE_SUFFIX = "util_simulation_setup"
+STACKUP_MODULE_SUFFIX = "util_stackup_reader"
+
+# settings values that are workflow objects or setupEM's own run control, not
+# parameters of a model
+_NOT_PARAMETERS = {"sim_path", "model_basename", "preview_only", "no_preview", "no_gui"}
+
+
+class _Run:
+    """What this run of the script does and records."""
+
+    def __init__(self, overrides, record=None, first_only=False, gui_first_only=False):
+        self.overrides = overrides
+        self.record = record
+        self.first_only = first_only
+        self.gui_first_only = gui_first_only
+        self.models = []
+        self.models_started = 0
+        self.variable_overrides = None
+
+
+# programs that start the solver; a script with start_simulation = True runs
+# one of these (e.g. run_command = ['./run_sim']) after building each model
+_SOLVER_PROGRAMS = ("run_sim", "run_elmer", "run_palace", "elmersolver", "palace")
+
+
+def _starts_solver(command):
+    if isinstance(command, (list, tuple)):
+        words = [str(w) for w in command]
+    else:
+        words = str(command).replace("&&", " ").replace(";", " ").split()
+    for word in words:
+        name = os.path.basename(word.strip("'\"")).lower()
+        if name.endswith((".bat", ".sh", ".exe")):
+            name = name.rsplit(".", 1)[0]
+        if name.startswith(_SOLVER_PROGRAMS[:4]) or name == "palace":
+            return True
+    return False
+
+
+def _skip_solver_starts():
+    """setupEM starts the solver itself (Start Simulation, one model after the
+    other): while it runs a script, the script's own solver start is skipped
+    instead of running every simulation inside Create Mesh."""
+    import subprocess
+
+    def wrap(original, result):
+        def call(*args, **kwargs):
+            command = args[0] if args else kwargs.get("args", kwargs.get("command", ""))
+            if _starts_solver(command):
+                print(f"setupEM: not starting {command!r} from the script, Start Simulation runs the solver.")
+                return result(command)
+            return original(*args, **kwargs)
+        return call
+
+    subprocess.run = wrap(subprocess.run, lambda c: subprocess.CompletedProcess(c, 0, "", ""))
+    subprocess.call = wrap(subprocess.call, lambda c: 0)
+    subprocess.check_call = wrap(subprocess.check_call, lambda c: 0)
+    os.system = wrap(os.system, lambda c: 0)
+
+
+def _parse_value(text):
+    try:
+        return ast.literal_eval(text)
+    except (ValueError, SyntaxError):
+        return text
+
+
+def _plain(value):
+    # JSON-able numbers / strings / bools, and lists or dicts of those
+    if isinstance(value, (bool, int, float, str)) or value is None:
+        return True
+    if isinstance(value, (list, tuple)):
+        return all(_plain(v) for v in value)
+    if isinstance(value, dict):
+        return all(isinstance(k, str) and _plain(v) for k, v in value.items())
+    return False
+
+
+def _record_model(run, settings, result):
+    if run.record is None:
+        return
+    if settings.get("elmer_thermal"):
+        solver = "elmer_thermal"
+    elif settings.get("elmer"):
+        solver = "elmer"
+    else:
+        solver = "palace"
+    config_name = result[0] if isinstance(result, tuple) and result and isinstance(result[0], str) else None
+    sim_path = settings.get("sim_path")
+    run.models.append({
+        "sim_path": os.path.abspath(sim_path).replace("\\", "/") if isinstance(sim_path, str) else None,
+        "model_basename": settings.get("model_basename"),
+        "solver": solver,
+        "config": config_name,
+        "variable_overrides": run.variable_overrides if _plain(run.variable_overrides) else None,
+        "settings": {k: v for k, v in settings.items() if k not in _NOT_PARAMETERS and _plain(v)},
+    })
+    # written after every model, so a run that stops halfway still lists what it built
+    os.makedirs(os.path.dirname(os.path.abspath(run.record)), exist_ok=True)
+    with open(run.record, "w", encoding="utf-8") as f:
+        json.dump(run.models, f, indent=1)
+
+
+def _patch(module, run):
+    name = getattr(module, "__name__", "").split(".")[-1]
+    if name == STACKUP_MODULE_SUFFIX:
+        original_read = getattr(module, "read_substrate", None)
+        if original_read is None or getattr(original_read, "_setupEM_run", False):
+            return
+
+        def read_substrate(*args, **kwargs):
+            # remember the stackup variables of the model being set up (a sweep
+            # parameter like Temp_Celsius often lives here)
+            run.variable_overrides = kwargs.get("variable_overrides", args[1] if len(args) > 1 else None)
+            return original_read(*args, **kwargs)
+
+        read_substrate._setupEM_run = True
+        module.read_substrate = read_substrate
+        return
+
+    original = getattr(module, "create_model", None)
+    if original is None or getattr(original, "_setupEM_run", False):
+        return
+
+    def create_model(*args, **kwargs):
+        run.models_started += 1
+        settings = kwargs.get("settings")
+        if settings is None:
+            settings = next((a for a in reversed(args) if isinstance(a, dict)), None)
+        if settings is not None:
+            settings.update(run.overrides)
+            if run.gui_first_only and run.models_started > 1:
+                # a sweep: the gmsh window only for the first model, the others
+                # are built without one (no_gui only controls the windows)
+                settings["no_gui"] = True
+                print(f"setupEM: model {run.models_started} is built without a gmsh window.")
+        result = original(*args, **kwargs)
+        if settings is not None:
+            _record_model(run, settings, result)
+        if run.first_only:
+            # a preview is done once the first model is built: the rest of the
+            # script would only set up further models (a sweep) or start the
+            # solver (start_simulation = True)
+            print("\nsetupEM preview: done after the first model, the rest of the script is not run.")
+            sys.stdout.flush()
+            sys.stderr.flush()
+            # a plain exit could be caught by the script's own try/except
+            os._exit(0)
+        return result
+
+    create_model._setupEM_run = True
+    module.create_model = create_model
+
+
+class _PatchingLoader(importlib.abc.Loader):
+    def __init__(self, loader, run):
+        self.loader = loader
+        self.run = run
+
+    def create_module(self, spec):
+        return self.loader.create_module(spec)
+
+    def exec_module(self, module):
+        self.loader.exec_module(module)
+        _patch(module, self.run)
+
+
+class _PatchingFinder(importlib.abc.MetaPathFinder):
+    def __init__(self, run):
+        self.run = run
+
+    def find_spec(self, fullname, path, target=None):
+        if fullname.split(".")[-1] not in (WORKFLOW_MODULE_SUFFIX, STACKUP_MODULE_SUFFIX):
+            return None
+        for finder in sys.meta_path:
+            if finder is self or not hasattr(finder, "find_spec"):
+                continue
+            spec = finder.find_spec(fullname, path, target)
+            if spec is not None:
+                if spec.loader is not None and hasattr(spec.loader, "exec_module"):
+                    spec.loader = _PatchingLoader(spec.loader, self.run)
+                return spec
+        return None
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("script", help="model script to run")
+    parser.add_argument("--set", action="append", default=[], metavar="KEY=VALUE",
+                        help="settings[KEY] = VALUE (a Python literal) when the model is created")
+    parser.add_argument("--source", metavar="FILE",
+                        help="run the code in FILE as if it were the script (same __file__, folder and "
+                             "output paths), e.g. unsaved changes for a preview")
+    parser.add_argument("--record", metavar="JSON",
+                        help="write the models the script creates (run folders, parameters) to this file")
+    parser.add_argument("--first-only", action="store_true",
+                        help="stop right after the script has built its first model")
+    parser.add_argument("--no-solver", action="store_true",
+                        help="don't let the script start the solver itself (start_simulation = True)")
+    parser.add_argument("--gui-first-only", action="store_true",
+                        help="show gmsh windows only for the first model the script builds")
+    args = parser.parse_args(argv)
+
+    overrides = {}
+    for item in args.set:
+        key, sep, value = item.partition("=")
+        if not sep or not key:
+            parser.error(f"--set expects KEY=VALUE, got {item!r}")
+        overrides[key.strip()] = _parse_value(value.strip())
+    run = _Run(overrides, record=args.record, first_only=args.first_only, gui_first_only=args.gui_first_only)
+
+    script = os.path.abspath(args.script)
+    for module in list(sys.modules.values()):
+        if getattr(module, "__name__", "").split(".")[-1] in (WORKFLOW_MODULE_SUFFIX, STACKUP_MODULE_SUFFIX):
+            _patch(module, run)
+    sys.meta_path.insert(0, _PatchingFinder(run))
+    if args.no_solver:
+        _skip_solver_starts()
+
+    # same environment as "python model.py"
+    sys.argv = [script]
+    sys.path[0] = os.path.dirname(script)
+    if args.source:
+        # other code, but run as the script itself: __file__ decides the output
+        # folder names (utilities.get_basename(__file__)) and relative paths
+        with open(args.source, encoding="utf-8") as f:
+            code = compile(f.read(), script, "exec")
+        exec(code, {"__name__": "__main__", "__file__": script, "__builtins__": __builtins__,
+                    "__package__": None, "__spec__": None, "__doc__": None})
+    else:
+        runpy.run_path(script, run_name="__main__")
+
+
+if __name__ == "__main__":
+    main()