cal-cabb 0.1.0__tar.gz

cal_cabb-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: cal-cabb
+Version: 0.1.0
+Summary: ATCA CABB continuum calibration pipeline.
+Requires-Python: <3.12,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: astropy>=6.1.7
+Requires-Dist: click>=8.1.8
+Requires-Dist: colorlog>=6.9.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pre-commit>=4.1.0

cal_cabb-0.1.0/cal_cabb/__init__.py

@@ -0,0 +1,9 @@
+from importlib.metadata import version
+
+from casaconfig import config
+
+__version__ = version("cal-cabb")
+
+config.logfile = "/dev/null"
+config.measures_auto_update = False
+config.data_auto_update = False

cal_cabb-0.1.0/cal_cabb/casa.py

@@ -0,0 +1,16 @@
+import casatasks
+
+from cal_cabb.logger import filter_stdout
+
+
+@filter_stdout(
+    "XYZHAND keyword not found in AN table.",
+    "No systemic velocity",
+    "No rest frequency",
+)
+def importuvfits(*args, **kwargs):
+    return casatasks.importuvfits(*args, **kwargs)
+
+
+def listobs(*args, **kwargs):
+    return casatasks.listobs(*args, **kwargs)

cal_cabb-0.1.0/cal_cabb/cli/atca_cal.py

