{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e0e69847",
   "metadata": {
    "id": "e0e69847"
   },
   "source": [
    "# Exploring TC PRIMED, Chapter 1a: NetCDF Files\n",
    "- Creators: Naufal Razin, Chris Slocum, and Kathy Haynes\n",
    "- Affiliations: CIRA and NESDIS/STAR\n",
    "\n",
    "---\n",
    "\n",
    "## Overview\n",
    "TC PRIMED uses NetCDF Groups to store data. Not all datasets stored in the NetCDF file format use NetCDF Groups. However, since TC PRIMED is a compilation of data from various sources, the NetCDF Groups functionality helps with data organization. In this notebook, you will learn how to read a TC PRIMED NetCDF file and retrieve the various information available in the different groups.\n",
    "\n",
    "## Prerequisites\n",
    "To successfully navigate and use this notebook, you should be familiar with:\n",
    "- the basics of Python programming such as loading modules, assigning variables, and list/array indexing\n",
    "\n",
    "## Learning Outcomes\n",
    "By working through this notebook, you should be able to:\n",
    "- understand the NetCDF file structure, particularly one that contains groups\n",
    "- interact with (e.g., load and plot) data from a NetCDF file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e92a0ec1",
   "metadata": {
    "id": "e92a0ec1"
   },
   "source": [
    "## Background\n",
    "[NetCDF](https://www.unidata.ucar.edu/software/netcdf/), or Network Common Data Form, \"is a set of software libraries and machine-independent data formats that support the creation, access, and sharing of array-oriented scientific data\" (Unidata 2023). Scientific data stored in NetCDF files are meant to be self-describing in that the file should include information about the data it contains. This self-describing information is also known as attributes or metadata. NetCDF files are a type of multidimensional raster files, like GeoTIFF files.\n",
    "\n",
    "[NetCDF Groups](https://www.unidata.ucar.edu/software/netcdf/workshops/2011/groups-types/GroupsIntro.html) are like directories or folders on your computer, except that they are contained within the NetCDF file. For example, you may have a file within a folder, and that folder is stored within a parent folder. The path to that file on your computer would be `parent_folder/child_folder/file`.\n",
    "\n",
    "In this tutorial, you will learn how to access the attributes of the different groups in a TC PRIMED file, as well as learn how to load TC PRIMED variables within the groups."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dWZRuWzGSbgg",
   "metadata": {
    "id": "dWZRuWzGSbgg"
   },
   "source": [
    "## Software\n",
    "This tutorial uses the Python programming language and packages. We will use:\n",
    "- `netCDF4` to load the TC PRIMED file\n",
    "- `numpy` for simple array operations\n",
    "\n",
    "### Install Packages\n",
    "Let's first check if we have the necessary Python packages to run this notebook. If we don't, let's install them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lgN28prkJNjC",
   "metadata": {
    "executionInfo": {
     "elapsed": 138,
     "status": "ok",
     "timestamp": 1694638572131,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "lgN28prkJNjC"
   },
   "outputs": [],
   "source": [
    "import subprocess, sys\n",
    "packages = [\"netCDF4\", \"numpy\"]\n",
    "for package in packages:\n",
    "    try:\n",
    "        __import__(package)\n",
    "    except ImportError:\n",
    "        subprocess.check_call([sys.executable, '-m', 'pip', 'install', package])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5F3IZzQrTZ2c",
   "metadata": {
    "id": "5F3IZzQrTZ2c"
   },
   "source": [
    "Now, let's load the modules in the packages (e.g., `Dataset`) or load the packages and assign a shorter object name for the packages (e.g., `import numpy as np`) for a cleaner use throughout the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4BtHkfoJThJU",
   "metadata": {
    "executionInfo": {
     "elapsed": 2,
     "status": "ok",
     "timestamp": 1694638572291,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "4BtHkfoJThJU"
   },
   "outputs": [],
   "source": [
    "# Load the Python packages we will use in this notebook\n",
    "from netCDF4 import Dataset\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d279e98",
   "metadata": {
    "id": "5d279e98"
   },
   "source": [
    "## Read File Online\n",
    "Finally, let's retrieve information from the TC PRIMED file that we will use in this example. The TC PRIMED file will be from a Global Precipitation Measurment (GPM) satellite Microwave Imager (GMI) overpass of Hurricane Florence (2018). We will use the Python `netCDF4` and `requests` packages to read and retrieve the information directly from the TC PRIMED file available on an [Amazon Web Service S3 bucket](https://noaa-nesdis-tcprimed-pds.s3.amazonaws.com/index.html) as part of the [NOAA Open Data Dissemination program (NODD)](https://www.noaa.gov/information-technology/open-data-dissemination), without downloading the file, and store the information from the file in an \"instance\" type called `DS`.\n",
    "\n",
    "Below, `NODD_URL` is a reflection of the TC PRIMED directory on NODD, and takes on the following form:\n",
    "\n",
    "`<TC PRIMED AWS URL>/<TC PRIMED Version>/<TC PRIMED Version Type>/<tropical cyclone season>/<tropical cyclone basin>/<tropical cyclone number>/`\n",
    "\n",
    "where\n",
    "\n",
    "`<TC PRIMED AWS URL>` is the following URL https://noaa-nesdis-tcprimed-pds.s3.amazonaws.com\n",
    "\n",
    "`<TC PRIMED Version>` is the version number, currently v01r00\n",
    "\n",
    "`<TC PRIMED Type>` is the final or preliminary type\n",
    "\n",
    "`<season>` is the four digit season. This is calendar year for the Northern Hemisphere. For the Southern Hemisphere, the year begins July 1, with calendar year plus one.\n",
    "\n",
    "`<basin>` is the ocean basin.\n",
    "\n",
    "AL – North Atlantic basin, north of the Equator;\n",
    "SL – South Atlantic basin, south of the Equator;\n",
    "EP – North East Pacific basin, eastward of 140 degrees west longitude;\n",
    "CP – North Central Pacific basin, between the dateline and 140 degrees west longitude;\n",
    "WP – North West Pacific basin, westward of the dateline;\n",
    "IO – North Indian Ocean basin, north of the Equator between 40 and 100 degrees east longitude;\n",
    "SH – South Pacific Ocean basin and South Indian Ocean basin.\n",
    "\n",
    "`<annual number>` is the annual cyclone number from 01 to 49."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5e27563",
   "metadata": {
    "executionInfo": {
     "elapsed": 1343,
     "status": "ok",
     "timestamp": 1694638573633,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "d5e27563"
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "# Specify the URL to the TC PRIMED folder on NODD\n",
    "NODD_URL = \"https://noaa-nesdis-tcprimed-pds.s3.amazonaws.com/v01r00/final/2018/AL/06/\"\n",
    "\n",
    "# Specify the name of the file we will use from the TC PRIMED folder on NODD\n",
    "FILE_NAME = \"TCPRIMED_v01r00-final_AL062018_GMI_GPM_025677_20180905051405.nc\"\n",
    "\n",
    "# Join NODD_URL and FILE_NAME to produce a complete link\n",
    "# Retrieve the contents of the TC PRIMED file from the complete link\n",
    "url_response = requests.get(NODD_URL + FILE_NAME)\n",
    "\n",
    "# Load the contents of the TC PRIMED file in an \"instance\" called DS\n",
    "DS = Dataset(FILE_NAME, memory=url_response.content)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57d7bd3b",
   "metadata": {
    "id": "57d7bd3b"
   },
   "source": [
    "As we have mentioned above, when reading a NetCDF file in Python, information is stored in an \"instance\" type. Let's first look at the instance of the file at the \"root\" group.\n",
    "\n",
    "The root group is the outer-most \"directory\" or \"folder\" in a NetCDF file. Its instance gets automatically loaded when you load a NetCDF file in Python. For datasets that do not use NetCDF Groups, all variables would be stored in the root group. However, in TC PRIMED, the root group stores only the \"global\" attributes &mdash; information about the whole file &mdash; and the different sub-groups.\n",
    "\n",
    "Let's print the root group instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0060b3d4",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 14,
     "status": "ok",
     "timestamp": 1694638573634,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "0060b3d4",
    "outputId": "fb6859b0-9cce-405b-e596-8d07f1a73ba2",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# DS would automatically contain information from the root group\n",
    "# Print the instance of the file from the root group\n",
    "print(DS)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85479255",
   "metadata": {
    "id": "85479255"
   },
   "source": [
    "The printout for the root group above shows all of the global attributes &mdash; e.g., dataset title, file ID, product version, etc. You can simply glean those information from the output above.\n",
    "\n",
    "Having gleaned the global attributes above, you can directly load a particular attribute from the root group using the `getncattr` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bd344c2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 12,
     "status": "ok",
     "timestamp": 1694638573634,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "3bd344c2",
    "outputId": "85f07f08-8126-46c8-e7d3-b7694d9e3e08"
   },
   "outputs": [],
   "source": [
    "# Load the \"summary\" attribute from the root group as root_summary\n",
    "root_summary = DS.getncattr(\"summary\")\n",
    "\n",
    "# Print root_summary\n",
    "print(root_summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "151968b4",
   "metadata": {
    "id": "151968b4"
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<h3>Exercise 1</h3>\n",
    "Using the example above, uncomment the template below, and change the code as necessary to load the \"title\" attribute from the root group.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "571NTsqFcLnV",
   "metadata": {
    "id": "571NTsqFcLnV"
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Hint:</b> If you are unsure about what attributes are available, print out the root group instance again.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef5dd45c",
   "metadata": {
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1694638573634,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "ef5dd45c"
   },
   "outputs": [],
   "source": [
    "# Load the \"title\" attribute from the root group as root_title\n",
    "#root_title = DS.getncattr(\"insert_attr_here\")\n",
    "\n",
    "# Print root_title\n",
    "#print(root_title)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d75a4662",
   "metadata": {
    "id": "d75a4662"
   },
   "source": [
    "Awesome! Now, let's step back and look at the root group again, printed out below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f8e20f6",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1694638573634,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "6f8e20f6",
    "outputId": "c0f9254d-5041-498a-cfa8-3f14cf5d6a33",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Print the instance of the file from the root group\n",
    "print(DS)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d120b8b",
   "metadata": {
    "id": "1d120b8b"
   },
   "source": [
    "Notice at the end of the printout, the available \"dimensions,\" \"variables,\" and \"groups\" are listed for the root group. **These are not part of the TC PRIMED file metadata, but are part of the standard output of the Python netCDF4 package as additional information**. Nonetheless, we can use that information. Under groups, six groups are listed. They are:\n",
    "- `overpass_metadata`\n",
    "- `overpass_storm_metadata`\n",
    "- `passive_microwave`\n",
    "- `GPROF`\n",
    "- `radar_radiometer`\n",
    "- `infrared`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "gNReQ7AwNkUX",
   "metadata": {
    "id": "gNReQ7AwNkUX"
   },
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>Be careful.</b> The <code>radar_radiometer</code> group is only available for satellites with precipitation radars, such as the TRMM and GPM. Other groups are available across the different sensors and satellites in TC PRIMED.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tBc4ErjdN0HM",
   "metadata": {
    "id": "tBc4ErjdN0HM"
   },
   "source": [
    "Now, let's access the instance of the `passive_microwave` group."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d262526e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1694638573635,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "d262526e",
    "outputId": "8410be6c-e824-4e3f-f49d-260817c71da4"
   },
   "outputs": [],
   "source": [
    "# Using the file instance, load the passive_microwave group as a\n",
    "# group instance called passive_microwave_group\n",
    "passive_microwave_group = DS[\"passive_microwave\"]\n",
    "\n",
    "# Print the passive_microwave group instance\n",
    "print(passive_microwave_group)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb14f7ce",
   "metadata": {
    "id": "eb14f7ce"
   },
   "source": [
    "Notice, as in the root group, the printout above indicates the dimensions, variables, and groups that are available in the `passive_microwave` group. In this example, you have\n",
    "- a `time` dimension of length 1\n",
    "- a `time` variable with a `time` dimension; therefore, a `time` variable of length 1\n",
    "- two sub-groups: `S1` and `S2`\n",
    "\n",
    "Let's load and print out the `time` variable instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35203b16",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1694638573635,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "35203b16",
    "outputId": "981c52e6-b1b5-4d6f-8c93-41b05375f6be"
   },
   "outputs": [],
   "source": [
    "# Using the file instance, load the variable instance for time\n",
    "# in the passive_microwave group by specifying its \"path\" in the file\n",
    "pm_time_instance = DS[\"passive_microwave/time\"]\n",
    "\n",
    "# Print the variable instance of passive microwave time\n",
    "print(pm_time_instance)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4770206c",
   "metadata": {
    "id": "4770206c"
   },
   "source": [
    "From the printout of the time variable instance, you can see information on the `time` variable. As you have seen from printing out the passive microwave group instance above, `time` is a one-dimensional array with one element (`current shape = (1,)`). Let's first retrieve the `long_name` attribute of this time instance using a function we've already used above, `getncattr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "863edd22",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1694638573635,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "863edd22",
    "outputId": "694dfdf8-34cf-4f4e-e691-173799a4d475"
   },
   "outputs": [],
   "source": [
    "# Using the file instance, load the variable instance for time\n",
    "# in the passive_microwave group by specifying its \"path\" in the file\n",
    "# Then, retrieve the long_name attribute using getncattr\n",
    "pm_time_long_name = DS[\"passive_microwave/time\"].getncattr(\"long_name\")\n",
    "\n",
    "# Print the time variable long_name\n",
    "print(pm_time_long_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37eaabaa",
   "metadata": {
    "id": "37eaabaa"
   },
   "source": [
    "Finally, let's retrieve the `time` variable itself from the `time` variable instance. To do so, load the variable from the `time` variable instance using `[:]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccec69ec",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 149,
     "status": "ok",
     "timestamp": 1694638573779,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "ccec69ec",
    "outputId": "cac25440-6755-4ed3-d4e3-b70a399805c8"
   },
   "outputs": [],
   "source": [
    "# Using the file instance, load the time variable from the\n",
    "# passive_microwave group by specifying its \"path\" in the file and\n",
    "# using [:] to load the variable\n",
    "pm_time = DS[\"passive_microwave/time\"][:]\n",
    "\n",
    "# Print the passive microwave time variable\n",
    "print(pm_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45717c1c",
   "metadata": {
    "id": "45717c1c"
   },
   "source": [
    "You've loaded a NetCDF variable! As you have seen in the cells above, it is a one-dimensional array with one element. The `time` variable in TC PRIMED files are in the units of seconds since 1970-01-01T00:00:00. We will briefly discuss this `time` unit in Chapter 1c.\n",
    "\n",
    "For now, let's go back to the `passive_microwave` group instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1712e3a",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 8,
     "status": "ok",
     "timestamp": 1694638573779,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "a1712e3a",
    "outputId": "e467a763-cf00-4d43-a288-7bf548889210"
   },
   "outputs": [],
   "source": [
    "# Using the file instance, load the passive_microwave group as a\n",
    "# group instance called passive_microwave_group\n",
    "passive_microwave_group = DS[\"passive_microwave\"]\n",
    "\n",
    "# Print the passive_microwave group instance\n",
    "print(passive_microwave_group)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed15b31b",
   "metadata": {
    "id": "ed15b31b"
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<h3>Exercise 2</h3> Notice that within the <code>passive_microwave</code> group, there are two additional groups called <code>S1</code> and <code>S2</code>. We will discuss these groups in more detail in Chapter 1b. But for now, using the knowledge you've obtained about NetCDF groups, instances, and variables, uncomment the code below and change the code as necessary to print out the <code>S1</code> group instance from the <code>passive_microwave</code> group."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a62565d",
   "metadata": {
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1694638573779,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "4a62565d"
   },
   "outputs": [],
   "source": [
    "# Using the file instance, load the S1 group within the passive_microwave\n",
    "# group as an instance called S1_group\n",
    "#S1_group = DS[\"insert_S1_group_here\"]\n",
    "\n",
    "# Print the S1 group instance\n",
    "#print(S1_group)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00e6de95",
   "metadata": {
    "id": "00e6de95"
   },
   "source": [
    "From the printout of the `S1` group instance above, you should see two dimensions\n",
    "- `scan` with length 171\n",
    "- `pixel` with length 221\n",
    "\n",
    "You should also see a list of variables such as `latitude` and `longitude`, all of which should have a `scan` dimension or both `scan` and `pixel` dimension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cea58360",
   "metadata": {
    "id": "cea58360"
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<h3>Exercise 3</h3> Using the knowledge you've obtained about NetCDF groups, instances, and variables, uncomment the template below and change the code as necessary to load and print out the <code>latitude</code> variable.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "CVQf9P_RjrkP",
   "metadata": {
    "id": "CVQf9P_RjrkP"
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Hint:</b> When loading variables, don't forget to use <code>[:]</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8cdd320",
   "metadata": {
    "executionInfo": {
     "elapsed": 8,
     "status": "ok",
     "timestamp": 1694638573780,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "a8cdd320"
   },
   "outputs": [],
   "source": [
    "# Using the file instance, load the latitude variable from the\n",
    "# passive_microwave group and S1 sub-group by specifying its \"path\"\n",
    "# in the file, and using [:] to load the variable\n",
    "#S1_latitude = DS[\"insert_latitude_var_here\"]\n",
    "\n",
    "# Print the latitude variable from the passive_microwave group and\n",
    "# the S1 sub-group\n",
    "#print(S1_latitude)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e2cfa7b",
   "metadata": {
    "id": "7e2cfa7b"
   },
   "source": [
    "When loading NetCDF variables, the `[:]` operator loads the full array of the variable. But, what if you only wanted the first 10 entries of the `scan` dimension? You can refer to the dimension information for each variable by first printing out the group or variable instance, like you've done in the cells above. Then, simply supply the read routine with the appropriate index. Let's look at an example by printing out the size of the `latitude` variable being loaded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ecd9a16",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1694638573780,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "2ecd9a16",
    "outputId": "1cc7e1f3-a944-4991-dfde-c6f5dc355bff"
   },
   "outputs": [],
   "source": [
    "# Load the full array of the latitude variable using only [:]\n",
    "S1_full_latitude = DS[\"passive_microwave/S1/latitude\"][:]\n",
    "\n",
    "# Print the shape of the full latitude array\n",
    "print(S1_full_latitude.shape)\n",
    "\n",
    "# Load a subset of the latitude variable for the first 10 entries of the\n",
    "# scan dimension and all of the pixel dimension\n",
    "S1_subset_latitude = DS[\"passive_microwave/S1/latitude\"][np.arange(0,10,1),:]\n",
    "\n",
    "# Print the shape of the latitude variable subset\n",
    "print(S1_subset_latitude.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c69894f",
   "metadata": {
    "id": "4c69894f"
   },
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<h3>Exercise 4</h3> Uncomment the template below and change the code as necessary to load the first 20 entries of the <code>scan</code> dimension and the first 10 entries of the <code>pixel</code> dimension for the latitude variable. Then, print out the shape of the variable array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76323471",
   "metadata": {
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1694638573780,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "76323471"
   },
   "outputs": [],
   "source": [
    "# Load a subset of the latitude variable for the first 20 entries of the\n",
    "# scan dimension and the first 10 entries of the pixel dimension\n",
    "#S1_subset_latitude = DS[\"insert_latitude_var_here\"]\n",
    "\n",
    "# Print the shape of the latitude variable subset\n",
    "#print(S1_subset_latitude.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "j10Qr5IHLDaX",
   "metadata": {
    "id": "j10Qr5IHLDaX"
   },
   "source": [
    "## Close the File\n",
    "When loading data from a NetCDF file, **always remember to close the file**. A best practice would be to close the file immediately after loading the variable or attribute of interest. However, since we're loading various variables and attributes throughout this notebook, we will close the file at the end of this notebook using the command below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "SOisGtrjMUzg",
   "metadata": {
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1694638573781,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "SOisGtrjMUzg"
   },
   "outputs": [],
   "source": [
    "DS.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a389a4d3",
   "metadata": {
    "id": "a389a4d3"
   },
   "source": [
    "## Final Thoughts\n",
    "There are other ways to query NetCDF files, like using [Unidata's NetCDF Utilities](https://docs.unidata.ucar.edu/nug/current/netcdf_utilities_guide.html). However, in this tutorial, you learned how to use the Python `netCDF4` package to:\n",
    "- retrieve information from a remote NetCDF file\n",
    "- print out NetCDF instances\n",
    "- obtain attributes from NetCDF instances\n",
    "- retrieve a variable from NetCDF instances\n",
    "- navigate groups in a NetCDF file\n",
    "- load only a subset of data from a NetCDF variable\n",
    "\n",
    "These are crucial steps for you to get familiarized with the structure of TC PRIMED files before you move on to conducting analyses on TC PRIMED data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "527025da",
   "metadata": {
    "id": "527025da"
   },
   "source": [
    "## Data Statement\n",
    "- Razin, Muhammad Naufal; Slocum, Christopher J.; Knaff, John A.; Brown, Paula J. 2023. Tropical Cyclone PRecipitation, Infrared, Microwave, and Environmental Dataset (TC PRIMED). v01r00. NOAA National Centers for Environmental Information. https://doi.org/10.25921/dmy1-0595."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cce1185",
   "metadata": {},
   "source": [
    "## References\n",
    "- Unidata, 2023: Network Common Data Form (NetCDF). Accessed 13 June 2023, https://www.unidata.ucar.edu/software/netcdf/."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffcc0ab1",
   "metadata": {
    "id": "ffcc0ab1"
   },
   "source": [
    "## Metadata\n",
    "- Language / package\n",
    "    - Python\n",
    "    - netCDF4\n",
    "    - numpy\n",
    "- Application keywords\n",
    "    - NetCDF\n",
    "    - NetCDF Groups\n",
    "- Geophysical keywords\n",
    "    - Tropical Cyclones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1246c922",
   "metadata": {
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1694638573781,
     "user": {
      "displayName": "Naufal Razin",
      "userId": "00945304052336708650"
     },
     "user_tz": 360
    },
    "id": "1246c922"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.15"
  },
  "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": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}