pclean — Parallel CLEAN Imaging with Dask

pclean is a modular, Dask-accelerated radio-interferometric imaging package that wraps CASA's synthesis imaging C++ tools (casatools) to provide transparent parallelism for cube (channel-distributed) and continuum (row-distributed) imaging workflows.

Features

Quick start

from pclean import pclean

# Parallel cube imaging (channels distributed across workers)
pclean(
    vis='my.ms',
    imagename='cube_out',
    specmode='cube',
    imsize=[512, 512],
    cell='1arcsec',
    niter=1000,
    deconvolver='hogbom',
    parallel=True,
    nworkers=8,
    cube_chunksize=1,       # one sub-cube per channel (max parallelism)
)

# Parallel continuum imaging (visibility rows chunked)
pclean(
    vis='my.ms',
    imagename='cont_out',
    specmode='mfs',
    imsize=[2048, 2048],
    cell='0.5arcsec',
    niter=5000,
    deconvolver='mtmfs',
    nterms=2,
    parallel=True,
    nworkers=4,
)

Command-line interface

python -m pclean --vis my.ms --imagename out --specmode cube \
    --imsize 512 512 --cell 1arcsec --niter 1000 \
    --parallel --nworkers 8

Additional parameters

Beyond the standard tclean parameters, pclean accepts:

Architecture

pclean/
├── src/pclean/
│   ├── __init__.py                # Package init, exposes pclean()
│   ├── __main__.py                # CLI entry point (python -m pclean)
│   ├── pclean.py                  # Top-level tclean-like interface
│   ├── params.py                  # Parameter container & validation
│   ├── imaging/
│   │   ├── serial_imager.py       # Single-process imager (base engine)
│   │   ├── deconvolver.py         # Deconvolution wrapper
│   │   └── normalizer.py          # Image normalization (gather/scatter)
│   ├── parallel/
│   │   ├── cluster.py             # Dask cluster lifecycle management
│   │   ├── cube_parallel.py       # Channel-parallel cube imaging
│   │   ├── continuum_parallel.py  # Row-parallel continuum imaging
│   │   └── worker_tasks.py        # Serialisable functions for workers
│   └── utils/
│       ├── partition.py           # Data / image partitioning helpers
│       ├── image_concat.py        # Sub-cube image concatenation
│       ├── memory_estimate.py     # Worker RAM estimation heuristics
│       ├── check_adios2.py        # Adios2StMan availability check
│       └── convert_adios2.py      # MS → ADIOS2 conversion utility

Documentation

Full documentation is hosted at pclean.readthedocs.io.

Requirements

• Python ≥ 3.10
• casatools ≥ 6.5
• dask + distributed
• numpy
• pydantic ≥ 2.0

Pixi environments

The project uses pixi for reproducible environment management. Four environments are defined in pyproject.toml:

Common tasks are exposed as pixi scripts:

pixi run -e dev test          # pytest -v
pixi run -e dev test-cov      # pytest with coverage
pixi run -e dev lint          # ruff check
pixi run -e dev fmt           # ruff format

References and acknowledgements

pclean builds on the imaging and calibration infrastructure developed by the CASA team at NRAO / ESO / NAOJ. The scientific algorithms — gridding, deconvolution, self-calibration — are the product of decades of CASA development; pclean is purely a computing-engineering effort that re-orchestrates those mature tools with a modern distributed runtime.

If this package contributes to published research, please cite the CASA software:

CASA Team, Bean, B., Bhatnagar, S., et al. 2022, "CASA, the Common Astronomy Software Applications for Radio Astronomy," PASP, 134, 114501. doi:10.1088/1538-3873/ac9642

McMullin, J. P., Waters, B., Schiebel, D., Young, W., & Golap, K. 2007, "CASA Architecture and Applications," ASP Conf. Ser., 376, 127. ads:2007ASPC..376..127M

Relation to CASA's built-in parallel imaging

pclean's parallel design closely follows the Python orchestration layer that CASA's tclean task already provides through the casatasks.private.imagerhelpers module:

The structural decomposition is the same: partition → image → normalize → deconvolve → iterate, with the same split between embarrassingly-parallel cube channels and gather/scatter continuum cycles. Both code-bases use polymorphic dispatch — task_tclean.py picks between PySynthesisImager, PyParallelCubeSynthesisImager, or PyParallelContSynthesisImager based on specmode and MPI availability; pclean makes the same choice based on its own parallel and is_cube flags.

The key difference is the parallelism transport. CASA's PyParallelImagerHelper sends Python code strings to MPI workers via casampi.MPIInterface, requiring mpicasa and a shared filesystem. pclean replaces this with Dask Distributed futures and actors, eliminating the MPI dependency in exchange for Dask scheduling overhead.

See also CASA Memo 13 (Sekhar, Rau & Xue 2024) for benchmarking of per-channel cube imaging distributed via SLURM job arrays that motivated this work (benchmarking scripts).

License

Copyright 2026 the pclean authors.

GPL-3.0-or-later — see LICENSE for details.

Disclaimer

This project is an independent, personal effort developed on the authors' own time. It is not affiliated with, endorsed by, or conducted as part of any employer's projects or responsibilities.

AI Disclosure

This project was developed with the assistance of AI coding agents (GitHub Copilot, Claude). The AI contributed to code generation, debugging, and documentation under human direction and review.