polytope-python 1.0.38__tar.gz → 1.0.40__tar.gz

{polytope_python-1.0.38/polytope_python.egg-info → polytope_python-1.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polytope-python
-Version: 1.0.38
+Version: 1.0.40
 Summary: Polytope datacube feature extraction library
 Home-page: https://github.com/ecmwf/polytope
 Author: ECMWF

{polytope_python-1.0.38 → polytope_python-1.0.40}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/healpix.py

@@ -101,7 +101,7 @@ class HealpixGridMapper(DatacubeMapper):
                 return idx
         for i in range(3 * self._resolution, 4 * self._resolution - 1):
             if i != first_idx:
-                idx += 4 * (4 * self._resolution - 1 - i + 1)
+                idx += 4 * (4 * self._resolution - 1 - i)
             else:
                 idx += second_idx
                 return idx

{polytope_python-1.0.38 → polytope_python-1.0.40}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/healpix_nested.py

@@ -13,11 +13,9 @@ class NestedHealpixGridMapper(DatacubeMapper):
         self._first_axis_vals = self.first_axis_vals()
         self.compressed_grid_axes = [self._mapped_axes[1]]
         self.Nside = self._resolution
-        self._cached_longitudes = {}
         self.k = int(math.log2(self.Nside))
         self.Npix = 12 * self.Nside * self.Nside
         self.Ncap = (self.Nside * (self.Nside - 1)) << 1
-        self._healpix_longitudes = {}
         if md5_hash is not None:
             self.md5_hash = md5_hash
         else:
@@ -59,9 +57,7 @@ class NestedHealpixGridMapper(DatacubeMapper):
         return values
 
     def second_axis_vals_from_idx(self, first_val_idx):
-        if first_val_idx not in self._healpix_longitudes:
-            self._healpix_longitudes[first_val_idx] = self.HEALPix_longitudes(first_val_idx)
-        values = self._healpix_longitudes[first_val_idx]
+        values = self.HEALPix_longitudes(first_val_idx)
         return values
 
     def HEALPix_nj(self, i):
@@ -77,19 +73,13 @@ class NestedHealpixGridMapper(DatacubeMapper):
             return self.HEALPix_nj(ni - 1 - i)
 
     def HEALPix_longitudes(self, i):
-        if i in self._cached_longitudes:
-            return self._cached_longitudes[i]
-        else:
-            Nj = self.HEALPix_nj(i)
-            step = 360.0 / Nj
-            start = (
-                step / 2.0
-                if i < self._resolution or 3 * self._resolution - 1 < i or (i + self._resolution) % 2
-                else 0.0
-            )
+        Nj = self.HEALPix_nj(i)
+        step = 360.0 / Nj
+        start = (
+            step / 2.0 if i < self._resolution or 3 * self._resolution - 1 < i or (i + self._resolution) % 2 else 0.0
+        )
 
-            longitudes = [start + n * step for n in range(Nj)]
-            self._cached_longitudes[i] = longitudes
+        longitudes = [start + n * step for n in range(Nj)]
         return longitudes
 
     def map_second_axis(self, first_val, lower, upper):
@@ -113,7 +103,7 @@ class NestedHealpixGridMapper(DatacubeMapper):
                 return idx
         for i in range(3 * self._resolution, 4 * self._resolution - 1):
             if i != first_idx:
-                idx += 4 * (4 * self._resolution - 1 - i + 1)
+                idx += 4 * (4 * self._resolution - 1 - i)
             else:
                 idx += second_idx
                 return idx

polytope_python-1.0.40/polytope_feature/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.40"

{polytope_python-1.0.38 → polytope_python-1.0.40/polytope_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polytope-python
-Version: 1.0.38
+Version: 1.0.40
 Summary: Polytope datacube feature extraction library
 Home-page: https://github.com/ecmwf/polytope
 Author: ECMWF

polytope_python-1.0.40/tests/test_healpix_nested_grid.py

@@ -0,0 +1,262 @@
+import pandas as pd
+import pytest
+from earthkit import data
+from helper_functions import download_test_data, find_nearest_latlon
+
+from polytope_feature.datacube.transformations.datacube_mappers.mapper_types.healpix_nested import (
+    NestedHealpixGridMapper,
+)
+from polytope_feature.engine.hullslicer import HullSlicer
+from polytope_feature.polytope import Polytope, Request
+from polytope_feature.shapes import Box, Select
+
+
+class TestHealpixNestedGrid:
+    def setup_method(self, method):
+        nexus_url = "https://get.ecmwf.int/test-data/polytope/test-data/healpix_nested.grib"
+        download_test_data(nexus_url, "healpix_nested.grib")
+
+        ds = data.from_source("file", "./tests/data/healpix_nested.grib")[3]
+        self.latlon_array = ds.to_xarray(engine="cfgrib").isel(step=0).isel(time=0).isel(heightAboveGround=0).t2m
+        self.options = {
+            "axis_config": [
+                {
+                    "axis_name": "date",
+                    "transformations": [{"name": "merge", "other_axis": "time", "linkers": ["T", "00"]}],
+                },
+                {
+                    "axis_name": "values",
+                    "transformations": [
+                        {
+                            "name": "mapper",
+                            "type": "healpix_nested",
+                            "resolution": 128,
+                            "axes": ["latitude", "longitude"],
+                        }
+                    ],
+                },
+                {"axis_name": "latitude", "transformations": [{"name": "reverse", "is_reverse": True}]},
+                {"axis_name": "longitude", "transformations": [{"name": "cyclic", "range": [0, 360]}]},
+            ],
+            "pre_path": {"class": "d1", "expver": "0001", "levtype": "sfc", "stream": "clte"},
+            "compressed_axes_config": [
+                "longitude",
+                "latitude",
+            ],
+            "alternative_axes": [
+                {
+                    "axis_name": "class",
+                    "values": [
+                        "d1",
+                    ],
+                },
+                {
+                    "axis_name": "activity",
+                    "values": [
+                        "ScenarioMIP",
+                    ],
+                },
+                {
+                    "axis_name": "dataset",
+                    "values": ["climate-dt"],
+                },
+                {
+                    "axis_name": "date",
+                    "values": ["20200102"],
+                },
+                {
+                    "axis_name": "time",
+                    "values": ["0100"],
+                },
+                {
+                    "axis_name": "experiment",
+                    "values": ["SSP3-7.0"],
+                },
+                {
+                    "axis_name": "expver",
+                    "values": ["0001"],
+                },
+                {
+                    "axis_name": "generation",
+                    "values": ["1"],
+                },
+                {
+                    "axis_name": "levtype",
+                    "values": ["sfc"],
+                },
+                {
+                    "axis_name": "model",
+                    "values": ["IFS-NEMO"],
+                },
+                {
+                    "axis_name": "param",
+                    "values": ["167"],
+                },
+                {
+                    "axis_name": "realization",
+                    "values": ["1"],
+                },
+                {
+                    "axis_name": "resolution",
+                    "values": ["standard"],
+                },
+                {
+                    "axis_name": "stream",
+                    "values": ["clte"],
+                },
+                {
+                    "axis_name": "type",
+                    "values": ["fc"],
+                },
+            ],
+        }
+        self.slicer = HullSlicer()
+        self.API = Polytope(
+            datacube=self.latlon_array,
+            engine=self.slicer,
+            options=self.options,
+        )
+
+    @pytest.mark.internet
+    def test_healpix_nested_grid_equator(self):
+        request = Request(
+            Select("valid_time", [pd.Timestamp("20200102T010000")]),
+            Select("time", [pd.Timestamp("20200102T010000")]),
+            Select("step", [0]),
+            Select("heightAboveGround", [2]),
+            Box(["latitude", "longitude"], [0, 0], [2, 2]),
+        )
+        result = self.API.retrieve(request)
+        result.pprint()
+        assert len(result.leaves) == 7
+        tot_leaves = 0
+        for leaf in result.leaves:
+            tot_leaves += len(leaf.result[1])
+        assert tot_leaves == 21
+
+        lats = []
+        lons = []
+        eccodes_lats = []
+        eccodes_lons = []
+        tol = 1e-8
+        for i, leaf in enumerate(result.leaves[:]):
+            cubepath = leaf.flatten()
+            lat = cubepath["latitude"]
+            lons_ = cubepath["longitude"]
+            for i, lon in enumerate(lons_):
+                lon = [
+                    lon,
+                ]
+                lats.append(lat)
+                lons.append(lon)
+                nearest_points = find_nearest_latlon("./tests/data/healpix_nested.grib", lat[0], lon[0])
+                eccodes_lat = nearest_points[0][0]["lat"]
+                eccodes_lon = nearest_points[0][0]["lon"]
+                eccodes_result = nearest_points[3][0]["value"]
+                eccodes_lats.append(eccodes_lat)
+                eccodes_lons.append(eccodes_lon)
+
+                mapper = NestedHealpixGridMapper("values", ["latitude", "longitude"], 128)
+                assert nearest_points[0][0]["index"] == mapper.unmap(lat, lon)[0]
+                assert eccodes_lat - tol <= lat[0]
+                assert lat[0] <= eccodes_lat + tol
+                assert eccodes_lon - tol <= lon[0]
+                assert lon[0] <= eccodes_lon + tol
+                assert leaf.result[1][i] - 1e-4 <= eccodes_result <= leaf.result[1][i] + 1e-4
+        assert len(eccodes_lats) == 21
+
+    @pytest.mark.internet
+    def test_healpix_nested_grid_south_pole(self):
+        request = Request(
+            Select("valid_time", [pd.Timestamp("20200102T010000")]),
+            Select("time", [pd.Timestamp("20200102T010000")]),
+            Select("step", [0]),
+            Select("heightAboveGround", [2]),
+            Box(["latitude", "longitude"], [-87, 0], [-85, 10]),
+        )
+        result = self.API.retrieve(request)
+        result.pprint()
+        assert len(result.leaves) == 5
+        tot_leaves = 0
+        for leaf in result.leaves:
+            tot_leaves += len(leaf.result[1])
+        assert tot_leaves == 5
+
+        lats = []
+        lons = []
+        eccodes_lats = []
+        eccodes_lons = []
+        tol = 1e-8
+        for i, leaf in enumerate(result.leaves[:]):
+            cubepath = leaf.flatten()
+            lat = cubepath["latitude"]
+            lons_ = cubepath["longitude"]
+            for i, lon in enumerate(lons_):
+                lon = [
+                    lon,
+                ]
+                lats.append(lat)
+                lons.append(lon)
+                nearest_points = find_nearest_latlon("./tests/data/healpix_nested.grib", lat[0], lon[0])
+                eccodes_lat = nearest_points[0][0]["lat"]
+                eccodes_lon = nearest_points[0][0]["lon"]
+                eccodes_result = nearest_points[3][0]["value"]
+                eccodes_lats.append(eccodes_lat)
+                eccodes_lons.append(eccodes_lon)
+
+                mapper = NestedHealpixGridMapper("values", ["latitude", "longitude"], 128)
+                assert nearest_points[0][0]["index"] == mapper.unmap(lat, lon)[0]
+                assert eccodes_lat - tol <= lat[0]
+                assert lat[0] <= eccodes_lat + tol
+                assert eccodes_lon - tol <= lon[0]
+                assert lon[0] <= eccodes_lon + tol
+                assert leaf.result[1][i] - 1e-4 <= eccodes_result <= leaf.result[1][i] + 1e-4
+        assert len(eccodes_lats) == 5
+
+    @pytest.mark.internet
+    def test_healpix_nested_grid_north_pole(self):
+        request = Request(
+            Select("valid_time", [pd.Timestamp("20200102T010000")]),
+            Select("time", [pd.Timestamp("20200102T010000")]),
+            Select("step", [0]),
+            Select("heightAboveGround", [2]),
+            Box(["latitude", "longitude"], [83, 0], [86, 10]),
+        )
+        result = self.API.retrieve(request)
+        result.pprint()
+        assert len(result.leaves) == 9
+        tot_leaves = 0
+        for leaf in result.leaves:
+            tot_leaves += len(leaf.result[1])
+        assert tot_leaves == 15
+
+        lats = []
+        lons = []
+        eccodes_lats = []
+        eccodes_lons = []
+        tol = 1e-8
+        for i, leaf in enumerate(result.leaves[:]):
+            cubepath = leaf.flatten()
+            lat = cubepath["latitude"]
+            lons_ = cubepath["longitude"]
+            for i, lon in enumerate(lons_):
+                lon = [
+                    lon,
+                ]
+                lats.append(lat)
+                lons.append(lon)
+                nearest_points = find_nearest_latlon("./tests/data/healpix_nested.grib", lat[0], lon[0])
+                eccodes_lat = nearest_points[0][0]["lat"]
+                eccodes_lon = nearest_points[0][0]["lon"]
+                eccodes_result = nearest_points[3][0]["value"]
+                eccodes_lats.append(eccodes_lat)
+                eccodes_lons.append(eccodes_lon)
+
+                mapper = NestedHealpixGridMapper("values", ["latitude", "longitude"], 128)
+                assert nearest_points[0][0]["index"] == mapper.unmap(lat, lon)[0]
+                assert eccodes_lat - tol <= lat[0]
+                assert lat[0] <= eccodes_lat + tol
+                assert eccodes_lon - tol <= lon[0]
+                assert lon[0] <= eccodes_lon + tol
+                assert leaf.result[1][i] - 1e-4 <= eccodes_result <= leaf.result[1][i] + 1e-4
+        assert len(eccodes_lats) == 15

polytope_python-1.0.38/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/__init__.py

@@ -1,5 +0,0 @@
-from .healpix import *
-from .local_regular import *
-from .octahedral import *
-from .reduced_ll import *
-from .regular import *

polytope_python-1.0.38/polytope_feature/version.py

@@ -1 +0,0 @@
-__version__ = "1.0.38"

polytope_python-1.0.38/tests/test_healpix_nested_grid.py

@@ -1,182 +0,0 @@
-# import geopandas as gpd
-# import matplotlib.pyplot as plt
-import pandas as pd
-import pytest
-
-from polytope_feature.datacube.transformations.datacube_mappers.mapper_types.healpix_nested import (
-    NestedHealpixGridMapper,
-)
-from polytope_feature.engine.hullslicer import HullSlicer
-from polytope_feature.polytope import Polytope, Request
-from polytope_feature.shapes import Box, Select
-
-
-class TestHealpixNestedGrid:
-    def setup_method(self, method):
-        self.options = {
-            "axis_config": [
-                {
-                    "axis_name": "date",
-                    "transformations": [{"name": "merge", "other_axis": "time", "linkers": ["T", "00"]}],
-                },
-                {
-                    "axis_name": "values",
-                    "transformations": [
-                        {
-                            "name": "mapper",
-                            "type": "healpix_nested",
-                            "resolution": 128,
-                            "axes": ["latitude", "longitude"],
-                        }
-                    ],
-                },
-                {"axis_name": "latitude", "transformations": [{"name": "reverse", "is_reverse": True}]},
-                {"axis_name": "longitude", "transformations": [{"name": "cyclic", "range": [0, 360]}]},
-            ],
-            "pre_path": {"class": "d1", "expver": "0001", "levtype": "sfc", "stream": "clte"},
-            "compressed_axes_config": [
-                "longitude",
-                "latitude",
-            ],
-            "alternative_axes": [
-                {
-                    "axis_name": "class",
-                    "values": [
-                        "d1",
-                    ],
-                },
-                {
-                    "axis_name": "activity",
-                    "values": [
-                        "ScenarioMIP",
-                    ],
-                },
-                {
-                    "axis_name": "dataset",
-                    "values": ["climate-dt"],
-                },
-                {
-                    "axis_name": "date",
-                    "values": ["20200102"],
-                },
-                {
-                    "axis_name": "time",
-                    "values": ["0100"],
-                },
-                {
-                    "axis_name": "experiment",
-                    "values": ["SSP3-7.0"],
-                },
-                {
-                    "axis_name": "expver",
-                    "values": ["0001"],
-                },
-                {
-                    "axis_name": "generation",
-                    "values": ["1"],
-                },
-                {
-                    "axis_name": "levtype",
-                    "values": ["sfc"],
-                },
-                {
-                    "axis_name": "model",
-                    "values": ["IFS-NEMO"],
-                },
-                {
-                    "axis_name": "param",
-                    "values": ["167"],
-                },
-                {
-                    "axis_name": "realization",
-                    "values": ["1"],
-                },
-                {
-                    "axis_name": "resolution",
-                    "values": ["standard"],
-                },
-                {
-                    "axis_name": "stream",
-                    "values": ["clte"],
-                },
-                {
-                    "axis_name": "type",
-                    "values": ["fc"],
-                },
-            ],
-        }
-
-    @pytest.mark.internet
-    @pytest.mark.fdb
-    @pytest.mark.skip(reason="different fdb schema for climate dt")
-    def test_healpix_nested_grid(self):
-        import pygribjump as gj
-
-        request = Request(
-            Select("activity", ["ScenarioMIP"]),
-            Select("class", ["d1"]),
-            Select("dataset", ["climate-dt"]),
-            Select("date", [pd.Timestamp("20200102T010000")]),
-            Select("experiment", ["SSP3-7.0"]),
-            Select("expver", ["0001"]),
-            Select("generation", ["1"]),
-            Select("levtype", ["sfc"]),
-            Select("model", ["IFS-NEMO"]),
-            Select("param", ["167"]),
-            Select("realization", ["1"]),
-            Select("resolution", ["standard"]),
-            Select("stream", ["clte"]),
-            Select("type", ["fc"]),
-            Box(["latitude", "longitude"], [0, 0], [2, 2]),
-        )
-
-        self.fdbdatacube = gj.GribJump()
-        self.slicer = HullSlicer()
-        self.API = Polytope(
-            datacube=self.fdbdatacube,
-            engine=self.slicer,
-            options=self.options,
-        )
-
-        result = self.API.retrieve(request)
-        result.pprint()
-        assert len(result.leaves) == 21
-
-        from helper_functions import find_nearest_latlon
-
-        lats = []
-        lons = []
-        eccodes_lats = []
-        eccodes_lons = []
-        tol = 1e-8
-        for i, leaf in enumerate(result.leaves[:]):
-            cubepath = leaf.flatten()
-            result_tree = leaf.result[0]
-            lat = cubepath["latitude"]
-            lon = cubepath["longitude"]
-            lats.append(lat)
-            lons.append(lon)
-            nearest_points = find_nearest_latlon("./tests/data/healpix_nested.grib", lat[0], lon[0])
-            eccodes_lat = nearest_points[0][0]["lat"]
-            eccodes_lon = nearest_points[0][0]["lon"]
-            eccodes_result = nearest_points[3][0]["value"]
-            eccodes_lats.append(eccodes_lat)
-            eccodes_lons.append(eccodes_lon)
-
-            mapper = NestedHealpixGridMapper("base", ["base", "base"], 128)
-            assert nearest_points[0][0]["index"] == mapper.unmap(lat, lon)
-            assert eccodes_lat - tol <= lat[0]
-            assert lat[0] <= eccodes_lat + tol
-            assert eccodes_lon - tol <= lon[0]
-            assert lon[0] <= eccodes_lon + tol
-            assert eccodes_result == result_tree
-        assert len(eccodes_lats) == 21
-
-        # worldmap = gpd.read_file(gpd.datasets.get_path("naturalearth_lowres"))
-        # fig, ax = plt.subplots(figsize=(12, 6))
-        # worldmap.plot(color="darkgrey", ax=ax)
-
-        # plt.scatter(lons, lats, s=18, c="red", cmap="YlOrRd")
-        # plt.scatter(eccodes_lons, eccodes_lats, s=6, c="green")
-        # plt.colorbar(label="Temperature")
-        # plt.show()