optmapper 0.1.0__tar.gz → 0.2.0__tar.gz

{optmapper-0.1.0/src/optmapper.egg-info → optmapper-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optmapper
-Version: 0.1.0
+Version: 0.2.0
 Summary: Production of LEGEND optical maps on batch systems
 Author-email: Luigi Pertoldi <gipert@pm.me>
 Maintainer: The LEGEND Collaboration

{optmapper-0.1.0 → optmapper-0.2.0}/src/optmapper/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
 
-__commit_id__ = commit_id = 'g44eb9ebce'
+__commit_id__ = commit_id = 'g4dbc0aba8'

{optmapper-0.1.0 → optmapper-0.2.0}/src/optmapper/cli.py

@@ -9,6 +9,7 @@ import shutil
 import sys
 from pathlib import Path
 
+from . import _version
 from .config import Config, ConfigError
 from .log_utils import setup_log
 from .schedulers import Job, LocalScheduler, get_scheduler
@@ -79,6 +80,12 @@ def optmapper_cli(argv: list[str] | None = None) -> None:
         description="%(prog)s: produce LEGEND optical maps. Prepares the geometry, "
         "submits the production jobs according to the configuration and exits.",
     )
+    parser.add_argument(
+        "--version",
+        action="version",
+        help="""Print %(prog)s version and exit""",
+        version=_version.__version__,
+    )
     parser.add_argument("config", help="production configuration file (YAML or JSON)")
     parser.add_argument("--verbose", "-v", action="count", default=0, help="increase verbosity")
     parser.add_argument(

{optmapper-0.1.0 → optmapper-0.2.0}/src/optmapper/config.py

@@ -10,7 +10,7 @@ from collections.abc import Mapping
 from dataclasses import dataclass, field
 from importlib import resources
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 import dbetto
 
@@ -100,22 +100,28 @@ class GeometryConfig:
 class EmissionConfig:
     """Energy spectrum of the generated optical photons.
 
-    Either `spectrum`, the dotted path of a function with signature
+    One of `spectrum`, the dotted path of a function with signature
     ``f(filename: str, output_macro: bool)`` like
-    :func:`pygeomoptics.lar.g4gps_lar_emissions_spectrum`, or a `gaussian` with a
-    `mean` (energy or wavelength) and a `sigma` (energy).
+    :func:`pygeomoptics.lar.g4gps_lar_emissions_spectrum`, `g4gps_spectrum_macro`, a
+    macro file written by such a function with ``output_macro=True``, or a `gaussian`
+    with a `mean` (energy or wavelength) and a `sigma` (energy).
     """
 
     spectrum: str | None = None
+    g4gps_spectrum_macro: str | None = None
     gaussian: dict | None = None
 
     @classmethod
-    def from_dict(cls, d: Mapping) -> EmissionConfig:
-        _check_keys(d, {"spectrum", "gaussian"}, "emission")
+    def from_dict(cls, d: Mapping, base: Path) -> EmissionConfig:
+        _check_keys(d, {f.name for f in dataclasses.fields(cls)}, "emission")
         e = cls(**d)
-        if (e.spectrum is None) == (e.gaussian is None):
-            msg = "emission: specify exactly one of 'spectrum' or 'gaussian'"
+        n_given = sum(v is not None for v in (e.spectrum, e.g4gps_spectrum_macro, e.gaussian))
+        if n_given != 1:
+            msg = (
+                "emission: specify exactly one of 'spectrum', 'g4gps_spectrum_macro' or 'gaussian'"
+            )
             raise ConfigError(msg)
+        e.g4gps_spectrum_macro = _resolve_path(e.g4gps_spectrum_macro, base)
         if e.gaussian is not None:
             e.gaussian = dict(e.gaussian)
             _check_keys(e.gaussian, {"mean", "sigma"}, "emission.gaussian")
@@ -195,17 +201,24 @@ class OptmapConfig:
 
 @dataclass
 class ProcessingConfig:
-    stp_files_per_map: int = 32
     parallel_maps: int = 8
     procs_per_map: int = 16
     merge_procs: int = 8
     bufsize: int = 50_000
-    keep_stp: bool = False
+    keep_stp: Literal["output", "scratch"] | None = None
 
     @classmethod
     def from_dict(cls, d: Mapping) -> ProcessingConfig:
         _check_keys(d, {f.name for f in dataclasses.fields(cls)}, "processing")
-        return cls(**d)
+        p = cls(**d)
+        if p.keep_stp is True:
+            p.keep_stp = "output"
+        elif p.keep_stp is False:
+            p.keep_stp = None
+        if p.keep_stp not in (None, "output", "scratch"):
+            msg = f"processing.keep_stp must be false, true, output or scratch, got {p.keep_stp!r}"
+            raise ConfigError(msg)
+        return p
 
 
 @dataclass
@@ -243,17 +256,30 @@ class ExecutionConfig:
     def from_dict(cls, d: Mapping) -> ExecutionConfig:
         d = dict(d)
         site = load_site(d.pop("site", "local"))
-        merged = deep_merge(site, d)
+        # expand slurm.all separately, so that any user option overrides the site preset
+        merged = deep_merge(_expand_slurm_all(site), _expand_slurm_all(d))
         _check_keys(merged, {f.name for f in dataclasses.fields(cls)}, "execution")
         e = cls(**merged)
         if e.scheduler not in ("slurm", "local"):
             msg = f"execution.scheduler must be slurm or local, got {e.scheduler!r}"
             raise ConfigError(msg)
-        _check_keys(e.slurm, {"node", "merge"}, "execution.slurm")
         e.env = {k: str(v) for k, v in e.env.items()}
         return e
 
 
+def _expand_slurm_all(d: Mapping) -> dict:
+    """Move the ``slurm.all`` options of an execution config to ``slurm.node`` and ``slurm.merge``.
+
+    Job type specific options take precedence over the ones in ``slurm.all``.
+    """
+    d = dict(d)
+    slurm = d.get("slurm", {})
+    _check_keys(slurm, {"all", "node", "merge"}, "execution.slurm")
+    if "all" in slurm:
+        d["slurm"] = {k: {**slurm["all"], **slurm.get(k, {})} for k in ("node", "merge")}
+    return d
+
+
 @dataclass
 class Config:
     name: str
@@ -288,7 +314,7 @@ class Config:
                 name=str(d["name"]),
                 output_dir=str(_resolve_path(d["output_dir"], base)),
                 geometry=GeometryConfig.from_dict(d["geometry"], base),
-                emission=EmissionConfig.from_dict(d["emission"]),
+                emission=EmissionConfig.from_dict(d["emission"], base),
                 optmap=OptmapConfig.from_dict(d["optmap"]),
                 statistics=StatisticsConfig.from_dict(d.get("statistics", {})),
                 processing=ProcessingConfig.from_dict(d.get("processing", {})),
@@ -335,6 +361,20 @@ class Config:
     def final_map(self) -> Path:
         return Path(self.output_dir) / f"{self.name}.lh5"
 
+    @property
+    def scratch_dir(self) -> Path:
+        """Scratch area of this production, expands environment variables of the caller."""
+        base = self.execution.scratch_dir or str(Path(self.output_dir) / "scratch")
+        return Path(os.path.expandvars(base)) / self.name
+
+    def stp_dir(self, index: int) -> Path | None:
+        """Where the remage output files of a node are kept, ``None`` if they are deleted."""
+        if self.processing.keep_stp == "output":
+            return Path(self.output_dir) / "stp" / f"node{index:04d}"
+        if self.processing.keep_stp == "scratch":
+            return self.scratch_dir / "stp" / f"node{index:04d}"
+        return None
+
     def node_map(self, index: int) -> Path:
         """Output map of a single node, the final map if there is only one node."""
         if self.statistics.nodes == 1:

{optmapper-0.1.0 → optmapper-0.2.0}/src/optmapper/macro.py

@@ -72,6 +72,23 @@ def load_spectrum_function(spec: str) -> Callable[[str, bool], None]:
     return func
 
 
+def read_spectrum_macro(path: str) -> list[str]:
+    """Read a spectrum macro written by a pygeom-optics ``g4gps_*`` function."""
+    try:
+        lines = Path(path).read_text().strip().splitlines()
+    except OSError as e:
+        msg = f"cannot read emission spectrum macro: {e}"
+        raise ConfigError(msg) from e
+    cmds = [ln.strip() for ln in lines if ln.strip() and not ln.lstrip().startswith("#")]
+    if not cmds or not all(c.startswith("/gps/") for c in cmds):
+        msg = (
+            f"emission spectrum macro '{path}' must only contain /gps/ commands, "
+            "was it written with output_macro=True?"
+        )
+        raise ConfigError(msg)
+    return lines
+
+
 @contextmanager
 def _optics_plugin(plugin: str | None) -> Iterator[None]:
     """Apply a pygeom-optics plugin, restoring the original material properties afterwards."""
@@ -107,6 +124,9 @@ def energy_commands(emission: EmissionConfig, optics_plugin: str | None = None)
             f"/gps/ene/sigma    {sigma.m:.6g} eV",
         ]
 