@@ -0,0 +1,218 @@
+import logging
+import os
+from pathlib import Path
+
+import click
+
+from cal_cabb.logger import setupLogger
+from cal_cabb.miriad import BANDS, CABBContinuumPipeline, MiriadWrapper
+
+logger = logging.getLogger(__name__)
+
+
+@click.command(context_settings={"show_default": True})
+@click.option("-B", "--band", type=str, default="L")
+@click.option("-p", "--primary-cal", type=str, default="1934-638")
+@click.option("-s", "--gain-cal", type=str, default=None)
+@click.option("-t", "--target", type=str, default=None)
+@click.option("-l", "--leakage-cal", type=str, default=None)
+@click.option(
+    "-m",
+    "--mfinterval",
+    default="1.0",
+    type=str,
+    help="Time interval to solve for antenna gains in bandpass calibration.",
+)
+@click.option(
+    "-b",
+    "--bpinterval",
+    default="1.0",
+    type=str,
+    help="Time interval to solve for bandpass in bandpass calibration.",
+)
+@click.option(
+    "-g",
+    "--gpinterval",
+    default="0.1",
+    type=str,
+    help="Time interval to solve for antenna gains in gain calibration.",
+)
+@click.option(
+    "-f",
+    "--nfbin",
+    default="4",
+    type=str,
+    help="Number of frequency subbands in which to solve for gains/leakage.",
+)
+@click.option(
+    "-n",
+    "--num-flag-rounds",
+    default=1,
+    type=int,
+    help="Number of rounds in each autoflagging / calibration loop.",
+)
+@click.option(
+    "-r",
+    "--refant",
+    type=click.Choice(["1", "2", "3", "4", "5", "6"]),
+    default="3",
+    help="Reference antenna.",
+)
+@click.option(
+    "--int-freq",
+    type=str,
+    default=None,
+    help="Intermediate Frequency (IF) to select (only valid for L-band)",
+)
+@click.option(
+    "--shiftra",
+    type=str,
+    default="0",
+    help="Offset between pointing and phase centre right ascension in arcsec.",
+)
+@click.option(
+    "--shiftdec",
+    type=str,
+    default="0",
+    help="Offset between pointing and phase centre declination in arcsec.",
+)
+@click.option(
+    "-P",
+    "--strong-pol",
+    is_flag=True,
+    default=False,
+    help="Solve for absolute XY phase and leakage (requires good leakage calibrator)",
+)
+@click.option(
+    "-F",
+    "--noflag",
+    is_flag=True,
+    default=False,
+    help="Disable birdie and rfiflag options in atlod and avoid target flagging.",
+)
+@click.option(
+    "-I",
+    "--interactive",
+    is_flag=True,
+    default=False,
+    help="Run calibration pipeline interactively with manual flagging.",
+)
+@click.option(
+    "-o",
+    "--out-dir",
+    type=Path,
+    default=Path("."),
+    help="Path to store calibrated MeasurementSet.",
+)
+@click.option(
+    "-S",
+    "--skip-pipeline",
+    is_flag=True,
+    default=False,
+    help="Skip execution of flagging/calibration pipeline.",
+)
+@click.option(
+    "-L",
+    "--savelogs",
+    is_flag=True,
+    default=False,
+    help="Store processing logs.",
+)
+@click.option(
+    "-d",
+    "--diagnostics",
+    is_flag=True,
+    default=False,
+    help="Generate diagnostic plots.",
+)
+@click.option(
+    "-k",
+    "--keep-intermediate",
+    is_flag=True,
+    default=False,
+    help="Store intermediate files produced by miriad.",
+)
+@click.option("-v", "--verbose", is_flag=True, default=False)
+@click.argument("data_dir")
+@click.argument("project_code")
+def main(
+    data_dir,
+    project_code,
+    band,
+    primary_cal,
+    gain_cal,
+    target,
+    leakage_cal,
+    strong_pol,
+    mfinterval,
+    bpinterval,
+    gpinterval,
+    nfbin,
+    num_flag_rounds,
+    refant,
+    int_freq,
+    shiftra,
+    shiftdec,
+    noflag,
+    interactive,
+    out_dir,
+    skip_pipeline,
+    savelogs,
+    diagnostics,
+    keep_intermediate,
+    verbose,
+):
+    os.system(f"mkdir -p {out_dir}")
+
+    logfile = out_dir / "atca-cal.log" if savelogs else None
+    setupLogger(verbose=verbose, filename=logfile)
+
+    miriad = MiriadWrapper(
+        data_dir=Path(data_dir),
+        band=BANDS.get(band),
+        project_code=project_code,
+        out_dir=out_dir,
+        strong_pol=strong_pol,
+        mfinterval=mfinterval,
+        bpinterval=bpinterval,
+        gpinterval=gpinterval,
+        nfbin=nfbin,
+        refant=refant,
+        IF=int_freq,
+        noflag=noflag,
+        verbose=verbose,
+    )
+
+    pipeline = CABBContinuumPipeline(
+        miriad=miriad,
+        shiftra=shiftra,
+        shiftdec=shiftdec,
+        num_flag_rounds=num_flag_rounds,
+        interactive=interactive,
+    )
+
+    try:
+        pipeline.miriad.set_targets(
+            primary_cal=primary_cal,
+            leakage_cal=leakage_cal,
+            gain_cal=gain_cal,
+            target=target,
+        )
+    except ValueError as e:
+        logger.error(e)
+        exit(1)
+
+    if not skip_pipeline:
+        pipeline.run()
+
+    if diagnostics:
+        pipeline.make_diagnostics()
+
+    if not keep_intermediate:
+        miriad.cleanup()
+
+    return
+
+
+if __name__ == "__main__":
+    main()

cal_cabb-0.1.0/cal_cabb/logger.py

