smos 0.5__py3-none-any.whl

smos/__init__.py

@@ -0,0 +1,10 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = __name__
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError

smos/cli.py

@@ -0,0 +1,25 @@
+"""
+Command line interface for all SMOS products: `smos <product> <command>`,
+e.g. `smos l3 download`. See `smos --help`.
+"""
+import click
+
+from smos.smos_l2.cli import smos_l2
+from smos.smos_ic.cli import smos_ic
+from smos.smos_l3.cli import smos_l3
+from smos.smos_l4.cli import smos_l4
+
+
+@click.group(short_help="SMOS Command Line Programs.", name="smos")
+def smos():
+    """
+    Download SMOS data and convert it into time series. Each product has
+    its own group of commands, see e.g. `smos l3 --help`.
+    """
+    pass
+
+
+smos.add_command(smos_l2, name="l2")
+smos.add_command(smos_ic, name="ic")
+smos.add_command(smos_l3, name="l3")
+smos.add_command(smos_l4, name="l4")

smos/grid.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+
+from pygeogrids.grids import CellGrid, BasicGrid, lonlat2cell
+from ease_grid import EASE2_grid
+import numpy as np
+from netCDF4 import Dataset
+import os
+
+
+class EASE25CellGrid(CellGrid):
+    """ CellGrid version of EASE25 Grid as used in SMOS IC """
+
+    def __init__(self, bbox=None, only_land=False):
+        """
+        Parameters
+        ----------
+        bbox: tuple, optional (default: None)
+            (min_lon, min_lat, max_lon, max_lat)
+            Bounding box to create subset for, if None is passed a global
+            grid is used.
+        only_land: bool, optional (default: False)
+            If True, restrict the grid to land points only.
+        """
+
+        ease25 = EASE2_grid(25000)
+        glob_lons, glob_lats = ease25.londim, ease25.latdim
+
+        lons, lats = np.meshgrid(glob_lons, glob_lats)
+        assert lons.shape == lats.shape
+        shape = lons.shape
+
+        lats = np.flipud(lats)  # flip lats, so that origin in bottom left
+
+        globgrid = BasicGrid(lons.flatten(), lats.flatten(), shape=shape)
+
+        self.bbox = bbox
+        self.cellsize = 5.
+
+        # Start with global grid
+        grid = globgrid
+        sgpis = globgrid.activegpis
+        params = {'subset': sgpis}
+        land_mask = None
+
+        # Get land mask if needed
+        if only_land:
+            mask_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), 
+                                   "Grid_Point_Mask_USGS.nc")
+            with Dataset(mask_path) as ds:
+                land_mask = ds.variables["USGS_Land_Flag"][:].flatten().filled() == 0.0
+
+        # Special handling when both land-only and bbox are specified
+        if only_land and self.bbox:
+            # Get land points from global grid
+            land_points = np.ma.masked_array(globgrid.get_grid_points()[0], land_mask)
+            land_sgpis = globgrid.activegpis[~land_points.mask]
+
+            # Get bbox points from global grid
+            bbox_sgpis = globgrid.get_bbox_grid_points(
+                latmin=self.bbox[1],
+                latmax=self.bbox[3],
+                lonmin=self.bbox[0],
+                lonmax=self.bbox[2]
+            )
+
+            # Create intersection of land points and bbox points
+            # (points that are both on land AND within bbox)
+            intersection = np.intersect1d(land_sgpis, bbox_sgpis)
+
+            # Use global grid with the intersection as subset
+            grid = globgrid
+            sgpis = intersection
+            params = {'subset': sgpis}
+            shape = (len(sgpis),)
+
+        # Apply original land mask if only_land is True but no bbox is specified
+        # Land points are a subset of the global grid, i.e. the gpis are the
+        # same as in the global grid (not renumbered).
+        elif only_land:
+            land_points = np.ma.masked_array(globgrid.get_grid_points()[0], land_mask)
+            sgpis = globgrid.activegpis[~land_points.mask]
+            params = {'subset': sgpis}
+            shape = (len(sgpis),)
+
+        # Apply original bbox filter if only bbox is specified (no land mask)
+        elif self.bbox:
+            bbox_sgpis = grid.get_bbox_grid_points(
+                latmin=self.bbox[1],
+                latmax=self.bbox[3],
+                lonmin=self.bbox[0],
+                lonmax=self.bbox[2]
+            )
+            sgpis = bbox_sgpis
+            params = {'subset': sgpis}
+
+        # Set final grid parameters
+        self.grid = grid
+        self.subset = sgpis
+        self.shape = shape
+
+        super().__init__(lon=grid.arrlon,
+                         lat=grid.arrlat,
+                         cells=lonlat2cell(grid.arrlon, grid.arrlat,
+                                           self.cellsize),
+                         shape=shape,
+                         **params)
+
+        if only_land:
+            self.subset_shape = shape
+        else:
+            self.subset_shape = (len(np.unique(self.activearrlat)),
+                                 len(np.unique(self.activearrlon)))
+
+
+    def cut(self) -> CellGrid:
+        # create a new grid from the active subset
+        return BasicGrid(lon=self.activearrlon,
+                         lat=self.activearrlat,
+                         gpis=self.activegpis,
+                         subset=None,
+                         shape=self.subset_shape).to_cell_grid(self.cellsize)