+    if emission.g4gps_spectrum_macro is not None:
+        return read_spectrum_macro(emission.g4gps_spectrum_macro)
+
     assert emission.spectrum is not None
     func = load_spectrum_function(emission.spectrum)
     with _optics_plugin(optics_plugin), tempfile.TemporaryDirectory() as tmpdir:

{optmapper-0.1.0 → optmapper-0.2.0}/src/optmapper/work.py

@@ -9,6 +9,7 @@ import re
 import resource
 import shlex
 import shutil
+import signal
 import subprocess
 import time
 from concurrent.futures import ThreadPoolExecutor
@@ -43,8 +44,13 @@ def _available_cpus() -> int:
 
 def merge_maps(cfg: Config, inputs: list[Path], output: Path, workdir: Path) -> None:
     """Merge optical maps into `output`, temporary files are written to `workdir`."""
+    from reboost.log_utils import setup_log as reboost_setup_log  # noqa: PLC0415
     from reboost.optmap.create import merge_optical_maps  # noqa: PLC0415
 
+    # the merge runs in this process, so log like ``reboost-optmap --verbose`` would
+    if not logging.getLogger("reboost").handlers:
+        reboost_setup_log(logging.INFO)
+
     output.parent.mkdir(parents=True, exist_ok=True)
     tmp = workdir / f".{output.name}.part"
     tmp.unlink(missing_ok=True)
