midas-calibrate 0.2.1__tar.gz

midas_calibrate-0.2.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: midas-calibrate
+Version: 0.2.1
+Summary: Native Python/Torch detector calibration for MIDAS — replaces AutoCalibrateZarr → CalibrantIntegratorOMP. CPU & GPU; LM-based refinement.
+Author: MIDAS contributors
+License: BSD-3-Clause
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.9
+Requires-Dist: torch>=2.1
+Requires-Dist: midas-hkls>=0.1.0
+Requires-Dist: midas-integrate>=0.1.0
+Requires-Dist: midas-peakfit>=0.2.0
+Requires-Dist: h5py>=3.0
+Requires-Dist: tifffile>=2022.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pandas>=1.5; extra == "dev"
+Provides-Extra: plots
+Requires-Dist: matplotlib>=3.5; extra == "plots"
+
+# midas-calibrate
+
+Native Python/Torch detector geometry calibration for MIDAS. Replaces
+`AutoCalibrateZarr → CalibrantIntegratorOMP → CalibrationCore`. Same input
+parameter file format, byte-compatible output, runs on CPU or GPU.
+
+## Quick start
+
+```python
+import tifffile
+from midas_calibrate import CalibrationParams, autocalibrate
+
+params = CalibrationParams.from_file("calib.txt")
+image = tifffile.imread("ceo2_calibrant.tif")
+result = autocalibrate(params, image)
+
+result.params.write("calib_refined.txt")
+print(f"final mean strain: {result.history[-1].mean_strain_uE:.1f} μϵ")
+```
+
+CLI:
+
+```bash
+midas-autocalibrate calib.txt --image ceo2.tif --output calib_refined.txt
+```
+
+## How it works
+
+* **E-step** — `midas-integrate` builds a CSR pixel→bin map from the current
+  geometry and integrates the image into a 2D (R, η) cake. Per (ring × η-bin)
+  the radial peak position is extracted via weighted centroid.
+* **M-step** — fit detector geometry to the (Y_pix, Z_pix, ring) data using a
+  custom batched Levenberg-Marquardt solver (`midas_peakfit.lm_solve_generic`)
+  with sigmoid-bounded reparameterisation, Cholesky_ex, and optional Huber
+  loss reshaping.
+* **Orchestrator** — alternating E↔M iterations with optional σ-clip outlier
+  rejection between iterations.
+
+The geometry forward model in [`geometry_torch.py`](midas_calibrate/geometry_torch.py)
+is a byte-for-byte port of `midas_integrate.geometry.pixel_to_REta` — verified
+to fp64 epsilon by parity tests.
+
+## Dependencies
+
+- [`midas-hkls`](../midas_hkls) — pure-Python crystallography (sginfo replacement)
+- [`midas-integrate`](../midas_integrate) — CSR pixel→bin mapper + integration
+- [`midas-peakfit`](../midas_peakfit) ≥ 0.2.0 — generic LM solver
+
+## Synthetic-data parity test
+
+The end-to-end synthetic test forward-simulates a CeO₂ calibrant image at
+known geometry, perturbs the seed (Lsd ±300μm, BC ±1.5px, tilts ±0.06°), and
+verifies recovery:
+
+```
+[iter 0] n_fits= 176  rc=0  strain=  105.2μϵ  Lsd=1000219.4  BC=(512.20,511.91)  ty=0.343  tz=0.180
+[iter 1] n_fits= 176  rc=0  strain=   25.7μϵ  Lsd= 999973.5  BC=(512.01,512.00)  ty=0.403  tz=0.250
+[iter 2] n_fits= 176  rc=0  strain=   19.4μϵ  Lsd= 999946.1  BC=(511.99,512.00)  ty=0.400  tz=0.267
+[iter 3] n_fits= 176  rc=0  strain=   21.6μϵ  Lsd= 999918.1  BC=(511.99,512.00)  ty=0.392  tz=0.285
+```
+
+Final recovery: Lsd within 82μm of truth, BC within 0.01 px, tilts within
+0.04°. Mean strain 21.6μϵ, well under the 50μϵ MIDAS calibration target.
+
+## Engines
+
+`autocalibrate` is the alternating E↔M engine (default).
+
+`autocalibrate_joint` will be the fully differentiable engine — geometry +
+per-(ring × η-bin) peak-shape parameters jointly refined in one batched
+Schur-complement-reduced LM (see §13 of the design doc). v0.1 ships with a
+working stub that delegates to the alternating engine; the arrowhead-LM
+infrastructure (`midas_peakfit.lm_solve_arrowhead`) is in place and tested.
+
+## Status
+
+v0.1.0 — alternating engine production-ready, joint engine scaffolded.
+
+See [`AutoCalibrate.md`](../../manuals/AutoCalibrate.md) for the manual and
+[`calibrate_torch_implementation_plan.md`](../../calibrate_torch_implementation_plan.md)
+for the full design and roadmap.

