diff --git a/examples/images/model_sounding_preview.png b/examples/images/model_sounding_preview.png new file mode 100644 index 0000000..1a14dd4 Binary files /dev/null and b/examples/images/model_sounding_preview.png differ diff --git a/examples/notebooks/Model_Sounding_Data.ipynb b/examples/notebooks/Model_Sounding_Data.ipynb index 499a897..a8af594 100644 --- a/examples/notebooks/Model_Sounding_Data.ipynb +++ b/examples/notebooks/Model_Sounding_Data.ipynb @@ -4,48 +4,129 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The EDEX modelsounding plugin creates 64-level vertical profiles from GFS and ETA (NAM) BUFR products distirubted over NOAAport. Paramters which are requestable are **pressure**, **temperature**, **specHum**, **uComp**, **vComp**, **omega**, **cldCvr**." + "\n", + "
\n", + "\n", + "
\n", + "\"Unidata\n", + "
\n", + "\n", + "# Model Sounding Data\n", + "**Python-AWIPS Tutorial Notebook**\n", + "\n", + "
\n", + "
\n", + "\n", + "---\n", + "\n", + "
\"preview
\n", + "\n", + "\n", + "# Objectives\n", + "\n", + "* Use python-awips to connect to an edex server\n", + "* Define and filter data request for model sounding data\n", + "* Create vertical profiles from GFS BUFR products\n", + "* Use MetPy to create [SkewT](https://unidata.github.io/MetPy/latest/api/generated/metpy.plots.SkewT.html) and [Hodograph](https://unidata.github.io/MetPy/latest/api/generated/metpy.plots.Hodograph.html) plots\n", + "\n", + "---" ] }, { - "cell_type": "code", - "execution_count": 1, + "cell_type": "markdown", "metadata": { - "scrolled": true + "toc": true }, - "outputs": [], "source": [ - "from awips.dataaccess import DataAccessLayer\n", - "import matplotlib.tri as mtri\n", - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n", - "from math import exp, log\n", - "import numpy as np\n", - "from metpy.calc import wind_components, lcl, dry_lapse, parcel_profile, dewpoint\n", - "from metpy.calc import wind_speed, wind_direction, thermo, vapor_pressure\n", - "from metpy.plots import SkewT, Hodograph\n", - "from metpy.units import units, concatenate\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\",category =RuntimeWarning)\n", - "\n", - "DataAccessLayer.changeEDEXHost(\"edex-cloud.unidata.ucar.edu\")\n", - "request = DataAccessLayer.newDataRequest(\"modelsounding\")\n", - "forecastModel = \"GFS\"\n", - "request.addIdentifier(\"reportType\", forecastModel)\n", - "request.setParameters(\"pressure\",\"temperature\",\"specHum\",\"uComp\",\"vComp\",\"omega\",\"cldCvr\")" + "

Table of Contents

