diff --git a/.gitignore b/.gitignore index 07cf231..f6a385a 100644 --- a/.gitignore +++ b/.gitignore @@ -9,4 +9,5 @@ logs/* nohup.out *.pyc nexrad/__pycache__/ -.mypy_cache/ \ No newline at end of file +.mypy_cache/ +temp/ \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..d99f2f3 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,6 @@ +{ + "[python]": { + "editor.defaultFormatter": "ms-python.black-formatter" + }, + "python.formatting.provider": "none" +} \ No newline at end of file diff --git a/README.md b/README.md index 47e9f5c..3da911d 100644 --- a/README.md +++ b/README.md @@ -89,7 +89,7 @@ When you're just rapidly prototyping things, this lag time is annoying. To speed up, you can batch files like this: ```shell -snakemake all --use-conda --cores 1 --batch all=1/1000 +nohup snakemake /home/jd82/RDF/jd82/NEXRAD/2020-11.nc --use-conda --cores all --rerun-incomplete & ``` See [dealing with very large workflows](https://snakemake.readthedocs.io/en/stable/executing/cli.html#dealing-with-very-large-workflows) for more details. @@ -99,19 +99,19 @@ See [dealing with very large workflows](https://snakemake.readthedocs.io/en/stab If you just want to build the dataset, a good default command to use is ```shell -snakemake all --use-conda --cores all --rerun-incomplete --keep-going +nohup snakemake all --use-conda --cores all --rerun-incomplete --keep-going ``` Note: +* `nohup`: Keep running on a remote machine via `ssh`, even if the connection closes (see [`nohup`](https://www.computerhope.com/unix/unohup.htm) docs). * `use_conda`: use anaconda for environments -* `--cores 10`: use 10 cores (out of 12) +* `--cores all`: use all cores (workstation has 12) * `--rerun-incomplete`: reduces errors if a job was canceled earlier * `--keep-going`: if a file causes an error, don't give up If you are on a different machine you can learn about how many cores are available with the `lscpu` command. -If you are running on a remote machine via `ssh`, then prepending the command above with [`nohup`](https://www.computerhope.com/unix/unohup.htm) may be a good idea. In a nutshell, this will keep the process running even after you close your `ssh` session. ### Linters diff --git a/Snakefile b/Snakefile index 2ae8b64..1e2ff88 100644 --- a/Snakefile +++ b/Snakefile @@ -1,4 +1,4 @@ -from datetime import datetime +from datetime import datetime, timedelta import platform import os diff --git a/environment.yml b/environment.yml index 9108bb0..978ac4c 100644 --- a/environment.yml +++ b/environment.yml @@ -6,13 +6,18 @@ channels: dependencies: - python=3.10 # specify python version - black # clean code and make it pretty + - cartopy - dask # needed for open_mfdataset - - ipykernel # for playing around locally + - matplotlib - mypy # type checking + - netcdf4 + - pandas - pylint # catch errors before you make them - snakemake # workflow management engine - snakefmt # format snakefiles correctly - xarray # N-d labeled array library + - zstandard - pip # install local packages - pip: - -e . + - ipython diff --git a/era5/download_era5_pressure.py b/era5/download_era5_pressure.py index cde5745..02f8edb 100644 --- a/era5/download_era5_pressure.py +++ b/era5/download_era5_pressure.py @@ -44,25 +44,28 @@ def main() -> None: parser.add_argument("--latmax", type=float, default=CONUS[1][1]) args = parser.parse_args() - if args.year >= 1959: - dataset = "reanalysis-era5-pressure-levels" - else: - dataset = "reanalysis-era5-pressure-levels-preliminary-back-extension" + dataset = "reanalysis-era5-pressure-levels" + product_type = "reanalysis" + months = [f"{month:02d}" for month in range(1, 13)] # 01, 02, ..., 12 + days = [f"{day}" for day in np.arange(1, 32)] # 1, 2, ..., 31 + hours = [f"{hour:02d}:00" for hour in range(24)] # 00:00, 01:00, ... 23:00 + bbox = [args.latmax, args.lonmin, args.latmin, args.lonmax] + grid = [args.resolution, args.resolution] ecmwf_client = cdsapi.Client() ecmwf_client.retrieve( dataset, { - "product_type": "reanalysis", + "product_type": product_type, + "format": "netcdf", "variable": args.variable, - "pressure_level": args.pressure_level, + "pressure_level": [args.pressure_level], "year": [args.year], - "month": [f"{month:02d}" for month in range(1, 13)], - "day": [f"{day}" for day in np.arange(1, 31 + 1)], - "time": [f"{hour:02d}:00" for hour in range(24)], # 00:00, 01:00, ... 23:00 - "area": [args.latmax, args.lonmin, args.latmin, args.lonmax], - "format": "netcdf", - "grid": [args.resolution, args.resolution], + "month": months, + "day": days, + "time": hours, + "area": bbox, + "grid": grid, }, args.outfile, ) diff --git a/era5/download_era5_single_level.py b/era5/download_era5_single_level.py index 471252e..adff810 100644 --- a/era5/download_era5_single_level.py +++ b/era5/download_era5_single_level.py @@ -3,8 +3,8 @@ (defaults to CONUS). Storing one year of data in one file makes it easier to work with and more resilient to errors in downloading. -You need to specify the year, the output file name, and the variable. Optionally, specify -the domain. The default domain is CONUS. +You need to specify the year, the output file name, the variable, and the pressure level. +Optionally, specify the domain. The default domain is CONUS. The variable should follow the ERA5 documentation. Some common ones: - 2m_temperature @@ -33,9 +33,9 @@ def main() -> None: # parse command line arguments parser = argparse.ArgumentParser() - parser.add_argument("--year", type=int) parser.add_argument("-o", "--outfile", type=str) parser.add_argument("--variable", type=str) + parser.add_argument("--year", type=int) parser.add_argument("--resolution", type=float) parser.add_argument("--lonmin", type=float, default=CONUS[0][0]) parser.add_argument("--lonmax", type=float, default=CONUS[0][1]) @@ -43,24 +43,27 @@ def main() -> None: parser.add_argument("--latmax", type=float, default=CONUS[1][1]) args = parser.parse_args() - if args.year >= 1959: - dataset = "reanalysis-era5-single-levels" - else: - dataset = "reanalysis-era5-single-levels-preliminary-back-extension" + dataset = "reanalysis-era5-single-levels" + product_type = "reanalysis" + months = [f"{month:02d}" for month in range(1, 13)] # 01, 02, ..., 12 + days = [f"{day}" for day in np.arange(1, 32)] # 1, 2, ..., 31 + hours = [f"{hour:02d}:00" for hour in range(24)] # 00:00, 01:00, ... 23:00 + bbox = [args.latmax, args.lonmin, args.latmin, args.lonmax] + grid = [args.resolution, args.resolution] ecmwf_client = cdsapi.Client() ecmwf_client.retrieve( dataset, { - "product_type": "reanalysis", + "product_type": product_type, + "format": "netcdf", "variable": args.variable, "year": [args.year], - "month": [f"{month:02d}" for month in range(1, 13)], - "day": [f"{day}" for day in np.arange(1, 31 + 1)], - "time": [f"{hour:02d}:00" for hour in range(24)], # 00:00, 01:00, ... 23:00 - "area": [args.latmax, args.lonmin, args.latmin, args.lonmax], - "format": "netcdf", - "grid": [args.resolution, args.resolution], + "month": months, + "day": days, + "time": hours, + "area": bbox, + "grid": grid, }, args.outfile, ) diff --git a/era5/era5.smk b/era5/era5.smk index 9277f6f..b59b684 100644 --- a/era5/era5.smk +++ b/era5/era5.smk @@ -73,18 +73,19 @@ rule era5_single_level: era5_years = range(config["era5"]["first_year"], config["era5"]["last_year"] + 1) # specify the files to download -pressure_vars = config["era5"]["vars"]["pressure_level"] -pressure_files = [ - os.path.join(ERA5_DATA_DIR, "pressure_level", f"{var}_500_{year}.nc") - for year in era5_years - for var in pressure_vars -] # ugly hack, currently forcing 500hPa +pressure_files = [] +for year in era5_years: + for var in config["era5"]["vars"]["pressure_level"]: + varname = var["name"] + levels = var["levels"] + for level in levels: + pressure_files.append(os.path.join(ERA5_DATA_DIR, "pressure_level", f"{varname}_{level}_{year}.nc")) single_level_vars = config["era5"]["vars"]["single_level"] single_level_files = [ os.path.join(ERA5_DATA_DIR, "single_level", f"{var}_{year}.nc") for year in era5_years - for var in pressure_vars + for var in single_level_vars ] diff --git a/era5/era5_config.yml b/era5/era5_config.yml index 2c3488b..2e381dc 100644 --- a/era5/era5_config.yml +++ b/era5/era5_config.yml @@ -5,12 +5,16 @@ era5: latmin: 25 latmax: 50 resolution: 0.25 - first_year: 2015 + first_year: 1940 last_year: 2022 vars: pressure_level: - - u_component_of_wind - - v_component_of_wind + - name: u_component_of_wind + levels: + - 500 + - name: v_component_of_wind + levels: + - 500 single_level: - vertical_integral_of_eastward_water_vapour_flux - vertical_integral_of_northward_water_vapour_flux diff --git a/nexrad/demo.ipynb b/nexrad/demo.ipynb new file mode 100644 index 0000000..573322f --- /dev/null +++ b/nexrad/demo.ipynb @@ -0,0 +1,2116 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NEXRAD Demo\n", + "\n", + "This is a very crude demo of how to access the NEXRAD data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime, timedelta\n", + "import os\n", + "\n", + "import cartopy.crs as ccrs\n", + "from cartopy import feature\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import xarray as xr\n", + "\n", + "from util.nexrad.namingconventions import get_nc_fname" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we need to specify where the data is located.\n", + "Depending on how you mount the data directory, this may be different." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "RDF_DIR = \"/home/jd82/RDF/jd82\"\n", + "os.path.isdir(RDF_DIR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we specify the times we want to plot.\n", + "Let's look at Hurricane Harvey." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_73774/3502822580.py:3: FutureWarning: 'H' is deprecated and will be removed in a future version, please use 'h' instead.\n", + " t_all = pd.date_range(start=t_start, end=t_end, freq=\"H\")\n" + ] + } + ], + "source": [ + "t_start = datetime(2017, 8, 25, 0)\n", + "t_end = datetime(2017, 8, 30, 23)\n", + "t_all = pd.date_range(start=t_start, end=t_end, freq=\"H\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now leverage the built-in package to get the filename corresponding to each given hour time stamp" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "144" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_files = [get_nc_fname(t, dirname=os.path.join(RDF_DIR, \"NEXRAD\")) for t in t_all]\n", + "all_files = [f for f in all_files if os.path.isfile(f)]\n", + "len(all_files)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now read them all in using the power of xarray" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'precip_mm' (time: 144, alt: 1, lat: 3500, lon: 7000)> Size: 14GB\n",
+       "dask.array<concatenate, shape=(144, 1, 3500, 7000), dtype=float32, chunksize=(1, 1, 1, 7000), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 1kB 2017-08-25 ... 2017-08-30T23:00:00\n",
+       "  * lon      (lon) float64 56kB 230.0 230.0 230.0 230.0 ... 300.0 300.0 300.0\n",
+       "  * lat      (lat) float64 28kB 54.99 54.98 54.97 54.96 ... 20.02 20.01 20.0\n",
+       "  * alt      (alt) float64 8B 0.0\n",
+       "Attributes:\n",
+       "    param:    9.6.209
" + ], + "text/plain": [ + " Size: 14GB\n", + "dask.array\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 1kB 2017-08-25 ... 2017-08-30T23:00:00\n", + " * lon (lon) float64 56kB 230.0 230.0 230.0 230.0 ... 300.0 300.0 300.0\n", + " * lat (lat) float64 28kB 54.99 54.98 54.97 54.96 ... 20.02 20.01 20.0\n", + " * alt (alt) float64 8B 0.0\n", + "Attributes:\n", + " param: 9.6.209" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = xr.open_mfdataset(all_files).rename({\"param9.6.209\": \"precip_mm\"})[\"precip_mm\"]\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We don't need to look at all of CONUS, a small area is fine" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'precip_mm' (time: 144, alt: 1, lat: 2000, lon: 2000)> Size: 2GB\n",
+       "dask.array<getitem, shape=(144, 1, 2000, 2000), dtype=float32, chunksize=(1, 1, 1, 2000), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 1kB 2017-08-25 ... 2017-08-30T23:00:00\n",
+       "  * lon      (lon) float64 16kB 255.0 255.0 255.0 255.0 ... 275.0 275.0 275.0\n",
+       "  * lat      (lat) float64 16kB 39.99 39.98 39.97 39.96 ... 20.02 20.01 20.0\n",
+       "  * alt      (alt) float64 8B 0.0\n",
+       "Attributes:\n",
+       "    param:    9.6.209
" + ], + "text/plain": [ + " Size: 2GB\n", + "dask.array\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 1kB 2017-08-25 ... 2017-08-30T23:00:00\n", + " * lon (lon) float64 16kB 255.0 255.0 255.0 255.0 ... 275.0 275.0 275.0\n", + " * lat (lat) float64 16kB 39.99 39.98 39.97 39.96 ... 20.02 20.01 20.0\n", + " * alt (alt) float64 8B 0.0\n", + "Attributes:\n", + " param: 9.6.209" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tx_precip = ds.sel(lon=slice(255, 275), lat=slice(40, 20))\n", + "tx_precip" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's convert the daily data to hourly data.\n", + "Note the `.compute()` command, which forces the computer to read the actual data, rather than just the metadata (which is what it does by default).\n", + "This may take a while since the RDF is surprisngly slow!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'precip_mm' (date: 6, alt: 1, lat: 2000, lon: 2000)> Size: 96MB\n",
+       "array([[[[ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         ...,\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ]]],\n",
+       "\n",
+       "\n",
+       "       [[[ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "...\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ]]],\n",
+       "\n",
+       "\n",
+       "       [[[ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         ...,\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ],\n",
+       "         [ 0.       ,  0.       ,  0.       , ...,  0.       ,\n",
+       "           0.       ,  0.       ]]]], dtype=float32)\n",
+       "Coordinates:\n",
+       "  * lon      (lon) float64 16kB 255.0 255.0 255.0 255.0 ... 275.0 275.0 275.0\n",
+       "  * lat      (lat) float64 16kB 39.99 39.98 39.97 39.96 ... 20.02 20.01 20.0\n",
+       "  * alt      (alt) float64 8B 0.0\n",
+       "  * date     (date) object 48B 2017-08-25 2017-08-26 ... 2017-08-29 2017-08-30\n",
+       "Attributes:\n",
+       "    param:    9.6.209
" + ], + "text/plain": [ + " Size: 96MB\n", + "array([[[[ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " ...,\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ]]],\n", + "\n", + "\n", + " [[[ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + "...\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ]]],\n", + "\n", + "\n", + " [[[ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " ...,\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ]]]], dtype=float32)\n", + "Coordinates:\n", + " * lon (lon) float64 16kB 255.0 255.0 255.0 255.0 ... 275.0 275.0 275.0\n", + " * lat (lat) float64 16kB 39.99 39.98 39.97 39.96 ... 20.02 20.01 20.0\n", + " * alt (alt) float64 8B 0.0\n", + " * date (date) object 48B 2017-08-25 2017-08-26 ... 2017-08-29 2017-08-30\n", + "Attributes:\n", + " param: 9.6.209" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "daily_precip = tx_precip.groupby(\"time.date\").sum().compute()\n", + "daily_precip" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can plot it using xarray's [built-in plotting](https://docs.xarray.dev/en/latest/user-guide/plotting.html#maps) to visualize" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = daily_precip.plot(\n", + " col=\"date\",\n", + " col_wrap=3,\n", + " subplot_kws=dict(projection=ccrs.PlateCarree()),\n", + " transform=ccrs.PlateCarree(),\n", + ")\n", + "\n", + "for ax in p.axs.flat:\n", + " ax.coastlines()\n", + " ax.add_feature(feature.STATES)\n", + "\n", + "plt.draw()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "climatedata", + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/nexrad/nexrad.smk b/nexrad/nexrad.smk index cb56c5a..4b0e872 100644 --- a/nexrad/nexrad.smk +++ b/nexrad/nexrad.smk @@ -1,19 +1,38 @@ +import os +from datetime import timedelta, datetime +import pandas as pd + # Use our local package from util.nexrad.nexrad import TimeRange from util.nexrad.const import GAUGECORR_BEGINTIME, MISSING_SNAPSHOTS -from util.nexrad.namingconventions import get_nc_fname, fname2url +from util.nexrad.namingconventions import get_nc_fname, fname2url, get_fname_base # Define directories -NEXRAD_DATA_DIR = os.path.join(DATADIR, "nexrad") +NEXRAD_DATA_DIR = os.path.join(DATADIR, "NEXRAD") NEXRAD_SRC_DIR = os.path.join(HOMEDIR, "nexrad") # this folder +NEXRAD_TEMP_DIR = os.path.join(HOMEDIR, "temp", "nexrad") # a temp folder - -# Define the configuration file -# configfile: os.path.join(NEXRAD_SRC_DIR, "nexrad_config.yaml") +# Define the time range to access +current_date = datetime.now().date() +ENDTIME = datetime.combine(current_date - timedelta(days=10), datetime.min.time()) + timedelta(hours=23) +trange = TimeRange(GAUGECORR_BEGINTIME, ENDTIME) +t_nonmissing = [t for t in trange.dts if t not in MISSING_SNAPSHOTS] -# Define the time range to access -trange = TimeRange(GAUGECORR_BEGINTIME, datetime(2023, 5, 31, 23)) +# creates a (temporary) grib2 file for each date-time +# the filename is temporary, so the grib2 file is deleted once the netcdf file is created +# first downloads using curl, then unzips using gunzip +rule download_unzip: + output: + os.path.join(NEXRAD_TEMP_DIR, "{fname}.grib2"), + conda: + os.path.join(NEXRAD_SRC_DIR, "download_unzip.yml") + params: + url=lambda wildcards: fname2url(wildcards.fname), + log: + os.path.join(LOGS, "download_unzip", "{fname}.log"), + shell: + "curl -L {params.url} | gunzip > {output}" # this rule convert grib to netcdf @@ -23,41 +42,22 @@ trange = TimeRange(GAUGECORR_BEGINTIME, datetime(2023, 5, 31, 23)) # setctomiss,-3 sets all values of -3 to missing rule grib2_to_nc: input: - os.path.join(NEXRAD_DATA_DIR, "temp", "{fname}.grib2"), # any grib2 file in + os.path.join(NEXRAD_TEMP_DIR, "{fname}.grib2"), output: - os.path.join(NEXRAD_DATA_DIR, "{fname}.nc"), # creates a netcdf file + os.path.join(NEXRAD_DATA_DIR, "{fname}.nc"), conda: os.path.join(NEXRAD_SRC_DIR, "grib2_to_nc.yml") log: os.path.join(LOGS, "grib2_to_nc", "{fname}.log"), shell: - "cdo -r -f nc4 -z zip_1 setctomiss,-3 -copy {input} {output}" - - -# creates a (temporarte) grib2 file for each date-time -# the filename is temporary, so the grib2 file is deleted once the netcdf file is created -# first downloads using curl, then unzips using gunzip -rule download_unzip: - output: - temp(os.path.join(NEXRAD_DATA_DIR, "temp", "{fname}.grib2")), - conda: - os.path.join(NEXRAD_SRC_DIR, "download_unzip.yml") - params: - url=lambda wildcards: fname2url(wildcards.fname), - log: - os.path.join(LOGS, "download_unzip", "{fname}.log"), - shell: - "curl -L {params.url} | gunzip > {output}" + "cdo -r -f nc4 setctomiss,-3 -copy {input} {output}" # a list of all the filenames for which there is data all_nexrad_nc_files = [ - get_nc_fname(dt=dti, dirname=NEXRAD_DATA_DIR) - for dti in trange.dts - if dti not in MISSING_SNAPSHOTS + get_nc_fname(dt, dirname=NEXRAD_DATA_DIR) for dt in t_nonmissing ] - rule nexrad: input: all_nexrad_nc_files, diff --git a/nexrad/nexrad_config.yml b/nexrad/nexrad_config.yml index e69de29..b49ffcd 100644 --- a/nexrad/nexrad_config.yml +++ b/nexrad/nexrad_config.yml @@ -0,0 +1,6 @@ +bounding_boxes: + - name: "Houston_Woodlands_Galveston" + lon_min: -96.0 + lon_max: -94.5 + lat_min: 28.5 + lat_max: 30.5 diff --git a/util/nexrad/const.py b/util/nexrad/const.py index 99db58c..572a939 100644 --- a/util/nexrad/const.py +++ b/util/nexrad/const.py @@ -110,6 +110,9 @@ datetime(2021, 9, 16, 20), datetime(2021, 9, 16, 21), datetime(2021, 9, 16, 22), + datetime(2024, 3, 17, 22), + datetime(2024, 3, 18, 22), + datetime(2024, 3, 19, 22), ] diff --git a/util/nexrad/namingconventions.py b/util/nexrad/namingconventions.py index 21060f2..0750829 100644 --- a/util/nexrad/namingconventions.py +++ b/util/nexrad/namingconventions.py @@ -28,9 +28,16 @@ def get_fname_base(dt: datetime, dirname: str = None) -> str: """ varname = get_varname(dt) dt_str = dt.strftime(DT_FORMAT) - fname = f"{varname}_00.00_{dt_str}" + dt_year = dt.strftime("%Y") + dt_month = dt.strftime("%m") + dt_day = dt.strftime("%d") + dt_fname = f"{varname}_00.00_{dt_str}" + + # Generate the nested path + fname = os.path.join(dt_year, dt_month, dt_day, dt_fname) if dirname: fname = os.path.join(dirname, fname) + return fname @@ -61,6 +68,10 @@ def get_url(dt: datetime) -> str: """ date_str = dt.strftime("%Y/%m/%d") fname = get_gz_fname(dt) + + # drop the folder structure + fname = fname.split("/")[-1] + varname = get_varname(dt) return f"https://mtarchive.geol.iastate.edu/{date_str}/mrms/ncep/{varname}/{fname}" @@ -69,7 +80,13 @@ def fname2dt(fname: str) -> datetime: """ Parse a filename to get the corresponding datetime """ - dt_str = fname.split("_00.00_")[1].split(".")[0] + # Extract the filename part, ignoring the directory structure + basename = os.path.basename(fname) + + # Extract the datetime string from the basename + dt_str = basename.split("_00.00_")[1].split(".")[0] + + # Parse the datetime string to a datetime object return datetime.strptime(dt_str, DT_FORMAT)