diffct 1.3.3__tar.gz → 2.0.0__tar.gz

{diffct-1.3.3 → diffct-2.0.0}/.gitignore

@@ -1,187 +1,195 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
-.pdm.toml
-.pdm-python
-.pdm-build/
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
-
-# PyPI configuration file
-.pypirc
-
-# Roo memory bank
-.vscode
-/memory-bank
-.rooignore
-
-# Cline configuration file
-.clinerules-architect
-.clinerules-ask
-.clinerules-code
-.clinerules-debug
-.clinerules-test
-.roomodes
-projectBrief.md
-.kiro
-.claude
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc
+
+# Roo memory bank
+.vscode
+/memory-bank
+.rooignore
+
+# Cline configuration file
+.clinerules-architect
+.clinerules-ask
+.clinerules-code
+.clinerules-debug
+.clinerules-test
+.roomodes
+projectBrief.md
+.kiro
+.claude
+
+# Local GPU / cluster validation evidence
+.validation/
+
+# Manim render output
+docs/video/media/
+docs/video/scenes.txt
+docs/video/palette.png

{diffct-1.3.3 → diffct-2.0.0}/CHANGELOG.md

@@ -5,6 +5,300 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.0] - 2026-10-09
+
+Version 2.0.0 replaces the circular-orbit API of 1.x with arbitrary
+per-view trajectories. It breaks the 1.x interface; see
+[docs/MIGRATION.md](docs/MIGRATION.md).
+
+### Breaking
+
+- ``diffct.Projector`` is the main entry point. Geometry is a tuple of
+  per-view tensors (source, detector centre, detector axes) instead of
+  scalar ``angles``, ``sid`` and ``sdd``.
+- The low-level ``*ProjectorFunction`` / ``*BackprojectorFunction`` classes
+  and the ``*_weighted_backproject`` helpers take per-view geometry tensors.
+- The separable-footprint backends (``sf``, ``sf_tr``, ``sf_tt``) of 1.3.x
+  are removed. All projectors use the matched cell-constant Siddon model.
+
+### Added
+
+- Multi-GPU execution in one process (``devices=[...]``) and one process per
+  GPU with torchrun and NCCL, on one or several nodes.
+- Install extras ``diffct[cu12]`` and ``diffct[cu13]`` pull in the matching
+  numba-cuda CUDA bindings, so one ``pip install`` gives a working import.
+- Measured walnut example (``examples/walnut_reconstruction.py``), intro video
+  and README figures with provenance records in ``docs/assets``.
+- Geometry gradients. Trajectory tensors may require gradients; ``Projector``
+  and the low-level Function classes return gradients for source, detector
+  centre and detector axes (parallel: ray direction, detector origin and
+  axis). CUDA kernels compute the exact derivative of the cell-constant
+  Siddon model from the face crossings of each ray. Distributed mode sums
+  the gradients over ranks.
+- Second derivatives for volumes and sinograms: backward passes are autograd
+  Functions themselves. Second derivatives with respect to the geometry
+  raise ``RuntimeError``.
+
+### Changed
+
+- Detector arrays are centred: cell ``k`` lies at
+  ``(k - (N - 1) / 2) * pitch`` from ``det_center`` (or ``det_origin``), as in
+  ``main``. Earlier dev versions used ``(k - N / 2) * pitch``. The projector,
+  the FBP/FDK gathers and ``detector_coordinates_1d`` all changed.
+- Siddon projections are line integrals in physical length. Earlier
+  versions returned voxel-length integrals, which differ by the factor
+  ``voxel_spacing``. Backprojection scales the same way, so the pair stays
+  matched. Results with ``voxel_spacing == 1`` do not change.
+- FBP and FDK gather kernels sample at voxel centres,
+  ``(index + 0.5 - N / 2) * voxel_spacing``, as the cell-constant Siddon
+  projector does. Earlier reconstructions were half a voxel off.
+- Siddon projector and backprojector kernels no longer skip ray pieces of
+  length ``<= 1e-6``. They skip only pieces of length exactly 0 or less.
+  Forward projection is now a continuous function of the geometry: each piece
+  changes a projection value by at most cell value x ``1e-6``.
+
+### Fixed
+
+- Fan and cone rays integrate only from the source to the detector pixel.
+  A source or detector inside the volume box gave the full-line integral.
+- Fan and cone ray setup measures the ray parameter from the endpoint
+  nearer the volume centre, and the traversal restarts at the volume entry
+  point. A distant source gave relative errors up to 5e-3 (source 1e6
+  voxels away) and could stop the traversal. Parallel-beam setup runs in
+  float64 for a distant detector origin. Projection speed does not change.
+- Ray setup treats a direction component as axis-parallel only below
+  1e-20, so a distant source with a small lateral component is no longer
+  rejected.
+- Siddon kernels use a finite sentinel instead of infinity, because
+  ``fastmath`` lets LLVM assume that infinity never occurs.
+- ``Projector`` rejects fan and cone views whose source coincides with the
+  detector centre or whose detector is edge-on to the source, and views where
+  both lie farther than 1e6 voxels from the volume centre.
+- The traversal treats a direction component as axis-parallel only below
+  1e-20. With the earlier 1e-6 limit, a ray that grazed a grid line was
+  assigned to the neighbouring row.
+- ``tests/distributed_projector_check.py`` no longer issues a MAX
+  all-reduce after a local failure while other ranks wait in a SUM
+  all-reduce.
+
+## [1.3.0.dev0] - 2026-04-14 (dev branch, not released on PyPI)
+
+First sync of the dev (arbitrary-trajectory) branch against the main
+branch's 1.2.10 / 1.2.11 analytical reconstruction overhaul. Brings
+dev up to functional parity with main 1.2.11 except for the 1.3.0
+separable-footprint (SF) projector backends, which rely on closed-form
+circular-orbit geometry and are not yet generalised to arbitrary
+trajectories.
+
+### Added
+
+#### Analytical reconstruction helpers (``diffct.analytical``)
+
+A new module exposes the following helpers, all trajectory-agnostic so
+they work with both the circular trajectories and the arbitrary
+``(src_pos, det_center, det_u_vec[, det_v_vec])`` trajectory arrays
+that dev-branch kernels already accept:
+
+- ``detector_coordinates_1d`` — detector cell centre coordinates.
+- ``angular_integration_weights`` — trapezoidal per-view weights for
+  the analytical FBP/FDK sum. Optional ``redundant_full_scan`` flag
+  absorbs the ``1/2`` redundancy factor for full scans.
+- ``fan_cosine_weights`` / ``cone_cosine_weights`` — per-detector-cell
+  ``cos(gamma)`` pre-weight for fan / cone FBP pipelines.
+- ``parker_weights`` — Parker short-scan redundancy weights for
+  circular fan geometries.
+- ``ramp_filter_1d`` — generic 1D ramp filter with ``sample_spacing``,
+  ``pad_factor``, ``window`` (``"ram-lak"``, ``"hann"``, ``"hamming"``,
+  ``"cosine"``, ``"shepp-logan"``), and ``use_rfft`` options, rescaled
+  by ``1 / sample_spacing`` so the output is in physical units.
+- ``parallel_weighted_backproject`` / ``fan_weighted_backproject`` /
+  ``cone_weighted_backproject`` — voxel-driven FBP / FDK backprojection
+  wrappers that dispatch to new dedicated gather kernels and apply the
+  analytical Fourier-convention constant (``1/(2*pi)`` for parallel,
+  ``sdd_mean/(2*pi*sid_mean)`` for fan and cone). These are the
+  **recommended path for analytical reconstruction** and replace the
+  previous pattern of passing a filtered sinogram through
+  ``*BackprojectorFunction.apply``.
+
+#### Voxel-driven FBP / FDK gather kernels
+
+Three new CUDA kernels, each under the dedicated ``fastmath=False``
+``_FDK_ACCURACY_DECORATOR`` added to ``diffct.constants``:
+
+- ``_parallel_2d_fbp_backproject_kernel`` — no distance weighting.
+- ``_fan_2d_fbp_backproject_kernel`` — ``(|S|/U_n)^2`` weighted,
+  where ``U_n`` is the signed distance from the per-view source to
+  the voxel along the detector normal.
+- ``_cone_3d_fdk_backproject_kernel`` — same pattern in 3D.
+
+Every kernel is voxel-driven: one thread per output pixel/voxel, loops
+over views inside, projects the voxel onto the detector using the
+per-view ``(src_pos, det_center, det_u_vec[, det_v_vec])`` arrays,
+bilinearly samples the filtered sinogram, applies the per-view weight
+and accumulates. They are completely separate from the pure Siddon
+adjoint kernels that back the autograd path; autograd is untouched.
+
+#### Tests (``tests/``)
+
+The dev branch had no test directory at all prior to this change.
+``pytest.ini`` and ``tests/__init__.py`` are new, plus 58 tests across
+11 files that mirror the main-branch test layout:
+
+- ``tests/test_adjoint_inner_product.py`` — ``<A x, y> = <x, A^T y>``
+  identity for parallel / fan / cone autograd pairs, plus an extra
+  ``test_cone_autograd_backward_matches_backprojector_forward`` that
+  protects the autograd ``ConeProjectorFunction.backward`` from
+  drifting away from the standalone ``ConeBackprojectorFunction``.
+- ``tests/test_gradcheck.py`` — ``torch.autograd.gradcheck`` for every
+  projector Function with float32-calibrated tolerances.
+- ``tests/test_weights.py`` — unit tests for ``detector_coordinates_1d``,
+  ``angular_integration_weights``, ``fan_cosine_weights``,
+  ``cone_cosine_weights`` and ``parker_weights``.
+- ``tests/test_cuda_smoke.py`` — end-to-end smoke tests for every
+  Projector / Backprojector Function pair + the analytical
+  ``*_weighted_backproject`` wrappers.
+- ``tests/test_cone_projector_autograd.py`` — gradient finiteness and
+  sparsity guard for the cone projector Function (circular + spiral
+  trajectories).
+- ``tests/test_fbp_parallel_accuracy.py`` /
+  ``tests/test_fbp_fan_accuracy.py`` /
+  ``tests/test_fdk_cone_accuracy.py`` — quantitative RMSE and
+  amplitude bounds for a full Shepp-Logan FBP / FDK pipeline per
+  geometry. These would have tripped on the old dev reconstruction
+  path, which silently produced wrong-amplitude volumes.
+- ``tests/test_fbp_fan_offsets.py`` /
+  ``tests/test_fdk_cone_offsets.py`` — adapted from main's offset
+  tests: dev's arbitrary-trajectory kernels have no scalar
+  ``detector_offset`` / ``center_offset_*`` parameters, so offsets
+  are applied by shifting the trajectory arrays directly. Verifies
+  that the FBP / FDK gather kernels handle non-centred trajectories.
+- ``tests/test_ramp_filter_windows.py`` — 29 parametrised tests covering
+  every ``_ramp_window`` option (DC gain, Nyquist value, non-negativity)
+  and the full ``ramp_filter_1d`` end-to-end (shape, DC annihilation,
+  rfft vs complex-fft parity, ``sample_spacing`` scaling, high-frequency
+  pass-through).
+
+#### Benchmark suite (``tests/benchmarks/``)
+
+Opt-in ``pytest-benchmark`` suite covering every CUDA kernel in the
+library (forward projector, pure-adjoint backprojector, and the full
+analytical FBP / FDK pipeline) across three sizes for each of the
+three geometries. 27 benchmarks total, excluded from the default
+``pytest tests/`` run via ``--ignore=tests/benchmarks`` in
+``pytest.ini``. Run explicitly with
+``pytest tests/benchmarks/ --benchmark-only``.
+
+#### Parker short-scan demos in examples
+
+``examples/circular_trajectory/fbp_fan.py`` and
+``examples/circular_trajectory/fdk_cone.py`` now expose an
+``apply_parker`` switch. When enabled, the example switches the
+trajectory to a minimal ``pi + 2*gamma_max`` short scan and applies
+``parker_weights`` to the sinogram before the ramp filter; when
+disabled, the pipeline runs a full ``2*pi`` scan with the ``1/2``
+redundancy factor absorbed by ``angular_integration_weights``. Both
+branches produce correctly amplitude-calibrated reconstructions.
+
+#### Documentation (``docs/source/api.rst``)
+
+New "Analytical Reconstruction Helpers", "Ramp Filter Options", and
+"Analytical FBP / FDK architecture" sections describe the new
+``diffct.analytical`` module, enumerate every ``ramp_filter_1d``
+option, and explain the analytical scale factors used in each
+``*_weighted_backproject`` wrapper.
+
+### Fixed
+
+#### FBP / FDK amplitude bugs in the ``circular_trajectory/*.py`` examples
+
+Prior to this release the circular-trajectory FBP / FDK examples
+(``examples/circular_trajectory/fbp_parallel.py``,
+``examples/circular_trajectory/fbp_fan.py``,
+``examples/circular_trajectory/fdk_cone.py``) produced amplitude-wrong
+reconstructions because they:
+
+- used ``*BackprojectorFunction.apply`` (the pure Siddon adjoint) as if
+  it were an FBP gather, so they missed the ``(sid/U)^2`` / ``(|S|/U_n)^2``
+  distance weight that the classical FBP / FDK formula requires;
+- hand-rolled a ramp filter missing the ``1/sample_spacing`` scale;
+- multiplied by a standalone ``pi/num_views`` normalisation that only
+  absorbs the angular step, not the ``1/(2*pi)`` Fourier-convention
+  constant.
+
+All three examples now go through the new
+``parallel_weighted_backproject`` / ``fan_weighted_backproject`` /
+``cone_weighted_backproject`` wrappers and end-to-end produce raw MSE
+matching the main branch's 1.2.11 release to within rounding:
+
+| Example                                 | Raw MSE   | Range             |
+|-----------------------------------------|-----------|-------------------|
+| ``circular_trajectory/fbp_parallel.py`` | ~0.00366  | ``[-0.02, 1.00]`` |
+| ``circular_trajectory/fbp_fan.py``      | ~0.00220  | ``[-0.10, 1.01]`` |
+| ``circular_trajectory/fdk_cone.py``     | ~0.00333  | ``[-0.07, 1.00]`` |
+
+### Notes on the sync from ``main``
+
+The ``main`` branch's 1.2.10 / 1.2.11 / 1.3.0 releases introduced several
+changes which this update brings to the dev branch, adapted where
+necessary for the arbitrary-trajectory kernel API:
+
+- ``1.2.10`` FDK / FBP voxel-driven gather, ``ramp_filter_1d`` options,
+  analytical constants, and the ``(sid/U)^2`` correctness fix: **ported**.
+  Because dev's kernels take per-view ``(src_pos, det_center, u_vec,
+  v_vec)`` arrays instead of closed-form ``sin(beta)/cos(beta)`` math,
+  the new gather kernels use ``U_n = (P - S) . n`` (where
+  ``n = u_vec x v_vec``) as the generalisation of the classical ``U``.
+  For a canonical circular orbit this reduces to the textbook
+  ``sid + x*sin(beta) - y*cos(beta)``.
+- ``1.2.10`` cone / fan autograd ``distance_weight=1.0`` bug fix:
+  **not applicable**. The dev cone / fan backward kernels were
+  already correct (they never had that parameter), so the autograd
+  adjoint identity holds on dev and is now protected by
+  ``tests/test_adjoint_inner_product.py``.
+- ``1.2.11`` gradcheck / ramp window tests / CHANGELOG: **ported**.
+- ``1.2.11`` benchmark suite: **not ported yet** (dev's benchmarks
+  directory stays empty).
+- ``1.3.0`` SF-TR / SF-TT projector backends: **not ported**. SF relies
+  on closed-form ``sin(beta)/cos(beta)`` math for the trapezoidal
+  transaxial / rectangular axial footprints. Generalising SF to
+  arbitrary per-view ``(S, C, u_vec, v_vec)`` trajectories is a
+  non-trivial research effort (the "separable" part is not separable
+  when the detector is not plane-aligned to the voxel axes) and will
+  be tackled in a dedicated follow-up.
+
+[Unreleased]: https://github.com/sypsyp97/diffct/tree/dev
+
+## [1.3.4] - 2026-04-23
+
+### Changed
+- **Siddon projectors switched to cell-constant integration.** The 2D
+  parallel, 2D fan, and 3D cone Siddon forward/backward kernels in
+  `diffct/differentiable.py` now integrate each ray by accumulating
+  `d_image[iy, ix] * seg_len` on the traversed pixel/voxel instead of
+  sampling the bi-/tri-linear interpolant at the segment midpoint.
+  This simplifies the inner loop, removes the interpolation weight
+  bookkeeping, and keeps the forward / adjoint pair matched by
+  construction (still verified by
+  `tests/test_adjoint_inner_product.py`). Kernel docstrings and the
+  `"siddon"` backend blurbs in `examples/iterative_reco_*.py` have
+  been updated to say *cell-constant Siddon*.
+- **Iterative examples clamp the reconstruction in-place** instead of
+  wrapping the forward pass in `nn.ReLU`. `examples/iterative_reco_parallel.py`,
+  `iterative_reco_fan.py`, and `iterative_reco_cone.py` now call
+  `self.model.reco.clamp_(min=0.0)` under `torch.no_grad()` after each
+  optimizer step, so gradients flow through the unclamped volume while
+  the stored state stays non-negative.
+- **`examples/iterative_reco_fan.py` default backend** is now
+  `"siddon"` (was `"sf"`), matching the parallel and cone iterative
+  examples.
+
+### Fixed
+- **FDK cone accuracy test tolerance.** `tests/test_fdk_cone_accuracy.py`
+  raises the maximum central z-profile error bound from `0.6` to `0.65`
+  to reflect the slightly sharper one-sample transition error at
+  ellipsoid boundaries under cell-constant forward projection; global
+  FDK RMSE is unchanged.
+
 ## [1.3.3] - 2026-04-23
 
 ### Fixed