From 33a80dfa709336d3f25c58dfc73eefe2083e6e10 Mon Sep 17 00:00:00 2001 From: Shay Carter Date: Fri, 19 Aug 2022 10:58:44 -0700 Subject: [PATCH] Update Model Sounding Data notebook - update to conform to the new format, with updated code for clarity and usefulness --- examples/notebooks/Model_Sounding_Data.ipynb | 469 +++++++++++++++---- 1 file changed, 374 insertions(+), 95 deletions(-) diff --git a/examples/notebooks/Model_Sounding_Data.ipynb b/examples/notebooks/Model_Sounding_Data.ipynb index 499a897..9af6ee2 100644 --- a/examples/notebooks/Model_Sounding_Data.ipynb +++ b/examples/notebooks/Model_Sounding_Data.ipynb @@ -4,7 +4,58 @@ "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**." + "Python-AWIPS Tutorial Notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\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": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "\n", + "[1 Imports](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#imports)
\n", + "[2 EDEX Connection](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#edex-connection)
\n", + "[3 Setting Location](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#setting-location)
\n", + "    [3.1 Available Location Names](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#available-location-names)
\n", + "    [3.2 Setting the Location Name](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#setting-the-location-name)
\n", + "[4 Filtering by Time](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#filtering-by-time)
\n", + "[5 Get the Data!](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#get-the-data)
\n", + "[6 Use the Data!](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#use-the-data)
\n", + "    [6.1 Prepare the Data!](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#prepare-the-data)
\n", + "    [6.2 Calculate Dewpoint from Specific Humidity](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#calculate-dewpoint-from-specific-humidity)
\n", + "        [6.2.1 Method 1](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#method-1)
\n", + "        [6.2.2 Method 2](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#method-2)
\n", + "        [6.2.3 Method 3](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#method-3)
\n", + "[7 Plot the Data!](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#plot-the-data)
\n", + "[8 See Also](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#see-also)
\n", + "    [8.1 Related Notebooks](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#related-notebooks)
\n", + "    [8.2 Additional Documentation](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html#additional-documentation)
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1 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. " ] }, { @@ -16,36 +67,74 @@ "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.calc import dewpoint, vapor_pressure, wind_speed, wind_direction\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\")" + "from metpy.units import units" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Available Locations" + "[Top](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html)\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2 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 identifer 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](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html)\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3 Setting Location" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.1 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 is." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, "outputs": [ { "data": { @@ -1053,7 +1142,7 @@ " ...]" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -1064,13 +1153,48 @@ "list(locations)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.2 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](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html)\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4 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 +1211,143 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Model Sounding Parameters\n", + "[Top](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html)\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", + "## 5 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](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html)\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6 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": [ + "### 6.2 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": [ + "### 6.2 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": [ + "#### 6.2.1 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 +1360,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**2) metpy calculated assuming spec. humidity = mixing ratio**" + "#### 6.2.2 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 +1378,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**3) NCEP AWIPS soundingrequest plugin**\n", + "#### 6.2.3 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 +1403,32 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## MetPy SkewT and Hodograph" + "[Top](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html)\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7 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, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -1236,28 +1438,58 @@ } ], "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", + "# Add a title to the plot\n", "plt.title( forecastModel + \" \" \\\n", " + ob.getLocationName() \\\n", " + \"(\"+ str(ob.getGeometry()) + \")\" \\\n", - " + \", \" + str(ob.getDataTime())\n", - ")\n", + " + \", \" + str(ob.getDataTime()))\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](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html)\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](https://unidata.github.io/python-awips/examples/generated/Model_Sounding_Data.html)\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": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false } }, "nbformat": 4,