From 6c4647a58e976e5eb88b0e63dfd07dd0b3170df1 Mon Sep 17 00:00:00 2001 From: iammeghana Date: Mon, 19 Aug 2024 14:37:28 -0400 Subject: [PATCH 1/2] added utility functions --- book/chapters/gridmet.ipynb | 2177 ++++++++++++++++++----------------- 1 file changed, 1099 insertions(+), 1078 deletions(-) diff --git a/book/chapters/gridmet.ipynb b/book/chapters/gridmet.ipynb index 92ba6f2..9f9c318 100644 --- a/book/chapters/gridmet.ipynb +++ b/book/chapters/gridmet.ipynb @@ -30,1116 +30,1381 @@ }, { "cell_type": "markdown", - "id": "3a1c3a47d3070625", + "id": "9ba26855", "metadata": {}, "source": [ - "## 3.2.1.1 Setup and Variable Mapping\n", + "## 3.2.1.1 Create a GridMET to DEM Mapper\n", "\n", - "The following code snippet sets up the environment by importing necessary libraries, defining a workspace, and mapping variables.\n", + "Here we generates a mapping between the coordinates in a DEM (Digital Elevation Model) and the corresponding coordinates in a GridMET dataset, saving the result to a CSV file.\n", "\n", - "- `gridmet_var_mapping`: A dictionary that associates short-form variable names with their full descriptive names.\n", + "- `nc_file`: A NetCDF file containing GridMET data, from which latitude and longitude arrays are extracted.\n", + "- `western_us_dem_df`: A DataFrame containing DEM coordinates loaded from a CSV file.\n", + "- `target_csv_path`: A string representing the file path where the resulting mapping CSV will be saved.\n", + "- `latitudes`: A `numpy` array of latitude values extracted from the NetCDF file.\n", + "- `longitudes`: A `numpy` array of longitude values extracted from the NetCDF file.\n", + "- `get_gridmet_var_value(row)`: A function that finds the nearest GridMET coordinates for a given DEM coordinate and returns those coordinates along with their indices.\n", "\n", - "- The `colors` list represents a gradient of colors associated with specific ranges of values" + "Here we create a detailed mapping between DEM coordinates and GridMET coordinates, facilitating the integration of data from different sources. This is crucial for tasks like spatial analysis, where accurate alignment between datasets is required." ] }, { "cell_type": "code", - "execution_count": 59, - "id": "174c8d71", + "execution_count": 69, + "id": "6173cfa8", "metadata": {}, "outputs": [], "source": [ - "import os\n", - "import numpy as np\n", - "import pandas as pd\n", - "import netCDF4 as nc\n", - "import urllib.request\n", - "from datetime import datetime, timedelta, date\n", - "import matplotlib.pyplot as plt\n", - "\n", - "work_dir = \"../data/gridmet_test_run\"\n", - "\n", - "gridmet_var_mapping = {\n", - " \"etr\": \"potential_evapotranspiration\",\n", - " \"pr\":\"precipitation_amount\",\n", - " \"rmax\":\"relative_humidity\",\n", - " \"rmin\":\"relative_humidity\",\n", - " \"tmmn\":\"air_temperature\",\n", - " \"tmmx\":\"air_temperature\",\n", - " \"vpd\":\"mean_vapor_pressure_deficit\",\n", - " \"vs\":\"wind_speed\",\n", - "}\n", - "\n", - "colors = [\n", - " (0.8627, 0.8627, 0.8627), # #DCDCDC - 0 - 1\n", - " (0.8627, 1.0000, 1.0000), # #DCFFFF - 1 - 2\n", - " (0.6000, 1.0000, 1.0000), # #99FFFF - 2 - 4\n", - " (0.5569, 0.8235, 1.0000), # #8ED2FF - 4 - 6\n", - " (0.4509, 0.6196, 0.8745), # #739EDF - 6 - 8\n", - " (0.4157, 0.4706, 1.0000), # #6A78FF - 8 - 10\n", - " (0.4235, 0.2784, 1.0000), # #6C47FF - 10 - 12\n", - " (0.5529, 0.0980, 1.0000), # #8D19FF - 12 - 14\n", - " (0.7333, 0.0000, 0.9176), # #BB00EA - 14 - 16\n", - " (0.8392, 0.0000, 0.7490), # #D600BF - 16 - 18\n", - " (0.7569, 0.0039, 0.4549), # #C10074 - 18 - 20\n", - " (0.6784, 0.0000, 0.1961), # #AD0032 - 20 - 30\n", - " (0.5020, 0.0000, 0.0000) # #800000 - > 30\n", - "]" + "def create_gridmet_to_dem_mapper(nc_file):\n", + " western_us_dem_df = pd.read_csv(western_us_coords)\n", + " # Check if the CSV already exists\n", + " target_csv_path = f'{work_dir}/gridmet_to_dem_mapper.csv'\n", + " if os.path.exists(target_csv_path):\n", + " print(f\"File {target_csv_path} already exists, skipping..\")\n", + " return\n", + " \n", + " # get the netcdf file and generate the csv file for every coordinate in the dem_template.csv\n", + " selected_date = datetime.strptime(test_start_date, \"%Y-%m-%d\")\n", + " # Read the NetCDF file\n", + " with nc.Dataset(nc_file) as nc_file:\n", + " \n", + " # Get the values at each coordinate using rasterio's sample function\n", + " latitudes = nc_file.variables['lat'][:]\n", + " longitudes = nc_file.variables['lon'][:]\n", + " \n", + " def get_gridmet_var_value(row):\n", + " # Perform your custom calculation here\n", + " gridmet_lat_index = find_nearest_index(latitudes, float(row[\"Latitude\"]))\n", + " gridmet_lon_index = find_nearest_index(longitudes, float(row[\"Longitude\"]))\n", + " return latitudes[gridmet_lat_index], longitudes[gridmet_lon_index], gridmet_lat_index, gridmet_lon_index\n", + " \n", + " # Use the apply function to apply the custom function to each row\n", + " western_us_dem_df[['gridmet_lat', 'gridmet_lon', \n", + " 'gridmet_lat_idx', 'gridmet_lon_idx',]] = western_us_dem_df.apply(lambda row: pd.Series(get_gridmet_var_value(row)), axis=1)\n", + " western_us_dem_df.rename(columns={\"Latitude\": \"dem_lat\", \n", + " \"Longitude\": \"dem_lon\"}, inplace=True)\n", + " \n", + " # Save the new converted AMSR to CSV file\n", + " western_us_dem_df.to_csv(target_csv_path, index=False)\n", + " \n", + " return western_us_dem_df" ] }, { "cell_type": "markdown", - "id": "6a0c2267", + "id": "e44f963a", "metadata": {}, "source": [ - "## 3.2.1.2 Map Values to Colors\n", - "\n", - "Here we generate a color mapping for a given column of data based on specified or automatically calculated value ranges. It returns the color mapping and the value ranges used.\n", + "## 3.2.1.2 Extracts NetCDF Data by Coordinates and Variable\n", "\n", - "- `df_col` (required): The data column from a DataFrame to map to colors.\n", - "- `value_ranges` (optional): A list of value ranges to determine the mapping of data values to colors. If not provided, the function calculates the ranges automatically.\n", - "- `map_value_to_color` takes a value and maps it to a color based on the `new_value_ranges`.\n", - "- It iterates through the ranges, assigning a color to the value based on which range it falls into.\n", - "- If the value is greater than all the defined ranges, the last color in the list is used.\n", + "The following code extracts specific meteorological data from a NetCDF file based on provided coordinates and a variable name, and returns the data in a pandas DataFrame.\n", "\n", - "we get the `color_mapping` (list of colors corresponding to each value in the data column) and `new_value_ranges` (the calculated or provided value ranges)." + "- `mapper_df`: A DataFrame containing the mapping between DEM coordinates and GridMET coordinates.\n", + "- `latitudes`: A `numpy` array of latitude values from the NetCDF file.\n", + "- `longitudes`: A `numpy` array of longitude values from the NetCDF file.\n", + "- `var_col`: The data array for the selected variable from the NetCDF file.\n", + "- `get_gridmet_var_value(row)`: Here we extract the variable value for each coordinate from the NetCDF data.\n", + "- `Latitude`, `Longitude`: The final latitude and longitude columns in the returned DataFrame.\n", + "- Here we automate the process of extracting specific meteorological data from a NetCDF file based on geospatial coordinates, allowing for detailed analysis of climate variables at specific locations.\n", + "- By leveraging a pre-generated mapping (from DEM to GridMET coordinates `3.1.10`), the function efficiently retrieves the data for the exact locations of interest, making it highly useful in spatial analysis and modeling tasks.\n" ] }, { "cell_type": "code", - "execution_count": 60, - "id": "47f03b97", + "execution_count": 71, + "id": "c09fdd0c", "metadata": {}, "outputs": [], "source": [ - "def create_color_maps_with_value_range(df_col, value_ranges=None):\n", - " if value_ranges == None:\n", - " max_value = df_col.max()\n", - " min_value = df_col.min()\n", - " if min_value < 0:\n", - " min_value = 0\n", - " step_size = (max_value - min_value) / 12\n", - "\n", - " # Create 10 periods\n", - " new_value_ranges = [min_value + i * step_size for i in range(12)]\n", - " # Define your custom function to map data values to colors\n", - " def map_value_to_color(value):\n", - " # Iterate through the value ranges to find the appropriate color index\n", - " for i, range_max in enumerate(new_value_ranges):\n", - " if value <= range_max:\n", - " return colors[i]\n", - "\n", - " # If the value is greater than the largest range, return the last color\n", - " return colors[-1]\n", + "def get_nc_csv_by_coords_and_variable(nc_file, var_name, target_date=test_start_date):\n", + " \n", + " create_gridmet_to_dem_mapper(nc_file)\n", + " \t\n", + " mapper_df = pd.read_csv(f'{work_dir}/gridmet_to_dem_mapper.csv')\n", + " \n", + " # get the netcdf file and generate the csv file for every coordinate in the dem_template.csv\n", + " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", + " # Read the NetCDF file\n", + " with nc.Dataset(nc_file) as nc_file:\n", + " # Get a list of all variables in the NetCDF file\n", + " variables = nc_file.variables.keys()\n", + " \n", + " # Get the values at each coordinate using rasterio's sample function\n", + " latitudes = nc_file.variables['lat'][:]\n", + " longitudes = nc_file.variables['lon'][:]\n", + " day = nc_file.variables['day'][:]\n", + " long_var_name = gridmet_var_mapping[var_name]\n", + " var_col = nc_file.variables[long_var_name][:]\n", "\n", - " # Map predicted_swe values to colors using the custom function\n", - " color_mapping = [map_value_to_color(value) for value in df_col.values]\n", - " return color_mapping, new_value_ranges" + " \n", + " # Calculate the day of the year\n", + " day_of_year = selected_date.timetuple().tm_yday\n", + " day_index = day_of_year - 1\n", + " \n", + " def get_gridmet_var_value(row):\n", + " # Perform your custom calculation here\n", + " lat_index = int(row[\"gridmet_lat_idx\"])\n", + " lon_index = int(row[\"gridmet_lon_idx\"])\n", + " var_value = var_col[day_index, lat_index, lon_index]\n", + " \n", + " return var_value\n", + " \n", + " # Use the apply function to apply the custom function to each row\n", + " mapper_df[var_name] = mapper_df.apply(get_gridmet_var_value, axis=1)\n", + " \n", + " # drop useless columns\n", + " mapper_df = mapper_df[[\"dem_lat\", \"dem_lon\", var_name]]\n", + " mapper_df.rename(columns={\"dem_lat\": \"Latitude\",\n", + " \"dem_lon\": \"Longitude\"}, inplace=True)\n", + " return mapper_df" ] }, { "cell_type": "markdown", - "id": "341d9f43", + "id": "6c685758", "metadata": {}, "source": [ - "## 3.2.1.3 Retrive the Current Year\n", + "## 3.2.1.3 Converts GridMET NetCDF Files to CSV\n", "\n", - "The following code snippet retrives the current year from the system's date and time." + "Here we converts NetCDF files containing GridMET meteorological data into CSV files for a specific date. It processes each NetCDF file in a specified directory and extracts relevant data based on the date provided.\n", + "\n", + "- `selected_date`: A `datetime` object representing the `target_date`.\n", + "- `generated_csvs`: A list that stores the paths to the CSV files that are generated during the function's execution.\n", + "- `res_csv`: The path where the resulting CSV file will be saved.\n", + "\n", + "- Here we automate the process of converting multiple NetCDF files into CSV format, making it easier to handle and analyze the data outside of specialized NetCDF tools.\n", + "\n", + "- We extract data for a specific variable from a NetCDF file by matching coordinates from a DEM template CSV file. This enables us to create a DataFrame containing the variable values alongside the corresponding coordinates. \n", + "\n", + "- By doing so, we can effectively extract and analyze meteorological data for specific geographical locations, aiding in various environmental and geographical studies, as well as modeling endeavors." ] }, { "cell_type": "code", - "execution_count": 61, - "id": "92e47a12", + "execution_count": 72, + "id": "46b63faa", "metadata": {}, "outputs": [], "source": [ - "def get_current_year():\n", - " \"\"\"\n", - " Get the current year.\n", + "def turn_gridmet_nc_to_csv(target_date=test_start_date):\n", + " \n", + " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", + " generated_csvs = []\n", + " for root, dirs, files in os.walk(gridmet_folder_name):\n", + " for file_name in files:\n", + " \n", + " if str(selected_date.year) in file_name and file_name.endswith(\".nc\"):\n", + " print(f\"Checking file: {file_name}\")\n", + " var_name = get_var_from_file_name(file_name)\n", + " res_csv = f\"../data/gridmet_test_run/testing_output/{str(selected_date.year)}_{var_name}_{target_date}.csv\"\n", "\n", - " Returns:\n", - " int: The current year.\n", - " \"\"\"\n", - " now = datetime.now()\n", - " current_year = now.year\n", - " return current_year" + " if os.path.exists(res_csv):\n", + " #os.remove(res_csv)\n", + " # print(f\"{res_csv} already exists. Skipping..\")\n", + " print(f\"File {os.path.basename(res_csv)} exists\")\n", + " generated_csvs.append(res_csv)\n", + " continue\n", + "\n", + " # Perform operations on each file here\n", + " netcdf_file_path = os.path.join(root, file_name)\n", + " print(\"Processing file:\", netcdf_file_path)\n", + " file_name = get_file_name_from_path(netcdf_file_path)\n", + "\n", + " df = get_nc_csv_by_coords_and_variable(netcdf_file_path, \n", + " var_name, target_date)\n", + " df.replace('--', pd.NA, inplace=True)\n", + " df.to_csv(res_csv, index=False)\n", + " print(\"gridmet var saved: \", res_csv)\n", + " generated_csvs.append(res_csv)\n", + " \n", + " return generated_csvs " ] }, { "cell_type": "markdown", - "id": "c84bca49", + "id": "77512189", "metadata": {}, "source": [ - "## 3.2.1.4 Removes Specific Files in a Folder\n", + "## 3.2.1.4 Plot GridMET Data\n", "\n", - "We remove all files within the specified folder.\n", + "The following code snippet generates a scatter plot of GridMET data for a specified date and saves the resulting image to a file. It processes data from a CSV file and creates a visual representation of the variable \"pr\" (precipitation) on a geographical grid.\n", "\n", - "- `folder_path`: A string representing the directory where files are to be removed.\n", - "- `current_year`: An integer representing the current year, used to filter which files should be deleted.\n", - "- `files`: A list containing the names of all items (files and directories) within the specified folder.\n", - "- `file_path`: A string representing the full path to each file in the folder, constructed by joining folder_path and the file name.\n", + "- `target_date`: The date for which the data is plotted, formatted as \"YYYY-MM-DD\".\n", + "- `selected_date`: A `datetime` object representing the `target_date`.\n", + "- `var_name`: A string representing the name of the variable to be plotted, set to \"pr\" (precipitation).\n", + "- `test_csv`: The file path to the CSV file containing the data to be plotted.\n", + "- `gridmet_var_df`: A DataFrame containing the loaded data from the CSV file.\n", + "- `colormaplist`: A list of colors corresponding to the value ranges in the data.\n", + "- `value_ranges`: The value ranges used to map the colors in the plot.\n", + "- `res_png_path`: The file path where the resulting plot image will be saved.\n", "\n", - "- The function then loops through each item in the `files` list. For each item:\n", - " - `file_path = os.path.join(folder_path, file)` constructs the full path to the file by combining the folder path and the file name.\n", - " - `if os.path.isfile(file_path) and str(current_year) in file_path and file_path.endswith(\".nc\"):` checks if the item is a file (not a directory), if the file name contains the current year as a substring, and if the file has a `.nc` extension (indicating a NetCDF file).\n", - " - If all these conditions are met, the file is deleted using `os.remove(file_path)`, and a message is printed to confirm the deletion." + "- **Visualization:** This function provides a visual representation of the GridMET data, specifically focusing on precipitation (\"pr\") values. Visualization helps in understanding spatial patterns and distributions in the data, making it easier to interpret and analyze.\n", + "- **Data Communication:** By saving the plot as an image, the function allows the results to be easily shared, included in reports, or further analyzed.\n", + "\n", + "We convert GridMET NetCDF files to CSV format for a specified date. We iterate through files in the GridMET folder, checking for files corresponding to the selected date. For each matching file, we extract the variable name and generate a CSV file containing the data. If the CSV file already exists, we skip the process. This process facilitates easy access and analysis of meteorological data for a specific date." ] }, { "cell_type": "code", - "execution_count": 62, - "id": "1b96876c", + "execution_count": 73, + "id": "62f7b586", "metadata": {}, "outputs": [], "source": [ - "def remove_files_in_folder(folder_path, current_year):\n", - " \"\"\"\n", - " Remove all files in a specified folder.\n", - "\n", - " Parameters:\n", - " folder_path (str): Path to the folder to remove files from.\n", - " \"\"\"\n", - " # Get a list of files in the folder\n", - " files = os.listdir(folder_path)\n", + "def plot_gridmet(target_date=test_start_date):\n", + " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", + " var_name = \"pr\"\n", + " test_csv = f\"../data/gridmet_test_run/testing_output/{str(selected_date.year)}_{var_name}_{target_date}.csv\"\n", + " gridmet_var_df = pd.read_csv(test_csv)\n", + " gridmet_var_df.replace('--', pd.NA, inplace=True)\n", + " gridmet_var_df.dropna(inplace=True)\n", + " gridmet_var_df['pr'] = pd.to_numeric(gridmet_var_df['pr'], errors='coerce')\n", + " \n", + " colormaplist, value_ranges = create_color_maps_with_value_range(gridmet_var_df[var_name])\n", + " \n", + " # Create a scatter plot\n", + " plt.scatter(gridmet_var_df[\"Longitude\"].values, \n", + " gridmet_var_df[\"Latitude\"].values, \n", + " label='Pressure', \n", + " color=colormaplist, \n", + " marker='o')\n", "\n", - " # Loop through the files and remove them\n", - " for file in files:\n", - " file_path = os.path.join(folder_path, file)\n", - " if os.path.isfile(file_path) and str(current_year) in file_path and file_path.endswith(\".nc\"):\n", - " os.remove(file_path)\n", - " print(f\"Deleted file: {file_path}\")" + " # Add labels and a legend\n", + " plt.xlabel('X-axis')\n", + " plt.ylabel('Y-axis')\n", + " plt.title('Scatter Plot Example')\n", + " plt.legend()\n", + " \n", + " res_png_path = f\"../data/gridmet_test_run/testing_output/{str(selected_date.year)}_{var_name}_{target_date}.png\"\n", + " plt.savefig(res_png_path)\n", + " print(f\"test image is saved at {res_png_path}\")" ] }, { "cell_type": "markdown", - "id": "770f22a3", + "id": "c27997ec", "metadata": {}, "source": [ - "## 3.2.1.5 Download File from a URL\n", + "## 3.2.1.5 Prepare Folder and Generating Year List\n", + "The code snippet prepares a directory for storing GridMET NetCDF files and determines the relevant years based on a specified target date. It also checks if existing files cover the selected date and removes them if necessary to ensure up-to-date data.\n", "\n", - "Here we download a file from a given URL and saves it to a specified location.\n", + "- `target_date`: The date for which the data is being prepared, formatted as \"YYYY-MM-DD\".\n", + "- `selected_date`: A `datetime` object representing the `target_date`.\n", + "- `past_october_1`: A `datetime` object representing October 1st of either the current year or the previous year, depending on the `selected_date`.\n", + "- `year_list`: A list of years that are relevant to the `selected_date`, used for data processing.\n", + "- `gridmet_folder_name`: The directory where the GridMET NetCDF files are stored.\n", + "- `nc_file`: The file path to the NetCDF file for the `tmmx` variable of the current year.\n", + "- `ifremove`: A boolean flag indicating whether the existing files should be removed based on the date coverage.\n", "\n", - "- `url`: A string representing the URL from which the file is to be downloaded.\n", - " - `target_file_path`: A string representing the path where the downloaded file should be saved.\n", + "- **Folder Preparation:** Ensuring that the necessary directory exists before proceeding with file operations is crucial for organizing and managing data effectively.\n", + "- **Data Integrity:** By checking whether existing files cover the required date range and removing them if they do not, the function ensures that the data used in the project is up-to-date and accurate.\n", + "- **Year Selection:** The `year_list` is essential for determining which years' data should be processed, ensuring that the analysis covers the appropriate time span.\n", "\n", - "- `with urllib.request.urlopen(url) as response:` opens a connection to the provided URL.\n", - " - `file_content = response.read()` reads the contents of the file from the URL." + "We plot GridMET meteorological data for a specific variable and date. We read the data from a corresponding CSV file and preprocess it, ensuring valid numerical values. Then, we create a scatter plot, mapping the variable values to geographic coordinates. The color of each point on the plot represents the magnitude of the variable value. Finally, we save the plot as a PNG image for further analysis and visualization." ] }, { "cell_type": "code", - "execution_count": 63, - "id": "d7c28a1a", + "execution_count": 74, + "id": "1c643f91", "metadata": {}, "outputs": [], "source": [ - "def download_file(url, target_file_path, variable):\n", - " \"\"\"\n", - " Download a file from a URL and save it to a specified location.\n", + "def prepare_folder_and_get_year_list(target_date=test_start_date):\n", + " # Check if the folder exists, if not, create it\n", + " if not os.path.exists(gridmet_folder_name):\n", + " os.makedirs(gridmet_folder_name)\n", "\n", - " Parameters:\n", - " url (str): URL of the file to download.\n", - " target_file_path (str): Path where the downloaded file should be saved.\n", - " variable (str): Name of the meteorological variable being downloaded.\n", - " \"\"\"\n", - " try:\n", - " with urllib.request.urlopen(url) as response:\n", - " print(f\"Downloading {url}\")\n", - " file_content = response.read()\n", - " save_path = target_file_path\n", - " with open(save_path, 'wb') as file:\n", - " file.write(file_content)\n", - " print(f\"File downloaded successfully and saved as: {os.path.basename(save_path)}\")\n", - " except Exception as e:\n", - " print(f\"An error occurred while downloading the file: {str(e)}\")" + " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", + " if selected_date.month < 10:\n", + " past_october_1 = datetime(selected_date.year - 1, 10, 1)\n", + " else:\n", + " past_october_1 = datetime(selected_date.year, 10, 1)\n", + " year_list = [selected_date.year, past_october_1.year]\n", + "\n", + " # Remove any existing files in the folder\n", + " if selected_date.year == datetime.now().year:\n", + " # check if the current year's netcdf contains the selected date\n", + " # get etr netcdf and read\n", + " nc_file = f\"{gridmet_folder_name}/tmmx_{selected_date.year}.nc\"\n", + " ifremove = False\n", + " if os.path.exists(nc_file):\n", + " with nc.Dataset(nc_file) as ncd:\n", + " day = ncd.variables['day'][:]\n", + " # Calculate the day of the year\n", + " day_of_year = selected_date.timetuple().tm_yday\n", + " day_index = day_of_year - 1\n", + " if len(day) <= day_index:\n", + " ifremove = True\n", + " \n", + " if ifremove:\n", + " print(\"The current year netcdf has new data. Redownloading..\")\n", + " remove_files_in_folder(gridmet_folder_name, selected_date.year) # only redownload when the year is the current year\n", + " else:\n", + " print(\"The existing netcdf already covers the selected date. Avoid downloading..\")\n", + " return year_list" ] }, { "cell_type": "markdown", - "id": "2525baae", + "id": "ccfe1332", "metadata": {}, "source": [ - "## 3.2.1.6 Downloads Specific Meteorological Variables\n", - "\n", - "Here we download specific meteorological variables from the GridMET climatology dataset for a list of years provided as input.\n", + "## 3.2.1.6 Adds a cummulative column\n", "\n", - "- `year_list`: A list of years for which the meteorological data is to be downloaded.\n", - "- `base_metadata_url` is a string that stores the base URL from where the meteorological data files will be downloaded.\n", - "- `variables_list` is a list containing the short names of the meteorological variables to be downloaded, such as `tmmn` (minimum temperature), `tmmx` (maximum temperature), `pr` (precipitation), `vpd` (vapor pressure deficit), `etr` (evapotranspiration), `rmax` (maximum relative humidity), `rmin` (minimum relative humidity), `vs` (wind speed).\n", + "Herw we add a new column to a DataFrame that contains the cumulative sum of the values in an existing column.\n", "\n", - "- The function loops through each variable in `variables_list`.\n", - "- For each variable, it further loops through each year in `year_list`." - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "id": "b73d3c85", - "metadata": {}, - "outputs": [], - "source": [ - "def download_gridmet_of_specific_variables(year_list):\n", - " \"\"\"\n", - " Download specific meteorological variables from the GridMET climatology dataset.\n", - " \"\"\"\n", - " # Make a directory to store the downloaded files\n", + "- `df`: The pandas DataFrame that contains the data to which the cumulative sum column will be added.\n", + "- `column_name`: The name of the column in the DataFrame for which the cumulative sum is to be calculated.\n", "\n", - " base_metadata_url = \"http://www.northwestknowledge.net/metdata/data/\"\n", - " variables_list = ['tmmn', 'tmmx', 'pr', 'vpd', 'etr', 'rmax', 'rmin', 'vs']\n", + "- **Data Enrichment:** Adding a cumulative sum column is useful for understanding trends over time, such as total precipitation over a period, cumulative sales, or accumulated values in any time series data.\n", + "- **Ease of Analysis:** By including the cumulative sum directly in the DataFrame, the function simplifies further analysis and visualization tasks that might require cumulative data.\n", "\n", - " for var in variables_list[:3]:\n", - " for y in year_list:\n", - " download_link = base_metadata_url + var + '_' + '%s' % y + '.nc'\n", - " target_file_path = os.path.join(gridmet_folder_name, var + '_' + '%s' % y + '.nc')\n", - " if not os.path.exists(target_file_path):\n", - " download_file(download_link, target_file_path, var)\n", - " else:\n", - " print(f\"File {os.path.basename(target_file_path)} exists\")" - ] - }, - { - "cell_type": "markdown", - "id": "455b8ece", - "metadata": {}, - "source": [ - "## 3.2.1.7 Extract File Name from File Path\n", "\n", - "Here we extracts the file name from a given file path.\n", - "- `file_path`: A string representing the full path to a file.\n", - "- `file_name = os.path.basename(file_path)` uses the `os.path.basename()` function to extract the file name from the complete file path. The `basename()` function returns the last component of the path, which is the file name." + "We prepare the folder structure for storing GridMET data and obtain a list of relevant years based on the target date. This process ensures that the necessary directory exists for data storage and determines the appropriate years for data retrieval without delving into technical details." ] }, { "cell_type": "code", - "execution_count": 65, - "id": "82adf8a9", + "execution_count": 75, + "id": "1621c7c1", "metadata": {}, "outputs": [], "source": [ - "def get_file_name_from_path(file_path):\n", - " # Get the file name from the file path\n", - " file_name = os.path.basename(file_path)\n", - " return file_name" + "def add_cumulative_column(df, column_name):\n", + " df[f'cumulative_{column_name}'] = df[column_name].sum()\n", + " return df" ] }, { "cell_type": "markdown", - "id": "f0c5e17f", + "id": "100e461b", "metadata": {}, "source": [ - "## 3.2.1.8 Extract Variable Name from File Name\n", - "\n", - "The code snippet extracts the variable name from a given file name, assuming the file name follows a specific format.\n", + "## 3.2.1.7 Prepare Cumulative History CSVs\n", "\n", - "- `file_name`: A string representing the name of the file from which the variable name will be extracted.\n", - "- `var_name = str(file_name.split('_')[0])` splits the file name at the underscore and takes the first part (index `0`), which is expected to be the variable name. The `str()` function ensures that `var_name` is treated as a string." - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "id": "2704d40c", - "metadata": {}, - "outputs": [], - "source": [ - "def get_var_from_file_name(file_name):\n", - " # Assuming the file name format is \"tmmm_year.csv\"\n", - " var_name = str(file_name.split('_')[0])\n", - " return var_name" - ] - }, - { - "cell_type": "markdown", - "id": "dea2dcf9", - "metadata": {}, - "source": [ - "## 3.2.1.9 Extracts Coordinates from a CSV File\n", + "generates cumulative history CSVs for a specified target date. It processes GridMET data by traversing the date range from the previous October 1st to the target date, downloading the necessary data, converting it to CSV, and calculating cumulative values for specific meteorological variables. The results are saved in new CSV files.\n", "\n", - "Here we extracts geographical coordinates (longitude and latitude) from a CSV file and returns them as a list of tuples.\n", + "- `target_date`: The target date for generating cumulative history CSVs.\n", + "- `selected_date`: The `datetime` object representing the `target_date`.\n", + "- `past_october_1`: A `datetime` object representing October 1st of the current or previous year.\n", + "- `generated_csvs`: A list of paths to the CSV files generated for the specific date.\n", + "- `cumulative_target_path`: The file path where the cumulative CSV will be saved.\n", + "- `date_keyed_objects`: A dictionary holding CSV file paths keyed by date.\n", + "- `force`: A boolean flag indicating whether to force regeneration of cumulative CSVs.\n", "\n", - "- `coordinates`: A list initialized as empty and used to store tuples of longitude and latitude values extracted from the CSV file.\n", - "- `df`: A DataFrame created by loading the CSV file using `pandas`. It contains the data from the CSV, including the `Latitude` and `Longitude` columns.\n", - "- `lon`: Represents the longitude extracted from the current row of the DataFrame.\n", - "- `lat`: Represents the latitude extracted from the current row of the DataFrame.\n", - "- Here we iterate over each row in the DataFrame using a `for` loop: `for index, row in df.iterrows():`.\n", - "- For each row, the function extracts the `Latitude` and `Longitude` values, converting them to floating-point numbers: `lon, lat = float(row[\"Latitude\"]), float(row[\"Longitude\"])`.\n", - "- These coordinates are appended to the `coordinates` list as a tuple: `coordinates.append((lon, lat))`." + "- **Cumulative Data Analysis:** The function enables the analysis of cumulative meteorological data, such as total precipitation over a period, which is crucial for understanding long-term trends and impacts.\n", + "- **Automated Data Processing:** By automating the download, processing, and cumulative calculation steps, the function ensures that the data is prepared consistently and efficiently, reducing manual workload.\n" ] }, { "cell_type": "code", - "execution_count": 67, - "id": "a0eca065", + "execution_count": 79, + "id": "ef804f40", "metadata": {}, "outputs": [], "source": [ - "def get_coordinates_of_template_tif():\n", - " \t# Load the CSV file and extract coordinates\n", - " coordinates = []\n", - " df = pd.read_csv(dem_csv)\n", - " for index, row in df.iterrows():\n", - " # Process each row here\n", - " lon, lat = float(row[\"Latitude\"]), float(row[\"Longitude\"])\n", - " coordinates.append((lon, lat))\n", - " return coordinates" - ] - }, - { - "cell_type": "markdown", - "id": "a6869942", - "metadata": {}, - "source": [ - "## 3.2.1.10 Find the Nearest Index in an Array\n", + "def prepare_cumulative_history_csvs(target_date=test_start_date, force=False):\n", + " \"\"\"\n", + " Prepare cumulative history CSVs for a specified target date.\n", "\n", - "- `array`: A `numpy` array of numerical values from which the closest element to `value` is to be found.\n", - "- `value`: A numerical value for which the closest corresponding element in `array` is sought.\n", + " Parameters:\n", + " - target_date (str, optional): The target date in the format 'YYYY-MM-DD'. Default is 'test_start_date'.\n", + " - force (bool, optional): If True, forcefully regenerate cumulative CSVs even if they already exist. Default is False.\n", "\n", - "The code snippet returns the `index` of the element in the array that is closest to the given `value`." - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "6d20022d", - "metadata": {}, - "outputs": [], - "source": [ - "def find_nearest_index(array, value):\n", - " # Find the index of the element in the array that is closest to the given value\n", - " return (abs(array - value)).argmin()" - ] - }, - { - "cell_type": "markdown", - "id": "9ba26855", - "metadata": {}, - "source": [ - "## 3.2.1.11 Create a GridMET to DEM Mapper\n", + " Returns:\n", + " None\n", "\n", - "Here we generates a mapping between the coordinates in a DEM (Digital Elevation Model) and the corresponding coordinates in a GridMET dataset, saving the result to a CSV file.\n", + " This function generates cumulative history CSVs for a specified target date. It traverses the date range from the past\n", + " October 1 to the target date, downloads gridmet data, converts it to CSV, and merges it into a big DataFrame.\n", + " The cumulative values are calculated and saved in new CSV files.\n", "\n", - "- `nc_file`: A NetCDF file containing GridMET data, from which latitude and longitude arrays are extracted.\n", - "- `western_us_dem_df`: A DataFrame containing DEM coordinates loaded from a CSV file.\n", - "- `target_csv_path`: A string representing the file path where the resulting mapping CSV will be saved.\n", - "- `latitudes`: A `numpy` array of latitude values extracted from the NetCDF file.\n", - "- `longitudes`: A `numpy` array of longitude values extracted from the NetCDF file.\n", - "- `get_gridmet_var_value(row)`: A function that finds the nearest GridMET coordinates for a given DEM coordinate and returns those coordinates along with their indices.\n", + " Example:\n", + " ```python\n", + " prepare_cumulative_history_csvs(target_date='2023-01-01', force=True)\n", + " ```\n", + "\n", + " Note: This function assumes the existence of the following helper functions:\n", + " - download_gridmet_of_specific_variables\n", + " - prepare_folder_and_get_year_list\n", + " - turn_gridmet_nc_to_csv\n", + " - add_cumulative_column\n", + " - process_group_value_filling\n", + " ```\n", + "\n", + " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", + " print(selected_date)\n", + " if selected_date.month < 10:\n", + " past_october_1 = datetime(selected_date.year - 1, 10, 1)\n", + " else:\n", + " past_october_1 = datetime(selected_date.year, 10, 1)\n", + "\n", + " # Rest of the function logic...\n", + "\n", + " filled_data = filled_data.loc[:, ['Latitude', 'Longitude', var_name, f'cumulative_{var_name}']]\n", + " print(\"new_df final shape: \", filled_data.head())\n", + " filled_data.to_csv(cumulative_target_path, index=False)\n", + " print(f\"new df is saved to {cumulative_target_path}\")\n", + " print(filled_data.describe())\n", + " ```\n", + "Note: This docstring includes placeholders such as \"download_gridmet_of_specific_variables\" and \"prepare_folder_and_get_year_list\" for the assumed existence of related helper functions. You should replace these placeholders with actual documentation for those functions.\n", + " \"\"\"\n", + " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", + " print(selected_date)\n", + " if selected_date.month < 10:\n", + " past_october_1 = datetime(selected_date.year - 1, 10, 1)\n", + " else:\n", + " past_october_1 = datetime(selected_date.year, 10, 1)\n", + "\n", + " # Traverse and print every day from past October 1 to the specific date\n", + " current_date = past_october_1\n", + " \n", + " date_keyed_objects = {}\n", + " download_gridmet_of_specific_variables(\n", + " prepare_folder_and_get_year_list(target_date=target_date)\n", + " )\n", + " # Set the specific date you want to process\n", + " # current_date = datetime.strptime(\"2024-08-11\", '%Y-%m-%d')\n", + " current_date = datetime.strptime(\"2024-08-11\", '%Y-%m-%d')\n", + "\n", + " # Initialize a dictionary to hold the date-keyed objects\n", + " date_keyed_objects = {}\n", + "\n", + " # Process the specific date\n", + " print('Processing date:', current_date.strftime('%Y-%m-%d'))\n", + " current_date_str = current_date.strftime('%Y-%m-%d')\n", + "\n", + " # Call the function to generate CSVs for the specific date\n", + " generated_csvs = turn_gridmet_nc_to_csv(target_date=current_date_str)\n", + "\n", + " # Read the CSV into a dataframe and store it in the dictionary\n", + " date_keyed_objects[current_date_str] = generated_csvs\n", + "\n", + " print(\"Processing complete for the date:\", current_date_str)\n", + " target_date = '2024-08-11'\n", + " target_generated_csvs = date_keyed_objects[target_date]\n", + " for index, single_csv in enumerate(target_generated_csvs):\n", + " # traverse the variables of gridmet here\n", + " # each variable is a loop\n", + " print(f\"creating cumulative for {single_csv}\")\n", + " \n", + " cumulative_target_path = f\"{single_csv}_cumulative.csv\"\n", + " print(\"cumulative_target_path = \", cumulative_target_path)\n", + " \n", + " if os.path.exists(cumulative_target_path) and not force:\n", + " print(f\"{cumulative_target_path} already exists, skipping..\")\n", + " continue\n", + " \n", + " # Extract the file name without extension\n", + " file_name = os.path.splitext(os.path.basename(single_csv))[0]\n", + " gap_filled_csv = f\"{cumulative_target_path}_gap_filled.csv\"\n", + "\n", + "\t# Split the file name using underscores\n", + " var_name = file_name.split('_')[1]\n", + " print(f\"Found variable name {var_name}\")\n", + " current_date = past_october_1\n", + " new_df = pd.read_csv(single_csv)\n", + " print(new_df.head())\n", + " \n", + " all_df = pd.read_csv(f\"../data/gridmet_test_run/testing_output/{str(selected_date.year)}_{var_name}_{target_date}.csv\")\n", + " all_df[\"date\"] = target_date\n", + " all_df[var_name] = pd.to_numeric(all_df[var_name], errors='coerce')\n", + " filled_data = all_df\n", + " filled_data = filled_data[(filled_data['date'] == target_date)]\n", + " filled_data.fillna(0, inplace=True)\n", + " print(\"Finished correctly \", filled_data.head())\n", + " filled_data = filled_data[['Latitude', 'Longitude', \n", + " var_name, \n", + "# f'cumulative_{var_name}'\n", + " ]]\n", + " print(filled_data.shape)\n", + " filled_data.to_csv(cumulative_target_path, index=False)\n", + " print(f\"new df is saved to {cumulative_target_path}\")\n", + " print(filled_data.describe())\n" + ] + }, + { + "cell_type": "markdown", + "id": "aa482514", + "metadata": {}, + "source": [ + "## 3.2.1.8 Running the Workflow for GridMET Data Processing\n", + "\n", + "This script sets up the necessary directories and file paths for processing GridMET data, then runs the cumulative history CSV preparation function to generate cumulative data for meteorological variables.\n", + "\n", + "- `homedir = os.path.expanduser('~')`: Expands the tilde (`~`) to the full path of the user's home directory.\n", + "- `work_dir`: Defines the main working directory for the project, where all data processing will take place.\n", + "- `gridmet_folder_name`: Specifies the folder within the working directory where the GridMET climatology data will be stored.\n", + "- `western_us_coords`: Points to a CSV file containing the coordinates for the western U.S., derived from a DEM file.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "d202cb61", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The existing netcdf already covers the selected date. Avoid downloading..\n", + "File tmmn_2024.nc exists\n", + "File tmmn_2023.nc exists\n", + "File tmmx_2024.nc exists\n", + "File tmmx_2023.nc exists\n", + "File pr_2024.nc exists\n", + "File pr_2023.nc exists\n", + "Checking file: tmmn_2024.nc\n", + "File 2024_tmmn_2024-08-13.csv exists\n", + "Checking file: tmmx_2024.nc\n", + "File 2024_tmmx_2024-08-13.csv exists\n", + "Checking file: pr_2024.nc\n", + "File 2024_pr_2024-08-13.csv exists\n", + "test image is saved at ../data/gridmet_test_run/testing_output/2024_pr_2024-08-13.png\n", + "2024-08-13 00:00:00\n", + "The existing netcdf already covers the selected date. Avoid downloading..\n", + "File tmmn_2024.nc exists\n", + "File tmmn_2023.nc exists\n", + "File tmmx_2024.nc exists\n", + "File tmmx_2023.nc exists\n", + "File pr_2024.nc exists\n", + "File pr_2023.nc exists\n", + "Processing date: 2024-08-11\n", + "Checking file: tmmn_2024.nc\n", + "File 2024_tmmn_2024-08-11.csv exists\n", + "Checking file: tmmx_2024.nc\n", + "File 2024_tmmx_2024-08-11.csv exists\n", + "Checking file: pr_2024.nc\n", + "File 2024_pr_2024-08-11.csv exists\n", + "Processing complete for the date: 2024-08-11\n", + "creating cumulative for ../data/gridmet_test_run/testing_output/2024_tmmn_2024-08-11.csv\n", + "cumulative_target_path = ../data/gridmet_test_run/testing_output/2024_tmmn_2024-08-11.csv_cumulative.csv\n", + "Found variable name tmmn\n", + " Latitude Longitude tmmn\n", + "0 49.0 -125.000 --\n", + "1 49.0 -124.964 --\n", + "2 49.0 -124.928 --\n", + "3 49.0 -124.892 --\n", + "4 49.0 -124.856 --\n", + "Finished correctly Latitude Longitude tmmn date\n", + "0 49.0 -125.000 0.0 2024-08-11\n", + "1 49.0 -124.964 0.0 2024-08-11\n", + "2 49.0 -124.928 0.0 2024-08-11\n", + "3 49.0 -124.892 0.0 2024-08-11\n", + "4 49.0 -124.856 0.0 2024-08-11\n", + "(462204, 3)\n", + "new df is saved to ../data/gridmet_test_run/testing_output/2024_tmmn_2024-08-11.csv_cumulative.csv\n", + " Latitude Longitude tmmn\n", + "count 462204.000000 462204.00000 462204.000000\n", + "mean 37.030000 -112.52600 193.127659\n", + "std 6.921275 7.21226 135.027899\n", + "min 25.060000 -125.00000 0.000000\n", + "25% 31.036000 -118.77200 0.000000\n", + "50% 37.030000 -112.52600 283.600000\n", + "75% 43.024000 -106.28000 288.100000\n", + "max 49.000000 -100.05200 310.900000\n", + "creating cumulative for ../data/gridmet_test_run/testing_output/2024_tmmx_2024-08-11.csv\n", + "cumulative_target_path = ../data/gridmet_test_run/testing_output/2024_tmmx_2024-08-11.csv_cumulative.csv\n", + "Found variable name tmmx\n", + " Latitude Longitude tmmx\n", + "0 49.0 -125.000 --\n", + "1 49.0 -124.964 --\n", + "2 49.0 -124.928 --\n", + "3 49.0 -124.892 --\n", + "4 49.0 -124.856 --\n", + "Finished correctly Latitude Longitude tmmx date\n", + "0 49.0 -125.000 0.0 2024-08-11\n", + "1 49.0 -124.964 0.0 2024-08-11\n", + "2 49.0 -124.928 0.0 2024-08-11\n", + "3 49.0 -124.892 0.0 2024-08-11\n", + "4 49.0 -124.856 0.0 2024-08-11\n", + "(462204, 3)\n", + "new df is saved to ../data/gridmet_test_run/testing_output/2024_tmmx_2024-08-11.csv_cumulative.csv\n", + " Latitude Longitude tmmx\n", + "count 462204.000000 462204.00000 462204.000000\n", + "mean 37.030000 -112.52600 203.360382\n", + "std 6.921275 7.21226 142.170743\n", + "min 25.060000 -125.00000 0.000000\n", + "25% 31.036000 -118.77200 0.000000\n", + "50% 37.030000 -112.52600 298.800000\n", + "75% 43.024000 -106.28000 304.500000\n", + "max 49.000000 -100.05200 322.200000\n", + "creating cumulative for ../data/gridmet_test_run/testing_output/2024_pr_2024-08-11.csv\n", + "cumulative_target_path = ../data/gridmet_test_run/testing_output/2024_pr_2024-08-11.csv_cumulative.csv\n", + "Found variable name pr\n", + " Latitude Longitude pr\n", + "0 49.0 -125.000 --\n", + "1 49.0 -124.964 --\n", + "2 49.0 -124.928 --\n", + "3 49.0 -124.892 --\n", + "4 49.0 -124.856 --\n", + "Finished correctly Latitude Longitude pr date\n", + "0 49.0 -125.000 0.0 2024-08-11\n", + "1 49.0 -124.964 0.0 2024-08-11\n", + "2 49.0 -124.928 0.0 2024-08-11\n", + "3 49.0 -124.892 0.0 2024-08-11\n", + "4 49.0 -124.856 0.0 2024-08-11\n", + "(462204, 3)\n", + "new df is saved to ../data/gridmet_test_run/testing_output/2024_pr_2024-08-11.csv_cumulative.csv\n", + " Latitude Longitude pr\n", + "count 462204.000000 462204.00000 462204.000000\n", + "mean 37.030000 -112.52600 0.883495\n", + "std 6.921275 7.21226 2.777075\n", + "min 25.060000 -125.00000 0.000000\n", + "25% 31.036000 -118.77200 0.000000\n", + "50% 37.030000 -112.52600 0.000000\n", + "75% 43.024000 -106.28000 0.000000\n", + "max 49.000000 -100.05200 45.400000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gridmet_folder_name = \"../data/gridmet_test_run/gridmet_climatology\"\n", + "western_us_coords = \"../data/dem_file.tif.csv\"\n", + "\n", + "# Run the download function\n", + "download_gridmet_of_specific_variables(prepare_folder_and_get_year_list())\n", + "turn_gridmet_nc_to_csv()\n", + "plot_gridmet()\n", + "\n", + "# prepare testing data with cumulative variables\n", + "prepare_cumulative_history_csvs(force=True)" + ] + }, + { + "cell_type": "markdown", + "id": "68f2bea0", + "metadata": {}, + "source": [ + "## 3.2.2 Merging Meteorological Data for Comprehensive Analysis\n", + "\n", + "In this chapter, we do\n", + "- `Data Collection:` We fetch gridMET climatology data for various meteorological variables (e.g., temperature, precipitation) and multiple years. \n", "\n", - "Here we create a detailed mapping between DEM coordinates and GridMET coordinates, facilitating the integration of data from different sources. This is crucial for tasks like spatial analysis, where accurate alignment between datasets is required." + "- `Data Processing:` After downloading, we extract relevant data for specific geographical locations corresponding to weather stations.\n", + "\n", + "- `Data Integration:` We merge similar variables obtained from different years into separate CSV files. We then combine all variables together into a single comprehensive dataset for further analysis and modeling tasks." + ] + }, + { + "cell_type": "markdown", + "id": "66524b4e", + "metadata": {}, + "source": [ + "## 3.2.2.1 Extracting and Saving Data from a NetCDF File\n", + "\n", + "Here we read data from a NetCDF file, extracts specific variables, and saves the data as a CSV file.\n", + "\n", + "- `ds = xr.open_dataset(file_name)`: Opens the NetCDF file for reading.\n", + "- `var_to_extract = list(ds.keys())`: Extracts the variable names present in the dataset.\n", + "- `var_name = var_to_extract[0]`: Selects the first variable from the list for further processing.\n", + "\n", + "For each station (defined in `stations`), we extract the latitude (`lat`) and longitude (`lon`).\n", + "Using `ds.sel(lat=lat, lon=lon, method='nearest')`, we select the data nearest to the specified latitude and longitude and then convert the subset data into a DataFrame." ] }, { "cell_type": "code", - "execution_count": 69, - "id": "6173cfa8", + "execution_count": 6, + "id": "3b4e75e6", "metadata": {}, "outputs": [], "source": [ - "def create_gridmet_to_dem_mapper(nc_file):\n", - " western_us_dem_df = pd.read_csv(western_us_coords)\n", - " # Check if the CSV already exists\n", - " target_csv_path = f'{work_dir}/gridmet_to_dem_mapper.csv'\n", - " if os.path.exists(target_csv_path):\n", - " print(f\"File {target_csv_path} already exists, skipping..\")\n", - " return\n", + "def get_gridmet_variable(file_name):\n", + " print(f\"reading values from {file_name}\")\n", + " result_data = []\n", + " ds = xr.open_dataset(file_name)\n", + " var_to_extract = list(ds.keys())\n", + " print(var_to_extract)\n", + " var_name = var_to_extract[0]\n", " \n", - " # get the netcdf file and generate the csv file for every coordinate in the dem_template.csv\n", - " selected_date = datetime.strptime(test_start_date, \"%Y-%m-%d\")\n", - " # Read the NetCDF file\n", - " with nc.Dataset(nc_file) as nc_file:\n", - " \n", - " # Get the values at each coordinate using rasterio's sample function\n", - " latitudes = nc_file.variables['lat'][:]\n", - " longitudes = nc_file.variables['lon'][:]\n", - " \n", - " def get_gridmet_var_value(row):\n", - " # Perform your custom calculation here\n", - " gridmet_lat_index = find_nearest_index(latitudes, float(row[\"Latitude\"]))\n", - " gridmet_lon_index = find_nearest_index(longitudes, float(row[\"Longitude\"]))\n", - " return latitudes[gridmet_lat_index], longitudes[gridmet_lon_index], gridmet_lat_index, gridmet_lon_index\n", + " df = pd.DataFrame(columns=['day', 'lat', 'lon', var_name])\n", " \n", - " # Use the apply function to apply the custom function to each row\n", - " western_us_dem_df[['gridmet_lat', 'gridmet_lon', \n", - " 'gridmet_lat_idx', 'gridmet_lon_idx',]] = western_us_dem_df.apply(lambda row: pd.Series(get_gridmet_var_value(row)), axis=1)\n", - " western_us_dem_df.rename(columns={\"Latitude\": \"dem_lat\", \n", - " \"Longitude\": \"dem_lon\"}, inplace=True)\n", + " csv_file = f'{gridmet_save_location}/{Path(file_name).stem}.csv'\n", + " if os.path.exists(csv_file):\n", + " \tprint(f\"The file '{csv_file}' exists.\")\n", + " \treturn\n", + "\n", + " for idx, row in stations.iterrows():\n", + " lat = row['latitude']\n", + " lon = row['longitude']\n", + "\t\t\n", + " subset_data = ds.sel(lat=lat, lon=lon, method='nearest')\n", + " subset_data['lat'] = lat\n", + " subset_data['lon'] = lon\n", + " converted_df = subset_data.to_dataframe()\n", + " converted_df = converted_df.reset_index(drop=False)\n", + " converted_df = converted_df.drop('crs', axis=1)\n", + " df = pd.concat([df, converted_df], ignore_index=True)\n", + " \n", + " result_df = df\n", + " print(\"got result_df : \", result_df.head())\n", + " result_df.to_csv(csv_file, index=False)\n", + " print(f'completed extracting data for {file_name}')" + ] + }, + { + "cell_type": "markdown", + "id": "a20501ee", + "metadata": {}, + "source": [ + "## 3.2.2.2 Merge Similar Variables from Different Years\n", + "\n", + "Here we merge CSV files containing similar variables but from different years. The merged data is saved as a single CSV file for each variable.\n", + "\n", + "- `file_groups = {}`: Initializes an empty dictionary to store grouped files.\n", + "- For each file, we extract the base name (variable name) and year, then groups files by the variable name if they end with `.csv`.\n", + "- And then Files are grouped based on the part of the filename before the year, ensuring that all files related to the same variable are grouped together.\n", + "\n", + "- Here we start by listing all the files in the specified `gridmet_save_location` directory.\n", + "- And then we group the files by their base names (e.g., `temperature`, `precipitation`) by splitting the filename at the underscore (`_`) and checking if the file is a CSV file with a valid year.\n", + "- For each group of files (i.e., files with the same variable but from different years), the function reads the first 5 files into pandas DataFrames and merges them into a single DataFrame.\n", + "- The merged DataFrame is saved as a new CSV file with the base name followed by `_merged.csv`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5798ad94", + "metadata": {}, + "outputs": [], + "source": [ + "def merge_similar_variables_from_different_years():\n", + " files = os.listdir(gridmet_save_location)\n", + " file_groups = {}\n", + "\n", + " for filename in files:\n", + " base_name, year_ext = os.path.splitext(filename)\n", + " parts = base_name.split('_')\n", + " if len(parts) == 2 and year_ext == '.csv':\n", + " file_groups.setdefault(parts[0], []).append(filename)\n", + "\n", + " for base_name, file_list in file_groups.items():\n", + " if len(file_list) > 1:\n", + " dfs = []\n", + " for filename in file_list[:5]:\n", + " df = pd.read_csv(os.path.join(gridmet_save_location, filename))\n", + " dfs.append(df)\n", + " merged_df = pd.concat(dfs, ignore_index=True)\n", + " merged_filename = f\"{base_name}_merged.csv\"\n", + " merged_df.to_csv(os.path.join(gridmet_save_location, merged_filename), index=False)\n", + " print(f\"Merged {file_list} into {merged_filename}\")" + ] + }, + { + "cell_type": "markdown", + "id": "bc7f03a0", + "metadata": {}, + "source": [ + "## 3.2.2.3 Merge All Variables Together\n", + "\n", + "Paths for specific variables (`rmin`, `rmax`, `tmmn`, `tmmx`) are explicitly defined, and their respective CSV files are loaded into DataFrames.\n", + "\n", + "The columns in the specific DataFrames are renamed to distinguish between similar variable names (e.g., `relative_humidity` for `rmin` and `rmax`)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "35fff41c", + "metadata": {}, + "outputs": [], + "source": [ + "def merge_all_variables_together():\n", + " merged_df = None\n", + " file_paths = []\n", + "\n", + " for filename in os.listdir(gridmet_save_location)[1:3]:\n", + " if filename.endswith(\"_merged.csv\"):\n", + " file_paths.append(os.path.join(gridmet_save_location, filename))\n", + "\t\n", + " rmin_merged_path = os.path.join(gridmet_save_location, 'rmin_merged.csv')\n", + " rmax_merged_path = os.path.join(gridmet_save_location, 'rmax_merged.csv')\n", + " tmmn_merged_path = os.path.join(gridmet_save_location, 'tmmn_merged.csv')\n", + " tmmx_merged_path = os.path.join(gridmet_save_location, 'tmmx_merged.csv')\n", " \n", - " # Save the new converted AMSR to CSV file\n", - " western_us_dem_df.to_csv(target_csv_path, index=False)\n", + " df_rmin = pd.read_csv(rmin_merged_path)\n", + " df_rmax = pd.read_csv(rmax_merged_path , engine='python')\n", + " df_tmmn = pd.read_csv(tmmn_merged_path)\n", + " df_tmmx = pd.read_csv(tmmx_merged_path)\n", " \n", - " return western_us_dem_df" + " df_rmin.rename(columns={'relative_humidity': 'relative_humidity_rmin'}, inplace=True)\n", + " df_rmax.rename(columns={'relative_humidity': 'relative_humidity_rmax'}, inplace=True)\n", + " df_tmmn.rename(columns={'air_temperature': 'air_temperature_tmmn'}, inplace=True)\n", + " df_tmmx.rename(columns={'air_temperature': 'air_temperature_tmmx'}, inplace=True)\n", + " \n", + " df_rmin.to_csv(os.path.join(gridmet_save_location, 'rmin_merged.csv'))\n", + " df_rmax.to_csv(os.path.join(gridmet_save_location, 'rmax_merged.csv'))\n", + " df_tmmn.to_csv(os.path.join(gridmet_save_location, 'tmmn_merged.csv'))\n", + " df_tmmx.to_csv(os.path.join(gridmet_save_location, 'tmmx_merged.csv'))\n", + " \n", + " if file_paths:\n", + " merged_df = pd.read_csv(file_paths[0])\n", + " for file_path in file_paths[1:3]:\n", + " df = pd.read_csv(file_path)\n", + " merged_df = pd.concat([merged_df, df], axis=1)\n", + " merged_df = merged_df.loc[:, ~merged_df.columns.duplicated()]\n", + " merged_df.to_csv(final_merged_csv, index=False)\n" + ] + }, + { + "cell_type": "markdown", + "id": "999d5177", + "metadata": {}, + "source": [ + "## 3.2.2.4 Workflow for Processing GridMET Climatology Data\n", + "\n", + "- The `download_gridmet_climatology()` function is called to download the necessary climatology data files for various variables.\n", + "- `nc_files = get_files_in_directory()`: This retrieves a list of all NetCDF files downloaded in the previous step.\n", + "- A loop iterates over the first five NetCDF files in the list (`nc_files`), printing each file's name and extracting data using the `get_gridmet_variable(nc)` function.\n", + "- `merge_similar_variables_from_different_years()`: This function is called to merge data files containing the same variable but from different years into a single file for each variable.\n", + "- `merge_all_variables_together()`: Finally, this function combines the merged data files for different variables into one comprehensive dataset, allowing for integrated analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "33d38173", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "downloading http://www.northwestknowledge.net/metdata/data/tmmn_2021.nc\n", + "downloading http://www.northwestknowledge.net/metdata/data/tmmx_2021.nc\n", + "downloading http://www.northwestknowledge.net/metdata/data/pr_2021.nc\n", + "downloading http://www.northwestknowledge.net/metdata/data/vpd_2021.nc\n", + "downloading http://www.northwestknowledge.net/metdata/data/etr_2021.nc\n", + "downloading http://www.northwestknowledge.net/metdata/data/rmax_2021.nc\n", + "downloading http://www.northwestknowledge.net/metdata/data/rmin_2021.nc\n", + "downloading http://www.northwestknowledge.net/metdata/data/vs_2021.nc\n", + "reading values from ../data/gridmet_test_run/gridmet_climatology/rmin_2021.nc\n", + "['relative_humidity']\n", + "The file '../data/gridmet_test_run/gridmet_climatology/rmin_2021.csv' exists.\n", + "reading values from ../data/gridmet_test_run/gridmet_climatology/tmmn_2021.nc\n", + "['air_temperature']\n", + "The file '../data/gridmet_test_run/gridmet_climatology/tmmn_2021.csv' exists.\n", + "reading values from ../data/gridmet_test_run/gridmet_climatology/etr_2021.nc\n", + "['potential_evapotranspiration']\n", + "The file '../data/gridmet_test_run/gridmet_climatology/etr_2021.csv' exists.\n", + "reading values from ../data/gridmet_test_run/gridmet_climatology/etr_2020.nc\n", + "['potential_evapotranspiration']\n", + "The file '../data/gridmet_test_run/gridmet_climatology/etr_2020.csv' exists.\n", + "reading values from ../data/gridmet_test_run/gridmet_climatology/rmin_2020.nc\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/lib/python3.10/site-packages/xarray/backends/plugins.py:80: RuntimeWarning: Engine 'cfgrib' loading failed:\n", + "Cannot find the ecCodes library\n", + " warnings.warn(f\"Engine {name!r} loading failed:\\n{ex}\", RuntimeWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['relative_humidity']\n", + "The file '../data/gridmet_test_run/gridmet_climatology/rmin_2020.csv' exists.\n", + "Merged ['tmmn_2020.csv', 'tmmn_2021.csv', 'tmmn_merged.csv'] into tmmn_merged.csv\n", + "Merged ['vs_merged.csv', 'vs_2020.csv', 'vs_2021.csv'] into vs_merged.csv\n", + "Merged ['rmax_merged.csv', 'rmax_2020.csv', 'rmax_2021.csv'] into rmax_merged.csv\n", + "Merged ['etr_merged.csv', 'etr_2020.csv', 'etr_2021.csv'] into etr_merged.csv\n", + "Merged ['vpd_merged.csv', 'vpd_2020.csv', 'vpd_2021.csv'] into vpd_merged.csv\n", + "Merged ['tmmx_2021.csv', 'tmmx_2020.csv', 'tmmx_merged.csv'] into tmmx_merged.csv\n", + "Merged ['pr_2021.csv', 'pr_2020.csv', 'pr_merged.csv'] into pr_merged.csv\n", + "Merged ['rmin_2021.csv', 'rmin_merged.csv', 'rmin_2020.csv'] into rmin_merged.csv\n" + ] + } + ], + "source": [ + "download_gridmet_climatology()\n", + "\n", + "nc_files = get_files_in_directory()\n", + "for nc in nc_files[:5]:\n", + " get_gridmet_variable(nc)\n", + "merge_similar_variables_from_different_years()\n", + "merge_all_variables_together()" ] }, { "cell_type": "markdown", - "id": "43f58a20", + "id": "3b84623c", "metadata": {}, "source": [ - "## 3.2.1.12 Calculate specific Operation Day\n", + "## Utility Functions for GridMET Climatology Data Downloader" + ] + }, + { + "cell_type": "markdown", + "id": "fba2568a", + "metadata": {}, + "source": [ + "## 3.2.1.1 Setup and Variable Mapping\n", "\n", - "Here we calculate the date exactly three days before the current date and returns it as a formatted string.\n", + "The following code snippet sets up the environment by importing necessary libraries, defining a workspace, and mapping variables.\n", "\n", - "- `current_date`: A `datetime` object representing the current date and time.\n", - "- `three_days_ago`: A `datetime` object representing the date three days before the current date.\n", - "- `three_days_ago_string`: A string representing the date three days ago, formatted as \"YYYY-MM-DD\".\n", - "- `test_start_date`: A string that stores the returned value from `get_operation_day()`, representing the operation day used in other parts of the code." + "- `gridmet_var_mapping`: A dictionary that associates short-form variable names with their full descriptive names.\n", + "\n", + "- The `colors` list represents a gradient of colors associated with specific ranges of values" ] }, { "cell_type": "code", - "execution_count": 70, - "id": "6dad59c8", + "execution_count": 1, + "id": "501f1e93", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2024-08-13\n" - ] - } - ], + "outputs": [], "source": [ - "from datetime import datetime, timedelta\n", - "def get_operation_day():\n", - " # Get the current date and time\n", - " current_date = datetime.now()\n", - "\n", - " # Calculate three days ago\n", - " three_days_ago = current_date - timedelta(days=3)\n", + "## Utility Functions\n", "\n", - " # Format the date as a string\n", - " three_days_ago_string = three_days_ago.strftime(\"%Y-%m-%d\")\n", + "import os\n", + "import numpy as np\n", + "import pandas as pd\n", + "import netCDF4 as nc\n", + "import urllib.request\n", + "from datetime import datetime, timedelta, date\n", + "import matplotlib.pyplot as plt\n", "\n", - " print(three_days_ago_string)\n", + "work_dir = \"../data/gridmet_test_run\"\n", "\n", - " return three_days_ago_string\n", + "gridmet_var_mapping = {\n", + " \"etr\": \"potential_evapotranspiration\",\n", + " \"pr\":\"precipitation_amount\",\n", + " \"rmax\":\"relative_humidity\",\n", + " \"rmin\":\"relative_humidity\",\n", + " \"tmmn\":\"air_temperature\",\n", + " \"tmmx\":\"air_temperature\",\n", + " \"vpd\":\"mean_vapor_pressure_deficit\",\n", + " \"vs\":\"wind_speed\",\n", + "}\n", "\n", - "test_start_date = get_operation_day()" + "colors = [\n", + " (0.8627, 0.8627, 0.8627), # #DCDCDC - 0 - 1\n", + " (0.8627, 1.0000, 1.0000), # #DCFFFF - 1 - 2\n", + " (0.6000, 1.0000, 1.0000), # #99FFFF - 2 - 4\n", + " (0.5569, 0.8235, 1.0000), # #8ED2FF - 4 - 6\n", + " (0.4509, 0.6196, 0.8745), # #739EDF - 6 - 8\n", + " (0.4157, 0.4706, 1.0000), # #6A78FF - 8 - 10\n", + " (0.4235, 0.2784, 1.0000), # #6C47FF - 10 - 12\n", + " (0.5529, 0.0980, 1.0000), # #8D19FF - 12 - 14\n", + " (0.7333, 0.0000, 0.9176), # #BB00EA - 14 - 16\n", + " (0.8392, 0.0000, 0.7490), # #D600BF - 16 - 18\n", + " (0.7569, 0.0039, 0.4549), # #C10074 - 18 - 20\n", + " (0.6784, 0.0000, 0.1961), # #AD0032 - 20 - 30\n", + " (0.5020, 0.0000, 0.0000) # #800000 - > 30\n", + "]\n" ] }, { "cell_type": "markdown", - "id": "e44f963a", + "id": "b80cd848", "metadata": {}, "source": [ - "## 3.2.1.13 Extracts NetCDF Data by Coordinates and Variable\n", + "## 3.2.1.2 Map Values to Colors\n", "\n", - "The following code extracts specific meteorological data from a NetCDF file based on provided coordinates and a variable name, and returns the data in a pandas DataFrame.\n", + "Here we generate a color mapping for a given column of data based on specified or automatically calculated value ranges. It returns the color mapping and the value ranges used.\n", "\n", - "- `mapper_df`: A DataFrame containing the mapping between DEM coordinates and GridMET coordinates.\n", - "- `latitudes`: A `numpy` array of latitude values from the NetCDF file.\n", - "- `longitudes`: A `numpy` array of longitude values from the NetCDF file.\n", - "- `var_col`: The data array for the selected variable from the NetCDF file.\n", - "- `get_gridmet_var_value(row)`: Here we extract the variable value for each coordinate from the NetCDF data.\n", - "- `Latitude`, `Longitude`: The final latitude and longitude columns in the returned DataFrame.\n", - "- Here we automate the process of extracting specific meteorological data from a NetCDF file based on geospatial coordinates, allowing for detailed analysis of climate variables at specific locations.\n", - "- By leveraging a pre-generated mapping (from DEM to GridMET coordinates `3.1.10`), the function efficiently retrieves the data for the exact locations of interest, making it highly useful in spatial analysis and modeling tasks.\n" + "- `df_col` (required): The data column from a DataFrame to map to colors.\n", + "- `value_ranges` (optional): A list of value ranges to determine the mapping of data values to colors. If not provided, the function calculates the ranges automatically.\n", + "- `map_value_to_color` takes a value and maps it to a color based on the `new_value_ranges`.\n", + "- It iterates through the ranges, assigning a color to the value based on which range it falls into.\n", + "- If the value is greater than all the defined ranges, the last color in the list is used.\n", + "\n", + "we get the `color_mapping` (list of colors corresponding to each value in the data column) and `new_value_ranges` (the calculated or provided value ranges)." ] }, { "cell_type": "code", - "execution_count": 71, - "id": "c09fdd0c", + "execution_count": 3, + "id": "695f9901", "metadata": {}, "outputs": [], "source": [ - "def get_nc_csv_by_coords_and_variable(nc_file, var_name, target_date=test_start_date):\n", - " \n", - " create_gridmet_to_dem_mapper(nc_file)\n", - " \t\n", - " mapper_df = pd.read_csv(f'{work_dir}/gridmet_to_dem_mapper.csv')\n", - " \n", - " # get the netcdf file and generate the csv file for every coordinate in the dem_template.csv\n", - " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", - " # Read the NetCDF file\n", - " with nc.Dataset(nc_file) as nc_file:\n", - " # Get a list of all variables in the NetCDF file\n", - " variables = nc_file.variables.keys()\n", - " \n", - " # Get the values at each coordinate using rasterio's sample function\n", - " latitudes = nc_file.variables['lat'][:]\n", - " longitudes = nc_file.variables['lon'][:]\n", - " day = nc_file.variables['day'][:]\n", - " long_var_name = gridmet_var_mapping[var_name]\n", - " var_col = nc_file.variables[long_var_name][:]\n", + "def create_color_maps_with_value_range(df_col, value_ranges=None):\n", + " if value_ranges == None:\n", + " max_value = df_col.max()\n", + " min_value = df_col.min()\n", + " if min_value < 0:\n", + " min_value = 0\n", + " step_size = (max_value - min_value) / 12\n", "\n", - " \n", - " # Calculate the day of the year\n", - " day_of_year = selected_date.timetuple().tm_yday\n", - " day_index = day_of_year - 1\n", - " \n", - " def get_gridmet_var_value(row):\n", - " # Perform your custom calculation here\n", - " lat_index = int(row[\"gridmet_lat_idx\"])\n", - " lon_index = int(row[\"gridmet_lon_idx\"])\n", - " var_value = var_col[day_index, lat_index, lon_index]\n", - " \n", - " return var_value\n", - " \n", - " # Use the apply function to apply the custom function to each row\n", - " mapper_df[var_name] = mapper_df.apply(get_gridmet_var_value, axis=1)\n", - " \n", - " # drop useless columns\n", - " mapper_df = mapper_df[[\"dem_lat\", \"dem_lon\", var_name]]\n", - " mapper_df.rename(columns={\"dem_lat\": \"Latitude\",\n", - " \"dem_lon\": \"Longitude\"}, inplace=True)\n", - " return mapper_df" + " # Create 10 periods\n", + " new_value_ranges = [min_value + i * step_size for i in range(12)]\n", + " # Define your custom function to map data values to colors\n", + " def map_value_to_color(value):\n", + " # Iterate through the value ranges to find the appropriate color index\n", + " for i, range_max in enumerate(new_value_ranges):\n", + " if value <= range_max:\n", + " return colors[i]\n", + "\n", + " # If the value is greater than the largest range, return the last color\n", + " return colors[-1]\n", + "\n", + " # Map predicted_swe values to colors using the custom function\n", + " color_mapping = [map_value_to_color(value) for value in df_col.values]\n", + " return color_mapping, new_value_ranges" ] }, { "cell_type": "markdown", - "id": "6c685758", + "id": "8267ed30", "metadata": {}, "source": [ - "## 3.2.1.14 Converts GridMET NetCDF Files to CSV\n", + "## 3.2.1.3 Retrive the Current Year\n", "\n", - "Here we converts NetCDF files containing GridMET meteorological data into CSV files for a specific date. It processes each NetCDF file in a specified directory and extracts relevant data based on the date provided.\n", + "The following code snippet retrives the current year from the system's date and time." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3f196690", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The history saving thread hit an unexpected error (OperationalError('unable to open database file')).History will not be written to the database.\n" + ] + } + ], + "source": [ + "def get_current_year():\n", + " \"\"\"\n", + " Get the current year.\n", "\n", - "- `selected_date`: A `datetime` object representing the `target_date`.\n", - "- `generated_csvs`: A list that stores the paths to the CSV files that are generated during the function's execution.\n", - "- `res_csv`: The path where the resulting CSV file will be saved.\n", + " Returns:\n", + " int: The current year.\n", + " \"\"\"\n", + " now = datetime.now()\n", + " current_year = now.year\n", + " return current_year" + ] + }, + { + "cell_type": "markdown", + "id": "6bb255e8", + "metadata": {}, + "source": [ + "## 3.2.1.4 Removes Specific Files in a Folder\n", "\n", - "- Here we automate the process of converting multiple NetCDF files into CSV format, making it easier to handle and analyze the data outside of specialized NetCDF tools.\n", + "We remove all files within the specified folder.\n", "\n", - "- We extract data for a specific variable from a NetCDF file by matching coordinates from a DEM template CSV file. This enables us to create a DataFrame containing the variable values alongside the corresponding coordinates. \n", + "- `folder_path`: A string representing the directory where files are to be removed.\n", + "- `current_year`: An integer representing the current year, used to filter which files should be deleted.\n", + "- `files`: A list containing the names of all items (files and directories) within the specified folder.\n", + "- `file_path`: A string representing the full path to each file in the folder, constructed by joining folder_path and the file name.\n", "\n", - "- By doing so, we can effectively extract and analyze meteorological data for specific geographical locations, aiding in various environmental and geographical studies, as well as modeling endeavors." + "- The function then loops through each item in the `files` list. For each item:\n", + " - `file_path = os.path.join(folder_path, file)` constructs the full path to the file by combining the folder path and the file name.\n", + " - `if os.path.isfile(file_path) and str(current_year) in file_path and file_path.endswith(\".nc\"):` checks if the item is a file (not a directory), if the file name contains the current year as a substring, and if the file has a `.nc` extension (indicating a NetCDF file).\n", + " - If all these conditions are met, the file is deleted using `os.remove(file_path)`, and a message is printed to confirm the deletion." ] }, { "cell_type": "code", - "execution_count": 72, - "id": "46b63faa", + "execution_count": 4, + "id": "3a5bac91", "metadata": {}, "outputs": [], "source": [ - "def turn_gridmet_nc_to_csv(target_date=test_start_date):\n", - " \n", - " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", - " generated_csvs = []\n", - " for root, dirs, files in os.walk(gridmet_folder_name):\n", - " for file_name in files:\n", - " \n", - " if str(selected_date.year) in file_name and file_name.endswith(\".nc\"):\n", - " print(f\"Checking file: {file_name}\")\n", - " var_name = get_var_from_file_name(file_name)\n", - " res_csv = f\"../data/gridmet_test_run/testing_output/{str(selected_date.year)}_{var_name}_{target_date}.csv\"\n", - "\n", - " if os.path.exists(res_csv):\n", - " #os.remove(res_csv)\n", - " # print(f\"{res_csv} already exists. Skipping..\")\n", - " print(f\"File {os.path.basename(res_csv)} exists\")\n", - " generated_csvs.append(res_csv)\n", - " continue\n", + "def remove_files_in_folder(folder_path, current_year):\n", + " \"\"\"\n", + " Remove all files in a specified folder.\n", "\n", - " # Perform operations on each file here\n", - " netcdf_file_path = os.path.join(root, file_name)\n", - " print(\"Processing file:\", netcdf_file_path)\n", - " file_name = get_file_name_from_path(netcdf_file_path)\n", + " Parameters:\n", + " folder_path (str): Path to the folder to remove files from.\n", + " \"\"\"\n", + " # Get a list of files in the folder\n", + " files = os.listdir(folder_path)\n", "\n", - " df = get_nc_csv_by_coords_and_variable(netcdf_file_path, \n", - " var_name, target_date)\n", - " df.replace('--', pd.NA, inplace=True)\n", - " df.to_csv(res_csv, index=False)\n", - " print(\"gridmet var saved: \", res_csv)\n", - " generated_csvs.append(res_csv)\n", - " \n", - " return generated_csvs " + " # Loop through the files and remove them\n", + " for file in files:\n", + " file_path = os.path.join(folder_path, file)\n", + " if os.path.isfile(file_path) and str(current_year) in file_path and file_path.endswith(\".nc\"):\n", + " os.remove(file_path)\n", + " print(f\"Deleted file: {file_path}\")" ] }, { "cell_type": "markdown", - "id": "77512189", + "id": "7cc22618", "metadata": {}, "source": [ - "## 3.2.1.15 Plot GridMET Data\n", - "\n", - "The following code snippet generates a scatter plot of GridMET data for a specified date and saves the resulting image to a file. It processes data from a CSV file and creates a visual representation of the variable \"pr\" (precipitation) on a geographical grid.\n", + "## 3.2.1.5 Download File from a URL\n", "\n", - "- `target_date`: The date for which the data is plotted, formatted as \"YYYY-MM-DD\".\n", - "- `selected_date`: A `datetime` object representing the `target_date`.\n", - "- `var_name`: A string representing the name of the variable to be plotted, set to \"pr\" (precipitation).\n", - "- `test_csv`: The file path to the CSV file containing the data to be plotted.\n", - "- `gridmet_var_df`: A DataFrame containing the loaded data from the CSV file.\n", - "- `colormaplist`: A list of colors corresponding to the value ranges in the data.\n", - "- `value_ranges`: The value ranges used to map the colors in the plot.\n", - "- `res_png_path`: The file path where the resulting plot image will be saved.\n", + "Here we download a file from a given URL and saves it to a specified location.\n", "\n", - "- **Visualization:** This function provides a visual representation of the GridMET data, specifically focusing on precipitation (\"pr\") values. Visualization helps in understanding spatial patterns and distributions in the data, making it easier to interpret and analyze.\n", - "- **Data Communication:** By saving the plot as an image, the function allows the results to be easily shared, included in reports, or further analyzed.\n", + "- `url`: A string representing the URL from which the file is to be downloaded.\n", + " - `target_file_path`: A string representing the path where the downloaded file should be saved.\n", "\n", - "We convert GridMET NetCDF files to CSV format for a specified date. We iterate through files in the GridMET folder, checking for files corresponding to the selected date. For each matching file, we extract the variable name and generate a CSV file containing the data. If the CSV file already exists, we skip the process. This process facilitates easy access and analysis of meteorological data for a specific date." + "- `with urllib.request.urlopen(url) as response:` opens a connection to the provided URL.\n", + " - `file_content = response.read()` reads the contents of the file from the URL." ] }, { "cell_type": "code", - "execution_count": 73, - "id": "62f7b586", + "execution_count": 5, + "id": "20c01c2c", "metadata": {}, "outputs": [], "source": [ - "def plot_gridmet(target_date=test_start_date):\n", - " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", - " var_name = \"pr\"\n", - " test_csv = f\"../data/gridmet_test_run/testing_output/{str(selected_date.year)}_{var_name}_{target_date}.csv\"\n", - " gridmet_var_df = pd.read_csv(test_csv)\n", - " gridmet_var_df.replace('--', pd.NA, inplace=True)\n", - " gridmet_var_df.dropna(inplace=True)\n", - " gridmet_var_df['pr'] = pd.to_numeric(gridmet_var_df['pr'], errors='coerce')\n", - " \n", - " colormaplist, value_ranges = create_color_maps_with_value_range(gridmet_var_df[var_name])\n", - " \n", - " # Create a scatter plot\n", - " plt.scatter(gridmet_var_df[\"Longitude\"].values, \n", - " gridmet_var_df[\"Latitude\"].values, \n", - " label='Pressure', \n", - " color=colormaplist, \n", - " marker='o')\n", + "def download_file(url, target_file_path, variable):\n", + " \"\"\"\n", + " Download a file from a URL and save it to a specified location.\n", "\n", - " # Add labels and a legend\n", - " plt.xlabel('X-axis')\n", - " plt.ylabel('Y-axis')\n", - " plt.title('Scatter Plot Example')\n", - " plt.legend()\n", - " \n", - " res_png_path = f\"../data/gridmet_test_run/testing_output/{str(selected_date.year)}_{var_name}_{target_date}.png\"\n", - " plt.savefig(res_png_path)\n", - " print(f\"test image is saved at {res_png_path}\")" + " Parameters:\n", + " url (str): URL of the file to download.\n", + " target_file_path (str): Path where the downloaded file should be saved.\n", + " variable (str): Name of the meteorological variable being downloaded.\n", + " \"\"\"\n", + " try:\n", + " with urllib.request.urlopen(url) as response:\n", + " print(f\"Downloading {url}\")\n", + " file_content = response.read()\n", + " save_path = target_file_path\n", + " with open(save_path, 'wb') as file:\n", + " file.write(file_content)\n", + " print(f\"File downloaded successfully and saved as: {os.path.basename(save_path)}\")\n", + " except Exception as e:\n", + " print(f\"An error occurred while downloading the file: {str(e)}\")" ] }, { "cell_type": "markdown", - "id": "c27997ec", + "id": "f52923c4", "metadata": {}, "source": [ - "## 3.2.1.16 Prepare Folder and Generating Year List\n", - "The code snippet prepares a directory for storing GridMET NetCDF files and determines the relevant years based on a specified target date. It also checks if existing files cover the selected date and removes them if necessary to ensure up-to-date data.\n", + "## 3.2.1.6 Downloads Specific Meteorological Variables\n", "\n", - "- `target_date`: The date for which the data is being prepared, formatted as \"YYYY-MM-DD\".\n", - "- `selected_date`: A `datetime` object representing the `target_date`.\n", - "- `past_october_1`: A `datetime` object representing October 1st of either the current year or the previous year, depending on the `selected_date`.\n", - "- `year_list`: A list of years that are relevant to the `selected_date`, used for data processing.\n", - "- `gridmet_folder_name`: The directory where the GridMET NetCDF files are stored.\n", - "- `nc_file`: The file path to the NetCDF file for the `tmmx` variable of the current year.\n", - "- `ifremove`: A boolean flag indicating whether the existing files should be removed based on the date coverage.\n", + "Here we download specific meteorological variables from the GridMET climatology dataset for a list of years provided as input.\n", "\n", - "- **Folder Preparation:** Ensuring that the necessary directory exists before proceeding with file operations is crucial for organizing and managing data effectively.\n", - "- **Data Integrity:** By checking whether existing files cover the required date range and removing them if they do not, the function ensures that the data used in the project is up-to-date and accurate.\n", - "- **Year Selection:** The `year_list` is essential for determining which years' data should be processed, ensuring that the analysis covers the appropriate time span.\n", + "- `year_list`: A list of years for which the meteorological data is to be downloaded.\n", + "- `base_metadata_url` is a string that stores the base URL from where the meteorological data files will be downloaded.\n", + "- `variables_list` is a list containing the short names of the meteorological variables to be downloaded, such as `tmmn` (minimum temperature), `tmmx` (maximum temperature), `pr` (precipitation), `vpd` (vapor pressure deficit), `etr` (evapotranspiration), `rmax` (maximum relative humidity), `rmin` (minimum relative humidity), `vs` (wind speed).\n", "\n", - "We plot GridMET meteorological data for a specific variable and date. We read the data from a corresponding CSV file and preprocess it, ensuring valid numerical values. Then, we create a scatter plot, mapping the variable values to geographic coordinates. The color of each point on the plot represents the magnitude of the variable value. Finally, we save the plot as a PNG image for further analysis and visualization." + "- The function loops through each variable in `variables_list`.\n", + "- For each variable, it further loops through each year in `year_list`." ] }, { "cell_type": "code", - "execution_count": 74, - "id": "1c643f91", + "execution_count": 6, + "id": "0ef4050b", "metadata": {}, "outputs": [], "source": [ - "def prepare_folder_and_get_year_list(target_date=test_start_date):\n", - " # Check if the folder exists, if not, create it\n", - " if not os.path.exists(gridmet_folder_name):\n", - " os.makedirs(gridmet_folder_name)\n", + "def download_gridmet_of_specific_variables(year_list):\n", + " \"\"\"\n", + " Download specific meteorological variables from the GridMET climatology dataset.\n", + " \"\"\"\n", + " # Make a directory to store the downloaded files\n", "\n", - " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", - " if selected_date.month < 10:\n", - " past_october_1 = datetime(selected_date.year - 1, 10, 1)\n", - " else:\n", - " past_october_1 = datetime(selected_date.year, 10, 1)\n", - " year_list = [selected_date.year, past_october_1.year]\n", + " base_metadata_url = \"http://www.northwestknowledge.net/metdata/data/\"\n", + " variables_list = ['tmmn', 'tmmx', 'pr', 'vpd', 'etr', 'rmax', 'rmin', 'vs']\n", "\n", - " # Remove any existing files in the folder\n", - " if selected_date.year == datetime.now().year:\n", - " # check if the current year's netcdf contains the selected date\n", - " # get etr netcdf and read\n", - " nc_file = f\"{gridmet_folder_name}/tmmx_{selected_date.year}.nc\"\n", - " ifremove = False\n", - " if os.path.exists(nc_file):\n", - " with nc.Dataset(nc_file) as ncd:\n", - " day = ncd.variables['day'][:]\n", - " # Calculate the day of the year\n", - " day_of_year = selected_date.timetuple().tm_yday\n", - " day_index = day_of_year - 1\n", - " if len(day) <= day_index:\n", - " ifremove = True\n", - " \n", - " if ifremove:\n", - " print(\"The current year netcdf has new data. Redownloading..\")\n", - " remove_files_in_folder(gridmet_folder_name, selected_date.year) # only redownload when the year is the current year\n", - " else:\n", - " print(\"The existing netcdf already covers the selected date. Avoid downloading..\")\n", - " return year_list" + " for var in variables_list[:3]:\n", + " for y in year_list:\n", + " download_link = base_metadata_url + var + '_' + '%s' % y + '.nc'\n", + " target_file_path = os.path.join(gridmet_folder_name, var + '_' + '%s' % y + '.nc')\n", + " if not os.path.exists(target_file_path):\n", + " download_file(download_link, target_file_path, var)\n", + " else:\n", + " print(f\"File {os.path.basename(target_file_path)} exists\")" ] }, { "cell_type": "markdown", - "id": "ccfe1332", + "id": "5c4e5956", "metadata": {}, "source": [ - "## 3.2.1.17 Adds a cummulative column\n", - "\n", - "Herw we add a new column to a DataFrame that contains the cumulative sum of the values in an existing column.\n", - "\n", - "- `df`: The pandas DataFrame that contains the data to which the cumulative sum column will be added.\n", - "- `column_name`: The name of the column in the DataFrame for which the cumulative sum is to be calculated.\n", - "\n", - "- **Data Enrichment:** Adding a cumulative sum column is useful for understanding trends over time, such as total precipitation over a period, cumulative sales, or accumulated values in any time series data.\n", - "- **Ease of Analysis:** By including the cumulative sum directly in the DataFrame, the function simplifies further analysis and visualization tasks that might require cumulative data.\n", - "\n", + "## 3.2.1.7 Extract File Name from File Path\n", "\n", - "We prepare the folder structure for storing GridMET data and obtain a list of relevant years based on the target date. This process ensures that the necessary directory exists for data storage and determines the appropriate years for data retrieval without delving into technical details." + "Here we extracts the file name from a given file path.\n", + "- `file_path`: A string representing the full path to a file.\n", + "- `file_name = os.path.basename(file_path)` uses the `os.path.basename()` function to extract the file name from the complete file path. The `basename()` function returns the last component of the path, which is the file name." ] }, { "cell_type": "code", - "execution_count": 75, - "id": "1621c7c1", + "execution_count": 7, + "id": "6439b645", "metadata": {}, "outputs": [], "source": [ - "def add_cumulative_column(df, column_name):\n", - " df[f'cumulative_{column_name}'] = df[column_name].sum()\n", - " return df" + "def get_file_name_from_path(file_path):\n", + " # Get the file name from the file path\n", + " file_name = os.path.basename(file_path)\n", + " return file_name" ] }, { "cell_type": "markdown", - "id": "100e461b", + "id": "d93fc723", "metadata": {}, "source": [ - "## 3.2.1.18 Prepare Cumulative History CSVs\n", - "\n", - "generates cumulative history CSVs for a specified target date. It processes GridMET data by traversing the date range from the previous October 1st to the target date, downloading the necessary data, converting it to CSV, and calculating cumulative values for specific meteorological variables. The results are saved in new CSV files.\n", + "## 3.2.1.8 Extract Variable Name from File Name\n", "\n", - "- `target_date`: The target date for generating cumulative history CSVs.\n", - "- `selected_date`: The `datetime` object representing the `target_date`.\n", - "- `past_october_1`: A `datetime` object representing October 1st of the current or previous year.\n", - "- `generated_csvs`: A list of paths to the CSV files generated for the specific date.\n", - "- `cumulative_target_path`: The file path where the cumulative CSV will be saved.\n", - "- `date_keyed_objects`: A dictionary holding CSV file paths keyed by date.\n", - "- `force`: A boolean flag indicating whether to force regeneration of cumulative CSVs.\n", + "The code snippet extracts the variable name from a given file name, assuming the file name follows a specific format.\n", "\n", - "- **Cumulative Data Analysis:** The function enables the analysis of cumulative meteorological data, such as total precipitation over a period, which is crucial for understanding long-term trends and impacts.\n", - "- **Automated Data Processing:** By automating the download, processing, and cumulative calculation steps, the function ensures that the data is prepared consistently and efficiently, reducing manual workload.\n" + "- `file_name`: A string representing the name of the file from which the variable name will be extracted.\n", + "- `var_name = str(file_name.split('_')[0])` splits the file name at the underscore and takes the first part (index `0`), which is expected to be the variable name. The `str()` function ensures that `var_name` is treated as a string." ] }, { "cell_type": "code", - "execution_count": 79, - "id": "ef804f40", + "execution_count": 8, + "id": "6b2f8595", "metadata": {}, - "outputs": [], - "source": [ - "def prepare_cumulative_history_csvs(target_date=test_start_date, force=False):\n", - " \"\"\"\n", - " Prepare cumulative history CSVs for a specified target date.\n", - "\n", - " Parameters:\n", - " - target_date (str, optional): The target date in the format 'YYYY-MM-DD'. Default is 'test_start_date'.\n", - " - force (bool, optional): If True, forcefully regenerate cumulative CSVs even if they already exist. Default is False.\n", - "\n", - " Returns:\n", - " None\n", - "\n", - " This function generates cumulative history CSVs for a specified target date. It traverses the date range from the past\n", - " October 1 to the target date, downloads gridmet data, converts it to CSV, and merges it into a big DataFrame.\n", - " The cumulative values are calculated and saved in new CSV files.\n", - "\n", - " Example:\n", - " ```python\n", - " prepare_cumulative_history_csvs(target_date='2023-01-01', force=True)\n", - " ```\n", - "\n", - " Note: This function assumes the existence of the following helper functions:\n", - " - download_gridmet_of_specific_variables\n", - " - prepare_folder_and_get_year_list\n", - " - turn_gridmet_nc_to_csv\n", - " - add_cumulative_column\n", - " - process_group_value_filling\n", - " ```\n", - "\n", - " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", - " print(selected_date)\n", - " if selected_date.month < 10:\n", - " past_october_1 = datetime(selected_date.year - 1, 10, 1)\n", - " else:\n", - " past_october_1 = datetime(selected_date.year, 10, 1)\n", - "\n", - " # Rest of the function logic...\n", - "\n", - " filled_data = filled_data.loc[:, ['Latitude', 'Longitude', var_name, f'cumulative_{var_name}']]\n", - " print(\"new_df final shape: \", filled_data.head())\n", - " filled_data.to_csv(cumulative_target_path, index=False)\n", - " print(f\"new df is saved to {cumulative_target_path}\")\n", - " print(filled_data.describe())\n", - " ```\n", - "Note: This docstring includes placeholders such as \"download_gridmet_of_specific_variables\" and \"prepare_folder_and_get_year_list\" for the assumed existence of related helper functions. You should replace these placeholders with actual documentation for those functions.\n", - " \"\"\"\n", - " selected_date = datetime.strptime(target_date, \"%Y-%m-%d\")\n", - " print(selected_date)\n", - " if selected_date.month < 10:\n", - " past_october_1 = datetime(selected_date.year - 1, 10, 1)\n", - " else:\n", - " past_october_1 = datetime(selected_date.year, 10, 1)\n", - "\n", - " # Traverse and print every day from past October 1 to the specific date\n", - " current_date = past_october_1\n", - " \n", - " date_keyed_objects = {}\n", - " download_gridmet_of_specific_variables(\n", - " prepare_folder_and_get_year_list(target_date=target_date)\n", - " )\n", - " # Set the specific date you want to process\n", - " # current_date = datetime.strptime(\"2024-08-11\", '%Y-%m-%d')\n", - " current_date = datetime.strptime(\"2024-08-11\", '%Y-%m-%d')\n", - "\n", - " # Initialize a dictionary to hold the date-keyed objects\n", - " date_keyed_objects = {}\n", - "\n", - " # Process the specific date\n", - " print('Processing date:', current_date.strftime('%Y-%m-%d'))\n", - " current_date_str = current_date.strftime('%Y-%m-%d')\n", + "outputs": [], + "source": [ + "def get_var_from_file_name(file_name):\n", + " # Assuming the file name format is \"tmmm_year.csv\"\n", + " var_name = str(file_name.split('_')[0])\n", + " return var_name" + ] + }, + { + "cell_type": "markdown", + "id": "dd3bee41", + "metadata": {}, + "source": [ + "## 3.2.1.9 Extracts Coordinates from a CSV File\n", "\n", - " # Call the function to generate CSVs for the specific date\n", - " generated_csvs = turn_gridmet_nc_to_csv(target_date=current_date_str)\n", + "Here we extracts geographical coordinates (longitude and latitude) from a CSV file and returns them as a list of tuples.\n", "\n", - " # Read the CSV into a dataframe and store it in the dictionary\n", - " date_keyed_objects[current_date_str] = generated_csvs\n", + "- `coordinates`: A list initialized as empty and used to store tuples of longitude and latitude values extracted from the CSV file.\n", + "- `df`: A DataFrame created by loading the CSV file using `pandas`. It contains the data from the CSV, including the `Latitude` and `Longitude` columns.\n", + "- `lon`: Represents the longitude extracted from the current row of the DataFrame.\n", + "- `lat`: Represents the latitude extracted from the current row of the DataFrame.\n", + "- Here we iterate over each row in the DataFrame using a `for` loop: `for index, row in df.iterrows():`.\n", + "- For each row, the function extracts the `Latitude` and `Longitude` values, converting them to floating-point numbers: `lon, lat = float(row[\"Latitude\"]), float(row[\"Longitude\"])`.\n", + "- These coordinates are appended to the `coordinates` list as a tuple: `coordinates.append((lon, lat))`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7c636ed1", + "metadata": {}, + "outputs": [], + "source": [ + "def get_coordinates_of_template_tif():\n", + " \t# Load the CSV file and extract coordinates\n", + " coordinates = []\n", + " df = pd.read_csv(dem_csv)\n", + " for index, row in df.iterrows():\n", + " # Process each row here\n", + " lon, lat = float(row[\"Latitude\"]), float(row[\"Longitude\"])\n", + " coordinates.append((lon, lat))\n", + " return coordinates" + ] + }, + { + "cell_type": "markdown", + "id": "6b3f9072", + "metadata": {}, + "source": [ + "## 3.2.1.10 Find the Nearest Index in an Array\n", "\n", - " print(\"Processing complete for the date:\", current_date_str)\n", - " target_date = '2024-08-11'\n", - " target_generated_csvs = date_keyed_objects[target_date]\n", - " for index, single_csv in enumerate(target_generated_csvs):\n", - " # traverse the variables of gridmet here\n", - " # each variable is a loop\n", - " print(f\"creating cumulative for {single_csv}\")\n", - " \n", - " cumulative_target_path = f\"{single_csv}_cumulative.csv\"\n", - " print(\"cumulative_target_path = \", cumulative_target_path)\n", - " \n", - " if os.path.exists(cumulative_target_path) and not force:\n", - " print(f\"{cumulative_target_path} already exists, skipping..\")\n", - " continue\n", - " \n", - " # Extract the file name without extension\n", - " file_name = os.path.splitext(os.path.basename(single_csv))[0]\n", - " gap_filled_csv = f\"{cumulative_target_path}_gap_filled.csv\"\n", + "- `array`: A `numpy` array of numerical values from which the closest element to `value` is to be found.\n", + "- `value`: A numerical value for which the closest corresponding element in `array` is sought.\n", "\n", - "\t# Split the file name using underscores\n", - " var_name = file_name.split('_')[1]\n", - " print(f\"Found variable name {var_name}\")\n", - " current_date = past_october_1\n", - " new_df = pd.read_csv(single_csv)\n", - " print(new_df.head())\n", - " \n", - " all_df = pd.read_csv(f\"../data/gridmet_test_run/testing_output/{str(selected_date.year)}_{var_name}_{target_date}.csv\")\n", - " all_df[\"date\"] = target_date\n", - " all_df[var_name] = pd.to_numeric(all_df[var_name], errors='coerce')\n", - " filled_data = all_df\n", - " filled_data = filled_data[(filled_data['date'] == target_date)]\n", - " filled_data.fillna(0, inplace=True)\n", - " print(\"Finished correctly \", filled_data.head())\n", - " filled_data = filled_data[['Latitude', 'Longitude', \n", - " var_name, \n", - "# f'cumulative_{var_name}'\n", - " ]]\n", - " print(filled_data.shape)\n", - " filled_data.to_csv(cumulative_target_path, index=False)\n", - " print(f\"new df is saved to {cumulative_target_path}\")\n", - " print(filled_data.describe())\n" + "The code snippet returns the `index` of the element in the array that is closest to the given `value`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "030aac68", + "metadata": {}, + "outputs": [], + "source": [ + "def find_nearest_index(array, value):\n", + " # Find the index of the element in the array that is closest to the given value\n", + " return (abs(array - value)).argmin()" ] }, { "cell_type": "markdown", - "id": "aa482514", + "id": "524ca247", "metadata": {}, "source": [ - "## 3.2.1.19 Running the Workflow for GridMET Data Processing\n", + "## 3.2.1.12 Calculate specific Operation Day\n", "\n", - "This script sets up the necessary directories and file paths for processing GridMET data, then runs the cumulative history CSV preparation function to generate cumulative data for meteorological variables.\n", + "Here we calculate the date exactly three days before the current date and returns it as a formatted string.\n", "\n", - "- `homedir = os.path.expanduser('~')`: Expands the tilde (`~`) to the full path of the user's home directory.\n", - "- `work_dir`: Defines the main working directory for the project, where all data processing will take place.\n", - "- `gridmet_folder_name`: Specifies the folder within the working directory where the GridMET climatology data will be stored.\n", - "- `western_us_coords`: Points to a CSV file containing the coordinates for the western U.S., derived from a DEM file.\n" + "- `current_date`: A `datetime` object representing the current date and time.\n", + "- `three_days_ago`: A `datetime` object representing the date three days before the current date.\n", + "- `three_days_ago_string`: A string representing the date three days ago, formatted as \"YYYY-MM-DD\".\n", + "- `test_start_date`: A string that stores the returned value from `get_operation_day()`, representing the operation day used in other parts of the code." ] }, { "cell_type": "code", - "execution_count": 80, - "id": "d202cb61", + "execution_count": 11, + "id": "29df8904", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The existing netcdf already covers the selected date. Avoid downloading..\n", - "File tmmn_2024.nc exists\n", - "File tmmn_2023.nc exists\n", - "File tmmx_2024.nc exists\n", - "File tmmx_2023.nc exists\n", - "File pr_2024.nc exists\n", - "File pr_2023.nc exists\n", - "Checking file: tmmn_2024.nc\n", - "File 2024_tmmn_2024-08-13.csv exists\n", - "Checking file: tmmx_2024.nc\n", - "File 2024_tmmx_2024-08-13.csv exists\n", - "Checking file: pr_2024.nc\n", - "File 2024_pr_2024-08-13.csv exists\n", - "test image is saved at ../data/gridmet_test_run/testing_output/2024_pr_2024-08-13.png\n", - "2024-08-13 00:00:00\n", - "The existing netcdf already covers the selected date. Avoid downloading..\n", - "File tmmn_2024.nc exists\n", - "File tmmn_2023.nc exists\n", - "File tmmx_2024.nc exists\n", - "File tmmx_2023.nc exists\n", - "File pr_2024.nc exists\n", - "File pr_2023.nc exists\n", - "Processing date: 2024-08-11\n", - "Checking file: tmmn_2024.nc\n", - "File 2024_tmmn_2024-08-11.csv exists\n", - "Checking file: tmmx_2024.nc\n", - "File 2024_tmmx_2024-08-11.csv exists\n", - "Checking file: pr_2024.nc\n", - "File 2024_pr_2024-08-11.csv exists\n", - "Processing complete for the date: 2024-08-11\n", - "creating cumulative for ../data/gridmet_test_run/testing_output/2024_tmmn_2024-08-11.csv\n", - "cumulative_target_path = ../data/gridmet_test_run/testing_output/2024_tmmn_2024-08-11.csv_cumulative.csv\n", - "Found variable name tmmn\n", - " Latitude Longitude tmmn\n", - "0 49.0 -125.000 --\n", - "1 49.0 -124.964 --\n", - "2 49.0 -124.928 --\n", - "3 49.0 -124.892 --\n", - "4 49.0 -124.856 --\n", - "Finished correctly Latitude Longitude tmmn date\n", - "0 49.0 -125.000 0.0 2024-08-11\n", - "1 49.0 -124.964 0.0 2024-08-11\n", - "2 49.0 -124.928 0.0 2024-08-11\n", - "3 49.0 -124.892 0.0 2024-08-11\n", - "4 49.0 -124.856 0.0 2024-08-11\n", - "(462204, 3)\n", - "new df is saved to ../data/gridmet_test_run/testing_output/2024_tmmn_2024-08-11.csv_cumulative.csv\n", - " Latitude Longitude tmmn\n", - "count 462204.000000 462204.00000 462204.000000\n", - "mean 37.030000 -112.52600 193.127659\n", - "std 6.921275 7.21226 135.027899\n", - "min 25.060000 -125.00000 0.000000\n", - "25% 31.036000 -118.77200 0.000000\n", - "50% 37.030000 -112.52600 283.600000\n", - "75% 43.024000 -106.28000 288.100000\n", - "max 49.000000 -100.05200 310.900000\n", - "creating cumulative for ../data/gridmet_test_run/testing_output/2024_tmmx_2024-08-11.csv\n", - "cumulative_target_path = ../data/gridmet_test_run/testing_output/2024_tmmx_2024-08-11.csv_cumulative.csv\n", - "Found variable name tmmx\n", - " Latitude Longitude tmmx\n", - "0 49.0 -125.000 --\n", - "1 49.0 -124.964 --\n", - "2 49.0 -124.928 --\n", - "3 49.0 -124.892 --\n", - "4 49.0 -124.856 --\n", - "Finished correctly Latitude Longitude tmmx date\n", - "0 49.0 -125.000 0.0 2024-08-11\n", - "1 49.0 -124.964 0.0 2024-08-11\n", - "2 49.0 -124.928 0.0 2024-08-11\n", - "3 49.0 -124.892 0.0 2024-08-11\n", - "4 49.0 -124.856 0.0 2024-08-11\n", - "(462204, 3)\n", - "new df is saved to ../data/gridmet_test_run/testing_output/2024_tmmx_2024-08-11.csv_cumulative.csv\n", - " Latitude Longitude tmmx\n", - "count 462204.000000 462204.00000 462204.000000\n", - "mean 37.030000 -112.52600 203.360382\n", - "std 6.921275 7.21226 142.170743\n", - "min 25.060000 -125.00000 0.000000\n", - "25% 31.036000 -118.77200 0.000000\n", - "50% 37.030000 -112.52600 298.800000\n", - "75% 43.024000 -106.28000 304.500000\n", - "max 49.000000 -100.05200 322.200000\n", - "creating cumulative for ../data/gridmet_test_run/testing_output/2024_pr_2024-08-11.csv\n", - "cumulative_target_path = ../data/gridmet_test_run/testing_output/2024_pr_2024-08-11.csv_cumulative.csv\n", - "Found variable name pr\n", - " Latitude Longitude pr\n", - "0 49.0 -125.000 --\n", - "1 49.0 -124.964 --\n", - "2 49.0 -124.928 --\n", - "3 49.0 -124.892 --\n", - "4 49.0 -124.856 --\n", - "Finished correctly Latitude Longitude pr date\n", - "0 49.0 -125.000 0.0 2024-08-11\n", - "1 49.0 -124.964 0.0 2024-08-11\n", - "2 49.0 -124.928 0.0 2024-08-11\n", - "3 49.0 -124.892 0.0 2024-08-11\n", - "4 49.0 -124.856 0.0 2024-08-11\n", - "(462204, 3)\n", - "new df is saved to ../data/gridmet_test_run/testing_output/2024_pr_2024-08-11.csv_cumulative.csv\n", - " Latitude Longitude pr\n", - "count 462204.000000 462204.00000 462204.000000\n", - "mean 37.030000 -112.52600 0.883495\n", - "std 6.921275 7.21226 2.777075\n", - "min 25.060000 -125.00000 0.000000\n", - "25% 31.036000 -118.77200 0.000000\n", - "50% 37.030000 -112.52600 0.000000\n", - "75% 43.024000 -106.28000 0.000000\n", - "max 49.000000 -100.05200 45.400000\n" + "2024-08-16\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "gridmet_folder_name = \"../data/gridmet_test_run/gridmet_climatology\"\n", - "western_us_coords = \"../data/dem_file.tif.csv\"\n", - "\n", - "# Run the download function\n", - "download_gridmet_of_specific_variables(prepare_folder_and_get_year_list())\n", - "turn_gridmet_nc_to_csv()\n", - "plot_gridmet()\n", + "from datetime import datetime, timedelta\n", + "def get_operation_day():\n", + " # Get the current date and time\n", + " current_date = datetime.now()\n", "\n", - "# prepare testing data with cumulative variables\n", - "prepare_cumulative_history_csvs(force=True)" - ] - }, - { - "cell_type": "markdown", - "id": "68f2bea0", - "metadata": {}, - "source": [ - "## 3.2.2 Merging Meteorological Data for Comprehensive Analysis\n", + " # Calculate three days ago\n", + " three_days_ago = current_date - timedelta(days=3)\n", "\n", - "In this chapter, we do\n", - "- `Data Collection:` We fetch gridMET climatology data for various meteorological variables (e.g., temperature, precipitation) and multiple years. \n", + " # Format the date as a string\n", + " three_days_ago_string = three_days_ago.strftime(\"%Y-%m-%d\")\n", "\n", - "- `Data Processing:` After downloading, we extract relevant data for specific geographical locations corresponding to weather stations.\n", + " print(three_days_ago_string)\n", "\n", - "- `Data Integration:` We merge similar variables obtained from different years into separate CSV files. We then combine all variables together into a single comprehensive dataset for further analysis and modeling tasks." + " return three_days_ago_string\n", + "\n", + "test_start_date = get_operation_day()" ] }, { "cell_type": "markdown", - "id": "751d6689", + "id": "ea2c5e26", "metadata": {}, "source": [ + "## Utility Functions for Merging Meteorological Data for Comprehensive Analysis\n", + "\n", "## 3.2.2.1 Importing Libraries\n", "\n", - "The code snippet sets up the environment and defines the necessary paths and timeframes for a data processing task" + "The code snippet sets up the environment and defines the necessary paths and timeframes for a data processing task\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 1, - "id": "1a5713a0", + "execution_count": 12, + "id": "c5b46678", "metadata": {}, "outputs": [], "source": [ @@ -1176,7 +1441,7 @@ }, { "cell_type": "markdown", - "id": "3f8fcaa7", + "id": "c149efa8", "metadata": {}, "source": [ "## 3.2.2.2 Get Files from a Directory\n", @@ -1185,8 +1450,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "eb0bc340", + "execution_count": 13, + "id": "87850a0c", "metadata": {}, "outputs": [], "source": [ @@ -1199,7 +1464,7 @@ }, { "cell_type": "markdown", - "id": "bef84df2", + "id": "df8e974a", "metadata": {}, "source": [ "## 3.2.2.3 Download File from a URL\n", @@ -1209,8 +1474,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "e1ad571c", + "execution_count": 14, + "id": "485cb98e", "metadata": {}, "outputs": [], "source": [ @@ -1230,7 +1495,7 @@ }, { "cell_type": "markdown", - "id": "87896c19", + "id": "9d8ade90", "metadata": {}, "source": [ "## 3.2.2.4 Download GridMET Climatology Data\n", @@ -1246,8 +1511,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "45bab2c5", + "execution_count": 15, + "id": "f3a26326", "metadata": {}, "outputs": [], "source": [ @@ -1266,250 +1531,6 @@ " if not os.path.exists(os.path.join(folder_name, var + '_' + '%s' % y + '.nc')):\n", " download_file(download_link, folder_name)" ] - }, - { - "cell_type": "markdown", - "id": "66524b4e", - "metadata": {}, - "source": [ - "## 3.2.2.5 Extracting and Saving Data from a NetCDF File\n", - "\n", - "Here we read data from a NetCDF file, extracts specific variables, and saves the data as a CSV file.\n", - "\n", - "- `ds = xr.open_dataset(file_name)`: Opens the NetCDF file for reading.\n", - "- `var_to_extract = list(ds.keys())`: Extracts the variable names present in the dataset.\n", - "- `var_name = var_to_extract[0]`: Selects the first variable from the list for further processing.\n", - "\n", - "For each station (defined in `stations`), we extract the latitude (`lat`) and longitude (`lon`).\n", - "Using `ds.sel(lat=lat, lon=lon, method='nearest')`, we select the data nearest to the specified latitude and longitude and then convert the subset data into a DataFrame." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "3b4e75e6", - "metadata": {}, - "outputs": [], - "source": [ - "def get_gridmet_variable(file_name):\n", - " print(f\"reading values from {file_name}\")\n", - " result_data = []\n", - " ds = xr.open_dataset(file_name)\n", - " var_to_extract = list(ds.keys())\n", - " print(var_to_extract)\n", - " var_name = var_to_extract[0]\n", - " \n", - " df = pd.DataFrame(columns=['day', 'lat', 'lon', var_name])\n", - " \n", - " csv_file = f'{gridmet_save_location}/{Path(file_name).stem}.csv'\n", - " if os.path.exists(csv_file):\n", - " \tprint(f\"The file '{csv_file}' exists.\")\n", - " \treturn\n", - "\n", - " for idx, row in stations.iterrows():\n", - " lat = row['latitude']\n", - " lon = row['longitude']\n", - "\t\t\n", - " subset_data = ds.sel(lat=lat, lon=lon, method='nearest')\n", - " subset_data['lat'] = lat\n", - " subset_data['lon'] = lon\n", - " converted_df = subset_data.to_dataframe()\n", - " converted_df = converted_df.reset_index(drop=False)\n", - " converted_df = converted_df.drop('crs', axis=1)\n", - " df = pd.concat([df, converted_df], ignore_index=True)\n", - " \n", - " result_df = df\n", - " print(\"got result_df : \", result_df.head())\n", - " result_df.to_csv(csv_file, index=False)\n", - " print(f'completed extracting data for {file_name}')" - ] - }, - { - "cell_type": "markdown", - "id": "a20501ee", - "metadata": {}, - "source": [ - "## 3.2.2.6 Merge Similar Variables from Different Years\n", - "\n", - "Here we merge CSV files containing similar variables but from different years. The merged data is saved as a single CSV file for each variable.\n", - "\n", - "- `file_groups = {}`: Initializes an empty dictionary to store grouped files.\n", - "- For each file, we extract the base name (variable name) and year, then groups files by the variable name if they end with `.csv`.\n", - "- And then Files are grouped based on the part of the filename before the year, ensuring that all files related to the same variable are grouped together.\n", - "\n", - "- Here we start by listing all the files in the specified `gridmet_save_location` directory.\n", - "- And then we group the files by their base names (e.g., `temperature`, `precipitation`) by splitting the filename at the underscore (`_`) and checking if the file is a CSV file with a valid year.\n", - "- For each group of files (i.e., files with the same variable but from different years), the function reads the first 5 files into pandas DataFrames and merges them into a single DataFrame.\n", - "- The merged DataFrame is saved as a new CSV file with the base name followed by `_merged.csv`." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "5798ad94", - "metadata": {}, - "outputs": [], - "source": [ - "def merge_similar_variables_from_different_years():\n", - " files = os.listdir(gridmet_save_location)\n", - " file_groups = {}\n", - "\n", - " for filename in files:\n", - " base_name, year_ext = os.path.splitext(filename)\n", - " parts = base_name.split('_')\n", - " if len(parts) == 2 and year_ext == '.csv':\n", - " file_groups.setdefault(parts[0], []).append(filename)\n", - "\n", - " for base_name, file_list in file_groups.items():\n", - " if len(file_list) > 1:\n", - " dfs = []\n", - " for filename in file_list[:5]:\n", - " df = pd.read_csv(os.path.join(gridmet_save_location, filename))\n", - " dfs.append(df)\n", - " merged_df = pd.concat(dfs, ignore_index=True)\n", - " merged_filename = f\"{base_name}_merged.csv\"\n", - " merged_df.to_csv(os.path.join(gridmet_save_location, merged_filename), index=False)\n", - " print(f\"Merged {file_list} into {merged_filename}\")" - ] - }, - { - "cell_type": "markdown", - "id": "bc7f03a0", - "metadata": {}, - "source": [ - "## 3.2.2.7 Merge All Variables Together\n", - "\n", - "Paths for specific variables (`rmin`, `rmax`, `tmmn`, `tmmx`) are explicitly defined, and their respective CSV files are loaded into DataFrames.\n", - "\n", - "The columns in the specific DataFrames are renamed to distinguish between similar variable names (e.g., `relative_humidity` for `rmin` and `rmax`)." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "35fff41c", - "metadata": {}, - "outputs": [], - "source": [ - "def merge_all_variables_together():\n", - " merged_df = None\n", - " file_paths = []\n", - "\n", - " for filename in os.listdir(gridmet_save_location)[1:3]:\n", - " if filename.endswith(\"_merged.csv\"):\n", - " file_paths.append(os.path.join(gridmet_save_location, filename))\n", - "\t\n", - " rmin_merged_path = os.path.join(gridmet_save_location, 'rmin_merged.csv')\n", - " rmax_merged_path = os.path.join(gridmet_save_location, 'rmax_merged.csv')\n", - " tmmn_merged_path = os.path.join(gridmet_save_location, 'tmmn_merged.csv')\n", - " tmmx_merged_path = os.path.join(gridmet_save_location, 'tmmx_merged.csv')\n", - " \n", - " df_rmin = pd.read_csv(rmin_merged_path)\n", - " df_rmax = pd.read_csv(rmax_merged_path , engine='python')\n", - " df_tmmn = pd.read_csv(tmmn_merged_path)\n", - " df_tmmx = pd.read_csv(tmmx_merged_path)\n", - " \n", - " df_rmin.rename(columns={'relative_humidity': 'relative_humidity_rmin'}, inplace=True)\n", - " df_rmax.rename(columns={'relative_humidity': 'relative_humidity_rmax'}, inplace=True)\n", - " df_tmmn.rename(columns={'air_temperature': 'air_temperature_tmmn'}, inplace=True)\n", - " df_tmmx.rename(columns={'air_temperature': 'air_temperature_tmmx'}, inplace=True)\n", - " \n", - " df_rmin.to_csv(os.path.join(gridmet_save_location, 'rmin_merged.csv'))\n", - " df_rmax.to_csv(os.path.join(gridmet_save_location, 'rmax_merged.csv'))\n", - " df_tmmn.to_csv(os.path.join(gridmet_save_location, 'tmmn_merged.csv'))\n", - " df_tmmx.to_csv(os.path.join(gridmet_save_location, 'tmmx_merged.csv'))\n", - " \n", - " if file_paths:\n", - " merged_df = pd.read_csv(file_paths[0])\n", - " for file_path in file_paths[1:3]:\n", - " df = pd.read_csv(file_path)\n", - " merged_df = pd.concat([merged_df, df], axis=1)\n", - " merged_df = merged_df.loc[:, ~merged_df.columns.duplicated()]\n", - " merged_df.to_csv(final_merged_csv, index=False)\n" - ] - }, - { - "cell_type": "markdown", - "id": "999d5177", - "metadata": {}, - "source": [ - "## 3.2.2.8 Workflow for Processing GridMET Climatology Data\n", - "\n", - "- The `download_gridmet_climatology()` function is called to download the necessary climatology data files for various variables.\n", - "- `nc_files = get_files_in_directory()`: This retrieves a list of all NetCDF files downloaded in the previous step.\n", - "- A loop iterates over the first five NetCDF files in the list (`nc_files`), printing each file's name and extracting data using the `get_gridmet_variable(nc)` function.\n", - "- `merge_similar_variables_from_different_years()`: This function is called to merge data files containing the same variable but from different years into a single file for each variable.\n", - "- `merge_all_variables_together()`: Finally, this function combines the merged data files for different variables into one comprehensive dataset, allowing for integrated analysis." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "33d38173", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "downloading http://www.northwestknowledge.net/metdata/data/tmmn_2021.nc\n", - "downloading http://www.northwestknowledge.net/metdata/data/tmmx_2021.nc\n", - "downloading http://www.northwestknowledge.net/metdata/data/pr_2021.nc\n", - "downloading http://www.northwestknowledge.net/metdata/data/vpd_2021.nc\n", - "downloading http://www.northwestknowledge.net/metdata/data/etr_2021.nc\n", - "downloading http://www.northwestknowledge.net/metdata/data/rmax_2021.nc\n", - "downloading http://www.northwestknowledge.net/metdata/data/rmin_2021.nc\n", - "downloading http://www.northwestknowledge.net/metdata/data/vs_2021.nc\n", - "reading values from ../data/gridmet_test_run/gridmet_climatology/rmin_2021.nc\n", - "['relative_humidity']\n", - "The file '../data/gridmet_test_run/gridmet_climatology/rmin_2021.csv' exists.\n", - "reading values from ../data/gridmet_test_run/gridmet_climatology/tmmn_2021.nc\n", - "['air_temperature']\n", - "The file '../data/gridmet_test_run/gridmet_climatology/tmmn_2021.csv' exists.\n", - "reading values from ../data/gridmet_test_run/gridmet_climatology/etr_2021.nc\n", - "['potential_evapotranspiration']\n", - "The file '../data/gridmet_test_run/gridmet_climatology/etr_2021.csv' exists.\n", - "reading values from ../data/gridmet_test_run/gridmet_climatology/etr_2020.nc\n", - "['potential_evapotranspiration']\n", - "The file '../data/gridmet_test_run/gridmet_climatology/etr_2020.csv' exists.\n", - "reading values from ../data/gridmet_test_run/gridmet_climatology/rmin_2020.nc\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/homebrew/lib/python3.10/site-packages/xarray/backends/plugins.py:80: RuntimeWarning: Engine 'cfgrib' loading failed:\n", - "Cannot find the ecCodes library\n", - " warnings.warn(f\"Engine {name!r} loading failed:\\n{ex}\", RuntimeWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['relative_humidity']\n", - "The file '../data/gridmet_test_run/gridmet_climatology/rmin_2020.csv' exists.\n", - "Merged ['tmmn_2020.csv', 'tmmn_2021.csv', 'tmmn_merged.csv'] into tmmn_merged.csv\n", - "Merged ['vs_merged.csv', 'vs_2020.csv', 'vs_2021.csv'] into vs_merged.csv\n", - "Merged ['rmax_merged.csv', 'rmax_2020.csv', 'rmax_2021.csv'] into rmax_merged.csv\n", - "Merged ['etr_merged.csv', 'etr_2020.csv', 'etr_2021.csv'] into etr_merged.csv\n", - "Merged ['vpd_merged.csv', 'vpd_2020.csv', 'vpd_2021.csv'] into vpd_merged.csv\n", - "Merged ['tmmx_2021.csv', 'tmmx_2020.csv', 'tmmx_merged.csv'] into tmmx_merged.csv\n", - "Merged ['pr_2021.csv', 'pr_2020.csv', 'pr_merged.csv'] into pr_merged.csv\n", - "Merged ['rmin_2021.csv', 'rmin_merged.csv', 'rmin_2020.csv'] into rmin_merged.csv\n" - ] - } - ], - "source": [ - "download_gridmet_climatology()\n", - "\n", - "nc_files = get_files_in_directory()\n", - "for nc in nc_files[:5]:\n", - " get_gridmet_variable(nc)\n", - "merge_similar_variables_from_different_years()\n", - "merge_all_variables_together()" - ] } ], "metadata": { From a0979e74b6b183988372ae0ca5a883b1438caad3 Mon Sep 17 00:00:00 2001 From: iammeghana Date: Mon, 19 Aug 2024 15:02:58 -0400 Subject: [PATCH 2/2] correction heading numbers --- book/chapters/gridmet.ipynb | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/book/chapters/gridmet.ipynb b/book/chapters/gridmet.ipynb index 9f9c318..3bb1811 100644 --- a/book/chapters/gridmet.ipynb +++ b/book/chapters/gridmet.ipynb @@ -953,7 +953,7 @@ "id": "fba2568a", "metadata": {}, "source": [ - "## 3.2.1.1 Setup and Variable Mapping\n", + "## 1. Setup and Variable Mapping\n", "\n", "The following code snippet sets up the environment by importing necessary libraries, defining a workspace, and mapping variables.\n", "\n", @@ -1014,7 +1014,7 @@ "id": "b80cd848", "metadata": {}, "source": [ - "## 3.2.1.2 Map Values to Colors\n", + "## 2. Map Values to Colors\n", "\n", "Here we generate a color mapping for a given column of data based on specified or automatically calculated value ranges. It returns the color mapping and the value ranges used.\n", "\n", @@ -1064,7 +1064,7 @@ "id": "8267ed30", "metadata": {}, "source": [ - "## 3.2.1.3 Retrive the Current Year\n", + "## 3. Retrive the Current Year\n", "\n", "The following code snippet retrives the current year from the system's date and time." ] @@ -1101,7 +1101,7 @@ "id": "6bb255e8", "metadata": {}, "source": [ - "## 3.2.1.4 Removes Specific Files in a Folder\n", + "## 4. Removes Specific Files in a Folder\n", "\n", "We remove all files within the specified folder.\n", "\n", @@ -1146,7 +1146,7 @@ "id": "7cc22618", "metadata": {}, "source": [ - "## 3.2.1.5 Download File from a URL\n", + "## 5. Download File from a URL\n", "\n", "Here we download a file from a given URL and saves it to a specified location.\n", "\n", @@ -1190,7 +1190,7 @@ "id": "f52923c4", "metadata": {}, "source": [ - "## 3.2.1.6 Downloads Specific Meteorological Variables\n", + "## 6. Downloads Specific Meteorological Variables\n", "\n", "Here we download specific meteorological variables from the GridMET climatology dataset for a list of years provided as input.\n", "\n", @@ -1233,7 +1233,7 @@ "id": "5c4e5956", "metadata": {}, "source": [ - "## 3.2.1.7 Extract File Name from File Path\n", + "## 7. Extract File Name from File Path\n", "\n", "Here we extracts the file name from a given file path.\n", "- `file_path`: A string representing the full path to a file.\n", @@ -1258,7 +1258,7 @@ "id": "d93fc723", "metadata": {}, "source": [ - "## 3.2.1.8 Extract Variable Name from File Name\n", + "## 8. Extract Variable Name from File Name\n", "\n", "The code snippet extracts the variable name from a given file name, assuming the file name follows a specific format.\n", "\n", @@ -1284,7 +1284,7 @@ "id": "dd3bee41", "metadata": {}, "source": [ - "## 3.2.1.9 Extracts Coordinates from a CSV File\n", + "## 9. Extracts Coordinates from a CSV File\n", "\n", "Here we extracts geographical coordinates (longitude and latitude) from a CSV file and returns them as a list of tuples.\n", "\n", @@ -1320,7 +1320,7 @@ "id": "6b3f9072", "metadata": {}, "source": [ - "## 3.2.1.10 Find the Nearest Index in an Array\n", + "## 10. Find the Nearest Index in an Array\n", "\n", "- `array`: A `numpy` array of numerical values from which the closest element to `value` is to be found.\n", "- `value`: A numerical value for which the closest corresponding element in `array` is sought.\n", @@ -1345,7 +1345,7 @@ "id": "524ca247", "metadata": {}, "source": [ - "## 3.2.1.12 Calculate specific Operation Day\n", + "## 11. Calculate specific Operation Day\n", "\n", "Here we calculate the date exactly three days before the current date and returns it as a formatted string.\n", "\n", @@ -1395,7 +1395,7 @@ "source": [ "## Utility Functions for Merging Meteorological Data for Comprehensive Analysis\n", "\n", - "## 3.2.2.1 Importing Libraries\n", + "## 1. Importing Libraries\n", "\n", "The code snippet sets up the environment and defines the necessary paths and timeframes for a data processing task\n", "\n" @@ -1444,7 +1444,7 @@ "id": "c149efa8", "metadata": {}, "source": [ - "## 3.2.2.2 Get Files from a Directory\n", + "## 2. Get Files from a Directory\n", "We collect the names of files with the extension \".nc\" within a specified directory by iterating through all files, appending their names to a list, and returning the list." ] }, @@ -1467,7 +1467,7 @@ "id": "df8e974a", "metadata": {}, "source": [ - "## 3.2.2.3 Download File from a URL\n", + "## 3. Download File from a URL\n", "\n", "Here we download a file from a given URL and saves it to a specified location on your system." ] @@ -1498,7 +1498,7 @@ "id": "9d8ade90", "metadata": {}, "source": [ - "## 3.2.2.4 Download GridMET Climatology Data\n", + "## 4. Download GridMET Climatology Data\n", "\n", "We attempt to download a file from a specified URL. We then save the downloaded file to a specified location.\n", "\n",