@@ -0,0 +1,207 @@
+import logging
+import os
+import selectors
+import threading
+from contextlib import contextmanager
+from functools import wraps
+from typing import Callable, Iterable, Optional
+
+import colorlog
+
+
+def setupLogger(verbose: bool, filename: Optional[str] = None) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+
+    # Get root logger disable any existing handlers, and set level
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+    root_logger.handlers = []
+
+    # Turn off some bothersome verbose logging modules
+    logging.getLogger("matplotlib").setLevel(logging.WARNING)
+    logging.getLogger("PIL").setLevel(logging.WARNING)
+    logging.getLogger("urllib").setLevel(logging.WARNING)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    logging.getLogger("h5py").setLevel(logging.INFO)
+
+    if filename:
+        formatter = logging.Formatter(
+            "%(levelname)-8s %(asctime)s - %(name)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+        file_handler = logging.FileHandler(filename)
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.DEBUG)
+
+        root_logger.addHandler(file_handler)
+
+    colorformatter = colorlog.ColoredFormatter(
+        "%(log_color)s%(levelname)-8s%(reset)s %(asctime)s - %(name)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        reset=True,
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "green",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "red,bg_white",
+        },
+    )
+
+    stream_handler = colorlog.StreamHandler()
+    stream_handler.setFormatter(colorformatter)
+    stream_handler.setLevel(level)
+
+    root_logger.addHandler(stream_handler)
+
+    return
+
+
+def parse_stdout_stderr(process, logger, print_stdout: bool = False):
+    """Parse STDOUT and STDERR from a subprocess and redirect to logger."""
+
+    sel = selectors.DefaultSelector()
+    sel.register(process.stdout, selectors.EVENT_READ)
+    sel.register(process.stderr, selectors.EVENT_READ)
+
+    # Filter uninteresting warnings and set to DEBUG level
+    debug_lines = [
+        "### Warning:  Using post-Aug94 ATCA flux scale for 1934-638",
+        "### Warning:  Correlations flagged or edge-rejected:",
+        "PGPLOT /png: writing new file as",
+    ]
+
+    lines_to_parse = True
+    while lines_to_parse:
+        for key, val in sel.select():
+            line = key.fileobj.readline()
+            if not line:
+                lines_to_parse = False
+                break
+
+            line = line.decode().rstrip()
+            debug_line = any(debug_str in line for debug_str in debug_lines)
+
+            if print_stdout:
+                print(line)
+            elif debug_line or key.fileobj is process.stdout:
+                logger.debug(line)
+            else:
+                logger.warning(line.replace("### Warning:  ", ""))
+
+    return
+
+
+logger = logging.getLogger(__name__)
+
+
+def filter_pipe_output(
+    pipe_r: int,
+    substrings: Iterable[str],
+    original_stream_fd: int,
+    stream: str,
+) -> None:
+    """Read lines from a pipe file descriptor and filter to debug/warning."""
+
+    with os.fdopen(pipe_r) as pipe:
+        for line in pipe:
+            if any(substr in line for substr in substrings):
+                continue
+            else:
+                os.write(original_stream_fd, line.encode())
+
+    return
+
+
+@contextmanager
+def redirect_c_output(
+    substrings: Iterable[str],
+    filter_stdout: bool = True,
+    filter_stderr: bool = True,
+):
+    """A context manager to redirect STDOUT / STDERR for both python and C level output."""
+
+    # Save original file descriptors
+    original_stdout_fd = os.dup(1) if filter_stdout else None
+    original_stderr_fd = os.dup(2) if filter_stderr else None
+
+    # Create pipes for capturing output
+    stdout_pipe_r, stdout_pipe_w = os.pipe() if filter_stdout else (None, None)
+    stderr_pipe_r, stderr_pipe_w = os.pipe() if filter_stderr else (None, None)
+
+    # Start threads to read and filter the output
+    stdout_thread = None
+    if filter_stdout:
+        stdout_thread = threading.Thread(
+            target=filter_pipe_output,
+            args=(stdout_pipe_r, substrings, original_stdout_fd, "STDOUT"),
+            daemon=True,
+        )
+        stdout_thread.start()
+
+    stderr_thread = None
+    if filter_stderr:
+        stderr_thread = threading.Thread(
+            target=filter_pipe_output,
+            args=(stderr_pipe_r, substrings, original_stderr_fd, "STDERR"),
+            daemon=True,
+        )
+        stderr_thread.start()
+
+    try:
+        # Redirect STDOUT / STDERR to pipe for filtering
+        if filter_stdout:
+            os.dup2(stdout_pipe_w, 1)
+        if filter_stderr:
+            os.dup2(stderr_pipe_w, 2)
+
+        yield
+
+    finally:
+        # Restore original file descriptors
+        if filter_stdout:
+            os.dup2(original_stdout_fd, 1)
+        if filter_stderr:
+            os.dup2(original_stderr_fd, 2)
+
+        # Close the write ends of the pipes to signal EOF to the threads
+        if filter_stdout:
+            os.close(stdout_pipe_w)
+        if filter_stderr:
+            os.close(stderr_pipe_w)
+
+        # Wait for threads to finish
+        if stdout_thread:
+            stdout_thread.join()
+        if stderr_thread:
+            stderr_thread.join()
+
+        # Close the original file descriptors and pipes
+        if filter_stdout:
+            os.close(original_stdout_fd)
+        if filter_stderr:
+            os.close(original_stderr_fd)
+
+    return
+
+
+def filter_stdout(
+    *substrings: str,
+    filter_stdout: bool = True,
+    filter_stderr: bool = True,
+):
+    """A decorator to filter C-level STDOUT/STDERR from within CASA function calls."""
+
+    def decorator(func: Callable):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            with redirect_c_output(
+                substrings,
+                filter_stdout=filter_stdout,
+                filter_stderr=filter_stderr,
+            ):
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

