diff --git a/_quarto.yml b/_quarto.yml index c324e01e..3ad21a2e 100644 --- a/_quarto.yml +++ b/_quarto.yml @@ -170,6 +170,14 @@ website: href: notebooks/GIS/GDAL_NetCDF_GeoTIFF.ipynb - text: "Tools" href: quarto_text/SWOT.html#tools + - section: "SWORD of Science (SoS)" + contents: + - text: "Exploring river discharge" + href: notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE.ipynb + - text: "Exploring river discharge and gauge data" + href: notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_gauges.ipynb + - text: "Visualizing river discharge" + href: notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_visualize.ipynb - href: quarto_text/GIS.qmd text: "GIS" - section: quarto_text/CloudvsLocalWorkflows.qmd diff --git a/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE.ipynb b/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE.ipynb new file mode 100644 index 00000000..db6ac2a3 --- /dev/null +++ b/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE.ipynb @@ -0,0 +1,1049 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](https://img.shields.io/badge/PO.DAAC-Contribution-%20?color=grey&labelColor=blue)\n", + "\n", + "> From the PO.DAAC Cookbook, to access the GitHub version of the notebook, follow [this link](insert link to notebook)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploring river discharge in the SWORD of Science (SoS) dataset\n", + "#### *Author: Nikki Tebaldi, NASA JPL PO.DAAC*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "The SWORD of Science (SoS) is a community-driven dataset produced for and from the execution of the Confluence workflow in the cloud which enables quick data access and compute on SWOT data. Data granules contain two files, priors and results. The priors file contains prior information, such as in-situ gage data and model output that is used to generate the discharge products. The results file contains the resulting river discharge data products.\n", + "\n", + "The SoS is organized by continent following [SWOT River Database (SWORD)](https://www.swordexplorer.com/) structure and naming conventions. It is indexed on the same reach and node identifier dimensions found in SWORD. Time series data is stored by cycle and pass on an observation dimension.\n", + "\n", + "\n", + "More information is available in the SWOT-Confluence Github repository:\n", + "* [Documentation for priors](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_data_description-priors.pdf)\n", + "* [Documentation for results](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_data_description-results.pdf)\n", + "\n", + "\n", + "Results are organized into groups corresponding to modules in the SWOT-Confluence processing software. Modules are described in the [Confluence Module Documentation](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_module_documentation_v1.0.pdf).\n", + "\n", + "### Table of Modules (Algorithms) and Discharge variables\n", + "\n", + "The following lists the algorithms alongside their discharge variables and location in the SoS results file assuming that the SoS is an open file represented by the `results` variable.\n", + "\n", + "| Module (Algorithm) | Discharge Variable | Location in the SoS |\n", + "|----------------------------------|----------------------------------|----------------------------------|\n", + "| HiVDI | Q | results[\"hivdi\"][\"Q\"] |\n", + "| MetroMan | allq | results[\"metroman\"][\"allq\"] |\n", + "| MOMMA | Q | results[\"momma\"][\"Q\"] |\n", + "| neoBAM | q1, q2, or q3 | results[\"neobam\"][\"q\"][\"q1\"] |\n", + "| SAD | Qa | results[\"sad\"][\"Qa\"] |\n", + "| SIC4DVar | Q_mm | results[\"sic4dvar\"][\"Q_mm\"] |\n", + "| MOI HiVDI | q | results[\"moi\"][\"hivdi\"][\"q\"] |\n", + "| MOI MetroMan | q | results[\"moi\"][\"metroman\"][\"q\"] |\n", + "| MOI MOMMA | q | results[\"moi\"][\"momma\"][\"q\"] |\n", + "| MOI neoBAM | q | results[\"moi\"][\"qeobam\"][\"q\"] |\n", + "| MOI SAD | q | results[\"moi\"][\"sad\"][\"q\"] |\n", + "| MOI SIC4DVar | q | results[\"moi\"][\"sic4dvar\"][\"q\"] |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Requirements\n", + "\n", + "### 1. Compute environment \n", + "\n", + "This tutorial can be run in the following environments:\n", + "- **Local compute environment** e.g. laptop, server: this tutorial can be run on your local machine\n", + "\n", + "### 2. Earthdata Login\n", + "\n", + "An Earthdata Login account is required to access data, as well as discover restricted data, from the NASA Earthdata system. Thus, to access NASA data, you need Earthdata Login. Please visit https://urs.earthdata.nasa.gov to register and manage your Earthdata Login account. This account is free to create and only takes a moment to set up." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Objectives\n", + "- To explore and begin to understand the structure of the SoS.\n", + "- To locate and plot river discharge.\n", + "\n", + "------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import pathlib\n", + "\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER\n", + "import earthaccess\n", + "import matplotlib.pyplot as plt\n", + "import netCDF4 as nc\n", + "import numpy as np\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Authenticate\n", + "Authenticate your Earthdata Login (EDL) information using the `earthaccess` python package as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "earthaccess.login() # Login with your EDL credentials if asked" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Search and Access SoS data\n", + "Locate the SoS data of interest and then download for access." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Granules found: 3\n" + ] + }, + { + "data": { + "text/plain": [ + "[Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -21.794, 'SouthBoundingCoordinate': 25.382, 'EastBoundingCoordinate': 25.382, 'NorthBoundingCoordinate': 81.115}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-25T20:01:59.000Z', 'BeginningDateTime': '2023-04-07T22:49:35.000Z'}}\n", + " Size(MB): 983.0999364852905\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc'],\n", + " Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -81.139, 'SouthBoundingCoordinate': -52, 'EastBoundingCoordinate': -52, 'NorthBoundingCoordinate': 11.097}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-26T12:04:55.000Z', 'BeginningDateTime': '2023-04-08T01:51:07.000Z'}}\n", + " Size(MB): 1700.4334163665771\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_priors.nc'],\n", + " Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -166.397, 'SouthBoundingCoordinate': 8.09, 'EastBoundingCoordinate': 8.09, 'NorthBoundingCoordinate': 82.311}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-26T13:28:35.000Z', 'BeginningDateTime': '2023-04-08T05:36:12.000Z'}}\n", + " Size(MB): 1613.2776679992676\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_priors.nc']]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Search and locate granules\n", + "granule_info = earthaccess.search_data(\n", + " short_name=\"SWOT_L4_DAWG_SOS_DISCHARGE\",\n", + " temporal=(\"2023-04-07\", \"2023-04-26\"),\n", + ")\n", + "granule_info" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Select a priors and results file to explore:\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_priors.nc\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_priors.nc\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Copy and paste a priors file: https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc\n" + ] + } + ], + "source": [ + "# Enter a directory path to store downloaded data in\n", + "downloads_dir = pathlib.Path(\"/path/to/store/sos/data\") # MODIFY to include path on your local system\n", + "\n", + "# Select a priors and results pair to explore\n", + "download_links = [[link for link in earthaccess.results.DataGranule.data_links(granule)] for granule in granule_info]\n", + "print(\"Select a priors and results file to explore:\")\n", + "for downloads in download_links: \n", + " for download in downloads:\n", + " if \"priors\" in download: print(download)\n", + "priors_link = input(\"Copy and paste a priors file: \")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ... select results\n", + "results_link = priors_link.replace(\"priors\", \"results\")\n", + "\n", + "earthaccess.download(priors_link, downloads_dir)\n", + "earthaccess.download(results_link, downloads_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Open downloaded files to access SoS granule data\n", + "priors_download = priors_link.split('/')[-1]\n", + "results_download = results_link.split('/')[-1]\n", + "\n", + "priors = nc.Dataset(downloads_dir.joinpath(priors_download), format=\"NETCDF4\")\n", + "results = nc.Dataset(downloads_dir.joinpath(results_download), format=\"NETCDF4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explore the SoS\n", + "We can now explore the SoS using either the data read directly from S3 or downloaded to your local computer." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Constants\n", + "\n", + "# Select a river\n", + "RIVER_NAME = \"Rhine\"\n", + "\n", + "# Select a discharge algorithm (hivdi, neobam, metroman, momma, sad, sic4dvar)\n", + "DISCHARGE_ALGORITHM = \"hivdi\"\n", + "DISCHARGE_VARIABLE = \"Q\"" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Priors Groups:\n", + "{'reaches': \n", + "group /reaches:\n", + " dimensions(sizes): \n", + " variables(dimensions): int64 reach_id(num_reaches), float64 x(num_reaches), float64 y(num_reaches), river_name(num_reaches)\n", + " groups: , 'nodes': \n", + "group /nodes:\n", + " dimensions(sizes): \n", + " variables(dimensions): int64 node_id(num_nodes), int64 reach_id(num_nodes), float64 x(num_nodes), float64 y(num_nodes), river_name(num_nodes)\n", + " groups: , 'model': \n", + "group /model:\n", + " dimensions(sizes): num_months(12), probability(20)\n", + " variables(dimensions): int32 num_months(num_months), int32 probability(probability), float64 flow_duration_q(num_reaches, probability), float64 max_q(num_reaches), float64 monthly_q(num_reaches, num_months), float64 mean_q(num_reaches), float64 min_q(num_reaches), float64 two_year_return_q(num_reaches), int32 area_estimate_flag(num_reaches)\n", + " groups: , 'gbpriors': \n", + "group /gbpriors:\n", + " dimensions(sizes): \n", + " variables(dimensions): \n", + " groups: reach, node, 'EAU': \n", + "group /EAU:\n", + " dimensions(sizes): num_days(16130), num_months(12), probability(20), nchars(100), num_EAU_reaches(243)\n", + " variables(dimensions): int32 num_days(num_days), int32 CAL(num_EAU_reaches), int32 EAU_reaches(num_EAU_reaches), int64 EAU_reach_id(num_EAU_reaches), float64 EAU_flow_duration_q(num_EAU_reaches, probability), float64 EAU_max_q(num_EAU_reaches), float64 EAU_monthly_q(num_EAU_reaches, num_months), float64 EAU_mean_q(num_EAU_reaches), float64 EAU_min_q(num_EAU_reaches), float64 EAU_two_year_return_q(num_EAU_reaches), |S1 EAU_id(num_EAU_reaches, nchars), float64 EAU_q(num_EAU_reaches, num_days), float64 EAU_qt(num_EAU_reaches, num_days)\n", + " groups: , 'DEFRA': \n", + "group /DEFRA:\n", + " dimensions(sizes): num_days(16130), num_months(12), probability(20), nchars(100), num_DEFRA_reaches(26)\n", + " variables(dimensions): int32 num_days(num_days), int32 CAL(num_DEFRA_reaches), int32 DEFRA_reaches(num_DEFRA_reaches), int64 DEFRA_reach_id(num_DEFRA_reaches), float64 DEFRA_flow_duration_q(num_DEFRA_reaches, probability), float64 DEFRA_max_q(num_DEFRA_reaches), float64 DEFRA_monthly_q(num_DEFRA_reaches, num_months), float64 DEFRA_mean_q(num_DEFRA_reaches), float64 DEFRA_min_q(num_DEFRA_reaches), float64 DEFRA_two_year_return_q(num_DEFRA_reaches), |S1 DEFRA_id(num_DEFRA_reaches, nchars), float64 DEFRA_q(num_DEFRA_reaches, num_days), float64 DEFRA_qt(num_DEFRA_reaches, num_days)\n", + " groups: }\n" + ] + } + ], + "source": [ + "# Display the priors groups\n", + "print(\"Priors Groups:\")\n", + "print(priors.groups)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results Groups:\n", + "{'reaches': \n", + "group /reaches:\n", + " dimensions(sizes): \n", + " variables(dimensions): int64 reach_id(num_reaches), float64 x(num_reaches), float64 y(num_reaches), river_name(num_reaches), int32 observations(num_reaches), float64 time(num_reaches)\n", + " groups: , 'nodes': \n", + "group /nodes:\n", + " dimensions(sizes): \n", + " variables(dimensions): int64 node_id(num_nodes), int64 reach_id(num_nodes), float64 x(num_nodes), float64 y(num_nodes), river_name(num_nodes), int32 observations(num_nodes), float64 time(num_nodes)\n", + " groups: , 'hivdi': \n", + "group /hivdi:\n", + " dimensions(sizes): \n", + " variables(dimensions): float64 Q(num_reaches), float64 A0(num_reaches), float64 beta(num_reaches), float64 alpha(num_reaches)\n", + " groups: , 'metroman': \n", + "group /metroman:\n", + " dimensions(sizes): \n", + " variables(dimensions): float64 allq(num_reaches), float64 A0hat(num_reaches), float64 nahat(num_reaches), float64 x1hat(num_reaches), float64 q_u(num_reaches)\n", + " groups: , 'moi': \n", + "group /moi:\n", + " dimensions(sizes): \n", + " variables(dimensions): \n", + " groups: geobam, hivdi, metroman, momma, sad, sic4dvar, 'momma': \n", + "group /momma:\n", + " dimensions(sizes): \n", + " variables(dimensions): float64 stage(num_reaches), float64 width(num_reaches), float64 slope(num_reaches), float64 Qgage(num_reaches), float64 seg(num_reaches), float64 n(num_reaches), float64 Y(num_reaches), float64 v(num_reaches), float64 Q(num_reaches), float64 Q_constrained(num_reaches), float64 gage_constrained(num_reaches), float64 input_Qm_prior(num_reaches), float64 input_Qb_prior(num_reaches), float64 input_Yb_prior(num_reaches), float64 input_known_ezf(num_reaches), float64 input_known_bkfl_stage(num_reaches), float64 input_known_nb_seg1(num_reaches), float64 input_known_x_seg1(num_reaches), float64 Qgage_constrained_nb_seg1(num_reaches), float64 Qgage_constrained_x_seg1(num_reaches), float64 input_known_nb_seg2(num_reaches), float64 input_known_x_seg2(num_reaches), float64 Qgage_constrained_nb_seg2(num_reaches), float64 Qgage_constrained_x_seg2(num_reaches), float64 n_bkfl_Qb_prior(num_reaches), float64 n_bkfl_slope(num_reaches), float64 vel_bkfl_Qb_prior(num_reaches), float64 Froude_bkfl_diag_Smean(num_reaches), float64 width_bkfl_solved_obs(num_reaches), float64 depth_bkfl_solved_obs(num_reaches), float64 depth_bkfl_diag_Wb_Smean(num_reaches), float64 zero_flow_stage(num_reaches), float64 bankfull_stage(num_reaches), float64 Qmean_prior(num_reaches), float64 Qmean_momma(num_reaches), float64 Qmean_momma.constrained(num_reaches), float64 width_stage_corr(num_reaches)\n", + " groups: , 'neobam': \n", + "group /neobam:\n", + " dimensions(sizes): \n", + " variables(dimensions): \n", + " groups: r, logn, logDb, logWb, q, 'offline': \n", + "group /offline:\n", + " dimensions(sizes): \n", + " variables(dimensions): float64 d_x_area(num_reaches), float64 d_x_area_u(num_reaches), float64 metro_q_c(num_reaches), float64 bam_q_c(num_reaches), float64 hivdi_q_c(num_reaches), float64 momma_q_c(num_reaches), float64 sads_q_c(num_reaches), float64 consensus_q_c(num_reaches), float64 metro_q_uc(num_reaches), float64 bam_q_uc(num_reaches), float64 hivdi_q_uc(num_reaches), float64 momma_q_uc(num_reaches), float64 sads_q_uc(num_reaches), float64 consensus_q_uc(num_reaches)\n", + " groups: , 'postdiagnostics': \n", + "group /postdiagnostics:\n", + " dimensions(sizes): nchar(10)\n", + " variables(dimensions): \n", + " groups: basin, reach, 'prediagnostics': \n", + "group /prediagnostics:\n", + " dimensions(sizes): \n", + " variables(dimensions): \n", + " groups: reach, node, 'sad': \n", + "group /sad:\n", + " dimensions(sizes): \n", + " variables(dimensions): float64 A0(num_reaches), float64 n(num_reaches), float64 Qa(num_reaches), float64 Q_u(num_reaches)\n", + " groups: , 'sic4dvar': \n", + "group /sic4dvar:\n", + " dimensions(sizes): \n", + " variables(dimensions): float64 A0(num_reaches), float64 n(num_reaches), float64 Q_mm(num_reaches), float64 Q_da(num_reaches)\n", + " groups: , 'validation': \n", + "group /validation:\n", + " dimensions(sizes): num_algos(14), nchar(16)\n", + " variables(dimensions): |S1 algo_names(num_reaches, num_algos, nchar), int32 has_validation(num_reaches), float64 nse(num_reaches, num_algos), float64 rsq(num_reaches, num_algos), float64 kge(num_reaches, num_algos), float64 rmse(num_reaches, num_algos), float64 testn(num_reaches, num_algos), float64 nrmse(num_reaches, num_algos), float64 nbias(num_reaches, num_algos), float64 rrmse(num_reaches, num_algos)\n", + " groups: }\n" + ] + } + ], + "source": [ + "# Display the module groups\n", + "print(\"Results Groups:\")\n", + "print(results.groups)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot river reach locations\n", + "Information about the spatial location of river reaches is in the reaches and nodes groups including river names. This data is taken directly from [SWOT River Database (SWORD)](https://www.swordexplorer.com/)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reaches Group\n", + "\n", + "group /reaches:\n", + " dimensions(sizes): \n", + " variables(dimensions): int64 reach_id(num_reaches), float64 x(num_reaches), float64 y(num_reaches), river_name(num_reaches), int32 observations(num_reaches), float64 time(num_reaches)\n", + " groups: \n", + "\n", + "Longitude\n", + "\n", + "float64 x(num_reaches)\n", + " long_name: longitude\n", + " comment: longitude of the reach center decimal ranging from 180°E to 180°W\n", + " units: degrees_east\n", + " valid_min: -180.0\n", + " valid_max: 180.0\n", + " coverage_content_type: coordinate\n", + "path = /reaches\n", + "unlimited dimensions: \n", + "current shape = (30768,)\n", + "filling on, default _FillValue of 9.969209968386869e+36 used\n" + ] + } + ], + "source": [ + "reaches = results.groups['reaches'] # Access the reaches group\n", + "\n", + "print(\"Reaches Group\")\n", + "print(reaches, \"\\n\")\n", + "\n", + "print(\"Longitude\")\n", + "print(reaches.variables['x'])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Indexes for Rhine:\n", + " (array([12597, 12598, 12599, 12600, 12601, 12602, 12603, 12606, 12616,\n", + " 12617, 12618, 12619, 12620, 12621, 12622, 12623, 12624, 12625,\n", + " 12626, 12627, 12628, 12629, 12630, 12631, 12634, 12635, 12636,\n", + " 12638, 12639, 12640, 12769, 12918, 12919, 12920, 12923, 12924,\n", + " 12925, 12926, 12931, 12932, 12933, 12938, 12939, 12940, 12941,\n", + " 12942, 12943, 12944, 13098, 13099, 13100, 13101, 13102, 13152,\n", + " 13153, 13154, 13155, 13156, 13157, 13158, 13159, 13160, 13161,\n", + " 13162, 13163, 13164, 13165, 13166, 13168, 13169, 13170, 13172,\n", + " 13173, 13174, 13175, 13176, 13177, 13178, 13179, 13180, 13181,\n", + " 13182, 13183, 13184, 13185, 13186, 13187, 13188, 13189, 13190,\n", + " 13191, 13192, 13193, 13194, 13195, 13196, 13197, 13198, 13199,\n", + " 13200, 13201, 13202, 13204, 13205, 13206, 13207, 13208, 13316,\n", + " 13317, 13319, 13324, 13325, 13326, 13327, 13328, 13329, 13330,\n", + " 13331, 13332, 13333, 13334, 13335, 13336, 13337, 13339, 13340,\n", + " 13341, 13342, 13343, 13345, 13346, 13362, 13363, 13364, 13365,\n", + " 13366, 13367, 13368, 13369, 13370, 13371, 13372, 13373, 13374,\n", + " 13375, 13385]),)\n" + ] + } + ], + "source": [ + "# Unpack the spatial coordinates and river names\n", + "reach_lon = results.groups['reaches'].variables['x']\n", + "reach_lat = results.groups['reaches'].variables['y']\n", + "\n", + "river_names = results.groups['reaches'].variables['river_name']\n", + "\n", + "# Filter data to only find the river of interest\n", + "idx = np.where(river_names[:] == RIVER_NAME)\n", + "print(f\"Indexes for {RIVER_NAME}:\\n {idx}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Rhine Reach Centerpoint Locations')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the location of the river\n", + "fig = plt.figure(figsize=(10,10))\n", + "\n", + "# Add map elements gridlines\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "ax.coastlines()\n", + "ax.add_feature(cfeature.STATES, edgecolor='black')\n", + "\n", + "gl = ax.gridlines(crs=ccrs.PlateCarree(), linewidth=1, color='black', alpha=0.5, linestyle='--', draw_labels=True)\n", + "gl.xlabels_top = False\n", + "gl.ylabels_left = True\n", + "gl.ylabels_right=False\n", + "gl.xlines = True\n", + "\n", + "gl.xformatter = LONGITUDE_FORMATTER\n", + "gl.yformatter = LATITUDE_FORMATTER\n", + "\n", + "# Plot the river reach centerpoint locations\n", + "ax.scatter(reach_lon[idx], y=reach_lat[idx], color='c')\n", + "\n", + "# Add the title\n", + "plt.title(f'{RIVER_NAME} Reach Centerpoint Locations')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Navigating Reaches and Nodes\n", + "The SoS is organized by continent following the conventions set in the [SWOT River Database](https://www.swordexplorer.com/) for the NetCDF file format. Reach identifiers can be found in the \"reaches\" group and node identifiers can be found in the \"nodes\" group. The following sections show you how to locate reaches and nodes by river name which allows you to index into the reach and/or node level data.\n", + "\n", + "**How to locate reach and node identifiers by river name**\n", + "\n", + "You can search for a river name using the same convention as used when plotting river reach locations to obtain the reach identifiers for that river. You can then use the reach identifiers to locate the nodes that belong to each reach for that river as the nodes are indexed on a different dimension (num_nodes) than reaches (num_reaches)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Node identifiers: [21101200010013 21101200010023 21101200010033 ... 29690900020221\n", + " 29690900020231 29690900030746]\n" + ] + } + ], + "source": [ + "# Locate the indexes for the specific river you are interested in\n", + "river_names = results['reaches']['river_name'][:]\n", + "reach_idx = np.where(river_names[:] == RIVER_NAME)\n", + "\n", + "# Locate the reach identifiers for the river name\n", + "reach_identifiers = results['reaches']['reach_id'][reach_idx]\n", + "\n", + "# Locate the reach identifiers of interest on the node-level\n", + "reach_node_identifiers = results['nodes']['reach_id'][:]\n", + "node_idx = []\n", + "for reach_identifier in reach_identifiers:\n", + " node_idx.extend(np.where(reach_node_identifiers == reach_identifier)[0])\n", + "\n", + "# Locate the node identifiers of interest using the reach identifiers to index\n", + "node_identifiers = results['nodes']['node_id'][:]\n", + "print(f\"Node identifiers: {node_identifiers}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Longitude #: (4620,)\n", + "Latitude #: (4620,)\n" + ] + } + ], + "source": [ + "# Unpack the spatial coordinates on the node level and index to values of interest\n", + "node_lon = results['nodes']['x'][node_idx]\n", + "node_lat = results['nodes']['y'][node_idx]\n", + "print(f\"Longitude #: {node_lon.shape}\")\n", + "print(f\"Latitude #: {node_lat.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Rhine Node Centerpoint Locations')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the nodes\n", + "fig = plt.figure(figsize=(10,10))\n", + "\n", + "# Add map elements gridlines\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "ax.coastlines()\n", + "ax.add_feature(cfeature.STATES, edgecolor='black')\n", + "\n", + "gl = ax.gridlines(crs=ccrs.PlateCarree(), linewidth=1, color='black', alpha=0.5, linestyle='--', draw_labels=True)\n", + "gl.xlabels_top = False\n", + "gl.ylabels_left = True\n", + "gl.ylabels_right=False\n", + "gl.xlines = True\n", + "\n", + "gl.xformatter = LONGITUDE_FORMATTER\n", + "gl.yformatter = LATITUDE_FORMATTER\n", + "\n", + "# Plot the river reach centerpoint locations\n", + "ax.scatter(x=node_lon, y=node_lat)\n", + "\n", + "# Add the title\n", + "plt.title(f'{RIVER_NAME} Node Centerpoint Locations')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Discharge Timeseries\n", + "The main data of interest in the results files is the timeseries of river discharge (q) estimates produced by each module. The SoS is a global dataset organized by continents and not every reach will have an associated discharge for each module. So it is helpful to filter out missing values in order to isolate and visualize discharge for the various modules.\n", + "\n", + "### How to locate data amongst missing values\n", + "You can use the `missing_value` NetCDF variable attribute to locate the value used to indicate missing data. You can then filter on that value to isolate the time steps with discharge estimates. The following example uses the HiVDI algorithm results to demonstrate filtering missing values and plotting discharge." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 indexes for locations that have values:\n", + " [12635, 12636, 12639, 12769, 12773, 12919, 12922, 12925, 12930, 12931]\n" + ] + } + ], + "source": [ + "# Retrieve discharge from HiVDI group\n", + "discharge_algo_q = results[DISCHARGE_ALGORITHM][DISCHARGE_VARIABLE][:]\n", + "\n", + "# Save the missing value\n", + "missing = results[DISCHARGE_ALGORITHM][DISCHARGE_VARIABLE].missing_value\n", + "\n", + "# Loop through each reach and filter out places where the missing value is present\n", + "data_indexes = []\n", + "for i in range(discharge_algo_q.shape[0]):\n", + " if discharge_algo_q[i].shape[0] > 1:\n", + " if np.any(discharge_algo_q[i] != missing): data_indexes.append(i) # For multiple time steps with non-missing values\n", + " if discharge_algo_q[i].shape[0] == 1 and discharge_algo_q[i] != missing: data_indexes.append(i) # For one time step with non-missing value\n", + "\n", + "# Display the numeric indexes where discharge data is present\n", + "print(f\"10 indexes for locations that have values:\\n {data_indexes[:10]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 reach identifiers for locations that have values:\n", + " [23261000571 23261000581 23261000631 23262000011 23262000051 23263000021\n", + " 23263000051 23263000081 23263000131 23263000141]\n" + ] + } + ], + "source": [ + "reach_identifiers = results['reaches']['reach_id'][data_indexes]\n", + "print(f\"10 reach identifiers for locations that have values:\\n {reach_identifiers[:10]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can now use the data indexes to retrieve location, time, and river name data about the reaches that have discharge data." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 River Names\n", + "['Rhine' 'Rhine' 'Rhine' 'Rhine' 'Mosel' 'Rhine' 'Lahn; Rhine' 'Rhine'\n", + " 'Lahn' 'Rhine']\n", + "\n", + "Indexes for the Rhine\n", + "(array([12597, 12598, 12599, 12600, 12601, 12602, 12603, 12606, 12616,\n", + " 12617, 12618, 12619, 12620, 12621, 12622, 12623, 12624, 12625,\n", + " 12626, 12627, 12628, 12629, 12630, 12631, 12634, 12635, 12636,\n", + " 12638, 12639, 12640, 12769, 12918, 12919, 12920, 12923, 12924,\n", + " 12925, 12926, 12931, 12932, 12933, 12938, 12939, 12940, 12941,\n", + " 12942, 12943, 12944, 13098, 13099, 13100, 13101, 13102, 13152,\n", + " 13153, 13154, 13155, 13156, 13157, 13158, 13159, 13160, 13161,\n", + " 13162, 13163, 13164, 13165, 13166, 13168, 13169, 13170, 13172,\n", + " 13173, 13174, 13175, 13176, 13177, 13178, 13179, 13180, 13181,\n", + " 13182, 13183, 13184, 13185, 13186, 13187, 13188, 13189, 13190,\n", + " 13191, 13192, 13193, 13194, 13195, 13196, 13197, 13198, 13199,\n", + " 13200, 13201, 13202, 13204, 13205, 13206, 13207, 13208, 13316,\n", + " 13317, 13319, 13324, 13325, 13326, 13327, 13328, 13329, 13330,\n", + " 13331, 13332, 13333, 13334, 13335, 13336, 13337, 13339, 13340,\n", + " 13341, 13342, 13343, 13345, 13346, 13362, 13363, 13364, 13365,\n", + " 13366, 13367, 13368, 13369, 13370, 13371, 13372, 13373, 13374,\n", + " 13375, 13385]),)\n", + "\n", + "Overlapping indexes for the Rhine with HIVDI Discharge data\n", + "[12635 12636 12639 12769 12919 12925 12931 12932 12933 12938 12939 12940\n", + " 12941 12942 12943 13098 13099 13100 13101 13102 13152 13153 13154 13155\n", + " 13156 13157 13158 13159 13161 13162 13163 13164 13165 13168 13169 13174\n", + " 13178 13180 13181 13189 13190 13191 13193 13195 13197 13207]\n" + ] + } + ], + "source": [ + "# Review what river names are present in the data\n", + "print(\"10 River Names\")\n", + "print(river_names[data_indexes[:10]])\n", + "\n", + "river_indexes = np.where(river_names == RIVER_NAME)\n", + "print(f\"\\nIndexes for the {RIVER_NAME}\")\n", + "print(river_indexes)\n", + "\n", + "# Locate overlap\n", + "overlap_indexes = np.intersect1d(data_indexes, river_indexes)\n", + "print(f\"\\nOverlapping indexes for the {RIVER_NAME} with {DISCHARGE_ALGORITHM.upper()} Discharge data\")\n", + "print(overlap_indexes)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rhine reach identifier to plot: 23261000571\n", + "\n", + "Discharge for Rhine reach identifier # 23261000571\n", + "[-1.00000000e+12 -1.00000000e+12 -1.00000000e+12 -1.00000000e+12\n", + " -1.00000000e+12 -1.00000000e+12 -1.00000000e+12 -1.00000000e+12\n", + " -1.00000000e+12 5.40782194e+01 4.99487494e+01 3.42913882e+01\n", + " 3.44913537e+01]\n", + "\n", + "Time for Rhine reach identifier # 23261000571\n", + "[7.34223036e+08 7.34308874e+08 7.34394712e+08 7.34909740e+08\n", + " 7.34995578e+08 7.35081416e+08 7.35167254e+08 7.35253092e+08\n", + " 7.35338929e+08 7.35510605e+08 7.35596443e+08 7.35682281e+08\n", + " 7.35768119e+08]\n" + ] + } + ], + "source": [ + "# Select the first reach in the Ohio River from the overlapping indexes\n", + "data_index = overlap_indexes[0]\n", + "\n", + "# Locate the reach identifier\n", + "reach_id = reaches['reach_id'][data_index]\n", + "print(f\"{RIVER_NAME} reach identifier to plot: {reach_id}\")\n", + "\n", + "# Retrieve discharge\n", + "discharge_algo_q = discharge_algo_q[data_index]\n", + "print(f\"\\nDischarge for {RIVER_NAME} reach identifier # {reach_id}\")\n", + "print(discharge_algo_q)\n", + "\n", + "# Retrieve time\n", + "time = results['reaches']['time'][data_index]\n", + "print(f\"\\nTime for {RIVER_NAME} reach identifier # {reach_id}\")\n", + "print(results['reaches']['time'][data_index])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Formatted time: ['2023-04-07T22:50:35' '2023-04-08T22:41:13' '2023-04-09T22:31:52'\n", + " '2023-04-15T21:35:40' '2023-04-16T21:26:18' '2023-04-17T21:16:56'\n", + " '2023-04-18T21:07:33' '2023-04-19T20:58:11' '2023-04-20T20:48:49'\n", + " '2023-04-22T20:30:05' '2023-04-23T20:20:43' '2023-04-24T20:11:21'\n", + " '2023-04-25T20:01:58']\n" + ] + } + ], + "source": [ + "# Transform time to correct format\n", + "swot_ts = datetime.datetime(2000,1,1,0,0,0)\n", + "missing_time = results['reaches']['time'].missing_value\n", + "time_str = []\n", + "for t in time:\n", + " if t == missing_time: \n", + " time_str.append('NO_DATA')\n", + " else:\n", + " time_str.append((swot_ts + datetime.timedelta(seconds=t)).strftime('%Y-%m-%dT%H:%M:%S'))\n", + "time_str = np.array(time_str)\n", + "print(f\"Formatted time: {time_str}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Discharge for Rhine reach identfier # 23261000571\n", + "[54.07821944 49.94874936 34.29138816 34.49135369]\n", + "\n", + "Time for Rhine reach identfier # 23261000571\n", + "['2023-04-22T20:30:05' '2023-04-23T20:20:43' '2023-04-24T20:11:21'\n", + " '2023-04-25T20:01:58']\n" + ] + } + ], + "source": [ + "# Filter any missing values out of reach identifier discharge and time\n", + "missing_reach_index = np.where(discharge_algo_q != missing)\n", + "\n", + "discharge_algo_q = discharge_algo_q[missing_reach_index]\n", + "print(f\"Discharge for {RIVER_NAME} reach identfier # {reach_id}\")\n", + "print(discharge_algo_q)\n", + "\n", + "time_str = time_str[missing_reach_index]\n", + "print(f\"\\nTime for {RIVER_NAME} reach identfier # {reach_id}\")\n", + "print(time_str)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Discharge Timeseries from HIVDI for the Ohio River reach identifier: 23261000571.')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Discharge for the River Reach Identifier\n", + "\n", + "# Set up plot\n", + "fig = plt.figure(figsize=(10,5))\n", + "ax1 = plt.subplot(311)\n", + "\n", + "# Plot data\n", + "ax1.scatter(time_str, discharge_algo_q)\n", + "ax1.plot(time_str, discharge_algo_q)\n", + "\n", + "# Define labels and title\n", + "ax1.set_ylabel('Discharge')\n", + "ax1.set_xlabel('Time')\n", + "plt.xticks(rotation = 45)\n", + "\n", + "plt.suptitle(f\"Discharge Timeseries from HIVDI for the Ohio River reach identifier: {reach_id}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting integrator results for comparison\n", + "The SoS contains reach-level Flow Law Parameter (FLPE) algorithms: HiVDI, neoBAM, MetroMan, MOMMA, SAD, SIC4DVar that produce discharge estimates using SWOT observations, SoS Priors and SWORD data. It can be helpful to compare the reach-level FLPEs to the discharge values produced by the Mean Optimization Integrator (MOI). The MOI takes SWOT observation data and reach-level FLPE output and integrates the results. It uses river topology to force mass conservation and also defined uncertainty. " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HIVDI MOI Discharge for Rhine reach identfier # 23261000571\n", + "[0.0009796 0.00062748 0.00012596 0.00014881]\n" + ] + } + ], + "source": [ + "# Locate MOI discharge results for discharge algorithm making sure to filter out missing values\n", + "moi_q = results[\"moi\"][DISCHARGE_ALGORITHM][\"q\"][data_index]\n", + "moi_q = moi_q[missing_reach_index]\n", + "\n", + "print(f\"{DISCHARGE_ALGORITHM.upper()} MOI Discharge for {RIVER_NAME} reach identfier # {reach_id}\")\n", + "print(moi_q)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot discharge algorithm alongside MOI discharge\n", + "\n", + "# Discharge algorithm Q\n", + "plt.scatter(time_str, discharge_algo_q)\n", + "plt.plot(time_str, discharge_algo_q, label=f\"{DISCHARGE_ALGORITHM.upper()}\")\n", + "\n", + "# MOI Q\n", + "plt.scatter(time_str, moi_q)\n", + "plt.plot(time_str, moi_q, label=\"MOI\")\n", + "\n", + "plt.suptitle(f\"Discharge Timeseries from HIVDI for the {RIVER_NAME} reach identifier: {reach_id}.\")\n", + "plt.legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Close dataset and file handler references" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "priors.close()\n", + "results.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Disclaimer: Reference herein to any specific commercial product, process, or service by trade name, trademark, manufacturer, or otherwise, does not constitute or imply its endorsement by the United States Government or the Jet Propulsion Laboratory, California Institute of Technology.*" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_gauges.ipynb b/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_gauges.ipynb new file mode 100644 index 00000000..a19ef4cb --- /dev/null +++ b/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_gauges.ipynb @@ -0,0 +1,673 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](https://img.shields.io/badge/PO.DAAC-Contribution-%20?color=grey&labelColor=blue)\n", + "\n", + "> From the PO.DAAC Cookbook, to access the GitHub version of the notebook, follow [this link](insert link to notebook)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploring gauges and river discharge in the SWORD of Science (SoS) dataset\n", + "#### *Author: Nikki Tebaldi, NASA JPL PO.DAAC*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "### Looking at discharge in the SoS\n", + "\n", + "It can be helpful to plot the flow law parameter estimation (FLPE) algorithm discharge alongside the integrator (MOI) discharge produced for that algorithm PLUS overlapping in situ gauge data. Note that not all rivers have gauge data associated with them. In this notebook we will look at the steps to plot SoS discharge values produced from running the Confluence workflow alongside in situ gauge data gathered and stored in the priors.\n", + "\n", + "### Granule structure (background)\n", + "\n", + "The SWORD of Science (SoS) is a community-driven dataset produced for and from the execution of the Confluence workflow in the cloud which enables quick data access and compute on SWOT data. Data granules contain two files, priors and results. The priors file contains prior information, such as in-situ gage data and model output that is used to generate the discharge products. The results file contains the resulting river discharge data products.\n", + "\n", + "The SoS is organized by continent following [SWOT River Database (SWORD)](https://www.swordexplorer.com/) structure and naming conventions. It is indexed on the same reach and node identifier dimensions found in SWORD. Time series data is stored by cycle and pass on an observation dimension.\n", + "\n", + "More information is available in the SWOT-Confluence Github repository:\n", + "* [Documentation for priors](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_data_description-priors.pdf)\n", + "* [Documentation for results](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_data_description-results.pdf)\n", + "\n", + "Results are organized into groups corresponding to modules in the SWOT-Confluence processing software. Modules are described in the [Confluence Module Documentation](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_module_documentation_v1.0.pdf).\n", + "\n", + "You can explore the SoS further in this notebook: Link TBD.\n", + "\n", + "### Locate data for a river that has gauges\n", + "\n", + "We will select the Ohio River as we know it has gauge data associated with it from the USGS but feel free to modify the constants below for your river of choice!\n", + "\n", + "### Table of Gauge Agencies by Continent\n", + "\n", + "The following list the continent with associated gauge agency and group name of the gauge agency as it is stored in the SoS.\n", + "\n", + "| Continent | Group Name | Gauge Agency |\n", + "|---------------|-----------|-------------------------------------------------------|\n", + "| Africa | GRDC | Global Runoff Data Centre |\n", + "| Asia | GRDC | Global Runoff Data Centre |\n", + "| Asia | MLIT | Ministry of Land, Infrastructure, Transport, Tourism |\n", + "| Europe | GRDC | Global Runoff Data Centre |\n", + "| Europe | DEFRA | Department of Environment Food & Rural Affairs |\n", + "| Europe | EAU | Hub'Eau France |\n", + "| North America | GRDC | Global Runoff Data Centre |\n", + "| North America | USGS | United State Geological Survey |\n", + "| North America | WSC | Water Survey Canada |\n", + "| Oceania | GRDC | Global Runoff Data Centre |\n", + "| Oceania | ABOM | Australian Government Bureau of Meteorology |\n", + "| South America | GRDC | Global Runoff Data Centre |\n", + "| South America | DGA | Direccion General de Aguas |\n", + "| South America | Hidroweb | Hidroweb |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Requirements\n", + "\n", + "### 1. Compute environment \n", + "\n", + "This tutorial can be run in the following environments:\n", + "- **Local compute environment** e.g. laptop, server: this tutorial can be run on your local machine\n", + "\n", + "### 2. Earthdata Login\n", + "\n", + "An Earthdata Login account is required to access data, as well as discover restricted data, from the NASA Earthdata system. Thus, to access NASA data, you need Earthdata Login. Please visit https://urs.earthdata.nasa.gov to register and manage your Earthdata Login account. This account is free to create and only takes a moment to set up." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Objectives\n", + "- To locate in situ gauge data stored in the SoS.\n", + "- To locate overlap between in situ observations and times where discharge values were produced.\n", + "- Plot gauge data alongside river discharge.\n", + "\n", + "\n", + "------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import pathlib\n", + "\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER\n", + "import earthaccess\n", + "import matplotlib.pyplot as plt\n", + "import netCDF4 as nc\n", + "import numpy as np\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Authenticate\n", + "Authenticate your Earthdata Login (EDL) information using the `earthaccess` python package as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "earthaccess.login() # Login with your EDL credentials if asked\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Search and Access SoS data\n", + "Locate the SoS data of interest and then download for access." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Granules found: 3\n" + ] + }, + { + "data": { + "text/plain": [ + "[Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -21.794, 'SouthBoundingCoordinate': 25.382, 'EastBoundingCoordinate': 25.382, 'NorthBoundingCoordinate': 81.115}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-25T20:01:59.000Z', 'BeginningDateTime': '2023-04-07T22:49:35.000Z'}}\n", + " Size(MB): 983.0999364852905\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc'],\n", + " Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -81.139, 'SouthBoundingCoordinate': -52, 'EastBoundingCoordinate': -52, 'NorthBoundingCoordinate': 11.097}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-26T12:04:55.000Z', 'BeginningDateTime': '2023-04-08T01:51:07.000Z'}}\n", + " Size(MB): 1700.4334163665771\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_priors.nc'],\n", + " Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -166.397, 'SouthBoundingCoordinate': 8.09, 'EastBoundingCoordinate': 8.09, 'NorthBoundingCoordinate': 82.311}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-26T13:28:35.000Z', 'BeginningDateTime': '2023-04-08T05:36:12.000Z'}}\n", + " Size(MB): 1613.2776679992676\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_priors.nc']]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Search and locate granules\n", + "granule_info = earthaccess.search_data(\n", + " short_name=\"SWOT_L4_DAWG_SOS_DISCHARGE\",\n", + " temporal=(\"2023-04-07\", \"2023-04-26\"),\n", + ")\n", + "granule_info" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Select a priors and results file to explore:\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_priors.nc\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_priors.nc\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Copy and paste a priors file: https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc\n" + ] + } + ], + "source": [ + "# Enter a directory path to store downloaded data in\n", + "downloads_dir = pathlib.Path(\"/path/to/store/sos/data\") # MODIFY to include path on your local system\n", + "\n", + "# Select a priors and results pair to explore\n", + "download_links = [[link for link in earthaccess.results.DataGranule.data_links(granule)] for granule in granule_info]\n", + "print(\"Select a priors and results file to explore:\")\n", + "for downloads in download_links: \n", + " for download in downloads:\n", + " if \"priors\" in download: print(download)\n", + "priors_link = input(\"Copy and paste a priors file: \")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ... select results\n", + "results_link = priors_link.replace(\"priors\", \"results\")\n", + "\n", + "earthaccess.download(priors_link, downloads_dir)\n", + "earthaccess.download(results_link, downloads_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Open downloaded files to access SoS granule data\n", + "priors_download = priors_link.split('/')[-1]\n", + "results_download = results_link.split('/')[-1]\n", + "\n", + "priors = nc.Dataset(downloads_dir.joinpath(priors_download), format=\"NETCDF4\")\n", + "results = nc.Dataset(downloads_dir.joinpath(results_download), format=\"NETCDF4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Locate gauge and rive discharge data.\n", + "We can now locate gauge and river discharge data from the SoS using either the data read directly from S3 or downloaded to your local computer." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Constants\n", + "\n", + "# Select a river\n", + "RIVER_NAME = \"Rhine\"\n", + "\n", + "# Select a discharge algorithm (hivdi, neobam, metroman, momma, sad, sic4dvar)\n", + "DISCHARGE_ALGORITHM = \"hivdi\"\n", + "DISCHARGE_VARIABLE = \"Q\"\n", + "\n", + "# Select a gauge agency\n", + "GAUGE_AGENCY = \"EAU\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Locate overlapping identifiers \n", + "Locate overlapping identifiers for reach and gauge data." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rhine reach identifiers:\n", + "[23261000181 23261000191 23261000201 23261000211 23261000221 23261000231\n", + " 23261000241 23261000274 23261000371 23261000381 23261000391 23261000401\n", + " 23261000411 23261000421 23261000431 23261000441 23261000451 23261000461\n", + " 23261000471 23261000481 23261000491 23261000501 23261000511 23261000521\n", + " 23261000561 23261000571 23261000581 23261000621 23261000631 23261000641\n", + " 23262000011 23263000011 23263000021 23263000031 23263000061 23263000071\n", + " 23263000081 23263000091 23263000141 23263000151 23263000161 23263000211\n", + " 23263000221 23263000231 23263000241 23263000251 23263000271 23263000281\n", + " 23265000021 23265000031 23265000041 23265000051 23265000061 23267000011\n", + " 23267000021 23267000031 23267000041 23267000051 23267000061 23267000071\n", + " 23267000081 23267000094 23267000101 23267000111 23267000121 23267000131\n", + " 23267000141 23267000154 23267000171 23267000181 23267000194 23267000214\n", + " 23267000224 23267000231 23267000244 23267000304 23267000361 23267000371\n", + " 23267000384 23267000391 23267000401 23267000414 23267000494 23267000501\n", + " 23267000511 23267000524 23267000531 23267000541 23267000551 23267000561\n", + " 23267000571 23267000584 23267000591 23267000604 23267000611 23267000624\n", + " 23267000631 23267000644 23267000651 23267000664 23267000671 23267000684\n", + " 23267000704 23267000711 23267000724 23267000731 23267000744 23269000024\n", + " 23269000031 23269000051 23269000101 23269000114 23269000121 23269000134\n", + " 23269000141 23269000214 23269000221 23269000234 23269000241 23269000254\n", + " 23269000261 23269000271 23269000283 23269000293 23269000311 23269000323\n", + " 23269000333 23269000343 23269000353 23269000371 23269000381 23269000714\n", + " 23269000721 23269000734 23269000741 23269000754 23269000761 23269000774\n", + " 23269000781 23269000794 23269000801 23269000814 23269000824 23269000831\n", + " 23269000841 23269000941]\n", + "Gauge reach identifiers:\n", + "[23267000501 23267000121 23267000121 23267000081 23267000081 23267000071\n", + " 23262000901 23262000801 23262000801 23262000731 23262001444 23262001104\n", + " 23262001061 23262001354 23262000551 23262000531 23262000511 23262000491\n", + " 23262001394 23250801191 23250200011 23250600821 23250600484 23250600471\n", + " 23250600441 23250600631 23250200441 23240600314 23240602811 23240600201\n", + " 23240600261 23240600091 23240700491 23240700321 23240700181 23240700081\n", + " 23240700021 23240500101 23240500101 23240600431 23240603204 23240400101\n", + " 23240602381 23240602651 23240100201 23240900074 23240900151 23240700541\n", + " 23240700464 23240400601 23240400491 23240400414 23240400291 23230500654\n", + " 23230500401 23230500301 23230500081 23230400101 23230400101 23230200764\n", + " 23230200744 23230200354 23230200331 23230200986 23230200434 23230200381\n", + " 23230200965 23229000554 23229000211 23229000131 23229000521 23229000101\n", + " 23229000431 23229000024 23228000341 23228000231 23228000151 23228000111\n", + " 23228000091 23227000261 23227000231 23227000181 23227000181 23227000111\n", + " 23227000101 23227000041 23227000011 23226000564 23226000461 23226000351\n", + " 23226000321 23226000311 23226000031 23225000031 23224001551 23224001174\n", + " 23224000821 23224000531 23224000391 23224000331 23224000121 23224000704\n", + " 23224000661 23224000601 23224000601 23224000241 23224000861 23224000191\n", + " 23224000021 23223000041 23222000351 23222000661 23222001144 23222000801\n", + " 23222000011 23221000224 23219000444 23219000071 23214400931 23214400791\n", + " 23214401114 23214400501 23214400111 23214400201 23214400151 23214400041\n", + " 23214400013 23214900374 23214900361 23214900261 23214900224 23214900014\n", + " 23214700141 23214700051 23214700011 23214600374 23214600144 23214300031\n", + " 23214201131 23214200904 23214200691 23214200564 23214200531 23214200091\n", + " 23214200011 23214100051 23214100031 23214100155 23216000611 23216000584\n", + " 23216000561 23216000511 23216000501 23216000441 23216000421 23216000401\n", + " 23216001061 23216001001 23216000721 23212001134 23212001081 23212001014\n", + " 23212000701 23212000674 23212001366 23212000071 23212000051 23212000834\n", + " 23212000364 23212000181 23212001345 23218000304 23218000381 23218000141\n", + " 23218000121 23218000101 21602801794 21602800144 21602902191 21602902121\n", + " 21602901924 21602901501 21602900954 21602700241 21602700121 21602700171\n", + " 21602700011 21602602314 21602602351 21602601944 21602601393 21602601373\n", + " 21602601363 21602600311 21602601251 21602601231 21602601231 21602601821\n", + " 21602602381 21602600631 21602600011 21602300471 21602300441 21602300241\n", + " 21602300774 21602300861 21602300664 21602300221 21602300131 21602300131\n", + " 21602300351 21602100401 21602100264 21602100181 21602100144 21602100535\n", + " 21602100535 21602400711 21602400761 21602400751 21602400744 21602401061\n", + " 21602400221 21602400201 21602200354 21602200681 21602200204 21602200084\n", + " 21603400261 21603400161 21603400141 21603400091 21603400064 21603400051\n", + " 21603200231 21603200261 21603200191 21603300181 21603300154 21603300061\n", + " 21601000171 21601000091 21601000013]\n", + "Overlapping reaches:\n", + "[23267000071 23267000081 23267000121 23267000501]\n", + "Reach id selected: 23267000071\n" + ] + } + ], + "source": [ + "# Locate overlapping reach identifier\n", + "river_names = results['reaches']['river_name'][:]\n", + "river_indexes = np.where(river_names == RIVER_NAME)\n", + "\n", + "river_reach = results[\"reaches\"][\"reach_id\"][river_indexes]\n", + "print(f\"{RIVER_NAME} reach identifiers:\")\n", + "print(river_reach)\n", + "\n", + "gauge_reach = priors[GAUGE_AGENCY][f\"{GAUGE_AGENCY}_reach_id\"][:]\n", + "print(\"Gauge reach identifiers:\")\n", + "print(gauge_reach)\n", + "\n", + "reach_overlap = np.intersect1d(gauge_reach, river_reach)\n", + "print(\"Overlapping reaches:\")\n", + "print(reach_overlap)\n", + "\n", + "# Select the first reach\n", + "reach_id = reach_overlap[0]\n", + "print(f\"Reach id selected: {reach_id}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Locate gauge discharge and in situ observation time\n", + "Locate discharge and save the in situ observation time for the reach of interest." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of gauge discharge values: 3722.\n", + "Number of gauge time values: 3722.\n" + ] + } + ], + "source": [ + "# Get reach index for gauge data\n", + "reach_gauge_index = np.where(gauge_reach == reach_id)\n", + "\n", + "# Get discharge and filter out missing values\n", + "missing = priors[GAUGE_AGENCY][f\"{GAUGE_AGENCY}_q\"]._FillValue\n", + "gauge_discharge = priors[GAUGE_AGENCY][f\"{GAUGE_AGENCY}_q\"][reach_gauge_index].filled()[0]\n", + "nonmissing_indexes_g = np.where(gauge_discharge != missing)\n", + "gauge_discharge = gauge_discharge[nonmissing_indexes_g]\n", + "print(f\"Number of gauge discharge values: {len(gauge_discharge)}.\")\n", + "\n", + "# Get time and filter out missing values\n", + "gauge_time = priors[GAUGE_AGENCY][f\"{GAUGE_AGENCY}_qt\"][reach_gauge_index].filled().astype(int)[0]\n", + "gauge_time = gauge_time[nonmissing_indexes_g]\n", + "print(f\"Number of gauge time values: {len(gauge_time)}.\")\n", + "\n", + "# Convert time from ordinal value\n", + "gauge_time = [ datetime.datetime.fromordinal(gt).strftime(\"%Y%m%d\") for gt in gauge_time ]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Locate algorithm discharge\n", + "Locate the algorithm discharge for a corresponding reach identifier that has gauge data. We will use HiVDI for this demonstration." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reach Index: (array([13158]),)\n", + "Number of HIVDI discharge values: 7.\n", + "[1213.67194541 1138.18496353 1115.0978839 1069.45943177 1082.94584138\n", + " 1198.94024353 1108.93895269]\n", + "Number of HIVDI time values: 7.\n", + "['20230418', '20230419', '20230420', '20230422', '20230423', '20230424', '20230425']\n" + ] + } + ], + "source": [ + "# Locate the reach identifier and associated discharge time series\n", + "reach_q_index = np.where(results['reaches']['reach_id'][:] == reach_id)\n", + "print(\"Reach Index: \", reach_q_index)\n", + "discharge_q = results[DISCHARGE_ALGORITHM][DISCHARGE_VARIABLE][reach_q_index][0]\n", + "\n", + "# Filter out missing values\n", + "missing = results[DISCHARGE_ALGORITHM][DISCHARGE_VARIABLE].missing_value\n", + "nonmissing_indexes = np.where(discharge_q != missing)\n", + "discharge_q = discharge_q[nonmissing_indexes]\n", + "print(f\"Number of {DISCHARGE_ALGORITHM.upper()} discharge values: {len(discharge_q)}.\")\n", + "print(discharge_q)\n", + "\n", + "# Retrieve SWOT observation times and filter out missing values\n", + "time = results['reaches']['time'][reach_q_index][0]\n", + "time = time[nonmissing_indexes]\n", + "\n", + "# Convert to discharge time to same format as gauge agency time\n", + "swot_ts = datetime.datetime(2000,1,1,0,0,0) # SWOT timestamp delta\n", + "discharge_time = [ (swot_ts + datetime.timedelta(seconds=st)).strftime(\"%Y%m%d\") for st in time ]\n", + "print(f\"Number of {DISCHARGE_ALGORITHM.upper()} time values: {len(time)}.\")\n", + "print(discharge_time)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Locate integrator (MOI) discharge\n", + "Locate the integrator discharge produced for the algorithm for the reach of interest that has gauge data. As mentioned, we will use HiVDI for this demonstration. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of integrator HIVDI discharge values: 7.\n", + "[334.24668321 297.51701118 290.62386718 259.68934869 261.49240103\n", + " 307.47902449 288.01774716]\n" + ] + } + ], + "source": [ + "# Locate MOI discharge results for discharge algorithm making sure to filter out missing values\n", + "moi_q = results[\"moi\"][DISCHARGE_ALGORITHM][\"q\"][reach_q_index][0]\n", + "moi_q = moi_q[nonmissing_indexes]\n", + "\n", + "# Set missing MOI to NaN\n", + "missing_moi = results[\"moi\"][DISCHARGE_ALGORITHM][\"q\"].missing_value\n", + "moi_q[moi_q == missing_moi] = np.nan\n", + "print(f\"Number of integrator {DISCHARGE_ALGORITHM.upper()} discharge values: {len(moi_q)}.\")\n", + "print(moi_q)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Locate overlapping observations\n", + "We will need to locate the discharge time series (FLPE and MOI) for the Rhine reach of interest and then determine if there are overlapping in situ observations with SWOT observations." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Days of observation overlap:\n", + "['20230418', '20230419', '20230420', '20230422', '20230423', '20230424', '20230425']\n", + "Gauge discharge:\n", + " [1334.333 1208.255 1148.526 1115.296 1077.891 1080.885 1153.646]\n", + "hivdi discharge:\n", + " [1213.67194541 1138.18496353 1115.0978839 1069.45943177 1082.94584138\n", + " 1198.94024353 1108.93895269]\n", + "MOI discharge for hivdi:\n", + " [334.24668321 297.51701118 290.62386718 259.68934869 261.49240103\n", + " 307.47902449 288.01774716]\n" + ] + } + ], + "source": [ + "# Find overlapping time between in situ and SWOT observations\n", + "obs_overlap = list(set(discharge_time).intersection(set(gauge_time)))\n", + "obs_overlap.sort()\n", + "print(\"Days of observation overlap:\")\n", + "print(obs_overlap)\n", + "\n", + "# Get indexes of overlap for gauge, algorithm and integrator\n", + "gauge_overlap_index = np.where(np.in1d(gauge_time, obs_overlap))[0]\n", + "discharge_overlap_index = np.where(np.in1d(discharge_time, obs_overlap))[0]\n", + "\n", + "# Retrieve time and discharge values for indexes\n", + "gauge_time = np.array(gauge_time)[gauge_overlap_index]\n", + "gauge_discharge = np.array(gauge_discharge)[gauge_overlap_index]\n", + "# print(\"Gauge time:\\n\", gauge_time)\n", + "print(\"Gauge discharge:\\n\", gauge_discharge)\n", + "\n", + "discharge_time = np.array(discharge_time)[discharge_overlap_index]\n", + "discharge_algo = np.array(discharge_q)[discharge_overlap_index]\n", + "# print(f\"{DISCHARGE_ALGORITHM} time:\\n\", discharge_time)\n", + "print(f\"{DISCHARGE_ALGORITHM} discharge:\\n\", discharge_algo)\n", + "\n", + "moi_q = np.array(moi_q)[discharge_overlap_index]\n", + "print(f\"MOI discharge for {DISCHARGE_ALGORITHM}:\\n\", moi_q)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting results for comparison\n", + "Let's plot all discharge time series to better visualize the differences and compare the FLPE, MOI, and gauge discharge values. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot discharge alongside MOI discharge and gauge discharge\n", + "\n", + "# Discharge algorithm Q\n", + "plt.scatter(discharge_time, discharge_algo)\n", + "plt.plot(discharge_time, discharge_algo, label=f\"{DISCHARGE_ALGORITHM.upper()}\")\n", + "\n", + "# MOI Q\n", + "plt.scatter(discharge_time, moi_q)\n", + "plt.plot(discharge_time, moi_q, label=\"MOI\")\n", + "\n", + "# Gauge Q\n", + "plt.scatter(gauge_time, gauge_discharge)\n", + "plt.plot(gauge_time, gauge_discharge, label=\"Gauge\")\n", + "\n", + "plt.suptitle(f\"Discharge Timeseries from {DISCHARGE_ALGORITHM} for the {RIVER_NAME} reach identifier: {reach_id}.\")\n", + "plt.legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Disclaimer: Reference herein to any specific commercial product, process, or service by trade name, trademark, manufacturer, or otherwise, does not constitute or imply its endorsement by the United States Government or the Jet Propulsion Laboratory, California Institute of Technology.*" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_visualize.ipynb b/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_visualize.ipynb new file mode 100644 index 00000000..a21cda38 --- /dev/null +++ b/notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_visualize.ipynb @@ -0,0 +1,1649 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](https://img.shields.io/badge/PO.DAAC-Contribution-%20?color=grey&labelColor=blue)\n", + "\n", + "> From the PO.DAAC Cookbook, to access the GitHub version of the notebook, follow [this link](insert link to notebook)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualizing discharge in the SWORD of Science (SoS)\n", + "#### *Author: Nikki Tebaldi, NASA JPL PO.DAAC*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "### Visualizing Discharge\n", + "\n", + "The following notebook shows how to visualize discharge time series data on a map. The notebook takes the mean of the timeseries for a river reach's discharge estimates and visualizes this mean discharge.\n", + "\n", + "### Granule structure (background)\n", + "\n", + "The SWORD of Science (SoS) is a community-driven dataset produced for and from the execution of the Confluence workflow in the cloud which enables quick data access and compute on SWOT data. Data granules contain two files, priors and results. The priors file contains prior information, such as in-situ gage data and model output that is used to generate the discharge products. The results file contains the resulting river discharge data products.\n", + "\n", + "The SoS is organized by continent following [SWOT River Database (SWORD)](https://www.swordexplorer.com/) structure and naming conventions. It is indexed on the same reach and node identifier dimensions found in SWORD. Time series data is stored by cycle and pass on an observation dimension.\n", + "\n", + "More information is available in the SWOT-Confluence Github repository:\n", + "* [Documentation for priors](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_data_description-priors.pdf)\n", + "* [Documentation for results](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_data_description-results.pdf)\n", + "\n", + "Results are organized into groups corresponding to modules in the SWOT-Confluence processing software. Modules are described in the [Confluence Module Documentation](https://github.com/SWOT-Confluence/documentation/blob/main/documentation/confluence_module_documentation_v1.0.pdf).\n", + "\n", + "You can explore the SoS further in this notebook: Link TBD.\n", + "\n", + "### Table of Modules (Algorithms) and Discharge variables\n", + "\n", + "The following lists the algorithms alongside their discharge variables and location in the SoS results file assuming that the SoS is an open file represented by the `results` variable.\n", + "\n", + "| Module (Algorithm) | Discharge Variable | Location in the SoS |\n", + "|----------------------------------|----------------------------------|----------------------------------|\n", + "| HiVDI | Q | results[\"hivdi\"][\"Q\"] |\n", + "| MetroMan | allq | results[\"metroman\"][\"allq\"] |\n", + "| MOMMA | Q | results[\"momma\"][\"Q\"] |\n", + "| neoBAM | q1, q2, or q3 | results[\"neobam\"][\"q\"][\"q1\"] |\n", + "| SAD | Qa | results[\"sad\"][\"Qa\"] |\n", + "| SIC4DVar | Q_mm | results[\"sic4dvar\"][\"Q_mm\"] |\n", + "| MOI HiVDI | q | results[\"moi\"][\"hivdi\"][\"q\"] |\n", + "| MOI MetroMan | q | results[\"moi\"][\"metroman\"][\"q\"] |\n", + "| MOI MOMMA | q | results[\"moi\"][\"momma\"][\"q\"] |\n", + "| MOI neoBAM | q | results[\"moi\"][\"qeobam\"][\"q\"] |\n", + "| MOI SAD | q | results[\"moi\"][\"sad\"][\"q\"] |\n", + "| MOI SIC4DVar | q | results[\"moi\"][\"sic4dvar\"][\"q\"] |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Requirements\n", + "\n", + "### 1. Compute environment \n", + "\n", + "This tutorial can be run in the following environments:\n", + "- **Local compute environment** e.g. laptop, server: this tutorial can be run on your local machine\n", + "\n", + "### 2. Earthdata Login\n", + "\n", + "An Earthdata Login account is required to access data, as well as discover restricted data, from the NASA Earthdata system. Thus, to access NASA data, you need Earthdata Login. Please visit https://urs.earthdata.nasa.gov to register and manage your Earthdata Login account. This account is free to create and only takes a moment to set up." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Objectives\n", + "- To locate an algorithms discharge data.\n", + "- Take the mean of discharge over a reach.\n", + "- Visualize mean discharge on a map.\n", + "\n", + "------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import pathlib\n", + "import warnings\n", + "\n", + "import branca.colormap as cm\n", + "import earthaccess\n", + "import folium\n", + "import geopandas as gpd\n", + "import netCDF4 as nc\n", + "import numpy as np\n", + "import pandas as pd\n", + "import shapely" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Authenticate\n", + "Authenticate your Earthdata Login (EDL) information using the `earthaccess` python package as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "earthaccess.login() # Login with your EDL credentials if asked\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Search and Access SoS data\n", + "Locate the SoS data of interest and then download for access." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Granules found: 3\n" + ] + }, + { + "data": { + "text/plain": [ + "[Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -21.794, 'SouthBoundingCoordinate': 25.382, 'EastBoundingCoordinate': 25.382, 'NorthBoundingCoordinate': 81.115}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-25T20:01:59.000Z', 'BeginningDateTime': '2023-04-07T22:49:35.000Z'}}\n", + " Size(MB): 983.0999364852905\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc'],\n", + " Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -81.139, 'SouthBoundingCoordinate': -52, 'EastBoundingCoordinate': -52, 'NorthBoundingCoordinate': 11.097}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-26T12:04:55.000Z', 'BeginningDateTime': '2023-04-08T01:51:07.000Z'}}\n", + " Size(MB): 1700.4334163665771\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_priors.nc'],\n", + " Collection: {'Version': '1', 'ShortName': 'SWOT_L4_DAWG_SOS_DISCHARGE'}\n", + " Spatial coverage: {'HorizontalSpatialDomain': {'Geometry': {'BoundingRectangles': [{'WestBoundingCoordinate': -166.397, 'SouthBoundingCoordinate': 8.09, 'EastBoundingCoordinate': 8.09, 'NorthBoundingCoordinate': 82.311}]}}}\n", + " Temporal coverage: {'RangeDateTime': {'EndingDateTime': '2023-04-26T13:28:35.000Z', 'BeginningDateTime': '2023-04-08T05:36:12.000Z'}}\n", + " Size(MB): 1613.2776679992676\n", + " Data: ['https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_results.nc', 'https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_priors.nc']]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Search and locate granules\n", + "granule_info = earthaccess.search_data(\n", + " short_name=\"SWOT_L4_DAWG_SOS_DISCHARGE\",\n", + " temporal=(\"2023-04-07\", \"2023-04-26\"),\n", + ")\n", + "granule_info" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Select a priors and results file to explore:\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/sa_sword_v15_SOS_unconstrained_0001_20240228T205034_priors.nc\n", + "https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/na_sword_v15_SOS_unconstrained_0001_20240228T205032_priors.nc\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Copy and paste a priors file: https://archive.podaac.earthdata.nasa.gov/podaac-ops-cumulus-protected/SWOT_L4_DAWG_SOS_DISCHARGE/eu_sword_v15_SOS_unconstrained_0001_20240228T205029_priors.nc\n" + ] + } + ], + "source": [ + "# Enter a directory path to store downloaded data in\n", + "downloads_dir = pathlib.Path(\"/path/to/store/sos/data\") # MODIFY to include path on your local system\n", + "\n", + "# Select a priors and results pair to explore\n", + "download_links = [[link for link in earthaccess.results.DataGranule.data_links(granule)] for granule in granule_info]\n", + "print(\"Select a priors and results file to explore:\")\n", + "for downloads in download_links: \n", + " for download in downloads:\n", + " if \"priors\" in download: print(download)\n", + "priors_link = input(\"Copy and paste a priors file: \")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ... select results\n", + "results_link = priors_link.replace(\"priors\", \"results\")\n", + "\n", + "earthaccess.download(priors_link, downloads_dir)\n", + "earthaccess.download(results_link, downloads_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Open downloaded files to access SoS granule data\n", + "priors_download = priors_link.split('/')[-1]\n", + "results_download = results_link.split('/')[-1]\n", + "\n", + "priors = nc.Dataset(downloads_dir.joinpath(priors_download), format=\"NETCDF4\")\n", + "results = nc.Dataset(downloads_dir.joinpath(results_download), format=\"NETCDF4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Locate gauge and rive discharge data.\n", + "We can now locate gauge and river discharge data from the SoS using either the data read directly from S3 or downloaded to your local computer." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Constants\n", + "\n", + "# Select a river\n", + "RIVER_NAME = \"Rhine\"\n", + "\n", + "# Select a discharge algorithm (hivdi, neobam, metroman, momma, sad, sic4dvar)\n", + "DISCHARGE_ALGORITHM = \"hivdi\"\n", + "DISCHARGE_VARIABLE = \"Q\"" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Discharge values:\n", + " [array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, 54.07821944,\n", + " 49.94874936, 34.29138816, 34.49135369])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, 82.61844383, nan, nan, nan,\n", + " nan, nan, nan])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 2907.9691168 ,\n", + " 3153.60845063, 3297.52519565, nan, 2184.5119275 ,\n", + " 2488.26914856])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, 140.25074677, 7878.00373995,\n", + " 1852.91098506, nan, nan, nan,\n", + " nan])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, 4464.2000491 , 5722.24574639,\n", + " nan, 279.63722341, 258.96348657, 323.14058122,\n", + " 4320.51866836])\n", + " array([nan]) array([nan]) array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " 3172.76812796])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, 812.95022706, 821.39065048,\n", + " 824.5340281 , 748.25414935, 750.22182631, 727.4228604 ,\n", + " 714.90032622])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, 12.96023473, 13.62441855, 9.2229579 , 6.78091378,\n", + " 6.08133493, 3.86084087, 4.35815961])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, 46.33641998, 44.15285669, nan, 14.58184889,\n", + " nan, 0.6631935 , 5.5124224 ])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan,\n", + " nan, nan, 482.5083491])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, 52.73158663, nan, 28.40903799,\n", + " nan, 9.20201576, 1.32055668])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, 280.86449094, 205.30851846,\n", + " 110.83887881, 151.87592498, 227.77297649, 93.05295619,\n", + " 81.05582342])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, 47.52573484, nan, nan, nan,\n", + " nan, 77.78871975, 12.8748962 ])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, 19.66703691, nan, nan,\n", + " nan, nan, nan])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, 96.90955888, 45.20619634, 5.87241546, nan,\n", + " nan, nan, 0.43745264])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, 16.7157942 , 14.55850863, nan, 5.07303443,\n", + " 4.12986955, 2.43344827, 3.19803766])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, 17.64858373, 14.15283703, 7.97109699,\n", + " 3.93440203, 3.08442744, 2.44310106, 2.33711971])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan,\n", + " 4.47810394, 1.72949116, 1.83256864, 1.75216572])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, 98.51437115, 90.98432077, 98.10419242,\n", + " nan, 57.94006526, 30.77548924, 57.57734148])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, 50.55048997, nan,\n", + " 26.59220618, 23.64661731, 24.57567818, 23.99663384])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, 69.2017186 , 55.13156023, nan,\n", + " nan, 32.72661602, 25.27141885, 27.32154394])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 91.85689278,\n", + " 118.09762553, 70.72385117, 117.09601965, 46.02141169,\n", + " 43.47693004, 58.09836739])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, 66.50971298, 64.91180821,\n", + " 57.92947014, 52.98187408, 50.83445596, 52.76051291])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, 70.04344344, 65.22378172,\n", + " 55.93499204, 50.85696393, 56.55554003, 57.94008371])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan,\n", + " 11.61540995, 12.1144766 , 12.34147342, 13.03231781])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " 100.96540712, 100.02751124, 91.80281586, 93.81840639,\n", + " 94.86759615, 99.19542762])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 1213.67194541,\n", + " 1138.18496353, 1115.0978839 , 1069.45943177, 1082.94584138,\n", + " 1198.94024353, 1108.93895269])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 149.84091602,\n", + " 143.07347301, 142.0394067 , 134.96703933, 134.45761119,\n", + " 142.42974651, nan])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 479.13397319,\n", + " 431.81058979, 419.96984402, nan, 495.59938085,\n", + " nan, nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 117.09868443,\n", + " 122.22892084, nan, 113.9907313 , 114.47006025,\n", + " 123.33244731, nan])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, 0.34485608, 0.35643217, 3.14244405,\n", + " 4.29356865, 2.06295992, 3.93507027, nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 1517.63972134,\n", + " 1338.77519837, 5921.30623408, nan, 3735.38675824,\n", + " 5768.54043902, nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 150.0785271 ,\n", + " 138.15145821, 115.59306174, nan, 122.53882181,\n", + " 102.65471851, 170.72795537])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 225.29351257,\n", + " 282.74613246, nan, nan, nan,\n", + " 28.93018406, nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, 284.92595543,\n", + " 269.58929591, 200.69054755, 199.35693809, 262.95554178,\n", + " 274.66925045, 196.70624072])\n", + " array([nan]) array([nan]) array([nan])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, 13.99616776, 28.98604862,\n", + " 38.61180849, 3.45407562, 1.8285061 , 0.43871852, 31.92912359])\n", + " array([nan]) array([nan]) array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " nan, 361.15208977, nan, 79.9505899 ,\n", + " 56.65382349, 315.28092266, nan])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan,\n", + " 11.40702748, 9.05996153, 10.35840011, 10.52491965, nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " 18066.12312538, nan, 13155.40783521, 13592.3818625 ,\n", + " 13460.42744663, 15166.61524739, 15473.56388479])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " nan, 8.01126872e+00, 8.30272947e-01, nan,\n", + " nan, nan, 1.17583270e+04])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, 38.15129006,\n", + " 3.3873721 , nan, nan, nan, nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " nan, 0.46128164, 359.28851327, nan,\n", + " nan, nan, nan])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, 25.22047988,\n", + " nan, nan, nan, nan, nan])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " nan, 3498.82326002, nan, nan,\n", + " nan, nan, nan])\n", + " array([nan])\n", + " array([ nan, nan, nan, nan,\n", + " nan, nan, nan, nan,\n", + " nan, 3701.80872278, nan, nan,\n", + " nan, nan, nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan])\n", + " array([ nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, 35.46511394,\n", + " 38.00128732, nan, 39.64547151, 43.47713267, 45.55741719])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])\n", + " array([nan]) array([nan]) array([nan]) array([nan]) array([nan])]\n", + "Length of discharge values: (146,)\n" + ] + } + ], + "source": [ + "# Get discharge for a specific river name\n", + "river_names = results['reaches']['river_name'][:]\n", + "reach_idx = np.where(river_names[:] == RIVER_NAME)\n", + "\n", + "\n", + "# Filter out missing values\n", + "discharge = results[DISCHARGE_ALGORITHM][DISCHARGE_VARIABLE][:][reach_idx]\n", + "missing = results[DISCHARGE_ALGORITHM][DISCHARGE_VARIABLE].missing_value\n", + "\n", + "# Loop through each reach and filter out places where the missing value is present\n", + "for i in range(discharge.shape[0]):\n", + " is_missing = np.all(discharge[i] == missing)\n", + " if is_missing:\n", + " discharge[i] = np.array([np.nan])\n", + " else:\n", + " discharge[i][discharge[i] == missing] = np.nan\n", + "\n", + "# discharge = discharge[data_indexes] \n", + "print(f\"Discharge values:\\n {discharge}\")\n", + "print(f\"Length of discharge values: {discharge.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean discharge:\n", + " [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, 43.20242766259139, 82.6184438345387, nan, 2806.3767678265503, nan, 3290.3884905945197, nan, 2561.4509591772926, nan, nan, nan, 3172.768127964829, nan, 771.382009704293, 8.126980052616233, 22.24934829272215, 482.50834910152236, 22.915799264864788, 164.39565275437067, 46.06311693081852, 19.667036911352756, 37.10640583102956, nan, 7.68478212404095, 7.367366854486422, 2.4480823643843834, 72.31596338656968, 29.87232509528331, 41.93057152878337, 77.9101568923245, 57.65463904823475, 59.425800813779496, 12.275919445942492, 96.77952739610087, 1132.4627517441627, 141.1346987945013, nan, 456.62844696408314, 118.22416882714128, 2.355888522926942, 3656.3296702111575, 133.2907571236616, nan, 178.98994303187487, 241.2705385597663, nan, nan, nan, 17.034921242178314, nan, nan, nan, 203.25935645781158, nan, 10.33757719434832, 14819.086566983768, nan, nan, nan, nan, nan, nan, nan, 3922.3895222840197, 20.769331076880015, 179.8748974544238, nan, 25.22047987608233, nan, 3498.8232600199126, nan, 3701.808722784879, nan, nan, nan, nan, nan, nan, nan, nan, 40.42928452605076, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]\n", + "Mean discharge length: 146\n" + ] + } + ], + "source": [ + "# Take the mean of the algorithm's river discharge - requires a loop because of ragged arrays\n", + "mean_discharge = []\n", + "for d in discharge:\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning) # Ignore mean of empty slice as this is expected\n", + " mean_discharge.append(np.nanmean(d)) # Ignore NaNs\n", + "print(f\"Mean discharge:\\n {mean_discharge}\")\n", + "print(f\"Mean discharge length: {len(mean_discharge)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
reach_iddischarge
023261000181NaN
123261000191NaN
223261000201NaN
323261000211NaN
423261000221NaN
\n", + "
" + ], + "text/plain": [ + " reach_id discharge\n", + "0 23261000181 NaN\n", + "1 23261000191 NaN\n", + "2 23261000201 NaN\n", + "3 23261000211 NaN\n", + "4 23261000221 NaN" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert discharge and reach identifiers into DataFrame\n", + "reach_ids = results[\"reaches\"][\"reach_id\"][:][reach_idx].filled()\n", + "pdf = pd.DataFrame({\n", + " \"reach_id\": reach_ids,\n", + " \"discharge\": mean_discharge\n", + "})\n", + "pdf.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "results.close() # Close the NetCDF dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read in SWORD to get topology data for river name\n", + "We will need to use SWORD to visualize a river's topology. This will need to be downloaded onto your local computer and placed in a directory that you can reference in the code below. You can SWORD from this site: [https://www.swordexplorer.com/](https://www.swordexplorer.com/). You will need to read in the correct SWORD shapefile by selecting the HydroBASINS Pfafstetter level 2 basins (hbXX) within each continent. See the [SWORD Product Description Document](http://gaia.geosci.unc.edu/SWORD/SWORD_ProductDescription_v16.pdf) for more information." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xyreach_idreach_lenn_nodeswsewse_varwidthwidth_varfacc...n_rch_dnrch_id_uprch_id_dnswot_orbitswot_obstyperiver_nameedit_flagtrib_flaggeometry
0-6.04915737.2185762312010001113823.649876692.50.501996108.03443.1955701419.435181...12312010055623120100545141 44721NODATANaN0LINESTRING (-6.10323 37.17382, -6.10289 37.173...
1-6.07817137.2177312312010002110958.610152550.70.000000332.04306.17295749838.097656...1231201000312312010054544711NODATANaN0LINESTRING (-6.10323 37.17382, -6.10356 37.174...
2-6.03320037.3029912312010003110894.357022540.70.004637256.02452.13949149793.073567...1231201000412312010002144711NODATANaN0LINESTRING (-6.05928 37.26167, -6.05927 37.261...
3-6.01567137.3934402312010004110926.456281551.00.099503180.0445.45888149748.591937...123120100061 231201000512312010003144711NODATANaN0LINESTRING (-6.02252 37.34482, -6.02251 37.345...
4-6.02845537.4610682312010005111942.410756603.30.03939554.0458.1252172011.318237...1231201003642312010004144711Rivera de HuelvaNaN0LINESTRING (-6.00566 37.44168, -6.00599 37.441...
\n", + "

5 rows × 30 columns

\n", + "
" + ], + "text/plain": [ + " x y reach_id reach_len n_nodes wse wse_var \\\n", + "0 -6.049157 37.218576 23120100011 13823.649876 69 2.5 0.501996 \n", + "1 -6.078171 37.217731 23120100021 10958.610152 55 0.7 0.000000 \n", + "2 -6.033200 37.302991 23120100031 10894.357022 54 0.7 0.004637 \n", + "3 -6.015671 37.393440 23120100041 10926.456281 55 1.0 0.099503 \n", + "4 -6.028455 37.461068 23120100051 11942.410756 60 3.3 0.039395 \n", + "\n", + " width width_var facc ... n_rch_dn rch_id_up \\\n", + "0 108.0 3443.195570 1419.435181 ... 1 23120100556 \n", + "1 332.0 4306.172957 49838.097656 ... 1 23120100031 \n", + "2 256.0 2452.139491 49793.073567 ... 1 23120100041 \n", + "3 180.0 445.458881 49748.591937 ... 1 23120100061 23120100051 \n", + "4 54.0 458.125217 2011.318237 ... 1 23120100364 \n", + "\n", + " rch_id_dn swot_orbit swot_obs type river_name edit_flag \\\n", + "0 23120100545 141 447 2 1 NODATA NaN \n", + "1 23120100545 447 1 1 NODATA NaN \n", + "2 23120100021 447 1 1 NODATA NaN \n", + "3 23120100031 447 1 1 NODATA NaN \n", + "4 23120100041 447 1 1 Rivera de Huelva NaN \n", + "\n", + " trib_flag geometry \n", + "0 0 LINESTRING (-6.10323 37.17382, -6.10289 37.173... \n", + "1 0 LINESTRING (-6.10323 37.17382, -6.10356 37.174... \n", + "2 0 LINESTRING (-6.05928 37.26167, -6.05927 37.261... \n", + "3 0 LINESTRING (-6.02252 37.34482, -6.02251 37.345... \n", + "4 0 LINESTRING (-6.00566 37.44168, -6.00599 37.441... \n", + "\n", + "[5 rows x 30 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Read in SWORD data as GeoPandas DataFrame\n", + "sword = pathlib.Path(\"/path/to/sword/shapefile.shp\")\n", + "gdf = gpd.read_file(sword)\n", + "gdf.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xyreach_idreach_lenn_nodeswsewse_varwidthwidth_varfacc...n_rch_dnrch_id_uprch_id_dnswot_orbitswot_obstyperiver_nameedit_flagtrib_flaggeometry
35266.23365551.825947232610001818580.296766439.3000000.219616375.374664923.545609159179.679845...12326100019123261000171236 51421Rhine20LINESTRING (6.17589 51.83773, 6.17628 51.83759...
35276.32389351.780903232610001918586.191571439.4000010.198737377.8634342695.005803159093.279060...12326100020123261000181236 51421RhineNaN0LINESTRING (6.28873 51.81080, 6.28912 51.81067...
35286.40361351.742265232610002018582.1195964310.3000000.042619374.3702093483.753299159008.223035...12326100021123261000191236 51421RhineNaN0LINESTRING (6.36071 51.75371, 6.36116 51.75367...
35296.50966751.6740942326100021117893.6411828911.0000000.041548404.1239325500.626216158919.468921...123261000231 232610002212326100020157 236 363 51441RhineNaN0LINESTRING (6.41422 51.71362, 6.41455 51.71344...
35306.60821851.634048232610002211289.550762612.1000000.000000127.0000004780.127500158732.593750...1232610002742326100021157 236 363 51441RhineNaN0LINESTRING (6.60434 51.63966, 6.60457 51.63917...
\n", + "

5 rows × 30 columns

\n", + "
" + ], + "text/plain": [ + " x y reach_id reach_len n_nodes wse \\\n", + "3526 6.233655 51.825947 23261000181 8580.296766 43 9.300000 \n", + "3527 6.323893 51.780903 23261000191 8586.191571 43 9.400001 \n", + "3528 6.403613 51.742265 23261000201 8582.119596 43 10.300000 \n", + "3529 6.509667 51.674094 23261000211 17893.641182 89 11.000000 \n", + "3530 6.608218 51.634048 23261000221 1289.550762 6 12.100000 \n", + "\n", + " wse_var width width_var facc ... n_rch_dn \\\n", + "3526 0.219616 375.374664 923.545609 159179.679845 ... 1 \n", + "3527 0.198737 377.863434 2695.005803 159093.279060 ... 1 \n", + "3528 0.042619 374.370209 3483.753299 159008.223035 ... 1 \n", + "3529 0.041548 404.123932 5500.626216 158919.468921 ... 1 \n", + "3530 0.000000 127.000000 4780.127500 158732.593750 ... 1 \n", + "\n", + " rch_id_up rch_id_dn swot_orbit swot_obs type \\\n", + "3526 23261000191 23261000171 236 514 2 1 \n", + "3527 23261000201 23261000181 236 514 2 1 \n", + "3528 23261000211 23261000191 236 514 2 1 \n", + "3529 23261000231 23261000221 23261000201 57 236 363 514 4 1 \n", + "3530 23261000274 23261000211 57 236 363 514 4 1 \n", + "\n", + " river_name edit_flag trib_flag \\\n", + "3526 Rhine 2 0 \n", + "3527 Rhine NaN 0 \n", + "3528 Rhine NaN 0 \n", + "3529 Rhine NaN 0 \n", + "3530 Rhine NaN 0 \n", + "\n", + " geometry \n", + "3526 LINESTRING (6.17589 51.83773, 6.17628 51.83759... \n", + "3527 LINESTRING (6.28873 51.81080, 6.28912 51.81067... \n", + "3528 LINESTRING (6.36071 51.75371, 6.36116 51.75367... \n", + "3529 LINESTRING (6.41422 51.71362, 6.41455 51.71344... \n", + "3530 LINESTRING (6.60434 51.63966, 6.60457 51.63917... \n", + "\n", + "[5 rows x 30 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Locate reach identifiers for river of interest\n", + "reach_mask = gdf[\"reach_id\"].isin(reach_ids)\n", + "gdf = gdf[reach_mask]\n", + "gdf.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xyreach_idreach_lenn_nodeswsewse_varwidthwidth_varfacc...rch_id_uprch_id_dnswot_orbitswot_obstyperiver_nameedit_flagtrib_flaggeometrydischarge
35266.23365551.825947232610001818580.296766439.3000000.219616375.374664923.545609159179.679845...2326100019123261000171236 51421Rhine20LINESTRING (6.17589 51.83773, 6.17628 51.83759...-1.000000e+12
35276.32389351.780903232610001918586.191571439.4000010.198737377.8634342695.005803159093.279060...2326100020123261000181236 51421RhineNaN0LINESTRING (6.28873 51.81080, 6.28912 51.81067...-1.000000e+12
35286.40361351.742265232610002018582.1195964310.3000000.042619374.3702093483.753299159008.223035...2326100021123261000191236 51421RhineNaN0LINESTRING (6.36071 51.75371, 6.36116 51.75367...-1.000000e+12
35296.50966751.6740942326100021117893.6411828911.0000000.041548404.1239325500.626216158919.468921...23261000231 232610002212326100020157 236 363 51441RhineNaN0LINESTRING (6.41422 51.71362, 6.41455 51.71344...-1.000000e+12
35306.60821851.634048232610002211289.550762612.1000000.000000127.0000004780.127500158732.593750...232610002742326100021157 236 363 51441RhineNaN0LINESTRING (6.60434 51.63966, 6.60457 51.63917...-1.000000e+12
\n", + "

5 rows × 31 columns

\n", + "
" + ], + "text/plain": [ + " x y reach_id reach_len n_nodes wse \\\n", + "3526 6.233655 51.825947 23261000181 8580.296766 43 9.300000 \n", + "3527 6.323893 51.780903 23261000191 8586.191571 43 9.400001 \n", + "3528 6.403613 51.742265 23261000201 8582.119596 43 10.300000 \n", + "3529 6.509667 51.674094 23261000211 17893.641182 89 11.000000 \n", + "3530 6.608218 51.634048 23261000221 1289.550762 6 12.100000 \n", + "\n", + " wse_var width width_var facc ... \\\n", + "3526 0.219616 375.374664 923.545609 159179.679845 ... \n", + "3527 0.198737 377.863434 2695.005803 159093.279060 ... \n", + "3528 0.042619 374.370209 3483.753299 159008.223035 ... \n", + "3529 0.041548 404.123932 5500.626216 158919.468921 ... \n", + "3530 0.000000 127.000000 4780.127500 158732.593750 ... \n", + "\n", + " rch_id_up rch_id_dn swot_orbit swot_obs type \\\n", + "3526 23261000191 23261000171 236 514 2 1 \n", + "3527 23261000201 23261000181 236 514 2 1 \n", + "3528 23261000211 23261000191 236 514 2 1 \n", + "3529 23261000231 23261000221 23261000201 57 236 363 514 4 1 \n", + "3530 23261000274 23261000211 57 236 363 514 4 1 \n", + "\n", + " river_name edit_flag trib_flag \\\n", + "3526 Rhine 2 0 \n", + "3527 Rhine NaN 0 \n", + "3528 Rhine NaN 0 \n", + "3529 Rhine NaN 0 \n", + "3530 Rhine NaN 0 \n", + "\n", + " geometry discharge \n", + "3526 LINESTRING (6.17589 51.83773, 6.17628 51.83759... -1.000000e+12 \n", + "3527 LINESTRING (6.28873 51.81080, 6.28912 51.81067... -1.000000e+12 \n", + "3528 LINESTRING (6.36071 51.75371, 6.36116 51.75367... -1.000000e+12 \n", + "3529 LINESTRING (6.41422 51.71362, 6.41455 51.71344... -1.000000e+12 \n", + "3530 LINESTRING (6.60434 51.63966, 6.60457 51.63917... -1.000000e+12 \n", + "\n", + "[5 rows x 31 columns]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Join discharge to GeoPandas DataFrame and extract discharge and geometries\n", + "gdf = gdf.join(pdf.set_index(\"reach_id\"), on=\"reach_id\")\n", + "gdf[\"discharge\"] = gdf[\"discharge\"].fillna(missing)\n", + "gdf.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize mean discharge on a map\n", + "Once the mean discharge has been calculated and the SWORD topology data has been read in, you can now map the discharge!" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Create map\n", + "max_x = np.median(gdf[\"x\"])\n", + "max_y = np.median(gdf[\"y\"])\n", + "m = folium.Map([max_y, max_x], zoom_start=10, tiles=\"cartodb positron\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "-999999999999.0-833333330862.7-666666661726.3-499999992590.0-333333323453.6-166666654317.314819.086566983768" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a color map\n", + "min_d = np.min(gdf[\"discharge\"])\n", + "max_d = np.max(gdf[\"discharge\"])\n", + "color_map = cm.LinearColormap([\"black\", \"red\", \"yellow\", \"green\"], vmin=min_d, vmax=max_d)\n", + "color_map.add_to(m)\n", + "color_map" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a tool tip to display reach identifier and discharge values\n", + "tooltip = folium.GeoJsonTooltip(\n", + " fields=[\"reach_id\", \"discharge\"],\n", + " aliases=[\"Reach Identifier:\", \"Mean Discharge:\"],\n", + " sticky=False,\n", + " labels=True,\n", + " style=\"\"\"\n", + " background-color: #F0EFEF;\n", + " border: 2px solid black;\n", + " border-radius: 3px;\n", + " box-shadow: 3px;\n", + " \"\"\",\n", + " max_width=800\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize mean discharge\n", + "folium.GeoJson(\n", + " gdf,\n", + " style_function=lambda feature: { \n", + " \"color\": color_map(feature[\"properties\"][\"discharge\"]),\n", + " \"weight\": 3,\n", + " },\n", + " tooltip=tooltip\n", + ").add_to(m)\n", + "m" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Disclaimer: Reference herein to any specific commercial product, process, or service by trade name, trademark, manufacturer, or otherwise, does not constitute or imply its endorsement by the United States Government or the Jet Propulsion Laboratory, California Institute of Technology.*" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/quarto_text/SWOT.qmd b/quarto_text/SWOT.qmd index 5518e623..29c80af2 100644 --- a/quarto_text/SWOT.qmd +++ b/quarto_text/SWOT.qmd @@ -134,6 +134,13 @@ In [Earthdata Search GUI](https://search.earthdata.nasa.gov/search): [SWODLR](https://github.com/podaac/swodlr) - a system for generating on demand raster products from SWOT L2 raster data with custom resolutions, projections, and extents. *-in development* +### **SWORD of Science** + +The SWORD of Science (SoS) is a community-driven dataset produced for and from the execution of the Confluence workflow which is a cloud-based workflow that executes on SWOT observations to produce river discharge parameter estimates. Data granules contain two files, priors and results. The priors file contains prior information, such as in-situ gauge data and model output that is used to generate the discharge products. The results file contains the resulting river discharge data products. + +- [Explore river discharge](../notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE.ipynb) +- [Explore river discharge with gauge data](../notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_gauges.ipynb) +- [Visualize river discharge](../notebooks/datasets/SWOT_L4_DAWG_SOS_DISCHARGE_visualize.ipynb) ## Additional Resources