\n", + "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Available Locations" + "## Imports\n", + "\n", + "The imports below are used throughout the notebook. Note the first import is coming directly from python-awips and allows us to connect to an EDEX server. The subsequent imports are for data manipulation and visualization. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from awips.dataaccess import DataAccessLayer\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n", + "from math import exp, log\n", + "import numpy as np\n", + "from metpy.calc import dewpoint, vapor_pressure, wind_speed, wind_direction\n", + "from metpy.plots import SkewT, Hodograph\n", + "from metpy.units import units" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Top\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## EDEX Connection\n", + "\n", + "First we establish a connection to Unidata's public EDEX server. With that connection made, we can create a [new data request object](http://unidata.github.io/python-awips/api/IDataRequest.html) and set the data type to ***modelsounding***, and define additional parameters and an identifier on the request." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, + "outputs": [], + "source": [ + "DataAccessLayer.changeEDEXHost(\"edex-cloud.unidata.ucar.edu\")\n", + "request = DataAccessLayer.newDataRequest(\"modelsounding\")\n", + "forecastModel = \"GFS\"\n", + "request.addIdentifier(\"reportType\", forecastModel)\n", + "request.setParameters(\"pressure\",\"temperature\",\"specHum\",\"uComp\",\"vComp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Top\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting Location\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Available Location Names\n", + "When working with a new data type, it is often useful to investigate all available options for a particular setting. Shown below is how to see all available location names for a data request with type `modelsounding` and `reportType` identifier of `GFS`. This step is not necessary if you already know exactly what the location name(s) you're interested in is." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, "outputs": [ { "data": { @@ -1053,7 +1134,7 @@ " ...]" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -1064,13 +1145,48 @@ "list(locations)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting the Location Name\n", + "\n", + "In this case we're setting the location name to `KFRM` which is the Municipal Airport in Fairmont, Minnesota." + ] + }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "request.setLocationNames(\"KFRM\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Top\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Filtering by Time\n", + "\n", + "Models produce many different time variants during their runs, so let's limit the data to the most recent time and forecast run." + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "request.setLocationNames(\"KFRM\")\n", "cycles = DataAccessLayer.getAvailableTimes(request, True)\n", "times = DataAccessLayer.getAvailableTimes(request)\n", "\n", @@ -1087,80 +1203,143 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Model Sounding Parameters\n", + "Top\n", "\n", - "Construct arrays for each parameter to plot (temperature, pressure, moisutre (spec. humidity), wind components, and cloud cover)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "parms = ['temperature', 'pressure', 'vComp', 'uComp', 'cldCvr', 'specHum', 'omega']\n", - "site = KFRM\n", - "geom = POINT (-94.41999816894531 43.65000152587891)\n", - "datetime = 2020-09-04 12:00:00\n", - "reftime = Sep 04 20 12:00:00 GMT\n", - "fcstHour = 0\n", - "period = (Sep 04 20 12:00:00 , Sep 04 20 12:00:00 )\n" - ] - } - ], - "source": [ - "tmp,prs,sh = np.array([]),np.array([]),np.array([])\n", - "uc,vc,om,cld = np.array([]),np.array([]),np.array([]),np.array([])\n", - "\n", - "for ob in response:\n", - " tmp = np.append(tmp,ob.getNumber(\"temperature\"))\n", - " prs = np.append(prs,ob.getNumber(\"pressure\"))\n", - " sh = np.append(sh,ob.getNumber(\"specHum\"))\n", - " uc = np.append(uc,ob.getNumber(\"uComp\"))\n", - " vc = np.append(vc,ob.getNumber(\"vComp\"))\n", - " om = np.append(om,ob.getNumber(\"omega\"))\n", - " cld = np.append(cld,ob.getNumber(\"cldCvr\"))\n", - "\n", - "print(\"parms = \" + str(ob.getParameters()))\n", - "print(\"site = \" + str(ob.getLocationName()))\n", - "print(\"geom = \" + str(ob.getGeometry()))\n", - "print(\"datetime = \" + str(ob.getDataTime()))\n", - "print(\"reftime = \" + str(ob.getDataTime().getRefTime()))\n", - "print(\"fcstHour = \" + str(ob.getDataTime().getFcstTime()))\n", - "print(\"period = \" + str(ob.getDataTime().getValidPeriod()))" + "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Calculating Dewpoint from Specific Humidity\n", + "## Get the Data!\n", "\n", - "Because the modelsounding plugin does not return dewpoint values, we must calculate the profile ourselves. Here are three examples of dewpoint calculated from specific humidity, including a manual calculation following NCEP AWIPS/NSHARP. \n", - "\n", - "**1) MetPy calculated mixing ratio and vapor pressure**" + "Here we can now request our data response from the EDEX server with our defined time filter.\n", + "Printing out some data about the response verifies we received the data we were interested in." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parms = ['temperature', 'pressure', 'vComp', 'uComp', 'specHum']\n", + "site = KFRM\n", + "geom = POINT (-94.41999816894531 43.65000152587891)\n", + "datetime = 2022-08-19 12:00:00\n", + "reftime = Aug 19 22 12:00:00 GMT\n", + "fcstHour = 0\n", + "period = (Aug 19 22 12:00:00 , Aug 19 22 12:00:00 )\n" + ] + } + ], + "source": [ + "obj = response[0]\n", + "\n", + "print(\"parms = \" + str(obj.getParameters()))\n", + "print(\"site = \" + str(obj.getLocationName()))\n", + "print(\"geom = \" + str(obj.getGeometry()))\n", + "print(\"datetime = \" + str(obj.getDataTime()))\n", + "print(\"reftime = \" + str(obj.getDataTime().getRefTime()))\n", + "print(\"fcstHour = \" + str(obj.getDataTime().getFcstTime()))\n", + "print(\"period = \" + str(obj.getDataTime().getValidPeriod()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Top\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use the Data!\n", + "\n", + "Since we filtered on time, and requested the data in the previous cell, we now have a `response` object we can work with." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prepare data objects\n", + "\n", + "Here we construct arrays for each parameter to plot (temperature, pressure, moisture (spec. humidity), wind components, and cloud cover). We have two sets of arrays for temperature and pressure, where the second set only has values as long as the specific humidity is not zero. That is because we are going to do some calculations with specific humidity, temperature, and pressure and we need all those arrays to be the same length, and for the specific humidty to not equal zero." + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "t = (tmp-273.15) * units.degC\n", - "p = prs/100 * units.mbar\n", + "# Create new arrays to populate from our response objects\n", + "tmp,prs,sh,prs2,tmp2 = np.array([]),np.array([]),np.array([]),np.array([]),np.array([])\n", + "uc,vc = np.array([]),np.array([])\n", + "\n", + "# Cycle through all response objects to populate new arrays\n", + "for ob in response:\n", + " tmp = np.append(tmp,ob.getNumber(\"temperature\"))\n", + " prs = np.append(prs,ob.getNumber(\"pressure\"))\n", + " uc = np.append(uc,ob.getNumber(\"uComp\"))\n", + " vc = np.append(vc,ob.getNumber(\"vComp\"))\n", + " # don't include data with 0 specific humidity\n", + " if(ob.getNumber(\"specHum\")==0):\n", + " continue\n", + " sh = np.append(sh,ob.getNumber(\"specHum\"))\n", + " prs2 = np.append(prs2,ob.getNumber(\"pressure\"))\n", + " tmp2 = np.append(tmp2,ob.getNumber(\"temperature\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate Dewpoint from Specific Humidity\n", + "\n", + "Because the modelsounding plugin does not return dewpoint values, we must calculate the profile ourselves. Here are three examples of dewpoint calculated from specific humidity, including a manual calculation following NCEP AWIPS/NSHARP. \n", + "\n", + "First, we'll set up variables that are used in all three methods (and later in the notebook)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "tfull = (tmp-273.15) * units.degC\n", + "t = (tmp2-273.15) * units.degC\n", + "\n", + "pfull = prs/100 * units.mbar\n", + "p = prs2/100 * units.mbar\n", "\n", "u,v = uc*1.94384,vc*1.94384 # m/s to knots\n", "spd = wind_speed(u*units.knots, v*units.knots)\n", "dir = wind_direction(u*units.knots, v*units.knots) * units.deg" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Method 1\n", + "\n", + "Here we'll calculate the dewpoint using MetPy calculated mixing ratio and the vapor pressure." + ] + }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -1173,12 +1352,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**2) metpy calculated assuming spec. humidity = mixing ratio**" + "#### Method 2\n", + "\n", + "Here we'll calculate dewpoint using MetPy while assuming the mixing ratio is equal to the specific humidity." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -1189,22 +1370,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**3) NCEP AWIPS soundingrequest plugin**\n", + "#### Method 3\n", "\n", - "based on GEMPAK/NSHARP, from https://github.com/Unidata/awips2-ncep/blob/unidata_16.2.2/edex/gov.noaa.nws.ncep.edex.plugin.soundingrequest/src/gov/noaa/nws/ncep/edex/plugin/soundingrequest/handler/MergeSounding.java#L1783" + "Here we use logic from the NCEP AWIPS soundingrequest plugin. This logic was based on [GEMPAK and NSHARP calculations](https://github.com/Unidata/awips2-ncep/blob/unidata_16.2.2/edex/gov.noaa.nws.ncep.edex.plugin.soundingrequest/src/gov/noaa/nws/ncep/edex/plugin/soundingrequest/handler/MergeSounding.java#L1783)." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# new arrays\n", - "ntmp = tmp\n", + "ntmp = tmp2\n", "\n", "# where p=pressure(pa), T=temp(C), T0=reference temp(273.16)\n", - "rh = 0.263*prs*sh / (np.exp(17.67*ntmp/(ntmp+273.15-29.65)))\n", + "rh = 0.263*prs2*sh / (np.exp(17.67*ntmp/(ntmp+273.15-29.65)))\n", "vaps = 6.112 * np.exp((17.67 * ntmp) / (ntmp + 243.5))\n", "vapr = rh * vaps / 100\n", "dwpc = np.array(243.5 * (np.log(6.112) - np.log(vapr)) / (np.log(vapr) - np.log(6.112) - 17.67)) * units.degC" @@ -1214,19 +1395,34 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## MetPy SkewT and Hodograph" + "Top\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot the Data!\n", + "\n", + "Create and display SkewT and Hodograph plots using MetPy.\n", + "\n", + "Since we're displaying all three dewpoint plots, we also create a \"zoomed in\" view to highlight the slight differences between the three calculations." ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": 12, + "metadata": { + "scrolled": false + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -1236,28 +1432,64 @@ } ], "source": [ - "%matplotlib inline\n", - "\n", - "plt.rcParams['figure.figsize'] = (12, 14)\n", + "# Create a new figure and define the size\n", + "fig = plt.figure(figsize=(12, 14))\n", "\n", "# Create a skewT plot\n", - "skew = SkewT()\n", + "skew = SkewT(fig)\n", "\n", "# Plot the data\n", - "skew.plot(p, t, 'r', linewidth=2)\n", + "skew.plot(pfull, tfull, 'r', linewidth=2)\n", "skew.plot(p, td, 'b', linewidth=2)\n", - "skew.plot(p, td2, 'y')\n", + "skew.plot(p, td2, 'y', linewidth=2)\n", "skew.plot(p, dwpc, 'g', linewidth=2)\n", - "\n", - "skew.plot_barbs(p, u, v)\n", + "skew.plot_barbs(pfull, u, v)\n", + "# set the domain and range (these may need to be adjusted\n", + "# depending on the exact data for best viewing purposes)\n", "skew.ax.set_ylim(1000, 100)\n", - "skew.ax.set_xlim(-40, 60)\n", + "skew.ax.set_xlim(-70, 40)\n", "\n", - "plt.title( forecastModel + \" \" \\\n", - " + ob.getLocationName() \\\n", - " + \"(\"+ str(ob.getGeometry()) + \")\" \\\n", - " + \", \" + str(ob.getDataTime())\n", - ")\n", + "# Add title to the plot\n", + "# format: \"2022-08-18 18Z FH 0 | GFS KFRM (43.65,-94.42)\"\n", + "datetime = str(ob.getDataTime())[0:-6]+\"Z\"\n", + "forecastHr = str(ob.getDataTime().getFcstTime())\n", + "site = ob.getLocationName()\n", + "lat = \"{:.2f}\".format(ob.getGeometry().y)\n", + "lon = \"{:.2f}\".format(ob.getGeometry().x)\n", + "coords = \"(\" + lat + \", \" + lon +\")\"\n", + "\n", + "title = datetime + \" FH \" + forecastHr + \" | \" + forecastModel + \" \" + site + \" \" + coords\n", + "plt.title(title)\n", + "\n", + "# Create a secondary axes for the \"zoomed in\" view\n", + "zoom_ax = inset_axes(skew.ax, '35%', '35%', loc=3,\n", + " bbox_to_anchor=(.05, .05, 1, 1),\n", + " bbox_transform=skew.ax.transAxes)\n", + "# create a secondary plot for zoomed in section\n", + "fig2 = plt.figure()\n", + "skew2 = SkewT(fig2)\n", + "skew2.ax = zoom_ax\n", + "skew2.plot(p, td, 'b', linewidth=2, label='MetPy calculated mixing ratio')\n", + "skew2.plot(p, td2, 'y', linewidth=2, label='MetPy spec. hum = mixing ratio')\n", + "skew2.plot(p, dwpc, 'g', linewidth=2, label='GEMPAK legacy caluclation')\n", + "# create a legend to explain the three lines\n", + "skew2.ax.legend(loc=1)\n", + "# remove the axis title on the zoomed plot since they\n", + "# are redundant and just clutter the plot\n", + "skew2.ax.set_xlabel(\"\")\n", + "skew2.ax.set_ylabel(\"\")\n", + "# these exact bounds may need to change depending on\n", + "# the most recent data\n", + "skew2.ax.set_ylim(970, 900)\n", + "skew2.ax.set_xlim(11, 14)\n", + "\n", + "# draw an indicator in the main plot of the \"zoomed in\" region\n", + "skew.ax.indicate_inset_zoom(zoom_ax, edgecolor=\"black\")\n", + "\n", + "# dispose of the second figure, since creating a new\n", + "# skewt in metpy automatically creates a new figure\n", + "# which is unnecessary in this case\n", + "plt.close(fig2)\n", "\n", "# An example of a slanted line at constant T -- in this case the 0 isotherm\n", "l = skew.ax.axvline(0, color='c', linestyle='--', linewidth=2)\n", @@ -1273,11 +1505,45 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "Top\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## See Also\n", + "\n", + "### Related Notebooks\n", + "\n", + "* [Grid Levels and Parameters](https://unidata.github.io/python-awips/examples/generated/Grid_Levels_and_Parameters.html)\n", + "* [Upper Air BUFR Soundings](http://unidata.github.io/python-awips/examples/generated/Upper_Air_BUFR_Soundings.html)\n", + "* [Forecast Model Vertical Sounding](http://unidata.github.io/python-awips/examples/generated/Forecast_Model_Vertical_Sounding.html)\n", + "\n", + "### Additional Documentation\n", + "\n", + "**python-awips:**\n", + "* [awips.DataAccessLayer](http://unidata.github.io/python-awips/api/DataAccessLayer.html)\n", + "* [awips.PyGeometryData](http://unidata.github.io/python-awips/api/PyGeometryData.html)\n", + "\n", + "**matplotlib:**\n", + "* [matplotlib.pyplot](https://matplotlib.org/3.3.3/api/_as_gen/matplotlib.pyplot.html)\n", + "* [metpy.skewt](https://unidata.github.io/MetPy/latest/api/generated/metpy.plots.SkewT.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Top\n", + "\n", + "---" + ] } ], "metadata": { @@ -1296,7 +1562,20 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true } }, "nbformat": 4, diff --git a/examples/notebooks/Regional_Surface_Obs_Plot.ipynb b/examples/notebooks/Regional_Surface_Obs_Plot.ipynb index 30aa2d7..12465f6 100644 --- a/examples/notebooks/Regional_Surface_Obs_Plot.ipynb +++ b/examples/notebooks/Regional_Surface_Obs_Plot.ipynb @@ -452,7 +452,20 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.6" + "version": "3.9.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false } }, "nbformat": 4,