spotless 0.7.2__py3-none-any.whl

spotless/__init__.py

@@ -0,0 +1,8 @@
+#
+# Copyright Tim Molteno 2017 tim@elec.ac.nz
+#
+# Init for the spotless imaging algorithm
+
+from .model import Model
+from .source import PointSource
+from .spotless import Spotless

spotless/gridless_cli.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python
+import matplotlib
+import os
+if os.name == 'posix' and "DISPLAY" not in os.environ:
+    matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+import argparse
+import json
+import logging
+from copy import deepcopy
+
+import numpy as np
+
+from tart.operation import settings
+
+from tart_tools import api_handler
+from tart_tools import api_imaging
+from tart.imaging import elaz
+
+from .spotless import Spotless
+from .spotless import get_source_list
+
+
+logger = logging.getLogger()
+
+
+def handle_image(args, img, title, time_repr, src_list=None):
+    """ This function manages the output of an image, drawing sources e.t.c."""
+    image_title = '{}_{}'.format(title, time_repr)
+    plt.title(image_title)
+    if args.fits:
+        fname = '{}.fits'.format(image_title)
+        fpath = os.path.join(args.dir, fname)
+        api_imaging.save_fits_image(img, fname=fname, out_dir=args.dir, timestamp=time_repr)
+        logger.info("Generating {}".format(fname))
+    if args.PNG:
+        fname = '{}.png'.format(image_title)
+        fpath = os.path.join(args.dir, fname)
+        plt.savefig(fpath, dpi=300)
+        logger.info("Generating {}".format(fname))
+    if args.PDF:
+        fname = '{}.pdf'.format(image_title)
+        fpath = os.path.join(args.dir, fname)
+        plt.savefig(fpath, dpi=600)
+        logger.info("Generating {}".format(fname))
+    if args.display:
+        plt.show()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Generate an all-sky TART Gridless Image',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument(
+        '--api', required=False,
+        default='https://tart.elec.ac.nz/signal',
+        help="Telescope API server URL.")
+
+    parser.add_argument('--catalog', required=False, default='https://tart.elec.ac.nz/catalog', help="Catalog API URL.")
+
+    parser.add_argument('--file', required=False, default=None, help="Snapshot ovservation saved JSON file (visiblities, positions and more).")
+    parser.add_argument('--vis', required=False, default=None, help="Use a local JSON file containing the visibilities to create the image.")
+    parser.add_argument('--dir', required=False, default='.', help="Output directory.")
+    parser.add_argument('--rotation', type=float, default=0.0, help="Apply rotation (in degrees) to the antenna positions.")
+    parser.add_argument('--nside', type=int, default=8, help="Healpix nside parameter for display purposes only.")
+
+    parser.add_argument('--beam', action="store_true", help="Generate a gridless beam.")
+
+    parser.add_argument('--elevation', type=float, default=20.0, help="Elevation limit for displaying sources (degrees)")
+    parser.add_argument('--display', action="store_true", help="Display Image to the user")
+    parser.add_argument('--fits', action="store_true", help="Generate a FITS format image")
+    parser.add_argument('--PNG', action="store_true", help="Generate a PNG format image")
+    parser.add_argument('--PDF', action="store_true", help="Generate a PDF format image")
+    parser.add_argument('--show-sources', action="store_true", help="Show known sources on images (only works on PNG).")
+
+    parser.add_argument('--title', required=False, default="", help="Prefix the title.")
+
+    parser.add_argument('--version', action="store_true",
+                        help="Display the current version")
+    parser.add_argument('--debug', action="store_true",
+                        help="Display debugging information")
+
+    source_json = None
+
+    ARGS = parser.parse_args()
+
+    if ARGS.debug:
+        level = logging.DEBUG
+    else:
+        level = logging.ERROR
+
+    logger = logging.getLogger('spotless')
+    logger.setLevel(level)
+
+    if ARGS.debug:
+        fh = logging.FileHandler('spotless.log')
+        fh.setLevel(level)
+
+        # create console handler and set level to debug
+        ch = logging.StreamHandler()
+        ch.setLevel(level)
+
+        # create formatter
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+        # add formatter to ch
+        ch.setFormatter(formatter)
+        fh.setFormatter(formatter)
+
+        # add ch to logger
+        logger.addHandler(ch)
+
+    if ARGS.version:
+        version = version("spotless")
+        print(f"gridless: Version {version}")
+        print("          (c) 2022-2023 Tim Molteno")
+        sys.exit(0)
+
+    
+    if ARGS.file:
+        logger.info("Getting Data from file: {}".format(ARGS.file))
+        # Load data from a JSON file
+        with open(ARGS.file, 'r') as json_file:
+            calib_info = json.load(json_file)
+
+        info = calib_info['info']
+        ant_pos = calib_info['ant_pos']
+        config = settings.from_api_json(info['info'], ant_pos)
+
+        flag_list = [] # [4, 5, 14, 22]
+
+        original_positions = deepcopy(config.get_antenna_positions())
+
+        gains_json = calib_info['gains']
+        gains = np.asarray(gains_json['gain'])
+        phase_offsets = np.asarray(gains_json['phase_offset'])
+        config = settings.from_api_json(info['info'], ant_pos)
+    
+        measurements = []
+        for d in calib_info['data']:
+            vis_json, source_json = d
+            cv, timestamp = api_imaging.vis_calibrated(vis_json, config, gains, phase_offsets, flag_list)
+            src_list = elaz.from_json(source_json, 0.0)
+        if not ARGS.show_sources:
+            src_list = None
+    else:
+        logger.info("Getting Data from API: {}".format(ARGS.api))
+
+        api = api_handler.APIhandler(ARGS.api)
+        config = api_handler.get_config(api)
+
+        gains = api.get('calibration/gain')
+
+        if (ARGS.vis is None):
+            vis_json = api.get('imaging/vis')
+        else:
+            with open(ARGS.vis, 'r') as json_file:
+                vis_json = json.load(json_file)
+
+        ts = api_imaging.vis_json_timestamp(vis_json)
+        if ARGS.show_sources:
+            source_json = api.get_url(api.catalog_url(config, datestr=ts.isoformat()))
+
+        logger.info("Data Download Complete")
+
+        cv, timestamp = api_imaging.vis_calibrated(vis_json, config, gains['gain'], gains['phase_offset'], flag_list=[])
+
+    api_imaging.rotate_vis(ARGS.rotation, cv, reference_positions = deepcopy(config.get_antenna_positions()))
+    
+    time_repr = "{:%Y_%m_%d_%H_%M_%S_%Z}".format(timestamp)
+
+    # Processing
+    should_make_images = ARGS.display or ARGS.PNG or ARGS.fits
+    
+    spot = Spotless(cv)
+    
+    src_list = get_source_list(source_json, el_limit=ARGS.elevation, jy_limit=1e4)
+    
+    if should_make_images:
+        nside = 2**ARGS.nside
+        spt = spot.display(plt, src_list, nside, False)
+        handle_image(ARGS, None, "" + ARGS.title, time_repr, src_list)
+    
+    if ARGS.beam:
+        spot.beam(plt, nside)
+        handle_image(ARGS, None, "dirty", "beam", src_list)