@@ -65,7 +71,8 @@ def _reboost_create_args(cfg: Config, workdir: Path) -> list[str]:
     settings = workdir / "optmap-settings.json"
     dbetto.utils.write_dict(cfg.optmap.reboost_settings(), str(settings))
     args = [
-        *("--bufsize", str(cfg.processing.bufsize), "create"),
+        # log the progress, to see how far it got if it is killed
+        *("--verbose", "--bufsize", str(cfg.processing.bufsize), "create"),
         *("--settings", str(settings), "--geom", str(cfg.gdml_file)),
         *("--n-procs", str(cfg.processing.procs_per_map)),
     ]
@@ -76,12 +83,39 @@ def _reboost_create_args(cfg: Config, workdir: Path) -> list[str]:
     return args
 
 
+def _exit_status(returncode: int) -> str:
+    """Describe the exit code of a `subprocess`, which is negative if killed by a signal."""
+    if returncode >= 0:
+        return f"exit code {returncode}"
+    try:
+        name = signal.Signals(-returncode).name
+    except ValueError:
+        name = f"signal {-returncode}"
+    msg = f"killed by {name}"
+    if -returncode == signal.SIGKILL:
+        msg += " (out of memory?)"
+    return msg
+
+
 def _create_map(create_args: list[str], inputs: list[Path], output: Path) -> None:
