00_Intro.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMynR5HXxWxPbBcbOnCggXy",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/aamatthews/2022UWCourse/blob/main/00_Intro.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Hands on Radar Data, Part 1\n",
        "### Alyssa Matthews and Ya-Chien Feng"
      ],
      "metadata": {
        "id": "pfljh8IPrSRc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Setup"
      ],
      "metadata": {
        "id": "ZHyfNatGgSMM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Welcome to Google Colab! It allows you to play with notebooks in python, without having to install anything on your own computer. \n",
        "\n",
        "To access the notebooks, go to this link in your browser:\n",
        "\n",
        "https://github.com/aamatthews/2022UWCourse\n",
        "\n"
      ],
      "metadata": {
        "id": "RKHrhc-VruoB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Before we get started, there is a little setup we have to do first. \n",
        "\n",
        "In each notebook we will be using PyART, the Python ARM Radar Toolkit, that is helpful for reading in, plotting, and contains multiple algorithms for digging in deeper to radar data. Since this doesn't come natively in Colab, we must first install it prior to importing. This can take a few minutes, so lets start it running first and we can cover some other basics."
      ],
      "metadata": {
        "id": "ud2836bBdlfx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install arm-pyart"
      ],
      "metadata": {
        "id": "4rw4d1qid244"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We will start with learning to read in and plot the various types of ARM radar data - Vertically Pointing, RHIs, and PPIs.\n",
        "\n",
        "\n",
        "*   To run a line, press shift+enter on your keyboard, or click the play button"
      ],
      "metadata": {
        "id": "sAr-XZVrgJPO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's grab some data for today! Run the below cell, click the folder icon on the left, then click the refresh folder icon to see the data appear. "
      ],
      "metadata": {
        "id": "xJzlheQ_8216"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!wget https://engineering.arm.gov/~amatthews/hou_data_sample/20220701.zip"
      ],
      "metadata": {
        "id": "xzkc-XuV9SHg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip 20220701.zip"
      ],
      "metadata": {
        "id": "68XtZrkSC3Dn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, lets import the libraries we will need in this notebook. We will add more later in the course in future notebooks, but these are the basics I tend to use most often in my work."
      ],
      "metadata": {
        "id": "kwBmCxcNddgl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import netCDF4 as nc\n",
        "import xarray as xr\n",
        "import pandas as pd\n",
        "import pyart\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline"
      ],
      "metadata": {
        "id": "HWuxKJPWqcL5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Reading in files\n",
        "\n",
        "In this section, I will show you three different ways you can read in files. Which you use really depends on which you prefer or which will work best for your needs."
      ],
      "metadata": {
        "id": "0-m13o1qvGRm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Option 1: NetCDF4 library \n",
        "\n",
        "For more information, you can view the documentation here:\n",
        "https://unidata.github.io/netcdf4-python/#Dataset.__init__"
      ],
      "metadata": {
        "id": "G_c2G3Juials"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = nc.Dataset('20220701/houkazrcfrgeM1.a1.20220701.190000.nc')"
      ],
      "metadata": {
        "id": "oNBMYvf6vCj0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the radar files, time is split into base time (the time at the start of the file) and time offset (the time since the file started). I like to save a combined timestamp of the two after reading in the data, as it can make the plots and data easier to interpret later on."
      ],
      "metadata": {
        "id": "dwvEJPXtjCkI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "time =  pd.to_datetime(data.variables['base_time'][:] + data.variables['time_offset'][:], unit='s')"
      ],
      "metadata": {
        "id": "haEo0Fq9-KP3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "time[0:10]"
      ],
      "metadata": {
        "id": "0LhCfK8CjABI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once you have read in the data file, there are various levels you can look at. First, is the data class. This will include all the attributes (or metadata), as well as the variables stored in the file."
      ],
      "metadata": {
        "id": "tr1cYdPljg9l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data"
      ],
      "metadata": {
        "id": "YcXXsAsoDFbY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Often, it is useful just to see what the variable names are. You can see the full details of each variable with data.variables, but to see just a list of the variable names, you can add the keys() function."
      ],
      "metadata": {
        "id": "D6d5T5Jgjtov"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data.variables.keys()"
      ],
      "metadata": {
        "id": "MFK6pNZw_l8i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once you know the name of a variable you want to look at, you can examine it to see the details of that variable, including a more detailed name, the dimension, and units. Lets take a look at Reflectivity."
      ],
      "metadata": {
        "id": "_x9ZQ5AZj9mw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data.variables['reflectivity']"
      ],
      "metadata": {
        "id": "yopA7cBTFF7w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, to view the data within the variable, you can add [:]"
      ],
      "metadata": {
        "id": "LmCR6N6ekRDN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data.variables['reflectivity'][:]"
      ],
      "metadata": {
        "id": "AxhqMbX_1yrf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets view a piece of the attributes or metadata. These are called directly from the dataset."
      ],
      "metadata": {
        "id": "1IOSVtnwqu53"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data.antenna_altitude"
      ],
      "metadata": {
        "id": "_KwnGNecq1Dv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Option 2: Xarray library \n",
        "\n",
        "This is another library that can read in netCDF4 files. Data read in with this library is in a more pandas-like structure (for those familiar with pandas). You can view the documentation for reading in a file with xarray here: \n",
        "\n",
        "https://docs.xarray.dev/en/stable/generated/xarray.open_dataset.html#xarray.open_dataset\n",
        "\n",
        "An ability I particularly like within xarray is its ability to read in multiple data files at once and save them to one structure instead of having to read in each file individually. For this course, though, we will just be focusing on reading in one file at a time for simplicity. The documentation for this can be found at:\n",
        "\n",
        "https://docs.xarray.dev/en/stable/generated/xarray.open_mfdataset.html#xarray.open_mfdataset"
      ],
      "metadata": {
        "id": "YzewjqzYFNDt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar = xr.open_dataset('20220701/houkazrcfrgeM1.a1.20220701.190000.nc', decode_times = False)"
      ],
      "metadata": {
        "id": "6R3mXW9FFI-K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "One known issue in Xarray is how it handles the 'time' variable in the ARM radar files. To correct this, I overwrite that variable with the combined base_time + time_offset, as I showed previously in the netCDF4 example."
      ],
      "metadata": {
        "id": "wn0ema7p9LYF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar['time'] = pd.to_datetime(radar['base_time'].values + radar['time_offset'].values, unit='s')"
      ],
      "metadata": {
        "id": "az6x53zb9HQB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To start digging into the data, lets first print the Dataset. As you can see, the output is much more condensed, with many options to expand the data to see what you are interested in. "
      ],
      "metadata": {
        "id": "sFMJ-qhJm76e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar"
      ],
      "metadata": {
        "id": "jxJo6n6m2xCg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets next get a list of the available variable names."
      ],
      "metadata": {
        "id": "GnvSrHdWnK_H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list(radar.variables.keys())"
      ],
      "metadata": {
        "id": "0saoZ94Q2x0O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To see the details of a particular variable, you can either expand it out in the radar output, or can use a command identical to the one we used in the netCDF4 library example. Lets look at Reflectivity again, and at the data within that variable."
      ],
      "metadata": {
        "id": "2K5sdFSSnTIG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "radar.variables['reflectivity']"
      ],
      "metadata": {
        "id": "egH393rJ20M3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To view the data within the variable, you can add .data or .values to the end of the variable."
      ],
      "metadata": {
        "id": "Dd0qAZMppxzF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar.variables['reflectivity'].data"
      ],
      "metadata": {
        "id": "3Ns7aCzh25y3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Viewing an attribute is done similarly to what we learned in the netCDF4 library example."
      ],
      "metadata": {
        "id": "O_wP2CP8rFfA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar.antenna_diameter"
      ],
      "metadata": {
        "id": "WQTxap-1rLk2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Option 3: PyART\n",
        "\n",
        "The PyART package can read in many different types of radar files. You can view its documentation at: \n",
        "\n",
        "https://arm-doe.github.io/pyart/"
      ],
      "metadata": {
        "id": "xxhEKrrqnl5k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar = pyart.io.read('20220701/houkazrcfrgeM1.a1.20220701.190000.nc')"
      ],
      "metadata": {
        "id": "uRnLF2wLoEst"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets view the information about this radar object. This will show us the variables and their information at the top, and the attributes and metadata at the bottom."
      ],
      "metadata": {
        "id": "r2CKusM7pB6y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar.info()"
      ],
      "metadata": {
        "id": "X6-jKNHco1Sg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "One difference between PyART and the netCDF4 or Xarray libraries is that PyART calls the data names 'fields' instead of 'variables'. Lets view them now."
      ],
      "metadata": {
        "id": "gSem11WNpUe0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar.fields"
      ],
      "metadata": {
        "id": "X-y4nN9LpQFE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "radar.fields['reflectivity']"
      ],
      "metadata": {
        "id": "ngcIQrB6pnzN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To view the data within the variable, you just add ['data'] to the end of the field."
      ],
      "metadata": {
        "id": "nY3eDcPapuQv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar.fields['reflectivity']['data']"
      ],
      "metadata": {
        "id": "lvVSKNrspq3a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Viewing the attributes or metadata is done a little differently to the other two examples when using PyART"
      ],
      "metadata": {
        "id": "N2B-5LFUrSQB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar.metadata['antenna_altitude']"
      ],
      "metadata": {
        "id": "hp5yHQWergTR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Exercise 1\n",
        "Pick one of the methods I showed above and read in a XSACR, KASACR, or CSAPR2 data file.\n",
        "\n",
        "Can you find the scan type for that file in the data?"
      ],
      "metadata": {
        "id": "sfuL5W5B4PqJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Hint"
      ],
      "metadata": {
        "id": "RB5dYstuqK-M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "it is an attribute or metadata, and not a variable"
      ],
      "metadata": {
        "id": "LrC0iPf4gpYg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        ":)"
      ],
      "metadata": {
        "id": "nDJyeEZBuUtn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Solutions"
      ],
      "metadata": {
        "id": "a5v8jh2oqRUz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = xr.open_dataset('20220701/houcsapr2cfrS2.a1.20220701.192028.nc')"
      ],
      "metadata": {
        "id": "1Mxx2lbu4_JN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data.scan_name"
      ],
      "metadata": {
        "id": "QTqst4iY5RAs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data = nc.Dataset('20220701/houcsapr2cfrS2.a1.20220701.192028.nc')"
      ],
      "metadata": {
        "id": "aU4S5XYvqZb9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data.scan_name"
      ],
      "metadata": {
        "id": "U4y2H-hLqeWq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data = pyart.io.read('20220701/houcsapr2cfrS2.a1.20220701.192028.nc')"
      ],
      "metadata": {
        "id": "9VvrCHV8qg5B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data.metadata['scan_name']"
      ],
      "metadata": {
        "id": "mvpP5BseqkjZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Now, lets plot some data!\n"
      ],
      "metadata": {
        "id": "W7QC1zUI3812"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The ARM scanning radars have the ability to scan in multiple ways. Here, we will go over various methods for plotting the most common scan types. First I will show a method with no specialized libraries, then I will show a method using PyART.\n",
        "\n",
        "![radar scan image](https://journals.ametsoc.org/view/journals/atot/31/3/images/full-jtech-d-13-00044_1-f3.jpg)"
      ],
      "metadata": {
        "id": "mfCXyEgUazwa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Vertically pointing data (VPT)"
      ],
      "metadata": {
        "id": "F5SnJkf44ATs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Method 1"
      ],
      "metadata": {
        "id": "hKgF0Yi0bgKK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "kazr = xr.open_dataset('20220701/houkazrcfrgeM1.a1.20220701.190000.nc', decode_times = False)\n",
        "kazr['time'] = pd.to_datetime(kazr['base_time'].values + kazr['time_offset'].values, unit='s')"
      ],
      "metadata": {
        "id": "uR7ag88n4Heb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(15,5))\n",
        "plt.pcolormesh(kazr['time'], kazr['range'], kazr['reflectivity'].T, cmap = 'jet')\n",
        "plt.colorbar(label = 'Reflectivity (dBZ)')\n",
        "plt.xlabel('Time')\n",
        "plt.ylabel('Height (m)')\n",
        "plt.title('KAZR Reflectivity');"
      ],
      "metadata": {
        "id": "lEsfMe-d8BMp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Method 2: PyART"
      ],
      "metadata": {
        "id": "-Fkb0SsMb0tS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar = pyart.io.read('/content/20220701/houkazrcfrgeM1.a1.20220701.190000.nc')"
      ],
      "metadata": {
        "id": "RoHeg21kb4MP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "display = pyart.graph.RadarDisplay(radar)\n",
        "fig = plt.figure(figsize=[8,4])\n",
        "# ax = fig.add_subplot(111)\n",
        "display.plot_vpt('reflectivity', vmin=-20, vmax=40)\n"
      ],
      "metadata": {
        "id": "62jFKeSKb_m-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##RHI or HSRHI"
      ],
      "metadata": {
        "id": "NeuXi04qDx_G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Method 1"
      ],
      "metadata": {
        "id": "WbVY_B0LebhY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "csapr = xr.open_dataset('/content/20220701/houcsapr2cfrS2.a1.20220701.192028.nc', decode_times = False)\n",
        "csapr['time'] = pd.to_datetime(csapr['base_time'].values + csapr['time_offset'].values, unit='s')"
      ],
      "metadata": {
        "id": "iUbzAY-o8Tqa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "csapr.scan_name"
      ],
      "metadata": {
        "id": "loJOrfwR8XR5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sweep_start = list(map(int,(csapr['sweep_start_ray_index'].data)))\n",
        "sweep_end = list(map(int,(csapr['sweep_end_ray_index'].data)))\n",
        "azi = csapr['azimuth'].data\n",
        "elv = csapr['elevation'].data\n",
        "r = csapr['range'].data\n",
        "\n",
        "y = np.outer(r, np.sin((elv)*np.pi/180.0))\n",
        "x = np.outer(r, np.cos((elv)*np.pi/180.0))\n",
        "sweep_num = 0\n",
        "\n",
        "\n",
        "\n",
        "for i in range(len(sweep_start)):\n",
        "    sweep_num = i\n",
        "#     print(sweep_num)\n",
        "    plt.figure(figsize=(20,40))\n",
        "    plt.subplot(6,1,1)\n",
        "    plt.pcolormesh(x[:,sweep_start[sweep_num]:sweep_end[sweep_num]].T,\n",
        "                   y[:,sweep_start[sweep_num]:sweep_end[sweep_num]].T,\n",
        "                   csapr['reflectivity'].data[sweep_start[sweep_num]:sweep_end[sweep_num],:], \n",
        "                   vmin=-60, vmax=50, cmap='jet')\n",
        "    clb = plt.colorbar()\n",
        "    clb.set_label('Zh')\n",
        "    plt.xlabel('Horizontal Distance from Radar (m)')\n",
        "    plt.ylabel('Height (m)')\n",
        "    azi_start = np.nanmedian(azi[sweep_start[sweep_num]])\n",
        "    plt.title('Azimuth: %f ' % azi_start)\n",
        "    plt.ylim(0,20000)\n"
      ],
      "metadata": {
        "id": "rzxdeRoYFXyX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Method 2: PyART"
      ],
      "metadata": {
        "id": "UvhkymS2eewZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar = pyart.io.read('/content/20220701/houcsapr2cfrS2.a1.20220701.192028.nc')"
      ],
      "metadata": {
        "id": "2m3IrmQbeeA_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "display = pyart.graph.RadarDisplay(radar)\n",
        "fig = plt.figure(figsize=[10, 5])\n",
        "display.plot('reflectivity', 0, vmin=-16, vmax=64.0)\n",
        "# plt.ylim(0,20)"
      ],
      "metadata": {
        "id": "C6pRKC61emG8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##PPI\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "FxuqojFGJZx7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Method 1"
      ],
      "metadata": {
        "id": "1iTJQ6rmfPj4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This is very similar to the RHI, except instead of y using azimuth, you use elevation and flip from cos to sin (or vice versa)"
      ],
      "metadata": {
        "id": "1jmyoopxJtHS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ppi = xr.open_dataset('/content/20220701/houcsapr2cfrS2.a1.20220701.192603.nc', decode_times = False)\n",
        "ppi['time'] = pd.to_datetime(ppi['base_time'].values + ppi['time_offset'].values, unit='s')"
      ],
      "metadata": {
        "id": "F26kuabRJ9H6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ppi.scan_name"
      ],
      "metadata": {
        "id": "AABgxeepKX4v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sweep_start = list(map(int,(ppi['sweep_start_ray_index'].data)))\n",
        "sweep_end = list(map(int,(ppi['sweep_end_ray_index'].data)))\n",
        "azi = ppi['azimuth'].data\n",
        "elv = ppi['elevation'].data\n",
        "r = ppi['range'].data\n",
        "\n",
        "y = np.outer(r, np.cos((azi)*np.pi/180.0))\n",
        "x = np.outer(r, np.sin((azi)*np.pi/180.0))\n",
        "sweep_num = 0\n",
        "\n",
        "for i in range(len(sweep_start)):\n",
        "    sweep_num = i\n",
        "#     print(sweep_num)\n",
        "    plt.figure(figsize=(10,7.5))\n",
        "\n",
        "    plt.pcolormesh(x[:,sweep_start[sweep_num]:sweep_end[sweep_num]].T,\n",
        "                   y[:,sweep_start[sweep_num]:sweep_end[sweep_num]].T,\n",
        "                   ppi['reflectivity'].data[sweep_start[sweep_num]:sweep_end[sweep_num],:], \n",
        "                   vmin=-60, vmax=40, cmap='jet')\n",
        "    clb = plt.colorbar()\n",
        "    clb.set_label('Zh')\n",
        "    plt.xlabel('E-W Distance from Radar (m)')\n",
        "    plt.ylabel('N-S Distance from Radar (m)')\n",
        "    elv_start = elv[sweep_start[sweep_num]+50]\n",
        "    plt.title('Elevation: %f' % elv_start)"
      ],
      "metadata": {
        "id": "pGsAlxWAJbXn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Method 2: PyART"
      ],
      "metadata": {
        "id": "uzKVpT7-n1Vn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "radar = pyart.io.read('/content/20220701/houcsapr2cfrS2.a1.20220701.192603.nc')"
      ],
      "metadata": {
        "id": "tqohmKzkfa0p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "display = pyart.graph.RadarDisplay(radar)\n",
        "fig = plt.figure(figsize=[7,6])\n",
        "\n",
        "display.plot('reflectivity', 0, vmin=-32, vmax=64.)\n",
        "display.plot_range_rings([20, 40, 60, 80, 100])\n",
        "display.plot_cross_hair(2.)"
      ],
      "metadata": {
        "id": "A1qwSJkufy4w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Exercise\n",
        "1. Plot an XSACR or KASACR scanning file. \n",
        "\n",
        "2. What do you see in the data?"
      ],
      "metadata": {
        "id": "kyxvmozULqsj"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "LXDu17shMGRu"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}