cal_cabb-0.1.0/cal_cabb/miriad.py

@@ -0,0 +1,516 @@
+import glob
+import logging
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import astropy.units as u
+import pandas as pd
+
+import cal_cabb
+from cal_cabb.casa import importuvfits, listobs
+from cal_cabb.logger import parse_stdout_stderr
+
+logger = logging.getLogger(__name__)
+
+package_root = cal_cabb.__path__[0]
+
+
+def prompt(msg, bypass=False, bypass_msg=None, default_response=True):
+    if bypass:
+        if bypass_msg is not None:
+            logger.warning(bypass_msg)
+        return default_response
+
+    msg = f"{msg} (y/n)\n"
+
+    resp = input(msg)
+    if resp not in ["y", "n"]:
+        resp = input(msg)
+
+    return True if resp == "y" else False
+
+
+@dataclass
+class Target:
+    name: str
+    path: Path
+
+
+@dataclass
+class Band:
+    freq: str
+    spec: str
+    IF: str
+
+
+BANDS = {
+    "L": Band(freq="2100", spec="2.1", IF="1"),
+    "C": Band(freq="5500", spec="5.5", IF="1"),
+    "X": Band(freq="9000", spec="9.0", IF="2"),
+    "K": Band(freq="12000", spec="12.0", IF="1"),
+}
+
+
+@dataclass
+class MiriadWrapper:
+    data_dir: Path
+    band: Band
+    project_code: str
+    mfinterval: float = 1.0
+    bpinterval: float = 1.0
+    gpinterval: float = 0.1
+    nfbin: int = 4
+    refant: int = 3
+    IF: str = None
+    noflag: bool = False
+    strong_pol: bool = False
+    out_dir: Path = Path(".")
+    verbose: bool = False
+
+    def __post_init__(self):
+        # Handle selection of IF in L-band
+        if self.IF is not None and self.band.freq == "2100":
+            self.band.IF = self.IF
+
+        self.IF = self.band.IF
+
+        self.uvfile = self.out_dir / "miriad" / f"{self.project_code}.uv"
+        self.opts = {
+            "mfinterval": self.mfinterval,
+            "bpinterval": self.bpinterval,
+            "gpinterval": self.gpinterval,
+            "nfbin": self.nfbin,
+            "ifsel": self.IF,
+            "spec": self.band.spec,
+            "refant": self.refant,
+        }
+        logger.debug("Miriad options set to:")
+        for k, v in self.opts.items():
+            logger.debug(f"{k}={v}")
+
+    def run_command(self, command, args=None, print_stdout=False):
+        if args is not None:
+            args = " ".join([f"{arg}" for arg in args])
+        else:
+            args = ""
+
+        exports = " ".join(f"export {opt}='{val}';" for opt, val in self.opts.items())
+
+        p = subprocess.Popen(
+            f"source {package_root}/functions.sh; {exports} {command} {args}",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=True,
+            executable="/bin/bash",
+        )
+
+        parse_stdout_stderr(p, logger, print_stdout)
+
+        return
+
+    def load_data(self, shiftra: str, shiftdec: str):
+        logger.info(f"Loading RPFITS files from {self.data_dir}")
+        self.run_command(
+            "load_data",
+            args=[
+                str(self.out_dir.absolute()),
+                str(self.data_dir),
+                "true" if self.noflag else "false",
+                str(self.project_code),
+                shiftra,
+                shiftdec,
+            ],
+        )
+
+        return
+
+    def path(self, target: str):
+        if target is None:
+            return Target(name=None, path=None)
+
+        path = Path(self.out_dir / "miriad" / f"{target}.{self.band.freq}")
+        return Target(name=target, path=path)
+
+    def set_targets(
+        self,
+        primary_cal: str = "1934-638",
+        gain_cal: Optional[str] = None,
+        target: Optional[str] = None,
+        leakage_cal: Optional[str] = None,
+    ):
+        ms = self.generate_ms(self.uvfile)
+
+        # Read and store scan summary
+        header = listobs(vis=ms)
+        scan_keys = [key for key in header.keys() if "scan" in key]
+        df = pd.DataFrame({scan: header[scan]["0"] for scan in scan_keys}).T
+        df["ScanTime"] = (df.EndTime - df.BeginTime) * u.day.to(u.min)
+        self.scans = df.sort_values("scanId").reset_index()
+
+        fields = [
+            str(Path(p).name).replace(f".{self.band.freq}", "")
+            for p in glob.glob(f"{self.out_dir}/miriad/*.{self.band.freq}")
+        ]
+
+        # Clean up intermediate files
+        os.system(f"rm -r {ms}")
+
+        if primary_cal not in fields:
+            raise ValueError(f"Could not locate {primary_cal} field in {self.uvfile}")
+
+        # Assume target and gain calibrator are two objects with most observing time
+        total_times = (
+            df.groupby("FieldName").ScanTime.sum().reset_index().sort_values("ScanTime")
+        )
+
+        if gain_cal is None:
+            gain_cal = total_times.iloc[-2].FieldName
+            logger.info(f"No gain calibrator specified, defaulting to {gain_cal}")
+        if target is None:
+            target = total_times.iloc[-1].FieldName
+            logger.info(f"No science target specified, defaulting to {target}")
+
+        self.target_paths = {
+            "primary_cal": self.path(primary_cal),
+            "gain_cal": self.path(gain_cal),
+            "leakage_cal": self.path(leakage_cal),
+            "target": self.path(target),
+        }
+
+        return
+
+    def blflag(self, vis, x, y, options):
+        per_bl = "" if "nobase" in options else "per baseline"
+        logger.info(f"Manually flagging {vis} in {y} vs {x} {per_bl}")
+        self.run_command(
+            "manflag",
+            args=[vis, x, y, options],
+            print_stdout=True,
+        )
+
+    def autoflag(self, vis):
+        logger.info(f"Autoflagging {vis}")
+        self.run_command("autoflag", args=[vis])
+
+    def flag_times(self, vis, start_time, end_time):
+        logger.info(f"Flagging {vis} between {start_time}-{end_time}")
+        self.run_command("flag_timerange", args=[vis, start_time, end_time])
+
+    def bandpass(self, vis):
+        logger.info(f"Running bandpass calibration on {vis}")
+        interpolate = "true" if self.noflag else "false"
+        self.run_command("cal_bandpass", args=[vis, interpolate])
+
+    def bootstrap(self, vis1, vis2):
+        if vis1 != vis2:
+            logger.info(f"Bootstrapping flux scale from {vis2.name} to {vis1.name}")
+            self.run_command("bootstrap", args=[vis1, vis2])
+
+    def gaincal(self, vis, options):
+        logger.info(f"Running gain/leakage calibration on {vis}")
+        self.run_command("cal_gains", args=[vis, options])
+
+    def copycal(self, vis1, vis2):
+        logger.info(f"Copying calibration tables from {vis1.name} to {vis2.name}")
+        self.run_command("copy_cal", args=[vis1, vis2])
+
+    def gpaver(self, vis):
+        logger.info(f"Averaging calibration solutions for {vis}")
+        self.run_command("average_gains", args=[vis])
+
+    def uvaver(self, vis):
+        logger.info(f"Applying calibration solutions to {vis}")
+        self.run_command("apply_gains", args=[vis])
+
+    def generate_ms(self, uv):
+        fitsfile = f"{uv}.fits"
+        ms = f"{uv}.ms"
+
+        self.run_command("uvtofits", args=[uv, fitsfile])
+
+        importuvfits(
+            fitsfile=fitsfile,
+            vis=ms,
+        )
+
+        os.system(f"rm -r {fitsfile}")
+
+        return ms
+
+    def cleanup(self):
+        os.system(f"rm -r {self.out_dir / 'miriad'}")
+
+
+@dataclass
+class CABBContinuumPipeline:
+    miriad: MiriadWrapper
+    shiftra: float
+    shiftdec: float
+    num_flag_rounds: int
+    interactive: bool
+
+    def __post_init__(self):
+        if os.path.exists(self.miriad.uvfile):
+            logger.warning(f"{self.miriad.uvfile} already exists, will not overwrite")
+            return
+
+        self.miriad.load_data(self.shiftra, self.shiftdec)
+
+    def flag_sequence(self, target):
+        self.miriad.blflag(
+            target,
+            x="time",
+            y="amp",
+            options="nofqav,nobase",
+        )
+        self.miriad.blflag(
+            target,
+            x="chan",
+            y="amp",
+            options="nofqav,nobase",
+        )
+        self.miriad.blflag(
+            target,
+            x="chan",
+            y="amp",
+            options="nofqav",
+        )
+        self.miriad.autoflag(target)
+        self.miriad.blflag(
+            target,
+            x="real",
+            y="imag",
+            options="nofqav,nobase",
+        )
+
+        return
+
+    def make_diagnostics(self):
+        logger.info("Generating calibration diagnostic plots")
+
+        cwd = Path(".").absolute()
+        os.system(f"mkdir -p {self.miriad.out_dir}/diagnostics")
+        os.chdir(self.miriad.out_dir)
+
+        pcal = self.miriad.target_paths.get("primary_cal").path.relative_to(
+            self.miriad.out_dir
+        )
+        scal = self.miriad.target_paths.get("gain_cal").path.relative_to(
+            self.miriad.out_dir
+        )
+
+        calibrators = set([pcal, scal])
+
+        # Primary / secondary plots
+        for vis in calibrators:
+            self.miriad.run_command(
+                f"uvfmeas vis={vis} \
+                stokes=i \
+                device=diagnostics/{vis.name}_spectrum.png/PNG"
+            )
+            self.miriad.run_command(
+                f"uvplt vis={vis} \
+                stokes=i  \
+                axis=re,im \
+                options=nofqav,nobase \
+                device=diagnostics/{vis.name}_real_imag.png/PNG"
+            )
+            self.miriad.run_command(
+                f"uvplt vis={vis} \
+                stokes=i \
+                axis=freq,phase \
+                nxy=4 \
+                options=nofqav \
+                device=diagnostics/{vis.name}_phase_spectrum.png/PNG"
+            )
+            self.miriad.run_command(
+                f"gpplt vis={vis} \
+                options=gains \
+                yaxis=amp,phase \
+                log=diagnostics/{vis.name}_gains.txt"
+            )
+            self.miriad.run_command(
+                f"gpplt vis={vis} \
+                options=polarization \
+                yaxis=amp,phase \
+                log=diagnostics/{vis.name}_leakages.txt"
+            )
+
+        # Primary plots
+        self.miriad.run_command(
+            f"gpplt vis={pcal} \
+            options=dots,bandpass \
+            log=diagnostics/{vis.name}_bandpass.txt \
+            device=diagnostics/{pcal.name}_bandpass.png/PNG"
+        )
+
+        # Secondary plots
+        self.miriad.run_command(
+            f"uvplt vis={scal} \
+            stokes=i \
+            axis=time,amp \
+            options=nofqav,nobase \
+            device=diagnostics/{scal.name}_amp_time.png/PNG"
+        )
+        self.miriad.run_command(
+            f"uvplt vis={scal} \
+            stokes=xx,yy \
+            axis=time,phase \
+            options=nofqav,nobase \
+            device=diagnostics/{scal.name}_phase_time.png/PNG"
+        )
+        self.miriad.run_command(
+            f"uvplt vis={scal} \
+            stokes=i \
+            axis=uc,vc \
+            options=nofqav,nobase \
+            device=diagnostics/{scal.name}_uv_coverage.png/PNG"
+        )
+        self.miriad.run_command(
+            f"uvplt vis={scal} \
+            stokes=i \
+            axis=time,parang \
+            options=nofqav,nobase \
+            device=diagnostics/{scal.name}_parang_coverage.png/PNG"
+        )
+        self.miriad.run_command(
+            f"gpplt vis={scal} \
+            options=dots,wrap \
+            yaxis=phase \
+            yrange=-180,180 \
+            device=diagnostics/phase_solutions.png/PNG"
+        )
+        self.miriad.run_command(
+            f"gpplt vis={scal} \
+            options=dots,xygains,wrap \
+            yaxis=phase \
+            yrange=-10,10 \
+            device=diagnostics/xy-phase_solutions.png/PNG"
+        )
+
+        # Rename bandpass plots for XX and YY polarisations
+        self.miriad.run_command(
+            f"mv \
+            diagnostics/{pcal.name}_bandpass.png \
+            diagnostics/{pcal.name}_bandpass_xx.png"
+        )
+        self.miriad.run_command(
+            f"mv \
+            diagnostics/{pcal.name}_bandpass.png_2 \
+            diagnostics/{pcal.name}_bandpass_yy.png"
+        )
+
+        # Remove all sub-band phase/xy-phase solution plots
+        for plot in glob.glob("diagnostics/*png_*"):
+            self.miriad.run_command(f"rm {plot}")
+
+        os.chdir(cwd)
+
+        return
+
+    def run(self):
+        primary_cal = self.miriad.target_paths.get("primary_cal").path
+        gain_cal = self.miriad.target_paths.get("gain_cal").path
+        target = self.miriad.target_paths.get("target").path
+        leakage_cal = self.miriad.target_paths.get("leakage_cal").path
+
+        if os.path.exists(f"{self.miriad.out_dir}/{target.name}.ms"):
+            logger.warning(
+                f"{self.miriad.out_dir}/{target.name}.ms already exists, will not overwrite"
+            )
+            return
+
+        # Primary bandpass / flux calibrator
+        # ---------------------------------
+        self.miriad.bandpass(primary_cal)
+
+        # Flag and solve for bandpass on primary calibrator
+        if self.interactive:
+            while prompt(f"Start interactive flagging of {primary_cal.name}?"):
+                self.flag_sequence(primary_cal)
+                self.miriad.bandpass(primary_cal)
+        else:
+            for _ in range(self.num_flag_rounds):
+                self.miriad.autoflag(primary_cal)
+                self.miriad.bandpass(primary_cal)
+
+        # Solve for primary calibrator gains / leakage
+        self.miriad.gaincal(primary_cal, options="xyvary")
+
+        # Set options to work with strong or weakly polarised calibrator
+        if self.miriad.strong_pol:
+            gp_options = "xyvary,qusolve,vsolve,xyref,polref"
+
+        else:
+            gp_options = "xyvary,qusolve"
+
+        # TODO:
+        # add flexibility for low parang coverage in which we switch off
+        # xy phase and pol corrections
+
+        # Leakage calibrator
+        # ------------------
+        if leakage_cal is not None:
+            self.miriad.copycal(primary_cal, leakage_cal)
+
+            # Flag and solve for gains / leakages / xy-phase on leakage calibrator
+            if self.interactive:
+                while prompt(f"Start interactive flagging of {leakage_cal.name}?"):
+                    self.flag_sequence(leakage_cal)
+                    self.miriad.gaincal(leakage_cal, options=gp_options)
+            else:
+                for _ in range(self.num_flag_rounds):
+                    self.miriad.autoflag(leakage_cal)
+                    self.miriad.gaincal(leakage_cal, options=gp_options)
+
+            # To avoid corruption of Stokes V zero-point, we copy solutions
+            # back to primary calibrator and repeat the sequence
+            self.miriad.copycal(leakage_cal, primary_cal)
+            self.miriad.gaincal(primary_cal, options="noxy")
+            self.miriad.copycal(primary_cal, leakage_cal)
+            self.miriad.gaincal(leakage_cal, options=gp_options)
+
+            # Now we turn off xy-phase / leakage calibration for subsequent gain calibration
+            self.miriad.copycal(leakage_cal, gain_cal)
+            gp_options = "qusolve,noxy,nopol"
+        else:
+            if primary_cal != gain_cal:
+                self.miriad.copycal(primary_cal, gain_cal)
+
+        # Secondary gain calibrator
+        # -------------------------
+        if primary_cal != gain_cal:
+            if self.interactive:
+                while prompt(f"Start interactive flagging of {gain_cal.name}?"):
+                    self.flag_sequence(gain_cal)
+                    self.miriad.gaincal(gain_cal, options=gp_options)
+            else:
+                for _ in range(self.num_flag_rounds):
+                    self.miriad.autoflag(gain_cal)
+                    self.miriad.gaincal(gain_cal, options=gp_options)
+
+            self.miriad.bootstrap(gain_cal, primary_cal)
+
+        # Science target
+        # --------------
+        self.miriad.copycal(gain_cal, target)
+
+        if not self.miriad.noflag:
+            self.miriad.autoflag(target)
+
+        # Average solutions and apply
+        # --------------------------
+        self.miriad.gpaver(target)
+        self.miriad.uvaver(gain_cal)
+        self.miriad.uvaver(target)
+
+        self.miriad.generate_ms(f"{target}.cal")
+        self.miriad.generate_ms(f"{gain_cal}.cal")
+        self.miriad.run_command(
+            f"mv {target}.cal.ms {self.miriad.out_dir}/{target.name}.ms"
+        )
+
+        return