-    """Create a map with ``reboost-optmap``, in a separate process as it spawns its own pool."""
+    """Create a map with ``reboost-optmap``, in a separate process as it spawns its own pool.
+
+    The output is forwarded line by line to the log as it is written, so that it is not lost
+    if a process is killed (e.g. out of memory) before the map creation finishes.
+    """
     cmd = ["reboost-optmap", *create_args, "--", *map(str, inputs), str(output)]
-    res = subprocess.run(cmd, capture_output=True, text=True, check=False)
-    if res.returncode != 0:
-        msg = f"map creation failed for {output.name}:\n{res.stdout}{res.stderr}"
+    # by default, Python block-buffers output to a pipe, which would be lost on SIGKILL
+    env = {**os.environ, "PYTHONUNBUFFERED": "1"}
+    with subprocess.Popen(
+        cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, env=env
+    ) as proc:
+        for line in proc.stdout:  # type: ignore[union-attr]
+            log.info("%s: %s", output.stem, line.rstrip())
+    if proc.returncode != 0:
+        msg = (
+            f"map creation failed for {output.name}: {_exit_status(proc.returncode)}, "
+            "see its output above"
+        )
         raise RuntimeError(msg)
     log.info("created %s from %d stp files", output.name, len(inputs))
 
@@ -91,10 +125,7 @@ def run_node(cfg: Config, index: int) -> None:
     from .macro import render_macro  # noqa: PLC0415
 
     job_id = os.environ.get("SLURM_JOB_ID", str(os.getpid()))
-    scratch_base = os.path.expandvars(
-        cfg.execution.scratch_dir or str(Path(cfg.output_dir) / "scratch")
-    )
-    scratch = Path(scratch_base) / cfg.name / f"node{index:04d}-{job_id}"
+    scratch = cfg.scratch_dir / f"node{index:04d}-{job_id}"
     # a requeued Slurm job keeps its ID, do not pick up files from the previous attempt
     shutil.rmtree(scratch, ignore_errors=True)
     scratch.mkdir(parents=True)
@@ -122,10 +153,9 @@ def run_node(cfg: Config, index: int) -> None:
     map_dir.mkdir()
     create_args = _reboost_create_args(cfg, scratch)
 
+    stp_dir = scratch / "stp"
+    stp_dir.mkdir()
     for run in range(cfg.statistics.runs_per_node):