spotless/model.py

@@ -0,0 +1,74 @@
+#
+# Copyright Tim Molteno 2017-2022 tim@elec.ac.nz
+# License GPLv3
+#
+
+import numpy as np
+import json
+
+from .source import PointSource
+
+
+class Model(object):
+
+    def __init__(self):
+        self.objects = []
+
+    def add_source(self, src):
+        self.objects.append(src)
+
+    def __getitem__(self, index):
+        return self.objects[index]
+
+    def model_vis(self, u_arr, v_arr, w_arr):
+        vis = np.zeros_like(u_arr, dtype=np.complex64)
+
+        for src in self.objects:
+            vis += src.get_vis(u_arr, v_arr, w_arr)
+        return vis
+
+    def to_dict(self):
+        ret = {}
+        objs = [obj.to_dict() for obj in self.objects]
+        ret["model"] = objs
+        return ret
+
+    def __repr__(self):
+        return json.dumps(self.to_dict(), indent=4)
+
+    def brightest(self):
+        '''Return Brightest Source'''
+        ret = None
+        b = 0.0
+        for src in self.objects:
+            if src.a > b:
+                b = src.a
+                ret = src
+        return ret
+
+    def faintest(self):
+        '''Return Faintest Source'''
+        ret = None
+        b = 9e99
+        for src in self.objects:
+            if src.a < b:
+                b = src.a
+                ret = src
+        return ret
+
+    def to_vector(self):
+        ret = []
+        for src in self.objects:
+            ret.append(src.a)
+            ret.append(src.el)
+            ret.append(src.az)
+        return np.array(ret)
+
+    @classmethod
+    def from_vector(cls, vect):
+        ret = cls()
+        bits = np.split(vect, len(vect)/3)
+        for src in bits:
+            a, el, az = src
+            ret.add_source(PointSource(a, el, az))
+        return ret

spotless/multi_spotless.py

@@ -0,0 +1,82 @@
+#
+# Copyright Tim Molteno 2017-2022 tim@elec.ac.nz
+# License GPLv3
+#
+
+import logging
+
+import numpy as np
+from scipy.optimize import minimize
+
+from .model import Model
+from .source import PointSource
+from .spotless import Spotless
+
+logger = logging.getLogger(__name__)
+
+
+class MultiSpotless(Spotless):
+    def __init__(self, disko, sphere):
+        super(MultiSpotless, self).__init__(disko, sphere)
+
+    def step(self):
+        """
+        Return a list of residual visibilities and a source location
+        so that the sum of the residual and the source visibilities
+        is conserved.
+        """
+        d_el = self.disko.get_beam_width().radians() / 2
+
+        m_vis = self.model.model_vis(
+            self.disko.u_arr, self.disko.v_arr, self.disko.w_arr
+        )
+
+        a_0, el_0, az_0, p0 = self.estimate_initial_point_source(self.vis_arr - m_vis)
+
+        a_init = max(a_0, 0.01)
+        model_vect = self.model.to_vector()
+        x0 = np.append(model_vect, [a_init, el_0, az_0])
+
+        # Get the bounds of the existing points. Each dimension is
+        # constrained appropriately.
+        bounds = []
+        for src in self.model:
+            for b in src.get_bounds(d_el, self.el_threshold_r):
+                bounds.append(b)
+
+        src = PointSource(a_init, el_0, az_0)
+        for b in src.get_bounds(d_el, self.el_threshold_r):
+            bounds.append(b)
+
+        # Use Nelder-Mead for MultiSpotless: the mixed amplitude/angle
+        # parameter space is poorly scaled, making gradient-based
+        # methods (L-BFGS-B) unreliable. Nelder-Mead only uses function
+        # values and handles this naturally.
+        fmin = minimize(
+            self.f_n,
+            x0.flatten(),
+            method="Nelder-Mead",
+            bounds=bounds,
+            options={
+                "xatol": 1e-3,
+                "fatol": 0.1,
+                "adaptive": True,
+            },
+        )
+        residual_power = fmin.fun
+
+        self.model = Model.from_vector(fmin.x)
+
+        self.residual_vis = self.vis_arr - self.model.model_vis(
+            self.disko.u_arr, self.disko.v_arr, self.disko.w_arr
+        )
+
+        return self.model, residual_power, p0
+
+    def f_n(self, x):
+        """
+        Find the power in the residual
+        """
+        mod = Model.from_vector(x)
+        m_vis = mod.model_vis(self.disko.u_arr, self.disko.v_arr, self.disko.w_arr)
+        return self.power(self.vis_arr - m_vis)

spotless/source.py