midas_calibrate-0.2.1/README.md

@@ -0,0 +1,81 @@
+# midas-calibrate
+
+Native Python/Torch detector geometry calibration for MIDAS. Replaces
+`AutoCalibrateZarr → CalibrantIntegratorOMP → CalibrationCore`. Same input
+parameter file format, byte-compatible output, runs on CPU or GPU.
+
+## Quick start
+
+```python
+import tifffile
+from midas_calibrate import CalibrationParams, autocalibrate
+
+params = CalibrationParams.from_file("calib.txt")
+image = tifffile.imread("ceo2_calibrant.tif")
+result = autocalibrate(params, image)
+
+result.params.write("calib_refined.txt")
+print(f"final mean strain: {result.history[-1].mean_strain_uE:.1f} μϵ")
+```
+
+CLI:
+
+```bash
+midas-autocalibrate calib.txt --image ceo2.tif --output calib_refined.txt
+```
+
+## How it works
+
+* **E-step** — `midas-integrate` builds a CSR pixel→bin map from the current
+  geometry and integrates the image into a 2D (R, η) cake. Per (ring × η-bin)
+  the radial peak position is extracted via weighted centroid.
+* **M-step** — fit detector geometry to the (Y_pix, Z_pix, ring) data using a
+  custom batched Levenberg-Marquardt solver (`midas_peakfit.lm_solve_generic`)
+  with sigmoid-bounded reparameterisation, Cholesky_ex, and optional Huber
+  loss reshaping.
+* **Orchestrator** — alternating E↔M iterations with optional σ-clip outlier
+  rejection between iterations.
+
+The geometry forward model in [`geometry_torch.py`](midas_calibrate/geometry_torch.py)
+is a byte-for-byte port of `midas_integrate.geometry.pixel_to_REta` — verified
+to fp64 epsilon by parity tests.
+
+## Dependencies
+
+- [`midas-hkls`](../midas_hkls) — pure-Python crystallography (sginfo replacement)
+- [`midas-integrate`](../midas_integrate) — CSR pixel→bin mapper + integration
+- [`midas-peakfit`](../midas_peakfit) ≥ 0.2.0 — generic LM solver
+
+## Synthetic-data parity test
+
+The end-to-end synthetic test forward-simulates a CeO₂ calibrant image at
+known geometry, perturbs the seed (Lsd ±300μm, BC ±1.5px, tilts ±0.06°), and
+verifies recovery:
+
+```
+[iter 0] n_fits= 176  rc=0  strain=  105.2μϵ  Lsd=1000219.4  BC=(512.20,511.91)  ty=0.343  tz=0.180
+[iter 1] n_fits= 176  rc=0  strain=   25.7μϵ  Lsd= 999973.5  BC=(512.01,512.00)  ty=0.403  tz=0.250
+[iter 2] n_fits= 176  rc=0  strain=   19.4μϵ  Lsd= 999946.1  BC=(511.99,512.00)  ty=0.400  tz=0.267
+[iter 3] n_fits= 176  rc=0  strain=   21.6μϵ  Lsd= 999918.1  BC=(511.99,512.00)  ty=0.392  tz=0.285
+```
+
+Final recovery: Lsd within 82μm of truth, BC within 0.01 px, tilts within
+0.04°. Mean strain 21.6μϵ, well under the 50μϵ MIDAS calibration target.
+
+## Engines
+
+`autocalibrate` is the alternating E↔M engine (default).
+
+`autocalibrate_joint` will be the fully differentiable engine — geometry +
+per-(ring × η-bin) peak-shape parameters jointly refined in one batched
+Schur-complement-reduced LM (see §13 of the design doc). v0.1 ships with a
+working stub that delegates to the alternating engine; the arrowhead-LM
+infrastructure (`midas_peakfit.lm_solve_arrowhead`) is in place and tested.
+
+## Status
+
+v0.1.0 — alternating engine production-ready, joint engine scaffolded.
+
+See [`AutoCalibrate.md`](../../manuals/AutoCalibrate.md) for the manual and
+[`calibrate_torch_implementation_plan.md`](../../calibrate_torch_implementation_plan.md)
+for the full design and roadmap.