-        stp_dir = scratch / "stp" / f"run{run:03d}"
-        stp_dir.mkdir(parents=True)
-
         cmd = [
             "remage",
             *cfg.advanced.remage_args,
@@ -143,33 +173,35 @@ def run_node(cfg: Config, index: int) -> None:
             log.debug("running: %s", shlex.join(cmd))
             subprocess.run(cmd, check=True)
 
-        stp_files = sorted(stp_dir.glob("*.lh5"), key=_natural_key)
-        if not stp_files:
-            msg = f"remage did not produce any output file in {stp_dir}"
-            raise RuntimeError(msg)
+    stp_files = sorted(stp_dir.glob("*.lh5"), key=_natural_key)
+    if not stp_files:
+        msg = f"remage did not produce any output file in {stp_dir}"
+        raise RuntimeError(msg)
 
-        chunks = [
-            stp_files[i : i + proc.stp_files_per_map]
-            for i in range(0, len(stp_files), proc.stp_files_per_map)
+    # split the stp files into parallel_maps contiguous chunks of about equal size
+    n_maps = min(proc.parallel_maps, len(stp_files))
+    chunks = [
+        stp_files[k * len(stp_files) // n_maps : (k + 1) * len(stp_files) // n_maps]
+        for k in range(n_maps)
+    ]
+    with (
+        _step(f"creating {len(chunks)} map(s) from {len(stp_files)} stp files"),
+        ThreadPoolExecutor(n_maps) as pool,
+    ):
+        futures = [
+            pool.submit(_create_map, create_args, chunk, map_dir / f"{k:04d}.lh5")
+            for k, chunk in enumerate(chunks)
         ]
-        with (
-            _step(f"run {run}: creating {len(chunks)} map(s) from {len(stp_files)} stp files"),
-            ThreadPoolExecutor(proc.parallel_maps) as pool,
-        ):
-            futures = [
-                pool.submit(_create_map, create_args, chunk, map_dir / f"run{run:03d}-{k:04d}.lh5")
-                for k, chunk in enumerate(chunks)
-            ]
-            for f in futures:
-                f.result()
-
-        if proc.keep_stp:
-            dest = Path(cfg.output_dir) / "stp" / f"node{index:04d}"
-            with _step(f"run {run}: copying stp files to {dest}"):
-                dest.mkdir(parents=True, exist_ok=True)
-                for stp_file in stp_files:
-                    shutil.copy2(stp_file, dest)
-        shutil.rmtree(stp_dir)
+        for f in futures:
+            f.result()
+
+    dest = cfg.stp_dir(index)
+    if dest is not None:
+        # moving is cheap if the destination is on the scratch file system
+        with _step(f"moving stp files to {dest}"):
+            dest.mkdir(parents=True, exist_ok=True)
+            for stp_file in stp_files:
+                shutil.move(stp_file, dest / stp_file.name)
 
     output = cfg.node_map(index)
     with _step(f"merging intermediate maps into {output}"):

{optmapper-0.1.0 → optmapper-0.2.0/src/optmapper.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optmapper
-Version: 0.1.0
+Version: 0.2.0
 Summary: Production of LEGEND optical maps on batch systems
 Author-email: Luigi Pertoldi <gipert@pm.me>
 Maintainer: The LEGEND Collaboration

optmapper-0.2.0/src/optmapper.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.2.0",
+  "distance": 0,
+  "node": "g4dbc0aba8c0cff3ffa6fdab00c66575cd0bf6e2d",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-21"
+}

{optmapper-0.1.0 → optmapper-0.2.0}/tests/conftest.py

@@ -107,6 +107,6 @@ def base_config(tmp_path, gdml_file):
         "emission": {"gaussian": {"mean": "128 nm", "sigma": "0.22 eV"}},
         "optmap": {"range_in_m": [[-1, 1], [-1, 1], [-1, 1]], "bins": [4, 4, 4]},
         "statistics": {"nodes": 1, "runs_per_node": 2, "processes_per_node": 3},
-        "processing": {"stp_files_per_map": 2, "parallel_maps": 2, "procs_per_map": 1},
+        "processing": {"parallel_maps": 2, "procs_per_map": 1},
         "execution": {"site": "local"},
     }

{optmapper-0.1.0 → optmapper-0.2.0}/tests/test_cli.py

@@ -21,7 +21,7 @@ def test_slurm_submission(tmp_path, base_config, fake_bin, monkeypatch):
     base_config["statistics"]["nodes"] = 3
     base_config["execution"] = {
         "site": "nersc",
-        "slurm": {"node": {"mail-user": "me@example.com", "exclusive": True}},
+        "slurm": {"all": {"mail-user": "me@example.com"}, "node": {"exclusive": True}},
     }
     optmapper_cli([_write(tmp_path, base_config)])
 
@@ -49,6 +49,8 @@ def test_slurm_submission(tmp_path, base_config, fake_bin, monkeypatch):
     merge = calls[3]
     assert "--dependency=afterany:1000:1001:1002" in merge
     assert "--qos=shared" in merge
+    assert "--mail-user=me@example.com" in merge
+    assert "--exclusive" not in merge
     assert shlex.split(merge[-1])[-3:] == ["merge", "--config", str(resolved)]
 
     # only the resolved config and the log directory, no job scripts
@@ -98,9 +100,10 @@ def test_launcher(base_config, monkeypatch):
 
 @pytest.mark.usefixtures("fake_bin")
 @pytest.mark.parametrize("nodes", [1, 2])
-def test_local_production(tmp_path, base_config, nodes):
+@pytest.mark.parametrize("keep_stp", [True, "scratch"])
+def test_local_production(tmp_path, base_config, nodes, keep_stp):
     base_config["statistics"]["nodes"] = nodes
-    base_config["processing"]["keep_stp"] = True
+    base_config["processing"]["keep_stp"] = keep_stp
     optmapper_cli([_write(tmp_path, base_config)])
 
     out = tmp_path / "out"
@@ -114,10 +117,11 @@ def test_local_production(tmp_path, base_config, nodes):
     ]
     assert (out / "test-map.mac").is_file()
     # 2 runs x 3 processes per node
-    assert len(list((out / "stp").glob("node*/*.lh5"))) == 6 * nodes
-    assert not (out / "scratch" / "test-map").exists() or not any(
-        (out / "scratch" / "test-map").iterdir()
-    )
+    scratch = out / "scratch" / "test-map"
+    stp = out / "stp" if keep_stp is True else scratch / "stp"
+    assert len(list(stp.glob("node*/*.lh5"))) == 6 * nodes
+    # only the kept stp files are left in the scratch area
+    assert {p.name for p in scratch.iterdir()} <= {"stp"}
     if nodes > 1:
         assert len(list((out / "nodes").glob("*.lh5"))) == nodes
         assert len(list((out / "logs").glob("test-map-merge-*.log"))) == 1

{optmapper-0.1.0 → optmapper-0.2.0}/tests/test_config.py

@@ -20,7 +20,7 @@ geometry:
     LEGEND_METADATA: $_/legend-metadata
     LEGEND1000_METADATA: $HOME/legend1000-metadata
 emission:
-  spectrum: pygeomoptics.lar.g4gps_lar_emissions_spectrum
+  g4gps_spectrum_macro: lar-spectrum.mac
 optmap:
   range_in_m: [[-2, 2], [-2, 2], [-3, 3]]
   bins: [80, 80, 120]
@@ -32,6 +32,7 @@ statistics:
     assert cfg.output_dir == str(tmp_path / "prod" / "out")
     assert cfg.geometry.config == str(tmp_path / "prod" / "geom-config.yaml")
     assert cfg.geometry.optics_plugin == str(tmp_path / "prod" / "plugin.py")
+    assert cfg.emission.g4gps_spectrum_macro == str(tmp_path / "prod" / "lar-spectrum.mac")
     assert cfg.geometry.env["LEGEND_METADATA"] == str(tmp_path / "prod" / "legend-metadata")
     assert not cfg.geometry.env["LEGEND1000_METADATA"].startswith("$")
     assert cfg.gdml_file == tmp_path / "prod" / "out" / "geom.gdml"
@@ -73,6 +74,36 @@ def test_site_presets(base_config):
         load_site("nonexistent-site")
 
 
+def test_slurm_all(tmp_path, base_config):
+    site = tmp_path / "mysite.yaml"
+    site.write_text(
+        "scheduler: slurm\n"
+        "slurm:\n"
+        "  all: {account: acc, mail-type: END}\n"
+        "  node: {time: '04:00:00', mail-type: FAIL}\n"
+        "  merge: {time: '01:00:00'}\n"
+    )
+    base_config["execution"] = {
+        "site": str(site),
+        "slurm": {"all": {"time": "02:00:00", "qos": "debug"}, "merge": {"qos": None}},
+    }
+    slurm = Config.from_dict(base_config).execution.slurm
+    assert set(slurm) == {"node", "merge"}
+    # user options, also from slurm.all, override the site preset
+    assert slurm["node"] == {
+        "account": "acc",
+        "mail-type": "FAIL",
+        "time": "02:00:00",
+        "qos": "debug",
+    }
+    assert slurm["merge"] == {"account": "acc", "mail-type": "END", "time": "02:00:00", "qos": None}
+
+    base_config["execution"] = {"site": "nersc", "slurm": {"all": {"time": "08:00:00"}}}
+    slurm = Config.from_dict(base_config).execution.slurm
+    assert slurm["node"]["time"] == slurm["merge"]["time"] == "08:00:00"
+    assert slurm["merge"]["qos"] == "shared"
+
+
 def test_site_preset_from_file(tmp_path, base_config):
     site = tmp_path / "mysite.yaml"
     site.write_text("scheduler: slurm\nslurm:\n  node:\n    partition: long\n")
@@ -96,6 +127,10 @@ def test_deep_merge():
         ({"geometry": {"gdml": "a.gdml", "env": {"A": "b"}}}, "require 'executable'"),
         ({"emission": {"gaussian": {"mean": 1}}}, "both"),
         ({"emission": {}}, "exactly one of"),
+        (
+            {"emission": {"spectrum": "a.b", "g4gps_spectrum_macro": "s.mac"}},
+            "exactly one of",
+        ),
         ({"statistics": {"nodes": 0}}, "positive integer"),
         ({"optmap": {"range_in_m": [[0, 1], [0, 1]], "bins": [1, 1]}}, "three entries"),
         ({"optmap": {"range_in_m": [[0, 1], [0, 2], [0, 1]], "bins": [1, 1, 1]}}, "equal x"),
@@ -104,8 +139,10 @@ def test_deep_merge():
             "shape",
         ),
         ({"optmap": {"range_in_m": [[1, 0]] * 3, "bins": [1] * 3}}, "empty range"),
