diffct 2.0.0__py3-none-any.whl

diffct/utils.py

@@ -0,0 +1,357 @@
+"""Utility classes and helper functions for diffct package.
+
+This module provides utility classes and functions for device management,
+PyTorch-CUDA bridging, stream caching, trigonometric table generation,
+memory layout validation, and CUDA grid computation.
+"""
+
+import math
+import numpy as np
+import torch
+from numba import cuda
+
+from .constants import _DTYPE, _TPB_2D, _TPB_3D, _INF, _EPSILON
+
+
+# ============================================================================
+# Device Management Utilities
+# ============================================================================
+
+class DeviceManager:
+    """Utilities for managing PyTorch tensor devices."""
+
+    @staticmethod
+    def get_device(tensor):
+        """Get the device of a PyTorch tensor.
+
+        Parameters
+        ----------
+        tensor : torch.Tensor
+            Tensor whose device to determine.
+
+        Returns
+        -------
+        torch.device
+            Device of the tensor or CPU if unavailable.
+
+        Examples
+        --------
+        >>> DeviceManager.get_device(torch.tensor([1, 2, 3]))
+        device(type='cpu')
+        """
+        return tensor.device if hasattr(tensor, "device") else torch.device("cpu")
+
+    @staticmethod
+    def ensure_device(tensor, device):
+        """Ensure a tensor resides on a given device.
+
+        Parameters
+        ----------
+        tensor : torch.Tensor
+            Tensor to move.
+        device : torch.device
+            Desired device.
+
+        Returns
+        -------
+        torch.Tensor
+            Tensor on the specified device. Unchanged if already on it.
+
+        Examples
+        --------
+        >>> DeviceManager.ensure_device(
+        ...     torch.tensor([1, 2, 3]),
+        ...     torch.device('cuda')
+        ... )
+        tensor([1, 2, 3], device='cuda:0')
+        """
+        if hasattr(tensor, "to") and tensor.device != device:
+            return tensor.to(device)
+        return tensor
+
+
+# ============================================================================
+# PyTorch-CUDA Bridge
+# ============================================================================
+
+class TorchCUDABridge:
+    """Bridge between PyTorch tensors and Numba CUDA arrays."""
+
+    @staticmethod
+    def tensor_to_cuda_array(tensor):
+        """Convert a PyTorch CUDA tensor to a Numba CUDA DeviceNDArray.
+
+        Provides a zero-copy view of a detached PyTorch tensor as a Numba CUDA array,
+        avoiding CPU data transfers. The returned array shares memory with the
+        original tensor.
+
+        Parameters
+        ----------
+        tensor : torch.Tensor
+            PyTorch tensor on a CUDA device.
+
+        Returns
+        -------
+        numba.cuda.cudadrv.devicearray.DeviceNDArray
+            Numba CUDA array view sharing memory with `tensor`.
+
+        Raises
+        ------
+        ValueError
+            If `tensor` is not on a CUDA device.
+
+        Examples
+        --------
+        >>> t = torch.randn(10, device='cuda')
+        >>> arr = TorchCUDABridge.tensor_to_cuda_array(t)
+        """
+        if not tensor.is_cuda:
+            raise ValueError("Tensor must be on CUDA device")
+        return cuda.as_cuda_array(tensor.detach())
+
+
+# ============================================================================
+# Stream Management (cached external Numba stream)
+# ============================================================================
+
+_cached_stream_ptr = None
+_cached_numba_stream = None
+
+
+def _get_numba_external_stream_for(pt_stream=None):
+    """Return a cached numba.cuda.external_stream for the current PyTorch CUDA stream.
+
+    Caches by the CUDA device and stream pointer to avoid repeated construction.
+
+    Parameters
+    ----------
+    pt_stream : torch.cuda.Stream, optional
+        PyTorch CUDA stream. If None, uses current stream.
+
+    Returns
+    -------
+    numba.cuda.cudadrv.driver.Stream
+        Numba external stream wrapper around PyTorch CUDA stream.
+    """
+    global _cached_stream_ptr, _cached_numba_stream
+    if pt_stream is None:
+        pt_stream = torch.cuda.current_stream()
+    # A stream pointer is only unique within one CUDA device.
+    ptr = int(pt_stream.cuda_stream)
+    device_index = pt_stream.device.index
+    if device_index is None:
+        device_index = torch.cuda.current_device()
+    key = (device_index, ptr)
+    if _cached_stream_ptr == key and _cached_numba_stream is not None:
+        return _cached_numba_stream
+    numba_stream = cuda.external_stream(pt_stream.cuda_stream)
+    _cached_stream_ptr = key
+    _cached_numba_stream = numba_stream
+    return numba_stream
+
+
+# ============================================================================
+# GPU-aware Trigonometric Table Generation
+# ============================================================================
+
+def _trig_tables(angles, dtype=_DTYPE, device=None):
+    """Compute cosine and sine tables for input angles.
+
+    Precompute cosine and sine values and return as torch tensors on the
+    same device as `angles`.
+
+    Parameters
+    ----------
+    angles : array-like or torch.Tensor
+        Projection angles in radians. Can be a NumPy array or a PyTorch tensor on CPU or CUDA.
+    dtype : numpy.dtype or torch.dtype, optional
+        Desired data type for output tables. Default is `_DTYPE`.
+    device : torch.device, optional
+        Target device for output tensors. If None, uses the device of `angles`.
+
+    Returns
+    -------
+    cos : torch.Tensor
+        Cosine values of `angles` on the same device.
+    sin : torch.Tensor
+        Sine values of `angles` on the same device.
+
+    Examples
+    --------
+    >>> angles = torch.linspace(0, torch.pi, 180, device='cuda')
+    >>> cos, sin = _trig_tables(angles)
+    >>> cos.device
+    device(type='cuda', index=0)
+    """
+    if isinstance(angles, torch.Tensor):
+        device = angles.device if device is None else device
+        # Compute both cos and sin in one call to avoid redundant kernel launches
+        angles_device = angles.to(dtype=dtype, device=device)
+        cos = torch.cos(angles_device)
+        sin = torch.sin(angles_device)
+        return cos, sin
+    else:
+        # fallback for non-tensor inputs: compute via PyTorch on CPU for consistency
+        # Determine desired torch dtype
+        if isinstance(dtype, torch.dtype):
+            torch_dtype = dtype
+        else:
+            _NP_TO_TORCH = {
+                np.float32: torch.float32,
+                np.float64: torch.float64,
+            }
+            torch_dtype = _NP_TO_TORCH.get(dtype, torch.float32)
+        # Convert input angles to a CPU torch tensor and compute both simultaneously
+        angles_cpu = torch.tensor(angles, dtype=torch_dtype)
+        cos_cpu = torch.cos(angles_cpu)
+        sin_cpu = torch.sin(angles_cpu)
+        if device is not None:
+            return cos_cpu.to(device), sin_cpu.to(device)
+        else:
+            return cos_cpu, sin_cpu
+
+
+# ============================================================================
+# Memory Layout Validation
+# ============================================================================
+
+def _validate_3d_memory_layout(tensor, expected_order='DHW'):
+    """Validate 3D tensor memory layout to prevent coordinate system inconsistencies.
+
+    Parameters
+    ----------
+    tensor : torch.Tensor
+        3D tensor to validate
+    expected_order : str, optional
+        Expected memory order ('DHW', 'VHW', etc.). Default is 'DHW'.
+
+    Raises
+    ------
+    ValueError
+        If tensor has unexpected memory layout or is non-contiguous
+    """
+    shape = tensor.shape
+    if len(shape) != 3:
+        raise ValueError(f"Expected 3D tensor, got {len(shape)}D")
+
+    # Early return for common case - contiguous tensor with expected ordering
+    if tensor.is_contiguous() and expected_order in ('DHW', 'VHW'):
+        # For DHW and VHW, the expected order matches memory layout when contiguous
+        return
+
+    # Only check memory order for DHW and VHW, not for internal WHD layout
+    if expected_order in ('DHW', 'VHW'):
+        if not tensor.is_contiguous():
+            raise ValueError(
+                "Input tensor must be contiguous. Call .contiguous() before passing to "
+                "cone beam functions to avoid memory duplication and ensure correct results."
+            )
+
+        strides = tensor.stride()
+        order_mapping = {
+            'DHW': (0, 1, 2),  # Depth, Height, Width
+            'VHW': (0, 1, 2),  # Views, Height, Width (for sinograms)
+        }
+        if expected_order not in order_mapping:
+            raise ValueError(f"Unsupported expected_order: {expected_order}")
+
+        expected_stride_order = order_mapping[expected_order]
+        # Check if actual strides match expected order
+        sorted_strides = sorted(enumerate(strides), key=lambda x: x[1], reverse=True)
+        actual_order = tuple(idx for idx, _ in sorted_strides)
+
+        if actual_order != expected_stride_order:
+            # Create appropriate error message based on context
+            if expected_order == 'VHW':
+                actual_str = f"({shape[0]}, {shape[1]}, {shape[2]})"
+                expected_str = "(Views, Height, Width)"
+                fix_str = "ensure your sinogram has shape (num_views, det_v, det_u)"
+            elif expected_order == 'DHW':
+                actual_str = f"({shape[0]}, {shape[1]}, {shape[2]})"
+                expected_str = "(Depth, Height, Width)"
+                fix_str = "ensure your volume has shape (D, H, W)"
+            else:
+                actual_str = str(tuple(shape))
+                expected_str = expected_order
+                fix_str = "check tensor dimensions"
+
+            raise ValueError(
+                f"Memory layout mismatch: expected {expected_str} order, "
+                f"but tensor has shape {actual_str}. Please {fix_str} and ensure "
+                f"the tensor is contiguous (.contiguous()) before passing to the function."
+            )
+    # For 'WHD' (internal layout), skip stride check entirely
+
+
+# ============================================================================
+# CUDA Grid Computation
+# ============================================================================
+
+def _grid_2d(n1, n2, tpb=_TPB_2D):
+    """Compute 2D CUDA grid and block dimensions.
+
+    Determine optimal grid and block sizes for 2D CUDA ray-tracing kernels.
+
+    Parameters
+    ----------
+    n1 : int
+        Number of elements along the first dimension (e.g., projection angles).
+    n2 : int
+        Number of elements along the second dimension (e.g., detector elements).
+    tpb : tuple of int, optional
+        Threads per block (default is `_TPB_2D`) to balance occupancy and memory.
+
+    Returns
+    -------
+    grid : tuple of int
+        Blocks count per axis.
+    tpb : tuple of int
+        Threads per block per axis.
+
+    Examples
+    --------
+    >>> grid, tpb = _grid_2d(180, 256)
+    >>> grid
+    (12, 16)
+    >>> tpb
+    (16, 16)
+    """
+    return (math.ceil(n1 / tpb[0]), math.ceil(n2 / tpb[1])), tpb
+
+
+def _grid_3d(n1, n2, n3, tpb=_TPB_3D):
+    """Compute 3D CUDA grid and block dimensions.
+
+    Determine optimal grid and block sizes for 3D CUDA cone-beam kernels.
+
+    Parameters
+    ----------
+    n1 : int
+        Number of elements along the first dimension (e.g., projection views).
+    n2 : int
+        Number of elements along the second dimension (e.g., detector u-axis).
+    n3 : int
+        Number of elements along the third dimension (e.g., detector v-axis).
+    tpb : tuple of int, optional
+        Threads per block (default is `_TPB_3D`) to balance occupancy and registers.
+
+    Returns
+    -------
+    grid : tuple of int
+        Blocks count per axis.
+    tpb : tuple of int
+        Threads per block per axis.
+
+    Examples
+    --------
+    >>> grid, tpb = _grid_3d(360, 256, 256)
+    >>> grid
+    (45, 32, 32)
+    >>> tpb
+    (8, 8, 8)
+    """
+    return (
+        math.ceil(n1 / tpb[0]),
+        math.ceil(n2 / tpb[1]),
+        math.ceil(n3 / tpb[2]),
+    ), tpb

