Create Zarr With Slices SentinelHub

xcube Data Store Framework – Sentinel Hub Data Store¶

Generating a larger Zarr datacube from Sentinel 2 Level-2A data¶

Please note:

In order to access data from Sentinel Hub, you need Sentinel Hub API credentials. They may be passed as store parameters (see further below) or exported from environment variables. In case you have not exported them already, you may also set them by uncommenting the cell below and adjusting the content to your access credentials. However, we do not recommend this method!

• Within DeepESDL there is the possiblity to apply for SentinelHub access - please contact the DeepESDL team :)
• This notebook runs with the python environment deepesdl-xcube-1.7.0, please checkout the documentation for help on changing the environment.**

In [1]:

import os

import numpy as np
import pandas as pd
import xarray as xr

# mandatory imports
from xcube.core.store import find_data_store_extensions
from xcube.core.store import get_data_store_params_schema
from xcube.core.store import new_data_store
from zappend.api import zappend

import os import numpy as np import pandas as pd import xarray as xr # mandatory imports from xcube.core.store import find_data_store_extensions from xcube.core.store import get_data_store_params_schema from xcube.core.store import new_data_store from zappend.api import zappend

Access data from Sentinel Hub¶

The xcube plugin xcube-sh provides a data store named sentinelhub that can be used to access Sentinel data in form 3-d datacubes of type xarray.Dataset.

In [2]:

sh_store = new_data_store('sentinelhub', num_retries=400)

sh_store = new_data_store('sentinelhub', num_retries=400)

Which datasets are supported by this data store?

In [3]:

sh_store.list_data_ids()

sh_store.list_data_ids()

Out[3]:

['S2L1C', 'S1GRD', 'S2L2A', 'DEM']

Describe the S2L2A dataset. The open_params_schema describes the parameters that can be passed to the data store's open_data() method.

In [4]:

sh_store.describe_data('S2L2A')

sh_store.describe_data('S2L2A')

Out[4]:

<xcube.core.store.descriptor.DatasetDescriptor at 0x7fb102d20a50>

Let's open a subset of this dataset to familiarize with its representation as an xarray.Dataset. The dataset is opened lazily, that is, data is loaded only at the time it is needed:

In [5]:

s2_cube = sh_store.open_data(
    'S2L2A',
    variable_names=['B02','B03','B04'],
    tile_size=[1024, 1024],
    spatial_res=0.00018,   # = 20.038 meters in degree
    bbox=[10.0, 54.27, 11.0, 54.6],
    time_range=[f'2023-07-08', f'2023-07-12'],
    time_period='1D'
)
s2_cube