+        ({"processing": {"keep_stp": "home"}}, "keep_stp"),
         ({"execution": {"scheduler": "pbs"}}, "scheduler"),
         ({"execution": {"slurm": {"nodes": {}}}}, "unknown key"),
+        ({"execution": {"site": {"slurm": {"nodes": {}}}}}, "unknown key"),
         ({"name": "a/b"}, "invalid production name"),
     ],
 )

{optmapper-0.1.0 → optmapper-0.2.0}/tests/test_macro.py

@@ -102,6 +102,28 @@ def test_spectrum_with_optics_plugin(tmp_path, base_config):
     assert all(a > b for a, b in itertools.pairwise(points))
 
 
+def test_spectrum_macro_file(tmp_path, base_config):
+    from pygeomoptics.lar import g4gps_lar_emissions_spectrum  # noqa: PLC0415
+
+    spectrum = tmp_path / "lar-spectrum.mac"
+    g4gps_lar_emissions_spectrum(str(spectrum), True)
+    base_config["emission"] = {"g4gps_spectrum_macro": str(spectrum)}
+    cfg = Config.from_dict(base_config)
+    assert energy_commands(cfg.emission) == spectrum.read_text().strip().splitlines()
+    macro = render_macro(cfg, 1)
+    assert macro.index("/gps/particle") < macro.index("/gps/hist/point")
+    assert macro.index("/gps/hist/inter") < macro.index("/gps/ang/type")
+
+    # the plain-text output of g4gps_* is not a macro
+    g4gps_lar_emissions_spectrum(str(spectrum), False)
+    with pytest.raises(ConfigError, match="output_macro=True"):
+        energy_commands(cfg.emission)
+
+    base_config["emission"] = {"g4gps_spectrum_macro": str(tmp_path / "missing.mac")}
+    with pytest.raises(ConfigError, match="cannot read"):
+        energy_commands(Config.from_dict(base_config).emission)
+
+
 @pytest.mark.parametrize("spec", ["pygeomoptics.lar.nonexistent", "nomodule.func", "os.getcwd"])
 def test_bad_spectrum(base_config, spec):
     base_config["emission"] = {"spectrum": spec}

optmapper-0.1.0/src/optmapper.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.1.0",
-  "distance": 0,
-  "node": "g44eb9ebce1da120934a68fff22e3e819804d7c30",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-07"
-}