From d2e9bf7877a48a3ccb427b4f70d761c1c15402c6 Mon Sep 17 00:00:00 2001 From: Yordan Radev Date: Tue, 4 Feb 2025 15:29:15 -0500 Subject: [PATCH 01/28] Fixed the import issue #317 --- readme.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/readme.md b/readme.md index 3db6544d..05eed3c2 100644 --- a/readme.md +++ b/readme.md @@ -88,7 +88,7 @@ Here is a step-by-step example of how to use this software. ```Python options = {"longitude": {"cyclic": [0, 360.0]}} - from polytope.polytope import Polytope + from polytope_feature.polytope import Polytope p = Polytope(datacube=array, axis_options=options) ``` @@ -97,7 +97,7 @@ Here is a step-by-step example of how to use this software. In this example, we want to extract a simple 2D box in latitude and longitude at step 0. We thus create the two relevant shapes we need to build this 3-dimensional object, ```Python import numpy as np - from polytope.shapes import Box, Select + from polytope_feature.shapes import Box, Select box = Box(["latitude", "longitude"], [0, 0], [1, 1]) step_point = Select("step", [np.timedelta64(0, "s")]) @@ -105,7 +105,7 @@ Here is a step-by-step example of how to use this software. which we then incorporate into a Polytope request. ```Python - from polytope.polytope import Request + from polytope_feature.polytope import Request request = Request(box, step_point) ``` From 312875da1f6c9d7a5f02d506dbc58c8967ac095b Mon Sep 17 00:00:00 2001 From: mathleur Date: Fri, 7 Feb 2025 17:49:54 +0100 Subject: [PATCH 02/28] add N320 grid --- .../datacube_mappers/datacube_mappers.py | 1 + .../mapper_types/reduced_gaussian.py | 1453 +++++++++++++++++ 2 files changed, 1454 insertions(+) create mode 100644 polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py diff --git a/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py b/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py index 583da76a..6e4ea749 100644 --- a/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py +++ b/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py @@ -137,4 +137,5 @@ def unmap_tree_node(self, node, unwanted_path): "reduced_ll": "ReducedLatLonMapper", "local_regular": "LocalRegularGridMapper", "healpix_nested": "NestedHealpixGridMapper", + "reduced_guassian": "ReducedGaussianGridMapper", } diff --git a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py new file mode 100644 index 00000000..c0546f4e --- /dev/null +++ b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py @@ -0,0 +1,1453 @@ +import bisect +import logging +import math + +from .....utility.list_tools import bisect_left_cmp, bisect_right_cmp +from ..datacube_mappers import DatacubeMapper + + +class ReducedGaussianGridMapper(DatacubeMapper): + def __init__(self, base_axis, mapped_axes, resolution, md5_hash=None, local_area=[], axis_reversed=None): + # TODO: if local area is not empty list, raise NotImplemented + self._mapped_axes = mapped_axes + self._base_axis = base_axis + self._resolution = resolution + self._first_axis_vals = self.first_axis_vals() + self._first_idx_map = self.create_first_idx_map() + self._second_axis_spacing = {} + self._axis_reversed = {mapped_axes[0]: True, mapped_axes[1]: False} + if self._axis_reversed[mapped_axes[1]]: + raise NotImplementedError("Octahedral grid with second axis in decreasing order is not supported") + if not self._axis_reversed[mapped_axes[0]]: + raise NotImplementedError("Octahedral grid with first axis in increasing order is not supported") + self.compressed_grid_axes = [self._mapped_axes[1]] + if md5_hash is not None: + self.md5_hash = md5_hash + else: + self.md5_hash = _md5_hash.get(resolution, None) + + def gauss_first_guess(self): + i = 0 + gvals = [ + 2.4048255577e0, + 5.5200781103e0, + 8.6537279129e0, + 11.7915344391e0, + 14.9309177086e0, + 18.0710639679e0, + 21.2116366299e0, + 24.3524715308e0, + 27.4934791320e0, + 30.6346064684e0, + 33.7758202136e0, + 36.9170983537e0, + 40.0584257646e0, + 43.1997917132e0, + 46.3411883717e0, + 49.4826098974e0, + 52.6240518411e0, + 55.7655107550e0, + 58.9069839261e0, + 62.0484691902e0, + 65.1899648002e0, + 68.3314693299e0, + 71.4729816036e0, + 74.6145006437e0, + 77.7560256304e0, + 80.8975558711e0, + 84.0390907769e0, + 87.1806298436e0, + 90.3221726372e0, + 93.4637187819e0, + 96.6052679510e0, + 99.7468198587e0, + 102.8883742542e0, + 106.0299309165e0, + 109.1714896498e0, + 112.3130502805e0, + 115.4546126537e0, + 118.5961766309e0, + 121.7377420880e0, + 124.8793089132e0, + 128.0208770059e0, + 131.1624462752e0, + 134.3040166383e0, + 137.4455880203e0, + 140.5871603528e0, + 143.7287335737e0, + 146.8703076258e0, + 150.0118824570e0, + 153.1534580192e0, + 156.2950342685e0, + ] + + numVals = len(gvals) + vals = [] + for i in range(self._resolution): + if i < numVals: + vals.append(gvals[i]) + else: + vals.append(vals[i - 1] + math.pi) + return vals + + def get_precomputed_values_N320(self): + lats = [ + 89.784877, + 89.506203, + 89.225883, + 88.945191, + 88.664358, + 88.383457, + 88.102518, + 87.821556, + 87.540577, + 87.259589, + 86.978592, + 86.697590, + 86.416583, + 86.135573, + 85.854560, + 85.573545, + 85.292528, + 85.011510, + 84.730490, + 84.449469, + 84.168447, + 83.887425, + 83.606402, + 83.325378, + 83.044353, + 82.763329, + 82.482303, + 82.201278, + 81.920252, + 81.639225, + 81.358199, + 81.077172, + 80.796145, + 80.515118, + 80.234091, + 79.953063, + 79.672035, + 79.391008, + 79.109980, + 78.828951, + 78.547923, + 78.266895, + 77.985866, + 77.704838, + 77.423809, + 77.142781, + 76.861752, + 76.580723, + 76.299694, + 76.018665, + 75.737636, + 75.456607, + 75.175578, + 74.894549, + 74.613520, + 74.332490, + 74.051461, + 73.770432, + 73.489402, + 73.208373, + 72.927344, + 72.646314, + 72.365285, + 72.084255, + 71.803226, + 71.522196, + 71.241166, + 70.960137, + 70.679107, + 70.398077, + 70.117048, + 69.836018, + 69.554988, + 69.273959, + 68.992929, + 68.711899, + 68.430869, + 68.149839, + 67.868810, + 67.587780, + 67.306750, + 67.025720, + 66.744690, + 66.463660, + 66.182630, + 65.901600, + 65.620570, + 65.339540, + 65.058510, + 64.777481, + 64.496451, + 64.215421, + 63.934391, + 63.653361, + 63.372331, + 63.091300, + 62.810270, + 62.529240, + 62.248210, + 61.967180, + 61.686150, + 61.405120, + 61.124090, + 60.843060, + 60.562030, + 60.281000, + 59.999970, + 59.718940, + 59.437910, + 59.156879, + 58.875849, + 58.594819, + 58.313789, + 58.032759, + 57.751729, + 57.470699, + 57.189668, + 56.908638, + 56.627608, + 56.346578, + 56.065548, + 55.784518, + 55.503487, + 55.222457, + 54.941427, + 54.660397, + 54.379367, + 54.098337, + 53.817306, + 53.536276, + 53.255246, + 52.974216, + 52.693186, + 52.412155, + 52.131125, + 51.850095, + 51.569065, + 51.288034, + 51.007004, + 50.725974, + 50.444944, + 50.163913, + 49.882883, + 49.601853, + 49.320823, + 49.039793, + 48.758762, + 48.477732, + 48.196702, + 47.915672, + 47.634641, + 47.353611, + 47.072581, + 46.791551, + 46.510520, + 46.229490, + 45.948460, + 45.667429, + 45.386399, + 45.105369, + 44.824339, + 44.543308, + 44.262278, + 43.981248, + 43.700218, + 43.419187, + 43.138157, + 42.857127, + 42.576096, + 42.295066, + 42.014036, + 41.733006, + 41.451975, + 41.170945, + 40.889915, + 40.608884, + 40.327854, + 40.046824, + 39.765793, + 39.484763, + 39.203733, + 38.922703, + 38.641672, + 38.360642, + 38.079612, + 37.798581, + 37.517551, + 37.236521, + 36.955490, + 36.674460, + 36.393430, + 36.112399, + 35.831369, + 35.550339, + 35.269308, + 34.988278, + 34.707248, + 34.426218, + 34.145187, + 33.864157, + 33.583127, + 33.302096, + 33.021066, + 32.740036, + 32.459005, + 32.177975, + 31.896945, + 31.615914, + 31.334884, + 31.053854, + 30.772823, + 30.491793, + 30.210763, + 29.929732, + 29.648702, + 29.367672, + 29.086641, + 28.805611, + 28.524581, + 28.243550, + 27.962520, + 27.681490, + 27.400459, + 27.119429, + 26.838399, + 26.557368, + 26.276338, + 25.995308, + 25.714277, + 25.433247, + 25.152217, + 24.871186, + 24.590156, + 24.309126, + 24.028095, + 23.747065, + 23.466035, + 23.185004, + 22.903974, + 22.622944, + 22.341913, + 22.060883, + 21.779853, + 21.498822, + 21.217792, + 20.936761, + 20.655731, + 20.374701, + 20.093670, + 19.812640, + 19.531610, + 19.250579, + 18.969549, + 18.688519, + 18.407488, + 18.126458, + 17.845428, + 17.564397, + 17.283367, + 17.002337, + 16.721306, + 16.440276, + 16.159246, + 15.878215, + 15.597185, + 15.316154, + 15.035124, + 14.754094, + 14.473063, + 14.192033, + 13.911003, + 13.629972, + 13.348942, + 13.067912, + 12.786881, + 12.505851, + 12.224821, + 11.943790, + 11.662760, + 11.381730, + 11.100699, + 10.819669, + 10.538638, + 10.257608, + 9.976578, + 9.695547, + 9.414517, + 9.133487, + 8.852456, + 8.571426, + 8.290396, + 8.009365, + 7.728335, + 7.447305, + 7.166274, + 6.885244, + 6.604213, + 6.323183, + 6.042153, + 5.761122, + 5.480092, + 5.199062, + 4.918031, + 4.637001, + 4.355971, + 4.074940, + 3.793910, + 3.512879, + 3.231849, + 2.950819, + 2.669788, + 2.388758, + 2.107728, + 1.826697, + 1.545667, + 1.264637, + 0.983606, + 0.702576, + 0.421546, + 0.140515, + -0.140515, + -0.421546, + -0.702576, + -0.983606, + -1.264637, + -1.545667, + -1.826697, + -2.107728, + -2.388758, + -2.669788, + -2.950819, + -3.231849, + -3.512879, + -3.793910, + -4.074940, + -4.355971, + -4.637001, + -4.918031, + -5.199062, + -5.480092, + -5.761122, + -6.042153, + -6.323183, + -6.604213, + -6.885244, + -7.166274, + -7.447305, + -7.728335, + -8.009365, + -8.290396, + -8.571426, + -8.852456, + -9.133487, + -9.414517, + -9.695547, + -9.976578, + -10.257608, + -10.538638, + -10.819669, + -11.100699, + -11.381730, + -11.662760, + -11.943790, + -12.224821, + -12.505851, + -12.786881, + -13.067912, + -13.348942, + -13.629972, + -13.911003, + -14.192033, + -14.473063, + -14.754094, + -15.035124, + -15.316154, + -15.597185, + -15.878215, + -16.159246, + -16.440276, + -16.721306, + -17.002337, + -17.283367, + -17.564397, + -17.845428, + -18.126458, + -18.407488, + -18.688519, + -18.969549, + -19.250579, + -19.531610, + -19.812640, + -20.093670, + -20.374701, + -20.655731, + -20.936761, + -21.217792, + -21.498822, + -21.779853, + -22.060883, + -22.341913, + -22.622944, + -22.903974, + -23.185004, + -23.466035, + -23.747065, + -24.028095, + -24.309126, + -24.590156, + -24.871186, + -25.152217, + -25.433247, + -25.714277, + -25.995308, + -26.276338, + -26.557368, + -26.838399, + -27.119429, + -27.400459, + -27.681490, + -27.962520, + -28.243550, + -28.524581, + -28.805611, + -29.086641, + -29.367672, + -29.648702, + -29.929732, + -30.210763, + -30.491793, + -30.772823, + -31.053854, + -31.334884, + -31.615914, + -31.896945, + -32.177975, + -32.459005, + -32.740036, + -33.021066, + -33.302096, + -33.583127, + -33.864157, + -34.145187, + -34.426218, + -34.707248, + -34.988278, + -35.269308, + -35.550339, + -35.831369, + -36.112399, + -36.393430, + -36.674460, + -36.955490, + -37.236521, + -37.517551, + -37.798581, + -38.079612, + -38.360642, + -38.641672, + -38.922703, + -39.203733, + -39.484763, + -39.765793, + -40.046824, + -40.327854, + -40.608884, + -40.889915, + -41.170945, + -41.451975, + -41.733006, + -42.014036, + -42.295066, + -42.576096, + -42.857127, + -43.138157, + -43.419187, + -43.700218, + -43.981248, + -44.262278, + -44.543308, + -44.824339, + -45.105369, + -45.386399, + -45.667429, + -45.948460, + -46.229490, + -46.510520, + -46.791551, + -47.072581, + -47.353611, + -47.634641, + -47.915672, + -48.196702, + -48.477732, + -48.758762, + -49.039793, + -49.320823, + -49.601853, + -49.882883, + -50.163913, + -50.444944, + -50.725974, + -51.007004, + -51.288034, + -51.569065, + -51.850095, + -52.131125, + -52.412155, + -52.693186, + -52.974216, + -53.255246, + -53.536276, + -53.817306, + -54.098337, + -54.379367, + -54.660397, + -54.941427, + -55.222457, + -55.503487, + -55.784518, + -56.065548, + -56.346578, + -56.627608, + -56.908638, + -57.189668, + -57.470699, + -57.751729, + -58.032759, + -58.313789, + -58.594819, + -58.875849, + -59.156879, + -59.437910, + -59.718940, + -59.999970, + -60.281000, + -60.562030, + -60.843060, + -61.124090, + -61.405120, + -61.686150, + -61.967180, + -62.248210, + -62.529240, + -62.810270, + -63.091300, + -63.372331, + -63.653361, + -63.934391, + -64.215421, + -64.496451, + -64.777481, + -65.058510, + -65.339540, + -65.620570, + -65.901600, + -66.182630, + -66.463660, + -66.744690, + -67.025720, + -67.306750, + -67.587780, + -67.868810, + -68.149839, + -68.430869, + -68.711899, + -68.992929, + -69.273959, + -69.554988, + -69.836018, + -70.117048, + -70.398077, + -70.679107, + -70.960137, + -71.241166, + -71.522196, + -71.803226, + -72.084255, + -72.365285, + -72.646314, + -72.927344, + -73.208373, + -73.489402, + -73.770432, + -74.051461, + -74.332490, + -74.613520, + -74.894549, + -75.175578, + -75.456607, + -75.737636, + -76.018665, + -76.299694, + -76.580723, + -76.861752, + -77.142781, + -77.423809, + -77.704838, + -77.985866, + -78.266895, + -78.547923, + -78.828951, + -79.109980, + -79.391008, + -79.672035, + -79.953063, + -80.234091, + -80.515118, + -80.796145, + -81.077172, + -81.358199, + -81.639225, + -81.920252, + -82.201278, + -82.482303, + -82.763329, + -83.044353, + -83.325378, + -83.606402, + -83.887425, + -84.168447, + -84.449469, + -84.730490, + -85.011510, + -85.292528, + -85.573545, + -85.854560, + -86.135573, + -86.416583, + -86.697590, + -86.978592, + -87.259589, + -87.540577, + -87.821556, + -88.102518, + -88.383457, + -88.664358, + -88.945191, + -89.225883, + -89.506203, + -89.784877, + ] + return lats + + def first_axis_vals(self): + if self._resolution == 320: + return self.get_precomputed_values_N320() + else: + logging.info("Calculating grid. Not using a pre-computed grid.") + precision = 1.0e-14 + nval = self._resolution * 2 + rad2deg = 180 / math.pi + convval = 1 - ((2 / math.pi) * (2 / math.pi)) * 0.25 + vals = self.gauss_first_guess() + new_vals = [0] * nval + denom = math.sqrt(((nval + 0.5) * (nval + 0.5)) + convval) + for jval in range(self._resolution): + root = math.cos(vals[jval] / denom) + conv = 1 + while abs(conv) >= precision: + mem2 = 1 + mem1 = root + for legi in range(nval): + legfonc = ((2.0 * (legi + 1) - 1.0) * root * mem1 - legi * mem2) / (legi + 1) + mem2 = mem1 + mem1 = legfonc + conv = legfonc / ((nval * (mem2 - root * legfonc)) / (1.0 - (root * root))) + root = root - conv + # add maybe a max iter here to make sure we converge at some point + new_vals[jval] = math.asin(root) * rad2deg + new_vals[nval - 1 - jval] = -new_vals[jval] + return new_vals + + def map_first_axis(self, lower, upper): + axis_lines = self._first_axis_vals + end_idx = bisect_left_cmp(axis_lines, lower, cmp=lambda x, y: x > y) + 1 + start_idx = bisect_right_cmp(axis_lines, upper, cmp=lambda x, y: x > y) + return_vals = axis_lines[start_idx:end_idx] + return return_vals + + def lon_spacing(self): + # TODO + if self._resolution == 320: + return [ + 18, + 25, + 36, + 40, + 45, + 50, + 60, + 64, + 72, + 72, + 75, + 81, + 90, + 96, + 100, + 108, + 120, + 120, + 125, + 135, + 144, + 144, + 150, + 160, + 180, + 180, + 180, + 192, + 192, + 200, + 216, + 216, + 216, + 225, + 240, + 240, + 240, + 250, + 256, + 270, + 270, + 288, + 288, + 288, + 300, + 300, + 320, + 320, + 320, + 324, + 360, + 360, + 360, + 360, + 360, + 360, + 375, + 375, + 384, + 384, + 400, + 400, + 405, + 432, + 432, + 432, + 432, + 450, + 450, + 450, + 480, + 480, + 480, + 480, + 480, + 486, + 500, + 500, + 500, + 512, + 512, + 540, + 540, + 540, + 540, + 540, + 540, + 576, + 576, + 576, + 576, + 576, + 576, + 600, + 600, + 600, + 600, + 640, + 640, + 640, + 640, + 640, + 640, + 640, + 640, + 648, + 648, + 675, + 675, + 675, + 675, + 720, + 720, + 720, + 720, + 720, + 720, + 720, + 720, + 720, + 729, + 750, + 750, + 750, + 750, + 768, + 768, + 768, + 768, + 800, + 800, + 800, + 800, + 800, + 800, + 810, + 810, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 900, + 900, + 900, + 900, + 900, + 900, + 900, + 900, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 972, + 972, + 1000, + 1000, + 1000, + 1000, + 1000, + 1000, + 1000, + 1000, + 1024, + 1024, + 1024, + 1024, + 1024, + 1024, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1152, + 1152, + 1152, + 1152, + 1152, + 1152, + 1152, + 1152, + 1152, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1215, + 1215, + 1215, + 1215, + 1215, + 1215, + 1215, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1280, + 1215, + 1215, + 1215, + 1215, + 1215, + 1215, + 1215, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1200, + 1152, + 1152, + 1152, + 1152, + 1152, + 1152, + 1152, + 1152, + 1152, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1125, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1080, + 1024, + 1024, + 1024, + 1024, + 1024, + 1024, + 1000, + 1000, + 1000, + 1000, + 1000, + 1000, + 1000, + 1000, + 972, + 972, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 960, + 900, + 900, + 900, + 900, + 900, + 900, + 900, + 900, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 864, + 810, + 810, + 800, + 800, + 800, + 800, + 800, + 800, + 768, + 768, + 768, + 768, + 750, + 750, + 750, + 750, + 729, + 720, + 720, + 720, + 720, + 720, + 720, + 720, + 720, + 720, + 675, + 675, + 675, + 675, + 648, + 648, + 640, + 640, + 640, + 640, + 640, + 640, + 640, + 600, + 600, + 600, + 600, + 576, + 576, + 576, + 576, + 576, + 576, + 540, + 540, + 540, + 540, + 540, + 512, + 512, + 500, + 500, + 500, + 486, + 480, + 480, + 480, + 480, + 480, + 450, + 450, + 450, + 432, + 432, + 432, + 432, + 405, + 400, + 400, + 384, + 384, + 375, + 375, + 360, + 360, + 360, + 360, + 360, + 360, + 324, + 320, + 320, + 320, + 300, + 300, + 288, + 288, + 288, + 270, + 270, + 256, + 250, + 240, + 240, + 240, + 225, + 216, + 216, + 216, + 200, + 192, + 192, + 180, + 180, + 180, + 160, + 150, + 144, + 144, + 135, + 125, + 120, + 120, + 108, + 100, + 96, + 90, + 81, + 75, + 72, + 72, + 64, + 60, + 50, + 45, + 40, + 36, + 25, + 18, + ] + + def second_axis_vals(self, first_val): + first_idx = self._first_axis_vals.index(first_val[0]) + Ny = self.lon_spacing()[first_idx] + second_spacing = 360 / Ny + return [i * second_spacing for i in range(Ny)] + + def axes_idx_to_reduced_gaussian_idx(self, first_idx, second_idx): + Ny_array = self.lon_spacing() + idx = 0 + for i in range(self._resolution): + if i != first_idx: + idx += Ny_array[i] + else: + idx += second_idx + return idx + + def find_second_idx(self, first_val, second_val): + tol = 1e-10 + second_axis_vals = self.second_axis_vals(first_val) + second_idx = bisect.bisect_left(second_axis_vals, second_val - tol) + return second_idx + + def unmap(self, first_val, second_val): + (first_idx, second_idx) = self.find_second_idx(first_val, second_val) + octahedral_index = self.axes_idx_to_reduced_gaussian_idx(first_idx, second_idx) + return octahedral_index + + +# md5 grid hash in form {resolution : hash} +_md5_hash = { + 320: ".", +} From e7b34b2ce72e6cd94b0221f9cf06cc3a2b8e8776 Mon Sep 17 00:00:00 2001 From: mathleur Date: Fri, 7 Feb 2025 17:56:15 +0100 Subject: [PATCH 03/28] TODO and fix typo --- .../transformations/datacube_mappers/datacube_mappers.py | 2 +- .../datacube_mappers/mapper_types/reduced_gaussian.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py b/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py index 6e4ea749..6d3d1e0b 100644 --- a/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py +++ b/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py @@ -137,5 +137,5 @@ def unmap_tree_node(self, node, unwanted_path): "reduced_ll": "ReducedLatLonMapper", "local_regular": "LocalRegularGridMapper", "healpix_nested": "NestedHealpixGridMapper", - "reduced_guassian": "ReducedGaussianGridMapper", + "reduced_gaussian": "ReducedGaussianGridMapper", } diff --git a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py index c0546f4e..2a648eba 100644 --- a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py +++ b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py @@ -772,7 +772,7 @@ def map_first_axis(self, lower, upper): return return_vals def lon_spacing(self): - # TODO + # TODO: too many values if self._resolution == 320: return [ 18, From 3540f389947d0e4e475148510c265a1a087880c8 Mon Sep 17 00:00:00 2001 From: mathleur Date: Mon, 10 Feb 2025 09:50:05 +0100 Subject: [PATCH 04/28] fix too many values in pl array --- .../datacube_mappers/mapper_types/reduced_gaussian.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py index 2a648eba..187c7300 100644 --- a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py +++ b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py @@ -772,7 +772,6 @@ def map_first_axis(self, lower, upper): return return_vals def lon_spacing(self): - # TODO: too many values if self._resolution == 320: return [ 18, @@ -861,7 +860,6 @@ def lon_spacing(self): 540, 540, 540, - 540, 576, 576, 576, @@ -879,7 +877,6 @@ def lon_spacing(self): 640, 640, 640, - 640, 648, 648, 675, From 44751fdccfdfb61258b2921b2e93dcba4f1c1e9b Mon Sep 17 00:00:00 2001 From: mathleur Date: Mon, 10 Feb 2025 13:31:44 +0100 Subject: [PATCH 05/28] start to add test to verify new grid type --- tests/test_regular_reduced_grid.py | 100 +++++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 tests/test_regular_reduced_grid.py diff --git a/tests/test_regular_reduced_grid.py b/tests/test_regular_reduced_grid.py new file mode 100644 index 00000000..1df016d3 --- /dev/null +++ b/tests/test_regular_reduced_grid.py @@ -0,0 +1,100 @@ +import pandas as pd +import pytest + +from eccodes import codes_grib_find_nearest, codes_grib_new_from_file + +from polytope_feature.engine.hullslicer import HullSlicer +from polytope_feature.polytope import Polytope, Request +from polytope_feature.shapes import Box, Select + + +class TestSlicingFDBDatacube: + def setup_method(self, method): + # Create a dataarray with 3 labelled axes using different index types + self.options = { + "axis_config": [ + {"axis_name": "step", "transformations": [{"name": "type_change", "type": "int"}]}, + { + "axis_name": "date", + "transformations": [{"name": "merge", "other_axis": "time", "linkers": ["T", "00"]}], + }, + { + "axis_name": "values", + "transformations": [ + {"name": "mapper", "type": "reduced_gaussian", + "resolution": 320, "axes": ["latitude", "longitude"]} + ], + }, + {"axis_name": "latitude", "transformations": [{"name": "reverse", "is_reverse": True}]}, + {"axis_name": "longitude", "transformations": [{"name": "cyclic", "range": [0, 360]}]}, + ], + "compressed_axes_config": [ + "longitude", + "latitude", + "levtype", + "step", + "date", + "domain", + "expver", + "param", + "class", + "stream", + "type", + ], + "pre_path": {"class": "od", "expver": "0001", "levtype": "sfc", "type": "fc", "stream": "oper"}, + } + + # Testing different shapes + @pytest.mark.fdb + def test_fdb_datacube(self): + import pygribjump as gj + + request = Request( + Select("step", [0]), + Select("levtype", ["sfc"]), + Select("date", [pd.Timestamp("20231102T000000")]), + Select("domain", ["g"]), + Select("expver", ["0001"]), + Select("param", ["167"]), + Select("class", ["od"]), + Select("stream", ["oper"]), + Select("type", ["fc"]), + Box(["latitude", "longitude"], [0, 0], [5, 5]), + ) + 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) == 3 + lats = [] + lons = [] + eccodes_lats = [] + eccodes_lons = [] + tol = 1e-4 + f = open("~/Downloads/aifs_data.grib", "rb") + messages = [] + message = codes_grib_new_from_file(f) + messages.append(message) + + leaves = result.leaves + for i in range(len(leaves)): + cubepath = leaves[i].flatten() + lat = cubepath["latitude"] + lon = cubepath["longitude"] + del cubepath + lats.append(lat) + lons.append(lon) + nearest_points = codes_grib_find_nearest(message, lat, lon)[0] + eccodes_lat = nearest_points.lat + eccodes_lon = nearest_points.lon + eccodes_lats.append(eccodes_lat) + eccodes_lons.append(eccodes_lon) + assert eccodes_lat - tol <= lat + assert lat <= eccodes_lat + tol + assert eccodes_lon - tol <= lon + assert lon <= eccodes_lon + tol From b837ed9c0638364e91a0536099507268e7b3a709 Mon Sep 17 00:00:00 2001 From: mathleur Date: Mon, 10 Feb 2025 14:56:40 +0100 Subject: [PATCH 06/28] fix N320 grid --- .../mapper_types/reduced_gaussian.py | 28 ++++++++----- tests/test_regular_reduced_grid.py | 39 +++++++++++-------- 2 files changed, 40 insertions(+), 27 deletions(-) diff --git a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py index 187c7300..dec9b3b5 100644 --- a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py +++ b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py @@ -13,7 +13,6 @@ def __init__(self, base_axis, mapped_axes, resolution, md5_hash=None, local_area self._base_axis = base_axis self._resolution = resolution self._first_axis_vals = self.first_axis_vals() - self._first_idx_map = self.create_first_idx_map() self._second_axis_spacing = {} self._axis_reversed = {mapped_axes[0]: True, mapped_axes[1]: False} if self._axis_reversed[mapped_axes[1]]: @@ -1432,19 +1431,28 @@ def axes_idx_to_reduced_gaussian_idx(self, first_idx, second_idx): idx += second_idx return idx - def find_second_idx(self, first_val, second_val): - tol = 1e-10 - second_axis_vals = self.second_axis_vals(first_val) - second_idx = bisect.bisect_left(second_axis_vals, second_val - tol) - return second_idx + # def find_second_idx(self, first_val, second_val): + # tol = 1e-10 + # second_axis_vals = self.second_axis_vals(first_val) + # second_idx = bisect.bisect_left(second_axis_vals, second_val[0] - tol) + # return second_idx + + # def unmap(self, first_val, second_val): + # (first_idx, second_idx) = self.find_second_idx(first_val, second_val) + # octahedral_index = self.axes_idx_to_reduced_gaussian_idx(first_idx, second_idx) + # return octahedral_index def unmap(self, first_val, second_val): - (first_idx, second_idx) = self.find_second_idx(first_val, second_val) - octahedral_index = self.axes_idx_to_reduced_gaussian_idx(first_idx, second_idx) - return octahedral_index + tol = 1e-8 + first_value = [i for i in self._first_axis_vals if first_val[0] - tol <= i <= first_val[0] + tol][0] + first_idx = self._first_axis_vals.index(first_value) + second_val = [i for i in self.second_axis_vals(first_val) if second_val[0] - tol <= i <= second_val[0] + tol][0] + second_idx = self.second_axis_vals(first_val).index(second_val) + reduced_gaussian_index = self.axes_idx_to_reduced_gaussian_idx(first_idx, second_idx) + return reduced_gaussian_index # md5 grid hash in form {resolution : hash} _md5_hash = { - 320: ".", + 320: "158db321ae8e773681eeb40e0a3d350f", } diff --git a/tests/test_regular_reduced_grid.py b/tests/test_regular_reduced_grid.py index 1df016d3..e6192205 100644 --- a/tests/test_regular_reduced_grid.py +++ b/tests/test_regular_reduced_grid.py @@ -70,13 +70,18 @@ def test_fdb_datacube(self): ) result = self.API.retrieve(request) result.pprint() - assert len(result.leaves) == 3 + leaves = result.leaves + assert len(leaves) == 18 + tot_leaves = 0 + for leaf in leaves: + tot_leaves += len(leaf.result) + assert tot_leaves == 324 lats = [] lons = [] eccodes_lats = [] eccodes_lons = [] - tol = 1e-4 - f = open("~/Downloads/aifs_data.grib", "rb") + tol = 1e-6 + f = open("tests/data/aifs_data_from_fdb.grib", "rb") messages = [] message = codes_grib_new_from_file(f) messages.append(message) @@ -84,17 +89,17 @@ def test_fdb_datacube(self): leaves = result.leaves for i in range(len(leaves)): cubepath = leaves[i].flatten() - lat = cubepath["latitude"] - lon = cubepath["longitude"] - del cubepath - lats.append(lat) - lons.append(lon) - nearest_points = codes_grib_find_nearest(message, lat, lon)[0] - eccodes_lat = nearest_points.lat - eccodes_lon = nearest_points.lon - eccodes_lats.append(eccodes_lat) - eccodes_lons.append(eccodes_lon) - assert eccodes_lat - tol <= lat - assert lat <= eccodes_lat + tol - assert eccodes_lon - tol <= lon - assert lon <= eccodes_lon + tol + lat = cubepath["latitude"][0] + lons_ = cubepath["longitude"] + for lon in lons_: + lats.append(lat) + lons.append(lon) + nearest_points = codes_grib_find_nearest(message, lat, lon)[0] + eccodes_lat = nearest_points.lat + eccodes_lon = nearest_points.lon + eccodes_lats.append(eccodes_lat) + eccodes_lons.append(eccodes_lon) + assert eccodes_lat - tol <= lat + assert lat <= eccodes_lat + tol + assert eccodes_lon - tol <= lon + assert lon <= eccodes_lon + tol From b04182b3707a5d39e832ea7bfc9b703ea270cc8f Mon Sep 17 00:00:00 2001 From: mathleur Date: Mon, 10 Feb 2025 14:58:34 +0100 Subject: [PATCH 07/28] black --- tests/test_regular_reduced_grid.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/tests/test_regular_reduced_grid.py b/tests/test_regular_reduced_grid.py index e6192205..29ca5c03 100644 --- a/tests/test_regular_reduced_grid.py +++ b/tests/test_regular_reduced_grid.py @@ -21,8 +21,12 @@ def setup_method(self, method): { "axis_name": "values", "transformations": [ - {"name": "mapper", "type": "reduced_gaussian", - "resolution": 320, "axes": ["latitude", "longitude"]} + { + "name": "mapper", + "type": "reduced_gaussian", + "resolution": 320, + "axes": ["latitude", "longitude"], + } ], }, {"axis_name": "latitude", "transformations": [{"name": "reverse", "is_reverse": True}]}, From 8c0d0634d0231456bc4525892225862916400f54 Mon Sep 17 00:00:00 2001 From: mathleur Date: Mon, 10 Feb 2025 14:59:51 +0100 Subject: [PATCH 08/28] isort --- tests/test_regular_reduced_grid.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/test_regular_reduced_grid.py b/tests/test_regular_reduced_grid.py index 29ca5c03..4d1b99d0 100644 --- a/tests/test_regular_reduced_grid.py +++ b/tests/test_regular_reduced_grid.py @@ -1,6 +1,5 @@ import pandas as pd import pytest - from eccodes import codes_grib_find_nearest, codes_grib_new_from_file from polytope_feature.engine.hullslicer import HullSlicer From 082d30adf92a5b3e2fd566fe473721a8bc5a6fb7 Mon Sep 17 00:00:00 2001 From: mathleur Date: Mon, 10 Feb 2025 15:01:03 +0100 Subject: [PATCH 09/28] flake8 --- .../datacube_mappers/mapper_types/reduced_gaussian.py | 1 - 1 file changed, 1 deletion(-) diff --git a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py index dec9b3b5..b2125b45 100644 --- a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py +++ b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py @@ -1,4 +1,3 @@ -import bisect import logging import math From 19c3904a210fd46986294f38d817ca792343803e Mon Sep 17 00:00:00 2001 From: mathleur Date: Mon, 10 Feb 2025 16:29:40 +0100 Subject: [PATCH 10/28] make N320 grid right to e-12 --- .../mapper_types/reduced_gaussian.py | 1286 +++++++++-------- tests/test_regular_reduced_grid.py | 2 +- 2 files changed, 645 insertions(+), 643 deletions(-) diff --git a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py index b2125b45..91f6aa92 100644 --- a/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py +++ b/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py @@ -90,647 +90,647 @@ def gauss_first_guess(self): def get_precomputed_values_N320(self): lats = [ - 89.784877, - 89.506203, - 89.225883, - 88.945191, - 88.664358, - 88.383457, - 88.102518, - 87.821556, - 87.540577, - 87.259589, - 86.978592, - 86.697590, - 86.416583, - 86.135573, - 85.854560, - 85.573545, - 85.292528, - 85.011510, - 84.730490, - 84.449469, - 84.168447, - 83.887425, - 83.606402, - 83.325378, - 83.044353, - 82.763329, - 82.482303, - 82.201278, - 81.920252, - 81.639225, - 81.358199, - 81.077172, - 80.796145, - 80.515118, - 80.234091, - 79.953063, - 79.672035, - 79.391008, - 79.109980, - 78.828951, - 78.547923, - 78.266895, - 77.985866, - 77.704838, - 77.423809, - 77.142781, - 76.861752, - 76.580723, - 76.299694, - 76.018665, - 75.737636, - 75.456607, - 75.175578, - 74.894549, - 74.613520, - 74.332490, - 74.051461, - 73.770432, - 73.489402, - 73.208373, - 72.927344, - 72.646314, - 72.365285, - 72.084255, - 71.803226, - 71.522196, - 71.241166, - 70.960137, - 70.679107, - 70.398077, - 70.117048, - 69.836018, - 69.554988, - 69.273959, - 68.992929, - 68.711899, - 68.430869, - 68.149839, - 67.868810, - 67.587780, - 67.306750, - 67.025720, - 66.744690, - 66.463660, - 66.182630, - 65.901600, - 65.620570, - 65.339540, - 65.058510, - 64.777481, - 64.496451, - 64.215421, - 63.934391, - 63.653361, - 63.372331, - 63.091300, - 62.810270, - 62.529240, - 62.248210, - 61.967180, - 61.686150, - 61.405120, - 61.124090, - 60.843060, - 60.562030, - 60.281000, - 59.999970, - 59.718940, - 59.437910, - 59.156879, - 58.875849, - 58.594819, - 58.313789, - 58.032759, - 57.751729, - 57.470699, - 57.189668, - 56.908638, - 56.627608, - 56.346578, - 56.065548, - 55.784518, - 55.503487, - 55.222457, - 54.941427, - 54.660397, - 54.379367, - 54.098337, - 53.817306, - 53.536276, - 53.255246, - 52.974216, - 52.693186, - 52.412155, - 52.131125, - 51.850095, - 51.569065, - 51.288034, - 51.007004, - 50.725974, - 50.444944, - 50.163913, - 49.882883, - 49.601853, - 49.320823, - 49.039793, - 48.758762, - 48.477732, - 48.196702, - 47.915672, - 47.634641, - 47.353611, - 47.072581, - 46.791551, - 46.510520, - 46.229490, - 45.948460, - 45.667429, - 45.386399, - 45.105369, - 44.824339, - 44.543308, - 44.262278, - 43.981248, - 43.700218, - 43.419187, - 43.138157, - 42.857127, - 42.576096, - 42.295066, - 42.014036, - 41.733006, - 41.451975, - 41.170945, - 40.889915, - 40.608884, - 40.327854, - 40.046824, - 39.765793, - 39.484763, - 39.203733, - 38.922703, - 38.641672, - 38.360642, - 38.079612, - 37.798581, - 37.517551, - 37.236521, - 36.955490, - 36.674460, - 36.393430, - 36.112399, - 35.831369, - 35.550339, - 35.269308, - 34.988278, - 34.707248, - 34.426218, - 34.145187, - 33.864157, - 33.583127, - 33.302096, - 33.021066, - 32.740036, - 32.459005, - 32.177975, - 31.896945, - 31.615914, - 31.334884, - 31.053854, - 30.772823, - 30.491793, - 30.210763, - 29.929732, - 29.648702, - 29.367672, - 29.086641, - 28.805611, - 28.524581, - 28.243550, - 27.962520, - 27.681490, - 27.400459, - 27.119429, - 26.838399, - 26.557368, - 26.276338, - 25.995308, - 25.714277, - 25.433247, - 25.152217, - 24.871186, - 24.590156, - 24.309126, - 24.028095, - 23.747065, - 23.466035, - 23.185004, - 22.903974, - 22.622944, - 22.341913, - 22.060883, - 21.779853, - 21.498822, - 21.217792, - 20.936761, - 20.655731, - 20.374701, - 20.093670, - 19.812640, - 19.531610, - 19.250579, - 18.969549, - 18.688519, - 18.407488, - 18.126458, - 17.845428, - 17.564397, - 17.283367, - 17.002337, - 16.721306, - 16.440276, - 16.159246, - 15.878215, - 15.597185, - 15.316154, - 15.035124, - 14.754094, - 14.473063, - 14.192033, - 13.911003, - 13.629972, - 13.348942, - 13.067912, - 12.786881, - 12.505851, - 12.224821, - 11.943790, - 11.662760, - 11.381730, - 11.100699, - 10.819669, - 10.538638, - 10.257608, - 9.976578, - 9.695547, - 9.414517, - 9.133487, - 8.852456, - 8.571426, - 8.290396, - 8.009365, - 7.728335, - 7.447305, - 7.166274, - 6.885244, - 6.604213, - 6.323183, - 6.042153, - 5.761122, - 5.480092, - 5.199062, - 4.918031, - 4.637001, - 4.355971, - 4.074940, - 3.793910, - 3.512879, - 3.231849, - 2.950819, - 2.669788, - 2.388758, - 2.107728, - 1.826697, - 1.545667, - 1.264637, - 0.983606, - 0.702576, - 0.421546, - 0.140515, - -0.140515, - -0.421546, - -0.702576, - -0.983606, - -1.264637, - -1.545667, - -1.826697, - -2.107728, - -2.388758, - -2.669788, - -2.950819, - -3.231849, - -3.512879, - -3.793910, - -4.074940, - -4.355971, - -4.637001, - -4.918031, - -5.199062, - -5.480092, - -5.761122, - -6.042153, - -6.323183, - -6.604213, - -6.885244, - -7.166274, - -7.447305, - -7.728335, - -8.009365, - -8.290396, - -8.571426, - -8.852456, - -9.133487, - -9.414517, - -9.695547, - -9.976578, - -10.257608, - -10.538638, - -10.819669, - -11.100699, - -11.381730, - -11.662760, - -11.943790, - -12.224821, - -12.505851, - -12.786881, - -13.067912, - -13.348942, - -13.629972, - -13.911003, - -14.192033, - -14.473063, - -14.754094, - -15.035124, - -15.316154, - -15.597185, - -15.878215, - -16.159246, - -16.440276, - -16.721306, - -17.002337, - -17.283367, - -17.564397, - -17.845428, - -18.126458, - -18.407488, - -18.688519, - -18.969549, - -19.250579, - -19.531610, - -19.812640, - -20.093670, - -20.374701, - -20.655731, - -20.936761, - -21.217792, - -21.498822, - -21.779853, - -22.060883, - -22.341913, - -22.622944, - -22.903974, - -23.185004, - -23.466035, - -23.747065, - -24.028095, - -24.309126, - -24.590156, - -24.871186, - -25.152217, - -25.433247, - -25.714277, - -25.995308, - -26.276338, - -26.557368, - -26.838399, - -27.119429, - -27.400459, - -27.681490, - -27.962520, - -28.243550, - -28.524581, - -28.805611, - -29.086641, - -29.367672, - -29.648702, - -29.929732, - -30.210763, - -30.491793, - -30.772823, - -31.053854, - -31.334884, - -31.615914, - -31.896945, - -32.177975, - -32.459005, - -32.740036, - -33.021066, - -33.302096, - -33.583127, - -33.864157, - -34.145187, - -34.426218, - -34.707248, - -34.988278, - -35.269308, - -35.550339, - -35.831369, - -36.112399, - -36.393430, - -36.674460, - -36.955490, - -37.236521, - -37.517551, - -37.798581, - -38.079612, - -38.360642, - -38.641672, - -38.922703, - -39.203733, - -39.484763, - -39.765793, - -40.046824, - -40.327854, - -40.608884, - -40.889915, - -41.170945, - -41.451975, - -41.733006, - -42.014036, - -42.295066, - -42.576096, - -42.857127, - -43.138157, - -43.419187, - -43.700218, - -43.981248, - -44.262278, - -44.543308, - -44.824339, - -45.105369, - -45.386399, - -45.667429, - -45.948460, - -46.229490, - -46.510520, - -46.791551, - -47.072581, - -47.353611, - -47.634641, - -47.915672, - -48.196702, - -48.477732, - -48.758762, - -49.039793, - -49.320823, - -49.601853, - -49.882883, - -50.163913, - -50.444944, - -50.725974, - -51.007004, - -51.288034, - -51.569065, - -51.850095, - -52.131125, - -52.412155, - -52.693186, - -52.974216, - -53.255246, - -53.536276, - -53.817306, - -54.098337, - -54.379367, - -54.660397, - -54.941427, - -55.222457, - -55.503487, - -55.784518, - -56.065548, - -56.346578, - -56.627608, - -56.908638, - -57.189668, - -57.470699, - -57.751729, - -58.032759, - -58.313789, - -58.594819, - -58.875849, - -59.156879, - -59.437910, - -59.718940, - -59.999970, - -60.281000, - -60.562030, - -60.843060, - -61.124090, - -61.405120, - -61.686150, - -61.967180, - -62.248210, - -62.529240, - -62.810270, - -63.091300, - -63.372331, - -63.653361, - -63.934391, - -64.215421, - -64.496451, - -64.777481, - -65.058510, - -65.339540, - -65.620570, - -65.901600, - -66.182630, - -66.463660, - -66.744690, - -67.025720, - -67.306750, - -67.587780, - -67.868810, - -68.149839, - -68.430869, - -68.711899, - -68.992929, - -69.273959, - -69.554988, - -69.836018, - -70.117048, - -70.398077, - -70.679107, - -70.960137, - -71.241166, - -71.522196, - -71.803226, - -72.084255, - -72.365285, - -72.646314, - -72.927344, - -73.208373, - -73.489402, - -73.770432, - -74.051461, - -74.332490, - -74.613520, - -74.894549, - -75.175578, - -75.456607, - -75.737636, - -76.018665, - -76.299694, - -76.580723, - -76.861752, - -77.142781, - -77.423809, - -77.704838, - -77.985866, - -78.266895, - -78.547923, - -78.828951, - -79.109980, - -79.391008, - -79.672035, - -79.953063, - -80.234091, - -80.515118, - -80.796145, - -81.077172, - -81.358199, - -81.639225, - -81.920252, - -82.201278, - -82.482303, - -82.763329, - -83.044353, - -83.325378, - -83.606402, - -83.887425, - -84.168447, - -84.449469, - -84.730490, - -85.011510, - -85.292528, - -85.573545, - -85.854560, - -86.135573, - -86.416583, - -86.697590, - -86.978592, - -87.259589, - -87.540577, - -87.821556, - -88.102518, - -88.383457, - -88.664358, - -88.945191, - -89.225883, - -89.506203, - -89.784877, - ] + -89.78487690721863, + -89.50620273820637, + -89.22588284761157, + -88.94519111831644, + -88.66435834182293, + -88.38345731224797, + -88.10251813893724, + -87.82155550711056, + -87.54057742641116, + -87.25958863483953, + -86.97859211359663, + -86.69758983192202, + -86.41658314273641, + -86.13557300618399, + -85.85456012248531, + -85.57354501429673, + -85.29252807962695, + -85.01150962689766, + -84.73048989880277, + -84.44946908892904, + -84.16844735357665, + -83.88742482032309, + -83.60640159433007, + -83.32537776305915, + -83.04435339984514, + -82.76332856663693, + -82.48230331612486, + -82.20127769340762, + -81.92025173731213, + -81.63922548144693, + -81.35819895505040, + -81.07717218367863, + -80.79614518976737, + -80.51511799309434, + -80.23409061116114, + -79.95306305951186, + -79.67203535199914, + -79.39100750100822, + -79.10997951764607, + -78.82895141190238, + -78.54792319278644, + -78.26689486844451, + -77.98586644626094, + -77.70483793294494, + -77.42380933460623, + -77.14278065682046, + -76.86175190468626, + -76.58072308287524, + -76.29969419567588, + -76.01866524703182, + -75.73763624057599, + -75.45660717966057, + -75.17557806738355, + -74.89454890661246, + -74.61351970000541, + -74.33249045002979, + -74.05146115897912, + -73.77043182898812, + -73.48940246204617, + -73.20837306000952, + -72.92734362461226, + -72.64631415747613, + -72.36528466011954, + -72.08425513396567, + -71.80322558034980, + -71.52219600052597, + -71.24116639567315, + -70.96013676690066, + -70.67910711525340, + -70.39807744171628, + -70.11704774721858, + -69.83601803263780, + -69.55498829880318, + -69.27395854649907, + -68.99292877646779, + -68.71189898941257, + -68.43086918599992, + -68.14983936686214, + -67.86880953259940, + -67.58777968378180, + -67.30674982095123, + -67.02571994462305, + -66.74469005528775, + -66.46366015341239, + -66.18263023944205, + -65.90160031380103, + -65.62057037689407, + -65.33954042910749, + -65.05851047081022, + -64.77748050235478, + -64.49645052407814, + -64.21542053630260, + -63.93439053933660, + -63.65336053347541, + -63.37233051900186, + -63.09130049618697, + -62.81027046529061, + -62.52924042656195, + -62.24821038024017, + -61.96718032655483, + -61.68615026572643, + -61.40512019796673, + -61.12409012347936, + -60.84306004246005, + -60.56202995509710, + -60.28099986157171, + -59.99996976205827, + -59.71893965672474, + -59.43790954573291, + -59.15687942923870, + -58.87584930739236, + -58.59481918033887, + -58.31378904821798, + -58.03275891116461, + -57.75172876930898, + -57.47069862277679, + -57.18966847168948, + -56.90863831616438, + -56.62760815631488, + -56.34657799225056, + -56.06554782407743, + -55.78451765189804, + -55.50348747581155, + -55.22245729591398, + -54.94142711229829, + -54.66039692505446, + -54.37936673426967, + -54.09833654002838, + -53.81730634241245, + -53.53627614150120, + -53.25524593737158, + -52.97421573009819, + -52.69318551975338, + -52.41215530640741, + -52.13112509012841, + -51.85009487098255, + -51.56906464903404, + -51.28803442434530, + -51.00700419697692, + -50.72597396698776, + -50.44494373443509, + -50.16391349937449, + -49.88288326186004, + -49.60185302194436, + -49.32082277967856, + -49.03979253511243, + -48.75876228829437, + -48.47773203927152, + -48.19670178808972, + -47.91567153479365, + -47.63464127942677, + -47.35361102203147, + -47.07258076264900, + -46.79155050131955, + -46.51052023808231, + -46.22948997297545, + -45.94845970603621, + -45.66742943730089, + -45.38639916680486, + -45.10536889458269, + -44.82433862066802, + -44.54330834509373, + -44.26227806789189, + -43.98124778909381, + -43.70021750873003, + -43.41918722683038, + -43.13815694342401, + -42.85712665853937, + -42.57609637220426, + -42.29506608444584, + -42.01403579529062, + -41.73300550476453, + -41.45197521289295, + -41.17094491970063, + -40.88991462521181, + -40.60888432945017, + -40.32785403243889, + -40.04682373420064, + -39.76579343475757, + -39.48476313413139, + -39.20373283234334, + -38.92270252941418, + -38.64167222536426, + -38.36064192021350, + -38.07961161398138, + -37.79858130668703, + -37.51755099834911, + -37.23652068898597, + -36.95549037861555, + -36.67446006725543, + -36.39342975492286, + -36.11239944163471, + -35.83136912740756, + -35.55033881225761, + -35.26930849620082, + -34.98827817925277, + -34.70724786142878, + -34.42621754274384, + -34.14518722321272, + -33.86415690284984, + -33.58312658166939, + -33.30209625968529, + -33.02106593691121, + -32.74003561336056, + -32.45900528904648, + -32.17797496398192, + -31.89694463817959, + -31.61591431165194, + -31.33488398441122, + -31.05385365646946, + -30.77282332783850, + -30.49179299852995, + -30.21076266855524, + -29.92973233792557, + -29.64870200665200, + -29.36767167474536, + -29.08664134221633, + -28.80561100907540, + -28.52458067533288, + -28.24355034099893, + -27.96252000608353, + -27.68148967059651, + -27.40045933454753, + -27.11942899794612, + -26.83839866080164, + -26.55736832312331, + -26.27633798492022, + -25.99530764620129, + -25.71427730697534, + -25.43324696725105, + -25.15221662703694, + -24.87118628634144, + -24.59015594517284, + -24.30912560353932, + -24.02809526144893, + -23.74706491890961, + -23.46603457592919, + -23.18500423251539, + -22.90397388867583, + -22.62294354441799, + -22.34191319974931, + -22.06088285467707, + -21.77985250920850, + -21.49882216335069, + -21.21779181711067, + -20.93676147049538, + -20.65573112351166, + -20.37470077616624, + -20.09367042846582, + -19.81264008041698, + -19.53160973202621, + -19.25057938329996, + -18.96954903424457, + -18.68851868486632, + -18.40748833517141, + -18.12645798516599, + -17.84542763485610, + -17.56439728424774, + -17.28336693334685, + -17.00233658215929, + -16.72130623069085, + -16.44027587894727, + -16.15924552693424, + -15.87821517465737, + -15.59718482212223, + -15.31615446933432, + -15.03512411629909, + -14.75409376302196, + -14.47306340950825, + -14.19203305576328, + -13.91100270179228, + -13.62997234760047, + -13.34894199319299, + -13.06791163857496, + -12.78688128375144, + -12.50585092872746, + -12.22482057350799, + -11.94379021809798, + -11.66275986250232, + -11.38172950672589, + -11.10069915077350, + -10.81966879464995, + -10.53863843836000, + -10.25760808190837, + -9.97657772529974, + -9.69554736853877, + -9.41451701163010, + -9.13348665457831, + -8.85245629738798, + -8.57142594006364, + -8.29039558260981, + -8.00936522503099, + -7.72833486733163, + -7.44730450951617, + -7.16627415158902, + -6.88524379355459, + -6.60421343541725, + -6.32318307718135, + -6.04215271885122, + -5.76112236043118, + -5.48009200192553, + -5.19906164333854, + -4.91803128467449, + -4.63700092593762, + -4.35597056713217, + -4.07494020826237, + -3.79390984933241, + -3.51287949034651, + -3.23184913130884, + -2.95081877222359, + -2.66978841309493, + -2.38875805392700, + -2.10772769472398, + -1.82669733549000, + -1.54566697622920, + -1.26463661694571, + -0.98360625764368, + -0.70257589832721, + -0.42154553900045, + -0.14051517966750, + 0.14051517966750, + 0.42154553900045, + 0.70257589832721, + 0.98360625764368, + 1.26463661694571, + 1.54566697622920, + 1.82669733549000, + 2.10772769472398, + 2.38875805392700, + 2.66978841309493, + 2.95081877222359, + 3.23184913130884, + 3.51287949034651, + 3.79390984933241, + 4.07494020826237, + 4.35597056713217, + 4.63700092593762, + 4.91803128467449, + 5.19906164333854, + 5.48009200192553, + 5.76112236043118, + 6.04215271885122, + 6.32318307718135, + 6.60421343541725, + 6.88524379355459, + 7.16627415158902, + 7.44730450951617, + 7.72833486733163, + 8.00936522503099, + 8.29039558260981, + 8.57142594006364, + 8.85245629738798, + 9.13348665457831, + 9.41451701163010, + 9.69554736853877, + 9.97657772529974, + 10.25760808190837, + 10.53863843836000, + 10.81966879464995, + 11.10069915077350, + 11.38172950672589, + 11.66275986250232, + 11.94379021809798, + 12.22482057350799, + 12.50585092872746, + 12.78688128375144, + 13.06791163857496, + 13.34894199319299, + 13.62997234760047, + 13.91100270179228, + 14.19203305576328, + 14.47306340950825, + 14.75409376302196, + 15.03512411629909, + 15.31615446933432, + 15.59718482212223, + 15.87821517465737, + 16.15924552693424, + 16.44027587894727, + 16.72130623069085, + 17.00233658215929, + 17.28336693334685, + 17.56439728424774, + 17.84542763485610, + 18.12645798516599, + 18.40748833517141, + 18.68851868486632, + 18.96954903424457, + 19.25057938329996, + 19.53160973202621, + 19.81264008041698, + 20.09367042846582, + 20.37470077616624, + 20.65573112351166, + 20.93676147049538, + 21.21779181711067, + 21.49882216335069, + 21.77985250920850, + 22.06088285467707, + 22.34191319974931, + 22.62294354441799, + 22.90397388867583, + 23.18500423251539, + 23.46603457592919, + 23.74706491890961, + 24.02809526144893, + 24.30912560353932, + 24.59015594517284, + 24.87118628634144, + 25.15221662703694, + 25.43324696725105, + 25.71427730697534, + 25.99530764620129, + 26.27633798492022, + 26.55736832312331, + 26.83839866080164, + 27.11942899794612, + 27.40045933454753, + 27.68148967059651, + 27.96252000608353, + 28.24355034099893, + 28.52458067533288, + 28.80561100907540, + 29.08664134221633, + 29.36767167474536, + 29.64870200665200, + 29.92973233792557, + 30.21076266855524, + 30.49179299852995, + 30.77282332783850, + 31.05385365646946, + 31.33488398441122, + 31.61591431165194, + 31.89694463817959, + 32.17797496398192, + 32.45900528904648, + 32.74003561336056, + 33.02106593691121, + 33.30209625968529, + 33.58312658166939, + 33.86415690284984, + 34.14518722321272, + 34.42621754274384, + 34.70724786142878, + 34.98827817925277, + 35.26930849620082, + 35.55033881225761, + 35.83136912740756, + 36.11239944163471, + 36.39342975492286, + 36.67446006725543, + 36.95549037861555, + 37.23652068898597, + 37.51755099834911, + 37.79858130668703, + 38.07961161398138, + 38.36064192021350, + 38.64167222536426, + 38.92270252941418, + 39.20373283234334, + 39.48476313413139, + 39.76579343475757, + 40.04682373420064, + 40.32785403243889, + 40.60888432945017, + 40.88991462521181, + 41.17094491970063, + 41.45197521289295, + 41.73300550476453, + 42.01403579529062, + 42.29506608444584, + 42.57609637220426, + 42.85712665853937, + 43.13815694342401, + 43.41918722683038, + 43.70021750873003, + 43.98124778909381, + 44.26227806789189, + 44.54330834509373, + 44.82433862066802, + 45.10536889458269, + 45.38639916680486, + 45.66742943730089, + 45.94845970603621, + 46.22948997297545, + 46.51052023808231, + 46.79155050131955, + 47.07258076264900, + 47.35361102203147, + 47.63464127942677, + 47.91567153479365, + 48.19670178808972, + 48.47773203927152, + 48.75876228829437, + 49.03979253511243, + 49.32082277967856, + 49.60185302194436, + 49.88288326186004, + 50.16391349937449, + 50.44494373443509, + 50.72597396698776, + 51.00700419697692, + 51.28803442434530, + 51.56906464903404, + 51.85009487098255, + 52.13112509012841, + 52.41215530640741, + 52.69318551975338, + 52.97421573009819, + 53.25524593737158, + 53.53627614150120, + 53.81730634241245, + 54.09833654002838, + 54.37936673426967, + 54.66039692505446, + 54.94142711229829, + 55.22245729591398, + 55.50348747581155, + 55.78451765189804, + 56.06554782407743, + 56.34657799225056, + 56.62760815631488, + 56.90863831616438, + 57.18966847168948, + 57.47069862277679, + 57.75172876930898, + 58.03275891116461, + 58.31378904821798, + 58.59481918033887, + 58.87584930739236, + 59.15687942923870, + 59.43790954573291, + 59.71893965672474, + 59.99996976205827, + 60.28099986157171, + 60.56202995509710, + 60.84306004246005, + 61.12409012347936, + 61.40512019796673, + 61.68615026572643, + 61.96718032655483, + 62.24821038024017, + 62.52924042656195, + 62.81027046529061, + 63.09130049618697, + 63.37233051900186, + 63.65336053347541, + 63.93439053933660, + 64.21542053630260, + 64.49645052407814, + 64.77748050235478, + 65.05851047081022, + 65.33954042910749, + 65.62057037689407, + 65.90160031380103, + 66.18263023944205, + 66.46366015341239, + 66.74469005528775, + 67.02571994462305, + 67.30674982095123, + 67.58777968378180, + 67.86880953259940, + 68.14983936686214, + 68.43086918599992, + 68.71189898941257, + 68.99292877646779, + 69.27395854649907, + 69.55498829880318, + 69.83601803263780, + 70.11704774721858, + 70.39807744171628, + 70.67910711525340, + 70.96013676690066, + 71.24116639567315, + 71.52219600052597, + 71.80322558034980, + 72.08425513396567, + 72.36528466011954, + 72.64631415747613, + 72.92734362461226, + 73.20837306000952, + 73.48940246204617, + 73.77043182898812, + 74.05146115897912, + 74.33249045002979, + 74.61351970000541, + 74.89454890661246, + 75.17557806738355, + 75.45660717966057, + 75.73763624057599, + 76.01866524703182, + 76.29969419567588, + 76.58072308287524, + 76.86175190468626, + 77.14278065682046, + 77.42380933460623, + 77.70483793294494, + 77.98586644626094, + 78.26689486844451, + 78.54792319278644, + 78.82895141190238, + 79.10997951764607, + 79.39100750100822, + 79.67203535199914, + 79.95306305951186, + 80.23409061116114, + 80.51511799309434, + 80.79614518976737, + 81.07717218367863, + 81.35819895505040, + 81.63922548144693, + 81.92025173731213, + 82.20127769340762, + 82.48230331612486, + 82.76332856663693, + 83.04435339984514, + 83.32537776305915, + 83.60640159433007, + 83.88742482032309, + 84.16844735357665, + 84.44946908892904, + 84.73048989880277, + 85.01150962689766, + 85.29252807962695, + 85.57354501429673, + 85.85456012248531, + 86.13557300618399, + 86.41658314273641, + 86.69758983192202, + 86.97859211359663, + 87.25958863483953, + 87.54057742641116, + 87.82155550711056, + 88.10251813893724, + 88.38345731224797, + 88.66435834182293, + 88.94519111831644, + 89.22588284761157, + 89.50620273820637, + 89.78487690721863, + ][::-1] return lats def first_axis_vals(self): @@ -1415,7 +1415,9 @@ def lon_spacing(self): ] def second_axis_vals(self, first_val): - first_idx = self._first_axis_vals.index(first_val[0]) + tol = 1e-8 + first_value = [i for i in self._first_axis_vals if first_val[0] - tol <= i <= first_val[0] + tol][0] + first_idx = self._first_axis_vals.index(first_value) Ny = self.lon_spacing()[first_idx] second_spacing = 360 / Ny return [i * second_spacing for i in range(Ny)] diff --git a/tests/test_regular_reduced_grid.py b/tests/test_regular_reduced_grid.py index 4d1b99d0..97c19d88 100644 --- a/tests/test_regular_reduced_grid.py +++ b/tests/test_regular_reduced_grid.py @@ -83,7 +83,7 @@ def test_fdb_datacube(self): lons = [] eccodes_lats = [] eccodes_lons = [] - tol = 1e-6 + tol = 1e-12 f = open("tests/data/aifs_data_from_fdb.grib", "rb") messages = [] message = codes_grib_new_from_file(f) From dc9de689ae53045e1256f013e0693c285b2f8a3c Mon Sep 17 00:00:00 2001 From: mathleur Date: Tue, 11 Feb 2025 13:27:12 +0100 Subject: [PATCH 11/28] remove year and month axes that aren't needed --- polytope_feature/datacube/backends/fdb.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/polytope_feature/datacube/backends/fdb.py b/polytope_feature/datacube/backends/fdb.py index bd60665a..d0e20ec8 100644 --- a/polytope_feature/datacube/backends/fdb.py +++ b/polytope_feature/datacube/backends/fdb.py @@ -84,6 +84,8 @@ def check_branching_axes(self, request): # TODO: When do these not appear?? self.fdb_coordinates.pop("direction", None) self.fdb_coordinates.pop("frequency", None) + self.fdb_coordinates.pop("year", None) + self.fdb_coordinates.pop("month", None) # NOTE: verify that we also remove the axis object for axes we've removed here axes_to_remove = set(self.complete_axes) - set(self.fdb_coordinates.keys()) From 33c1018a2274278857ffd41daea5ab97842c8d60 Mon Sep 17 00:00:00 2001 From: mathleur Date: Tue, 11 Feb 2025 17:10:51 +0100 Subject: [PATCH 12/28] add wave support for param 140251 --- polytope_feature/datacube/backends/fdb.py | 23 ++++- tests/test_wave_spectra_data.py | 101 ++++++++++++++++++++++ 2 files changed, 121 insertions(+), 3 deletions(-) create mode 100644 tests/test_wave_spectra_data.py diff --git a/polytope_feature/datacube/backends/fdb.py b/polytope_feature/datacube/backends/fdb.py index bd60665a..803096c6 100644 --- a/polytope_feature/datacube/backends/fdb.py +++ b/polytope_feature/datacube/backends/fdb.py @@ -31,6 +31,7 @@ def __init__( if len(alternative_axes) == 0: logging.info("Find GribJump axes for %s", context) self.fdb_coordinates = self.gj.axes(partial_request, ctx=context) + print(self.fdb_coordinates) logging.info("Retrieved available GribJump axes for %s", context) if len(self.fdb_coordinates) == 0: raise BadRequestError(partial_request) @@ -80,10 +81,25 @@ def check_branching_axes(self, request): (upper, lower, idx) = polytope.extents(ax) if "sfc" in polytope.points[idx]: self.fdb_coordinates.pop("levelist", None) + # if ax == "stream": + # (upper, lower, idx) = polytope.extents(ax) + # if "wave" in polytope.points[idx]: + # if len(polytope.points[idx]) > 1: + # raise ValueError( + # "Please request stream wave separately from data on other streams.") # noqa: E501 + # self.fdb_coordinates.pop("levtype", None) + + if ax == "param": + (upper, lower, idx) = polytope.extents(ax) + if "140251" not in polytope.points[idx]: + self.fdb_coordinates.pop("direction", None) + self.fdb_coordinates.pop("frequency", None) + else: + # special param with direction and frequency + if len(polytope.points[idx]) > 1: + raise ValueError( + "Param 251 is part of a special branching of the datacube. Please request it separately.") # noqa: E501 self.fdb_coordinates.pop("quantile", None) - # TODO: When do these not appear?? - self.fdb_coordinates.pop("direction", None) - self.fdb_coordinates.pop("frequency", None) # NOTE: verify that we also remove the axis object for axes we've removed here axes_to_remove = set(self.complete_axes) - set(self.fdb_coordinates.keys()) @@ -129,6 +145,7 @@ def get(self, requests: TensorIndexTree, context=None): logging.debug("The requests we give GribJump are: %s", printed_list_to_gj) logging.info("Requests given to GribJump extract for %s", context) try: + print(complete_list_complete_uncompressed_requests) output_values = self.gj.extract(complete_list_complete_uncompressed_requests, context) except Exception as e: if "BadValue: Grid hash mismatch" in str(e): diff --git a/tests/test_wave_spectra_data.py b/tests/test_wave_spectra_data.py new file mode 100644 index 00000000..a9fcb10c --- /dev/null +++ b/tests/test_wave_spectra_data.py @@ -0,0 +1,101 @@ +import pytest +from helper_functions import find_nearest_latlon + +from polytope_feature.engine.hullslicer import HullSlicer +from polytope_feature.polytope import Polytope, Request +from polytope_feature.shapes import Box, Select +import pandas as pd + + +class TestHealpixGrid: + def setup_method(self, method): + + import pygribjump as gj + + self.fdb_datacube = gj.GribJump() + + self.options = { + "axis_config": [ + {"axis_name": "number", "transformations": [{"name": "type_change", "type": "int"}]}, + {"axis_name": "step", "transformations": [{"name": "type_change", "type": "int"}]}, + { + "axis_name": "date", + "transformations": [{"name": "merge", "other_axis": "time", "linkers": ["T", "00"]}], + }, + { + "axis_name": "values", + "transformations": [ + {"name": "mapper", "type": "octahedral", "resolution": 1280, "axes": ["latitude", "longitude"]} + ], + }, + {"axis_name": "longitude", "transformations": [{"name": "cyclic", "range": [0, 360]}]}, + {"axis_name": "latitude", "transformations": [{"name": "reverse", "is_reverse": True}]}, + ], + "pre_path": {"class": "od", "expver": "0001", "type": "fc", "stream": "wave", "date": "20250201"}, + "compressed_axes_config": [ + "longitude", + "latitude", + "levtype", + "step", + "date", + "domain", + "expver", + "param", + "class", + "stream", + "type", + "number", + ], + } + self.slicer = HullSlicer() + self.API = Polytope( + datacube=self.fdb_datacube, + engine=self.slicer, + options=self.options, + ) + + @pytest.mark.internet + def test_healpix_grid(self): + + request = Request( + Select("step", [1]), + Select("date", [pd.Timestamp("20250201T000000")]), + Select("domain", ["g"]), + Select("expver", ["0001"]), + Select("param", ["140251"]), + Select("class", ["od"]), + Select("stream", ["wave"]), + Select("type", ["fc"]), + Select("direction", ["1"]), + Select("frequency", ["1"]), + Box(["latitude", "longitude"], [1, 1], [2, 2]), + Select("levtype", ["sfc"]) + ) + result = self.API.retrieve(request) + result.pprint() + assert len(result.leaves) == 14 + assert result.leaves[0].result[1].size == 1 + assert result.leaves[1].result[1].size == 1 + + lats = [] + lons = [] + eccodes_lats = [] + tol = 1e-8 + leaves = result.leaves + for i, leaf in enumerate(leaves): + cubepath = leaf.flatten() + lat = cubepath["latitude"][0] + new_lons = cubepath["longitude"] + for j, lon in enumerate(new_lons): + lats.append(lat) + lons.append(lon) + nearest_points = find_nearest_latlon("./tests/data/wave_spectra.grib", lat, lon) + eccodes_lat = nearest_points[0][0]["lat"] + eccodes_lon = nearest_points[0][0]["lon"] + assert eccodes_lat - tol <= lat + assert lat <= eccodes_lat + tol + assert eccodes_lon - tol <= lon + assert lon <= eccodes_lon + tol + tol = 1e-2 + eccodes_lats.append(lat) + assert len(eccodes_lats) == 14 From 8ca745a9ae6f20289549f0de9f246a9a7c934db2 Mon Sep 17 00:00:00 2001 From: mathleur Date: Tue, 11 Feb 2025 17:11:57 +0100 Subject: [PATCH 13/28] clean up --- polytope_feature/datacube/backends/fdb.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/polytope_feature/datacube/backends/fdb.py b/polytope_feature/datacube/backends/fdb.py index 803096c6..2900a613 100644 --- a/polytope_feature/datacube/backends/fdb.py +++ b/polytope_feature/datacube/backends/fdb.py @@ -81,13 +81,6 @@ def check_branching_axes(self, request): (upper, lower, idx) = polytope.extents(ax) if "sfc" in polytope.points[idx]: self.fdb_coordinates.pop("levelist", None) - # if ax == "stream": - # (upper, lower, idx) = polytope.extents(ax) - # if "wave" in polytope.points[idx]: - # if len(polytope.points[idx]) > 1: - # raise ValueError( - # "Please request stream wave separately from data on other streams.") # noqa: E501 - # self.fdb_coordinates.pop("levtype", None) if ax == "param": (upper, lower, idx) = polytope.extents(ax) From fe6e3e1771df9a1ceabbfdfdd3a79052c9be0896 Mon Sep 17 00:00:00 2001 From: mathleur Date: Tue, 11 Feb 2025 17:13:22 +0100 Subject: [PATCH 14/28] isort + black --- polytope_feature/datacube/backends/fdb.py | 3 ++- tests/test_wave_spectra_data.py | 6 ++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/polytope_feature/datacube/backends/fdb.py b/polytope_feature/datacube/backends/fdb.py index 2900a613..95f769c8 100644 --- a/polytope_feature/datacube/backends/fdb.py +++ b/polytope_feature/datacube/backends/fdb.py @@ -91,7 +91,8 @@ def check_branching_axes(self, request): # special param with direction and frequency if len(polytope.points[idx]) > 1: raise ValueError( - "Param 251 is part of a special branching of the datacube. Please request it separately.") # noqa: E501 + "Param 251 is part of a special branching of the datacube. Please request it separately." + ) # noqa: E501 self.fdb_coordinates.pop("quantile", None) # NOTE: verify that we also remove the axis object for axes we've removed here diff --git a/tests/test_wave_spectra_data.py b/tests/test_wave_spectra_data.py index a9fcb10c..9e868b5d 100644 --- a/tests/test_wave_spectra_data.py +++ b/tests/test_wave_spectra_data.py @@ -1,15 +1,14 @@ +import pandas as pd import pytest from helper_functions import find_nearest_latlon from polytope_feature.engine.hullslicer import HullSlicer from polytope_feature.polytope import Polytope, Request from polytope_feature.shapes import Box, Select -import pandas as pd class TestHealpixGrid: def setup_method(self, method): - import pygribjump as gj self.fdb_datacube = gj.GribJump() @@ -56,7 +55,6 @@ def setup_method(self, method): @pytest.mark.internet def test_healpix_grid(self): - request = Request( Select("step", [1]), Select("date", [pd.Timestamp("20250201T000000")]), @@ -69,7 +67,7 @@ def test_healpix_grid(self): Select("direction", ["1"]), Select("frequency", ["1"]), Box(["latitude", "longitude"], [1, 1], [2, 2]), - Select("levtype", ["sfc"]) + Select("levtype", ["sfc"]), ) result = self.API.retrieve(request) result.pprint() From e24ea285f1816a14e18823de28776bfdb98c3b93 Mon Sep 17 00:00:00 2001 From: mathleur Date: Tue, 11 Feb 2025 17:15:28 +0100 Subject: [PATCH 15/28] fix flake8 --- polytope_feature/datacube/backends/fdb.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/polytope_feature/datacube/backends/fdb.py b/polytope_feature/datacube/backends/fdb.py index 95f769c8..ab7a2dd1 100644 --- a/polytope_feature/datacube/backends/fdb.py +++ b/polytope_feature/datacube/backends/fdb.py @@ -91,8 +91,8 @@ def check_branching_axes(self, request): # special param with direction and frequency if len(polytope.points[idx]) > 1: raise ValueError( - "Param 251 is part of a special branching of the datacube. Please request it separately." - ) # noqa: E501 + "Param 251 is part of a special branching of the datacube. Please request it separately." # noqa: E501 + ) self.fdb_coordinates.pop("quantile", None) # NOTE: verify that we also remove the axis object for axes we've removed here From 062df44680e9535595ad5a23d787a815d85bb151 Mon Sep 17 00:00:00 2001 From: mathleur Date: Tue, 11 Feb 2025 17:24:06 +0100 Subject: [PATCH 16/28] fix module not found for pygribjump in ci --- tests/test_wave_spectra_data.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/test_wave_spectra_data.py b/tests/test_wave_spectra_data.py index 9e868b5d..5eb1e32d 100644 --- a/tests/test_wave_spectra_data.py +++ b/tests/test_wave_spectra_data.py @@ -9,10 +9,6 @@ class TestHealpixGrid: def setup_method(self, method): - import pygribjump as gj - - self.fdb_datacube = gj.GribJump() - self.options = { "axis_config": [ {"axis_name": "number", "transformations": [{"name": "type_change", "type": "int"}]}, @@ -47,14 +43,18 @@ def setup_method(self, method): ], } self.slicer = HullSlicer() + + @pytest.mark.internet + def test_healpix_grid(self): + import pygribjump as gj + + self.fdb_datacube = gj.GribJump() self.API = Polytope( datacube=self.fdb_datacube, engine=self.slicer, options=self.options, ) - @pytest.mark.internet - def test_healpix_grid(self): request = Request( Select("step", [1]), Select("date", [pd.Timestamp("20250201T000000")]), From a00c861c51ccb04fa10aba7f89d7a6b9eb3f13df Mon Sep 17 00:00:00 2001 From: mathleur Date: Wed, 12 Feb 2025 09:21:14 +0100 Subject: [PATCH 17/28] mark the test as fdb test --- tests/test_wave_spectra_data.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_wave_spectra_data.py b/tests/test_wave_spectra_data.py index 5eb1e32d..6835fee4 100644 --- a/tests/test_wave_spectra_data.py +++ b/tests/test_wave_spectra_data.py @@ -7,7 +7,7 @@ from polytope_feature.shapes import Box, Select -class TestHealpixGrid: +class TestWaveData: def setup_method(self, method): self.options = { "axis_config": [ @@ -44,7 +44,7 @@ def setup_method(self, method): } self.slicer = HullSlicer() - @pytest.mark.internet + @pytest.mark.fdb def test_healpix_grid(self): import pygribjump as gj From 0213f2831aa97ff3f72d5a6ca351c0fd5dbeb04d Mon Sep 17 00:00:00 2001 From: awarde96 Date: Wed, 12 Feb 2025 09:40:44 +0000 Subject: [PATCH 18/28] Update data portfolio with climate and extremes dt data --- docs/Service/Data_Portfolio.md | 78 +++++++++++++++++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-) diff --git a/docs/Service/Data_Portfolio.md b/docs/Service/Data_Portfolio.md index 52fd1d9d..9bed7505 100644 --- a/docs/Service/Data_Portfolio.md +++ b/docs/Service/Data_Portfolio.md @@ -1,6 +1,6 @@ # Data Portfolio -Polytope feature extraction only has access to data that is stored on an FDB. The dataset currently available via Polyope feature extraction is the operational forecast. We plan to add Destination Earth Digital Twin data in the future. +Polytope feature extraction only has access to data that is stored on an FDB. The dataset currently available via Polyope feature extraction is the operational forecast. ## Operational Forecast Data @@ -49,3 +49,79 @@ Only data that is contained in the operational FDB can be requested via Polytope We sometimes limit the size of requests for area features such as bounding box and polygon to maintain quality of service. Access to operational data is limited by our release schedule. + + +## Extremes DT Data + +The following values available for each field specified are: + +* `class` : `d1` +* `dataste` : `extremes-dt` +* `stream` : `oper` `wave` +* `type` : `fc` +* `levtype` : `sfc` `pl` `hl` +* `expver` : `0001` +* `domain` : `g` +* `step` : `0/to/96` + +If `levtype` is `pl` a `levelist` must be provided: + +* `levelist` : `1/to/1000` + +If `levtype` is `hl` a `levelist` must be provided: + +* `levtype` : `100` + +`pl` and `hl` also only contain a subset of parameters that are available in grid point. These are: + +* `pl` + * `Geopotential` + * `Temperature` + * `U component of wind` + * `V component of wind` + * `Specific humidity` + * `Relative humidity` +* `hl` + * `100 metre U wind component` + * `100 metre V wind component ` + +For `sfc` most `params` are available. + +For `stream` : `wave` the following parameters are available: + +* `Mean zero-crossing wave period` +* `Significant height of combined wind waves and swell` +* `Mean wave direction` +* `Peak wave period` +* `Mean wave period` + +Only Extremes-DT data from the past 15 days can be accessed by users. + + +## Climate DT Data + +The following values available for each field specified are: + +* `class` : `d1` +* `dataste` : `climate-dt` +* `activity` : `ScenarioMIP` `story-nudging` `CMIP6` +* `model`: `IFS-NEMO`, +* `generation` : `1`, +* `realization`: `1`, +* `resolution`: `standard/high`, +* `time`: `0000/to/2300`, +* `stream` : `clte` +* `type` : `fc` +* `levtype` : `sfc` `pl` `o2d` +* `expver` : `0001` +* `domain` : `g` + +If `levtype` is `pl` a `levelist` must be provided: + +* `levelist` : `1/to/1000` + +`pl` is currently being scanned and new parameters will come online as time passes. This is also the case for `o2d`. + +For `sfc` most `params` are available. + +Currently for `date` between `2020` and `2050` is available. From 34bed1a4e139b9748f779650e438e9f314f51890 Mon Sep 17 00:00:00 2001 From: awarde96 Date: Wed, 12 Feb 2025 09:56:28 +0000 Subject: [PATCH 19/28] Update timeseries with new interface --- .../Service/Examples/timeseries_example.ipynb | 73 +++++++++++++++++-- docs/Service/Features/timeseries.md | 19 +++-- 2 files changed, 78 insertions(+), 14 deletions(-) diff --git a/docs/Service/Examples/timeseries_example.ipynb b/docs/Service/Examples/timeseries_example.ipynb index 0921c813..a6593ebb 100644 --- a/docs/Service/Examples/timeseries_example.ipynb +++ b/docs/Service/Examples/timeseries_example.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -28,18 +28,22 @@ " \"class\": \"od\",\n", " \"stream\" : \"enfo\",\n", " \"type\" : \"pf\",\n", - " \"date\" : -1,\n", + " \"date\" : -1, # Note: date must be within the last two days \n", " \"time\" : \"0000\",\n", " \"levtype\" : \"sfc\",\n", " \"expver\" : \"0001\", \n", " \"domain\" : \"g\",\n", " \"param\" : \"164/167/169\",\n", " \"number\" : \"1/to/50\",\n", - " \"step\": \"0/to/360\",\n", " \"feature\" : {\n", " \"type\" : \"timeseries\",\n", " \"points\": LOCATION,\n", - " \"axes\": \"step\",\n", + " \"time_axis\": \"step\",\n", + " \"range\" : {\n", + " \"start\" : 0,\n", + " \"end\" : 360,\n", + " },\n", + " \"axes\" : [\"latitude\", \"longitude\"]\n", " },\n", "}\n", "\n", @@ -68,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -85,12 +89,12 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -108,6 +112,59 @@ "chart.line(ds,aggregation='mean', line_color='grey', time_frequency=TIME_FREQUENCY)\n", "chart.show(renderer=\"png\") # Replace with chart.show() in an interactive session!" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convert to Xarray" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 176kB\n", + "Dimensions: (x: 1, y: 1, z: 1, number: 50, datetime: 1, t: 145)\n", + "Coordinates:\n", + " * x (x) float64 8B -9.104\n", + " * y (y) float64 8B 38.81\n", + " * z (z) int64 8B 0\n", + " * number (number) int64 400B 1 2 3 4 5 6 7 8 9 ... 43 44 45 46 47 48 49 50\n", + " * datetime (datetime) Date: Wed, 12 Feb 2025 09:58:15 +0000 Subject: [PATCH 20/28] Fix typos --- .../Examples/vertical_profile_example.ipynb | 26 ++++++++++++++++++- docs/Service/Features/timeseries.md | 2 +- 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/docs/Service/Examples/vertical_profile_example.ipynb b/docs/Service/Examples/vertical_profile_example.ipynb index c9c2f028..5f697105 100644 --- a/docs/Service/Examples/vertical_profile_example.ipynb +++ b/docs/Service/Examples/vertical_profile_example.ipynb @@ -73,6 +73,30 @@ "chart.fig.update_layout(yaxis2={\"title\": \"hPa\"})\n", "chart.show(renderer=\"png\") # Replace with chart.show() in an interactive session!" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Convert to Xarray" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "da = ds.to_xarray()\n", + "print(da)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -91,7 +115,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.8" } }, "nbformat": 4, diff --git a/docs/Service/Features/timeseries.md b/docs/Service/Features/timeseries.md index 4b890634..55cdb6c3 100644 --- a/docs/Service/Features/timeseries.md +++ b/docs/Service/Features/timeseries.md @@ -110,4 +110,4 @@ Conversely at least one of `range` or `step` must be included. ## Note: -Previously the `axes` keyword was used for `time_axis`. We still allow this behaviour to satisfy backwards compatability with previous requests. +Previously the `axes` keyword was used for `time_axis`. We still allow this behavior to satisfy backwards compatibility with previous requests. From fa24cc70e644ba519b8259f86c6071748cd534fb Mon Sep 17 00:00:00 2001 From: awarde96 Date: Wed, 12 Feb 2025 10:01:53 +0000 Subject: [PATCH 21/28] Add links to destinE examples --- docs/Service/Examples/examples.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/docs/Service/Examples/examples.md b/docs/Service/Examples/examples.md index 1e6a0be3..f706fd52 100644 --- a/docs/Service/Examples/examples.md +++ b/docs/Service/Examples/examples.md @@ -5,4 +5,8 @@ * Vertical Profile * Bounding Box * Trajectory -* Country Cut-Out \ No newline at end of file +* Country Cut-Out + +For examples of Polytope Feature Extraction on Destination Earth Digital Twin Data please visit the following Github Repo: https://github.com/destination-earth-digital-twins/polytope-examples + +It contains examples for both the Climate DT and the Extremes DT. \ No newline at end of file From c7d22eccf67d2b2eafd876ca0a6c62f0075cdeeb Mon Sep 17 00:00:00 2001 From: Mathilde Leuridan <90444327+mathleur@users.noreply.github.com> Date: Wed, 12 Feb 2025 13:50:41 +0100 Subject: [PATCH 22/28] Update Data_Portfolio.md --- docs/Service/Data_Portfolio.md | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/docs/Service/Data_Portfolio.md b/docs/Service/Data_Portfolio.md index 9bed7505..69f95d7a 100644 --- a/docs/Service/Data_Portfolio.md +++ b/docs/Service/Data_Portfolio.md @@ -1,10 +1,10 @@ # Data Portfolio -Polytope feature extraction only has access to data that is stored on an FDB. The dataset currently available via Polyope feature extraction is the operational forecast. +Polytope feature extraction only has access to data that is stored on an FDB. The datasets currently available via Polyope feature extraction are the operational ECMWF forecast, as well as the data produced by the Destination Earth Extremes and Climate digital twins. ## Operational Forecast Data -The following values available for each field specified are: +The following key value pairs are available via Polytope: * `class` : `od` * `stream` : `enfo` `oper` @@ -18,7 +18,7 @@ If `type` is `enfo`: * `number` : `0/to/50` -If `levtype` is `pl` or `ml` a `levelist` must be provided: +If `levtype` is `pl` or `ml`, a `levelist` must be provided: * `levelist` : `1/to/1000` @@ -42,9 +42,9 @@ If `levtype` is `pl` or `ml` a `levelist` must be provided: * `crwe` * `ttpha` -For `sfc` most `params` will be available but not all. +For `sfc`, most `params` will be available but not all. -Only data that is contained in the operational FDB can be requested via Polytope feature extraction, the FDB usually only contains the last two days of forecasts. +Only data that is contained in the operational FDB can be requested via Polytope feature extraction. The FDB usually only contains the last two days of forecasts. We sometimes limit the size of requests for area features such as bounding box and polygon to maintain quality of service. @@ -56,7 +56,7 @@ Access to operational data is limited by our release schedule. The following values available for each field specified are: * `class` : `d1` -* `dataste` : `extremes-dt` +* `dataset` : `extremes-dt` * `stream` : `oper` `wave` * `type` : `fc` * `levtype` : `sfc` `pl` `hl` @@ -64,11 +64,11 @@ The following values available for each field specified are: * `domain` : `g` * `step` : `0/to/96` -If `levtype` is `pl` a `levelist` must be provided: +If `levtype` is `pl`, a `levelist` must be provided: * `levelist` : `1/to/1000` -If `levtype` is `hl` a `levelist` must be provided: +If `levtype` is `hl`, a `levelist` must be provided: * `levtype` : `100` @@ -103,7 +103,7 @@ Only Extremes-DT data from the past 15 days can be accessed by users. The following values available for each field specified are: * `class` : `d1` -* `dataste` : `climate-dt` +* `dataset` : `climate-dt` * `activity` : `ScenarioMIP` `story-nudging` `CMIP6` * `model`: `IFS-NEMO`, * `generation` : `1`, @@ -116,12 +116,12 @@ The following values available for each field specified are: * `expver` : `0001` * `domain` : `g` -If `levtype` is `pl` a `levelist` must be provided: +If `levtype` is `pl`, a `levelist` must be provided: * `levelist` : `1/to/1000` -`pl` is currently being scanned and new parameters will come online as time passes. This is also the case for `o2d`. +`pl` is currently being scanned and new parameters will become available as time passes. This is also the case for `o2d`. -For `sfc` most `params` are available. +For `sfc`, most `params` are available. -Currently for `date` between `2020` and `2050` is available. +Currently, only data for `dates` between `2020` and `2050` is available. From a991c6496c13d9e32e081fde26c338d54d091608 Mon Sep 17 00:00:00 2001 From: Mathilde Leuridan <90444327+mathleur@users.noreply.github.com> Date: Wed, 12 Feb 2025 13:51:53 +0100 Subject: [PATCH 23/28] Update timeseries.md --- docs/Service/Features/timeseries.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/Service/Features/timeseries.md b/docs/Service/Features/timeseries.md index 55cdb6c3..a09c2caa 100644 --- a/docs/Service/Features/timeseries.md +++ b/docs/Service/Features/timeseries.md @@ -21,7 +21,7 @@ request = { "feature" : { "type" : "timeseries", "points": [[-9.10, 38.78]], - "time_axes": "step", + "time_axis": "step", "range" : { "start" : 0, "end" : 360, From 26e35facb9e4bf6ad5920046d96314779b49867e Mon Sep 17 00:00:00 2001 From: Mathilde Leuridan <90444327+mathleur@users.noreply.github.com> Date: Wed, 12 Feb 2025 13:52:37 +0100 Subject: [PATCH 24/28] Update timeseries.md --- docs/Service/Features/timeseries.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/Service/Features/timeseries.md b/docs/Service/Features/timeseries.md index a09c2caa..b41cbb29 100644 --- a/docs/Service/Features/timeseries.md +++ b/docs/Service/Features/timeseries.md @@ -94,7 +94,7 @@ request = { "feature" : { "type" : "timeseries", "points": [[-9.10, 38.78]], - "time_axes": "step", + "time_axis": "step", }, "format": "covjson", } From 42e8af7562a3075aaa4de3b8d26da09e77932edc Mon Sep 17 00:00:00 2001 From: Mathilde Leuridan <90444327+mathleur@users.noreply.github.com> Date: Wed, 12 Feb 2025 13:54:37 +0100 Subject: [PATCH 25/28] Update Data_Portfolio.md --- docs/Service/Data_Portfolio.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/Service/Data_Portfolio.md b/docs/Service/Data_Portfolio.md index 69f95d7a..b88df6af 100644 --- a/docs/Service/Data_Portfolio.md +++ b/docs/Service/Data_Portfolio.md @@ -108,7 +108,7 @@ The following values available for each field specified are: * `model`: `IFS-NEMO`, * `generation` : `1`, * `realization`: `1`, -* `resolution`: `standard/high`, +* `resolution`: `standard` `high`, * `time`: `0000/to/2300`, * `stream` : `clte` * `type` : `fc` From 7542885ed1a9e9d2a8f754ebc5d008b06220c2a1 Mon Sep 17 00:00:00 2001 From: Mathilde Leuridan <90444327+mathleur@users.noreply.github.com> Date: Wed, 12 Feb 2025 16:05:51 +0100 Subject: [PATCH 26/28] Update Data_Portfolio.md --- docs/Service/Data_Portfolio.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/Service/Data_Portfolio.md b/docs/Service/Data_Portfolio.md index b88df6af..d9f001d0 100644 --- a/docs/Service/Data_Portfolio.md +++ b/docs/Service/Data_Portfolio.md @@ -105,11 +105,11 @@ The following values available for each field specified are: * `class` : `d1` * `dataset` : `climate-dt` * `activity` : `ScenarioMIP` `story-nudging` `CMIP6` -* `model`: `IFS-NEMO`, -* `generation` : `1`, -* `realization`: `1`, -* `resolution`: `standard` `high`, -* `time`: `0000/to/2300`, +* `model`: `IFS-NEMO` +* `generation` : `1` +* `realization`: `1` +* `resolution`: `standard` `high` +* `time`: `0000/to/2300` * `stream` : `clte` * `type` : `fc` * `levtype` : `sfc` `pl` `o2d` From 6df162f1fbe71a50242fb322a8754fab8a907514 Mon Sep 17 00:00:00 2001 From: mathleur Date: Wed, 12 Feb 2025 16:19:47 +0100 Subject: [PATCH 27/28] remove print statements --- polytope_feature/datacube/backends/fdb.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/polytope_feature/datacube/backends/fdb.py b/polytope_feature/datacube/backends/fdb.py index ab7a2dd1..609b74cf 100644 --- a/polytope_feature/datacube/backends/fdb.py +++ b/polytope_feature/datacube/backends/fdb.py @@ -31,7 +31,6 @@ def __init__( if len(alternative_axes) == 0: logging.info("Find GribJump axes for %s", context) self.fdb_coordinates = self.gj.axes(partial_request, ctx=context) - print(self.fdb_coordinates) logging.info("Retrieved available GribJump axes for %s", context) if len(self.fdb_coordinates) == 0: raise BadRequestError(partial_request) @@ -139,7 +138,6 @@ def get(self, requests: TensorIndexTree, context=None): logging.debug("The requests we give GribJump are: %s", printed_list_to_gj) logging.info("Requests given to GribJump extract for %s", context) try: - print(complete_list_complete_uncompressed_requests) output_values = self.gj.extract(complete_list_complete_uncompressed_requests, context) except Exception as e: if "BadValue: Grid hash mismatch" in str(e): From cd7524ae8d6c93068d184a544099d2ed68542330 Mon Sep 17 00:00:00 2001 From: mathleur Date: Thu, 13 Feb 2025 09:29:34 +0100 Subject: [PATCH 28/28] update version --- polytope_feature/version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/polytope_feature/version.py b/polytope_feature/version.py index 8c79b2ef..65d99ece 100644 --- a/polytope_feature/version.py +++ b/polytope_feature/version.py @@ -1 +1 @@ -__version__ = "1.0.26" +__version__ = "1.0.27"