mskit-simu 0.6.1__py3-none-any.whl

mskit/__init__.py

@@ -0,0 +1,33 @@
+"""
+MSKit — Mini Simulation Kit
+============================
+Terrain-based simulations powered by real-world data:
+  * JAXA AW3D30 30m elevation (global, lazy-streamed from HuggingFace)
+  * OpenTraffic / OSRM  — live road speeds, global
+  * UTD19              — 40 cities, 23 541 loop detectors (ETH Zurich)
+  * OpenCTV            — free public traffic cameras (SG, London, NYC)
+  * Simu               — built-in AI assistant (SmolLM2-360M, open-source)
+
+Dataset : https://huggingface.co/datasets/MegaBites-AI/AW3D30-DEM-Tiles
+GitHub  : https://github.com/MegaBites-AI/MSKit
+"""
+
+from .dem import DEMTile, DEMLoader
+from .sims.random_walk import RandomWalk
+from .sims.projectile import Projectile
+from .sims.flow import WaterFlow
+from .sims.agent import TerrainAgent
+from .traffic import OpenTrafficLayer, UTD19Layer, TrafficRouter, OpenCTVLayer
+from .simu import Simu
+
+__version__ = "0.6.0"
+__author__  = "MegaBites AI Team"
+__dataset__ = "MegaBites-AI/AW3D30-DEM-Tiles"
+__github__  = "https://github.com/MegaBites-AI/MSKit"
+
+__all__ = [
+    "DEMTile", "DEMLoader",
+    "RandomWalk", "Projectile", "WaterFlow", "TerrainAgent",
+    "OpenTrafficLayer", "UTD19Layer", "TrafficRouter", "OpenCTVLayer",
+    "Simu",
+]

mskit/_cli.py

@@ -0,0 +1,8 @@
+"""CLI entry point for mskit-upload command."""
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+def upload_main():
+    from scripts.upload_tiles import main
+    main()

mskit/cli.py

