aquifer_assignment_tool.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.3"
    },
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/BYU-Hydroinformatics/gwdm-notebooks/blob/main/aquifer_assignment_tool.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zgeqa-MkE3zc"
      },
      "source": [
        "# **Aquifer Assignment Tool**\n",
        "\n",
        "### Used for assigning aquifer IDs and names to wells.\n",
        "\n",
        "*An aquifers shapefile/geojson file and a csv of well locations is required as input. A csv file is created with aquifer IDs and names assigned to each well. Reclassification of wells into secondary aquifers is possible for wells that fall outside the primary aquifer boundaries.*  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WQTGFKnTrApa"
      },
      "source": [
        "## **Instructions:**\n",
        "*This is a Google Colab Notebook, shared as a Github Gist. That means that you can perform operations within this notebook and download your files once you're done. Once you restart the session (e.g. refresh the page) your changes will not be saved. However, you can save a copy of this notebook using the \"File\" tab.*\n",
        "* To use this tool, follow the instructions in the right side of each cell.\n",
        "* **To run each cell, press the play button on the left. Occasionally, the cell will require additional input after pressing the play button.**\n",
        "* If an error appears, double check that all input options are correct.\n",
        "* After all cells have been run, csv files will be generated, which can be downloaded from the \"Files\" window on the left"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zUNcQSSo2Acp"
      },
      "source": [
        "#@markdown ### **<- Run this cell to install dependencies**\n",
        "# Install dependencies\n",
        "%%capture\n",
        "!pip install geopandas\n",
        "!pip install pygeos\n",
        "!pip install dms2dec"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ODjabxFsE3zd"
      },
      "source": [
        "#@markdown ### **<- Run cell to load necessary packages**\n",
        "%%capture\n",
        "import pandas as pd\n",
        "import geopandas as gpd\n",
        "import pygeos\n",
        "import ipywidgets as widgets\n",
        "import sys\n",
        "from google.colab import files\n",
        "from dms2dec.dms_convert import dms2dec"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vTwxyM2z9yci"
      },
      "source": [
        "## **Options:**\n",
        "Indicate which operation you would like to perform:\n",
        "1. Add aquifers to a wells file from an aquifers file\n",
        "2. Add aquifers to a time series file from a wells file"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nxp714ivDJpx"
      },
      "source": [
        "#@markdown ## **I. Add Aquifers from an Aquifers file**\n",
        "#@markdown ##### 1. Add Aquifers from an Aquifers File?\n",
        "addAquifers = \"1) Yes - wells will be assigned their appropriate aquifer, depending on their lat/long coordinates\" #@param [\"1) Yes - wells will be assigned their appropriate aquifer, depending on their lat/long coordinates\", \"2) No - aquifers exist already within the wells file and can be added to the time series file\"]\n",
        "addAquifers = int(addAquifers[0])\n",
        "#@markdown ##### <br>2. Reclassify wells that fall outside of primary aquifers?\n",
        "#@markdown #####*(requires a secondary aquifers file)*\n",
        "reclass = False #@param {type:\"boolean\"}\n",
        "#@markdown <br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br>\n",
        "#@markdown ###**<- Now, run cell and follow instructions on output (right below the cell) to upload your file**\n",
        "\n",
        "if addAquifers == 1:\n",
        "  print('Upload the Primary Aquifers File (upload shapefiles as zip folders)')\n",
        "  uploaded = files.upload()\n",
        "  aq_file = ''.join(uploaded)\n",
        "  try:\n",
        "    try: aq_gdf = gpd.read_file(aq_file)\n",
        "    except: aq_gdf = gpd.read_file(aq_file+'!'+aq_file[0:-4])\n",
        "  except: print(\"Try zipping your shapefile files into a zip folder directly (instead of zipping the folder that they reside in)\")\n",
        "  aList = aq_gdf.columns\n",
        "  Aquifer_Name_widget, AquiferID_widget = widgets.Dropdown(options=aList, description = \"\"), widgets.Dropdown(options=aList, description = \"\")\n",
        "  if reclass == True:\n",
        "    #Add in the secondary aquifers\n",
        "    print('\\nUpload the Secondary Aquifers File (for reclassified wells)\\nMUST BE DIFFERENT NAME THAN PRIMARY AQ FILE')\n",
        "    uploaded2 = files.upload()\n",
        "    aq_file2 = ''.join(uploaded2)\n",
        "    try:\n",
        "      try: aq_gdf2 = gpd.read_file(aq_file2)\n",
        "      except: aq_gdf2 = gpd.read_file(aq_file2+'!'+aq_file2[0:-4])\n",
        "    except: print(\"Try zipping your shapefile files into a zip folder directly (instead of zipping the folder that they reside in)\")\n",
        "    aList2 = aq_gdf2.columns\n",
        "    Aquifer_Name2_widget, AquiferID2_widget = widgets.Dropdown(options=aList2, description = \"\"), widgets.Dropdown(options=aList2, description = \"\")\n",
        "else:\n",
        "  sys.exit(\"'Don't add aquifers' selected - CONTINUE TO NEXT STEP\\n\")\n",
        "\n",
        "print(\"\\n\\nPlease select the appropriate headers in your file for primary and (if applicable) secondary aquifers file(s)\")\n",
        "aqGrid = [widgets.VBox([widgets.Label(value='Primary Aquifer Name:'), widgets.Label(value='Primary Aquifer ID:')]), widgets.VBox([Aquifer_Name_widget, AquiferID_widget])]\n",
        "if reclass == True:\n",
        "  aqGrid2 = [widgets.VBox([widgets.Label(value='Secondary Aquifer Name:'), widgets.Label(value='Secondary Aquifer ID:')]), widgets.VBox([Aquifer_Name2_widget, AquiferID2_widget])]\n",
        "  aqGrid = [aqGrid[0],aqGrid[1], aqGrid2[0], aqGrid2[1]]\n",
        "widgets.HBox(aqGrid)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8t8bFl0g2XJ0"
      },
      "source": [
        "#@markdown ## **II. Add a Wells File**\n",
        "\n",
        "#@markdown ##### 1. Lat/Long Format\n",
        "latLong = \"1) Decimal\" #@param [\"1) Decimal\", \"2) DMS\"]\n",
        "latLong = int(latLong[0])\n",
        "#@markdown ##### 2. Select decimal type in the file (in U.S. decimal is a period \".\"):\n",
        "# I'm not sure we need this one; come back to this\n",
        "decSymbol = \"period (.)\" #@param [\"period (.)\", \"comma (,)\"]\n",
        "decSymbol_Wells = decSymbol[-2]\n",
        "#@markdown <br><br><br><br><br><br><br><br><br><br>\n",
        "#@markdown ###**<- Now, run cell and follow instructions on output**\n",
        "\n",
        "print('\\nUpload a file with well metadata')\n",
        "uploaded = files.upload()\n",
        "wells_file = ''.join(uploaded)\n",
        "wls_df = pd.read_csv(wells_file, decimal=decSymbol_Wells)\n",
        "\n",
        "wList = wls_df.columns\n",
        "well_ID_Wells_widget = widgets.Dropdown(options=wList, description = \"Well ID\")\n",
        "lat_widget = widgets.Dropdown(options=wList, description = \"Latitude\")\n",
        "long_widget = widgets.Dropdown(options=wList, description = \"Longitude\")\n",
        "wellAqID_widget = widgets.Dropdown(options=wList, description = \"Aquifer ID\")\n",
        "wellAqName_widget = widgets.Dropdown(options=wList, description = \"Aquifer Name\")\n",
        "\n",
        "wItems = [widgets.VBox([well_ID_Wells_widget, lat_widget, long_widget])]\n",
        "if addAquifers == 2:\n",
        "  wItems = [wItems[0], widgets.VBox([wellAqID_widget,wellAqName_widget])]\n",
        "print(\"\\nSpecify the appropriate headers for your file\")\n",
        "widgets.GridBox(wItems, layout=widgets.Layout(grid_template_columns=\"repeat(3, 350px)\"))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MUFn86Y3BWtP"
      },
      "source": [
        "#@markdown ## **III. Add Aquifers to a Time Series File**\n",
        "\n",
        "#@markdown ##### 1. Add aquifer IDs to a separate time series file?\n",
        "#@markdown ###### (Well IDs must match the well IDs in the wells file)\n",
        "addAqTS = True #@param {type:\"boolean\"}\n",
        "#@markdown ##### 2. Select decimal type in the file (in the U.S., a decimal is a \".\"):\n",
        "decSymbol = \"period (.)\" #@param [\"period (.)\", \"comma (,)\"]\n",
        "decSymbol_TS = decSymbol[-2]\n",
        "#@markdown <br><br><br><br>\n",
        "#@markdown ###**<- Now, run cell and follow instructions on output**\n",
        "\n",
        "if addAqTS == True:\n",
        "  print('Upload the time series file (if your file is large, it will take a couple minutes to upload)')\n",
        "  uploaded = files.upload()\n",
        "  tms_file = ''.join(uploaded)\n",
        "  tms_df = pd.read_csv(tms_file, decimal=decSymbol_TS)\n",
        "  well_ID_TS_widget = widgets.Dropdown(options=tms_df.columns, description = \"Well ID\")\n",
        "  print(\"\\nSpecify the appropriate header for your file\")\n",
        "else:\n",
        "  sys.exit('\\n\\nTIME SERIES FILE NOT ADDED.\\n\\n->If you would like to add a time series file, verify that you have \"addAqTS\" checked. Otherwise, continue to the next cell.\\n\\n')\n",
        "well_ID_TS_widget\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cNzFBUN3dyRA"
      },
      "source": [
        "#### **Obtain values and define functions**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YHjkWp0Im72H"
      },
      "source": [
        "#@markdown ### **<- Run the cell to obtain values from dropdown menu(s) and proceed**\n",
        "\n",
        "if 'aList' in globals():\n",
        "  Aquifer_Name = Aquifer_Name_widget.value\n",
        "  AquiferID = AquiferID_widget.value\n",
        "  if 'aList2' in globals():\n",
        "    Aquifer_Name2 = Aquifer_Name2_widget.value\n",
        "    AquiferID2 = AquiferID2_widget.value\n",
        "if 'wList' in globals():\n",
        "  well_ID_Wells = well_ID_Wells_widget.value\n",
        "  lat = lat_widget.value\n",
        "  long = long_widget.value\n",
        "  if addAquifers == 2:\n",
        "    wellAqID = wellAqID_widget.value\n",
        "    wellAqName = wellAqName_widget.value\n",
        "if 'tms_df' in globals():\n",
        "  well_ID_TS = well_ID_TS_widget.value\n",
        "\n",
        "wls_df = pd.read_csv(wells_file, decimal=decSymbol_Wells)\n",
        "tms_df = pd.read_csv(tms_file, decimal=decSymbol_TS)\n",
        "\n",
        "print(\"Success!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "20kBwTdoLb68"
      },
      "source": [
        "#@markdown ### **<- Run cell to create functions and proceed**\n",
        "\n",
        "# Function to add aquifers to each well and drop wells outside of the aquifers\n",
        "def addAq(gdf, aq_gdf, aqID, aqName):\n",
        "  if 'AquiferID' in gdf.columns:\n",
        "    gdf = gdf.rename(columns=({'AquiferID':'Old_Aquifer_ID'}))\n",
        "  if 'Aquifer_Name' in gdf.columns:\n",
        "    gdf = gdf.rename(columns=({'Aquifer_Name':'Old_Aquifer_Name'}))\n",
        "  inAqGdf = gpd.sjoin(gdf, aq_gdf[[aqID, aqName, \"geometry\"]], how='left', op='within')\n",
        "  inAqGdf = inAqGdf.dropna(subset=[aqID])\n",
        "  inAqGdf = inAqGdf.drop('index_right', axis=1)\n",
        "  return inAqGdf\n",
        "\n",
        "def addSecAq(gdf, inAqGdf, aq_gdf, aqID, aqName):\n",
        "  outAqGdf = gdf[~gdf.isin(inAqGdf)].dropna()\n",
        "  in2ndAqGdf = addAq(outAqGdf,aq_gdf,aqID,aqName)\n",
        "  return in2ndAqGdf\n",
        "\n",
        "# Define the background map function\n",
        "def background_map(aquifers, secondaryAq = 1, wells = 1, wells_in_aquifer = 1):\n",
        "  world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres')) # Background map is part of geopandas library\n",
        "  ax = world.plot(color='white', edgecolor='black')\n",
        "  minx, miny, maxx, maxy = aquifers.total_bounds\n",
        "  if type(secondaryAq) == gpd.geodataframe.GeoDataFrame:\n",
        "    secondaryAq.plot(ax=ax, color='lightsteelblue') # L Blue Polygons = secondary aquifers\n",
        "    minx, miny, maxx, maxy = secondaryAq.total_bounds\n",
        "  aquifers.plot(ax=ax, color='royalblue') # Royal Blue Polygons = primary aquifers\n",
        "  if type(wells) == gpd.geodataframe.GeoDataFrame:\n",
        "    wells.plot(ax=ax, color='red', markersize=15) # Red dots = wells outside of aquifers\n",
        "    minx, miny, maxx, maxy = wells.total_bounds\n",
        "  if type(wells_in_aquifer) == gpd.geodataframe.GeoDataFrame:\n",
        "    wells_in_aquifer.plot(ax=ax, color='greenyellow', markersize=20) # Green dots = wells inside of aquifers\n",
        "  ax.set_xlim(minx, maxx)\n",
        "  ax.set_ylim(miny, maxy)\n",
        "\n",
        "# Function to convert a dataframe to a geodataframe\n",
        "def toGDF(df, latCol, lonCol):\n",
        "  if latLong > 1:\n",
        "    df[[lonCol, latCol]] = df[[lonCol, latCol]].applymap(lambda x: dms2dec(x))  # Convert from DMS to decimal\n",
        "  gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df[lonCol], df[latCol]))\n",
        "  # Ensure consistent Coordinate Reference System\n",
        "  gdf.crs = ('epsg:4326')\n",
        "  return gdf\n",
        "\n",
        "print(\"Success!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2sChlcJjK_7e"
      },
      "source": [
        "### **Add Aquifers to Wells File**\n",
        "#### Run the cells in this section to add aquifer IDs and names to your wells in the wells file.\n",
        "* If you didn't add an aquifers file and you already have aquifers in your wells file, you can skip to the next section."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dnReVkPY6Zxt"
      },
      "source": [
        "#@markdown ### **<- Run the cell and ensure aquifer(s) look reasonable. Then run the remaining cells in this section.**\n",
        "if addAquifers == 1:\n",
        "  # Set reference frame to WGS84. This is only necessary to ensure that all geodataframes on on same coordinate system.\n",
        "  aq_gdf.crs = ('epsg:4326')\n",
        "  # Plot the aq_gdf on a background map so that the user can double check the shape\n",
        "  print('Royal Blue = Primary Aquifers \\nLight Blue = Secondary Aquifers (if applicable)')\n",
        "  if 'aq_gdf2' in globals(): background_map(aq_gdf, aq_gdf2)\n",
        "  else: background_map(aq_gdf)\n",
        "else:\n",
        "  print(\"Aquifers file not added. If you need to add aquifers to your\\nwells file, you must go back and add an aquifers file. Otherwise,\\nproceed to the next section.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2W1WYO3EifoO"
      },
      "source": [
        "#@markdown ### **<- Run the cell to create a plot of wells within and outside of the aquifers.**\n",
        "#@markdown ##### *Wells that fall within aquifers will be saved to a csv file.*\n",
        "if addAquifers == 1:\n",
        "  # Add aquifers to wells file and save file\n",
        "  wls_gdf = toGDF(wls_df, lat, long)\n",
        "  wls_in_aq_gdf = addAq(wls_gdf, aq_gdf, AquiferID, Aquifer_Name)\n",
        "  wls_in_aq_df = pd.DataFrame(wls_in_aq_gdf.drop(columns='geometry'))\n",
        "  wls_in_aq_df.to_csv (wells_file[0:-4]+'_wells_with_aquifers.csv', index = None, header=True)\n",
        "  print(\"Aquifers assigned to wells.\\n\")\n",
        "\n",
        "  # Create a plot that shows the wells that fall within the aquifers\n",
        "  background_map(aq_gdf, wells=wls_gdf, wells_in_aquifer=wls_in_aq_gdf)\n",
        "  wDrop = len(wls_gdf) - len(wls_in_aq_gdf)\n",
        "  print(\"Map:\\n - Green dots are wells inside the primary aquifer(s)\\n - Red dots are wells outside primary aquifer(s)\\n\\n%d wells fell outside the primary aquifer(s) and will be dropped or reclassified (if applicable)\" %wDrop)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_nD9I3-ZhrMa"
      },
      "source": [
        "#@markdown ### **<- Run the cell to reclassify wells, if necessary.**\n",
        "# Reclassify wells (if necessary)\n",
        "if addAquifers == 1 and reclass == True and wDrop > 0:\n",
        "  # Create dataset of reclassified wells\n",
        "  wls_out_aq_gdf = wls_gdf[~wls_gdf.isin(wls_in_aq_gdf)].dropna()\n",
        "  wls_in_aq_gdf2 = addAq(wls_out_aq_gdf, aq_gdf2, AquiferID2, Aquifer_Name2)\n",
        "\n",
        "  # Create a plot that shows the wells that fall within the secondary aquifers (if any)\n",
        "  aqReclass = len(wls_in_aq_gdf2)\n",
        "  print(\"%d wells were reclassified\\n\\n\" %aqReclass)\n",
        "  if aqReclass > 0:\n",
        "    wls_in_aq_gdf2.to_csv (wells_file[0:-4]+'_wells_with_secondary_aquifers.csv', index = None, header=True)\n",
        "    background_map(aq_gdf2, wells_in_aquifer=wls_in_aq_gdf2)\n",
        "    print(\"Green dots are wells that were reclassified into the secondary aquifer(s)\")\n",
        "else:\n",
        "  print(\"No wells were reclassified\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hgL-_ODzygLd"
      },
      "source": [
        "### **Add Aquifers to Time Series File**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6nAK7C_6_VAF"
      },
      "source": [
        "#@markdown ### **<- Run the cell to add aquifer IDs to the time series file**\n",
        "#@markdown ##### *The time series file will be saved to a csv file.*\n",
        "if addAqTS == True:\n",
        "  if addAquifers == 1:\n",
        "    # Prepare variables to add primary aquifers to time series file\n",
        "    wls_df = wls_in_aq_df\n",
        "    wellAqName, wellAqID = Aquifer_Name, AquiferID\n",
        "    if reclass == True and wDrop > 0 and aqReclass > 0:\n",
        "      # Add secondary aquifers to time series file (if applicable)\n",
        "      tms_with_aq_df2 = tms_df.merge(wls_in_aq_gdf2[[well_ID_Wells, AquiferID2, Aquifer_Name2]],left_on=[well_ID_TS],right_on=[well_ID_Wells])\n",
        "      tms_with_aq_df2.to_csv (tms_file[0:-4]+'_TS_with_secondary_aquifers.csv', index = None, header=True)\n",
        "      print(\"Secondary aquifers assigned to TS file\")\n",
        "  # Add primary aquifers to Time series file\n",
        "  tms_with_aq_df = tms_df.merge(wls_in_aq_df[[well_ID_Wells,wellAqID,wellAqName]],left_on=[well_ID_TS],right_on=[well_ID_Wells])\n",
        "  tms_with_aq_df.to_csv (tms_file[0:-4]+'_TS_with_aquifers.csv', index = None, header=True)\n",
        "  print(\"Aquifer IDs and names assigned to TS file\")\n",
        "else:\n",
        "  print(\"'addAqTS' was not selected and a time series file was not added.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-vYX28mYiLVT"
      },
      "source": [
        "## **Retrieve Files**\n",
        "#### Check the 'Files' panel on the left for your new files (hit the refresh button if they don't appear immediately)\n",
        "![files_panel.png](data:image/png;base64,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)"
      ]
    }
  ]
}