midas_calibrate-0.2.1/midas_calibrate/__init__.py

@@ -0,0 +1,32 @@
+"""midas-calibrate — native Python/Torch detector calibration.
+
+Public API:
+
+    from midas_calibrate import CalibrationParams, build_ring_table, refine_geometry
+
+    params = CalibrationParams.from_file("calib.txt")
+    rt = build_ring_table(params)
+    result = autocalibrate(params)            # full pipeline
+"""
+from .params import CalibrationParams
+from .rings import RingTable, build_ring_table
+from .refine import FittedPoint, RefineResult, refine_geometry
+from .orchestrator import CalibrationResult, IterRecord, autocalibrate
+from .estep import CakeProfile, integrate_cake, run_estep
+
+__version__ = "0.2.1"
+
+__all__ = [
+    "CakeProfile",
+    "CalibrationParams",
+    "CalibrationResult",
+    "FittedPoint",
+    "IterRecord",
+    "RefineResult",
+    "RingTable",
+    "autocalibrate",
+    "build_ring_table",
+    "integrate_cake",
+    "refine_geometry",
+    "run_estep",
+]

midas_calibrate-0.2.1/midas_calibrate/cli.py

@@ -0,0 +1,76 @@
+"""Command-line entry points for midas-calibrate."""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Sequence
+
+import numpy as np
+
+
+def _load_image(path: Path) -> np.ndarray:
+    p = Path(path)
+    if p.suffix.lower() in (".tif", ".tiff"):
+        import tifffile
+        return tifffile.imread(p)
+    if p.suffix.lower() in (".h5", ".hdf5"):
+        import h5py
+        with h5py.File(p, "r") as f:
+            keys = list(f.keys())
+            return np.asarray(f[keys[0]])
+    if p.suffix.lower() in (".npy",):
+        return np.load(p)
+    raise ValueError(f"unknown image extension: {p.suffix}")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    return autocalibrate_main(argv)
+
+
+def autocalibrate_main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="midas-autocalibrate",
+                                     description="Native Python detector calibration")
+    parser.add_argument("params_file", type=Path, help="CalibrationParams .txt")
+    parser.add_argument("--image", type=Path, default=None,
+                        help="calibrant image (overrides ImagePath in params)")
+    parser.add_argument("--dark", type=Path, default=None)
+    parser.add_argument("--output", type=Path, default=None,
+                        help="path to write parameters_refined.txt (default: alongside input)")
+    parser.add_argument("--engine", choices=["alternating", "joint"], default="alternating")
+    parser.add_argument("--n-iters", type=int, default=None,
+                        help="override nIterations from the params file")
+    parser.add_argument("--quiet", action="store_true")
+    args = parser.parse_args(argv)
+
+    from .orchestrator import autocalibrate
+    from .params import CalibrationParams
+
+    params = CalibrationParams.from_file(args.params_file)
+    if args.n_iters is not None:
+        params.nIterations = args.n_iters
+
+    image_path = args.image or Path(params.ImagePath)
+    image = _load_image(image_path)
+    dark = _load_image(args.dark) if args.dark else None
+
+    if args.engine == "joint":
+        try:
+            from .joint import autocalibrate_joint
+            result = autocalibrate_joint(params, image, dark=dark, verbose=not args.quiet)
+        except ImportError:
+            print("joint engine not yet available; falling back to alternating", file=sys.stderr)
+            result = autocalibrate(params, image, dark=dark, verbose=not args.quiet)
+    else:
+        result = autocalibrate(params, image, dark=dark, verbose=not args.quiet)
+
+    out = args.output or args.params_file.with_name(args.params_file.stem + "_refined.txt")
+    result.params.write(out)
+    if not args.quiet:
+        print(f"\nFinal mean strain: {result.history[-1].mean_strain_uE:.1f} μϵ")
+        print(f"Refined parameters written to {out}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

midas_calibrate-0.2.1/midas_calibrate/estep.py

@@ -0,0 +1,169 @@
+"""E-step: integrate calibrant image, extract per-(ring, η-bin) peak positions.
+
+Strategy:
+  1. Build a uniform-R, uniform-η bin grid spanning the calibrant ring range
+     (subsetting per-ring windows after integration).
+  2. Build midas_integrate's PixelMap + CSR from the current geometry.
+  3. Integrate the image into a 2D (R, η) cake.
+  4. For each (ring, η-bin), compute a weighted centroid in the radial window
+     to get R_fit (px).  v0.1 uses centroid; future versions can swap in a
+     pseudo-Voigt LM via midas_peakfit.lm_solve_generic.
+  5. Convert (R_fit, η_bin_center) → (Y_pix, Z_pix) via midas_integrate's
+     Newton-Raphson inverse.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import numpy as np
+import torch
+
+from midas_integrate.detector_mapper import build_map
+from midas_integrate.geometry import build_tilt_matrix, invert_REta_to_pixel
+from midas_integrate.kernels import build_csr, integrate
+from midas_integrate.params import IntegrationParams
+
+from .params import CalibrationParams
+from .refine import FittedPoint
+from .rings import RingTable
+
+
+def _calibration_to_integration_params(
+    params: CalibrationParams, *, R_min: float, R_max: float, R_bin_size: float, eta_bin_size: float,
+) -> IntegrationParams:
+    ip = IntegrationParams()
+    ip.NrPixelsY = params.NrPixelsY
+    ip.NrPixelsZ = params.NrPixelsZ
+    ip.pxY = params.pxY
+    ip.pxZ = params.pxZ if params.pxZ > 0 else params.pxY
+    ip.Lsd = params.Lsd
+    ip.BC_y = params.BC_y
+    ip.BC_z = params.BC_z
+    ip.tx = params.tx
+    ip.ty = params.ty
+    ip.tz = params.tz
+    for i in range(15):
+        setattr(ip, f"p{i}", getattr(params, f"p{i}"))
+    ip.RhoD = params.RhoD if params.RhoD > 0 else params.MaxRingRad
+    ip.Parallax = params.Parallax
+    ip.Wavelength = params.Wavelength
+    ip.RMin = float(R_min)
+    ip.RMax = float(R_max)
+    ip.RBinSize = float(R_bin_size)
+    ip.EtaMin = -180.0
+    ip.EtaMax = 180.0
+    ip.EtaBinSize = float(eta_bin_size)
+    ip.SolidAngleCorrection = 0
+    ip.PolarizationCorrection = 0
+    return ip
+
+
+@dataclass
+class CakeProfile:
+    R_centers: np.ndarray
+    eta_centers: np.ndarray
+    intensity: np.ndarray  # [n_R, n_eta]
+
+
+def integrate_cake(
+    params: CalibrationParams,
+    image: np.ndarray,
+    rt: RingTable,
+    *, dark: Optional[np.ndarray] = None,
+) -> CakeProfile:
+    """Build CSR + integrate the image into a uniform (R, η) cake."""
+    if dark is not None:
+        image = image - dark
+
+    # R range: half-Width margin around min/max ring radius.
+    px = 0.5 * (params.pxY + params.pxZ) if params.pxZ > 0 else params.pxY
+    half_px = 0.5 * params.Width / px
+    R_min = max(0.0, float(rt.r_ideal_px.min()) - half_px - 1.0)
+    R_max = float(rt.r_ideal_px.max()) + half_px + 1.0
+    ip = _calibration_to_integration_params(
+        params, R_min=R_min, R_max=R_max,
+        R_bin_size=params.RBinSize, eta_bin_size=params.EtaBinSize,
+    )
+
+    pmap_result = build_map(ip, verbose=False)
+    from midas_integrate.bin_io import PixelMap as _PixelMap
+    pmap = _PixelMap(
+        pxList=pmap_result.pxList,
+        counts=pmap_result.counts,
+        offsets=pmap_result.offsets,
+        map_header=None, nmap_header=None,
+    )
+    geom = build_csr(
+        pmap,
+        n_r=ip.n_r_bins, n_eta=ip.n_eta_bins,
+        n_pixels_y=ip.NrPixelsY, n_pixels_z=ip.NrPixelsZ,
+        bc_y=ip.BC_y, bc_z=ip.BC_z,
+        device="cpu", dtype=torch.float64,
+        build_modes=("bilinear",),
+    )
+
+    img_t = torch.as_tensor(image, dtype=torch.float64).contiguous()
+    cake = integrate(img_t, geom, mode="bilinear", normalize=True).numpy()
+
+    R_edges = np.linspace(ip.RMin, ip.RMin + ip.RBinSize * ip.n_r_bins, ip.n_r_bins + 1)
+    eta_edges = np.linspace(ip.EtaMin, ip.EtaMax, ip.n_eta_bins + 1)
+    return CakeProfile(
+        R_centers=0.5 * (R_edges[:-1] + R_edges[1:]),
+        eta_centers=0.5 * (eta_edges[:-1] + eta_edges[1:]),
+        intensity=cake,
+    )
+
+
+def extract_fitted_points(
+    cake: CakeProfile, rt: RingTable, params: CalibrationParams,
+    *, snr_min: float = 1.0,
+) -> List[FittedPoint]:
+    """Per (ring × η-bin): centroid in the radial window → (R_fit, η) → (Y_pix, Z_pix)."""
+    px = 0.5 * (params.pxY + params.pxZ) if params.pxZ > 0 else params.pxY
+    half_px = 0.5 * params.Width / px
+    TRs = build_tilt_matrix(params.tx, params.ty, params.tz)
+
+    fits: List[FittedPoint] = []
+    for ring_i, r_ideal in enumerate(rt.r_ideal_px):
+        idx = np.where(np.abs(cake.R_centers - r_ideal) <= half_px)[0]
+        if idx.size < 3:
+            continue
+        R_window = cake.R_centers[idx]
+        for eta_j, eta in enumerate(cake.eta_centers):
+            I = cake.intensity[idx, eta_j]
+            I = np.maximum(I - I.min(), 0.0)
+            tot = I.sum()
+            if tot <= 0.0:
+                continue
+            R_fit = float((I * R_window).sum() / tot)
+            peak = float(I.max())
+            mean = float(I.mean()) + 1e-12
+            snr = peak / mean
+            if snr < snr_min:
+                continue
+            try:
+                Y_pix, Z_pix = invert_REta_to_pixel(
+                    R_fit, eta,
+                    Ycen=params.BC_y, Zcen=params.BC_z, TRs=TRs,
+                    Lsd=params.Lsd, RhoD=(params.RhoD if params.RhoD > 0 else params.MaxRingRad),
+                    px=px, parallax=params.Parallax,
+                )
+            except Exception:
+                continue
+            fits.append(FittedPoint(
+                Y_pix=float(Y_pix), Z_pix=float(Z_pix),
+                ring_idx=ring_i, snr=snr,
+            ))
+    return fits
+
+
+def run_estep(
+    params: CalibrationParams,
+    image: np.ndarray,
+    rt: RingTable,
+    *, dark: Optional[np.ndarray] = None,
+) -> Tuple[CakeProfile, List[FittedPoint]]:
+    cake = integrate_cake(params, image, rt, dark=dark)
+    fits = extract_fitted_points(cake, rt, params, snr_min=params.SNRMin)
+    return cake, fits

midas_calibrate-0.2.1/midas_calibrate/geometry_torch.py

@@ -0,0 +1,154 @@
+"""Differentiable detector forward model in pure torch.
+
+Mirrors midas_integrate.geometry.pixel_to_REta but in torch ops so the result
+is autograd-traced through to geometry parameters (Lsd, BC, tilts, p0..p14,
+parallax, wavelength).  All units match MIDAS conventions:
+
+  * Lsd in μm; BC in pixels; tilts in degrees (Rx · Ry · Rz order).
+  * Eta in degrees, atan2(-Y', Z'), [-180, 180).
+  * Distortion ΔR/RhoD = polynomial in (R/RhoD).
+
+Inverse mapping (R, η) → (Y_pix, Z_pix) is a Newton-Raphson loop and is
+provided here for the alternating engine; the joint engine forward-models
+predicted-R(geometry) directly without inversion.
+"""
+from __future__ import annotations
+
+from typing import Tuple
+
+import torch
+
+
+def build_tilt_matrix_torch(tx: torch.Tensor, ty: torch.Tensor, tz: torch.Tensor) -> torch.Tensor:
+    """TRs = Rx(tx) · Ry(ty) · Rz(tz),  angles in degrees, [3,3] tensor.
+
+    All inputs scalar torch tensors; output [3,3] tensor with grad flowing.
+    """
+    one = torch.ones((), dtype=tx.dtype, device=tx.device)
+    zero = torch.zeros((), dtype=tx.dtype, device=tx.device)
+    deg2rad = torch.tensor(0.017453292519943295, dtype=tx.dtype, device=tx.device)
+    cx, sx = torch.cos(tx * deg2rad), torch.sin(tx * deg2rad)
+    cy, sy = torch.cos(ty * deg2rad), torch.sin(ty * deg2rad)
+    cz, sz = torch.cos(tz * deg2rad), torch.sin(tz * deg2rad)
+
+    Rx = torch.stack([torch.stack([one, zero, zero]),
+                      torch.stack([zero, cx, -sx]),
+                      torch.stack([zero, sx, cx])])
+    Ry = torch.stack([torch.stack([cy, zero, sy]),
+                      torch.stack([zero, one, zero]),
+                      torch.stack([-sy, zero, cy])])
+    Rz = torch.stack([torch.stack([cz, -sz, zero]),
+                      torch.stack([sz, cz, zero]),
+                      torch.stack([zero, zero, one])])
+    return Rx @ Ry @ Rz
+
+
+def pixel_to_REta_torch(
+    Y_pix: torch.Tensor,            # [...] pixel Y indices
+    Z_pix: torch.Tensor,            # [...] pixel Z indices
+    *,
+    Lsd: torch.Tensor,
+    BC_y: torch.Tensor,
+    BC_z: torch.Tensor,
+    tx: torch.Tensor,
+    ty: torch.Tensor,
+    tz: torch.Tensor,
+    p_coeffs: torch.Tensor,         # [15] distortion coefficients p0..p14
+    parallax: torch.Tensor,
+    px: torch.Tensor,               # μm; mean of pxY/pxZ
+    rho_d: torch.Tensor,            # px; distortion normalization radius
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Differentiable pixel → (R [px], Eta [deg]).
+
+    Byte-for-byte port of midas_integrate.geometry.pixel_to_REta — vector layout
+    ``(0, Yc, Zc)`` → tilt → add Lsd along x; then 2θ via Lsd/Xp projection;
+    distortion applied as a *multiplicative scaling* on Rad (NOT ΔR).
+    """
+    deg2rad = torch.tensor(0.017453292519943295, dtype=Y_pix.dtype, device=Y_pix.device)
+    rad2deg = torch.tensor(57.29577951308232, dtype=Y_pix.dtype, device=Y_pix.device)
+
+    # Untilted physical coordinates (μm) — note the X-component is 0 before tilt.
+    Yc = (-Y_pix + BC_y) * px
+    Zc = (Z_pix - BC_z) * px
+
+    TRs = build_tilt_matrix_torch(tx, ty, tz)
+    # Apply tilt to (0, Yc, Zc): only columns 1 and 2 of TRs matter.
+    abcpr_x = TRs[0, 1] * Yc + TRs[0, 2] * Zc
+    abcpr_y = TRs[1, 1] * Yc + TRs[1, 2] * Zc
+    abcpr_z = TRs[2, 1] * Yc + TRs[2, 2] * Zc
+
+    XYZ_x = Lsd + abcpr_x
+    XYZ_y = abcpr_y
+    XYZ_z = abcpr_z
+    safe_x = torch.where(XYZ_x.abs() < 1e-30, torch.full_like(XYZ_x, 1e-30), XYZ_x)
+    rad_um = (Lsd / safe_x) * torch.sqrt(XYZ_y * XYZ_y + XYZ_z * XYZ_z)
+    eta_tilted = rad2deg * torch.atan2(-XYZ_y, XYZ_z)
+
+    # Distortion polynomial uses EtaT = 90 - EtaTilted (matches numpy).
+    eta_T_rad = (90.0 - eta_tilted) * deg2rad
+    R_norm = rad_um / rho_d if rho_d > 0 else torch.zeros_like(rad_um)
+
+    p = p_coeffs
+    dist = (
+        p[0] * R_norm.pow(2) * torch.cos(2 * eta_T_rad + deg2rad * p[6])
+        + p[1] * R_norm.pow(4) * torch.cos(4 * eta_T_rad + deg2rad * p[3])
+        + p[2] * R_norm.pow(2)
+        + p[4] * R_norm.pow(6)
+        + p[5] * R_norm.pow(4)
+        + p[7] * R_norm.pow(4) * torch.cos(eta_T_rad + deg2rad * p[8])
+        + p[9] * R_norm.pow(3) * torch.cos(3 * eta_T_rad + deg2rad * p[10])
+        + p[11] * R_norm.pow(5) * torch.cos(5 * eta_T_rad + deg2rad * p[12])
+        + p[13] * R_norm.pow(6) * torch.cos(6 * eta_T_rad + deg2rad * p[14])
+        + 1.0
+    )
+    Rt = rad_um * dist / px
+
+    if isinstance(parallax, torch.Tensor):
+        if parallax.abs().item() > 0:
+            two_theta = torch.atan(rad_um / Lsd)
+            Rt = Rt + parallax * torch.sin(two_theta) / px
+    return Rt, eta_tilted
+
+
+def predict_R_at_pixel(Y_pix: torch.Tensor, Z_pix: torch.Tensor,
+                        params_vec: torch.Tensor, px: float, rho_d: float) -> torch.Tensor:
+    """Compute R [px] given a packed geometry parameter vector.
+
+    Layout of params_vec (length 23):
+        [0]   Lsd
+        [1,2] BC_y, BC_z
+        [3,4] ty, tz                  (tx fixed at 0 for now)
+        [5..19] p0..p14
+        [20]  parallax
+        [21]  wavelength             (unused in geometry; needed for predict_R_ideal)
+        [22]  tx                     (fixed at the input value)
+    """
+    Lsd = params_vec[0]
+    BC_y = params_vec[1]; BC_z = params_vec[2]
+    ty = params_vec[3]; tz = params_vec[4]
+    p = params_vec[5:20]
+    parallax = params_vec[20]
+    tx = params_vec[22]
+    px_t = torch.as_tensor(px, dtype=params_vec.dtype, device=params_vec.device)
+    rho_d_t = torch.as_tensor(rho_d, dtype=params_vec.dtype, device=params_vec.device)
+    R, _eta = pixel_to_REta_torch(
+        Y_pix, Z_pix, Lsd=Lsd, BC_y=BC_y, BC_z=BC_z,
+        tx=tx, ty=ty, tz=tz, p_coeffs=p, parallax=parallax,
+        px=px_t, rho_d=rho_d_t,
+    )
+    return R
+
+
+def predict_R_ideal(two_theta_deg: torch.Tensor, params_vec: torch.Tensor, px: float) -> torch.Tensor:
+    """R_ideal[px] = Lsd · tan(2θ) / px.  When wavelength is refined, two_theta_deg
+    must be recomputed externally from d-spacing — this function expects the
+    already-resolved 2θ values."""
+    Lsd = params_vec[0]
+    return Lsd * torch.tan(two_theta_deg * 0.017453292519943295) / px
+
+
+def predict_two_theta_from_d(d_spacing_A: torch.Tensor, wavelength_A: torch.Tensor) -> torch.Tensor:
+    """Bragg's law in torch:  2θ = 2 arcsin(λ / 2d)."""
+    s = wavelength_A / (2.0 * d_spacing_A)
+    s = s.clamp(min=-0.999999, max=0.999999)
+    return 2.0 * torch.asin(s) * 57.29577951308232  # → deg

midas_calibrate-0.2.1/midas_calibrate/joint.py

@@ -0,0 +1,53 @@
+"""Joint differentiable engine — fully end-to-end LM over geometry + per-region peak-shape parameters.
+
+**Status (v0.1.0): scaffolded but not yet wired.**
+
+The infrastructure is in place:
+
+- ``midas_peakfit.lm_solve_arrowhead`` provides a Schur-complement-reduced LM
+  solver for the joint  J = [J_dense | block_diag(J_block_k)]  problem (see
+  the §13 plan).
+- ``midas_calibrate.geometry_torch.pixel_to_REta_torch`` is a fully torch /
+  autograd compatible forward model.
+- ``midas_calibrate.refine`` already exercises lm_solve_generic with the
+  geometry parameters as a 23-dim dense vector — the joint formulation just
+  enlarges this to add per-(ring, η-bin) peak-shape blocks.
+
+What's left (deferred to v0.2):
+
+1. ``forward_cake(θ_geom, θ_shape)`` — predict the (R, η) cake intensity by
+   summing pseudo-Voigts whose centers are determined by θ_geom (NOT by θ_shape).
+2. Block-arrow Jacobian assembly: per-region 5×M peak-shape Jacobian +
+   coupled geometry columns, packaged for ``lm_solve_arrowhead``.
+3. Warm-start: 1-2 iterations of ``orchestrator.autocalibrate`` (alternating)
+   followed by per-region peak-shape seeding.
+
+For now ``autocalibrate_joint`` is a thin wrapper that delegates to the
+alternating engine; users get the same end result through a more conventional
+implementation.  Swap-in is local to this module — no caller changes needed
+once the joint forward model lands.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+import numpy as np
+
+from .orchestrator import CalibrationResult, autocalibrate
+from .params import CalibrationParams
+
+
+def autocalibrate_joint(
+    params: CalibrationParams,
+    image: np.ndarray,
+    *, dark: Optional[np.ndarray] = None,
+    verbose: bool = True,
+) -> CalibrationResult:
+    """Full differentiable end-to-end calibration.
+
+    v0.1: delegates to the alternating engine.  See module docstring for the
+    deferred-but-scoped roadmap to the true joint formulation.
+    """
+    if verbose:
+        print("[joint] v0.1 stub — delegating to alternating engine")
+    return autocalibrate(params, image, dark=dark, verbose=verbose)