cal_cabb-0.1.0/cal_cabb.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: cal-cabb
+Version: 0.1.0
+Summary: ATCA CABB continuum calibration pipeline.
+Requires-Python: <3.12,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: astropy>=6.1.7
+Requires-Dist: click>=8.1.8
+Requires-Dist: colorlog>=6.9.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pre-commit>=4.1.0

cal_cabb-0.1.0/cal_cabb.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+cal_cabb/__init__.py
+cal_cabb/casa.py
+cal_cabb/logger.py
+cal_cabb/miriad.py
+cal_cabb.egg-info/PKG-INFO
+cal_cabb.egg-info/SOURCES.txt
+cal_cabb.egg-info/dependency_links.txt
+cal_cabb.egg-info/entry_points.txt
+cal_cabb.egg-info/requires.txt
+cal_cabb.egg-info/top_level.txt
+cal_cabb/cli/atca_cal.py

cal_cabb-0.1.0/cal_cabb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cal_cabb-0.1.0/cal_cabb.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+atca-cal = cal_cabb.cli.atca_cal:main

cal_cabb-0.1.0/cal_cabb.egg-info/requires.txt

@@ -0,0 +1,5 @@
+astropy>=6.1.7
+click>=8.1.8
+colorlog>=6.9.0
+pandas>=2.2.3
+pre-commit>=4.1.0

cal_cabb-0.1.0/cal_cabb.egg-info/top_level.txt

@@ -0,0 +1 @@
+cal_cabb

cal_cabb-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "cal-cabb"
+version = "0.1.0"
+description = "ATCA CABB continuum calibration pipeline."
+readme = "README.md"
+requires-python = ">=3.11,<3.12"
+dependencies = [
+    "astropy>=6.1.7",
+    "click>=8.1.8",
+    "colorlog>=6.9.0",
+    "pandas>=2.2.3",
+    "pre-commit>=4.1.0",
+]
+
+[project.scripts]
+atca-cal = "cal_cabb.cli.atca_cal:main"
+
+[dependency-groups]
+dev = [
+    "isort>=6.0.0",
+    "mypy>=1.15.0",
+    "pre-commit>=4.1.0",
+    "ruff>=0.9.7",
+]
+
+
+[tool.ruff]
+lint.ignore = ["E741"]

cal_cabb-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+