@@ -0,0 +1,354 @@
+"""
+MSKit CLI — unified command-line interface.
+Entry point: mskit
+
+Commands:
+  mskit simu                    Interactive AI assistant
+  mskit run "desc..."           One-shot simulation
+  mskit cameras --city NAME     Traffic cameras near a city
+  mskit cameras --lat L --lon O Search cameras by coordinates
+  mskit traffic --city NAME     Traffic speed/congestion
+  mskit demo                    Full feature demo
+  mskit info                    Version and data source info
+"""
+from __future__ import annotations
+
+import sys
+import argparse
+import textwrap
+import datetime
+from typing import Optional
+
+# ── City table ───────────────────────────────────────────────────────────────
+_CITIES = {
+    "tokyo":         (35.6762, 139.6503),
+    "london":        (51.5074,  -0.1278),
+    "paris":         (48.8566,   2.3522),
+    "new york":      (40.7128, -74.0060),
+    "nyc":           (40.7128, -74.0060),
+    "singapore":     ( 1.3521, 103.8198),
+    "sydney":        (-33.8688, 151.2093),
+    "berlin":        (52.5200,  13.4050),
+    "zurich":        (47.3769,   8.5417),
+    "hong kong":     (22.3193, 114.1694),
+    "dubai":         (25.2048,  55.2708),
+    "seoul":         (37.5665, 127.0000),
+    "beijing":       (39.9042, 116.4074),
+    "shanghai":      (31.2304, 121.4737),
+    "mumbai":        (19.0760,  72.8777),
+    "los angeles":   (34.0522,-118.2437),
+    "san francisco": (37.7749,-122.4194),
+    "chicago":       (41.8781, -87.6298),
+    "toronto":       (43.6532, -79.3832),
+    "amsterdam":     (52.3676,   4.9041),
+    "moscow":        (55.7558,  37.6173),
+    "istanbul":      (41.0082,  28.9784),
+    "bangkok":       (13.7563, 100.5018),
+    "cairo":         (30.0444,  31.2357),
+    "nairobi":       (-1.2921,  36.8219),
+    "sao paulo":     (-23.5505,-46.6333),
+    "buenos aires":  (-34.6037,-58.3816),
+    "mount fuji":    (35.3606, 138.7274),
+    "fuji":          (35.3606, 138.7274),
+    "himalayas":     (27.9881,  86.9250),
+    "everest":       (27.9881,  86.9250),
+    "alps":          (46.5000,   8.5000),
+    "grand canyon":  (36.1069,-112.1129),
+    "yellowstone":   (44.4280,-110.5885),
+}
+
+BANNER = r"""
+  __  __  ___  _  ___ _
+ |  \/  |/ __|| |/ (_) |_
+ | |\/| |\__ \| ' <| |  _|
+ |_|  |_||___/|_|\_\_|\__|
+
+ Mini Simulation Kit  v{version}
+ GitHub  : https://github.com/MegaBites-AI/MSKit
+ Dataset : MegaBites-AI/AW3D30-DEM-Tiles  (HuggingFace)
+"""
+
+def _hr(w=56): return "─" * w
+def _section(t): print(f"\n{'━'*56}\n  {t}\n{'━'*56}")
+
+
+def _resolve_location(city, lat, lon):
+    if city:
+        k = city.lower().strip()
+        if k in _CITIES:
+            la, lo = _CITIES[k]
+            return la, lo, city.title()
+        print(f"❌ Unknown city '{city}'.")
+        print(f"   Known: {', '.join(sorted(_CITIES))}")
+        sys.exit(1)
+    if lat is not None and lon is not None:
+        return lat, lon, f"({lat:.4f}, {lon:.4f})"
+    print("❌ Provide --city NAME  or  --lat LAT --lon LON")
+    sys.exit(1)
+
+
+def _add_loc(p):
+    g = p.add_mutually_exclusive_group()
+    g.add_argument("--city", default=None)
+    p.add_argument("--lat", type=float, default=None)
+    p.add_argument("--lon", type=float, default=None)
+
+
+# ── Sub-command handlers ──────────────────────────────────────────────────────
+
+def cmd_simu(args):
+    from mskit.simu.simu import _cli_main
+    _cli_main()
+
+
+def cmd_run(args):
+    desc = " ".join(args.description).strip()
+    if not desc:
+        print('❌ Usage: mskit run "describe your simulation"')
+        sys.exit(1)
+    print(f'\n🤖 MSKit — Running: "{desc}"\n')
+    from mskit.simu import Simu
+    simu = Simu(verbose=True, auto_select="untrained", auto_simmode="custom")
+    try:
+        from mskit import DEMLoader, TrafficRouter
+        dem = DEMLoader()
+        simu._dem     = dem
+        simu._traffic = TrafficRouter(dem)
+    except Exception:
+        pass
+    simu.chat(desc)
+
+
+def cmd_cameras(args):
+    from mskit.traffic import OpenCTVLayer
+    lat, lon, name = _resolve_location(
+        getattr(args,"city",None),
+        getattr(args,"lat",None),
+        getattr(args,"lon",None),
+    )
+    radius  = getattr(args,"radius",5.0) or 5.0
+    tfl_key = getattr(args,"tfl_key",None)
+
+    _section(f"📷  OpenCTV — Cameras near {name}")
+    print(f"  Coords  : {lat:.5f}, {lon:.5f}")
+    print(f"  Radius  : {radius} km")
+
+    layer = OpenCTVLayer(tfl_app_key=tfl_key)
+    src   = layer.covered_at(lat, lon)
+    if src:
+        print(f"  Source  : {layer.SOURCES[src]}")
+    else:
+        print("  Source  : Synthetic (area not covered by live feeds)")
+        print("  Covered : Singapore · London · New York City")
+
+    print("\n  Fetching...", end="", flush=True)
+    report = layer.traffic_report(lat, lon, radius_km=radius)
+    print(f" {report.camera_count} cameras found.\n")
+
+    if not report.cameras:
+        print("  No cameras in this area.")
+        return
+
+    if report.nearest:
+        n = report.nearest
+        dist = n.distance_km(lat, lon)
+        print(f"  📍 Nearest  : {n.name} ({dist:.2f} km)")
+        print(f"     Source   : {n.source}")
+        print(f"     Coords   : {n.lat:.5f}, {n.lon:.5f}")
+        if n.direction: print(f"     Direction: {n.direction}")
+        if n.image_url: print(f"     Image URL: {n.image_url}")
+        if n.timestamp: print(f"     Updated  : {n.timestamp}")
+
+    shown = report.cameras[:10]
+    if len(shown) > 1:
+        print(f"\n  All cameras (showing {len(shown)} of {report.camera_count}):")
+        for i, c in enumerate(shown, 1):
+            dist = c.distance_km(lat, lon)
+            line = f"  [{i:2d}] {c.name}  ({dist:.2f} km)"
+            if c.image_url:
+                line += f"\n        {c.image_url}"
+            print(line)
+    if report.camera_count > 10:
+        print(f"\n  ... and {report.camera_count-10} more.")
+    print(f"\n  Timestamp: {report.timestamp}")
+
+
+def cmd_traffic(args):
+    lat, lon, name = _resolve_location(
+        getattr(args,"city",None),
+        getattr(args,"lat",None),
+        getattr(args,"lon",None),
+    )
+    _section(f"🚦  Traffic Report — {name}")
+    print(f"  Coords : {lat:.5f}, {lon:.5f}")
+    print(f"  Time   : {datetime.datetime.utcnow():%Y-%m-%d %H:%M:%S} UTC\n")
+
+    try:
+        from mskit.traffic import TrafficRouter
+        from mskit import DEMLoader
+        info = TrafficRouter(DEMLoader()).traffic_at(lat, lon)
+        d = info.to_dict()
+        print(f"  Speed      : {d.get('speed_kmh',0):.1f} km/h")
+        print(f"  Flow       : {d.get('flow_veh_h',0):.0f} veh/h")
+        print(f"  Occupancy  : {d.get('occupancy_pct',0):.1f}%")
+        print(f"  Congestion : {str(d.get('congestion_level','?')).upper()}")
+        print(f"  Source     : {d.get('source','?')}")
+        print(f"  Confidence : {d.get('confidence',0)*100:.0f}%")
+    except Exception as e:
+        print(f"  ⚠️  Traffic data: {e}")
+
+    try:
+        from mskit.traffic import OpenCTVLayer
+        report = OpenCTVLayer().traffic_report(lat, lon, radius_km=5)
+        print(f"\n  📷 Cameras  : {report.camera_count} within 5 km [{report.source}]")
+        if report.nearest:
+            d = report.nearest.distance_km(lat,lon)
+            print(f"  Nearest    : {report.nearest.name} ({d:.2f} km)")
+    except Exception:
+        pass
+
+
+def cmd_info(args):
+    import mskit
+    print(BANNER.format(version=mskit.__version__))
+    print(_hr())
+    print("  DATA SOURCES")
+    print(_hr())
+    rows = [
+        ("Elevation", "JAXA AW3D30 (30m global DEM)"),
+        ("",          "MegaBites-AI/AW3D30-DEM-Tiles on HuggingFace"),
+        ("Traffic",   "OpenTraffic / OSRM  (global road network, priority 1)"),
+        ("",          "UTD19 — 40 cities, 23,541 loop detectors (priority 2)"),
+        ("",          "Synthetic terrain+time model (fallback)"),
+        ("Cameras",   "OpenCTV aggregator:"),
+        ("",          "  • Singapore LTA  — 87 cams, 20s refresh, no key"),
+        ("",          "  • TfL JamCam     — 900+ London cams, free key"),
+        ("",          "  • NYC DOT        — ~900 NYC cams, no key"),
+        ("",          "  • Synthetic fallback everywhere else"),
+        ("AI Brain",  "HuggingFaceTB/SmolLM2-360M-Instruct"),
+        ("",          "360M params · Apache 2.0 · CPU-capable"),
+    ]
+    for label, val in rows:
+        print(f"  {label:<12} {val}")
+    print()
+    print(_hr())
+    print("  SIMULATIONS")
+    print(_hr())
+    for name, desc in [
+        ("random_walk", "Slope-biased terrain walk"),
+        ("projectile",  "Ballistic trajectory over real terrain"),
+        ("water_flow",  "D8 runoff routing"),
+        ("agent",       "RL terrain navigator"),
+        ("traffic",     "Road speed + congestion query"),
+        ("profile",     "Elevation cross-section between two points"),
+    ]:
+        print(f"  {name:<14} {desc}")
+    print(_hr())
+    print(f"  Version : {mskit.__version__}")
+    print(f"  GitHub  : {mskit.__github__}")
+    print()
+
+
+def cmd_demo(args):
+    import mskit
+    print(BANNER.format(version=mskit.__version__))
+    print("  Running full feature demo...\n")
+
+    _section("📷  OpenCTV — Singapore cameras")
+    try:
+        from mskit.traffic import OpenCTVLayer
+        r = OpenCTVLayer().traffic_report(1.3521, 103.8198, radius_km=3)
+        print(f"  Found {r.camera_count} cameras near Singapore centre.")
+        if r.nearest:
+            print(f"  Nearest : {r.nearest.name}")
+            print(f"  Image   : {r.nearest.image_url or '(no URL — synthetic)'}")
+    except Exception as e:
+        print(f"  ⚠️  {e}")
+
+    _section("🚦  Traffic — Tokyo")
+    try:
+        from mskit.traffic import TrafficRouter
+        from mskit import DEMLoader
+        info = TrafficRouter(DEMLoader()).traffic_at(35.6762, 139.6503)
+        d = info.to_dict()
+        print(f"  Speed      : {d['speed_kmh']:.1f} km/h")
+        print(f"  Congestion : {d['congestion_level']}")
+        print(f"  Source     : {d['source']}")
+    except Exception as e:
+        print(f"  ⚠️  {e}")
+
+    _section("🤖  Simu — All 6 sims at London (untrained brain)")
+    try:
+        from mskit.simu import Simu
+        simu = Simu(verbose=True, auto_select="untrained", auto_simmode="everything")
+        result = simu.chat("London")
+        ok = sum(1 for v in result["output"].values() if "error" not in v)
+        print(f"\n  {ok}/6 simulations completed.")
+    except Exception as e:
+        print(f"  ⚠️  {e}")
+
+    print(f"\n{'━'*56}")
+    print("  Demo complete! Run `mskit simu` for the full AI experience.")
+    print('━'*56 + "\n")
+
+
+# ── Argument parser ───────────────────────────────────────────────────────────
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="mskit",
+        description="MSKit — Mini Simulation Kit",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=textwrap.dedent("""
+        Examples:
+          mskit simu
+          mskit run "random walk in Tokyo 500 steps"
+          mskit cameras --city singapore
+          mskit cameras --lat 51.5 --lon -0.1 --radius 3
+          mskit traffic --city london
+          mskit traffic --lat 40.71 --lon -74.00
+          mskit demo
+          mskit info
+        """),
+    )
+    sub = parser.add_subparsers(dest="command", metavar="COMMAND")
+
+    p = sub.add_parser("simu", help="Start Simu AI assistant (interactive)")
+    p.set_defaults(func=cmd_simu)
+
+    p = sub.add_parser("run", help="Run a simulation from plain-English description")
+    p.add_argument("description", nargs=argparse.REMAINDER)
+    p.set_defaults(func=cmd_run)
+
+    p = sub.add_parser("cameras", help="Query OpenCTV traffic cameras")
+    _add_loc(p)
+    p.add_argument("--radius", type=float, default=5.0)
+    p.add_argument("--tfl-key", dest="tfl_key", default=None)
+    p.set_defaults(func=cmd_cameras)
+
+    p = sub.add_parser("traffic", help="Query traffic speed/congestion")
+    _add_loc(p)
+    p.set_defaults(func=cmd_traffic)
+
+    p = sub.add_parser("info", help="Version and data source info")
+    p.set_defaults(func=cmd_info)
+
+    p = sub.add_parser("demo", help="Run a quick feature demo")
+    p.set_defaults(func=cmd_demo)
+
+    return parser
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+    if not args.command:
+        import mskit
+        print(BANNER.format(version=mskit.__version__))
+        parser.print_help()
+        sys.exit(0)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

