tabsim 0.0.2__tar.gz → 0.0.3__tar.gz

{tabsim-0.0.2 → tabsim-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tabsim
-Version: 0.0.2
+Version: 0.0.3
 Summary: Trajectory-based Radio Frequency Interference (RFI) simulations for radio interferometeric data.
 Author-email: Chris Finlay <christopher.finlay@epfl.ch>
 Maintainer-email: Chris Finlay <christopher.finlay@epfl.ch>
@@ -680,7 +680,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
         
 Project-URL: Repository, https://github.com/chrisfinlay/tab-sim.git
-Requires-Python: <3.13,>=3.10
+Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jax
@@ -704,12 +704,16 @@ Requires-Dist: ipython; extra == "ipy"
 Requires-Dist: ipykernel; extra == "ipy"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Dynamic: license-file
 
 # tab-sim
 
 [![DOI:10.1093/mnras/stad1979](https://zenodo.org/badge/DOI/10.1093/mnras/stad1979.svg)](https://doi.org/10.1093/mnras/stad1979)
 [![DOI:10.48550/arXiv.2502.00106](https://img.shields.io/badge/arXiv-2502.00106-b31b1b.svg)](https://doi.org/10.48550/arXiv.2502.00106)
+[![Documentation Status](https://readthedocs.org/projects/tab-sim/badge/?version=latest)](https://tab-sim.readthedocs.io/en/latest/?badge=latest)
 
 **T**r**A**jectory **B**ased RFI **Sim**ulations of radio interferometry data. 
 A source to visibility model for RFI sources including certain near-field effects. 
@@ -717,6 +721,10 @@ A source to visibility model for RFI sources including certain near-field effect
 `tab-sim` is written in [JAX](https://jax.readthedocs.io/en/latest/notebooks/quickstart.html) 
 and [Dask](https://www.dask.org) and can therefore use GPUs and/or CPUs to perform larger than memory computation.
 
+## Documentation
+
+[https://tab-sim.readthedocs.io/](https://tab-sim.readthedocs.io/)
+
 ## Installation
 
 The following instructions are expected to work on Linux machine. If you are running Windows it is recommended to use WSL. If you are running Mac then it is best to start with a [conda](https://docs.conda.io/en/latest/)/[mamba](https://mamba.readthedocs.io/en/latest/index.html) environment and install `python-casacore` before continuing with the `pip` install method. If all else fails there is the [Docker install](#docker).

{tabsim-0.0.2 → tabsim-0.0.3}/README.md

@@ -2,6 +2,7 @@
 
 [![DOI:10.1093/mnras/stad1979](https://zenodo.org/badge/DOI/10.1093/mnras/stad1979.svg)](https://doi.org/10.1093/mnras/stad1979)
 [![DOI:10.48550/arXiv.2502.00106](https://img.shields.io/badge/arXiv-2502.00106-b31b1b.svg)](https://doi.org/10.48550/arXiv.2502.00106)
+[![Documentation Status](https://readthedocs.org/projects/tab-sim/badge/?version=latest)](https://tab-sim.readthedocs.io/en/latest/?badge=latest)
 
 **T**r**A**jectory **B**ased RFI **Sim**ulations of radio interferometry data. 
 A source to visibility model for RFI sources including certain near-field effects. 
@@ -9,6 +10,10 @@ A source to visibility model for RFI sources including certain near-field effect
 `tab-sim` is written in [JAX](https://jax.readthedocs.io/en/latest/notebooks/quickstart.html) 
 and [Dask](https://www.dask.org) and can therefore use GPUs and/or CPUs to perform larger than memory computation.
 
+## Documentation
+
+[https://tab-sim.readthedocs.io/](https://tab-sim.readthedocs.io/)
+
 ## Installation
 
 The following instructions are expected to work on Linux machine. If you are running Windows it is recommended to use WSL. If you are running Mac then it is best to start with a [conda](https://docs.conda.io/en/latest/)/[mamba](https://mamba.readthedocs.io/en/latest/index.html) environment and install `python-casacore` before continuing with the `pip` install method. If all else fails there is the [Docker install](#docker).

tabsim-0.0.3/docs/conf.py

@@ -0,0 +1,14 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath('..'))
+
+project = 'tab‑sim'
+author = 'Chris Finlay'
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+]
+templates_path = ['_templates']
+exclude_patterns = []
+html_theme = 'sphinx_rtd_theme'

{tabsim-0.0.2 → tabsim-0.0.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tabsim"
-version = "0.0.2"
+version = "0.0.3"
 license = {file = "LICENSE"}
 readme = "README.md"
 # dynamic = ["version", "readme"]
@@ -17,7 +17,7 @@ maintainers = [
 ]
 description = "Trajectory-based Radio Frequency Interference (RFI) simulations for radio interferometeric data."
 
-requires-python = ">=3.10,<3.13"
+requires-python = ">=3.9,<3.13"
 dependencies = [
     "jax", "dask<=2024.10.0", "xarray", "zarr<3.0.0", 
     "dask-ms>=0.2.21", "scipy", "tqdm", "matplotlib", 
@@ -32,6 +32,7 @@ sat = ["regions"]
 # all_cpu = ["regions", "bdsf", "TGEpy @ git+https://github.com/chrisfinlay/TGEpy.git"]
 ipy = ["ipython", "ipykernel"]
 test = ["pytest"]
+docs = ["sphinx", "sphinx-rtd-theme"]
 
 [project.urls]
 Repository = "https://github.com/chrisfinlay/tab-sim.git"

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim/config.py

@@ -5,7 +5,8 @@ import sys
 import shutil
 
 import collections.abc
-from typing import Tuple
+from typing import Tuple, Union, Optional
+
 from datetime import datetime
 
 import dask.array as da
@@ -13,13 +14,14 @@ from dask.array.core import Array
 import xarray as xr
 import numpy as np
 import pandas as pd
+from astropy.time import Time
 
 from tabsim.dask.observation import Observation
 from tabsim.sky import generate_random_sky
 from tabsim.plot import plot_uv, plot_src_alt, plot_angular_seps
 from tabsim.write import write_ms, mk_obs_name, mk_obs_dir
-from tabsim.jax.coordinates import calculate_fringe_frequency
-from tabsim.tle import get_visible_satellite_tles
+from tabsim.jax.coordinates import calculate_fringe_frequency, jd_to_mjd
+from tabsim.tle import get_visible_satellite_tles, id_generator
 
 from daskms import xds_from_ms
 
@@ -188,7 +190,7 @@ def load_sky_model(file_path: str, freqs: Array, src_type: str) -> tuple:
         raise KeyError("'src_type' must be one of {'point', 'gauss', 'exp'}.")
 
 
-def sigma_value(value: str | float | int, obs: Observation):
+def sigma_value(value: Union[str, float, int], obs: Observation):
     try:
         if isinstance(value, str):
             sigma = (np.mean(obs.noise_std) / np.sqrt(obs.n_time * obs.n_bl)).compute()
@@ -212,12 +214,9 @@ def load_obs(obs_spec: dict) -> Observation:
         return x
 
     if obs_["start_time_jd"]:
-        from tabascal.jax.coordinates import jd_to_mjd
 
         start_time_mjd = jd_to_mjd(obs_["start_time_jd"])
     elif obs_["start_time_isot"]:
-        from astropy.time import Time
-        from tabascal.jax.coordinates import jd_to_mjd
 
         start_time_mjd = jd_to_mjd(
             Time(obs_["start_time_isot"], format="isot", scale="ut1").jd
@@ -837,11 +836,14 @@ def print_fringe_freq_tle_sat(obs: Observation):
 
 
 def run_sim_config(
-    obs_spec: dict = None, config_path: str = None, spacetrack_path: str = None
+    obs_spec: Optional[dict] = None,
+    config_path: Optional[str] = None,
+    spacetrack_path: Optional[str] = None,
 ) -> Tuple[Observation, str]:
 
     from tabsim.tle import id_generator
 
+
     log_path = f"log_sim_{id_generator()}.txt"
     log = open(log_path, "w")
     backup = sys.stdout
@@ -859,7 +861,7 @@ def run_sim_config(
     obs = load_obs(obs_spec)
     add_astro_sources(obs, obs_spec)
     add_satellite_sources(obs, obs_spec)
-    if obs_spec["rfi_sources"]["tle_satellite"]["max_n_sat"] != 0:
+    if obs_spec["rfi_sources"]["tle_satellite"]["max_n_sat"] != 0 and spacetrack_path:
         add_tle_satellite_sources(obs, obs_spec, spacetrack_path)
     add_stationary_sources(obs, obs_spec)
     add_gains(obs, obs_spec)

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim/jax/coordinates.py

@@ -1,6 +1,7 @@
 import jax.numpy as jnp
 from jax import jit, vmap, jacrev, config, Array
 from tabsim.jax.utils import jit_with_doc
+from jax.lax import scan
 
 config.update("jax_enable_x64", True)
 
@@ -690,7 +691,7 @@ def calculate_fringe_frequency(
     r_ecef = xyz_to_itrf(rfi_xyz, gsa)
     s_ecef = r_ecef - jnp.mean(ants_itrf, axis=0)
     s_hat_ecef = s_ecef / jnp.linalg.norm(s_ecef, axis=-1, keepdims=True)
-    s_hat_dot = jnp.gradient(s_hat_ecef, times, axis=0)
+    s_hat_dot = jnp.gradient(s_hat_ecef, jnp.diff(times[:2])[0], axis=0)
 
     a1, a2 = jnp.triu_indices(len(ants_itrf), 1)
     bl_ecef = ants_itrf[a1] - ants_itrf[a2]
@@ -1080,3 +1081,256 @@ def orbit_fisher(times: Array, orbit_params: Array, RIC_std: Array) -> Array:
     fisher = vmap(propagate, in_axes=(0, None))(J, F).sum(axis=0)
 
     return fisher
+
+
+# New Orbit Model with Keplerian Elements
+
+
+def R_z(angle):
+    c, s = jnp.cos(angle), jnp.sin(angle)
+    return jnp.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])
+
+
+def R_x(angle):
+    c, s = jnp.cos(angle), jnp.sin(angle)
+    return jnp.array([[1, 0, 0], [0, c, -s], [0, s, c]])
+
+
+def solve_kepler(M, e, max_iter=100):
+    """Newton-Raphson solver for Kepler's equation."""
+
+    def newton_step(E, _):
+        f = E - e * jnp.sin(E) - M
+        f_prime = 1 - e * jnp.cos(E)
+        E_new = E - f / f_prime
+        return E_new, E_new
+
+    E0 = M
+    E_final, _ = scan(newton_step, E0, None, length=max_iter)
+
+    return E_final
+
+
+def kepler_orbit(times, t_epoch, params):
+    """
+    Compute orbit position over time for a single satellite.
+
+    times: (T,)
+    params: (6,) = [a, e, i, Ω, ω, M0]
+    Returns: (T, 3)
+    """
+    a, e, i_deg, Ω_deg, ω_deg, M0_deg = params
+
+    mu = 398600.4418  # km^3/s^2
+
+    n = jnp.sqrt(mu / jnp.abs(a) ** 3) * 86400
+
+    i = jnp.radians(i_deg)
+    Ω = jnp.radians(Ω_deg)
+    ω = jnp.radians(ω_deg)
+    M_0 = jnp.radians(M0_deg)
+
+    M = M_0 + n * (times - t_epoch)  # Mean anomaly
+
+    E = vmap(solve_kepler, (0, None))(jnp.atleast_1d(M), e)
+
+    nu = 2 * jnp.arctan2(
+        jnp.sqrt(1 + e) * jnp.sin(E / 2), jnp.sqrt(1 - e) * jnp.cos(E / 2)
+    )
+
+    r = a * (1 - e * jnp.cos(E))
+    x_orb = r * jnp.cos(nu)
+    y_orb = r * jnp.sin(nu)
+    z_orb = jnp.zeros_like(x_orb)
+
+    R = R_z(Ω) @ R_x(i) @ R_z(ω)
+
+    pos_orb = jnp.stack([x_orb, y_orb, z_orb], axis=1)  # (T, 3)
+    pos_inertial = pos_orb @ R.T  # (T, 3)
+
+    return pos_inertial * 1e3
+
+
+def kepler_orbit_many(
+    times_jd: Array,
+    epoch_jd: Array,
+    elements: Array,
+    # semi_major: Array,
+    # eccentricity: Array,
+    # inclination: Array,
+    # ra_of_asc_node: Array,
+    # arg_of_peri: Array,
+    # mean_anomaly: Array,
+):
+    """Propagate Keplerian orbits for a set of satellites using orbital elements as defined in a TLE.
+
+    Parameters
+    ----------
+    times_jd : Array (n_time,)
+        Propagation times in Julian Date.
+    epoch_jd : Array (n_sat,)
+        Epoch of the TLE in Julian Date.
+    semi_major : Array (n_sat,)
+        Semi major axis of the orbit in km.
+    eccentricity : Array (n_sat,)
+        Eccentricity of the orbit.
+    inclination : Array (n_sat,)
+        Inclination of the orbit in degrees.
+    ra_of_asc_node : Array (n_sat,)
+        Right ascension of the ascending node in degrees.
+    arg_of_peri : Array (n_sat,)
+        Argument of the pericentre in degrees.
+    mean_anomaly : Array (n_sat,)
+        Mean anomaly of the orbit at the epoch time in degrees.
+    """
+
+    # elements = [
+    #     jnp.atleast_1d(x)
+    #     for x in [
+    #         semi_major,
+    #         eccentricity,
+    #         inclination,
+    #         ra_of_asc_node,
+    #         arg_of_peri,
+    #         mean_anomaly,
+    #     ]
+    # ]
+
+    pos = vmap(kepler_orbit, (None, 0, 0))(times_jd, epoch_jd, elements)
+
+    return pos
+
+
+def kepler_orbit_velocity(times_jd: Array, epoch_jd: float, elements: Array) -> Array:
+
+    vel_vmap = vmap(jacrev(kepler_orbit, argnums=(0)), in_axes=(0, None, None))
+    velocity = vel_vmap(times_jd, epoch_jd, elements).reshape(len(times_jd), 3)
+
+    return velocity
+
+
+def R_uvw(
+    times_jd: Array,
+    epoch_jd: float,
+    elements: Array,
+) -> Array:
+    """
+    Calculate the rotation matrices at each time step to transform from an Earth
+    centric reference frame (ECI) to a satellite centric frame given the
+    parameters of its (circular) orbit.
+
+    Parameters
+    ----------
+    times: ndarray (n_time,)
+        Times at which to evaluate the rotation matrices.
+    elevation: float
+        Elevation/Altitude of the orbit in metres.
+    inclination: float
+        Inclination angle of the orbit relative to the equatorial plane.
+    lon_asc_node: float
+        Longitude of the ascending node of the orbit. This is the longitude of
+        when the orbit crosses the equator from the south to the north.
+    periapsis: float
+        Perisapsis of the orbit. This is the angular starting point of the orbit
+        at t = 0.
+
+    Returns
+    -------
+    R: ndarray (3, 3)
+        The rotation matrix to orient to a satellite centric (RIC) frame defined
+        by the Radial, In-track, Cross-track components.
+    """
+    times_jd = jnp.asarray(times_jd)
+    elements = jnp.asarray(elements)
+
+    position = kepler_orbit(times_jd, epoch_jd, elements)
+    velocity = kepler_orbit_velocity(times_jd, epoch_jd, elements)
+
+    vel_hat = velocity / jnp.linalg.norm(velocity, axis=-1, keepdims=True)
+    u_hat = position / jnp.linalg.norm(position, axis=-1, keepdims=True)
+    w_hat = jnp.cross(u_hat, vel_hat)
+    v_hat = jnp.cross(w_hat, u_hat)
+    R = jnp.stack([u_hat.T, v_hat.T, w_hat.T])
+
+    return R
+
+
+def kepler_RIC_dev(
+    times_jd: Array,
+    epoch_jd: float,
+    true_elements: Array,
+    estimated_elements: Array,
+) -> Array:
+    """
+    Calculate the Radial (R), In-track (I) and Cross-track (C) deviations
+    between two circular orbits given their orbit parameters at many time steps.
+
+    Parameters
+    ----------
+    times: array (n_time,)
+        Times at which to evaluate the RIC deviations.
+    true_orb_params: ndarray (4,)
+        Orbit parameters (elevation, inclination, lon_asc_node, periapsis) of
+        the object of most interest. The more accurate measurement when
+        comparing the same object.
+    est_orb_params: array (elevation, inclination, lon_asc_node, periapsis)
+        Estimated orbit parameters.
+
+    Returns
+    -------
+    RIC: ndarray (n_time, 3)
+        Radial, In-track and Cross-track coordinates, in metres, of the orbiting
+        body relative to the orbit defined by 'true_orbit_params'.
+    """
+    times_jd = jnp.asarray(times_jd)
+    true_elements = jnp.asarray(true_elements)
+    estimated_elements = jnp.asarray(estimated_elements)
+
+    true_xyz = kepler_orbit(times_jd, epoch_jd, true_elements)
+    est_xyz = kepler_orbit(times_jd, epoch_jd, estimated_elements)
+
+    R = R_uvw(times_jd, epoch_jd, true_elements)
+    true_uvw = vmap(lambda x, y: x @ y, in_axes=(-1, 0))(R, true_xyz)
+    est_uvw = vmap(lambda x, y: x @ y, in_axes=(-1, 0))(R, est_xyz)
+
+    return est_uvw - true_uvw
+
+
+def kepler_orbit_fisher(
+    times_jd: Array, epoch_jd: float, elements: Array, RIC_std: Array
+) -> Array:
+    """
+    Calculate the inverse covariance (Fisher) matrix in orbital elements
+    induced by errors in the RIC frame of an orbiting object. This is
+    essentially linear uncertainty propagation assuming Gaussian errors.
+
+    Parameters
+    ----------
+    times: ndarray (n_time,)
+        Times at which the RIC covariance/standard deviations is defined.
+    orbit_params: ndarray (4,)
+        Orbit parameters (elevation, inclination, lon_asc_node, periapsis) for
+        the orbit defining the origin of the RIC frame.
+    RIC_std: ndarray (3,)
+        The standard deviation in the Radial, In-track and Cross-track
+        directions.
+
+    Returns
+    -------
+    fisher: ndarray (6, 6)
+        The inverse covariance (Fisher) matrix for the orbit parameters induced
+        by the orbit uncertainties in the RIC frame.
+    """
+    times_jd = jnp.asarray(times_jd)
+    elements = jnp.asarray(elements)
+    RIC_std = jnp.asarray(RIC_std)
+
+    J = jacrev(kepler_RIC_dev, argnums=(3,))(times_jd, epoch_jd, elements, elements)[0]
+    F = jnp.diag(1.0 / RIC_std**2)
+
+    def propagate(J, F):
+        return J.T @ F @ J
+
+    fisher = vmap(propagate, in_axes=(0, None))(J, F).sum(axis=0)
+
+    return fisher

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim/scripts/sim_vis.py

@@ -5,8 +5,10 @@ from pathlib import Path
 
 from tabsim.config import load_config, run_sim_config
 
+from typing import Union
 
-def get_abs_path(rel_path: str | None, work_dir: str) -> str | None:
+
+def get_abs_path(rel_path: Union[str, None], work_dir: str) -> Union[str, None]:
     if rel_path:
         return os.path.abspath(os.path.join(work_dir, rel_path))
     else:

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim/sky.py

@@ -2,8 +2,10 @@ import numpy as np
 import jax.numpy as jnp
 import dask.array as da
 
+from typing import Optional
 
-def uniform_points_disk(radius: float, n_src: int, random_seed: int | None = None):
+
+def uniform_points_disk(radius: float, n_src: int, random_seed: Optional[int] = None):
     """
     Generate uniformly distributed random points on a disk.
 

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim/tle.py

@@ -21,8 +21,10 @@ from glob import glob
 
 from importlib.resources import files
 
+from typing import Optional
 
-def make_tle_dir(tle_dir: str | None):
+
+def make_tle_dir(tle_dir: Optional[str]):
 
     if tle_dir:
         tle_dir = os.path.abspath(tle_dir)
@@ -89,7 +91,7 @@ def get_tles_by_id(
     epoch_jd: float,
     window_days: float = 1.0,
     limit: int = 2000,
-    tle_dir: str | None = None,
+    tle_dir: Optional[str] = None,
 ) -> pd.DataFrame:
 
     tle_dir = make_tle_dir(tle_dir)
@@ -166,7 +168,7 @@ def get_tles_by_name(
     epoch_jd: float,
     window_days: float = 1.0,
     limit: int = 10000,
-    tle_dir: str | None = None,
+    tle_dir: Optional[str] = None,
 ) -> pd.DataFrame:
 
     tle_dir = make_tle_dir(tle_dir)
@@ -291,7 +293,7 @@ def get_visible_satellite_tles(
     min_elevation: float,
     names: ArrayLike = [],
     norad_ids: ArrayLike = [],
-    tle_dir: str | None = None,
+    tle_dir: Optional[str] = None,
 ) -> tuple:
     """Get the TLEs corresponding to satellites that satisfy the conditions given.
 

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim/write.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from tabsim.dask.observation import Observation
@@ -12,9 +12,11 @@ import dask
 import dask.array as da
 import numpy as np
 import xarray as xr
-from daskms import Dataset, xds_to_table
+from daskms import Dataset, xds_to_table, xds_from_ms
 import numpy as np
 
+from dask.array.core import Array
+
 
 def rm_dir(path: str, overwrite: bool = True):
     """Remove a directory but check for existence and overwrite flag before.
@@ -73,7 +75,7 @@ def mk_obs_dir(output_path: str, obs_name: str, overwrite: bool = True) -> tuple
     return save_path, zarr_path, ms_path
 
 
-def mk_obs_name(prefix: str, obs: Observation, suffix: str = None) -> str:
+def mk_obs_name(prefix: str, obs: Observation, suffix: Optional[str] = None) -> str:
     """Construct an observation name based on the parameters of the observation and an additional prefix.
 
     Parameters
@@ -381,6 +383,40 @@ def get_stationary_rfi_data(obs: Observation):
     return rfi_stat
 
 
+def add_to_ms(ds: Dataset, ms_path: str, flags: Optional[Array] = None):
+
+    n_time = ds.attrs["n_time"]
+    n_freq = ds.attrs["n_freq"]
+    n_corr = 1
+    n_bl = ds.attrs["n_bl"]
+    n_row = n_time * n_bl
+
+    xds_ms = xds_from_ms(ms_path)[0]
+
+    dims = ["row", "chan", "corr"]
+    chunks = {k: v for k, v in xds_ms.chunks.items() if k in dims}
+
+    vis_rfi = ds.vis_rfi.data.reshape(n_row, n_freq, n_corr)
+    vis_rfi = xr.DataArray(
+        da.stack(
+            [vis_rfi, da.zeros_like(vis_rfi), da.zeros_like(vis_rfi), vis_rfi], axis=2
+        ),
+        dims=("row", "chan", "corr"),
+    )
+
+    xds_ms = xds_ms.assign(DATA=xds_ms.DATA + vis_rfi)
+    cols = "DATA"
+
+    if flags:
+        flags = xr.DataArray(
+            ds.flags.data.reshape(n_row, n_freq, n_corr), dims=("row", "chan", "corr")
+        )
+        xds_ms = xds_ms.assign(FLAG=flags)
+        cols.append("FLAG")
+
+    dask.compute(xds_to_table([xds_ms], ms_path, cols))
+
+
 def write_ms(
     ds: Dataset,
     ms_path: str,

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tabsim
-Version: 0.0.2
+Version: 0.0.3
 Summary: Trajectory-based Radio Frequency Interference (RFI) simulations for radio interferometeric data.
 Author-email: Chris Finlay <christopher.finlay@epfl.ch>
 Maintainer-email: Chris Finlay <christopher.finlay@epfl.ch>
@@ -680,7 +680,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
         
 Project-URL: Repository, https://github.com/chrisfinlay/tab-sim.git
-Requires-Python: <3.13,>=3.10
+Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jax
@@ -704,12 +704,16 @@ Requires-Dist: ipython; extra == "ipy"
 Requires-Dist: ipykernel; extra == "ipy"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Dynamic: license-file
 
 # tab-sim
 
 [![DOI:10.1093/mnras/stad1979](https://zenodo.org/badge/DOI/10.1093/mnras/stad1979.svg)](https://doi.org/10.1093/mnras/stad1979)
 [![DOI:10.48550/arXiv.2502.00106](https://img.shields.io/badge/arXiv-2502.00106-b31b1b.svg)](https://doi.org/10.48550/arXiv.2502.00106)
+[![Documentation Status](https://readthedocs.org/projects/tab-sim/badge/?version=latest)](https://tab-sim.readthedocs.io/en/latest/?badge=latest)
 
 **T**r**A**jectory **B**ased RFI **Sim**ulations of radio interferometry data. 
 A source to visibility model for RFI sources including certain near-field effects. 
@@ -717,6 +721,10 @@ A source to visibility model for RFI sources including certain near-field effect
 `tab-sim` is written in [JAX](https://jax.readthedocs.io/en/latest/notebooks/quickstart.html) 
 and [Dask](https://www.dask.org) and can therefore use GPUs and/or CPUs to perform larger than memory computation.
 
+## Documentation
+
+[https://tab-sim.readthedocs.io/](https://tab-sim.readthedocs.io/)
+
 ## Installation
 
 The following instructions are expected to work on Linux machine. If you are running Windows it is recommended to use WSL. If you are running Mac then it is best to start with a [conda](https://docs.conda.io/en/latest/)/[mamba](https://mamba.readthedocs.io/en/latest/index.html) environment and install `python-casacore` before continuing with the `pip` install method. If all else fails there is the [Docker install](#docker).

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+docs/conf.py
 tabsim/__init__.py
 tabsim/config.py
 tabsim/plot.py

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim.egg-info/requires.txt

@@ -11,6 +11,10 @@ spacetrack
 skyfield
 numpy<2.0.0
 
+[docs]
+sphinx
+sphinx-rtd-theme
+
 [gpu]
 jax[cuda12]
 

{tabsim-0.0.2 → tabsim-0.0.3}/tabsim.egg-info/top_level.txt

@@ -1,4 +1,5 @@
 dist
+docs
 examples
 tabsim
 tests