diffct-2.0.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.5
+Name: diffct
+Version: 2.0.0
+Summary: Differentiable CUDA projectors for CT: arbitrary trajectories, multi-GPU and multi-node execution, geometry gradients
+Project-URL: Homepage, https://github.com/sypsyp97/diffct
+Project-URL: Documentation, https://sypsyp97.github.io/diffct/
+Project-URL: Changelog, https://github.com/sypsyp97/diffct/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/sypsyp97/diffct/issues
+Author-email: Yipeng Sun <yipeng.sun@fau.de>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: CT reconstruction,CUDA,PyTorch,computed tomography,differentiable programming
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.10
+Requires-Dist: numba
+Requires-Dist: numba-cuda
+Requires-Dist: numpy<2.5
+Requires-Dist: torch
+Provides-Extra: cu12
+Requires-Dist: numba-cuda[cu12]; extra == 'cu12'
+Provides-Extra: cu13
+Requires-Dist: numba-cuda[cu13]; extra == 'cu13'
+Description-Content-Type: text/markdown
+
+<h1 align="center">diffct</h1>
+
+<p align="center">English · <a href="README.zh.md">简体中文</a></p>
+
+<p align="center">
+  Differentiable CUDA projectors for CT: arbitrary trajectories, multi-GPU, multi-node, geometry gradients.
+</p>
+
+<p align="center">
+  <a href="https://opensource.org/licenses/Apache-2.0"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg?style=flat-square" alt="License"></a>
+  <a href="https://doi.org/10.5281/zenodo.14999333"><img src="https://img.shields.io/badge/DOI-10.5281%2Fzenodo.14999333-blue.svg?style=flat-square" alt="DOI"></a>
+  <a href="https://pypi.org/project/diffct/"><img src="https://img.shields.io/pypi/v/diffct.svg?style=flat-square&logo=pypi&logoColor=white" alt="PyPI version"></a>
+  <a href="https://sypsyp97.github.io/diffct/"><img src="https://img.shields.io/github/actions/workflow/status/sypsyp97/diffct/docs.yml?branch=main&label=docs&style=flat-square" alt="Documentation"></a>
+  <a href="https://github.com/sypsyp97/diffct/actions"><img src="https://img.shields.io/github/actions/workflow/status/sypsyp97/diffct/ci.yml?branch=main&label=CI&style=flat-square" alt="CI/CD"></a>
+  <a href="https://deepwiki.com/sypsyp97/diffct"><img src="docs/assets/deepwiki-badge.svg" alt="Ask DeepWiki"></a>
+</p>
+
+<p align="center">
+  <img src="docs/assets/diffct_intro.gif" width="100%" alt="diffct intro: projection, sinogram, trajectories, multi-GPU split, reconstruction and geometry calibration">
+</p>
+
+<p align="center">
+  <a href="docs/assets/diffct_intro.mp4">Intro video (MP4)</a> ·
+  <a href="https://www.preprints.org/manuscript/202605.1446/v1">Technical report</a> ·
+  <a href="https://doi.org/10.20944/preprints202605.1446.v1">DOI</a>
+</p>
+
+<p align="center">
+  <a href="#install">Install</a> ·
+  <a href="#quickstart">Quickstart</a> ·
+  <a href="#why-diffct">Features</a> ·
+  <a href="#performance">Performance</a> ·
+  <a href="#examples">Examples</a> ·
+  <a href="#citation">Citation</a>
+</p>
+
+> **Version 2.0** replaces the circular-orbit API of 1.x with per-view trajectories. Code written for 1.x needs changes; see the [migration notes](docs/MIGRATION.md).
+> For Apple Silicon, use the [MLX port by Linda-Sophie Schneider](https://github.com/Linda-SophieSchneider/DiffCT-MLX).
+
+## Why diffct
+
+To our knowledge, diffct is the only open-source GPU CT library that combines arbitrary per-view trajectories, autograd through the volume, first-order gradients through the acquisition geometry, and built-in multi-GPU and multi-node execution. We compared it with LEAP, TIGRE, ASTRA/tomosipo, DiffDRR and others in October 2026.
+
+- **Arbitrary trajectories.** Each view has its own source, detector centre and detector axes. Circular, helical, saddle, sinusoidal, random and calibrated scans use the same code. Trajectory tensors with `requires_grad=True` receive geometry gradients for calibration.
+- **Matched operators.** `project()` and `backproject()` form an exact adjoint pair for the cell-constant Siddon model. Both support PyTorch autograd, with volume/sinogram gradients and Hessian-vector products.
+- **Multi-GPU and multi-node.** Use `devices=[0, 1, 2, 3]` in one process, or one process per GPU with torchrun and NCCL. Views are partitioned and the volume is replicated. Speedup depends on workload and communication costs.
+- **Analytical helpers.** `diffct.analytical` provides ramp filters (ram-lak, shepp-logan, cosine, hamming, hann), fan, cone and Parker weights, and FBP and FDK backprojection.
+- **Validated.** FDK matches ASTRA 2.5.0 `FDK_CUDA`: PSNR within 0.3 dB. Geometry gradients match an independent float64 reference to about 1e-6. The [recorded A100 validation](docs/VALIDATION.md) reports 229 passing pytest tests. Full notes: [REFERENCE](docs/REFERENCE.md#validation-summary).
+
+Capabilities, limits and isocenter rules: [docs/REFERENCE.md](docs/REFERENCE.md#capabilities-and-limits).
+
+## Install
+
+You need a CUDA GPU and PyTorch. Install PyTorch for your CUDA version first.
+
+```bash
+pip install "diffct[cu12]"    # [cu13] for CUDA 13; install PyTorch for your CUDA first
+```
+
+From source, with the examples:
+
+```bash
+git clone https://github.com/sypsyp97/diffct.git
+cd diffct && pip install -e ".[cu12]"
+python examples/quickstart.py               # smoke test: prints adjoint mismatch ~1e-8 for each beam
+```
+
+<details>
+<summary>Notes on CUDA versions</summary>
+
+- Numba CUDA imports `numpy.row_stack`, which NumPy 2.5 removes. Keep
+  `numpy<2.5`.
+- Keep NVVM and NVJitLink compatible with the CUDA libraries that PyTorch
+  loads. A newer NVVM with an older NVJitLink fails when the kernels compile.
+- A tested CUDA 13 set:
+  `pip install "numpy<2.5" "numba-cuda[cu13]" "cuda-toolkit[cccl,cudart,nvrtc,nvvm]==13.0.2" "nvidia-nvjitlink<13.1"`.
+- A tested CUDA 12 set: PyTorch 2.10 (cu126) with `numba-cuda[cu12]` 0.30.4 on
+  NVIDIA driver 535.
+
+</details>
+
+## Quickstart
+
+Create the acquisition once. Then call `project()` and `backproject()`.
+
+```python
+import torch
+from diffct import Projector, spiral_trajectory_3d
+
+trajectory = spiral_trajectory_3d(360, sid=320.0, sdd=512.0, z_range=40.0, n_turns=1.0, device="cpu")
+A = Projector(trajectory, volume_shape=(128, 128, 128), detector_shape=(384, 256), detector_spacing=0.8)
+
+volume = torch.rand(A.volume_shape, device="cuda")
+sinogram = A.project(volume)        # (360, 384, 256) line integrals
+adjoint = A.backproject(sinogram)   # matched adjoint A^T
+
+x = torch.zeros_like(volume, requires_grad=True)
+loss = 0.5 * (A.project(x) - sinogram).square().sum()
+loss.backward()                     # x.grad = A^T (A x - y)
+```
+
+**Custom or calibrated trajectories.** Pass calibrated tensors directly instead of a generator; no circular fit is needed. See [REFERENCE](docs/REFERENCE.md#custom-or-calibrated-trajectories).
+
+**Geometry gradients.** Set `requires_grad=True` on trajectory tensors before you build `Projector`. See [REFERENCE](docs/REFERENCE.md#geometry-gradients).
+
+**Several GPUs and nodes.** Use `devices=[0, 1, 2, 3]` in one process, or one process per GPU with torchrun for one or more nodes. See [REFERENCE](docs/REFERENCE.md#several-gpus-and-nodes) and [DISTRIBUTED.md](docs/DISTRIBUTED.md).
+
+```python
+A = Projector(trajectory, (128, 128, 128), (384, 256), detector_spacing=0.8, devices=[0, 1, 2, 3])
+```
+
+## Performance
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/assets/scaling_dark.png">
+    <img src="docs/assets/scaling_light.png" width="100%" alt="Time per forward, adjoint and CGLS iteration on 1, 4 and 8 GPUs, 64^3 and 128^3">
+  </picture>
+</p>
+
+| 128³ volume | 1 GPU | 4 GPUs, 1 node | 8 GPUs, 2 nodes |
+|---|---:|---:|---:|
+| Forward projection | 8.45 ms | 2.66 ms (3.2×) | 1.68 ms (5.0×) |
+| Adjoint (backprojection) | 20.66 ms | 5.89 ms (3.5×) | 4.62 ms (4.5×) |
+| CGLS iteration | 30.08 ms | 8.08 ms (3.7×) | 5.59 ms (5.4×) |
+
+Circular trajectory, 360 views, detector (2n, 1.5n) cells at pitch 1.25, A100 64 GB on Leonardo Booster. Small volumes scale less: at 64³, one CGLS iteration takes 4.63 ms on 1 GPU, 1.57 ms on 4 and 1.56 ms on 8. Raw data: [docs/assets/scaling.json](docs/assets/scaling.json).
+
+To measure one against several GPUs on your machine (default scan of the script, not the table setup):
+
+```bash
+python examples/benchmark_projector.py --devices 0 1
+```
+
+## Gallery
+
+**Measured walnut.** 240 measured views, circular cone beam, 256³: FDK (Hann window), SIRT (200 iterations), CGLS (20), TV (300, weight 0.3); axial and coronal centre slices.
+
+<p align="center">
+  <img src="docs/assets/walnut_measured.png" width="100%" alt="Measured walnut: FDK, SIRT, CGLS and TV reconstructions">
+</p>
+
+```bash
+python examples/walnut_reconstruction.py --figure out.png
+```
+
+**Simulated helical scan of the walnut.** The FDK walnut volume as ground truth, 720 views, 1% noise, 256³. PSNR: FDK 26.67 dB, CGLS (30 iterations) 34.13 dB, SIRT (200) 34.52 dB, TV (200, weight 1.0) 37.77 dB.
+
+<p align="center">
+  <img src="docs/assets/walnut_helical.png" width="100%" alt="Simulated helical scan of the walnut: FDK, CGLS, SIRT and TV reconstructions">
+</p>
+
+```bash
+python examples/walnut_reconstruction.py --algorithms --save-volume walnut256.npy
+python examples/iterative_reconstruction.py --size 256 --views 720 --trajectory helical --noise 0.01 --phantom walnut256.npy --figure out.png
+```
+
+Walnut data: Meaney 2022, Zenodo 6986012, CC BY 4.0; see [examples/data/NOTICE](examples/data/NOTICE).
+
+## Examples
+
+`quickstart.py`, `analytical_reconstruction.py`, `iterative_reconstruction.py`, `walnut_reconstruction.py`, `geometry_calibration.py`, `benchmark_projector.py`, `plot_trajectory.py`, and the Slurm template `slurm/multi_node.sbatch`. Launch modes, distributed-loss rules and measured results are in [examples/README.md](examples/README.md).
+
+## Documentation
+
+| Document | Contents |
+|---|---|
+| [Trajectory guide](docs/source/trajectories.rst) | Trajectory tuples and `Projector` usage |
+| [docs/REFERENCE.md](docs/REFERENCE.md) | Capabilities and limits, custom trajectories, geometry gradients, multi-GPU details, geometry and units |
+| [docs/DISTRIBUTED.md](docs/DISTRIBUTED.md) | Execution/memory choices, distributed loss rules, Slurm and cross-node checks |
+| [docs/VALIDATION.md](docs/VALIDATION.md) | Test commands, validation details and the limits of each check |
+| [docs/MIGRATION.md](docs/MIGRATION.md) | Moving from the circular-only API |
+| [docs/video/README.md](docs/video/README.md) | How the intro video is rendered |
+| [CHANGELOG.md](CHANGELOG.md) | Release history |
+
+Run the test suite on a CUDA host with `python -m pytest tests/ -q`.
+
+## Citation
+
+If you use this library in your research, please cite the software and the technical report:
+
+```bibtex
+@software{diffct2025,
+  author    = {Yipeng Sun},
+  title     = {diffct: Differentiable Computed Tomography Reconstruction with CUDA},
+  year      = 2025,
+  publisher = {Zenodo},
+  doi       = {10.5281/zenodo.14999333},
+  url       = {https://doi.org/10.5281/zenodo.14999333}
+}
+
+@article{202605.1446,
+  doi       = {10.20944/preprints202605.1446.v1},
+  url       = {https://doi.org/10.20944/preprints202605.1446.v1},
+  year      = 2026,
+  month     = {May},
+  publisher = {Preprints},
+  author    = {Yipeng Sun and Linda-Sophie Schneider and Chengze ye and Andreas Maier},
+  title     = {diffct: Differentiable CT Operators from Circular Orbits to Arbitrary Trajectories},
+  journal   = {Preprints}
+}
+```
+
+## License and acknowledgements
+
+Apache 2.0, see [LICENSE](LICENSE). The project draws on
+[PYRO-NN](https://github.com/csyben/PYRO-NN) and
+[geometry_gradients_CT](https://github.com/mareikethies/geometry_gradients_CT).
+Issues and pull requests are welcome. The walnut data are CC BY 4.0 (Meaney 2022); see [NOTICE](NOTICE).

diffct-2.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+diffct/__init__.py,sha256=dvV3ttkCyMsaINHz1oBB-I_e9OLM6LYOR0RpG1tVlDo,2191
+diffct/analytical.py,sha256=lNY3lzzauxo6XbCYdwZ5mY7zqFXKlVAt1vxoHPpCdEE,25106
+diffct/constants.py,sha256=IKC_0u9aoNCG4M13KcRrl2plO0dTiokac-2aCYJJMb4,3060
+diffct/differentiable.py,sha256=cFirhqXRpUemL7y7Sl_0uqZKGJNj__ptQEcTwYNKzys,1879
+diffct/geometry.py,sha256=uN6J5fO4I4_dF3ecGP5IUaQIB7_odPocbr2_AKd3r5U,37576
+diffct/operators.py,sha256=BfBkZpAXhWoCxOPgPF0VfNp1atenNYDTphM5Q6Xy2ns,24602
+diffct/projectors.py,sha256=9-kLHYJFeohz-fhKZiYFyRNY7vOKnRplazpnNfIhckc,41108
+diffct/utils.py,sha256=bfrmO_HlHmDkUQQQ0yf_fk-OSidSKRBpYUMNAnYxW_Q,11988
+diffct/kernels/__init__.py,sha256=PhdgiZEyPzdnJ6tVmX6zzUvQH4EESwW8rfC_jCTlzhU,1106
+diffct/kernels/cone_beam.py,sha256=TBtjX51f-WkaFqm6umQfr6zm2JQGjFIDsgs-skMj090,24620
+diffct/kernels/fan_beam.py,sha256=5rRdIiqYL7ghJkk-MGlW5kfcznUlZhoOA-NKZtFhPJ4,16498
+diffct/kernels/geometry_vjp.py,sha256=K8pKSqqw86ejvDkv-VLnv_qvxfWzs9IentSr6SROYe4,19102
+diffct/kernels/parallel_beam.py,sha256=k6lOCAPvY1F9P9E2d-dYPx55328-66OKQ-MhPuP7hmw,16517
+diffct-2.0.0.dist-info/METADATA,sha256=wj5VNajRfnkDnnJ2LvXyiMyBLblY2VvwZW2SPLvLBMk,12096
+diffct-2.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+diffct-2.0.0.dist-info/licenses/LICENSE,sha256=a1fjzGs44LpDnV_LmA2Tzp8z-eJKoNVVdLOnh-F6J6E,11344
+diffct-2.0.0.dist-info/licenses/NOTICE,sha256=du9I2sDF5IDfiY9vF64WWzMJh-MarpVXyLfWQmhbvmI,714
+diffct-2.0.0.dist-info/RECORD,,

diffct-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any