diff --git a/M3N2_final_hw_njm.ipynb b/M3N2_final_hw_njm.ipynb new file mode 100644 index 0000000..4ef6801 --- /dev/null +++ b/M3N2_final_hw_njm.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9d27e63f", + "metadata": {}, + "source": [ + "# Module 3 Project: Daily Climatology and Weather Plot\n", + "\n", + "**Student Name:** Nathan Makowski \n", + "**Course:** ATMS 523 / Weather and Climate Data Analytics \n", + "**Date:** 2025-10-08 \n", + "\n", + "---\n", + "\n", + "### Project Description\n", + "\n", + "This notebook demonstrates the following:\n", + "\n", + "1. Downloading daily GHCN station data from Amazon Web Services for the Metro Detroit station.\n", + "2. Computing the daily climatology (1991–2020) including:\n", + " - Record high and low temperatures\n", + " - Average high and low temperatures for each calendar day\n", + "3. Extracting actual daily temperatures for a specific year (e.g., 2024).\n", + "4. Plotting daily temperatures:\n", + " - Actual high/low temperatures\n", + " - Average high/low temperatures (1991–2020)\n", + " - Record high/low temperatures\n", + "5. Includes intermediate checks to inspect the data at key steps.\n", + "6. Excludes leap day (Feb 29) from all calculations." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b95d74d3", + "metadata": {}, + "outputs": [], + "source": [ + "# -------------------------------\n", + "# Daily Climatology and Plotting\n", + "# -------------------------------\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from datetime import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "05ab62f1", + "metadata": {}, + "outputs": [], + "source": [ + "# -------------------------------\n", + "# Function to download GHCN station data and compute daily climatology\n", + "# -------------------------------\n", + "\n", + "def daily_climatology(station_id, start_year=1991, end_year=2020):\n", + " \"\"\"\n", + " Download GHCN daily data for a station and compute:\n", + " - Record max and min temperatures for each day-of-year (DOY)\n", + " - Average max and min temperatures for 1991-2020\n", + " \n", + " Returns a DataFrame with columns:\n", + " ['record_max_temp','record_min_temp','average_max_temp','average_min_temp',\n", + " 'record_max_year','record_min_year']\n", + " \"\"\"\n", + " # Read station parquet data from AWS\n", + " df = pd.read_parquet(\n", + " f\"s3://noaa-ghcn-pds/parquet/by_station/STATION={station_id}/\",\n", + " storage_options={\"anon\": True}\n", + " )\n", + " print(\"Initial data loaded:\")\n", + " print(df.head())\n", + "\n", + " # Convert date\n", + " df['DATE'] = pd.to_datetime(df['DATE'].apply(lambda x: datetime.strptime(str(x), '%Y%m%d')))\n", + " df = df.set_index('DATE').sort_index()\n", + " print(\"\\nAfter converting DATE to datetime and sorting:\")\n", + " print(df.head())\n", + "\n", + " # Separate TMAX and TMIN\n", + " df_tmax = df[df['ELEMENT']=='TMAX'].copy()\n", + " df_tmin = df[df['ELEMENT']=='TMIN'].copy()\n", + "\n", + " df_tmax['VALUE_C'] = df_tmax['DATA_VALUE'] / 10.0\n", + " df_tmin['VALUE_C'] = df_tmin['DATA_VALUE'] / 10.0\n", + "\n", + " print(f\"\\nTMAX sample:\\n{df_tmax.head()}\")\n", + " print(f\"\\nTMIN sample:\\n{df_tmin.head()}\")\n", + "\n", + " # Function to compute daily stats\n", + " def daily_stats(df_elem):\n", + " df_elem = df_elem[\n", + " ~((df_elem.index.month == 2) & (df_elem.index.day == 29)) # drop Feb 29\n", + " ]\n", + " df_elem = df_elem[(df_elem.index.year >= start_year) & (df_elem.index.year <= end_year)]\n", + " df_elem['DOY'] = df_elem.index.day_of_year\n", + " df_elem['YEAR'] = df_elem.index.year\n", + " \n", + " print(f\"\\nData after filtering years and dropping Feb 29 ({df_elem.index.min()} to {df_elem.index.max()}):\")\n", + " print(df_elem.head())\n", + "\n", + " grouped = df_elem.groupby('DOY')\n", + "\n", + " record_max = grouped['VALUE_C'].max()\n", + " record_max_year = grouped.apply(lambda x: x.loc[x['VALUE_C'].idxmax(), 'YEAR'])\n", + " record_min = grouped['VALUE_C'].min()\n", + " record_min_year = grouped.apply(lambda x: x.loc[x['VALUE_C'].idxmin(), 'YEAR'])\n", + " average = grouped['VALUE_C'].mean()\n", + "\n", + " return pd.DataFrame({\n", + " 'record_temp': record_max if df_elem['ELEMENT'].iloc[0]=='TMAX' else record_min,\n", + " 'average_temp': average,\n", + " 'record_year': record_max_year if df_elem['ELEMENT'].iloc[0]=='TMAX' else record_min_year\n", + " })\n", + "\n", + " tmax_stats = daily_stats(df_tmax).rename(columns={'record_temp':'record_max_temp',\n", + " 'average_temp':'average_max_temp',\n", + " 'record_year':'record_max_year'})\n", + " tmin_stats = daily_stats(df_tmin).rename(columns={'record_temp':'record_min_temp',\n", + " 'average_temp':'average_min_temp',\n", + " 'record_year':'record_min_year'})\n", + " \n", + " print(\"\\nTMAX daily stats sample:\")\n", + " print(tmax_stats.head())\n", + " print(\"\\nTMIN daily stats sample:\")\n", + " print(tmin_stats.head())\n", + "\n", + " # Combine into one DataFrame\n", + " clim = pd.DataFrame({\n", + " 'record_max_temp': tmax_stats['record_max_temp'],\n", + " 'record_max_year': tmax_stats['record_max_year'],\n", + " 'average_max_temp': tmax_stats['average_max_temp'],\n", + " 'average_min_temp': tmin_stats['average_min_temp'],\n", + " 'record_min_temp': tmin_stats['record_min_temp'],\n", + " 'record_min_year': tmin_stats['record_min_year']\n", + " })\n", + "\n", + " print(\"\\nCombined climatology sample:\")\n", + " print(clim.head())\n", + "\n", + " return clim, df_tmax, df_tmin" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "173cd9a3", + "metadata": {}, + "outputs": [], + "source": [ + "# -------------------------------\n", + "# Prepare daily data for a specific year\n", + "# -------------------------------\n", + "\n", + "def daily_year_data(df_tmax, df_tmin, year):\n", + " \"\"\"\n", + " Prepare daily actual temperatures for a specific year\n", + " \"\"\"\n", + " df_tmax_year = df_tmax[df_tmax.index.year == year][['VALUE_C']].rename(columns={'VALUE_C':'TMAX'})\n", + " df_tmin_year = df_tmin[df_tmin.index.year == year][['VALUE_C']].rename(columns={'VALUE_C':'TMIN'})\n", + "\n", + " print(f\"\\nTMAX for {year} sample:\")\n", + " print(df_tmax_year.head())\n", + " print(f\"\\nTMIN for {year} sample:\")\n", + " print(df_tmin_year.head())\n", + " \n", + " # Merge on date index\n", + " df_year = df_tmax_year.join(df_tmin_year, how='inner')\n", + " \n", + " # Drop Feb 29 if exists\n", + " df_year = df_year[~((df_year.index.month==2) & (df_year.index.day==29))]\n", + " \n", + " df_year['DOY'] = df_year.index.day_of_year\n", + "\n", + " print(f\"\\nMerged daily data for {year} sample:\")\n", + " print(df_year.head())\n", + "\n", + " return df_year" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5c679b29", + "metadata": {}, + "outputs": [], + "source": [ + "# -------------------------------\n", + "# Plot function\n", + "# -------------------------------\n", + "\n", + "def plot_year_temperatures(clim, df_year, city_name='Detroit', year=2024):\n", + " \"\"\"\n", + " Plot record, average, and actual TMAX/TMIN for a given year\n", + " \"\"\"\n", + " plt.figure(figsize=(15,6))\n", + " \n", + " # Actual\n", + " plt.plot(df_year['DOY'], df_year['TMAX'], color='red', alpha=0.7, label='Actual Max')\n", + " plt.plot(df_year['DOY'], df_year['TMIN'], color='blue', alpha=0.7, label='Actual Min')\n", + " \n", + " # Climatology\n", + " plt.plot(clim.index, clim['average_max_temp'], color='orange', linestyle='--', label='Average Max (1991-2020)')\n", + " plt.plot(clim.index, clim['average_min_temp'], color='cyan', linestyle='--', label='Average Min (1991-2020)')\n", + " \n", + " # Records\n", + " plt.plot(clim.index, clim['record_max_temp'], color='darkred', linestyle=':', label='Record Max')\n", + " plt.plot(clim.index, clim['record_min_temp'], color='darkblue', linestyle=':', label='Record Min')\n", + " \n", + " plt.title(f'Daily Temperatures for {city_name} in {year}')\n", + " plt.xlabel('Day of Year')\n", + " plt.ylabel('Temperature (°C)')\n", + " plt.legend()\n", + " plt.grid(alpha=0.3)\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "e9c4987d", + "metadata": {}, + "source": [ + "## Daily Temperatures for 2024\n", + "\n", + "This plot displays the daily temperatures for **Detroit Metro Airport** in **2024**, including:\n", + "\n", + "- **Actual Temperatures:** \n", + " - Red line: Actual daily maximum temperature \n", + " - Blue line: Actual daily minimum temperature\n", + "\n", + "- **Climatological Averages (1991–2020):** \n", + " - Orange dashed line: Average daily maximum temperature \n", + " - Cyan dashed line: Average daily minimum temperature\n", + "\n", + "- **Records (1991–2020):** \n", + " - Dark red dotted line: Record daily maximum temperature \n", + " - Dark blue dotted line: Record daily minimum temperature\n", + "\n", + "Leap day (February 29) is excluded from both the climatology and 2024 data." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c3544c12", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial data loaded:\n", + " ID DATE DATA_VALUE M_FLAG Q_FLAG S_FLAG OBS_TIME ELEMENT\n", + "0 USW00094847 19950709 0 None None X None ACMC\n", + "1 USW00094847 19650101 100 None None X None ACMH\n", + "2 USW00094847 19650102 100 None None X None ACMH\n", + "3 USW00094847 19650103 40 None None X None ACMH\n", + "4 USW00094847 19650104 90 None None X None ACMH\n", + "\n", + "After converting DATE to datetime and sorting:\n", + " ID DATA_VALUE M_FLAG Q_FLAG S_FLAG OBS_TIME ELEMENT\n", + "DATE \n", + "1942-08-01 USW00094847 229 H None S None TAVG\n", + "1942-08-02 USW00094847 241 H None S None TAVG\n", + "1942-08-03 USW00094847 218 H None S None TAVG\n", + "1942-08-04 USW00094847 206 H None S None TAVG\n", + "1942-08-05 USW00094847 201 H None S None TAVG\n", + "\n", + "TMAX sample:\n", + " ID DATA_VALUE M_FLAG Q_FLAG S_FLAG OBS_TIME ELEMENT \\\n", + "DATE \n", + "1958-12-01 USW00094847 -17 None None 0 2400 TMAX \n", + "1958-12-02 USW00094847 17 None None 0 2400 TMAX \n", + "1958-12-03 USW00094847 33 None None 0 2400 TMAX \n", + "1958-12-04 USW00094847 56 None None 0 2400 TMAX \n", + "1958-12-05 USW00094847 6 None None 0 2400 TMAX \n", + "\n", + " VALUE_C \n", + "DATE \n", + "1958-12-01 -1.7 \n", + "1958-12-02 1.7 \n", + "1958-12-03 3.3 \n", + "1958-12-04 5.6 \n", + "1958-12-05 0.6 \n", + "\n", + "TMIN sample:\n", + " ID DATA_VALUE M_FLAG Q_FLAG S_FLAG OBS_TIME ELEMENT \\\n", + "DATE \n", + "1959-01-01 USW00094847 -6 None None 0 2400 TMIN \n", + "1959-01-02 USW00094847 -11 None None 0 2400 TMIN \n", + "1959-01-03 USW00094847 -67 None None 0 2400 TMIN \n", + "1959-01-04 USW00094847 -161 None None 0 2400 TMIN \n", + "1959-01-05 USW00094847 -206 None None 0 2400 TMIN \n", + "\n", + " VALUE_C \n", + "DATE \n", + "1959-01-01 -0.6 \n", + "1959-01-02 -1.1 \n", + "1959-01-03 -6.7 \n", + "1959-01-04 -16.1 \n", + "1959-01-05 -20.6 \n", + "\n", + "Data after filtering years and dropping Feb 29 (1991-01-01 00:00:00 to 2020-12-31 00:00:00):\n", + " ID DATA_VALUE M_FLAG Q_FLAG S_FLAG OBS_TIME ELEMENT \\\n", + "DATE \n", + "1991-01-01 USW00094847 -6 None None 0 2400 TMAX \n", + "1991-01-02 USW00094847 28 None None 0 2400 TMAX \n", + "1991-01-03 USW00094847 -50 None None 0 2400 TMAX \n", + "1991-01-04 USW00094847 -17 None None 0 2400 TMAX \n", + "1991-01-05 USW00094847 -11 None None 0 2400 TMAX \n", + "\n", + " VALUE_C DOY YEAR \n", + "DATE \n", + "1991-01-01 -0.6 1 1991 \n", + "1991-01-02 2.8 2 1991 \n", + "1991-01-03 -5.0 3 1991 \n", + "1991-01-04 -1.7 4 1991 \n", + "1991-01-05 -1.1 5 1991 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_8774/2814963747.py:54: FutureWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " record_max_year = grouped.apply(lambda x: x.loc[x['VALUE_C'].idxmax(), 'YEAR'])\n", + "/tmp/ipykernel_8774/2814963747.py:56: FutureWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " record_min_year = grouped.apply(lambda x: x.loc[x['VALUE_C'].idxmin(), 'YEAR'])\n", + "/tmp/ipykernel_8774/2814963747.py:54: FutureWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " record_max_year = grouped.apply(lambda x: x.loc[x['VALUE_C'].idxmax(), 'YEAR'])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Data after filtering years and dropping Feb 29 (1991-01-01 00:00:00 to 2020-12-31 00:00:00):\n", + " ID DATA_VALUE M_FLAG Q_FLAG S_FLAG OBS_TIME ELEMENT \\\n", + "DATE \n", + "1991-01-01 USW00094847 -106 None None 0 2400 TMIN \n", + "1991-01-02 USW00094847 -56 None None 0 2400 TMIN \n", + "1991-01-03 USW00094847 -106 None None 0 2400 TMIN \n", + "1991-01-04 USW00094847 -117 None None 0 2400 TMIN \n", + "1991-01-05 USW00094847 -78 None None 0 2400 TMIN \n", + "\n", + " VALUE_C DOY YEAR \n", + "DATE \n", + "1991-01-01 -10.6 1 1991 \n", + "1991-01-02 -5.6 2 1991 \n", + "1991-01-03 -10.6 3 1991 \n", + "1991-01-04 -11.7 4 1991 \n", + "1991-01-05 -7.8 5 1991 \n", + "\n", + "TMAX daily stats sample:\n", + " record_max_temp average_max_temp record_max_year\n", + "DOY \n", + "1 11.7 1.536667 2011\n", + "2 13.9 1.913333 2000\n", + "3 14.4 1.656667 2004\n", + "4 16.1 2.003333 1997\n", + "5 15.0 0.716667 1997\n", + "\n", + "TMIN daily stats sample:\n", + " record_min_temp average_min_temp record_min_year\n", + "DOY \n", + "1 -18.8 -6.096667 2018\n", + "2 -17.7 -5.723333 2018\n", + "3 -20.5 -5.283333 2014\n", + "4 -17.2 -5.176667 1996\n", + "5 -23.3 -6.290000 1999\n", + "\n", + "Combined climatology sample:\n", + " record_max_temp record_max_year average_max_temp average_min_temp \\\n", + "DOY \n", + "1 11.7 2011 1.536667 -6.096667 \n", + "2 13.9 2000 1.913333 -5.723333 \n", + "3 14.4 2004 1.656667 -5.283333 \n", + "4 16.1 1997 2.003333 -5.176667 \n", + "5 15.0 1997 0.716667 -6.290000 \n", + "\n", + " record_min_temp record_min_year \n", + "DOY \n", + "1 -18.8 2018 \n", + "2 -17.7 2018 \n", + "3 -20.5 2014 \n", + "4 -17.2 1996 \n", + "5 -23.3 1999 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_8774/2814963747.py:56: FutureWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " record_min_year = grouped.apply(lambda x: x.loc[x['VALUE_C'].idxmin(), 'YEAR'])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "TMAX for 2024 sample:\n", + " TMAX\n", + "DATE \n", + "2024-01-01 2.2\n", + "2024-01-02 0.6\n", + "2024-01-03 1.7\n", + "2024-01-04 0.0\n", + "2024-01-05 0.0\n", + "\n", + "TMIN for 2024 sample:\n", + " TMIN\n", + "DATE \n", + "2024-01-01 -0.5\n", + "2024-01-02 -1.0\n", + "2024-01-03 0.0\n", + "2024-01-04 -7.1\n", + "2024-01-05 -7.1\n", + "\n", + "Merged daily data for 2024 sample:\n", + " TMAX TMIN DOY\n", + "DATE \n", + "2024-01-01 2.2 -0.5 1\n", + "2024-01-02 0.6 -1.0 2\n", + "2024-01-03 1.7 0.0 3\n", + "2024-01-04 0.0 -7.1 4\n", + "2024-01-05 0.0 -7.1 5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# -------------------------------\n", + "# For Detroit Metro Airport (USW00094847)\n", + "# -------------------------------\n", + "\n", + "station_id = \"USW00094847\"\n", + "clim, df_tmax, df_tmin = daily_climatology(station_id)\n", + "df_2024 = daily_year_data(df_tmax, df_tmin, 2024)\n", + "plot_year_temperatures(clim, df_2024, city_name='Detroit Metro Airport', year=2024)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46bc4cbb", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/README.md b/README.md index 3dbf7ef..4877ab1 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,37 @@ -# ATMS 523 Module-3 +# Module 3 Project: Daily Climatology and Weather Plot -Code, notebooks, and homework for ATMS 523 Module 3. +**Student Name:** Nathan Makowski +**Course:** ATMS 523 / Weather and Climate Data Analytics +**Date:** 2025-10-08 + +--- + +## Project Overview + +This project demonstrates how to: + +1. **Download daily GHCN station data** from Amazon Web Services (AWS) for a selected station. +2. **Compute daily climatology** for the 1991–2020 period, including: + - Record high and low temperatures + - Average high and low temperatures for each calendar day +3. **Extract actual daily temperatures** for a specific year (2024 in this case). +4. **Visualize the data** using `matplotlib` with a plot that shows: + - Actual daily high and low temperatures + - Climatological average high and low temperatures + - Record high and low temperatures +5. Excludes leap day (February 29) from all calculations. + +--- + +## Files + +- `M3N2_final_hw_njm.ipynb` — The Jupyter Notebook containing all code, checks, and plots. +- `README.md` — This file explaining the project and its contents. + +--- + +## How to Run + +1. Ensure Python 3.10+ and the required packages are installed: + ```bash + pip install pandas numpy matplotlib pyarrow