s2_cube = sh_store.open_data( 'S2L2A', variable_names=['B02','B03','B04'], tile_size=[1024, 1024], spatial_res=0.00018, # = 20.038 meters in degree bbox=[10.0, 54.27, 11.0, 54.6], time_range=[f'2023-07-08', f'2023-07-12'], time_period='1D' ) s2_cube

Out[5]:

<xarray.Dataset> Size: 755MB
Dimensions:    (time: 5, lat: 2048, lon: 6144, bnds: 2)
Coordinates:
  * lat        (lat) float64 16kB 54.64 54.64 54.64 54.64 ... 54.27 54.27 54.27
  * lon        (lon) float64 49kB 10.0 10.0 10.0 10.0 ... 11.11 11.11 11.11
  * time       (time) datetime64[ns] 40B 2023-07-08T12:00:00 ... 2023-07-12T1...
    time_bnds  (time, bnds) datetime64[ns] 80B dask.array<chunksize=(5, 2), meta=np.ndarray>
Dimensions without coordinates: bnds
Data variables:
    B02        (time, lat, lon) float32 252MB dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>
    B03        (time, lat, lon) float32 252MB dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>
    B04        (time, lat, lon) float32 252MB dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>
Attributes: (12/13)
    Conventions:               CF-1.7
    title:                     S2L2A Data Cube Subset
    history:                   [{'program': 'xcube_sh.chunkstore.SentinelHubC...
    date_created:              2024-09-11T08:47:04.855222
    time_coverage_start:       2023-07-08T00:00:00+00:00
    time_coverage_end:         2023-07-13T00:00:00+00:00
    ...                        ...
    time_coverage_resolution:  P1DT0H0M0S
    geospatial_lon_min:        10.0
    geospatial_lat_min:        54.27
    geospatial_lon_max:        11.10592
    geospatial_lat_max:        54.63864
    processing_level:          L2A

xarray.Dataset

• Dimensions:
  • time: 5
  • lat: 2048
  • lon: 6144
  • bnds: 2
• Coordinates: (4)
  • lat
    (lat)
    float64
    54.64 54.64 54.64 ... 54.27 54.27

    units :

    decimal_degrees

    long_name :

    latitude

    standard_name :

    latitude

    array([54.63855, 54.63837, 54.63819, ..., 54.27045, 54.27027, 54.27009])

  • lon
    (lon)
    float64
    10.0 10.0 10.0 ... 11.11 11.11

    units :

    decimal_degrees

    long_name :

    longitude

    standard_name :

    longitude

    array([10.00009, 10.00027, 10.00045, ..., 11.10547, 11.10565, 11.10583])

  • time
    (time)
    datetime64[ns]
    2023-07-08T12:00:00 ... 2023-07-...

    standard_name :

    time

    bounds :

    time_bnds

    array(['2023-07-08T12:00:00.000000000', '2023-07-09T12:00:00.000000000',
           '2023-07-10T12:00:00.000000000', '2023-07-11T12:00:00.000000000',
           '2023-07-12T12:00:00.000000000'], dtype='datetime64[ns]')

  • time_bnds
    (time, bnds)
    datetime64[ns]
    dask.array<chunksize=(5, 2), meta=np.ndarray>

    standard_name :

    time

    Array Chunk Bytes 80 B 80 B Shape (5, 2) (5, 2) Dask graph 1 chunks in 2 graph layers Data type datetime64[ns] numpy.ndarray

• Data variables: (3)
  • B02
    (time, lat, lon)
    float32
    dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>

    sample_type :

    FLOAT32

    units :

    reflectance

    wavelength :

    492.25

    wavelength_a :

    492.4

    wavelength_b :

    492.1

    bandwidth :

    66.0

    bandwidth_a :

    66

    bandwidth_b :

    66

    resolution :

    10

    Array Chunk Bytes 240.00 MiB 4.00 MiB Shape (5, 2048, 6144) (1, 1024, 1024) Dask graph 60 chunks in 2 graph layers Data type float32 numpy.ndarray

  • B03
    (time, lat, lon)
    float32
    dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>

    sample_type :

    FLOAT32

    units :

    reflectance

    wavelength :

    559.4

    wavelength_a :

    559.8

    wavelength_b :

    559

    bandwidth :

    36.0

    bandwidth_a :

    36

    bandwidth_b :

    36

    resolution :

    10

    Array Chunk Bytes 240.00 MiB 4.00 MiB Shape (5, 2048, 6144) (1, 1024, 1024) Dask graph 60 chunks in 2 graph layers Data type float32 numpy.ndarray

  • B04
    (time, lat, lon)
    float32
    dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>

    sample_type :

    FLOAT32

    units :

    reflectance

    wavelength :

    664.75

    wavelength_a :

    664.6

    wavelength_b :

    664.9

    bandwidth :

    31.0

    bandwidth_a :

    31

    bandwidth_b :

    31

    resolution :

    10

    Array Chunk Bytes 240.00 MiB 4.00 MiB Shape (5, 2048, 6144) (1, 1024, 1024) Dask graph 60 chunks in 2 graph layers Data type float32 numpy.ndarray

• Indexes: (3)
  • lat
    PandasIndex

    PandasIndex(Index([          54.63855,           54.63837,           54.63819,
                     54.63801,           54.63783,           54.63765,
                     54.63747,           54.63729,           54.63711,
                     54.63693,
           ...
           54.271710000000006, 54.271530000000006, 54.271350000000005,
           54.271170000000005, 54.270990000000005, 54.270810000000004,
           54.270630000000004, 54.270450000000004, 54.270270000000004,
                     54.27009],
          dtype='float64', name='lat', length=2048))

  • lon
    PandasIndex

    PandasIndex(Index([          10.00009,           10.00027,           10.00045,
           10.000630000000001,           10.00081,           10.00099,
                     10.00117,           10.00135,           10.00153,
           10.001710000000001,
           ...
           11.104209999999998, 11.104389999999999, 11.104569999999999,
                     11.10475,           11.10493,           11.10511,
                     11.10529, 11.105469999999999, 11.105649999999999,
                     11.10583],
          dtype='float64', name='lon', length=6144))

  • time
    PandasIndex

    PandasIndex(DatetimeIndex(['2023-07-08 12:00:00', '2023-07-09 12:00:00',
                   '2023-07-10 12:00:00', '2023-07-11 12:00:00',
                   '2023-07-12 12:00:00'],
                  dtype='datetime64[ns]', name='time', freq=None))

• Attributes: (13)

  Conventions :

  CF-1.7

  title :

  S2L2A Data Cube Subset

  history :

  [{'program': 'xcube_sh.chunkstore.SentinelHubChunkStore', 'cube_config': {'dataset_name': 'S2L2A', 'band_names': ['B02', 'B03', 'B04'], 'band_fill_values': None, 'band_sample_types': None, 'band_units': None, 'tile_size': [1024, 1024], 'bbox': [10.0, 54.27, 11.10592, 54.63864], 'spatial_res': 0.00018, 'crs': 'WGS84', 'upsampling': 'NEAREST', 'downsampling': 'NEAREST', 'mosaicking_order': 'mostRecent', 'time_range': ['2023-07-08T00:00:00+00:00', '2023-07-12T00:00:00+00:00'], 'time_period': '1 days 00:00:00', 'time_tolerance': None, 'collection_id': None, 'four_d': False}}]

  date_created :

  2024-09-11T08:47:04.855222

  time_coverage_start :

  2023-07-08T00:00:00+00:00

  time_coverage_end :

  2023-07-13T00:00:00+00:00

  time_coverage_duration :

  P5DT0H0M0S

  time_coverage_resolution :

  P1DT0H0M0S

  geospatial_lon_min :

  10.0

  geospatial_lat_min :

  54.27

  geospatial_lon_max :

  11.10592

  geospatial_lat_max :

  54.63864

  processing_level :

  L2A

In [6]:

s2_cube.B03.isel(time=0).plot.imshow(vmax=0.2, cmap="bone")

s2_cube.B03.isel(time=0).plot.imshow(vmax=0.2, cmap="bone")

Out[6]:

<matplotlib.image.AxesImage at 0x7fb10012f690>

The dataset s2_cube could be written to Zarr by simply using s2_cube.to_zarr(path) but that approach is not appropriate for larger datacubes for several reasons:

• Sentinel Hub may lower bandwidth due to the very many concurrent API requests it receives for each written chunk of our datacube.
• Your Sentinel Hub subscription may run out of credits.
• Network errors while reading or filesystem errors while writing may occur unexpectedly at any time.
• Potential, yet undiscovered memory leaks in the involved libraries may lead to out-of-memory conditions.

Therefore we will introduce a new tool zappend that can avoid or at least mitigate some of the issues above. Before that we discuss the team storage where you can persist your datacubes.

Access team storage¶

The DeepESDL team storage is a special writable bucket in AWS S3 object storage that is used by your team to allow for shared access of datasets. The xcube software provides an data store of type s3 to access datasets in object storage.

In [7]:

S3_USER_STORAGE_KEY = os.environ["S3_USER_STORAGE_KEY"]
S3_USER_STORAGE_SECRET = os.environ["S3_USER_STORAGE_SECRET"]
S3_USER_STORAGE_BUCKET = os.environ["S3_USER_STORAGE_BUCKET"]

S3_USER_STORAGE_KEY = os.environ["S3_USER_STORAGE_KEY"] S3_USER_STORAGE_SECRET = os.environ["S3_USER_STORAGE_SECRET"] S3_USER_STORAGE_BUCKET = os.environ["S3_USER_STORAGE_BUCKET"]

In [8]:

team_store = new_data_store(
    "s3", 
    root=S3_USER_STORAGE_BUCKET, 
    storage_options=dict(
        anon=False, 
        key=S3_USER_STORAGE_KEY, 
        secret=S3_USER_STORAGE_SECRET
    )
)

team_store = new_data_store( "s3", root=S3_USER_STORAGE_BUCKET, storage_options=dict( anon=False, key=S3_USER_STORAGE_KEY, secret=S3_USER_STORAGE_SECRET ) )

Which datasets are already in the team store?

In [9]:

team_store.list_data_ids()

team_store.list_data_ids()

Out[9]:

['SST.levels',
 'amazonas_v8.zarr',
 'amazonas_v9.zarr',
 'noise_trajectory.zarr',
 'reanalysis-era5-single-levels-monthly-means-subset-2001-2010_TMH.zarr',
 's2-demo-cube.zarr']

If you need to delete datasets from team storage, use the has_data() and delete_data() store methods:

In [10]:

if team_store.has_data('ERA5_example.levels'):
    team_store.delete_data('ERA5_example.levels')

if team_store.has_data('ERA5_example.levels'): team_store.delete_data('ERA5_example.levels')

Generate a larger Zarr datacube from Sentinel data¶

As anounced, we will utilize the zappend tool for writing larger datacubes into team storage. The objective of zappend is to address recurring memory issues when generating large geospatial datacubes using the Zarr format by subsequently concatenating data slices along an append dimension, e.g., time (the default) for geospatial satellite observations. Each append step is atomic, that is, the append operation is a transaction that is rolled back, in case the append operation fails. This ensures integrity of the target data cube. Find our more:

zappend can be used in a number of ways. In the following example we read smaller Sentinel datacubes, dataset slices, from the sh_store as described above. We use a Python generator function that provides a stream of dataset slices. The slice stream will be passed to zappend allowing it to process the slices subsequentially and open a slice dataset only when it is its turn. Another advantage of this approach is that a used slice dataset vanishes from memory, as no references are being kept anywhere.

Our datacube specification:

In [11]:

variables = ['B02', 'B03', 'B04']

x1 = 10.00  # degree
y1 = 54.27  # degree
x2 = 11.00  # degree
y2 = 54.60  # degree

bbox = x1, y1, x2, y2

spatial_res = 0.00018   # = 20.038 meters in degree

time_range = '2023-06-01', '2023-06-05'  # For testing. adjust!
time_period = '1D'

target_zarr = 's2-demo-cube.zarr'

variables = ['B02', 'B03', 'B04'] x1 = 10.00 # degree y1 = 54.27 # degree x2 = 11.00 # degree y2 = 54.60 # degree bbox = x1, y1, x2, y2 spatial_res = 0.00018 # = 20.038 meters in degree time_range = '2023-06-01', '2023-06-05' # For testing. adjust! time_period = '1D' target_zarr = 's2-demo-cube.zarr'

Delete an existing target datacube:

In [12]:

if team_store.has_data(target_zarr):
    team_store.delete_data(target_zarr)

if team_store.has_data(target_zarr): team_store.delete_data(target_zarr)

This is the aforementioned generator function that provides the stream of slice datasets:

In [13]:

def generate_slices(sh_store, time_ranges, variables, bbox, spatial_res, time_period):
    for time_range in time_ranges:
        print(f'Opening slice dataset for {time_range}')
        slice_ds = sh_store.open_data(
            'S2L2A',
            variable_names=variables,
            tile_size=[1024, 1024],
            spatial_res=spatial_res,
            bbox=bbox,
            time_range=time_range,
            time_period=time_period
        )
        print(f'Opened slice dataset of size {slice_ds.nbytes / (10 ** 9)} GB')

        # Note, that you can modify slice_ds in any way you want here.
        # E.g. you could add computed variables or update dataset attributes.
        
        yield slice_ds    

def generate_slices(sh_store, time_ranges, variables, bbox, spatial_res, time_period): for time_range in time_ranges: print(f'Opening slice dataset for {time_range}') slice_ds = sh_store.open_data( 'S2L2A', variable_names=variables, tile_size=[1024, 1024], spatial_res=spatial_res, bbox=bbox, time_range=time_range, time_period=time_period ) print(f'Opened slice dataset of size {slice_ds.nbytes / (10 ** 9)} GB') # Note, that you can modify slice_ds in any way you want here. # E.g. you could add computed variables or update dataset attributes. yield slice_ds

Define a function that creates a list of time ranges each having the duration given by time_period:

In [14]:

def get_time_ranges(time_range, time_period):
    interval_td = pd.Timedelta(time_period)
    one_sec = pd.Timedelta("1s")
    start_date, stop_date = pd.to_datetime(time_range)
    dates = pd.date_range(start_date, stop_date + interval_td, freq=interval_td)
    def to_date_str(date):
        return date.strftime("%Y-%m-%d")
    return [
        (to_date_str(dates[i]), to_date_str(dates[i + 1] - one_sec))
        for i in range(len(dates) - 1)
    ]

def get_time_ranges(time_range, time_period): interval_td = pd.Timedelta(time_period) one_sec = pd.Timedelta("1s") start_date, stop_date = pd.to_datetime(time_range) dates = pd.date_range(start_date, stop_date + interval_td, freq=interval_td) def to_date_str(date): return date.strftime("%Y-%m-%d") return [ (to_date_str(dates[i]), to_date_str(dates[i + 1] - one_sec)) for i in range(len(dates) - 1) ]

In [15]:

time_ranges = get_time_ranges(time_range, time_period)

# Test it
time_ranges

time_ranges = get_time_ranges(time_range, time_period) # Test it time_ranges

Out[15]:

[('2023-06-01', '2023-06-01'),
 ('2023-06-02', '2023-06-02'),
 ('2023-06-03', '2023-06-03'),
 ('2023-06-04', '2023-06-04'),
 ('2023-06-05', '2023-06-05')]

In [16]:

# Remember, no data is read here, the generator produces a lazy slice stream!
slices = generate_slices(sh_store, time_ranges, variables, bbox, spatial_res, time_period)

# Remember, no data is read here, the generator produces a lazy slice stream! slices = generate_slices(sh_store, time_ranges, variables, bbox, spatial_res, time_period)

In [17]:

zappend(
    slices=slices,
    target_dir=f"s3://{S3_USER_STORAGE_BUCKET}/{target_zarr}",
    target_storage_options={
        "anon": False,
        "key": S3_USER_STORAGE_KEY,
        "secret": S3_USER_STORAGE_SECRET
    }
)

zappend( slices=slices, target_dir=f"s3://{S3_USER_STORAGE_BUCKET}/{target_zarr}", target_storage_options={ "anon": False, "key": S3_USER_STORAGE_KEY, "secret": S3_USER_STORAGE_SECRET } )

Opening slice dataset for ('2023-06-01', '2023-06-01')
Opened slice dataset of size 0.151060504 GB
Opening slice dataset for ('2023-06-02', '2023-06-02')
Opened slice dataset of size 0.151060504 GB
Opening slice dataset for ('2023-06-03', '2023-06-03')
Opened slice dataset of size 0.151060504 GB
Opening slice dataset for ('2023-06-04', '2023-06-04')
Opened slice dataset of size 0.151060504 GB
Opening slice dataset for ('2023-06-05', '2023-06-05')
Opened slice dataset of size 0.151060504 GB

In [18]:

list(team_store.get_data_ids())

list(team_store.get_data_ids())

Out[18]:

['SST.levels',
 'amazonas_v8.zarr',
 'amazonas_v9.zarr',
 'noise_trajectory.zarr',
 'reanalysis-era5-single-levels-monthly-means-subset-2001-2010_TMH.zarr',
 's2-demo-cube.zarr']

Open generated cube from team storage¶

In [19]:

s2_cube = team_store.open_data(target_zarr)
s2_cube

s2_cube = team_store.open_data(target_zarr) s2_cube

Out[19]:

<xarray.Dataset> Size: 755MB
Dimensions:    (time: 5, lat: 2048, lon: 6144, bnds: 2)
Coordinates:
  * lat        (lat) float64 16kB 54.64 54.64 54.64 54.64 ... 54.27 54.27 54.27
  * lon        (lon) float64 49kB 10.0 10.0 10.0 10.0 ... 11.11 11.11 11.11
  * time       (time) datetime64[ns] 40B 2023-06-01T12:00:00 ... 2023-06-05T1...
    time_bnds  (time, bnds) datetime64[ns] 80B dask.array<chunksize=(1, 2), meta=np.ndarray>
Dimensions without coordinates: bnds
Data variables:
    B02        (time, lat, lon) float32 252MB dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>
    B03        (time, lat, lon) float32 252MB dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>
    B04        (time, lat, lon) float32 252MB dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>
Attributes: (12/13)
    Conventions:               CF-1.7
    date_created:              2024-09-11T08:47:12.058769
    geospatial_lat_max:        54.63864
    geospatial_lat_min:        54.27
    geospatial_lon_max:        11.10592
    geospatial_lon_min:        10.0
    ...                        ...
    processing_level:          L2A
    time_coverage_duration:    P1DT0H0M0S
    time_coverage_end:         2023-06-02T00:00:00+00:00
    time_coverage_resolution:  P1DT0H0M0S
    time_coverage_start:       2023-06-01T00:00:00+00:00
    title:                     S2L2A Data Cube Subset

xarray.Dataset

• Dimensions:
  • time: 5
  • lat: 2048
  • lon: 6144
  • bnds: 2
• Coordinates: (4)
  • lat
    (lat)
    float64
    54.64 54.64 54.64 ... 54.27 54.27

    long_name :

    latitude

    standard_name :

    latitude

    units :

    decimal_degrees

    array([54.63855, 54.63837, 54.63819, ..., 54.27045, 54.27027, 54.27009])

  • lon
    (lon)
    float64
    10.0 10.0 10.0 ... 11.11 11.11

    long_name :

    longitude

    standard_name :

    longitude

    units :

    decimal_degrees

    array([10.00009, 10.00027, 10.00045, ..., 11.10547, 11.10565, 11.10583])

  • time
    (time)
    datetime64[ns]
    2023-06-01T12:00:00 ... 2023-06-...

    bounds :

    time_bnds

    standard_name :

    time

    array(['2023-06-01T12:00:00.000000000', '2023-06-02T12:00:00.000000000',
           '2023-06-03T12:00:00.000000000', '2023-06-04T12:00:00.000000000',
           '2023-06-05T12:00:00.000000000'], dtype='datetime64[ns]')

  • time_bnds
    (time, bnds)
    datetime64[ns]
    dask.array<chunksize=(1, 2), meta=np.ndarray>

    standard_name :

    time

    Array Chunk Bytes 80 B 16 B Shape (5, 2) (1, 2) Dask graph 5 chunks in 2 graph layers Data type datetime64[ns] numpy.ndarray

• Data variables: (3)
  • B02
    (time, lat, lon)
    float32
    dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>

    bandwidth :

    66.0

    bandwidth_a :

    66

    bandwidth_b :

    66

    resolution :

    10

    sample_type :

    FLOAT32

    units :

    reflectance

    wavelength :

    492.25

    wavelength_a :

    492.4

    wavelength_b :

    492.1

    Array Chunk Bytes 240.00 MiB 4.00 MiB Shape (5, 2048, 6144) (1, 1024, 1024) Dask graph 60 chunks in 2 graph layers Data type float32 numpy.ndarray

  • B03
    (time, lat, lon)
    float32
    dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>

    bandwidth :

    36.0

    bandwidth_a :

    36

    bandwidth_b :

    36

    resolution :

    10

    sample_type :

    FLOAT32

    units :

    reflectance

    wavelength :

    559.4

    wavelength_a :

    559.8

    wavelength_b :

    559

    Array Chunk Bytes 240.00 MiB 4.00 MiB Shape (5, 2048, 6144) (1, 1024, 1024) Dask graph 60 chunks in 2 graph layers Data type float32 numpy.ndarray

  • B04
    (time, lat, lon)
    float32
    dask.array<chunksize=(1, 1024, 1024), meta=np.ndarray>

    bandwidth :

    31.0

    bandwidth_a :

    31

    bandwidth_b :

    31

    resolution :

    10

    sample_type :

    FLOAT32

    units :

    reflectance

    wavelength :

    664.75

    wavelength_a :

    664.6

    wavelength_b :

    664.9

    Array Chunk Bytes 240.00 MiB 4.00 MiB Shape (5, 2048, 6144) (1, 1024, 1024) Dask graph 60 chunks in 2 graph layers Data type float32 numpy.ndarray

• Indexes: (3)
  • lat
    PandasIndex

    PandasIndex(Index([          54.63855,           54.63837,           54.63819,
                     54.63801,           54.63783,           54.63765,
                     54.63747,           54.63729,           54.63711,
                     54.63693,
           ...
           54.271710000000006, 54.271530000000006, 54.271350000000005,
           54.271170000000005, 54.270990000000005, 54.270810000000004,
           54.270630000000004, 54.270450000000004, 54.270270000000004,
                     54.27009],
          dtype='float64', name='lat', length=2048))

  • lon
    PandasIndex

    PandasIndex(Index([          10.00009,           10.00027,           10.00045,
           10.000630000000001,           10.00081,           10.00099,
                     10.00117,           10.00135,           10.00153,
           10.001710000000001,
           ...
           11.104209999999998, 11.104389999999999, 11.104569999999999,
                     11.10475,           11.10493,           11.10511,
                     11.10529, 11.105469999999999, 11.105649999999999,
                     11.10583],
          dtype='float64', name='lon', length=6144))

  • time
    PandasIndex

    PandasIndex(DatetimeIndex(['2023-06-01 12:00:00', '2023-06-02 12:00:00',
                   '2023-06-03 12:00:00', '2023-06-04 12:00:00',
                   '2023-06-05 12:00:00'],
                  dtype='datetime64[ns]', name='time', freq=None))

• Attributes: (13)

  Conventions :

  CF-1.7

  date_created :

  2024-09-11T08:47:12.058769

  geospatial_lat_max :

  54.63864

  geospatial_lat_min :

  54.27

  geospatial_lon_max :

  11.10592

  geospatial_lon_min :

  10.0

  history :

  [{'cube_config': {'band_fill_values': None, 'band_names': ['B02', 'B03', 'B04'], 'band_sample_types': None, 'band_units': None, 'bbox': [10.0, 54.27, 11.10592, 54.63864], 'collection_id': None, 'crs': 'WGS84', 'dataset_name': 'S2L2A', 'downsampling': 'NEAREST', 'four_d': False, 'mosaicking_order': 'mostRecent', 'spatial_res': 0.00018, 'tile_size': [1024, 1024], 'time_period': '1 days 00:00:00', 'time_range': ['2023-06-01T00:00:00+00:00', '2023-06-01T00:00:00+00:00'], 'time_tolerance': None, 'upsampling': 'NEAREST'}, 'program': 'xcube_sh.chunkstore.SentinelHubChunkStore'}]

  processing_level :

  L2A

  time_coverage_duration :

  P1DT0H0M0S

  time_coverage_end :

  2023-06-02T00:00:00+00:00

  time_coverage_resolution :

  P1DT0H0M0S

  time_coverage_start :

  2023-06-01T00:00:00+00:00

  title :

  S2L2A Data Cube Subset

Looks good, now let's clean up the example cube :)

In [20]:

team_store.delete_data(target_zarr)

team_store.delete_data(target_zarr)

In [ ]: