disko 1.4.0__tar.gz → 1.4.2__tar.gz

{disko-1.4.0 → disko-1.4.2}/CHANGES.md

@@ -1,5 +1,18 @@
 # Changes
 
+## 1.4.2 (2026-06-22)
+
+- Delegate angle parsing to `angle-parser` library; remove custom `parse_ending` and unit constants from `Resolution`
+- Add `angle-parser>=0.2.0` dependency; remove fallback for `mas`, `uas` (now handled natively)
+- Lower minimum gmsh version from 4.9 to 4.0
+- Update optional `tart2ms` dependency from >=0.7.1 to >=0.9.0
+- Update `uv.lock` for all dependency changes
+
+## 1.4.1 (2026-06-22)
+
+- Remove redundant `DirectImagingOperator` (10% code reduction); `DiSkOOperator` handles the exact adjoint directly via `A.T`.
+- Fix FISTA and LSMR initial guess: Use true adjoint `np.abs(A.T @ d)` to guarantee a physically correct (non-mirrored) starting image.
+
 ## 1.4.0 (2026-06-22)
 
 - Convert from pygmsh to gmsh native API; remove pygmsh dependency; add meshio

{disko-1.4.0 → disko-1.4.2}/Makefile

@@ -72,7 +72,7 @@ TART_ARGS=--fov 155deg --res 1deg --ms test_data/test.ms --debug --field 1  --HD
 cygnus_lsmr:
 	${TIME} uv run disko  --healpix --fov 3arcmin --ms ~/astro/cyg2052.ms --FITS --res 0.5arcsec --matrix-free --lsmr --nvis 5000 --alpha 0.01 --title 'cygnus_lsmr'
 cygnus_fista:
-	${TIME} uv run disko  --debug --healpix --fov 3arcmin --ms ~/astro/cyg2052.ms --FITS --res 1arcsec --matrix-free --fista --alpha 1e-7 --niter 200 --nvis 10000 --title 'cygnus_fista'
+	${TIME} uv run disko  --debug --healpix --fov 3arcmin --ms ~/astro/cyg2052.ms --FITS --res 1arcsec --matrix-free --fista --niter 200 --nvis 2000 --title 'cygnus_fista'
 
 tart:
 	uv run disko --healpix ${TART_ARGS} --SVG --alpha=0.025 --tikhonov  --title 'tart'

{disko-1.4.0 → disko-1.4.2}/PKG-INFO

@@ -1,13 +1,14 @@
 Metadata-Version: 2.4
 Name: disko
-Version: 1.4.0
+Version: 1.4.2
 Summary: Discrete Sky Operator (DiSkO) Aperture Synthesis Radio Imaging
 Author-email: Tim Molteno <tim@elec.ac.nz>
 License: GPLv3
 License-File: LICENSE.txt
 Requires-Python: <3.14,>=3.11
+Requires-Dist: angle-parser>=0.2.0
 Requires-Dist: dask-ms<0.3.0,>=0.2.25
-Requires-Dist: gmsh>=4.9
+Requires-Dist: gmsh>=4.0
 Requires-Dist: h5py>=3.7
 Requires-Dist: healpy<2.0.0,>=1.15.0
 Requires-Dist: imageio>=0.6.0b1
@@ -22,7 +23,7 @@ Requires-Dist: tart-tools>=1.4.0
 Requires-Dist: tart>=1.4.0
 Requires-Dist: toolz>=0.11.2
 Provides-Extra: ms
-Requires-Dist: tart2ms>=0.7.1; extra == 'ms'
+Requires-Dist: tart2ms>=0.9.0; extra == 'ms'
 Description-Content-Type: text/markdown
 
 # Discrete Sky Operator (DiSkO) Synthesis Imaging

{disko-1.4.0 → disko-1.4.2}/disko/__init__.py

