From 0b2493895906c980e17a1c4df7ec60711c0f8478 Mon Sep 17 00:00:00 2001 From: "Branson, Paul (O&A, IOMRC Crawley)" Date: Mon, 5 Jul 2021 19:42:55 +1000 Subject: [PATCH 1/2] fix order of datasets --- rompy/intake.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rompy/intake.py b/rompy/intake.py index e17e98c3..31658675 100644 --- a/rompy/intake.py +++ b/rompy/intake.py @@ -151,7 +151,7 @@ def _open_dataset(self): futures = [__open_preprocess(url,self.chunks,self.ds_filters,self.xarray_kwargs) for url in self.urlpath] dsets = compute(*futures,traverse=False) if len(dsets[0].lead) == 1: # Assumes this indicates that each timestep of forecase is separate file - inits = [to_datetime(ds.init.values[0]) for ds in dsets] + inits = sorted([to_datetime(ds.init.values[0]) for ds in dsets]) dsets_concat = [] for i in set(inits): subset = [ds for ds in dsets if ds.init.values[0] == i] From 004eaad3ca5900ffda3a98c5d639a8a8ab86947b Mon Sep 17 00:00:00 2001 From: "Branson, Paul (O&A, IOMRC Crawley)" Date: Mon, 9 Aug 2021 18:58:05 +1000 Subject: [PATCH 2/2] fix walk_server, organise notebook naming --- ...e.ipynb => catalog_advanced_BOM_WW3.ipynb} | 0 ...atalogs.ipynb => catalog_basic_AODN.ipynb} | 0 notebooks/catalog_basic_CSIRO_SWAN.ipynb | 415 ++++++++++++++++++ ...example.ipynb => model_swan_example.ipynb} | 0 rompy/utils.py | 10 +- 5 files changed, 422 insertions(+), 3 deletions(-) rename notebooks/{advanced_catalog_use.ipynb => catalog_advanced_BOM_WW3.ipynb} (100%) rename notebooks/{aodn_catalogs.ipynb => catalog_basic_AODN.ipynb} (100%) create mode 100644 notebooks/catalog_basic_CSIRO_SWAN.ipynb rename notebooks/{swan_model_example.ipynb => model_swan_example.ipynb} (100%) diff --git a/notebooks/advanced_catalog_use.ipynb b/notebooks/catalog_advanced_BOM_WW3.ipynb similarity index 100% rename from notebooks/advanced_catalog_use.ipynb rename to notebooks/catalog_advanced_BOM_WW3.ipynb diff --git a/notebooks/aodn_catalogs.ipynb b/notebooks/catalog_basic_AODN.ipynb similarity index 100% rename from notebooks/aodn_catalogs.ipynb rename to notebooks/catalog_basic_AODN.ipynb diff --git a/notebooks/catalog_basic_CSIRO_SWAN.ipynb b/notebooks/catalog_basic_CSIRO_SWAN.ipynb new file mode 100644 index 00000000..c3e6f082 --- /dev/null +++ b/notebooks/catalog_basic_CSIRO_SWAN.ipynb @@ -0,0 +1,415 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "confident-plate", + "metadata": {}, + "source": [ + "# Demonstrate access to individual simulations via the Intake catalog" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "difficult-recommendation", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import rompy\n", + "import xarray as xr\n", + "\n", + "xr.set_options(display_style='text')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "major-winner", + "metadata": {}, + "outputs": [], + "source": [ + "cat = rompy.cat" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "charitable-kitty", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'swan_perth_fc.map': name: map\n", + " container: xarray\n", + " plugin: ['netcdf']\n", + " driver: ['netcdf']\n", + " description: SWAN Maps output\n", + " direct_access: forbid\n", + " user_parameters: [{'name': 'fcdate', 'description': 'Forecast date', 'type': 'datetime', 'default': Timestamp('2021-02-03 00:00:00')}]\n", + " metadata: \n", + " plots: \n", + " hs: \n", + " title: Significant wave height\n", + " kind: quadmesh\n", + " x: longitude\n", + " y: latitude\n", + " z: hs\n", + " groupby: time\n", + " cmap: rainbow\n", + " projection: PlateCarree\n", + " width: 600\n", + " height: 600\n", + " dynamic: True\n", + " rasterize: True\n", + " args: \n", + " chunks: \n", + " time: 24\n", + " urlpath: {{ CATALOG_DIR.replace(\"fileServer\",\"dodsC\") }}/{{fcdate.strftime(\"%Y%m%d.000000\")}}/swan_out.nc,\n", + " 'swan_perth_fc.table': name: table\n", + " container: xarray\n", + " plugin: ['netcdf']\n", + " driver: ['netcdf']\n", + " description: SWAN Table output\n", + " direct_access: forbid\n", + " user_parameters: [{'name': 'fcdate', 'description': 'Forecast date', 'type': 'datetime', 'default': Timestamp('2021-02-03 00:00:00')}]\n", + " metadata: \n", + " plots: \n", + " hs: \n", + " title: Significant wave height\n", + " kind: line\n", + " x: time\n", + " y: hs\n", + " groupby: points\n", + " width: 600\n", + " height: 600\n", + " args: \n", + " chunks: \n", + " urlpath: {{ CATALOG_DIR.replace(\"fileServer\",\"dodsC\") }}/{{fcdate.strftime(\"%Y%m%d.000000\")}}/tab_out.nc,\n", + " 'swan_perth_fc.spectra': name: spectra\n", + " container: xarray\n", + " plugin: ['netcdf']\n", + " driver: ['netcdf']\n", + " description: SWAN Spectra output\n", + " direct_access: forbid\n", + " user_parameters: [{'name': 'fcdate', 'description': 'Forecast date', 'type': 'datetime', 'default': Timestamp('2021-02-03 00:00:00')}]\n", + " metadata: \n", + " args: \n", + " chunks: \n", + " points: 1\n", + " urlpath: {{ CATALOG_DIR.replace(\"fileServer\",\"dodsC\") }}/{{fcdate.strftime(\"%Y%m%d.000000\")}}/spec_out.nc,\n", + " 'swan_perth_fc': name: swan_perth_fc\n", + " container: catalog\n", + " plugin: ['yaml_file_cat']\n", + " driver: ['yaml_file_cat']\n", + " description: \n", + " direct_access: forbid\n", + " user_parameters: []\n", + " metadata: \n", + " args: \n", + " path: {{ CATALOG_DIR }}/swan_perth_fc/intake.yaml,\n", + " 'swan_mandurah_fc.map': name: map\n", + " container: xarray\n", + " plugin: ['netcdf']\n", + " driver: ['netcdf']\n", + " description: SWAN Maps output\n", + " direct_access: forbid\n", + " user_parameters: [{'name': 'fcdate', 'description': 'Forecast date', 'type': 'datetime', 'default': Timestamp('2021-02-03 00:00:00')}]\n", + " metadata: \n", + " plots: \n", + " hs: \n", + " title: Significant wave height\n", + " kind: quadmesh\n", + " x: longitude\n", + " y: latitude\n", + " z: hs\n", + " groupby: time\n", + " cmap: rainbow\n", + " projection: PlateCarree\n", + " width: 600\n", + " height: 600\n", + " dynamic: True\n", + " rasterize: True\n", + " args: \n", + " chunks: \n", + " time: 24\n", + " xc: 500\n", + " yc: 500\n", + " urlpath: {{ CATALOG_DIR.replace(\"fileServer\",\"dodsC\") }}/{{fcdate.strftime(\"%Y%m%d.000000\")}}/swan_out.nc,\n", + " 'swan_mandurah_fc.table': name: table\n", + " container: xarray\n", + " plugin: ['netcdf']\n", + " driver: ['netcdf']\n", + " description: SWAN Table output\n", + " direct_access: forbid\n", + " user_parameters: [{'name': 'fcdate', 'description': 'Forecast date', 'type': 'datetime', 'default': Timestamp('2021-02-03 00:00:00')}]\n", + " metadata: \n", + " plots: \n", + " hs: \n", + " title: Significant wave height\n", + " kind: line\n", + " x: time\n", + " y: hs\n", + " groupby: points\n", + " width: 600\n", + " height: 600\n", + " args: \n", + " chunks: \n", + " urlpath: {{ CATALOG_DIR.replace(\"fileServer\",\"dodsC\") }}/{{fcdate.strftime(\"%Y%m%d.000000\")}}/tab_out.nc,\n", + " 'swan_mandurah_fc.spectra': name: spectra\n", + " container: xarray\n", + " plugin: ['netcdf']\n", + " driver: ['netcdf']\n", + " description: SWAN Spectra output\n", + " direct_access: forbid\n", + " user_parameters: [{'name': 'fcdate', 'description': 'Forecast date', 'type': 'datetime', 'default': Timestamp('2021-02-03 00:00:00')}]\n", + " metadata: \n", + " args: \n", + " chunks: \n", + " points: 1\n", + " time: 24\n", + " urlpath: {{ CATALOG_DIR.replace(\"fileServer\",\"dodsC\") }}/{{fcdate.strftime(\"%Y%m%d.000000\")}}/spec_out.nc,\n", + " 'swan_mandurah_fc': name: swan_mandurah_fc\n", + " container: catalog\n", + " plugin: ['yaml_file_cat']\n", + " driver: ['yaml_file_cat']\n", + " description: \n", + " direct_access: forbid\n", + " user_parameters: []\n", + " metadata: \n", + " args: \n", + " path: {{ CATALOG_DIR }}/swan_mandurah_fc/intake.yaml}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cat.csiro.swan.walk()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "controlling-drain", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ds=cat.csiro.swan.swan_perth_fc.spectra(fcdate='2021-07-08').to_dask()\n", + "ds.hs.isel(points=100).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8c70773-6fdd-4852-a245-ae7f68460978", + "metadata": {}, + "outputs": [], + "source": [ + "import geoviews as gv\n", + "gv.extension('bokeh')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acknowledged-atlas", + "metadata": {}, + "outputs": [], + "source": [ + "cat.csiro.swan.swan_perth_fc.map(fcdate='2021-07-08').hvplot.hs()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "prostate-pearl", + "metadata": {}, + "outputs": [], + "source": [ + "import wavespectra as ws" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "diagnostic-circumstances", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
<xarray.Dataset>\n",
+       "Dimensions:  (dir: 36, freq: 32, site: 438, time: 121)\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 2021-07-08 2021-07-08T01:00:00 ... 2021-07-13\n",
+       "  * freq     (freq) float32 0.0464 0.05123 0.05657 0.06245 ... 0.8203 0.9057 1.0\n",
+       "  * dir      (dir) float32 265.0 255.0 245.0 235.0 ... 305.0 295.0 285.0 275.0\n",
+       "  * site     (site) int64 1 2 3 4 5 6 7 8 9 ... 431 432 433 434 435 436 437 438\n",
+       "Data variables:\n",
+       "    lon      (site) float32 dask.array<chunksize=(1,), meta=np.ndarray>\n",
+       "    lat      (site) float32 dask.array<chunksize=(1,), meta=np.ndarray>\n",
+       "    efth     (time, site, freq, dir) float32 dask.array<chunksize=(121, 1, 32, 36), meta=np.ndarray>\n",
+       "    dpt      (time, site) float32 dask.array<chunksize=(121, 1), meta=np.ndarray>\n",
+       "    wspd     (time, site) float32 dask.array<chunksize=(121, 1), meta=np.ndarray>\n",
+       "    wdir     (time, site) float32 dask.array<chunksize=(121, 1), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    Conventions:                     CF-1.5\n",
+       "    History:                         Created with agioncmd version 1.5\n",
+       "    Directional_convention:          nautical\n",
+       "    project:                         SWAN\n",
+       "    model:                           41.31\n",
+       "    run:                             \n",
+       "    DODS_EXTRA.Unlimited_Dimension:  time
" + ], + "text/plain": [ + "\n", + "Dimensions: (dir: 36, freq: 32, site: 438, time: 121)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 2021-07-08 2021-07-08T01:00:00 ... 2021-07-13\n", + " * freq (freq) float32 0.0464 0.05123 0.05657 0.06245 ... 0.8203 0.9057 1.0\n", + " * dir (dir) float32 265.0 255.0 245.0 235.0 ... 305.0 295.0 285.0 275.0\n", + " * site (site) int64 1 2 3 4 5 6 7 8 9 ... 431 432 433 434 435 436 437 438\n", + "Data variables:\n", + " lon (site) float32 dask.array\n", + " lat (site) float32 dask.array\n", + " efth (time, site, freq, dir) float32 dask.array\n", + " dpt (time, site) float32 dask.array\n", + " wspd (time, site) float32 dask.array\n", + " wdir (time, site) float32 dask.array\n", + "Attributes:\n", + " Conventions: CF-1.5\n", + " History: Created with agioncmd version 1.5\n", + " Directional_convention: nautical\n", + " project: SWAN\n", + " model: 41.31\n", + " run: \n", + " DODS_EXTRA.Unlimited_Dimension: time" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds_ws = ws.read_dataset(ds)\n", + "ds_ws" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "downtown-barrier", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/srv/conda/envs/notebook/lib/python3.8/site-packages/xarray/plot/utils.py:444: MatplotlibDeprecationWarning: Calling gca() with keyword arguments was deprecated in Matplotlib 3.4. Starting two minor releases later, gca() will take no keyword arguments. The gca() function should only be used to get the current axes, or if no axes exist, create new axes with default keyword arguments. To create a new axes with non-default arguments, use plt.axes() or plt.subplot().\n", + " ax = plt.gca(**kwargs)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ds_ws.isel(site=10,time=5).spec.plot(as_period=True,cmap='viridis')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "romance-judgment", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "operating-indianapolis", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/swan_model_example.ipynb b/notebooks/model_swan_example.ipynb similarity index 100% rename from notebooks/swan_model_example.ipynb rename to notebooks/model_swan_example.ipynb diff --git a/rompy/utils.py b/rompy/utils.py index 54e786b3..b67ca027 100644 --- a/rompy/utils.py +++ b/rompy/utils.py @@ -21,11 +21,9 @@ def dict_product(d): yield dict(zip(keys, element)) def walk_server(urlpath, fn_fmt, fmt_fields, url_replace): - from os.path import dirname from functools import reduce from operator import iconcat from dask import delayed, compute - import dask.config as dc # Targetted scans of the file system based on date range test_urls = set([urlpath.format(**pv) for pv in dict_product(fmt_fields)]) @@ -37,12 +35,16 @@ def walk_server(urlpath, fn_fmt, fmt_fields, url_replace): def check_url(test_url,test_fns): from fsspec import filesystem from fsspec.utils import get_protocol + from os.path import dirname fs = filesystem(get_protocol(test_url)) logger.debug(f'testing {test_url}') urls = [] if fs.exists(test_url): for url, _ , links in fs.walk(test_url): - urls += [dirname(url) + '/' + fn for fn in links if fn in test_fns] + # test for case that url is a local directory, otherwise likely a http url + if fs.isfile(url): + url = dirname(url) + urls += [url + '/' + fn for fn in links if fn in test_fns] return urls valid_urls = compute(*[check_url(test_url,test_fns) for test_url in test_urls], @@ -55,6 +57,8 @@ def check_url(test_url,test_fns): for f,r in url_replace.items(): valid_urls = [u.replace(f,r) for u in valid_urls] + + logger.debug(f'valid_urls after replace : {valid_urls}') return valid_urls