simind-python-connector 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

simind_python_connector/__init__.py

@@ -14,7 +14,7 @@ for _dist_name in ("simind-python-connector", __name__):
     except _meta.PackageNotFoundError:
         continue
 else:  # editable / source checkout
-    __version__ = "1.0.0"
+    __version__ = "2.0.0"
 
 
 def __getattr__(name: str) -> Any:

simind_python_connector/backends/__init__.py

@@ -19,6 +19,7 @@ Usage:
 
 import importlib
 import logging
+import os
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 from .base import AcquisitionDataInterface, ImageDataInterface
@@ -233,6 +234,9 @@ def create_image_data(
     if isinstance(filepath_or_object, ImageDataInterface):
         return filepath_or_object
 
+    if isinstance(filepath_or_object, os.PathLike):
+        filepath_or_object = os.fspath(filepath_or_object)
+
     backend_hint = detect_image_backend(filepath_or_object)
     if backend_hint is None:
         backend_hint = detect_backend_from_interface(filepath_or_object)
@@ -314,6 +318,9 @@ def create_acquisition_data(
     if isinstance(filepath_or_object, AcquisitionDataInterface):
         return filepath_or_object
 
+    if isinstance(filepath_or_object, os.PathLike):
+        filepath_or_object = os.fspath(filepath_or_object)
+
     backend_hint = detect_acquisition_backend(filepath_or_object)
     if backend_hint is None:
         backend_hint = detect_backend_from_interface(filepath_or_object)

simind_python_connector/builders/acquisition_builder.py

@@ -97,6 +97,19 @@ class STIRSPECTAcquisitionDataBuilder:
         else:
             self.pixel_array = np.array(self.pixel_array, dtype=np.float32)
 
+        expected_shape = (
+            1,
+            matrix_size_1,
+            num_projections,
+            matrix_size_2,
+        )
+        if self.pixel_array.shape != expected_shape:
+            raise ValueError(
+                f"pixel array shape {self.pixel_array.shape} does not match "
+                f"header dimensions {expected_shape} "
+                "(tof, bin, view, axial)"
+            )
+
         def _write(base_path: Path, cleanup: bool) -> AcquisitionData:
             header_path = base_path.with_suffix(".hs")
             raw_file_path = base_path.with_suffix(".s")
@@ -112,9 +125,8 @@ class STIRSPECTAcquisitionDataBuilder:
 
             acqdata = self._load_acquisition(str(header_path))
 
-            flipped = np.flip(self.pixel_array, axis=-1)
             acqdata = acqdata.clone()
-            acqdata.fill(flipped)
+            acqdata.fill(self.pixel_array)
             acqdata.write(str(header_path))
 
             if cleanup:
@@ -194,27 +206,50 @@ class STIRSPECTAcquisitionDataBuilder:
             acqdata = self.build(output_path=output_path_base)
             return [acqdata]
 
+        if self.pixel_array is None:
+            raise ValueError(
+                "build_multi_energy requires pixel_array to be set "
+                "(use update_header_from_dicom or set it directly)"
+            )
+
+        num_windows = len(self.energy_windows)
+        total_projections = int(self.header.get("!number of projections", 1))
+        if self.pixel_array.ndim != 4 or (
+            self.pixel_array.shape[2] != total_projections
+        ):
+            raise ValueError(
+                f"pixel array shape {self.pixel_array.shape} does not match "
+                f"declared {total_projections} projections"
+            )
+        if total_projections % num_windows != 0:
+            raise ValueError(
+                f"Number of projections ({total_projections}) must be divisible "
+                f"by the number of energy windows ({num_windows})"
+            )
+        projections_per_window = total_projections // num_windows
+
         # number of projections needs dividing by number of energy windows
-        num_projections = int(self.header.get("!number of projections", 1))
-        num_projections //= len(self.energy_windows)
-        self.header["!number of projections"] = str(num_projections)
+        self.header["!number of projections"] = str(projections_per_window)
 
         # split pixel_array into energy windows along 3rd axis
-        pixel_array_list = np.array_split(
-            self.pixel_array, len(self.energy_windows), axis=2
-        )
-
-        acqdata_list = []
-        for idx, ew in enumerate(self.energy_windows):
-            # Update header for this energy window.
-            self.header["energy window lower level[1]"] = ew["lower"]
-            self.header["energy window upper level[1]"] = ew["upper"]
-            suffix = f"_ew{idx + 1}"
-            output_path = output_path_base + suffix
-            self.pixel_array = pixel_array_list[idx]
-            acqdata = self.build(output_path=output_path)
-            acqdata_list.append(acqdata)
-        return acqdata_list
+        original_pixel_array = self.pixel_array
+        try:
+            pixel_array_list = np.array_split(original_pixel_array, num_windows, axis=2)
+
+            acqdata_list = []
+            for idx, ew in enumerate(self.energy_windows):
+                # Update header for this energy window.
+                self.header["energy window lower level[1]"] = ew["lower"]
+                self.header["energy window upper level[1]"] = ew["upper"]
+                suffix = f"_ew{idx + 1}"
+                output_path = output_path_base + suffix
+                self.pixel_array = pixel_array_list[idx]
+                acqdata = self.build(output_path=output_path)
+                acqdata_list.append(acqdata)
+            return acqdata_list
+        finally:
+            self.pixel_array = original_pixel_array
+            self.header["!number of projections"] = str(total_projections)
 
     def update_header_from_dicom(self, dicom_filepath):
         """
@@ -303,6 +338,8 @@ class STIRSPECTAcquisitionDataBuilder:
             )
 
         # Rotation Information Sequence processing
+        num_frames = ds.get("NumberOfFrames", None)
+        time_per_projection = None
         try:
             if (0x0054, 0x0052) in ds:
                 rot_seq = ds[(0x0054, 0x0052)].value
@@ -322,16 +359,17 @@ class STIRSPECTAcquisitionDataBuilder:
                             rot_item[(0x0018, 0x1242)].value / 1000
                         )
 
-                    if num_frames is not None:
+                    if time_per_projection is not None and num_frames is not None:
                         self.header["number of time frames"] = str(1)
                         self.header["!image duration (sec)[1]"] = str(
                             int(
                                 np.round(
-                                    float(time_per_projection) * float(num_frames), 0
+                                    float(time_per_projection) * float(num_frames),
+                                    0,
                                 )
                             )
                         )
-                    else:
+                    elif time_per_projection is not None:
                         self.header["!time per projection (sec)[1]"] = (
                             time_per_projection
                         )
@@ -516,11 +554,21 @@ class STIRSPECTAcquisitionDataBuilder:
         except AttributeError:
             warnings.warn("StudyDescription not found in DICOM.")
         try:
-            self.pixel_array = ds.pixel_array
-            print(self.pixel_array.shape)
-            self.pixel_array = np.transpose(self.pixel_array, (2, 0, 1))
-            # rotate the image by 90 degrees cW in axis 1
-            self.pixel_array = np.rot90(self.pixel_array, 3, axes=(0, 2))
-            self.pixel_array = np.expand_dims(self.pixel_array, axis=0)
+            raw_pixel_array = ds.pixel_array
         except AttributeError:
             warnings.warn("Pixel data not found in DICOM.")
+            return
+
+        raw_pixel_array = np.asarray(raw_pixel_array)
+        if raw_pixel_array.ndim == 2:
+            # Single frame: promote to (frames=1, rows, columns) so the
+            # transpose below sees the same layout as multiframe data.
+            raw_pixel_array = raw_pixel_array[np.newaxis, :, :]
+        elif raw_pixel_array.ndim != 3:
+            raise ValueError(
+                f"pixel data must be 2D or 3D, got {raw_pixel_array.ndim}D"
+            )
+        self.pixel_array = np.transpose(raw_pixel_array, (2, 0, 1))
+        # rotate the image by 90 degrees cW in axis 1
+        self.pixel_array = np.rot90(self.pixel_array, 3, axes=(0, 2))
+        self.pixel_array = np.expand_dims(self.pixel_array, axis=0)

simind_python_connector/builders/image_builder.py

@@ -79,12 +79,24 @@ class STIRSPECTImageDataBuilder:
 
     def _resolve_data_array(self) -> np.ndarray:
         if self.pixel_array is not None:
-            return np.asarray(self.pixel_array, dtype=np.float32)
-
-        dim_x = int(self.header["!matrix size [1]"])
-        dim_y = int(self.header["!matrix size [2]"])
-        dim_z = int(self.header["!matrix size [3]"])
-        return np.zeros((dim_z, dim_y, dim_x), dtype=np.float32)
+            data = np.asarray(self.pixel_array, dtype=np.float32)
+        else:
+            dim_x = int(self.header["!matrix size [1]"])
+            dim_y = int(self.header["!matrix size [2]"])
+            dim_z = int(self.header["!matrix size [3]"])
+            data = np.zeros((dim_z, dim_y, dim_x), dtype=np.float32)
+
+        expected_shape = (
+            int(self.header["!matrix size [3]"]),
+            int(self.header["!matrix size [2]"]),
+            int(self.header["!matrix size [1]"]),
+        )
+        if data.shape != expected_shape:
+            raise ValueError(
+                f"pixel array shape {data.shape} does not match header "
+                f"dimensions {expected_shape} (z, y, x)"
+            )
+        return data
 
     def build(self, output_path: Optional[str | Path] = None):
         """

simind_python_connector/connectors/__init__.py

@@ -1,4 +1,10 @@
-"""Connector/adaptor APIs."""
+"""Connector/adaptor APIs.
+
+Backend-specific adaptors are exposed lazily so that importing this package
+never imports SIRF, STIR, or PyTomography.
+"""
+
+import importlib
 
 from .base import BaseConnector
 from .python_connector import (
@@ -7,9 +13,22 @@ from .python_connector import (
     RuntimeOperator,
     SimindPythonConnector,
 )
-from .pytomography_adaptor import PyTomographySimindAdaptor
-from .sirf_adaptor import SirfSimindAdaptor
-from .stir_adaptor import StirSimindAdaptor
+
+
+_LAZY_ADAPTORS = {
+    "PyTomographySimindAdaptor": "pytomography_adaptor",
+    "SirfSimindAdaptor": "sirf_adaptor",
+    "StirSimindAdaptor": "stir_adaptor",
+}
+
+
+def __getattr__(name):
+    if name in _LAZY_ADAPTORS:
+        module = importlib.import_module(f".{_LAZY_ADAPTORS[name]}", __name__)
+        obj = getattr(module, name)
+        globals()[name] = obj
+        return obj
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
 __all__ = [

simind_python_connector/connectors/_spacing.py

@@ -17,9 +17,11 @@ def _voxel_size_from_spacing(spacing: Any) -> float | None:
 
     if values:
         if len(values) >= 4:
-            return float(values[3])
-        if len(values) >= 3:
-            return float(values[2])
+            # Raw STIR-style coordinate sequence: (unused, z, y, x)
+            return float(values[1])
+        if len(values) == 3:
+            # Public (z, y, x) convention
+            return float(values[0])
 
     if hasattr(spacing, "z"):
         try:
@@ -28,13 +30,13 @@ def _voxel_size_from_spacing(spacing: Any) -> float | None:
             pass
 
     if hasattr(spacing, "at"):
-        for index in (3, 2):
+        for index in (1, 2, 3):
             try:
                 return float(spacing.at(index))
             except Exception:
                 continue
 
-    for index in (3, 2):
+    for index in (1, 2, 3):
         try:
             return float(spacing[index])
         except Exception:
@@ -44,12 +46,16 @@ def _voxel_size_from_spacing(spacing: Any) -> float | None:
 
 
 def extract_voxel_size_mm(image: Any, backend_name: str) -> float:
-    """Extract z voxel spacing in mm from backend image metadata."""
+    """Extract z voxel spacing in mm from backend image metadata.
+
+    Backend images report ``voxel_sizes()`` in ``(z, y, x)`` order, so the
+    first element is the z spacing.
+    """
     if hasattr(image, "voxel_sizes"):
         voxel_sizes = image.voxel_sizes()
         try:
             if len(voxel_sizes) >= 3:
-                return float(voxel_sizes[2])
+                return float(voxel_sizes[0])
         except Exception:
             pass
 

simind_python_connector/connectors/python_connector.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import contextlib
 import logging
+import math
 import os
 import shutil
 from dataclasses import dataclass, field
@@ -62,11 +63,12 @@ class SimindPythonConnector(BaseConnector):
         quantization_scale: float = 1.0,
     ) -> None:
         self.logger = logging.getLogger(__name__)
+        self._validate_output_prefix(output_prefix)
         self.output_dir = Path(output_dir).expanduser().resolve()
         self.output_dir.mkdir(parents=True, exist_ok=True)
         self.output_prefix = output_prefix
         self.quantization_scale = float(quantization_scale)
-        if self.quantization_scale <= 0:
+        if not math.isfinite(self.quantization_scale) or self.quantization_scale <= 0:
             raise ValueError("quantization_scale must be > 0")
 
         self.config = self._initialize_config(config_source)
@@ -75,12 +77,31 @@ class SimindPythonConnector(BaseConnector):
         self.converter = SimindToStirConverter()
 
         self._outputs: Optional[dict[str, ProjectionResult]] = None
+        self._window_file_path: Optional[Path] = None
+
+    @staticmethod
+    def _validate_output_prefix(prefix: str) -> None:
+        """Reject prefixes that could escape the output directory."""
+        if (
+            not isinstance(prefix, str)
+            or not prefix
+            or prefix in {".", ".."}
+            or "/" in prefix
+            or "\\" in prefix
+            or Path(prefix).is_absolute()
+        ):
+            raise ValueError(f"output_prefix must be a plain filename, got {prefix!r}")
 
     @staticmethod
     def _initialize_config(config_source: ConfigSource) -> SimulationConfig:
         if isinstance(config_source, SimulationConfig):
             return config_source
 
+        if not isinstance(config_source, (str, os.PathLike)):
+            # importlib.resources Traversable from configs.get(): hand it to
+            # SimulationConfig untouched (supports zipped installs).
+            return SimulationConfig(config_source)
+
         config_path = Path(config_source).expanduser().resolve()
         if not config_path.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_source}")
@@ -124,14 +145,30 @@ class SimindPythonConnector(BaseConnector):
             raise ValueError("source and mu_map must have identical shapes")
 
         vox_cm = float(voxel_size_mm) / SIMIND_VOXEL_UNIT_CONVERSION
-        if vox_cm <= 0:
+        if not math.isfinite(vox_cm) or vox_cm <= 0:
             raise ValueError("voxel_size_mm must be > 0")
-
-        routine = (
-            ScoringRoutine(scoring_routine)
-            if isinstance(scoring_routine, int)
-            else scoring_routine
-        )
+        if source_array.size == 0 or mu_map_array.size == 0:
+            raise ValueError("source and mu_map must not be empty")
+        if not np.isfinite(source_array).all() or not np.isfinite(mu_map_array).all():
+            raise ValueError("source and mu_map must contain only finite values")
+        if (source_array < 0).any() or (mu_map_array < 0).any():
+            raise ValueError("source and mu_map must be non-negative")
+
+        if isinstance(scoring_routine, ScoringRoutine):
+            routine = scoring_routine
+        elif isinstance(scoring_routine, int) and not isinstance(scoring_routine, bool):
+            try:
+                routine = ScoringRoutine(scoring_routine)
+            except ValueError as exc:
+                raise ValueError(
+                    f"scoring_routine {scoring_routine!r} is not a valid "
+                    "ScoringRoutine value"
+                ) from exc
+        else:
+            raise ValueError(
+                "scoring_routine must be a ScoringRoutine or int, got "
+                f"{type(scoring_routine).__name__}"
+            )
         dim_z, dim_y, dim_x = (int(v) for v in source_array.shape)
 
         cfg = self.config
@@ -156,8 +193,10 @@ class SimindPythonConnector(BaseConnector):
         cfg.set_value(31, vox_cm)
         cfg.set_value(33, 1)
         cfg.set_value(34, dim_z)
-        cfg.set_value(78, dim_x)
-        cfg.set_value(79, dim_y)
+        cfg.set_value(78, dim_x)  # density map i
+        cfg.set_value(79, dim_x)  # source map i
+        cfg.set_value(81, dim_y)  # density map j
+        cfg.set_value(82, dim_y)  # source map j
 
         self.runtime_switches.set_switch("PX", vox_cm)
 
@@ -198,12 +237,14 @@ class SimindPythonConnector(BaseConnector):
         scatter_orders: Union[int, list[int]],
     ) -> None:
         """Write a SIMIND window file for this connector run."""
+        window_path = self.output_dir / f"{self.output_prefix}.win"
         create_window_file(
             lower_bounds,
             upper_bounds,
             scatter_orders,
-            output_filename=str(self.output_dir / self.output_prefix),
+            output_filename=str(window_path),
         )
+        self._window_file_path = window_path
 
     def run(
         self, runtime_operator: Optional[RuntimeOperator] = None
@@ -211,22 +252,27 @@ class SimindPythonConnector(BaseConnector):
         """Run SIMIND and return projection outputs as NumPy arrays."""
         self._outputs = None
 
+        # Runtime-operator switches apply to this run only; merge them into
+        # a throwaway switch set instead of persistent connector state.
+        run_switches_holder = RuntimeSwitches()
+        for key, value in self.runtime_switches.switches.items():
+            run_switches_holder.set_switch(key, value)
         orbit_file = None
         if runtime_operator is not None:
-            self.set_runtime_switches(runtime_operator.switches)
+            for key, value in runtime_operator.switches.items():
+                run_switches_holder.set_switch(key, value)
             orbit_file = self._prepare_orbit_file(runtime_operator.orbit_file)
 
         config_path = self.output_dir / self.output_prefix
         self.config.save_file(config_path)
 
-        original_cwd = Path.cwd()
-        try:
-            os.chdir(self.output_dir)
-            self.executor.run_simulation(
-                self.output_prefix, orbit_file, self.runtime_switches.switches
-            )
-        finally:
-            os.chdir(original_cwd)
+        self._clear_previous_outputs()
+        self.executor.run_simulation(
+            self.output_prefix,
+            orbit_file,
+            run_switches_holder.switches,
+            cwd=self.output_dir,
+        )
 
         header_files = self._ensure_interfile_headers()
         self._outputs = self._load_projection_outputs(header_files)
@@ -241,6 +287,46 @@ class SimindPythonConnector(BaseConnector):
     def get_config(self) -> SimulationConfig:
         return self.config
 
+    _OUTPUT_SUFFIXES = {".h00", ".hs", ".a00", ".s", ".win"}
+
+    def _clear_previous_outputs(self) -> None:
+        """Delete stale outputs from earlier runs sharing this prefix.
+
+        Connector-written inputs (``{prefix}_src.smi`` / ``{prefix}_dns.dmi``)
+        are protected because SIMIND still needs them on disk.
+        """
+        protected = {
+            f"{self.output_prefix}_src.smi",
+            f"{self.output_prefix}_dns.dmi",
+        }
+        if (
+            self._window_file_path is not None
+            and self._window_file_path.parent == self.output_dir
+        ):
+            # Energy-window input written via set_energy_windows(); protect
+            # only that exact file, never a pre-existing one at the current
+            # prefix/location.
+            protected.add(self._window_file_path.name)
+        for slot in (5, 6):
+            try:
+                protected.add(self.config.get_data_file(slot))
+            except KeyError:
+                pass
+        for path in sorted(self.output_dir.iterdir()):
+            if not path.is_file() or path.name in protected:
+                continue
+            stem_ok = path.stem == self.output_prefix or path.stem.startswith(
+                f"{self.output_prefix}_"
+            )
+            if not stem_ok:
+                continue
+            if path.suffix in self._OUTPUT_SUFFIXES or (
+                path.suffix.startswith(".b")
+                and path.suffix[2:].isdigit()
+                and path.stem == self.output_prefix
+            ):
+                path.unlink()
+
     def _prepare_orbit_file(self, orbit_file: Optional[PathLike]) -> Optional[Path]:
         if orbit_file is None:
             return None
@@ -273,12 +359,18 @@ class SimindPythonConnector(BaseConnector):
                 self.output_dir.glob(f"{self.output_prefix}_component_*.hs")
             )
         else:
-            h00_files = sorted(self.output_dir.glob(f"*{self.output_prefix}*.h00"))
+            h00_files = sorted(
+                set(self.output_dir.glob(f"{self.output_prefix}_*.h00"))
+                | set(self.output_dir.glob(f"{self.output_prefix}.h00"))
+            )
             for h00_file in h00_files:
                 hs_file = h00_file.with_suffix(".hs")
                 self.converter.convert_file(str(h00_file), str(hs_file))
 
-            hs_files = sorted(self.output_dir.glob(f"*{self.output_prefix}*.hs"))
+            hs_files = sorted(
+                set(self.output_dir.glob(f"{self.output_prefix}_*.hs"))
+                | {h00_file.with_suffix(".hs") for h00_file in h00_files}
+            )
         if not hs_files:
             raise FileNotFoundError(
                 f"No projection headers (.hs) found for prefix {self.output_prefix!r} "

simind_python_connector/connectors/pytomography_adaptor.py

@@ -134,6 +134,11 @@ class PyTomographySimindAdaptor(BaseConnector):
     def run(
         self, runtime_operator: Optional[RuntimeOperator] = None
     ) -> Dict[str, torch.Tensor]:
+        # Clear all output caches up front so failed reruns cannot leak
+        # results from a previous successful run.
+        self._outputs = None
+        self._output_metadata = None
+        self._output_header_paths = None
         self._validate_inputs()
         assert self._source is not None  # for type checkers
         assert self._mu_map is not None

simind_python_connector/connectors/sirf_adaptor.py

@@ -79,6 +79,9 @@ class SirfSimindAdaptor(BaseConnector):
         self.python_connector.add_runtime_switch(switch, value)
 
     def run(self, runtime_operator: Optional[RuntimeOperator] = None) -> dict[str, Any]:
+        # Drop cached outputs before validation so a failed rerun can never
+        # expose results from a previous successful run.
+        self._outputs = None
         self._validate_inputs()
         assert self._source is not None
         assert self._mu_map is not None

simind_python_connector/connectors/stir_adaptor.py

@@ -79,6 +79,9 @@ class StirSimindAdaptor(BaseConnector):
         self.python_connector.add_runtime_switch(switch, value)
 
     def run(self, runtime_operator: Optional[RuntimeOperator] = None) -> dict[str, Any]:
+        # Drop cached outputs before validation so a failed rerun can never
+        # expose results from a previous successful run.
+        self._outputs = None
         self._validate_inputs()
         assert self._source is not None
         assert self._mu_map is not None

simind_python_connector/converters/attenuation.py

@@ -57,7 +57,9 @@ def get_attenuation_coefficient(material, energy, file_path=None):
         raise ValueError("Unknown material. Accepted values are 'water' or 'bone'.")
 
     if file_path:
-        filepath = Path(file_path) / filename
+        # filename may already be an absolute packaged path; join only its
+        # basename so the override directory is honoured.
+        filepath = Path(file_path) / Path(str(filename)).name
     else:
         filepath = get_package_data_path(filename)
 

simind_python_connector/converters/simind_to_stir.py

@@ -28,7 +28,7 @@ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
 class ConversionConfig:
     """Configuration for SIMIND to STIR conversion."""
 
-    radius_scale_factor: float = 10.0  # cm to mm
+    radius_scale_factor: float = 1.0  # pass-through; SIMIND writes Radius in mm
     angle_offset: float = 180.0  # degrees
     default_number_format: str = "float"
     ignored_patterns: List[str] = None
@@ -74,9 +74,9 @@ class RadiusConversionRule(ConversionRule):
 
     def convert(self, line: str, context: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
         try:
-            # Assume .h00 files contain radius in mm (SIMIND's inconsistent behavior)
-            # So use radius value as-is for STIR (which expects mm)
-            radius_value = float(line.split()[-1])
+            # Apply the configured scale factor (default 1.0 keeps SIMIND's
+            # millimetre Radius values unchanged).
+            radius_value = float(line.split()[-1]) * self.scale_factor
             return f"Radius := {radius_value}", context
         except (ValueError, IndexError) as e:
             logging.warning(f"Failed to convert radius line '{line}': {e}")
@@ -283,6 +283,10 @@ class SimindToStirConverter:
     ) -> List[ConversionRule]:
         """Create conversion rules in order of priority."""
         return [
+            # Data-file names must be rewritten before ignore rules run:
+            # ignored substrings such as "patient" otherwise comment out
+            # data files whose paths happen to contain them.
+            DataFileNameRule(data_file_override),
             IgnorePatternRule(self.config.ignored_patterns),
             OrbitFileRule(self.input_file_dir),  # Process orbit file before other rules
             RadiusConversionRule(self.config.radius_scale_factor),
@@ -293,7 +297,6 @@ class SimindToStirConverter:
             ImageDurationRule(),
             EnergyWindowRule("lower"),
             EnergyWindowRule("upper"),
-            DataFileNameRule(data_file_override),
         ]
 
     def convert_line(
@@ -507,12 +510,11 @@ class SimindToStirConverter:
             self.logger.warning(f"No .h00 file found with prefix {output_prefix}")
             return None
         else:
-            # Multiple .h00 files - this might be scattwin, not penetrate
-            self.logger.warning(
-                "Multiple .h00 files found - this may not be penetrate routine output"
+            raise ValueError(
+                f"Multiple .h00 files match prefix {output_prefix!r} in "
+                f"{output_dir}: {[f.name for f in sorted(h00_files)]}. "
+                "Remove stale outputs or use a distinct output prefix."
             )
-            # Return the first one as fallback
-            return str(h00_files[0])
 
     def read_parameter(self, filename: str, parameter: str) -> Optional[str]:
         """Read a parameter from a header file."""