simind-python-connector 1.1.0__tar.gz → 1.1.1__tar.gz

{simind_python_connector-1.1.0/simind_python_connector.egg-info → simind_python_connector-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simind-python-connector
-Version: 1.1.0
+Version: 1.1.1
 Summary: Python SIMIND Monte Carlo connector with STIR/SIRF/PyTomography adaptors
 Author-email: Sam Porter <sam.porter.18@ucl.ac.uk>, Rebecca Gillen <rebecca.gillen.18@ucl.ac.uk>, "Efstathios (Stahis) Varzakis" <efstathios.varzakis.22@ucl.ac.uk>
 Maintainer-email: Sam Porter <sam.porter.18@ucl.ac.uk>

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/docs/backends.rst

@@ -16,7 +16,7 @@ Dependency Matrix
    * - ``SimindPythonConnector``
      - SIMIND executable on ``PATH`` (no SIRF/STIR/PyTomography requirement)
    * - ``StirSimindAdaptor``
-     - STIR Python (``stir``)
+     - STIR Python (``stir`` and ``stirextra``)
    * - ``SirfSimindAdaptor``
      - SIRF (``sirf.STIR``)
    * - ``PyTomographySimindAdaptor``

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/docs/changelog.rst

@@ -7,6 +7,62 @@ All notable changes to this project are documented in this file.
 
 The format is based on `Keep a Changelog <https://keepachangelog.com/en/1.0.0/>`_, and this project adheres to `Semantic Versioning <https://semver.org/spec/v2.0.0.html>`_.
 
+1.1.1 - 2026-10-11
+------------------
+
+Fixed
+~~~~~
+
+- A negative Index 1 (energies from the isotope file) turned the mu map into
+  near-vacuum; it is now converted at ``abs(Index 1)``.
+- Acquisition arrays use ``(tof, axial, view, bin)``, and DICOM matrix sizes and
+  pixel spacing are no longer swapped, so non-square projections build
+  correctly. ``create_stir_acqdata`` takes ``(bins, axial)`` and uses the same
+  layout.
+- The PyTomography adaptor reverses axial slices to match PyTomography's SIMIND
+  reader; reconstructions were flipped along z.
+- The STIR/SIRF adaptors raise a ``ValueError`` for non-cubic voxels instead of
+  using the z spacing for every axis.
+- The adaptors default ``scoring_routine`` to None, which keeps the
+  configuration's Index 84; they used to overwrite it with SCATTWIN.
+- The geometry docs give the projection axis orders correctly.
+- PyTomography PENETRATE and fallback outputs use the reader's
+  ``(view, bin, axial)`` order, and PyTomography scatter orders are validated
+  like the core's.
+- The STIR/SIRF adaptors reject a mu map whose voxel size differs from the
+  source's.
+- The legacy SIRF attenuation loader reverses the voxel sizes with the
+  dimensions.
+- The SIRF wrapper's ``maximum()`` and ``sapyb()`` update the wrapped object.
+- Piecewise Schneider conversion gives HU outside the table the nearest
+  segment's density, so metal above 4001 HU no longer becomes air.
+- MPI runs use ``$SIMIND_MPI_BIN``, else ``simind_mpi`` next to the serial
+  binary, with ``/MP`` and without a stray ``-p``.
+- An output header that cannot be read raises instead of being skipped.
+- YAML export keeps unnamed parameters and flags.
+- New header keys are written before ``!END OF INTERFILE``, and ``set()``
+  changes the last duplicate key, the one readers use.
+- A header converted into another directory points at its data by absolute
+  path, and an orbit file named like an ignored key keeps its radii.
+- DICOM frames are split by ``EnergyWindowVector`` when present; each output
+  declares one window and its share of the duration.
+- ``run()`` sets Flags 5 and 14, which SIMIND needs to write readable headers,
+  so config-defined phantom runs work.
+- Example 07C no longer drops attenuation and PSF modelling silently, and the
+  examples accept ``SIMIND_BIN``.
+- Importing the converter no longer configures root logging.
+- setuptools 77.0.3 or newer is required to build.
+
+Changed
+~~~~~~~
+
+- ``get_attenuation_coefficient`` takes keV, as documented.
+- ``NN`` must be an integer >= 1, switches reject None and bool values,
+  ``quantization_scale`` must be in (0, 1], and ``output_prefix`` must match
+  ``[a-z0-9][a-z0-9_-]*`` (SIMIND lowercases file names).
+- Publishing waits for the tests and checks the tag against the version; tests
+  also run on ``release/**`` branches.
+
 1.1.0 - 2026-10-11
 ------------------
 

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/docs/conf.py

@@ -13,7 +13,7 @@ sys.path.insert(0, os.path.abspath(".."))
 project = "simind-python-connector"
 copyright = f"{datetime.now().year}, Sam Porter, Efstathios Varzakis"
 author = "Sam Porter, Efstathios Varzakis"
-release = "1.1.0"
+release = "1.1.1"
 for dist_name in ("simind-python-connector",):
     try:
         release = importlib_metadata.version(dist_name)

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/docs/examples/07C_pytomography_adaptor_osem.py

@@ -90,21 +90,13 @@ def _build_system_matrix(
 ) -> SPECTSystemMatrix:
     object_meta, proj_meta = pytomo_simind.get_metadata(str(projection_header))
 
-    obj2obj_transforms = []
-    try:
-        obj2obj_transforms.append(
-            SPECTAttenuationTransform(
-                attenuation_map=attenuation_map_xyz.to(dtype=torch.float32).contiguous()
-            )
-        )
-    except Exception:
-        pass
-
-    try:
-        psf_meta = pytomo_simind.get_psfmeta_from_header(str(projection_header))
-        obj2obj_transforms.append(SPECTPSFTransform(psf_meta=psf_meta))
-    except Exception:
-        pass
+    psf_meta = pytomo_simind.get_psfmeta_from_header(str(projection_header))
+    obj2obj_transforms = [
+        SPECTAttenuationTransform(
+            attenuation_map=attenuation_map_xyz.to(dtype=torch.float32).contiguous()
+        ),
+        SPECTPSFTransform(psf_meta=psf_meta),
+    ]
 
     return SPECTSystemMatrix(
         obj2obj_transforms=obj2obj_transforms,

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1/docs}/examples/_python_connector_helpers.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import shutil
 
 import numpy as np
@@ -8,9 +9,9 @@ from simind_python_connector import SimindPythonConnector
 
 
 def require_simind() -> None:
-    if shutil.which("simind") is None:
+    if shutil.which(os.environ.get("SIMIND_BIN") or "simind") is None:
         raise RuntimeError(
-            "SIMIND executable not found in PATH. "
+            "SIMIND executable not found ($SIMIND_BIN or simind on PATH). "
             "Install SIMIND before running this example."
         )
 

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/docs/geometry.rst

@@ -9,9 +9,9 @@ At-a-Glance Axis Conventions
 
 - STIR/SIRF image arrays are handled as ``(z, y, x)``.
 - STIR/SIRF projection arrays are often 4D with a singleton TOF axis:
-  ``(tof, bin, view, axial)``. For these, **view 0** is ``arr[0, :, 0, :]``.
+  ``(tof, axial, view, bin)``. For these, **view 0** is ``arr[0, :, 0, :]``.
 - Raw Interfile projection loading in ``interfile_numpy`` is exposed as
-  ``(views, bins, axial)`` when no singleton TOF axis is present.
+  ``(view, axial, bin)`` when no singleton TOF axis is present.
 - ``PyTomographySimindAdaptor`` public object-space tensors are ``(x, y, z)``.
 - PyTomography object space is ``(x, y, z)`` (``Lx, Ly, Lz``).
 - PyTomography SIMIND projections from ``pytomography.io.SPECT.simind`` are
@@ -35,11 +35,10 @@ Units
 - STIR/SIRF image geometry is typically expressed in **mm**.
 - Connectors handle conversion internally via voxel-size settings (for example,
   runtime switch ``PX`` is set in cm for SIMIND).
-- STIR/SIRF adaptor voxel size extraction expects z-spacing in mm. Images
-  report ``voxel_sizes()`` as ``(z, y, x)``, so the **first** element is the z
-  spacing. Raw ``get_grid_spacing()`` sequences follow the STIR coordinate
-  layout ``(unused, z, y, x)`` and use index 1; coordinate objects with a
-  ``z`` accessor use that accessor directly.
+- STIR/SIRF adaptors read the voxel spacing in mm and need cubic voxels; other
+  images raise a ``ValueError``. Images report ``voxel_sizes()`` as
+  ``(z, y, x)``, and raw ``get_grid_spacing()`` sequences follow the STIR
+  coordinate layout ``(unused, z, y, x)``.
 
 Projection Size
 ---------------

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/examples/07C_pytomography_adaptor_osem.py

@@ -90,21 +90,13 @@ def _build_system_matrix(
 ) -> SPECTSystemMatrix:
     object_meta, proj_meta = pytomo_simind.get_metadata(str(projection_header))
 
-    obj2obj_transforms = []
-    try:
-        obj2obj_transforms.append(
-            SPECTAttenuationTransform(
-                attenuation_map=attenuation_map_xyz.to(dtype=torch.float32).contiguous()
-            )
-        )
-    except Exception:
-        pass
-
-    try:
-        psf_meta = pytomo_simind.get_psfmeta_from_header(str(projection_header))
-        obj2obj_transforms.append(SPECTPSFTransform(psf_meta=psf_meta))
-    except Exception:
-        pass
+    psf_meta = pytomo_simind.get_psfmeta_from_header(str(projection_header))
+    obj2obj_transforms = [
+        SPECTAttenuationTransform(
+            attenuation_map=attenuation_map_xyz.to(dtype=torch.float32).contiguous()
+        ),
+        SPECTPSFTransform(psf_meta=psf_meta),
+    ]
 
     return SPECTSystemMatrix(
         obj2obj_transforms=obj2obj_transforms,

{simind_python_connector-1.1.0/docs → simind_python_connector-1.1.1}/examples/_python_connector_helpers.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import shutil
 
 import numpy as np
@@ -8,9 +9,9 @@ from simind_python_connector import SimindPythonConnector
 
 
 def require_simind() -> None:
-    if shutil.which("simind") is None:
+    if shutil.which(os.environ.get("SIMIND_BIN") or "simind") is None:
         raise RuntimeError(
-            "SIMIND executable not found in PATH. "
+            "SIMIND executable not found ($SIMIND_BIN or simind on PATH). "
             "Install SIMIND before running this example."
         )
 

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=61.0", "wheel"]
+requires = ["setuptools>=77.0.3", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "simind-python-connector"
-version = "1.1.0"
+version = "1.1.1"
 description = "Python SIMIND Monte Carlo connector with STIR/SIRF/PyTomography adaptors"
 readme = "README.md"
 requires-python = ">=3.9"

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/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.1.0"
+    __version__ = "1.1.1"
 
 
 def __getattr__(name: str) -> Any:

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/simind_python_connector/backends/sirf_backend.py

@@ -88,7 +88,7 @@ class SirfImageData(ImageDataInterface):
 
     def maximum(self, value: float) -> None:
         """Apply element-wise maximum."""
-        self._obj.maximum(value)
+        self._obj.maximum(value, out=self._obj)
 
     @property
     def native_object(self):
@@ -150,7 +150,7 @@ class SirfImageData(ImageDataInterface):
             SirfImageData: self after modification (for chaining)
         """
         y_obj = y._obj if isinstance(y, SirfImageData) else y
-        self._obj.sapyb(a, y_obj, b)
+        self._obj.sapyb(a, y_obj, b, out=self._obj)
         return self
 
 
@@ -305,5 +305,5 @@ class SirfAcquisitionData(AcquisitionDataInterface):
             SirfAcquisitionData: self after modification (for chaining)
         """
         y_obj = y._obj if isinstance(y, SirfAcquisitionData) else y
-        self._obj.sapyb(a, y_obj, b)
+        self._obj.sapyb(a, y_obj, b, out=self._obj)
         return self

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/simind_python_connector/builders/acquisition_builder.py

@@ -92,22 +92,22 @@ class STIRSPECTAcquisitionDataBuilder:
         num_projections = int(self.header.get("!number of projections", 1))
         if self.pixel_array is None:
             self.pixel_array = np.zeros(
-                (1, matrix_size_1, num_projections, matrix_size_2), dtype=np.float32
+                (1, matrix_size_2, num_projections, matrix_size_1), dtype=np.float32
             )
         else:
             self.pixel_array = np.array(self.pixel_array, dtype=np.float32)
 
         expected_shape = (
             1,
-            matrix_size_1,
-            num_projections,
             matrix_size_2,
+            num_projections,
+            matrix_size_1,
         )
         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)"
+                "(tof, axial, view, bin)"
             )
 
         def _write(base_path: Path, cleanup: bool) -> AcquisitionData:
@@ -115,6 +115,8 @@ class STIRSPECTAcquisitionDataBuilder:
             raw_file_path = base_path.with_suffix(".s")
 
             self.header["name of data file"] = raw_file_path.name
+            # Keys added since an earlier build must come before the terminator.
+            self.header.pop("!END OF INTERFILE", None)
             self.header["!END OF INTERFILE"] = ""
 
             with open(header_path, "w") as f:
@@ -221,35 +223,54 @@ class STIRSPECTAcquisitionDataBuilder:
                 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
-        self.header["!number of projections"] = str(projections_per_window)
+        window_vector = getattr(self, "energy_window_vector", None)
+        if window_vector is not None:
+            window_vector = np.asarray(window_vector)
+            if len(window_vector) != total_projections:
+                raise ValueError(
+                    f"EnergyWindowVector has {len(window_vector)} entries for "
+                    f"{total_projections} frames"
+                )
+            frames_per_window = [
+                np.flatnonzero(window_vector == idx + 1) for idx in range(num_windows)
+            ]
+        else:
+            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})"
+                )
+            # Without a window vector, assume one contiguous block per window.
+            frames_per_window = np.array_split(
+                np.arange(total_projections), num_windows
+            )
 
-        # split pixel_array into energy windows along 3rd axis
         original_pixel_array = self.pixel_array
+        original_header = dict(self.header)
+        duration = original_header.get("!image duration (sec)[1]")
         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.
+                frames = frames_per_window[idx]
+                self.header["!number of projections"] = str(len(frames))
+                self.header["!number of energy windows"] = "1"
                 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]
+                if duration is not None:
+                    # Windows are acquired simultaneously, so each output
+                    # covers only its own frames.
+                    self.header["!image duration (sec)[1]"] = (
+                        f"{float(duration) * len(frames) / total_projections:g}"
+                    )
+                output_path = output_path_base + f"_ew{idx + 1}"
+                self.pixel_array = original_pixel_array[:, :, frames, :]
                 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)
+            self.header = original_header
 
     def update_header_from_dicom(self, dicom_filepath):
         """
@@ -273,16 +294,18 @@ class STIRSPECTAcquisitionDataBuilder:
                 "Modality not found in DICOM. Retaining default '!imaging modality'."
             )
         try:
-            self.header["!matrix size [1]"] = str(ds.Rows)
-            self.header["!matrix size [2]"] = str(ds.Columns)
+            self.header["!matrix size [1]"] = str(ds.Columns)
+            self.header["!matrix size [2]"] = str(ds.Rows)
         except AttributeError:
             warnings.warn(
                 "Rows/Columns not found in DICOM. Retaining default matrix sizes."
             )
         try:
             pixel_spacing = ds.PixelSpacing
-            self.header["scaling factor (mm/pixel) [1]"] = str(pixel_spacing[0])
-            self.header["scaling factor (mm/pixel) [2]"] = str(pixel_spacing[1])
+            # DICOM PixelSpacing is [row spacing, column spacing]; Interfile
+            # [1] is the column/bin axis and [2] the row/axial axis.
+            self.header["scaling factor (mm/pixel) [1]"] = str(pixel_spacing[1])
+            self.header["scaling factor (mm/pixel) [2]"] = str(pixel_spacing[0])
         except AttributeError:
             warnings.warn(
                 "PixelSpacing not found in DICOM. Retaining default scaling factors."
@@ -303,6 +326,10 @@ class STIRSPECTAcquisitionDataBuilder:
         try:
             ewi_seq_tag = (0x0054, 0x0012)
             self.energy_windows = []  # list to hold each energy window's info
+            vector = ds.get("EnergyWindowVector")
+            self.energy_window_vector = (
+                [int(v) for v in np.atleast_1d(vector)] if vector is not None else None
+            )
             if ewi_seq_tag in ds:
                 ewi_seq = ds[ewi_seq_tag].value
                 for ewi_item in ewi_seq:

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/simind_python_connector/builders/image_builder.py

@@ -111,6 +111,9 @@ class STIRSPECTImageDataBuilder:
             header_path = base_path.with_suffix(".hv")
             raw_path = base_path.with_suffix(".v")
             self.header["!name of data file"] = raw_path.name
+            # Keys added after construction must come before the terminator.
+            self.header.pop("!END OF INTERFILE", None)
+            self.header["!END OF INTERFILE"] = ""
 
             with open(header_path, "w") as f:
                 line = 0

simind_python_connector-1.1.1/simind_python_connector/connectors/_spacing.py

@@ -0,0 +1,83 @@
+"""Helpers for extracting voxel spacing from SIRF/STIR image objects."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+def _call_or_value(value: Any) -> Any:
+    return value() if callable(value) else value
+
+
+def _spacing_zyx(spacing: Any) -> Optional[tuple[float, float, float]]:
+    try:
+        values = tuple(float(v) for v in spacing)
+    except Exception:
+        values = ()
+
+    if len(values) >= 4:
+        # Raw STIR-style coordinate sequence: (unused, z, y, x)
+        return values[1], values[2], values[3]
+    if len(values) == 3:
+        # Public (z, y, x) convention
+        return values[0], values[1], values[2]
+
+    if all(hasattr(spacing, axis) for axis in ("z", "y", "x")):
+        try:
+            z, y, x = (float(_call_or_value(getattr(spacing, axis))) for axis in "zyx")
+            return z, y, x
+        except Exception:
+            pass
+
+    # Non-iterable STIR coordinates index (z, y, x) from 1.
+    for accessor in (
+        getattr(spacing, "at", None),
+        getattr(spacing, "__getitem__", None),
+    ):
+        if accessor is None:
+            continue
+        try:
+            z, y, x = (float(accessor(index)) for index in (1, 2, 3))
+            return z, y, x
+        except Exception:
+            continue
+
+    return None
+
+
+def extract_voxel_size_mm(image: Any, backend_name: str) -> float:
+    """Return the voxel size in mm from backend image metadata.
+
+    Backend images report spacing in ``(z, y, x)`` order. The connector takes a
+    single voxel size, so the voxels must be cubic.
+    """
+    zyx = None
+    if hasattr(image, "voxel_sizes"):
+        try:
+            voxel_sizes = tuple(float(v) for v in image.voxel_sizes())
+            if len(voxel_sizes) >= 3:
+                zyx = voxel_sizes[:3]
+        except Exception:
+            pass
+
+    if zyx is None and hasattr(image, "get_grid_spacing"):
+        zyx = _spacing_zyx(image.get_grid_spacing())
+        if zyx is None:
+            raise ValueError(
+                f"Unable to read voxel spacing from {backend_name} get_grid_spacing()."
+            )
+
+    if zyx is None:
+        raise ValueError(
+            f"{backend_name} source object must expose voxel_sizes() or "
+            "get_grid_spacing()."
+        )
+    if max(zyx) - min(zyx) > 1e-3:
+        raise ValueError(
+            f"{backend_name} images must have cubic voxels; got (z, y, x) = "
+            f"{tuple(zyx)} mm"
+        )
+    return float(zyx[0])
+
+
+__all__ = ["extract_voxel_size_mm"]

{simind_python_connector-1.1.0 → simind_python_connector-1.1.1}/simind_python_connector/connectors/python_connector.py

@@ -8,6 +8,7 @@ import contextlib
 import logging
 import math
 import os
+import re
 import shutil
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -68,8 +69,11 @@ class SimindPythonConnector(BaseConnector):
         self.output_dir.mkdir(parents=True, exist_ok=True)
         self.output_prefix = output_prefix
         self.quantization_scale = float(quantization_scale)
-        if not math.isfinite(self.quantization_scale) or self.quantization_scale <= 0:
-            raise ValueError("quantization_scale must be > 0")
+        # Above 1 the source would be clipped at MAX_SOURCE, changing its shape.
+        if not 0 < self.quantization_scale <= 1:
+            raise ValueError(
+                f"quantization_scale must be in (0, 1], got {quantization_scale!r}"
+            )
 
         self.config = self._initialize_config(config_source)
         self.runtime_switches = RuntimeSwitches()
@@ -82,16 +86,18 @@ class SimindPythonConnector(BaseConnector):
 
     @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()
+        """Accept only prefixes SIMIND keeps unchanged in its file names.
+
+        SIMIND lowercases file names on Unix, a dot would be taken for a file
+        extension, and glob characters would break output discovery.
+        """
+        if not isinstance(prefix, str) or not re.fullmatch(
+            r"[a-z0-9][a-z0-9_-]*", prefix
         ):
-            raise ValueError(f"output_prefix must be a plain filename, got {prefix!r}")
+            raise ValueError(
+                "output_prefix must contain only lowercase letters, digits, '_' "
+                f"and '-', got {prefix!r}"
+            )
 
     @staticmethod
     def _initialize_config(config_source: ConfigSource) -> SimulationConfig:
@@ -136,7 +142,9 @@ class SimindPythonConnector(BaseConnector):
 
         The projection pixel size and matrix (Index 28, 76, 77) come from the
         configuration, not from the phantom. scoring_routine overrides Index 84;
-        None keeps the configuration value.
+        None keeps the configuration value. The connector reads SPECT Interfile
+        output, so this sets Flag 5 (SPECT) and Flag 14 (Interfile headers).
+        The mu map is taken to be at abs(Index 1) keV.
 
         Returns:
             Tuple of (source_file_path, density_file_path).
@@ -222,7 +230,9 @@ class SimindPythonConnector(BaseConnector):
         cfg.set_data_file(6, src_prefix)
 
         if cfg.get_flag(11):
-            photon_energy = float(cfg.get_value("photon_energy"))
+            # A negative Index 1 asks SIMIND to read photon energies from the
+            # isotope file; its absolute value is still the window energy.
+            photon_energy = abs(float(cfg.get_value("photon_energy")))
             density = attenuation_to_density(mu_map_array, photon_energy) * 1000.0
         else:
             density = np.zeros_like(mu_map_array)
@@ -290,6 +300,10 @@ class SimindPythonConnector(BaseConnector):
                     fov_length_mm,
                 )
 
+        # Outputs are read from SPECT Interfile headers (.h00), which SIMIND
+        # writes only with Flag 5 (SPECT) and Flag 14 (Interfile) set.
+        self.config.set_flag(5, True)
+        self.config.set_flag(14, True)
         config_path = self.output_dir / self.output_prefix
         self.config.save_file(config_path)
 
@@ -415,12 +429,9 @@ class SimindPythonConnector(BaseConnector):
             try:
                 interfile = load_interfile_array(header_path)
             except Exception as exc:
-                self.logger.warning(
-                    "Skipping output %s due to parse/load error: %s",
-                    header_path,
-                    exc,
-                )
-                continue
+                raise RuntimeError(
+                    f"SIMIND output {header_path} could not be read: {exc}"
+                ) from exc
 
             key = self._extract_output_key(header_path)
             outputs[key] = ProjectionResult(
@@ -430,11 +441,6 @@ class SimindPythonConnector(BaseConnector):
                 metadata=interfile.metadata,
             )
 
-        if not outputs:
-            raise RuntimeError(
-                f"No valid outputs were parsed from headers in {self.output_dir}"
-            )
-
         return outputs
 
     def _extract_output_key(self, header_path: Path) -> str: