diff --git a/python/examples/hrrr_hourly.ipynb b/python/examples/hrrr_hourly.ipynb new file mode 100644 index 0000000..2e14a6b --- /dev/null +++ b/python/examples/hrrr_hourly.ipynb @@ -0,0 +1,1936 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import fsspec\n", + "\n", + "fs_read = fsspec.filesystem('s3', anon=True, skip_instance_cache=True, use_ssl=False) # For now SSL false is solving my cert issues **shrug**\n", + "fs_write = fsspec.filesystem('')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read 49 HRRR files\n" + ] + } + ], + "source": [ + "hrr_hourly_member_files = fs_read.glob('s3://noaa-hrrr-bdp-pds/hrrr.20230722/conus/hrrr.t18z.wrfsfcf*.grib2')\n", + "\n", + "files = sorted(['s3://'+f for f in hrr_hourly_member_files])\n", + "print(f'Read {len(files)} HRRR files')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "import datetime\n", + "\n", + "def parse_model_run_datestamp_offset(key: str):\n", + " '''\n", + " Parse the model run forecast time key from the key of the file in the HRRR S3 bucket, given the HRRR naming convention: \n", + " 's3://noaa-hrrr-bdp-pds/hrrr.20230722/conus/hrrr.t12z.wrfsfcf01.grib2' \n", + " where the model_date is 20230315 and the model_hour is 00 and the offset is 1, this would result in a key of 20230315T01\n", + " '''\n", + " model_date, model_hour, offset = re.search(r'hrrr\\.(\\d{8})\\/conus\\/hrrr\\.t(\\d{2})z\\.wrfsfcf(\\d{2})', key).groups()\n", + " model_date = datetime.datetime.strptime(f'{model_date}T{model_hour}', '%Y%m%dT%H') + datetime.timedelta(hours=int(offset))\n", + " model_date_key = model_date.strftime('%Y%m%dT%H')\n", + " return model_date_key, int(offset)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import ujson\n", + "from gribberish.kerchunk import scan_gribberish\n", + "\n", + "so = {\"anon\": True, \"use_ssl\": False}\n", + "json_dir = 'hrrr_hourly/'\n", + "\n", + "def make_json_name(file_url, message_number): #create a unique name for each reference file\n", + " date, _ = parse_model_run_datestamp_offset(file_url)\n", + " name = file_url.split('/')[5].split('.')[0:3]\n", + " return f'{json_dir}{name[0]}_{date}_message{message_number}.json'\n", + "\n", + "def gen_json(file_url):\n", + " out = scan_gribberish(\n", + " file_url, \n", + " storage_options=so, \n", + " only_variables=['apcp', 'prate', 'cpofp', 'vis', 'tcdc', 'tmp', 'pres', 'ugrd', 'vgrd', 'dpt'], \n", + " skip=10,\n", + " filter_by_variable_attrs={\n", + " 'ugrd': {\n", + " 'statistical_process': '', \n", + " 'fixed_surface_value': '10',\n", + " }, \n", + " 'vgrd': {\n", + " 'statistical_process': '', \n", + " 'fixed_surface_value': '10',\n", + " }, \n", + " 'tmp': {\n", + " 'fixed_surface_type': 'ground or water surface',\n", + " }, \n", + " 'dpt': {\n", + " 'fixed_surface_type': 'specific height level above ground',\n", + " 'fixed_surface_value': '2'\n", + " },\n", + " 'tcdc': {\n", + " 'fixed_surface_value': 'entire atmosphere',\n", + " },\n", + " 'pres': {\n", + " 'fixed_surface_type': 'ground or water surface',\n", + " }\n", + " }\n", + " )\n", + " for i, message in enumerate(out):\n", + " out_file_name = make_json_name(file_url, i) # get name\n", + " with fs_write.open(out_file_name, \"w\") as f: \n", + " f.write(ujson.dumps(message)) # write to file" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from dask.distributed import Client, progress\n", + "\n", + "client = Client(processes=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "87038a6acb304d06b21141e5ab81a955", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "futures = client.map(gen_json, files[1:], retries=1)\n", + "progress(futures)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "client.shutdown()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 479 reference files\n" + ] + } + ], + "source": [ + "from kerchunk.combine import MultiZarrToZarr\n", + "\n", + "reference_jsons = sorted(fs_write.ls(json_dir)) #get list of file names\n", + "\n", + "print(f'Found {len(reference_jsons)} reference files')\n", + "\n", + "# combine individual references into single consolidated reference\n", + "mzz = MultiZarrToZarr(reference_jsons,\n", + " concat_dims = ['time'],\n", + " identical_dims=['x', 'y', 'latitude', 'longitude'])\n", + "\n", + "d = mzz.translate()\n", + "\n", + "with open(f'{json_dir}/hrrr_kerchunk.json', 'w') as f:\n", + " f.write(ujson.dumps(d))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:    (time: 48, y: 1059, x: 1799)\n",
+       "Coordinates:\n",
+       "    latitude   (y, x) float64 dask.array<chunksize=(1059, 1799), meta=np.ndarray>\n",
+       "    longitude  (y, x) float64 dask.array<chunksize=(1059, 1799), meta=np.ndarray>\n",
+       "  * time       (time) datetime64[s] 2023-07-22T19:00:00 ... 2023-07-24T18:00:00\n",
+       "  * x          (x) float64 -2.701e+06 -2.698e+06 ... 2.69e+06 2.693e+06\n",
+       "  * y          (y) float64 -1.581e+06 -1.578e+06 ... 1.59e+06 1.593e+06\n",
+       "Data variables:\n",
+       "    apcp       (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    cpofp      (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    dpt        (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    prate      (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    pres       (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    tmp        (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    ugrd       (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    vgrd       (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "    vis        (time, y, x) float64 dask.array<chunksize=(1, 1059, 1799), meta=np.ndarray>\n",
+       "Attributes:\n",
+       "    meta:     Generated with gribberishpy
" + ], + "text/plain": [ + "\n", + "Dimensions: (time: 48, y: 1059, x: 1799)\n", + "Coordinates:\n", + " latitude (y, x) float64 dask.array\n", + " longitude (y, x) float64 dask.array\n", + " * time (time) datetime64[s] 2023-07-22T19:00:00 ... 2023-07-24T18:00:00\n", + " * x (x) float64 -2.701e+06 -2.698e+06 ... 2.69e+06 2.693e+06\n", + " * y (y) float64 -1.581e+06 -1.578e+06 ... 1.59e+06 1.593e+06\n", + "Data variables:\n", + " apcp (time, y, x) float64 dask.array\n", + " cpofp (time, y, x) float64 dask.array\n", + " dpt (time, y, x) float64 dask.array\n", + " prate (time, y, x) float64 dask.array\n", + " pres (time, y, x) float64 dask.array\n", + " tmp (time, y, x) float64 dask.array\n", + " ugrd (time, y, x) float64 dask.array\n", + " vgrd (time, y, x) float64 dask.array\n", + " vis (time, y, x) float64 dask.array\n", + "Attributes:\n", + " meta: Generated with gribberishpy" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import xarray as xr\n", + "\n", + "# open dataset as zarr object using fsspec reference file system and xarray\n", + "fs = fsspec.filesystem(\"reference\", fo=f'./hrrr_hourly/hrrr_kerchunk.json', remote_protocol='s3', remote_options={'anon':True, 'use_ssl': False})\n", + "m = fs.get_mapper(\"\")\n", + "ds = xr.open_dataset(m, engine=\"zarr\", backend_kwargs=dict(consolidated=False), chunks={'time': 1})\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import pyproj\n", + "to_xy = pyproj.Transformer.from_crs('epsg:4326', ds.prate.crs, always_xy=True).transform\n", + "lat, lng = 41.42717976016072, -71.462122760827\n", + "x_sel, y_sel = to_xy(lng, lat)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "f, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "selected_ds = ds[['prate', 'apcp']].interp(x=x_sel, y=y_sel, method='linear')\n", + "\n", + "selected_prate = (selected_ds.prate * 3600) / 25.4 # convert from kg/m^2/s to in/hr\n", + "selected_apcp = (selected_ds.apcp) / 25.4 # convert from kg/m^2/s to in/hr\n", + "\n", + "ax.plot(selected_prate.time, selected_prate, label='prate')\n", + "ax.plot(selected_apcp.time, selected_apcp, label='apcp')\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "ROTCON_P = 0.622515\n", + "LON_XX_P = -97.5\n", + "LAT_TAN_P = 38.5\n", + "\n", + "angle2 = ROTCON_P*(ds.longitude-LON_XX_P)*0.017453\n", + "sinx2 = np.sin(angle2)\n", + "cosx2 = np.cos(angle2)\n", + "\n", + "un = cosx2 * ds.ugrd + sinx2 * ds.vgrd\n", + "vn = -sinx2 * ds.ugrd + cosx2 * ds.vgrd\n", + "\n", + "wind_speed = np.sqrt(un**2 + vn**2) * 2.23694 # convert from m/s to mph\n", + "# wind_dir = (270 - np.arctan2(vn, un) * 180 / np.pi) % 360\n", + "\n", + "wind_speed_ll = wind_speed.interp(x=x_sel, y=y_sel, method='linear')\n", + "# wind_dir_ll = wind_dir.interp(x=x_sel, y=y_sel, method='linear').isel(time=2)\n", + "\n", + "wind_speed_ll.plot()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env", + "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.9.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/examples/hrrr_hourly/hrrr_kerchunk.json b/python/examples/hrrr_hourly/hrrr_kerchunk.json new file mode 100644 index 0000000..f9c4c8f --- /dev/null +++ b/python/examples/hrrr_hourly/hrrr_kerchunk.json @@ -0,0 +1 @@ +{"version":1,"refs":{".zgroup":"{\"zarr_format\":2}","time\/.zarray":"{\n \"chunks\": [\n 48\n ],\n \"compressor\": null,\n \"dtype\": \"