From 6e46e436a2db06c7a9d44719634acb0e20b8cfdf Mon Sep 17 00:00:00 2001 From: henze Date: Thu, 7 May 2026 17:32:55 -0700 Subject: [PATCH 1/2] Add open_icechunk.ipynb --- notebooks/Advanced_cloud/open_icechunk.ipynb | 12104 +++++++++++++++++ 1 file changed, 12104 insertions(+) create mode 100644 notebooks/Advanced_cloud/open_icechunk.ipynb diff --git a/notebooks/Advanced_cloud/open_icechunk.ipynb b/notebooks/Advanced_cloud/open_icechunk.ipynb new file mode 100644 index 00000000..efb301ad --- /dev/null +++ b/notebooks/Advanced_cloud/open_icechunk.ipynb @@ -0,0 +1,12104 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ce676c6b-db54-449a-9952-a73a9a93bf39", + "metadata": {}, + "source": [ + "## Example of Opening an Icechunk Store In-Cloud\n", + "\n", + "#### *Author: Dean Henze, PO.DAAC*\n", + "\n", + "This notebook demonstrates opening a virtual dataset (VDS) stored as an Icechunk store (note this technology is currently experimental, although it is gaining momentum). For a general overview of VDS's see the [Using Virutal Datasets chapter](https://podaac.github.io/tutorials/quarto_text/UsingVirtualDatasets.html) on the PO.DAAC Cookbook.\n", + "\n", + "The example dataset(s) used here are from the SASSIE ECCO project (The e.g. the [User Guide](https://doi.org/10.5067/SEL1D-DUG11) with project overview). The ECCO model (Estimating the Circulation and Climate of the Ocean) was run over the arctic region over a seven year period in support of the SASSIE field experiment (Salinity and Stratification at the Sea Ice Edge). The SASSIE ECCO data are traditionally archived and available in netCDF format - one file per day(month) for the daily-mean(monthly-snapshot) datasets. The model output variables (totalling ~50 TBs) are large enough that they are spread out over 18 different netCDF datasets for the daily-means, and over 3 different datasets for the monthly-snapshots. One novel functionality of VDS's being tested here is the ability to combine the data across e.g. the 18 daily-mean datasets so users can interact with the data as if all variables were contained in a single dataset. Computing performance is TBD.\n", + "\n", + "The AWS S3 paths to the SASSIE ECCO icechunk stores are\n", + "\n", + "**Daily averages:**\n", + "\n", + "s3://podaac-ops-cumulus-public/virtual_collections/SASSIE_ECCO_V1R1/SASSIE_ECCO_L4_DAILY_V1R1_virtual_s3.icechunk/\n", + "\n", + "**Monthly snapshots:**\n", + "\n", + "s3://podaac-ops-cumulus-public/virtual_collections/SASSIE_ECCO_V1R1/SASSIE_ECCO_L4_SNAPSHOT_V1R1_virtual_s3.icechunk/" + ] + }, + { + "cell_type": "markdown", + "id": "81464144-bf17-4fe0-861b-b97d01aed169", + "metadata": {}, + "source": [ + "## Requirements and Python environment\n", + "\n", + "* Earthdata login account: An Earthdata Login account is required to access data from the NASA Earthdata system. Please visit https://urs.earthdata.nasa.gov to register and manage your Earthdata Login account.\n", + "\n", + "* Compute environment: This notebook is meant to be run in the cloud (AWS instance running in us-west-2).\n", + "\n", + "* The minimal working installation for Python 3.13 environment is\n", + "\n", + "```\n", + "earthaccess==0.16.0\n", + "icechunk==1.1.19\n", + "xarray==2025.6.1\n", + "zarr==3.1.1\n", + "matplotlib\n", + "jupyterlab\n", + "```\n", + "\n", + "***Note that the icechunk=1.1.19 dependency is important! Do not use a more recent version.***" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0a074463-73c5-4284-85d5-9679eb64158b", + "metadata": {}, + "outputs": [], + "source": [ + "import icechunk\n", + "import xarray as xr\n", + "import earthaccess" + ] + }, + { + "cell_type": "markdown", + "id": "ede75846-f591-408b-9421-ac73dee84312", + "metadata": {}, + "source": [ + "### 1. Define a function to access the icechunk store\n", + "\n", + "This function does not need any modification. It defines some access keywords and a mapper to the VDS. The mapper will contain all the required access credentials and can be passed directly to xarray. In the future this step will likely be built into to earthaccess but for now we must define it in the notebook. The only inputs to the function are:\n", + "\n", + "1. Your EDS credentials\n", + "2. The link to the VDS reference file (in the header of this notebook and in the next section)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "db744b69-c703-4234-8fab-b5b19aaffdaf", + "metadata": {}, + "outputs": [], + "source": [ + "def open_readonly_icechunkstore_s3(\n", + " s3path_store, creds_store, creds_data_chunks, \n", + " bucket_data_chunks = \"s3://podaac-ops-cumulus-protected/\"):\n", + " \"\"\"\n", + " Opens and returns an icechunk store with read-only capabilities.\n", + "\n", + " Inputs\n", + " ------\n", + " s3path_store: str or path\n", + " AWS S3 path to the icechunk store, e.g. \"s3://podaac-ops-cumulus-public/virtual_collections/...\".\n", + " creds_store: dict\n", + " Credentials to access the icechunk store (e.g. EDL creds for NASA Earthdata). Expected\n", + " dictionary keys are \"accessKeyId\", \"secretAccessKey\", and \"sessionToken\".\n", + " creds_data_chunks: dict\n", + " Credentials to access the science data that the icechunk store points to (e.g. EDL creds \n", + " for NASA Earthdata). Expected dictionary keys are \"accessKeyId\", \"secretAccessKey\",\n", + " and \"sessionToken\".\n", + " bucket_data_chunks: str\n", + " Name of bucket containing the science data that the icechunk store points to. E.g. for\n", + " PO.DAAC data this might be \"s3://podaac-ops-cumulus-protected/\". Note you need\n", + " the \"s3://\" prefix.\n", + " \"\"\"\n", + " \n", + " \n", + " # 1. Create the raw static credentials object for virtual chunks\n", + " virtualchunk_static_creds = icechunk.s3_static_credentials(\n", + " access_key_id = creds_data_chunks[\"accessKeyId\"],\n", + " secret_access_key = creds_data_chunks[\"secretAccessKey\"],\n", + " session_token = creds_data_chunks[\"sessionToken\"]\n", + " )\n", + " auth_map = icechunk.containers_credentials({\n", + " bucket_data_chunks: virtualchunk_static_creds\n", + " })\n", + " \n", + " # 2. Config for the store / metadata repository\n", + " s3path_split = s3path_store.split(\"/\")\n", + " bucket_store = \"/\".join(s3path_split[2:3])\n", + " prefix_store = \"/\".join(s3path_split[3:])\n", + "\n", + " storage = icechunk.s3_storage(\n", + " bucket = bucket_store,\n", + " prefix = prefix_store,\n", + " access_key_id = creds_store['accessKeyId'],\n", + " secret_access_key = creds_store['secretAccessKey'],\n", + " session_token = creds_store['sessionToken']\n", + " )\n", + " \n", + " # 3. Open the repository, passing the compiled auth_map!\n", + " repo = icechunk.Repository.open(\n", + " storage,\n", + " authorize_virtual_chunk_access=auth_map\n", + " )\n", + " \n", + " # 4. Return the store\n", + " session = repo.readonly_session(\"main\")\n", + " return session.store" + ] + }, + { + "cell_type": "markdown", + "id": "bf5ba5ce-e274-4e10-9932-2624b30ab698", + "metadata": {}, + "source": [ + "### 2. Access store and open data with Xarray\n", + "\n", + "Steps are to:\n", + "\n", + "1. Login to NASA EDL.\n", + "2. Use the above function to get the icechunk store mapper.\n", + "3. Pass the mapper into Xarray to open the dataset.\n", + "4. Perform some sample computations" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8bfe1ba3-9cf2-4c56-8f92-ade97b98f9d9", + "metadata": {}, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Enter your Earthdata Login username: deanh808\n", + "Enter your Earthdata password: ········\n" + ] + } + ], + "source": [ + "# 1. Authenticate with NASA Earthdata and dynamically fetch S3 credentials ------------------------------------------\n", + "earthaccess.login() # Uses your ~/.netrc file or environment variables if configured\n", + "ea_creds = earthaccess.get_s3_credentials(daac=\"PODAAC\")" + ] + }, + { + "cell_type": "markdown", + "id": "1517fc94-f258-4920-b3e1-91269aea2ef6", + "metadata": {}, + "source": [ + "The AWS S3 paths to the SASSIE ECCO icechunk stores are\n", + "\n", + "**Daily averages:**\n", + "\n", + "s3://podaac-ops-cumulus-public/virtual_collections/SASSIE_ECCO_V1R1/SASSIE_ECCO_L4_DAILY_V1R1_virtual_s3.icechunk/\n", + "\n", + "**Monthly snapshots:**\n", + "\n", + "s3://podaac-ops-cumulus-public/virtual_collections/SASSIE_ECCO_V1R1/SASSIE_ECCO_L4_SNAPSHOT_V1R1_virtual_s3.icechunk/" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a487df69-0502-4cec-930c-297b017f998a", + "metadata": {}, + "outputs": [], + "source": [ + "## 2. Get the icechunk store mapper ----------------------------------------------------------------------------------\n", + "s3path_store = \"s3://podaac-ops-cumulus-public/virtual_collections/SASSIE_ECCO_V1R1/SASSIE_ECCO_L4_DAILY_V1R1_virtual_s3.icechunk/\"\n", + "store = open_readonly_icechunkstore_s3(\n", + " s3path_store, \n", + " ea_creds, ea_creds, \n", + " bucket_data_chunks = \"s3://podaac-ops-cumulus-protected/\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "307180bf-277d-447a-b2d7-6c42fde93097", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/coiled/env/lib/python3.14/site-packages/zarr/codecs/numcodecs/_codecs.py:141: ZarrUserWarning: Numcodecs codecs are not in the Zarr version 3 specification and may not be supported by other zarr implementations.\n", + " super().__init__(**codec_config)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 828 ms, sys: 163 ms, total: 991 ms\n", + "Wall time: 1.58 s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 46TB\n",
+       "Dimensions:    (time: 2581, k_l: 90, j: 1080, i: 1800, i_g: 1800, j_g: 1080,\n",
+       "                k: 90, k_u: 90, nb: 4, k_p1: 91, nv: 2)\n",
+       "Coordinates: (12/23)\n",
+       "    XC         (j, i) float32 8MB dask.array<chunksize=(1080, 1800), meta=np.ndarray>\n",
+       "    XC_bnds    (j, i, nb) float32 31MB dask.array<chunksize=(1080, 1800, 4), meta=np.ndarray>\n",
+       "    YC         (j, i) float32 8MB dask.array<chunksize=(1080, 1800), meta=np.ndarray>\n",
+       "    XU         (j, i_g) float32 8MB dask.array<chunksize=(1080, 1800), meta=np.ndarray>\n",
+       "    YC_bnds    (j, i, nb) float32 31MB dask.array<chunksize=(1080, 1800, 4), meta=np.ndarray>\n",
+       "    YU         (j, i_g) float32 8MB dask.array<chunksize=(1080, 1800), meta=np.ndarray>\n",
+       "    ...         ...\n",
+       "  * j_g        (j_g) int32 4kB 0 1 2 3 4 5 6 ... 1074 1075 1076 1077 1078 1079\n",
+       "  * k_p1       (k_p1) int32 364B 0 1 2 3 4 5 6 7 8 ... 83 84 85 86 87 88 89 90\n",
+       "  * k_l        (k_l) int32 360B 0 1 2 3 4 5 6 7 8 ... 81 82 83 84 85 86 87 88 89\n",
+       "    time_bnds  (time, nv) datetime64[ns] 41kB dask.array<chunksize=(1, 2), meta=np.ndarray>\n",
+       "  * k_u        (k_u) int32 360B 0 1 2 3 4 5 6 7 8 ... 81 82 83 84 85 86 87 88 89\n",
+       "  * time       (time) datetime64[ns] 21kB 2014-01-15T12:00:00 ... 2021-02-07T...\n",
+       "Dimensions without coordinates: nb, nv\n",
+       "Data variables: (12/83)\n",
+       "    ADVr_SLT   (time, k_l, j, i) float32 2TB dask.array<chunksize=(1, 15, 270, 450), meta=np.ndarray>\n",
+       "    ADVr_TH    (time, k_l, j, i) float32 2TB dask.array<chunksize=(1, 15, 270, 450), meta=np.ndarray>\n",
+       "    ADVxHEFF   (time, j, i_g) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "    ADVxAREA   (time, j, i_g) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "    ADVyAREA   (time, j_g, i) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "    ADVx_SLT   (time, k, j, i_g) float32 2TB dask.array<chunksize=(1, 15, 270, 450), meta=np.ndarray>\n",
+       "    ...         ...\n",
+       "    oceQsw     (time, j, i) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "    oceTAUX    (time, j, i_g) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "    sIceLoad   (time, j, i) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "    oceFWflx   (time, j, i) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "    oceTAUY    (time, j_g, i) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "    oceQnet    (time, j, i) float32 20GB dask.array<chunksize=(1, 1080, 1800), meta=np.ndarray>\n",
+       "Attributes: (12/49)\n",
+       "    acknowledgement:                   This research was carried out by the J...\n",
+       "    author:                            Marie Zahn, Mike Wood, Ian Fenty, and ...\n",
+       "    cdm_data_type:                     Grid\n",
+       "    Conventions:                       CF-1.8, ACDD-1.3\n",
+       "    creator_email:                     marie.j.zahn@jpl.nasa.gov\n",
+       "    creator_institution:               NASA Jet Propulsion Laboratory (JPL)\n",
+       "    ...                                ...\n",
+       "    geospatial_vertical_min:           -7000.0\n",
+       "    geospatial_vertical_positive:      up\n",
+       "    geospatial_vertical_resolution:    variable\n",
+       "    geospatial_vertical_units:         meter\n",
+       "    identifier_product_doi:            https://doi.org/10.5067/SEL1D-DUG11\n",
+       "    date_created:                      2026-03-21T00:00:00Z
" + ], + "text/plain": [ + " Size: 46TB\n", + "Dimensions: (time: 2581, k_l: 90, j: 1080, i: 1800, i_g: 1800, j_g: 1080,\n", + " k: 90, k_u: 90, nb: 4, k_p1: 91, nv: 2)\n", + "Coordinates: (12/23)\n", + " XC (j, i) float32 8MB dask.array\n", + " XC_bnds (j, i, nb) float32 31MB dask.array\n", + " YC (j, i) float32 8MB dask.array\n", + " XU (j, i_g) float32 8MB dask.array\n", + " YC_bnds (j, i, nb) float32 31MB dask.array\n", + " YU (j, i_g) float32 8MB dask.array\n", + " ... ...\n", + " * j_g (j_g) int32 4kB 0 1 2 3 4 5 6 ... 1074 1075 1076 1077 1078 1079\n", + " * k_p1 (k_p1) int32 364B 0 1 2 3 4 5 6 7 8 ... 83 84 85 86 87 88 89 90\n", + " * k_l (k_l) int32 360B 0 1 2 3 4 5 6 7 8 ... 81 82 83 84 85 86 87 88 89\n", + " time_bnds (time, nv) datetime64[ns] 41kB dask.array\n", + " * k_u (k_u) int32 360B 0 1 2 3 4 5 6 7 8 ... 81 82 83 84 85 86 87 88 89\n", + " * time (time) datetime64[ns] 21kB 2014-01-15T12:00:00 ... 2021-02-07T...\n", + "Dimensions without coordinates: nb, nv\n", + "Data variables: (12/83)\n", + " ADVr_SLT (time, k_l, j, i) float32 2TB dask.array\n", + " ADVr_TH (time, k_l, j, i) float32 2TB dask.array\n", + " ADVxHEFF (time, j, i_g) float32 20GB dask.array\n", + " ADVxAREA (time, j, i_g) float32 20GB dask.array\n", + " ADVyAREA (time, j_g, i) float32 20GB dask.array\n", + " ADVx_SLT (time, k, j, i_g) float32 2TB dask.array\n", + " ... ...\n", + " oceQsw (time, j, i) float32 20GB dask.array\n", + " oceTAUX (time, j, i_g) float32 20GB dask.array\n", + " sIceLoad (time, j, i) float32 20GB dask.array\n", + " oceFWflx (time, j, i) float32 20GB dask.array\n", + " oceTAUY (time, j_g, i) float32 20GB dask.array\n", + " oceQnet (time, j, i) float32 20GB dask.array\n", + "Attributes: (12/49)\n", + " acknowledgement: This research was carried out by the J...\n", + " author: Marie Zahn, Mike Wood, Ian Fenty, and ...\n", + " cdm_data_type: Grid\n", + " Conventions: CF-1.8, ACDD-1.3\n", + " creator_email: marie.j.zahn@jpl.nasa.gov\n", + " creator_institution: NASA Jet Propulsion Laboratory (JPL)\n", + " ... ...\n", + " geospatial_vertical_min: -7000.0\n", + " geospatial_vertical_positive: up\n", + " geospatial_vertical_resolution: variable\n", + " geospatial_vertical_units: meter\n", + " identifier_product_doi: https://doi.org/10.5067/SEL1D-DUG11\n", + " date_created: 2026-03-21T00:00:00Z" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "\n", + "## 3. Open dataset ---------------------------------------------------------------------------------------------------\n", + "ds = xr.open_zarr(store, consolidated=False)\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "id": "c21297bd-71c8-4153-9aa1-8d34316d6731", + "metadata": {}, + "source": [ + "#### 4. Sample computations\n", + "\n", + "#### Map of salinity at a single depth and time" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a778944e-5699-4605-90df-d30e6eebf6c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.73 s, sys: 341 ms, total: 2.07 s\n", + "Wall time: 2.44 s\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "ds[\"SALT\"].isel(time=0, k=10).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "2ebd5a76-fbc8-449d-8626-ec18dd5e497b", + "metadata": {}, + "source": [ + "#### Time series of salinity at a single grid point and depth, over the entire record" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "097379df-5141-4cf7-be6e-68a7d5073582", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2min 7s, sys: 21.6 s, total: 2min 29s\n", + "Wall time: 3min 27s\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "ds[\"SALT\"].isel(i=600, j=600, k=10).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51603a02-b933-46cd-9808-0d9b322ea882", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 636146d7371ec02460dfaf0c38ad4e1327665991 Mon Sep 17 00:00:00 2001 From: henze Date: Thu, 7 May 2026 18:10:37 -0700 Subject: [PATCH 2/2] Fix typo in notebook header. Add link to notebook in sidebar. Add link to notebook in VDS chapter. --- _quarto.yml | 2 ++ notebooks/Advanced_cloud/open_icechunk.ipynb | 4 ++-- quarto_text/UsingVirtualDatasets.qmd | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/_quarto.yml b/_quarto.yml index 95319b76..bdbf0053 100644 --- a/_quarto.yml +++ b/_quarto.yml @@ -276,6 +276,8 @@ website: contents: - text: "Using VDS Starter Notebook" href: notebooks/Advanced_cloud/using_vds_starter.ipynb + - text: "Opening an Icechunk Store" + href: notebooks/Advanced_cloud/open_icechunk.ipynb - text: "Gulf of Tehuantepec Upwelling Example" href: notebooks/Advanced_cloud/GulfofTehuantepec_Ocean_Response.ipynb - text: "Virtualizarr Recipes" diff --git a/notebooks/Advanced_cloud/open_icechunk.ipynb b/notebooks/Advanced_cloud/open_icechunk.ipynb index efb301ad..7aa3dcd9 100644 --- a/notebooks/Advanced_cloud/open_icechunk.ipynb +++ b/notebooks/Advanced_cloud/open_icechunk.ipynb @@ -11,7 +11,7 @@ "\n", "This notebook demonstrates opening a virtual dataset (VDS) stored as an Icechunk store (note this technology is currently experimental, although it is gaining momentum). For a general overview of VDS's see the [Using Virutal Datasets chapter](https://podaac.github.io/tutorials/quarto_text/UsingVirtualDatasets.html) on the PO.DAAC Cookbook.\n", "\n", - "The example dataset(s) used here are from the SASSIE ECCO project (The e.g. the [User Guide](https://doi.org/10.5067/SEL1D-DUG11) with project overview). The ECCO model (Estimating the Circulation and Climate of the Ocean) was run over the arctic region over a seven year period in support of the SASSIE field experiment (Salinity and Stratification at the Sea Ice Edge). The SASSIE ECCO data are traditionally archived and available in netCDF format - one file per day(month) for the daily-mean(monthly-snapshot) datasets. The model output variables (totalling ~50 TBs) are large enough that they are spread out over 18 different netCDF datasets for the daily-means, and over 3 different datasets for the monthly-snapshots. One novel functionality of VDS's being tested here is the ability to combine the data across e.g. the 18 daily-mean datasets so users can interact with the data as if all variables were contained in a single dataset. Computing performance is TBD.\n", + "The example dataset(s) used here are from the SASSIE ECCO project (the [User Guide](https://doi.org/10.5067/SEL1D-DUG11) has a project overview). The ECCO model (Estimating the Circulation and Climate of the Ocean) was run over the arctic region over a seven year period in support of the SASSIE field experiment (Salinity and Stratification at the Sea Ice Edge). The SASSIE ECCO data are traditionally archived and available in netCDF format - one file per day(month) for the daily-mean(monthly-snapshot) datasets. The model output variables (totalling ~50 TBs) are large enough that they are spread out over 18 different netCDF datasets for the daily-means, and over 3 different datasets for the monthly-snapshots. One novel functionality of VDS's being tested here is the ability to combine the data across e.g. the 18 daily-mean datasets so users can interact with the data as if all variables were contained in a single dataset. Computing performance is TBD.\n", "\n", "The AWS S3 paths to the SASSIE ECCO icechunk stores are\n", "\n", @@ -12096,7 +12096,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.4" + "version": "3.13.5" } }, "nbformat": 4, diff --git a/quarto_text/UsingVirtualDatasets.qmd b/quarto_text/UsingVirtualDatasets.qmd index 7eaad807..cf5c485b 100644 --- a/quarto_text/UsingVirtualDatasets.qmd +++ b/quarto_text/UsingVirtualDatasets.qmd @@ -44,7 +44,7 @@ Summarizing the points above, and adding some additional ones, the benefits of V ### Using Virtual Datasets -To date we have explored accessing VDS’s programmatically via Jupyter notebooks, using the Xarray package for opening data. The quickest way to get up to speed with this method is to check out the [**starter notebook here**](../notebooks/Advanced_cloud/using_vds_starter.ipynb). **As with other access methods, you need an Earthdata Login account**. Other than that, the majority of the code to obtain credentials is boiler-plate and the only action item on the user is to find the VDS link for the dataset they want to use. Currently you can find the link using the table in the [Available Products](./UsingVirtualDatasets.html#available-products) section below. In the future, the links will be advertised on dataset landing pages and searchable in CMR metadata. +To date we have explored accessing VDS’s programmatically via Jupyter notebooks, using the Xarray package for opening data. The quickest way to get up to speed with this method is to check out the [**starter notebook**](../notebooks/Advanced_cloud/using_vds_starter.ipynb). For those looking to open a VDS in `icechunk` format, see the [**opening icechunk notebook**](../notebooks/Advanced_cloud/open_icechunk.ipynb) (currently in initial tests and only for in-cloud use). **As with other access methods, you need an Earthdata Login account**. Other than that, the majority of the code to obtain credentials is boiler-plate and the only action item on the user is to find the VDS link for the dataset they want to use. Currently you can find the link using the table in the [Available Products](./UsingVirtualDatasets.html#available-products) section below. In the future, the links will be advertised on dataset landing pages and searchable in CMR metadata. Additionally, the following notebook demonstrates using VDS’s for more involved computations: