xradio 1.0.2__py3-none-any.whl → 1.1.1__py3-none-any.whl

xradio/image/image.py

@@ -12,22 +12,25 @@ import shutil
 import toolviper.utils.logger as logger
 import xarray as xr
 
-# from .._utils.zarr.common import _load_no_dask_zarr
-
-# from ._util.fits import _read_fits_image
-from ._util.image_factory import (
+from xradio.image._util.image_factory import (
     _make_empty_aperture_image,
     _make_empty_lmuv_image,
     _make_empty_sky_image,
 )
-from ._util.zarr import _load_image_from_zarr_no_dask, _xds_from_zarr, _xds_to_zarr
-from ._util._fits.xds_from_fits import _fits_image_to_xds
+from xradio.image._util.zarr import (
+    _load_image_from_zarr_no_dask,
+    _xds_from_zarr,
+    _xds_to_zarr,
+)
+from xradio.image._util._fits.xds_from_fits import _fits_image_to_xds
 
-warnings.filterwarnings("ignore", category=FutureWarning)
+from xradio.image._util.image_factory import create_image_xds_from_store
 
+# warnings.filterwarnings("ignore", category=FutureWarning)
 
-def read_image(
-    infile: str,
+
+def open_image(
+    store: Union[str, dict],
     chunks: dict = {},
     verbose: bool = False,
     do_sky_coords: bool = True,
@@ -65,9 +68,9 @@ def read_image(
 
     Parameters
     ----------
-    infile : str
-        Path to the input CASA image
-    :chunks : dict
+    store : str
+        Path to the input image
+    chunks : dict
         The desired dask chunk size. Only applicable for casacore and fits images.
         Supported optional keys are 'l', 'm', 'frequency', 'polarization', and 'time'.
         The supported values are positive integers, indicating the length of a chunk
@@ -75,7 +78,7 @@ def read_image(
         along that axis is equal to the number of pixels along that axis. For zarr
         images, this parameter is ignored and the chunk size used to store the arrays
         in the zarr image is used. 'l' represents the longitude like dimension, and 'm'
-        represents the latitude like dimension. For apeature images, 'u' may be used in
+        represents the latitude like dimension. For aperture images, 'u' may be used in
         place of 'l', and 'v' in place of 'm'.
     verbose : bool
         emit debugging messages? Default is False.
@@ -105,47 +108,36 @@ def read_image(
     -------
     xarray.Dataset
     """
-    # from ._util.casacore import _read_casa_image
-    # return _read_casa_image(infile, chunks, verbose, do_sky_coords)
-    emsgs = []
-    do_casa = True
-    try:
-        from ._util.casacore import _read_casa_image
-    except Exception as e:
-        emsgs.append(
-            "python-casacore could not be imported, will not try to "
-            f"read as casacore image: {e.args}"
-        )
-        do_casa = False
-    if do_casa:
-        # next statement is short circuit for debug, comment out when not debugging
-        # return _read_casa_image(infile, chunks, verbose, do_sky_coords)
-        try:
-            return _read_casa_image(infile, chunks, verbose, do_sky_coords)
-        except Exception as e:
-            emsgs.append(f"image format appears not to be casacore: {e.args}")
-    # next statement is for debug, comment when done debugging
-    # return _fits_image_to_xds(infile, chunks, verbose, do_sky_coords, compute_mask)
-    try:
-        img_full_path = os.path.expanduser(infile)
-        return _fits_image_to_xds(infile, chunks, verbose, do_sky_coords, compute_mask)
-    except Exception as e:
-        emsgs.append(f"image format appears not to be fits {e.args}")
-    # when done debuggin comment out next line
-    # return _xds_from_zarr(infile, {"dv": "dask", "coords": "numpy"}, selection=selection)
-    try:
-        return _xds_from_zarr(
-            infile, {"dv": "dask", "coords": "numpy"}, selection=selection
-        )
-    except Exception as e:
-        emsgs.append(f"image format appears not to be zarr {e.args}")
-    emsgs.insert(
-        0, f"Unrecognized image format. Supported types are CASA, FITS, and zarr.\n"
+    # try:
+    #       from ._util.casacore import _open_casa_image
+    # except ModuleNotFoundError as exc:
+    #     logger.warning(
+    #         "Could not import the function to convert from MSv2 to MSv4. "
+    #         f"That functionality will not be available. Details: {exc}"
+    #     )
+    #     _open_casa_image = None
+
+    from ._util.casacore import _open_casa_image
+
+    img_xds = create_image_xds_from_store(
+        store,
+        _open_casa_image,
+        {"chunks": chunks, "verbose": verbose, "do_sky_coords": do_sky_coords},
+        _fits_image_to_xds,
+        {
+            "chunks": chunks,
+            "verbose": verbose,
+            "do_sky_coords": do_sky_coords,
+            "compute_mask": compute_mask,
+        },
+        _xds_from_zarr,
+        {"output": {"dv": "dask", "coords": "numpy"}, "selection": selection},
     )
-    raise RuntimeError("\n".join(emsgs))
 
+    return img_xds
 
-def load_image(infile: str, block_des: dict = None, do_sky_coords=True) -> xr.Dataset:
+
+def load_image(store: str, block_des: dict = None, do_sky_coords=True) -> xr.Dataset:
     """
     Load an image or portion of an image (subimage) into memory with data variables
     being converted from dask to numpy arrays and coordinate arrays being converted
@@ -154,7 +146,7 @@ def load_image(infile: str, block_des: dict = None, do_sky_coords=True) -> xr.Da
 
     Parameters
     ----------
-    infile : str
+    store : str
         Path to the input image, currently CASA and zarr images are supported
     block_des : dict
         The description of data to return, supported keys are time,
@@ -176,9 +168,6 @@ def load_image(infile: str, block_des: dict = None, do_sky_coords=True) -> xr.Da
     -------
     xarray.Dataset
     """
-    do_casa = True
-    emsgs = []
-
     if block_des is None:
         block_des = {}
 
@@ -187,52 +176,35 @@ def load_image(infile: str, block_des: dict = None, do_sky_coords=True) -> xr.Da
         for k, v in selection.items():
             if type(v) == int:
                 selection[k] = slice(v, v + 1)
-    try:
-        from ._util.casacore import _read_casa_image
-    except Exception as e:
-        emsgs.append(
-            "python-casacore could not be imported, will not try to "
-            f"read as casacore image: {e.args}"
-        )
-        do_casa = False
-    if do_casa:
-        # comment next line when done debugging
-        # return _load_casa_image_block(infile, selection, do_sky_coords)
-        try:
-            from ._util.casacore import _load_casa_image_block
-
-            return _load_casa_image_block(infile, selection, do_sky_coords)
-        except Exception as e:
-            emsgs.append(f"image format appears not to be casacore: {e.args}")
-    """
-    try:
-        return __read_fits_image(infile, chunks, masks, history, verbose)
-    except Exception as e:
-        emsgs.append(f'image format appears not to be fits {e.args}')
-    """
-    # when done debugging, comment out next line
-    # return _load_image_from_zarr_no_dask(infile, block_des)
-    # return _xds_from_zarr(infile, {"dv": "numpy"}, selection)
-    try:
-        return _load_image_from_zarr_no_dask(infile, block_des)
-        # return _xds_from_zarr(infile, {"dv": "numpy", "coords": "numpy"}, selection)
-    except Exception as e:
-        emsgs.append(f"image format appears not to be zarr {e.args}")
-    emsgs.insert(
-        0, f"Unrecognized image format. Supported formats are casacore and zarr.\n"
+
+    from ._util.casacore import _load_casa_image_block
+
+    img_xds = create_image_xds_from_store(
+        store,
+        _load_casa_image_block,
+        {"block_des": selection, "do_sky_coords": do_sky_coords},
+        None,
+        {},
+        _xds_from_zarr,
+        {"output": {"dv": "dask", "coords": "numpy"}, "selection": selection},
     )
-    raise RuntimeError("\n".join(emsgs))
+    return img_xds
 
 
 def write_image(
     xds: xr.Dataset, imagename: str, out_format: str = "casa", overwrite: bool = False
 ) -> None:
     """
+    TODO: I think the user should be permitted to specify data groups to write.
     Convert an xds image to CASA or zarr image.
     xds : xarray.Dataset
         XDS to convert
     imagename : str
         Path to output image
+        For writing to CASA, it is possible multiple images will be created, based
+        on what are in the data groups. If multiple images are created, the imagenames
+        will have identifying extensions added to the provided imagename. If only one
+        image is created, the provided imagename will be used as is.
     out_format : str
         Format of output image, currently "casa" and "zarr" are supported
     overwrite : bool
@@ -256,9 +228,9 @@ def write_image(
             )
     my_format = out_format.lower()
     if my_format == "casa":
-        from ._util.casacore import _xds_to_casa_image
+        from ._util.casacore import _xds_to_multiple_casa_images, _xds_to_casa_image
 
-        _xds_to_casa_image(xds, imagename)
+        _xds_to_multiple_casa_images(xds, imagename)
     elif my_format == "zarr":
         _xds_to_zarr(xds, imagename)
     else:
@@ -272,7 +244,7 @@ def make_empty_sky_image(
     phase_center: Union[list, np.ndarray],
     image_size: Union[list, np.ndarray],
     cell_size: Union[list, np.ndarray],
-    chan_coords: Union[list, np.ndarray],
+    frequency_coords: Union[list, np.ndarray],
     pol_coords: Union[list, np.ndarray],
     time_coords: Union[list, np.ndarray],
     direction_reference: str = "fK5",
@@ -292,7 +264,7 @@ def make_empty_sky_image(
         Number of x and y axis pixels in image.
     cell_size : array of float, length = 2, units = rad
         Cell size of x and y axis pixels in image.
-    chan_coords : list or np.ndarray
+    frequency_coords : list or np.ndarray
         The center frequency in Hz of each image channel.
     pol_coords : list or np.ndarray
         The polarization code for each image polarization.
@@ -312,7 +284,7 @@ def make_empty_sky_image(
         phase_center,
         image_size,
         cell_size,
-        chan_coords,
+        frequency_coords,
         pol_coords,
         time_coords,
         direction_reference,
@@ -326,7 +298,7 @@ def make_empty_aperture_image(
     phase_center: Union[List[float], np.ndarray],
     image_size: Union[List[int], np.ndarray],
     sky_image_cell_size: Union[List[float], np.ndarray],
-    chan_coords: Union[List[float], np.ndarray],
+    frequency_coords: Union[List[float], np.ndarray],
     pol_coords: Union[List[str], np.ndarray],
     time_coords: Union[List[float], np.ndarray],
     direction_reference: str = "fk5",
@@ -345,7 +317,7 @@ def make_empty_aperture_image(
         Number of x and y axis pixels in image.
     sky_image_cell_size : array of float, length = 2, units = rad
         Cell size of x and y axis pixels in sky image, used to get cell size in uv image
-    chan_coords : list or np.ndarray
+    frequency_coords : list or np.ndarray
         The center frequency in Hz of each image channel.
     pol_coords : list or np.ndarray
         The polarization code for each image polarization.
@@ -362,7 +334,7 @@ def make_empty_aperture_image(
         phase_center,
         image_size,
         sky_image_cell_size,
-        chan_coords,
+        frequency_coords,
         pol_coords,
         time_coords,
         direction_reference,
@@ -375,7 +347,7 @@ def make_empty_lmuv_image(
     phase_center: Union[List[float], np.ndarray],
     image_size: Union[List[int], np.ndarray],
     sky_image_cell_size: Union[List[float], np.ndarray],
-    chan_coords: Union[List[float], np.ndarray],
+    frequency_coords: Union[List[float], np.ndarray],
     pol_coords: Union[List[float], np.ndarray],
     time_coords: Union[List[float], np.ndarray],
     direction_reference: str = "fk5",
@@ -396,7 +368,7 @@ def make_empty_lmuv_image(
     sky_image_cell_size : array of float, length = 2, units = rad
         Cell size of sky image. The cell size of the u,v image will be computed from
         1/(image_size * sky_image_cell_size)
-    chan_coords : list or np.ndarray
+    frequency_coords : list or np.ndarray
         The center frequency in Hz of each image channel.
     pol_coords : list or np.ndarray
         The polarization code for each image polarization.
@@ -416,7 +388,7 @@ def make_empty_lmuv_image(
         phase_center,
         image_size,
         sky_image_cell_size,
-        chan_coords,
+        frequency_coords,
         pol_coords,
         time_coords,
         direction_reference,

xradio/image/image_xds.py

@@ -0,0 +1,262 @@
+from collections.abc import Mapping, Iterable
+import datetime
+from typing import Any, Union
+
+import numpy as np
+import xarray as xr
+
+from xradio._utils.list_and_array import to_list
+
+IMAGE_DATASET_TYPES = {"image_dataset"}
+
+from xradio._utils.xarray_helpers import get_data_group_name, create_new_data_group
+
+
+class InvalidAccessorLocation(ValueError):
+    """
+    Raised by ImageXds accessor functions called on a wrong Dataset (not image).
+    """
+
+    pass
+
+
+@xr.register_dataset_accessor("xr_img")
+class ImageXds:
+    """Accessor to the Image Dataset."""
+
+    _xds: xr.Dataset
+
+    def __init__(self, dataset: xr.Dataset):
+        """
+        Initialize the ImageXds instance.
+
+        Parameters
+        ----------
+        dataset: xarray.Dataset
+            The image Dataset node to construct an ImageXds accessor.
+        """
+
+        self._xds = dataset
+        self.meta = {"summary": {}}
+
+    def test_func(self):
+        if self._xds.attrs.get("type") not in IMAGE_DATASET_TYPES:
+            raise InvalidAccessorLocation(f"{self._xds.path} is not a image node.")
+
+        return "Hallo"
+
+    def add_data_group(
+        self,
+        new_data_group_name: str,
+        new_data_group: dict = {},
+        data_group_dv_shared_with: str = None,
+    ) -> xr.Dataset:
+        """Adds a data group to the image Dataset, grouping the given data, weight, flag, etc. variables
+        and field_and_source_xds.
+
+        Parameters
+        ----------
+        new_data_group_name : str
+            _description_
+        new_data_group : dict
+            _description_, by default Non
+        data_group_dv_shared_with : str, optional
+            _description_, by default "base"
+
+        Returns
+        -------
+        xr.Dataset
+          Image Dataset with the new group added
+        """
+
+        if self._xds.attrs.get("type") not in IMAGE_DATASET_TYPES:
+            raise InvalidAccessorLocation(f"{self._xds.path} is not a image node.")
+
+        new_data_group_name, new_data_group = create_new_data_group(
+            self._xds,
+            "image",
+            new_data_group_name,
+            new_data_group,
+            data_group_dv_shared_with=data_group_dv_shared_with,
+        )
+
+        self._xds.attrs["data_groups"][new_data_group_name] = new_data_group
+        return self._xds
+
+    def get_lm_cell_size(self):
+        """Get the lm cell size in radians from the image Dataset.
+
+        Returns
+        -------
+        float
+            The lm cell size in radians.
+        """
+
+        if self._xds.attrs.get("type") not in IMAGE_DATASET_TYPES:
+            raise InvalidAccessorLocation(f"{self._xds.path} is not a image node.")
+
+        l_cell_size = self._xds.coords["l"][1].values - self._xds.coords["l"][0].values
+        m_cell_size = self._xds.coords["m"][1].values - self._xds.coords["m"][0].values
+
+        return np.array([l_cell_size, m_cell_size])
+
+    def add_uv_coordinates(self) -> xr.Dataset:
+        """Adds the uv coordinates in wavelengths to the image Dataset.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        xr.Dataset
+            Image Dataset with the uv coordinates added.
+        """
+
+        if self._xds.attrs.get("type") not in IMAGE_DATASET_TYPES:
+            raise InvalidAccessorLocation(f"{self._xds.path} is not a image node.")
+
+        from xradio.image._util.image_factory import _make_uv_coords
+
+        # self._xds = _make_uv_coords(self._xds,image_size=image_size, sky_image_cell_size=self.get_lm_cell_size())
+
+        # Calculate uv coordinates in meters based on l and m. _make_uv_coords assumes reference pixel at center (not necessary the case).
+        delta = self.get_lm_cell_size()
+        image_size = [self._xds.sizes["l"], self._xds.sizes["m"]]
+
+        u = self._xds.coords["l"].values / ((delta[0] ** 2) * image_size[0])
+        v = self._xds.coords["m"].values / ((delta[1] ** 2) * image_size[1])
+
+        self._xds = self._xds.assign_coords({"u": u, "v": v})
+        return self._xds
+
+    def get_uv_in_lambda(self, frequency: float):
+        """Get the uv coordinates in wavelengths for a specific frequency from the image Dataset.
+
+        Parameters
+        ----------
+        frequency : float
+            The frequency in Hz to calculate the uv coordinates in wavelengths.
+
+        Returns
+        -------
+        np.ndarray
+            The uv coordinates in wavelengths.
+        """
+
+        if self._xds.attrs.get("type") not in IMAGE_DATASET_TYPES:
+            raise InvalidAccessorLocation(f"{self._xds.path} is not a image node.")
+
+        c = 299792458.0  # Speed of light in m/s
+        wavelength = c / frequency  # Wavelength in meters
+
+        u_in_lambda = self._xds.coords["u"] / wavelength
+        v_in_lambda = self._xds.coords["v"] / wavelength
+
+        return u_in_lambda, v_in_lambda
+
+    def get_reference_pixel_indices(self):
+        """Get the reference pixel indices from the image Dataset. The reference pixel is defined as the pixel where l=0 and m=0 or u=0 and v=0.
+
+        Returns
+        -------
+        dict
+            A dictionary with the reference pixel indices for each dimension.
+        """
+
+        if self._xds.attrs.get("type") not in IMAGE_DATASET_TYPES:
+            raise InvalidAccessorLocation(f"{self._xds.path} is not a image node.")
+
+        image_center_index = None
+
+        if "l" in self._xds.coords:
+            l_index = np.where(self._xds.coords["l"].values == 0)[0][0]
+            m_index = np.where(self._xds.coords["m"].values == 0)[0][0]
+
+            lm_indexes = np.array([l_index, m_index])
+            image_center_index = lm_indexes
+        else:
+            lm_indexes = None
+
+        if "u" in self._xds.coords:
+            u_index = np.where(self._xds.coords["u"].values == 0)[0][0]
+            v_index = np.where(self._xds.coords["v"].values == 0)[0][0]
+            uv_indexes = np.array([u_index, v_index])
+
+            assert np.array_equal(
+                lm_indexes, uv_indexes
+            ), "lm and uv reference pixel indices do not match."
+            image_center_index = uv_indexes
+        else:
+            uv_indexes = None
+
+        if image_center_index is None:
+            raise ValueError("No lm or uv coordinates found in the image Dataset.")
+
+        return image_center_index
+
+    def sel(
+        self,
+        indexers: Union[Mapping[Any, Any], None] = None,
+        method: Union[str, None] = None,
+        tolerance: Union[int, float, Iterable[Union[int, float]], None] = None,
+        drop: bool = False,
+        **indexers_kwargs: Any,
+    ) -> xr.Dataset:
+        """
+        Select data along dimension(s) by label. Alternative to `xarray.Dataset.sel <https://xarray.pydata.org/en/stable/generated/xarray.Dataset.sel.html>`__ so that a data group can be selected by name by using the `data_group_name` parameter.
+        For more information on data groups see `Data Groups <https://xradio.readthedocs.io/en/latest/measurement_set_overview.html#Data-Groups>`__ section. See `xarray.Dataset.sel <https://xarray.pydata.org/en/stable/generated/xarray.Dataset.sel.html>`__ for parameter descriptions.
+
+        Returns
+        -------
+        xarray.Dataset
+            xarray Dataset with ImageXds accessors
+
+        Examples
+        --------
+        >>> # Select data group 'robust0.5' and polarization 'XX'.
+        >>> selected_img_xds = img_xds.xr_img.sel(data_group_name='robust0.5', polarization='XX')
+        """
+
+        if self._xds.attrs.get("type") not in IMAGE_DATASET_TYPES:
+            raise InvalidAccessorLocation(f"{self._xds.path} is not a image node.")
+
+        if "data_group_name" in indexers_kwargs:
+            data_group_name = indexers_kwargs["data_group_name"]
+            del indexers_kwargs["data_group_name"]
+        elif (indexers is not None) and ("data_group_name" in indexers):
+            data_group_name = indexers["data_group_name"]
+            del indexers["data_group_name"]
+        else:
+            data_group_name = None
+
+        if data_group_name is not None:
+            sel_data_group_set = set(
+                self._xds.attrs["data_groups"][data_group_name].values()
+            ) - set(["date", "description"])
+
+            data_variables_to_drop = []
+            for dg_name, dg in self._xds.attrs["data_groups"].items():
+                # print(f"Data group: {dg_name}", dg)
+                dg_copy = dg.copy()
+                dg_copy.pop("date", None)
+                dg_copy.pop("description", None)
+                temp_set = set(dg_copy.values()) - sel_data_group_set
+                data_variables_to_drop.extend(list(temp_set))
+
+            data_variables_to_drop = list(set(data_variables_to_drop))
+
+            sel_img_xds = self._xds
+
+            sel_corr_xds = self._xds.sel(
+                indexers, method, tolerance, drop, **indexers_kwargs
+            ).drop_vars(data_variables_to_drop)
+
+            sel_img_xds = sel_corr_xds
+
+            sel_img_xds.attrs["data_groups"] = {
+                data_group_name: self._xds.attrs["data_groups"][data_group_name]
+            }
+
+            return sel_img_xds
+        else:
+            return self._xds.sel(indexers, method, tolerance, drop, **indexers_kwargs)

xradio/image/schema.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Literal, Optional, Union
+from xradio.schema.bases import (
+    xarray_dataset_schema,
+    xarray_dataarray_schema,
+    dict_schema,
+)
+
+
+@dict_schema
+class DataGroupDict:
+    """Defines a group of images."""
+
+    sky: Optional[str]
+    """ Name of the sky variable, for example 'SKY'. Derived from the gridded visibilities. On plane tangential to celestial sphere. """
+    flag: Optional[str]
+    """ Name of the sky pixels flags variable, for example 'FLAG_SKY'. For CASA images this is an internal mask. """
+    point_spread_function: Optional[str]
+    """ Name of the point spread function variable of the group, for example 'POINT_SPREAD_FUNCTION'. On plane tangential to celestial sphere. """
+    primary_beam: Optional[str]
+    """ Name of the primary beam variable of the group, for example 'PRIMARY_BEAM'. On plane tangential to celestial sphere. """
+    mask: Optional[str]
+    """ Name of the deconvolution mask variable of the group, for example 'MASK_DECONVOLVE'. On plane tangential to celestial sphere. """
+    beam_fit_params_sky: Optional[str]
+    """ Name of the beam fit parameters variable of the group, for example 'BEAM_FIT_PARAMETERS'. That applies to the sky, residual images and the point spread function if present. """
+    beam_fit_params_point_spread_function: Optional[str]
+    """ Name of the beam fit parameters variable of the group, for example 'BEAM_FIT_PARAMETERS'. That applies to the sky, residual images and the point spread function if present. """
+    visibility: Optional[str]
+    """ Name of the visibility variable of the group, for example 'VISIBILITY'. The gridded visibilities used to create the images using a Fourier transform. On aperture plane."""
+    visibility_normalization: Optional[str]
+    """ Normalization factor for the gridded visibility data. """
+    uv_sampling: Optional[str]
+    """ Name of the uv sampling variable of the group, for example 'UV_SAMPLING'. The gridded weights used to create the point spread function using a Fourier transform. On aperture plane."""
+    uv_sampling_normalization: Optional[str]
+    """ Normalization factor for the gridded weights. This is the sum of weights and the sensitivity can be calculated using 1/sqrt(uv_sampling_normalization)."""
+    aperture: Optional[str]
+    """ Name of the aperture variable of the group, for example 'APERTURE'. On aperture plane. The aperture is the Fourier transform of the primary beam."""
+    aperture_normalization: Optional[str]
+    """ Normalization factor for the aperture data.  """
+    description: str
+    """ More details about the data group. """
+    date: str
+    """ Creation date-time, in ISO 8601 format: 'YYYY-MM-DDTHH:mm:ss.SSS'. """
+
+    # sky: Optional[str]
+    # """ Name of the sky variable, for example 'SKY'. Derived from the gridded visibilities. On plane tangential to celestial sphere. """
+    # flag_sky: Optional[str]
+    # """ Name of the sky pixels flags variable, for example 'FLAG_SKY'. For CASA images this is an internal mask. """
+    # model: Optional[str]
+    # """ Name of the model variable, for example 'MODEL'. On plane tangential to celestial sphere. """
+    # flag_model: Optional[str]
+    # """ Name of the model pixels flags variable, for example 'FLAG_MODEL'. For CASA images this is an internal mask. """
+    # residual: Optional[str]
+    # """ Name of the residual variable of the group, for example 'RESIDUAL'. residual = sky - model. On plane tangential to celestial sphere. """
+    # flag_residual: Optional[str]
+    # """ Name of the residual pixels flags variable, for example 'FLAG_RESIDUAL'. For CASA images this is an internal mask. """
+    # point_spread_function: Optional[str]
+    # """ Name of the point spread function variable of the group, for example 'POINT_SPREAD_FUNCTION'. On plane tangential to celestial sphere. """
+    # flag_point_spread_function: Optional[str]
+    # """ Name of the point spread function pixels flags variable, for example 'FLAG_POINT_SPREAD_FUNCTION'. For CASA images this is an internal mask. """
+    # primary_beam: Optional[str]
+    # """ Name of the primary beam variable of the group, for example 'PRIMARY_BEAM'. On plane tangential to celestial sphere. """
+    # flag_primary_beam: Optional[str]
+    # """ Name of the primary beam pixels flags variable, for example 'FLAG_PRIMARY_BEAM'. For CASA images this is an internal mask. """
+    # mask_deconvolve: Optional[str]
+    # """ Name of the deconvolution mask variable of the group, for example 'MASK_DECONVOLVE'. On plane tangential to celestial sphere. """
+    # beam_fit_params: Optional[str]
+    # """ Name of the beam fit parameters variable of the group, for example 'BEAM_FIT_PARAMETERS'. That applies to the sky, residual images and the point spread function if present. """
+    # visibility: Optional[str]
+    # """ Name of the visibility variable of the group, for example 'VISIBILITY'. The gridded visibilities used to create the images using a Fourier transform. On aperture plane."""
+    # visibility_normalization: Optional[str]
+    # """ Normalization factor for the gridded visibility data. """
+    # uv_sampling: Optional[str]
+    # """ Name of the uv sampling variable of the group, for example 'UV_SAMPLING'. The gridded weights used to create the point spread function using a Fourier transform. On aperture plane."""
+    # uv_sampling_normalization: Optional[str]
+    # """ Normalization factor for the gridded weights. This is the sum of weights and the sensitivity can be calculated using 1/sqrt(uv_sampling_normalization)."""
+    # aperture: Optional[str]
+    # """ Name of the aperture variable of the group, for example 'APERTURE'. On aperture plane. The aperture is the Fourier transform of the primary beam."""
+    # aperture_normalization: Optional[str]
+    # """ Normalization factor for the aperture data.  """
+    # description: str
+    # """ More details about the data group. """
+    # date: str
+    # """ Creation date-time, in ISO 8601 format: 'YYYY-MM-DDTHH:mm:ss.SSS'. """