@@ -8,7 +8,6 @@ import logging  # noqa: F401
 # Public API — imported by external users
 from .cli import disko_from_ms  # noqa: F401
 from .disko import (  # noqa: F401
-    DirectImagingOperator,
     DiSkO,
     DiSkOOperator,
     get_all_uvw,

{disko-1.4.0 → disko-1.4.2}/disko/disko.py

@@ -247,12 +247,12 @@ class DiSkOOperator(pylops.LinearOperator):
 
     def _rmatvec(self, v):
         r"""
-        Returns x = A^H * v, where A^H is the conjugate transpose of A.
+        Returns x = A^T * v, where A^T is the transpose of A.
 
         x = ( T_real' T_imag') (v_real
                                 v_imag)
 
-        Matrix-free: uses cached float32 harmonic blocks.
+        Matrix-free: uses cached float64 harmonic blocks.
         """
         assert v.shape == (self.M,)
         n_u = self.u_arr.shape[0]
@@ -278,117 +278,6 @@ class DiSkOOperator(pylops.LinearOperator):
         return ret
 
 
-class DirectImagingOperator(pylops.LinearOperator):
-    r"""
-    This is the approximate inverse of the DiSkOOperator, and corresponds to
-    imaging by the discrete fourier transform
-    """
-
-    def __init__(self, u_arr, v_arr, w_arr, data, frequencies, sphere):
-        super().__init__()
-        self.N = sphere.npix  # Number of pixels
-        self.u_arr = u_arr
-        self.v_arr = v_arr
-        self.w_arr = w_arr
-        self.dtype = REAL_DATATYPE
-
-        try:
-            self.n_v, self.n_freq, self.npol = data.shape
-        except Exception:
-            raise RuntimeError("Data must be of the shape [n_v, n_freq, n_pol]")
-
-        self.M = self.n_v * self.n_freq
-
-        self.frequencies = frequencies
-        self.sphere = sphere
-
-        if self.sphere.l.shape[0] != self.N:
-            raise RuntimeError(
-                f"self.sphere.l.shape != self.N, {self.sphere.l.shape} != {self.N}"
-            )
-
-        self.shape = (self.N, self.M)
-        self.explicit = False  # Can't be directly inverted
-        logger.info("Creating DirectImagingOperator data={}".format(self.shape))
-
-    def _compute_harmonics_block(self, p2j, u_blk, v_blk, w_blk):
-        """Compute a block of the complex harmonics matrix.
-
-        Args:
-            p2j: complex frequency factor (1j * omega)
-            u_blk, v_blk, w_blk: 1D arrays of UVW coordinates for this
-                block of visibilities.
-
-        Returns:
-            H_block: complex array of shape (len(u_blk), self.N)
-        """
-        phase = p2j * (
-            np.outer(u_blk, self.sphere.l)
-            + np.outer(v_blk, self.sphere.m)
-            + np.outer(w_blk, self.sphere.n_minus_1)
-        )
-        return np.exp(phase) * self.sphere.pixel_areas[np.newaxis, :]
-
-    def _block_size(self):
-        """Number of visibility rows per block, targeting ~200 MB per block."""
-        return max(256, int(200 * 1024 * 1024 / (16 * max(1, self.N))))
-
-    def _matvec(self, v):
-        """
-        Multiply by the measurements v, producing the sky.
-        Returns A * v.
-
-        sky = real(v_complex @ H) where H[i,j] is the harmonic at
-        visibility i, pixel j.  Computed in blocks for memory efficiency.
-        """
-        n_vis = self.n_v // 2
-        vis_complex = v[:n_vis] + 1.0j * v[n_vis:]
-
-        sky = np.zeros(self.N, dtype=self.dtype)
-        block_size = self._block_size()
-
-        for f in self.frequencies:
-            p2j = jomega(f)
-            for i_start in range(0, n_vis, block_size):
-                i_end = min(i_start + block_size, n_vis)
-                H_block = self._compute_harmonics_block(
-                    p2j,
-                    self.u_arr[i_start:i_end],
-                    self.v_arr[i_start:i_end],
-                    self.w_arr[i_start:i_end],
-                )  # shape (block_size, N)
-                sky += np.real(vis_complex[i_start:i_end] @ H_block)
-
-        return sky
-
-    def _rmatvec(self, x):
-        r"""
-        Map sky vector x back to visibilities.
-
-        v_complex = conj(H) @ x, then split into real/imag parts.
-        """
-        assert x.shape == (self.N,)
-        n_vis = self.n_v // 2
-
-        ret_complex = np.zeros(n_vis, dtype=COMPLEX_DATATYPE)
-        block_size = self._block_size()
-
-        for f in self.frequencies:
-            p2j = jomega(f)
-            for i_start in range(0, n_vis, block_size):
-                i_end = min(i_start + block_size, n_vis)
-                H_block = self._compute_harmonics_block(
-                    p2j,
-                    self.u_arr[i_start:i_end],
-                    self.v_arr[i_start:i_end],
-                    self.w_arr[i_start:i_end],
-                )  # shape (block_size, N)
-                # v_complex[i] = dot(conj(H[i,:]), x)  =>  v_block = H_block.conj() @ x
-                ret_complex[i_start:i_end] = H_block.conj() @ x
-
-        return np.concatenate((np.real(ret_complex), np.imag(ret_complex)))
-
-
 class DiSkO(object):
     def __init__(self, u_arr, v_arr, w_arr, frequency):
         self.harmonics = {}  # Temporary store for harmonics
@@ -589,9 +478,6 @@ class DiSkO(object):
         logger.info("frequencies: {}".format(frequencies))
 
         A = DiSkOOperator(self.u_arr, self.v_arr, self.w_arr, data, frequencies, sphere)
-        Apre = DirectImagingOperator(
-            self.u_arr, self.v_arr, self.w_arr, data, frequencies, sphere
-        )
         d = data.flatten()
 
         logger.info("Data.shape {}".format(data.shape))
@@ -611,7 +497,7 @@ class DiSkO(object):
             sky, niter, cost_history = pylops.optimization.sparsity.fista(
                 Op=A,
                 y=d,
-                x0=np.abs(Apre @ d),
+                x0=np.abs(A.T @ d),
                 eps=eps,
                 tol=1e-10,
                 niter=niter,
@@ -658,7 +544,7 @@ class DiSkO(object):
         if lsmr is True:
             if alpha < 0:
                 alpha = np.mean(self.rms)
-            x0 = Apre @ d
+            x0 = A.T @ d
 
             sky, info = pylops.optimization.leastsquares.normal_equations_inversion(
                 A, Regs=None, y=d, x0=x0, epsI=alpha, show=True

disko-1.4.2/disko/resolution.py

@@ -0,0 +1,108 @@
+#
+# Copyright Tim Molteno 2022-2026 tim@elec.ac.nz
+#
+
+import astropy.constants as const
+import numpy as np
+
+
+class Resolution:
+    """
+    Degrees (°), minutes ('), seconds (")
+    """
+
+    def __init__(self, x_rad):
+        self.x_rad = x_rad
+
+    @classmethod
+    def from_deg(cls, x_deg):
+        return cls(np.radians(x_deg))
+
+    @classmethod
+    def from_rad(cls, x_rad):
+        return cls(x_rad)
+
+    @classmethod
+    def from_arcmin(cls, x_arcmin):
+        return cls(np.radians(x_arcmin / 60))
+
+    @classmethod
+    def from_arcsec(cls, x_arcsec):
+        return cls(np.radians(x_arcsec / 3600))
+
+    @classmethod
+    def from_string(cls, x_str):
+        from angle_parser import parse_angle
+
+        # Normalize common symbols to parseable forms
+        s = x_str.replace('"', "arcsec").replace("'", "arcmin")
+
+        return cls(parse_angle(s))
+
+    def radians(self):
+        return self.x_rad
+
+    def degrees(self):
+        return np.degrees(self.x_rad)
+
+    def arcmin(self):
+        return self.degrees() * 60
+
+    def arcsec(self):
+        return self.degrees() * 3600
+
+    def __repr__(self):
+        d = self.degrees()
+        if np.abs(d) > 1:
+            return f"{d:4.2f}deg"
+
+        if np.abs(self.arcmin()) > 1:
+            return f"{self.arcmin():4.2f}arcmin"
+
+        arcsec = self.arcsec()
+        if np.abs(arcsec) > 1:
+            return f"{arcsec:4.2f}arcsec"
+
+        mas = arcsec * 1000
+        if np.abs(mas) >= 1:
+            return f"{mas:4.2f}mas"
+
+        uas = mas * 1000
+        return f"{uas:4.2f}uas"
+
+    def get_min_baseline(self, frequency):
+        """
+        Get the shortest baseline length (in meters) that will resolve
+        this resolution, at the specified frequency.
+
+        Double-slit interferometer (spacing d). Fringe maxima
+        occur at angles where
+            d * sin(theta) = n * wavelength
+
+        n = 1: sin(theta) = wavelength/d
+        n = 2: sin(theta) = 2*wavelength/d
+
+        angular spacing = wavelength / d
+
+        so d = spacing / theta
+        """
+        wavelength = const.c.value / frequency
+        spacing = wavelength / self.x_rad
+        return spacing * 2  # Nyquist requires twice this...
+
+    @classmethod
+    def from_baseline(cls, bl, frequency):
+        res_limit = cls.rayleigh_criterion(bl, frequency)
+        return cls(res_limit / 2)  # Nyquist requires twice the resolution
+
+    @staticmethod
+    def rayleigh_criterion(bl, frequency):
+        """
+        The accepted criterion for determining the diffraction limit to resolution
+        developed by Lord Rayleigh in the 19th century.
+
+        approx resolution given by first order Bessel functions
+        assuming array is a flat disk of length bl
+        """
+        min_wl = const.c.value / frequency
+        return 1.220 * min_wl / bl

{disko-1.4.0 → disko-1.4.2}/disko/tests/test_disko.py

@@ -276,23 +276,6 @@ class TestDiSkO(unittest.TestCase):
 
         dottest(Op, self.disko.n_v * 2, self.sphere.npix, tol=1e-04)
 
-        Op = disko.DirectImagingOperator(
-            self.disko.u_arr,
-            self.disko.v_arr,
-            self.disko.w_arr,
-            data,
-            frequencies,
-            self.sphere,
-        )
-        pylops.utils.dottest(
-            Op,
-            self.sphere.npix,
-            self.disko.n_v * 2,
-            rtol=1e-06,
-            complexflag=0,
-            raiseerror=True,
-            verb=True,
-        )
 
     def test_tiny_gamma(self):
         """

{disko-1.4.0 → disko-1.4.2}/disko/tests/test_pylops_operator.py

@@ -123,23 +123,6 @@ class TestPylopsOperator(unittest.TestCase):
 
         dottest(Op, self.disko.n_v * 2, self.sphere.npix, tol=1e-04)
 
-        Op = disko.DirectImagingOperator(
-            self.disko.u_arr,
-            self.disko.v_arr,
-            self.disko.w_arr,
-            data,
-            frequencies,
-            self.sphere,
-        )
-        pylops.utils.dottest(
-            Op,
-            self.sphere.npix,
-            self.disko.n_v * 2,
-            rtol=1e-06,
-            complexflag=0,
-            raiseerror=True,
-            verb=True,
-        )
 
     def test_pylops_tiny(self):
         r"""

{disko-1.4.0 → disko-1.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "disko"
-version = "1.4.0"
+version = "1.4.2"
 description = "Discrete Sky Operator (DiSkO) Aperture Synthesis Radio Imaging"
 authors = [
     {name = "Tim Molteno",email = "tim@elec.ac.nz"}
@@ -21,14 +21,15 @@ dependencies = [
     "pylops>=2.0",
     "toolz>=0.11.2",
     "imageio>=0.6.0b1",
-    "gmsh>=4.9",
+    "gmsh>=4.0",
     "meshio>=5.0",
     "dask-ms>=0.2.25,<0.3.0",
+    "angle-parser>=0.2.0",
 ]
 
 [project.optional-dependencies]
 ms = [
-    "tart2ms>=0.7.1",
+    "tart2ms>=0.9.0",
 ]
 
 [dependency-groups]

{disko-1.4.0 → disko-1.4.2}/uv.lock

@@ -6,6 +6,15 @@ resolution-markers = [
     "python_full_version < '3.12'",
 ]
 
+[[package]]
+name = "angle-parser"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/f7/d23c265e13daa3885406da19dd9798fc121ce0fb008252b38b4a18b8d432/angle_parser-0.2.0.tar.gz", hash = "sha256:83f9444113e4ab0da243fb8139d3dcd20d2b0facf63253e97fd41ece47e0f22f", size = 2748, upload-time = "2026-07-07T02:03:43.583Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/45/4250a354331ea3a36e7abd14fa1313bb87e59c197061a009afa66b0c24ba/angle_parser-0.2.0-py3-none-any.whl", hash = "sha256:8bba1bf8b03acdc04ffb7dfe21a74981ecceaab671c3d36bf95fd34a6271c30c", size = 2840, upload-time = "2026-07-07T02:03:42.288Z" },
+]
+
 [[package]]
 name = "appdirs"
 version = "1.4.4"
@@ -370,9 +379,10 @@ wheels = [
 
 [[package]]
 name = "disko"
-version = "1.3.3"
+version = "1.4.1"
 source = { editable = "." }
 dependencies = [
+    { name = "angle-parser" },
     { name = "dask-ms" },
     { name = "gmsh" },
     { name = "h5py" },
@@ -403,6 +413,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "angle-parser", specifier = "==0.2.0" },
     { name = "dask-ms", specifier = ">=0.2.25,<0.3.0" },
     { name = "gmsh", specifier = ">=4.9" },
     { name = "h5py", specifier = ">=3.7" },

disko-1.4.0/disko/resolution.py

@@ -1,127 +0,0 @@
-#
-# Copyright Tim Molteno 2022-2026 tim@elec.ac.nz
-#
-
-import numpy as np
-
-import astropy.constants as const
-
-
-def parse_ending(x_str, ending):
-    if x_str.endswith(ending):
-        return float(x_str.split(ending)[0])
-    return None
-
-
-DEGREES = "deg"
-MINUTES = 'arcmin'
-SECONDS = 'arcsec'
-MILLIARCSECONDS = 'mas'
-MICROARCSECONDS = 'uas'
-
-
-def rayleigh_criterion(bl, frequency):
-    '''
-        The accepted criterion for determining the diffraction limit to resolution
-        developed by Lord Rayleigh in the 19th century.
-
-        approx resolution given by first order Bessel functions
-        assuming array is a flat disk of length bl
-    '''
-    min_wl = const.c.value / frequency
-    return (1.220 * min_wl / bl)
-
-
-class Resolution:
-    '''
-        Degrees (°), minutes ('), seconds (")
-    '''
-
-    def __init__(self, x_rad):
-        self.x_rad = x_rad
-
-    @classmethod
-    def from_deg(cls, x_deg):
-        return cls(np.radians(x_deg))
-
-    @classmethod
-    def from_rad(cls, x_rad):
-        return cls(x_rad)
-
-    @classmethod
-    def from_arcmin(cls, x_arcmin):
-        return cls(np.radians(x_arcmin/60))
-
-    @classmethod
-    def from_arcsec(cls, x_arcsec):
-        return cls(np.radians(x_arcsec/3600))
-
-    @classmethod
-    def from_string(cls, x_str):
-        endings = [MICROARCSECONDS, MILLIARCSECONDS, SECONDS, MINUTES, DEGREES]
-        deg_factors = [3600*1000000, 3600*1000, 3600, 60, 1]
-        parsed = [parse_ending(x_str, e) for e in endings]
-        for p, f in zip(parsed, deg_factors):
-            if p is not None:
-                return cls.from_deg(p/f)
-
-        return cls.from_deg(float(x_str))
-
-    def radians(self):
-        return self.x_rad
-
-    def degrees(self):
-        return np.degrees(self.x_rad)
-
-    def arcmin(self):
-        return self.degrees() * 60
-
-    def arcsec(self):
-        return self.degrees() * 3600
-
-    def mas(self):
-        return np.de
-
-    def __repr__(self):
-        d = self.degrees()
-        if np.abs(d) > 1:
-            return f"{d:4.2f}deg"
-
-        if np.abs(self.arcmin()) > 1:
-            return f"{self.arcmin():4.2f}{MINUTES}"
-
-        arcsec = self.arcsec()
-        if np.abs(arcsec) > 1:
-            return f"{arcsec:4.2f}{SECONDS}"
-
-        mas = arcsec * 1000
-        if np.abs(mas) >= 1:
-            return f"{mas:4.2f}{MILLIARCSECONDS}"
-
-        uas = mas * 1000
-        return f"{uas:4.2f}{MICROARCSECONDS}"
-
-    def get_min_baseline(self, frequency):
-        '''
-            Get the shortest baseline length (in meters) that will resolve
-            this resolution, at the specified frequency.
-
-            Double-slit interferometer (spacing d). Fringe maxima
-            occur at angles where
-                d * sin(theta) = n * wavelength
-
-            n = 1: sin(theta) = wavelength/d
-            n = 2: sin(theta) = 2*wavelength/d
-
-            angular spacing = wavelength / d
-
-            so d = spacing / theta
-        '''
-        wavelength = const.c.value / frequency
-        spacing = wavelength / self.x_rad
-        return spacing*2    # Nyquist requires twice this...
-
-    @classmethod
-    def from_baseline(cls, bl, frequency):
-        res_limit = rayleigh_criterion(bl, frequency)
-        return cls(res_limit / 2)  # Nyquist requires twice the resolution