@@ -0,0 +1,85 @@
+#
+# Copyright Tim Molteno 2017-2022 tim@elec.ac.nz
+# License GPLv3
+#
+
+import logging
+from disko import jomega
+
+import numpy as np
+import json
+from . import sphere
+
+from tart.util import constants
+
+logger = logging.getLogger(__name__)
+
+
+class PointSource(object):
+    '''
+    A single point source in el,az co-ordinates
+    '''
+
+    def __init__(self, a, el, az):
+        self.a = a
+        self.el = el
+        self.az = az
+        self.power = None   # The power will be set after fitting
+
+    def get_power(self):
+        if self.power is None:
+            return self.a
+        return self.power
+
+    def to_dict(self):
+        ret = {}
+        ret["a"] = self.a
+        ret["el"] = np.degrees(self.el)
+        ret["az"] = np.degrees(self.az)
+        if (self.power is not None):
+            ret["p"] = float(self.power)
+            # return "{p:None, a:{:03.2f}, el:{:03.1f}, az:{:03.1f}},".format(self.a, np.degrees(self.el), np.degrees(self.az))
+        # else:
+            # return "{p:{:03.2f}, a:{:03.2f}, el:{:03.1f}, az:{:03.1f}},".format(self.power,
+            # self.a, np.degrees(self.el), np.degrees(self.az))
+        return ret
+
+    def __repr__(self):
+        return json.dumps(self.to_dict())
+
+    def get_vis(self, u_arr, v_arr, w_arr):
+        '''
+            Generate a list of visibilities from the source at u,v,w points
+            See "The non-coplanar baselines effect in radio interferometry: The W-projection algorithm"
+            by Tim Cornwell. Note that this paper chooses direction cosines (l,m) as its basis for the
+            integral and the image coordinates. It introduces a factor sqrt(1 - l**2 - m**2) which
+            implies that visibilities are infinite when the object is on the horizon (l or m ==1). This
+            is really just a correction because dl dm approaches zero at this point.
+
+            The Smirnov papers on the RIME provide a formalism that is easier to derive algorithms for.
+
+            TODO: Use an antenna model (for the whole telescope initially, and then eventually for each antenna)
+            to modify the source amplitude (self.a) and predict the visibilities from a low-elevation source.
+        '''
+        l, m, n = sphere.elaz2lmn(self.el, self.az)
+
+        p2j = jomega(constants.L1_FREQ)
+        vis = self.a*self.a * \
+            np.exp(-p2j*(u_arr*l + v_arr*m + w_arr*(n - 1.0)))
+        return vis
+
+    def get_bounds(self, d_el, el_threshold_r=0):
+        '''
+            TODO check that the source remains inside the sphere.
+        '''
+        logger.info(f" get_bounds({d_el}, {el_threshold_r})")
+        d_az = np.abs(d_el/(np.cos(self.el) + 0.001))
+
+        el_lower = max(self.el - d_el, el_threshold_r)
+        el_upper = max(el_threshold_r, self.el + d_el)
+
+        logger.info(f" Elevation: ({el_lower}, {el_upper})")
+
+        return [(0.0, None),
+                (el_lower, min(el_upper, np.pi/2)),
+                (self.az - d_az, self.az + d_az)]

spotless/sphere.py

@@ -0,0 +1,28 @@
+#
+# Copyright Tim Molteno 2017-2022 tim@elec.ac.nz
+# License GPLv3
+#
+# Classes to hold pixelated spheres
+#
+
+import logging
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+def elaz2lmn(el_r, az_r):
+    ll = np.sin(az_r)*np.cos(el_r)
+    m = np.cos(az_r)*np.cos(el_r)
+    # Often written in this weird way... np.sqrt(1.0 - l**2 - m**2)
+    n = np.sin(el_r)
+    return ll, m, n
+
+
+def get_peak(sphere):
+    i = np.argmax(sphere.pixels)
+    a_0 = sphere.pixels[i]
+    el_0 = sphere.el_r[i]
+    az_0 = sphere.az_r[i]
+
+    return a_0, el_0, az_0