mskit/dem.py

@@ -0,0 +1,231 @@
+"""
+DEMTile & DEMLoader — fetch AW3D30 elevation tiles on demand from HuggingFace.
+
+Tile naming follows JAXA convention: N{lat:03d}E{lon:03d} etc.
+Each tile covers 1°×1° at 30m resolution (3600×3600 pixels).
+"""
+
+from __future__ import annotations
+
+import os
+import math
+import struct
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import Optional, Tuple
+
+import numpy as np
+
+HF_DATASET = "MegaBites-AI/AW3D30-DEM-Tiles"
+HF_BASE = f"https://huggingface.co/datasets/{HF_DATASET}/resolve/main"
+CACHE_DIR = Path(os.path.expanduser("~/.cache/mskit/dem"))
+
+
+def _tile_name(lat: float, lon: float) -> str:
+    """Return JAXA-style tile name for a lat/lon coordinate."""
+    lat_i = int(math.floor(lat))
+    lon_i = int(math.floor(lon))
+    lat_ch = "N" if lat_i >= 0 else "S"
+    lon_ch = "E" if lon_i >= 0 else "W"
+    return f"{lat_ch}{abs(lat_i):03d}{lon_ch}{abs(lon_i):03d}"
+
+
+class DEMTile:
+    """
+    A single 1°×1° elevation tile fetched from the HF dataset.
+
+    Parameters
+    ----------
+    lat : float  — latitude of any point inside the tile (or tile SW corner)
+    lon : float  — longitude of any point inside the tile
+    token : str, optional — HuggingFace token for private repos
+
+    Examples
+    --------
+    >>> tile = DEMTile(35.6, 139.7)   # Tokyo
+    >>> elev = tile.elevation_at(35.68, 139.69)
+    >>> print(f"{elev:.1f} m")
+    """
+
+    ROWS = 3600
+    COLS = 3600
+
+    def __init__(self, lat: float, lon: float, token: Optional[str] = None):
+        self.lat = math.floor(lat)
+        self.lon = math.floor(lon)
+        self.name = _tile_name(lat, lon)
+        self._token = token or os.environ.get("HF_TOKEN")
+        self._data: Optional[np.ndarray] = None
+
+    # ------------------------------------------------------------------
+    # Data loading
+    # ------------------------------------------------------------------
+
+    def _cache_path(self) -> Path:
+        CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        return CACHE_DIR / f"{self.name}.npy"
+
+    def _remote_url(self) -> str:
+        """Build URL for the tile's .npy file on HuggingFace."""
+        # tiles are stored as: data/{lat_band}/{tile_name}.npy
+        lat_band = f"N{abs(self.lat):03d}" if self.lat >= 0 else f"S{abs(self.lat):03d}"
+        return f"{HF_BASE}/data/{lat_band}/{self.name}.npy"
+
+    def load(self) -> "DEMTile":
+        """Download (or load from cache) the elevation grid."""
+        cache = self._cache_path()
+        if cache.exists():
+            self._data = np.load(str(cache))
+            return self
+
+        url = self._remote_url()
+        headers = {}
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+
+        req = urllib.request.Request(url, headers=headers)
+        try:
+            with urllib.request.urlopen(req) as resp:
+                data = resp.read()
+        except urllib.error.HTTPError as e:
+            raise FileNotFoundError(
+                f"Tile {self.name} not found in dataset ({e.code}). "
+                "It may not have been uploaded yet."
+            ) from e
+
+        # Save to cache
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".npy") as tmp:
+            tmp.write(data)
+            tmp_path = tmp.name
+
+        arr = np.load(tmp_path)
+        np.save(str(cache), arr)
+        os.unlink(tmp_path)
+        self._data = arr
+        return self
+
+    @property
+    def data(self) -> np.ndarray:
+        if self._data is None:
+            self.load()
+        return self._data
+
+    # ------------------------------------------------------------------
+    # Spatial queries
+    # ------------------------------------------------------------------
+
+    def elevation_at(self, lat: float, lon: float) -> float:
+        """Return elevation (metres) at an exact lat/lon coordinate."""
+        row, col = self._latlon_to_rc(lat, lon)
+        return float(self.data[row, col])
+
+    def patch(
+        self,
+        lat: float,
+        lon: float,
+        radius_km: float = 5.0,
+    ) -> np.ndarray:
+        """
+        Return a square elevation patch centred on (lat, lon).
+
+        radius_km controls the half-width of the extracted square.
+        """
+        # 30 m per pixel → pixels per km ≈ 33.33
+        px = int(radius_km * 33.33)
+        r, c = self._latlon_to_rc(lat, lon)
+        r0, r1 = max(0, r - px), min(self.ROWS, r + px)
+        c0, c1 = max(0, c - px), min(self.COLS, c + px)
+        return self.data[r0:r1, c0:c1]
+
+    def slope(self) -> np.ndarray:
+        """Return slope grid (degrees) computed via central differences."""
+        dy, dx = np.gradient(self.data.astype(float), 30.0, 30.0)
+        return np.degrees(np.arctan(np.sqrt(dx**2 + dy**2)))
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _latlon_to_rc(self, lat: float, lon: float) -> Tuple[int, int]:
+        frac_lat = lat - self.lat   # 0..1
+        frac_lon = lon - self.lon   # 0..1
+        # Row 0 = north edge
+        row = int((1.0 - frac_lat) * (self.ROWS - 1))
+        col = int(frac_lon * (self.COLS - 1))
+        row = max(0, min(self.ROWS - 1, row))
+        col = max(0, min(self.COLS - 1, col))
+        return row, col
+
+    def __repr__(self) -> str:
+        loaded = "loaded" if self._data is not None else "not loaded"
+        return f"<DEMTile {self.name} ({loaded})>"
+
+
+class DEMLoader:
+    """
+    Multi-tile loader with an LRU-style cache.
+
+    Automatically fetches and stitches adjacent tiles so simulations
+    can cross tile boundaries seamlessly.
+
+    Parameters
+    ----------
+    max_tiles : int — max tiles to keep in memory simultaneously
+    token : str, optional — HuggingFace token
+
+    Examples
+    --------
+    >>> loader = DEMLoader()
+    >>> elev = loader.elevation_at(35.68, 139.69)
+    """
+
+    def __init__(self, max_tiles: int = 9, token: Optional[str] = None):
+        self._max = max_tiles
+        self._token = token or os.environ.get("HF_TOKEN")
+        self._cache: dict[str, DEMTile] = {}
+
+    def _get_tile(self, lat: float, lon: float) -> DEMTile:
+        name = _tile_name(lat, lon)
+        if name not in self._cache:
+            if len(self._cache) >= self._max:
+                # evict oldest
+                oldest = next(iter(self._cache))
+                del self._cache[oldest]
+            tile = DEMTile(lat, lon, token=self._token)
+            tile.load()
+            self._cache[name] = tile
+        return self._cache[name]
+
+    def elevation_at(self, lat: float, lon: float) -> float:
+        """Return elevation (m) at any lat/lon, fetching tiles as needed."""
+        return self._get_tile(lat, lon).elevation_at(lat, lon)
+
+    def patch(self, lat: float, lon: float, radius_km: float = 5.0) -> np.ndarray:
+        """Return elevation patch centred on (lat, lon)."""
+        return self._get_tile(lat, lon).patch(lat, lon, radius_km)
+
+    def elevation_profile(
+        self,
+        lat1: float, lon1: float,
+        lat2: float, lon2: float,
+        steps: int = 200,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Return (distances_km, elevations_m) along a straight-line transect.
+        """
+        lats = np.linspace(lat1, lat2, steps)
+        lons = np.linspace(lon1, lon2, steps)
+        elevs = np.array([self.elevation_at(la, lo) for la, lo in zip(lats, lons)])
+
+        # Haversine distances
+        R = 6371.0
+        dists = np.zeros(steps)
+        for i in range(1, steps):
+            dlat = math.radians(lats[i] - lats[i-1])
+            dlon = math.radians(lons[i] - lons[i-1])
+            a = math.sin(dlat/2)**2 + math.cos(math.radians(lats[i-1])) * \
+                math.cos(math.radians(lats[i])) * math.sin(dlon/2)**2
+            dists[i] = dists[i-1] + 2 * R * math.asin(math.sqrt(a))
+
+        return dists, elevs

mskit/sims/__init__.py

@@ -0,0 +1 @@
+# mskit.sims — simulation modules